839 lines
20 KiB
Java
839 lines
20 KiB
Java
package org.gcube.portlets.user.databasesmanager.client.panels;
|
|
|
|
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
import org.gcube.portlets.user.databasesmanager.client.GWTdbManagerServiceAsync;
|
|
import org.gcube.portlets.user.databasesmanager.client.datamodel.FileModel;
|
|
import org.gcube.portlets.user.databasesmanager.client.datamodel.Result;
|
|
import org.gcube.portlets.user.databasesmanager.client.events.SelectedItemEvent;
|
|
|
|
//import org.gcube.portlets.user.dbmanager.client.GWTdbManagerServiceAsync;
|
|
//import org.gcube.portlets.user.dbmanager.client.datamodel.FileModel;
|
|
//import org.gcube.portlets.user.dbmanager.client.datamodel.Result;
|
|
//import org.gcube.portlets.user.dbmanager.client.events.SelectedItemEvent;
|
|
|
|
import com.extjs.gxt.ui.client.Style.SelectionMode;
|
|
import com.extjs.gxt.ui.client.event.ComponentEvent;
|
|
import com.extjs.gxt.ui.client.event.EventType;
|
|
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
|
|
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
|
|
import com.extjs.gxt.ui.client.event.TreePanelEvent;
|
|
import com.extjs.gxt.ui.client.store.TreeStore;
|
|
import com.extjs.gxt.ui.client.widget.LayoutContainer;
|
|
import com.extjs.gxt.ui.client.widget.layout.FlowData;
|
|
import com.extjs.gxt.ui.client.widget.layout.FlowLayout;
|
|
import com.extjs.gxt.ui.client.widget.treepanel.TreePanel;
|
|
import com.google.gwt.event.shared.HandlerManager;
|
|
import com.google.gwt.user.client.Event;
|
|
import com.google.gwt.user.client.Window;
|
|
import com.google.gwt.user.client.rpc.AsyncCallback;
|
|
|
|
public class GxtTreePanel extends LayoutContainer {
|
|
|
|
private TreeStore<FileModel> store;
|
|
private TreePanel<FileModel> treePanel;
|
|
|
|
private HandlerManager eventBus = null;
|
|
|
|
private String value = "";
|
|
private int treeDepthSelectedItem;
|
|
private boolean SelectedItemIsSchema = false;
|
|
private GWTdbManagerServiceAsync RPCservice = null;
|
|
|
|
private LinkedHashMap<String, FileModel> dataDBInfo = null;
|
|
|
|
private String ResourceNameSelected;
|
|
private String DatabaseNameSelected;
|
|
private String SchemaNameSelected;
|
|
private String TableNameSelected;
|
|
|
|
private LinkedHashMap<String, String> infoOnSelectedItem;
|
|
|
|
private static Logger rootLogger = Logger.getLogger("GxtTreePanel");
|
|
|
|
public GxtTreePanel(HandlerManager eBus, GWTdbManagerServiceAsync service)
|
|
throws Exception {
|
|
|
|
RPCservice = service;
|
|
|
|
eventBus = eBus;
|
|
|
|
store = new TreeStore<FileModel>();
|
|
|
|
this.initLayout();
|
|
|
|
}
|
|
|
|
private void initLayout() throws Exception {
|
|
|
|
setLayout(new FlowLayout(10));
|
|
|
|
treePanel = new TreePanel<FileModel>(store) {
|
|
|
|
@Override
|
|
public boolean hasChildren(FileModel parent) {
|
|
if (parent.isExpanded() == true) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void onComponentEvent(ComponentEvent ce) {
|
|
super.onComponentEvent(ce);
|
|
|
|
TreePanelEvent<FileModel> tpe = (TreePanelEvent) ce;
|
|
EventType typeEvent = tpe.getType();
|
|
|
|
int type = ce.getEventTypeInt();
|
|
switch (type) {
|
|
case Event.ONCLICK:
|
|
onRightClick(tpe);
|
|
break;
|
|
// case Event.ONDBLCLICK:
|
|
// onDoubleClick(tpe);
|
|
// break;
|
|
// case Event.ONSCROLL:
|
|
// onScroll(tpe);
|
|
// break;
|
|
// case Event.ONFOCUS:
|
|
// onFocus(ce);
|
|
// break;
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
treePanel.setDisplayProperty("name");
|
|
|
|
// load the root
|
|
loadRootItemTree();
|
|
|
|
// Single selection Mode
|
|
treePanel.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);
|
|
|
|
// select root item
|
|
treePanel.getSelectionModel().select(store.getRootItems().get(0), true);
|
|
|
|
// expand level 1
|
|
treePanel.setExpanded(store.getRootItems().get(0), true);
|
|
|
|
add(treePanel, new FlowData(10));
|
|
|
|
addListeners();
|
|
|
|
}
|
|
|
|
// private void createLayout() {
|
|
//
|
|
// // Folder model = getTreeModel();
|
|
//
|
|
// }
|
|
|
|
private void addListeners() {
|
|
|
|
treePanel.getSelectionModel().addSelectionChangedListener(
|
|
new SelectionChangedListener<FileModel>() {
|
|
|
|
@Override
|
|
public void selectionChanged(
|
|
SelectionChangedEvent<FileModel> se) {
|
|
|
|
// System.out.println("SelectionChangedListener");
|
|
|
|
dataDBInfo = null;
|
|
|
|
ResourceNameSelected = null;
|
|
DatabaseNameSelected = null;
|
|
SchemaNameSelected = null;
|
|
TableNameSelected = null;
|
|
|
|
infoOnSelectedItem = null;
|
|
|
|
SelectedItemIsSchema = false;
|
|
|
|
// the selected element
|
|
List<FileModel> data = treePanel.getSelectionModel()
|
|
.getSelectedItems();
|
|
|
|
treePanel.setExpanded(data.get(0), true); // expand
|
|
// level of
|
|
// the
|
|
// element
|
|
// selected
|
|
|
|
value = data.get(0).get("name");
|
|
|
|
// System.out.println("GxtTreePanel Value: "
|
|
// + data.get(0).get("name"));
|
|
|
|
rootLogger.log(Level.INFO, "GxtTreePanel-> selectedItem value: " + value);
|
|
|
|
// System.out.println("GxtTreePanel Depth: "
|
|
// + store.getDepth(data.get(0)));
|
|
|
|
treeDepthSelectedItem = store.getDepth(data.get(0));
|
|
|
|
// rootLogger.log(Level.INFO, "GxtTreePanel-> selectedItem level depth: " + treeDepthSelectedItem);
|
|
|
|
rootLogger.log(Level.INFO, "selectedItem level depth: " + treeDepthSelectedItem);
|
|
|
|
int numChildrenFolder = store.getChildCount(data.get(0));
|
|
|
|
// recover the appropriate information whenever an
|
|
// element is selected
|
|
|
|
setInfoOnSelectedItem(data.get(0));
|
|
|
|
if ((numChildrenFolder == 0)
|
|
&& (data.get(0).isLoaded() != true)) {
|
|
treePanel.mask("Loading", "x-mask-loading");
|
|
|
|
switch (treeDepthSelectedItem) {
|
|
// case 1:
|
|
//
|
|
// loadResources(data.get(0));
|
|
// break;
|
|
|
|
case 2:
|
|
loadDBInfo(data.get(0));
|
|
break;
|
|
|
|
case 3:
|
|
loadSchema(data.get(0));
|
|
break;
|
|
|
|
case 4:
|
|
loadTables(data.get(0));
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
// fire event
|
|
eventBus.fireEvent(new SelectedItemEvent());
|
|
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
private void loadRootItemTree() throws Exception {
|
|
|
|
// treePanel.mask("Loading", "x-mask-loading");
|
|
|
|
this.mask("Loading", "x-mask-loading");
|
|
|
|
|
|
final FileModel root = new FileModel("Resources");
|
|
store.insert(root, 0, true);
|
|
|
|
// store.add(root, true);
|
|
|
|
loadResources(root, this);
|
|
|
|
}
|
|
|
|
public String getValue() {
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
public int getTreeDepthSelectedItem() {
|
|
|
|
return treeDepthSelectedItem;
|
|
}
|
|
|
|
private void loadResources(final FileModel element, final GxtTreePanel tree) {
|
|
|
|
// System.out.println("Start RPC - getResources");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> Start RPC - getResource");
|
|
rootLogger.log(Level.SEVERE, "Start RPC - getResource");
|
|
|
|
// call remote service
|
|
|
|
RPCservice.getResource(new AsyncCallback<List<FileModel>>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
|
|
Window.alert(caught.getMessage());
|
|
// System.out.println("FAILURE");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> FAILURE RPC getResource");
|
|
|
|
rootLogger.log(Level.SEVERE, "FAILURE RPC getResource");
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<FileModel> result) {
|
|
|
|
if (tree.isMasked())
|
|
tree.unmask();
|
|
|
|
// if (treePanel.isMasked())
|
|
// treePanel.unmask();
|
|
|
|
// System.out.println("SUCCESS");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> SUCCESS RPC getResource");
|
|
|
|
rootLogger.log(Level.SEVERE, "SUCCESS RPC getResource");
|
|
|
|
// print check
|
|
for (int i = 0; i < result.size(); i++) {
|
|
|
|
// System.out.println(result.get(i).getName());
|
|
|
|
// rootLogger.log(Level.INFO, "GxtTreePanel-> Resource: " + result.get(i).getName());
|
|
|
|
rootLogger.log(Level.INFO, "Resource: " + result.get(i).getName());
|
|
|
|
}
|
|
|
|
// int numChildrenFolder = store.getChildCount(element);
|
|
|
|
addChildren(element, result);
|
|
|
|
element.setIsLoaded(true);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// System.out.println("End RPC - getResources");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> End RPC - getResource");
|
|
|
|
rootLogger.log(Level.SEVERE, "End RPC - getResource");
|
|
}
|
|
|
|
private void loadDBInfo(final FileModel element) {
|
|
|
|
// System.out.println("Start RPC - getDBInfo");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> Start RPC - getDBInfo");
|
|
|
|
rootLogger.log(Level.SEVERE, "Start RPC - getDBInfo");
|
|
|
|
|
|
// call remote service
|
|
|
|
RPCservice.getDBInfo(element.getName(),
|
|
new AsyncCallback<LinkedHashMap<String, FileModel>>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
|
|
Window.alert(caught.getMessage());
|
|
// System.out.println("FAILURE");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> FAILURE RPC getDBInfo");
|
|
|
|
rootLogger.log(Level.SEVERE, "FAILURE RPC getDBInfo");
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(
|
|
LinkedHashMap<String, FileModel> result) {
|
|
|
|
if (treePanel.isMasked())
|
|
treePanel.unmask();
|
|
|
|
// System.out.println("SUCCESS");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> SUCCESS RPC getDBInfo");
|
|
|
|
rootLogger.log(Level.SEVERE, "SUCCESS RPC getDBInfo");
|
|
|
|
if (result.size() != 0) {
|
|
|
|
// recover keys from the result
|
|
|
|
Set<String> keys = result.keySet();
|
|
|
|
Object[] array = keys.toArray();
|
|
|
|
// System.out.println("array size: " + array.length);
|
|
|
|
// recover information for each database
|
|
|
|
List<FileModel> children = new ArrayList<FileModel>();
|
|
int numIterations = (result.size()) / 5;
|
|
|
|
int i = 0;
|
|
int j = 0;
|
|
for (i = 0; i < numIterations; i++) {
|
|
|
|
// System.out.println("index i: " + i);
|
|
|
|
String DBName = null;
|
|
List<Result> DBInfo = new ArrayList<Result>();
|
|
|
|
for (j = (i * 5); j < (i + 1) * 5; j++) {
|
|
|
|
// System.out.println("index j: " + j);
|
|
|
|
if (array[j].toString().contains(
|
|
"Database Name")) {
|
|
|
|
// recover the database name
|
|
DBName = result
|
|
.get(array[j].toString())
|
|
.getName();
|
|
|
|
Result row = new Result(
|
|
"Database Name", result.get(
|
|
array[j].toString())
|
|
.getName());
|
|
DBInfo.add(row);
|
|
|
|
}
|
|
|
|
if (array[j].toString().contains("URL")) {
|
|
Result row = new Result("URL", result
|
|
.get(array[j].toString())
|
|
.getName());
|
|
DBInfo.add(row);
|
|
}
|
|
|
|
if (array[j].toString().contains(
|
|
"Driver Name")) {
|
|
|
|
Result row = new Result("Driver Name",
|
|
result.get(array[j].toString())
|
|
.getName());
|
|
DBInfo.add(row);
|
|
|
|
}
|
|
|
|
if (array[j].toString().contains(
|
|
"Dialect Name")) {
|
|
|
|
Result row = new Result("Dialect Name",
|
|
result.get(array[j].toString())
|
|
.getName());
|
|
DBInfo.add(row);
|
|
|
|
}
|
|
|
|
if (array[j].toString().contains(
|
|
"Platform Name")) {
|
|
|
|
Result row = new Result(
|
|
"Platform Name", result.get(
|
|
array[j].toString())
|
|
.getName());
|
|
DBInfo.add(row);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
FileModel child = new FileModel(DBName);
|
|
|
|
child.setIsDatabase(true);
|
|
|
|
child.setDBInfo(DBInfo);
|
|
|
|
children.add(child);
|
|
|
|
}
|
|
|
|
addChildren(element, children);
|
|
|
|
}
|
|
|
|
// System.out.println("children number: "
|
|
// + store.getChildCount(element));
|
|
|
|
// rootLogger.log(Level.INFO, "GxtTreePanel-> children number: " + store.getChildCount(element));
|
|
|
|
rootLogger.log(Level.INFO, "children number: " + store.getChildCount(element));
|
|
|
|
element.setIsLoaded(true);
|
|
|
|
// // fire event
|
|
// eventBus.fireEvent(new DisplayDBInfoEvent());
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// System.out.println("End RPC - getDBInfo");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> End RPC - getDBInfo");
|
|
|
|
rootLogger.log(Level.SEVERE, "End RPC - getDBInfo");
|
|
|
|
}
|
|
|
|
private void loadSchema(final FileModel element) {
|
|
|
|
// System.out.println("Start RPC - getSchema");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> Start RPC - getDBSchema");
|
|
|
|
rootLogger.log(Level.SEVERE, "Start RPC - getDBSchema");
|
|
|
|
// recover data inputs
|
|
|
|
LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();
|
|
|
|
FileModel parent = store.getParent(element);
|
|
|
|
dataInput.put("ResourceName", parent.getName());
|
|
dataInput.put("DatabaseName", element.getName());
|
|
|
|
// call remote service
|
|
|
|
RPCservice.getDBSchema(dataInput, new AsyncCallback<List<FileModel>>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
Window.alert(caught.getMessage());
|
|
// System.out.println("FAILURE");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> FAILURE RPC getDBSchema");
|
|
|
|
rootLogger.log(Level.SEVERE, "FAILURE RPC getDBSchema");
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<FileModel> result) {
|
|
|
|
if (treePanel.isMasked())
|
|
treePanel.unmask();
|
|
|
|
// System.out.println("SUCCESS");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> SUCCESS RPC getDBSchema");
|
|
|
|
rootLogger.log(Level.SEVERE, "SUCCESS RPC getDBSchema");
|
|
|
|
|
|
if (result.size() == 0) { // the database has not schema
|
|
|
|
loadTables(element);
|
|
|
|
} else {
|
|
|
|
// // print check
|
|
// for (int i = 0; i < result.size(); i++) {
|
|
// System.out.println(result.get(i).getName());
|
|
//
|
|
// }
|
|
|
|
// int numChildrenFolder = store.getChildCount(element);
|
|
|
|
// if (numChildrenFolder == 0) {
|
|
|
|
addChildren(element, result);
|
|
|
|
element.setIsLoaded(true);
|
|
|
|
// }
|
|
}
|
|
|
|
}
|
|
});
|
|
|
|
// System.out.println("End RPC - getSchema");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> End RPC - getDBSchema");
|
|
|
|
rootLogger.log(Level.SEVERE, "End RPC - getDBSchema");
|
|
|
|
}
|
|
|
|
private void loadTables(final FileModel element) {
|
|
|
|
// System.out.println("Start RPC - getTables");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> Start RPC - getTables");
|
|
|
|
rootLogger.log(Level.SEVERE, "Start RPC - getTables");
|
|
|
|
// recover data inputs
|
|
|
|
LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();
|
|
|
|
FileModel parent = store.getParent(element);
|
|
FileModel parent1 = store.getParent(parent);
|
|
|
|
dataInput.put("ResourceName", parent1.getName());
|
|
dataInput.put("DatabaseName", parent.getName());
|
|
dataInput.put("SchemaName", element.getName());
|
|
|
|
rootLogger.log(Level.INFO, "ResourceName: " + parent1.getName());
|
|
rootLogger.log(Level.INFO, "DatabaseName: " + parent.getName());
|
|
rootLogger.log(Level.INFO, "SchemaName: " + element.getName());
|
|
|
|
// System.out.println(parent1.getName());
|
|
// System.out.println(parent.getName());
|
|
// System.out.println(element.getName());
|
|
|
|
// call remote service
|
|
|
|
RPCservice.getTables(dataInput, new AsyncCallback<List<FileModel>>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
Window.alert(caught.getMessage());
|
|
// System.out.println("FAILURE");
|
|
rootLogger.log(Level.SEVERE, "FAILURE RPC getTables");
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<FileModel> result) {
|
|
|
|
if (treePanel.isMasked())
|
|
treePanel.unmask();
|
|
|
|
// System.out.println("SUCCESS");
|
|
|
|
rootLogger.log(Level.SEVERE, "SUCCESS RPC getTables");
|
|
|
|
if (result.size() == 0) { // the database has not tables
|
|
|
|
// System.out.println("the database has not tables");
|
|
|
|
rootLogger.log(Level.SEVERE, "the database has not tables");
|
|
|
|
// loadTables(element);
|
|
element.setIsExpanded(false);
|
|
|
|
treePanel.setExpanded(element, false);
|
|
|
|
} else {
|
|
|
|
for (int i = 0; i < result.size(); i++) {
|
|
|
|
result.get(i).setIsExpanded(false);
|
|
result.get(i).setIsLoaded(true);
|
|
|
|
// System.out.println(result.get(i).getName());
|
|
|
|
rootLogger.log(Level.INFO, "table: " + result.get(i).getName());
|
|
|
|
}
|
|
|
|
// int numChildrenFolder = store.getChildCount(element);
|
|
|
|
// if (numChildrenFolder == 0) {
|
|
|
|
addChildren(element, result);
|
|
|
|
// }
|
|
}
|
|
|
|
element.setIsLoaded(true);
|
|
|
|
|
|
}
|
|
});
|
|
|
|
// System.out.println("End RPC - getTables");
|
|
|
|
rootLogger.log(Level.SEVERE, "End RPC getTables");
|
|
|
|
}
|
|
|
|
public boolean getSelectedItemIsSchema() {
|
|
|
|
return SelectedItemIsSchema;
|
|
}
|
|
|
|
public LinkedHashMap<String, FileModel> getDataOnDB() {
|
|
return dataDBInfo;
|
|
}
|
|
|
|
// public FileModel getSelectedItem(){
|
|
//
|
|
//
|
|
// return treePanel.getSelectionModel().getSelectedItem();
|
|
//
|
|
// }
|
|
|
|
private void addChildren(FileModel parent, List<FileModel> children) {
|
|
|
|
if (parent != null) {
|
|
|
|
store.add(parent, children, true);
|
|
|
|
// System.out.println("Added children in store");
|
|
|
|
rootLogger.log(Level.INFO, "Added children in store");
|
|
}
|
|
}
|
|
|
|
public String getResourceNameSelected() {
|
|
|
|
return ResourceNameSelected;
|
|
|
|
}
|
|
|
|
public String getDatabaseNameSelected() {
|
|
|
|
return DatabaseNameSelected;
|
|
|
|
}
|
|
|
|
public String getSchemaNameSelected() {
|
|
|
|
return SchemaNameSelected;
|
|
|
|
}
|
|
|
|
public String getTableNameSelected() {
|
|
|
|
return TableNameSelected;
|
|
|
|
}
|
|
|
|
private void setInfoOnSelectedItem(FileModel element) {
|
|
|
|
infoOnSelectedItem = new LinkedHashMap<String, String>();
|
|
|
|
if ((treeDepthSelectedItem == 4) && (element.isSchema() == true)) { // the
|
|
// selected
|
|
// element
|
|
// is
|
|
// a
|
|
// schema
|
|
|
|
// System.out.println("is a schema");
|
|
|
|
rootLogger.log(Level.SEVERE, "setInfo for selected item schema");
|
|
|
|
SelectedItemIsSchema = true;
|
|
|
|
// //recover schema name
|
|
// SchemaNameSelected = element.getName();
|
|
|
|
// recover database name
|
|
FileModel database = store.getParent(element);
|
|
|
|
DatabaseNameSelected = database.getName();
|
|
|
|
// recover resource name
|
|
FileModel resource = store.getParent(database);
|
|
ResourceNameSelected = resource.getName();
|
|
|
|
infoOnSelectedItem.put("ResourceName", ResourceNameSelected);
|
|
infoOnSelectedItem.put("DatabaseName", DatabaseNameSelected);
|
|
|
|
}
|
|
|
|
else if ((treeDepthSelectedItem == 4) && (element.isSchema() == false)) { // the
|
|
// selected
|
|
// element
|
|
// is
|
|
// a
|
|
// table
|
|
// because
|
|
// the
|
|
// database
|
|
// is
|
|
// mysql
|
|
// type
|
|
|
|
// System.out.println("is a table");
|
|
|
|
rootLogger.log(Level.SEVERE, "setInfo for selected item table");
|
|
|
|
// recover table name
|
|
TableNameSelected = element.getName();
|
|
|
|
// recover database name
|
|
FileModel database = store.getParent(element);
|
|
|
|
DatabaseNameSelected = database.getName();
|
|
|
|
// recover resource name
|
|
FileModel resource = store.getParent(database);
|
|
ResourceNameSelected = resource.getName();
|
|
|
|
infoOnSelectedItem.put("ResourceName", ResourceNameSelected);
|
|
infoOnSelectedItem.put("DatabaseName", DatabaseNameSelected);
|
|
infoOnSelectedItem.put("TableName", TableNameSelected);
|
|
|
|
} else if (treeDepthSelectedItem == 5) { // the selected item is a table
|
|
// so the database is
|
|
// postgres type
|
|
|
|
// System.out.println("is a table");
|
|
|
|
rootLogger.log(Level.SEVERE, "setInfo for selected item table");
|
|
|
|
// recover table name
|
|
TableNameSelected = element.getName();
|
|
|
|
// recover schema name
|
|
FileModel schema = store.getParent(element);
|
|
SchemaNameSelected = schema.getName();
|
|
|
|
// recover database name
|
|
FileModel database = store.getParent(schema);
|
|
|
|
DatabaseNameSelected = database.getName();
|
|
|
|
// recover resource name
|
|
FileModel resource = store.getParent(database);
|
|
ResourceNameSelected = resource.getName();
|
|
|
|
infoOnSelectedItem.put("ResourceName", ResourceNameSelected);
|
|
infoOnSelectedItem.put("DatabaseName", DatabaseNameSelected);
|
|
infoOnSelectedItem.put("SchemaName", SchemaNameSelected);
|
|
infoOnSelectedItem.put("TableName", TableNameSelected);
|
|
|
|
} else if (treeDepthSelectedItem == 3) { // the selected item is a
|
|
// database
|
|
|
|
// System.out.println("is a database");
|
|
|
|
rootLogger.log(Level.SEVERE, "setInfo for selected item database");
|
|
|
|
// recover database name
|
|
DatabaseNameSelected = element.getName();
|
|
|
|
// recover resource name
|
|
FileModel resource = store.getParent(element);
|
|
ResourceNameSelected = resource.getName();
|
|
|
|
infoOnSelectedItem.put("ResourceName", ResourceNameSelected);
|
|
infoOnSelectedItem.put("DatabaseName", DatabaseNameSelected);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public LinkedHashMap<String, String> getInfoOnSelectedItem() {
|
|
|
|
return infoOnSelectedItem;
|
|
}
|
|
|
|
public TreePanel<FileModel> getTreePanel() {
|
|
return this.treePanel;
|
|
}
|
|
|
|
public TreeStore<FileModel> getTreeStore() {
|
|
return this.store;
|
|
}
|
|
|
|
}
|