1288 lines
32 KiB
Java
1288 lines
32 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.databasesmanager.client.utils.ConstantsPortlet;
|
|
|
|
import com.extjs.gxt.ui.client.Style.Scroll;
|
|
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.Events;
|
|
import com.extjs.gxt.ui.client.event.Listener;
|
|
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.MessageBox;
|
|
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.rpc.AsyncCallback;
|
|
|
|
//class that implements the tree object
|
|
|
|
public class GxtTreePanel extends LayoutContainer {
|
|
|
|
// to manage the tree
|
|
private TreeStore<FileModel> store;
|
|
private TreePanel<FileModel> treePanel;
|
|
|
|
// to manage events
|
|
private HandlerManager eventBus = null;
|
|
|
|
private String value = "";
|
|
private int treeDepthSelectedItem;
|
|
// private boolean SelectedItemIsSchema = false;
|
|
|
|
// the rpc remote service
|
|
private GWTdbManagerServiceAsync RPCservice = null;
|
|
|
|
// to keep track of information associated to a database
|
|
// private LinkedHashMap<String, FileModel> dataDBInfo = null;
|
|
|
|
// private String ResourceNameSelected;
|
|
// private String DatabaseNameSelected;
|
|
// private String SchemaNameSelected;
|
|
// private String TableNameSelected;
|
|
|
|
// to keep track of information associated to the selected item
|
|
private LinkedHashMap<String, String> infoOnSelectedItem;
|
|
|
|
private static Logger rootLogger = Logger.getLogger("GxtTreePanel");
|
|
|
|
// constructor
|
|
public GxtTreePanel(HandlerManager eBus, GWTdbManagerServiceAsync service)
|
|
throws Exception {
|
|
|
|
RPCservice = service;
|
|
|
|
eventBus = eBus;
|
|
|
|
store = new TreeStore<FileModel>();
|
|
|
|
//remove the scroll mode (the scroll of the panel that contains the tree is used)
|
|
this.setScrollMode(Scroll.NONE);
|
|
|
|
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();
|
|
|
|
// boolean rightClick = false;
|
|
//
|
|
// if (typeEvent == Events.OnMouseDown) {
|
|
//
|
|
// if (ce.isRightClick()){
|
|
// rightClick = true;
|
|
// }
|
|
// }
|
|
|
|
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;
|
|
}
|
|
|
|
// view.onEvent(tpe);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
treePanel.setDisplayProperty("name");
|
|
|
|
|
|
|
|
// load the root
|
|
loadRootItemTree();
|
|
|
|
// set 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() {
|
|
|
|
// to manage the selection item event in the tree
|
|
treePanel.getSelectionModel().addSelectionChangedListener(
|
|
new SelectionChangedListener<FileModel>() {
|
|
|
|
@Override
|
|
public void selectionChanged(
|
|
SelectionChangedEvent<FileModel> se) {
|
|
|
|
// reset infromation at each selection
|
|
// dataDBInfo = null;
|
|
// ResourceNameSelected = null;
|
|
// DatabaseNameSelected = null;
|
|
// SchemaNameSelected = null;
|
|
// TableNameSelected = null;
|
|
// infoOnSelectedItem = null;
|
|
// SelectedItemIsSchema = false;
|
|
|
|
// the selected element
|
|
List<FileModel> data = treePanel.getSelectionModel()
|
|
.getSelectedItems();
|
|
|
|
FileModel selectedItem = data.get(0);
|
|
|
|
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)));
|
|
|
|
// get the depth level
|
|
treeDepthSelectedItem = store.getDepth(data.get(0));
|
|
|
|
// rootLogger.log(Level.INFO,
|
|
// "GxtTreePanel-> selectedItem level depth: " +
|
|
// treeDepthSelectedItem);
|
|
|
|
rootLogger.log(Level.INFO, "selectedItem level depth: "
|
|
+ treeDepthSelectedItem);
|
|
|
|
// get children number for the selected item
|
|
|
|
int numChildrenFolder = store.getChildCount(data.get(0));
|
|
|
|
// recover the appropriate information whenever an
|
|
// element is selected
|
|
|
|
// setInfoOnSelectedItem(data.get(0));
|
|
|
|
treePanel.setExpanded(data.get(0), true); // expand
|
|
// level of
|
|
// the
|
|
// element
|
|
// selected
|
|
|
|
// do not make a rpc call
|
|
if ((data.get(0).isLoaded() == true)) {
|
|
|
|
setInfoOnSelectedItem(data.get(0));
|
|
|
|
// fire event when an item has been selected in the
|
|
// tree
|
|
eventBus.fireEvent(new SelectedItemEvent());
|
|
|
|
} else if (data.get(0).isDatabase()) {
|
|
|
|
setInfoOnSelectedItem(data.get(0));
|
|
|
|
// fire event when an item has been selected in the
|
|
// tree
|
|
eventBus.fireEvent(new SelectedItemEvent());
|
|
|
|
} else if (data.get(0).isSchema()) {
|
|
|
|
setInfoOnSelectedItem(data.get(0));
|
|
|
|
// fire event when an item has been selected in the
|
|
// tree
|
|
eventBus.fireEvent(new SelectedItemEvent());
|
|
|
|
}
|
|
|
|
// // check to make the RPC call only one time. The
|
|
// // selected item has not loaded
|
|
// if ((numChildrenFolder == 0)
|
|
// && (data.get(0).isLoaded() != true)) {
|
|
//
|
|
// // treePanel.disableEvents(true);
|
|
//
|
|
// // selectedItem.setIsSchema(false);
|
|
//
|
|
// switch (treeDepthSelectedItem) {
|
|
// // case 1:
|
|
// //
|
|
// // loadResources(data.get(0));
|
|
// // break;
|
|
//
|
|
// case 2: // the selected item is the resource
|
|
// // selectedItem.setIsSchema(false);
|
|
//
|
|
// // to mask the tree panel
|
|
// treePanel.mask("Loading", "x-mask-loading");
|
|
//
|
|
// loadDBInfo(data.get(0), treePanel);
|
|
// // loadDBInfo(data.get(0));
|
|
// break;
|
|
//
|
|
// case 3: // the selected item is a database
|
|
//
|
|
// if (selectedItem.getDatabaseType().equals(
|
|
// ConstantsPortlet.POSTGRES)) {
|
|
//
|
|
// // to mask the tree panel
|
|
// treePanel.mask("Loading", "x-mask-loading");
|
|
// // load schema for postgres database
|
|
//
|
|
// // selectedItem.setIsSchema(false);
|
|
// loadSchema(data.get(0));
|
|
// }
|
|
// // else {
|
|
// // // System.out.println("database mysql: " +
|
|
// // // data.get(0).getName() +
|
|
// // // data.get(0).getDatabaseType());
|
|
// //
|
|
// // // load tables for mysql database
|
|
// // loadTables(data.get(0));
|
|
// // }
|
|
// break;
|
|
//
|
|
// // case 4: // load tables for postgres database
|
|
// // // selectedItem.setIsSchema(false);
|
|
// // loadTables(data.get(0));
|
|
// // break;
|
|
//
|
|
// }
|
|
// }
|
|
|
|
// else {
|
|
// //if the selected item has already been been loaded
|
|
//
|
|
// setInfoOnSelectedItem(data.get(0));
|
|
// }
|
|
|
|
// // fire event when an item has been selected in the
|
|
// tree
|
|
// eventBus.fireEvent(new SelectedItemEvent());
|
|
|
|
}
|
|
});
|
|
|
|
treePanel.addListener(Events.Expand,
|
|
new Listener<TreePanelEvent<FileModel>>() {
|
|
public void handleEvent(final TreePanelEvent<FileModel> be) {
|
|
|
|
rootLogger.log(Level.INFO, "Expand");
|
|
|
|
FileModel selectedItem = (FileModel) (be.getNode()
|
|
.getModel());
|
|
|
|
rootLogger.log(Level.INFO,
|
|
"selected: " + selectedItem.getName());
|
|
|
|
// select the expanded item
|
|
treePanel.getSelectionModel()
|
|
.select(selectedItem, true);
|
|
|
|
int numChildrenFolder = store
|
|
.getChildCount(selectedItem);
|
|
|
|
setInfoOnSelectedItem(selectedItem);
|
|
|
|
// get the depth level
|
|
treeDepthSelectedItem = store.getDepth(selectedItem);
|
|
|
|
rootLogger.log(Level.INFO, "selectedItem level depth: "
|
|
+ treeDepthSelectedItem);
|
|
|
|
// check to make the RPC call only one time. The
|
|
// selected item has not loaded
|
|
if ((numChildrenFolder == 0)
|
|
&& (selectedItem.isLoaded() != true)) {
|
|
|
|
if (treeDepthSelectedItem!=1){
|
|
treePanel.disableEvents(true);
|
|
}
|
|
|
|
|
|
// selectedItem.setIsSchema(false);
|
|
|
|
switch (treeDepthSelectedItem) {
|
|
// case 1:
|
|
//
|
|
// loadResources(data.get(0));
|
|
// break;
|
|
|
|
case 2: // the selected item is the resource
|
|
// selectedItem.setIsSchema(false);
|
|
|
|
// to mask the tree panel
|
|
treePanel.mask("Loading", "x-mask-loading");
|
|
|
|
loadDBInfo(selectedItem, treePanel);
|
|
// loadDBInfo(data.get(0));
|
|
break;
|
|
|
|
case 3: // the selected item is a database
|
|
|
|
if (selectedItem.getDatabaseType().equals(
|
|
ConstantsPortlet.POSTGRES)) {
|
|
|
|
// to mask the tree panel
|
|
treePanel.mask("Loading", "x-mask-loading");
|
|
// load schema for postgres database
|
|
|
|
// selectedItem.setIsSchema(false);
|
|
loadSchema(selectedItem);
|
|
}
|
|
// else {
|
|
// // System.out.println("database mysql: " +
|
|
// // data.get(0).getName() +
|
|
// // data.get(0).getDatabaseType());
|
|
//
|
|
// // load tables for mysql database
|
|
// loadTables(data.get(0));
|
|
// }
|
|
break;
|
|
|
|
// case 4: // load tables for postgres database
|
|
// // selectedItem.setIsSchema(false);
|
|
// loadTables(data.get(0));
|
|
// break;
|
|
|
|
}
|
|
|
|
// fire event when an item has been selected in the
|
|
// tree
|
|
eventBus.fireEvent(new SelectedItemEvent());
|
|
}
|
|
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
// load the root
|
|
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;
|
|
|
|
}
|
|
|
|
// // get the tree depth
|
|
// public int getTreeDepthSelectedItem() {
|
|
//
|
|
// return treeDepthSelectedItem;
|
|
// }
|
|
|
|
// load resources
|
|
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 rpc 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");
|
|
|
|
MessageBox.alert("Error ",
|
|
"<br/>Message:" + caught.getMessage(), null);
|
|
|
|
if (tree.isMasked()) {
|
|
tree.unmask();
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<FileModel> result) {
|
|
|
|
// 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);
|
|
|
|
if (result.size() == 0) {
|
|
element.setIsExpanded(false);
|
|
treePanel.setExpanded(element, false);
|
|
}
|
|
|
|
if (tree.isMasked())
|
|
tree.unmask();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// System.out.println("End RPC - getResources");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> End RPC - getResource");
|
|
|
|
rootLogger.log(Level.SEVERE, "End RPC - getResource");
|
|
}
|
|
|
|
// load information fo a database
|
|
private void loadDBInfo(final FileModel element,
|
|
final TreePanel<FileModel> tree) {
|
|
|
|
// 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");
|
|
|
|
MessageBox.alert("Error ",
|
|
"<br/>Message:" + caught.getMessage(), null);
|
|
|
|
if (treePanel.isMasked())
|
|
treePanel.unmask();
|
|
|
|
tree.enableEvents(true);
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(
|
|
LinkedHashMap<String, FileModel> result) {
|
|
|
|
// 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++) {
|
|
|
|
String DatabaseType = null;
|
|
|
|
// 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());
|
|
|
|
String driver = result.get(
|
|
array[j].toString()).getName();
|
|
DBInfo.add(row);
|
|
|
|
if (driver.toUpperCase().contains(
|
|
ConstantsPortlet.POSTGRES)) {
|
|
|
|
DatabaseType = ConstantsPortlet.POSTGRES;
|
|
|
|
}
|
|
|
|
if (driver.toUpperCase().contains(
|
|
ConstantsPortlet.MYSQL)) {
|
|
|
|
DatabaseType = ConstantsPortlet.MYSQL;
|
|
|
|
}
|
|
}
|
|
|
|
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);
|
|
|
|
// set that the item is a database
|
|
child.setIsDatabase(true);
|
|
|
|
child.setDBInfo(DBInfo);
|
|
|
|
// check print
|
|
// rootLogger.log(Level.INFO, "DatabaseType: " +
|
|
// DatabaseType);
|
|
|
|
// set the database type considering the driver
|
|
// infromation
|
|
child.setDatabaseType(DatabaseType);
|
|
|
|
if (DatabaseType.equals(ConstantsPortlet.MYSQL)) {
|
|
|
|
child.setIsExpanded(false);
|
|
|
|
treePanel.setExpanded(child, false);
|
|
|
|
}
|
|
|
|
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());
|
|
|
|
if (result.size() == 0) {
|
|
element.setIsExpanded(false);
|
|
treePanel.setExpanded(element, false);
|
|
}
|
|
|
|
if (treePanel.isMasked())
|
|
treePanel.unmask();
|
|
|
|
// tree.enable();
|
|
|
|
tree.enableEvents(true);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// System.out.println("End RPC - getDBInfo");
|
|
|
|
// rootLogger.log(Level.SEVERE, "GxtTreePanel-> End RPC - getDBInfo");
|
|
|
|
rootLogger.log(Level.SEVERE, "End RPC - getDBInfo");
|
|
|
|
}
|
|
|
|
// load schema
|
|
|
|
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");
|
|
|
|
MessageBox.alert("Error ",
|
|
"<br/>Message:" + caught.getMessage(), null);
|
|
|
|
if (treePanel.isMasked())
|
|
treePanel.unmask();
|
|
|
|
treePanel.enableEvents(true);
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<FileModel> result) {
|
|
|
|
// 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
|
|
|
|
// element.setIsSchema(false);
|
|
// element.setIsLoaded(false);
|
|
// loadTables(element);
|
|
|
|
rootLogger.log(Level.INFO, "the database has not schema");
|
|
|
|
element.setIsExpanded(false);
|
|
treePanel.setExpanded(element, false);
|
|
|
|
} 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) {
|
|
|
|
for (int i = 0; i < result.size(); i++) {
|
|
|
|
// element.setIsSchema(true);
|
|
result.get(i).setIsSchema(true);
|
|
result.get(i).setIsExpanded(false);
|
|
treePanel.setExpanded(result.get(i), false);
|
|
}
|
|
|
|
addChildren(element, result);
|
|
|
|
// element.setIsLoaded(true);
|
|
|
|
// }
|
|
}
|
|
|
|
element.setIsLoaded(true);
|
|
|
|
if (treePanel.isMasked())
|
|
treePanel.unmask();
|
|
|
|
treePanel.enableEvents(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) {
|
|
|
|
if (treePanel.isMasked())
|
|
treePanel.unmask();
|
|
|
|
// fire event to manage the tables loading
|
|
// eventBus.fireEvent(new LoadTablesEvent());
|
|
|
|
// 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>();
|
|
//
|
|
// // check if the element is a schema or a database
|
|
//
|
|
// // System.out.println("element is a schema: " + element.isSchema());
|
|
// //
|
|
// // if (element.isSchema()) {
|
|
// //
|
|
// // System.out.println("element is a schema: " + element.isSchema());
|
|
// //
|
|
// // FileModel database = store.getParent(element);
|
|
// // FileModel resource = store.getParent(database);
|
|
// //
|
|
// // dataInput.put("ResourceName", resource.getName());
|
|
// // dataInput.put("DatabaseName", database.getName());
|
|
// // dataInput.put("SchemaName", element.getName());
|
|
// //
|
|
// // System.out.println("schema name: " + element.getName());
|
|
// //
|
|
// // rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// // rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
// // rootLogger.log(Level.INFO, "SchemaName: " + element.getName());
|
|
// //
|
|
// // // System.out.println(parent1.getName());
|
|
// // // System.out.println(parent.getName());
|
|
// // // System.out.println(element.getName());
|
|
// //
|
|
// // }
|
|
// //
|
|
// // if (element.isDatabase()) {
|
|
// //
|
|
// // System.out.println("element is a database: " +
|
|
// element.isDatabase());
|
|
// //
|
|
// // FileModel resource = store.getParent(element);
|
|
// // // FileModel parent1 = store.getParent(parent);
|
|
// //
|
|
// // dataInput.put("ResourceName", resource.getName());
|
|
// // dataInput.put("DatabaseName", element.getName());
|
|
// // dataInput.put("SchemaName", "");
|
|
// //
|
|
// // rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// // rootLogger.log(Level.INFO, "DatabaseName: " + element.getName());
|
|
// // rootLogger.log(Level.INFO, "SchemaName: " + "");
|
|
// //
|
|
// // // System.out.println(parent1.getName());
|
|
// // // System.out.println(parent.getName());
|
|
// // // System.out.println(element.getName());
|
|
// //
|
|
// // }
|
|
//
|
|
// String resource = "";
|
|
// String database = "";
|
|
// String schema = "";
|
|
//
|
|
// if (element.isDatabase()) { // the selected item is a database
|
|
//
|
|
// rootLogger.log(Level.INFO, "element is a database ");
|
|
//
|
|
// database = element.getName();
|
|
// resource = store.getParent(element).getName();
|
|
//
|
|
// dataInput.put("ResourceName", resource);
|
|
// dataInput.put("DatabaseName", database);
|
|
// dataInput.put("SchemaName", "");
|
|
//
|
|
// } else { // the selected item is a schema
|
|
//
|
|
// rootLogger.log(Level.INFO, "element is a schema ");
|
|
//
|
|
// FileModel db = store.getParent(element);
|
|
// database = db.getName();
|
|
//
|
|
// resource = store.getParent(db).getName();
|
|
// schema = element.getName();
|
|
//
|
|
// dataInput.put("ResourceName", resource);
|
|
// dataInput.put("DatabaseName", database);
|
|
// dataInput.put("SchemaName", schema);
|
|
//
|
|
// // dataInput.put("ResourceName", resource.getName());
|
|
// // dataInput.put("DatabaseName", database.getName());
|
|
// // dataInput.put("SchemaName", element.getName());
|
|
//
|
|
// }
|
|
|
|
// FileModel database = store.getParent(element);
|
|
// FileModel resource = store.getParent(database);
|
|
//
|
|
// dataInput.put("ResourceName", resource.getName());
|
|
// dataInput.put("DatabaseName", database.getName());
|
|
|
|
// if (element.getDatabaseType().equals(ConstantsPortlet.POSTGRES)){
|
|
//
|
|
//
|
|
// }
|
|
// else{
|
|
// dataInput.put("SchemaName", "");
|
|
// }
|
|
|
|
// System.out.println("schema name: " + element.getName());
|
|
|
|
// rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
|
|
// rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + element.getName());
|
|
|
|
// rootLogger.log(Level.INFO, "ResourceName: " + resource);
|
|
// rootLogger.log(Level.INFO, "DatabaseName: " + database);
|
|
// rootLogger.log(Level.INFO, "SchemaName: " + schema);
|
|
|
|
// 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");
|
|
//
|
|
// // no tables are available (the schema has not table)
|
|
// if (caught.getMessage().equals(
|
|
// "java.lang.Exception: Result not available")) {
|
|
//
|
|
// element.setIsExpanded(false);
|
|
//
|
|
// treePanel.setExpanded(element, false);
|
|
//
|
|
// element.setIsLoaded(true);
|
|
//
|
|
// if (treePanel.isMasked())
|
|
// treePanel.unmask();
|
|
//
|
|
// treePanel.enableEvents(true);
|
|
//
|
|
// }
|
|
//
|
|
// // MessageBox.alert("Error ","<br/>Message:"+caught.getMessage(),
|
|
// // null);
|
|
//
|
|
// }
|
|
//
|
|
// @Override
|
|
// public void onSuccess(List<FileModel> result) {
|
|
//
|
|
//
|
|
//
|
|
// // 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).setIsTable(true);
|
|
//
|
|
// // result.get(i).setIsExpanded(false);
|
|
//
|
|
// result.get(i).setIsLoaded(true);
|
|
//
|
|
// // result.get(i).setIsSchema(false);
|
|
//
|
|
// // element.setIsLoaded(true);
|
|
//
|
|
// // ppritn check
|
|
// // 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);
|
|
//
|
|
// element.setIsExpanded(false);
|
|
// treePanel.setExpanded(element, false);
|
|
//
|
|
// if (treePanel.isMasked())
|
|
// treePanel.unmask();
|
|
//
|
|
// treePanel.enableEvents(true);
|
|
//
|
|
// //fire event
|
|
// eventBus.fireEvent(new LoadTablesEvent());
|
|
//
|
|
//
|
|
//
|
|
// }
|
|
// });
|
|
//
|
|
// //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;
|
|
//
|
|
// }
|
|
|
|
// set information (useful for the submitquery operation) for the selected
|
|
// item. The selected item can be a schema, a table and a database.
|
|
private void setInfoOnSelectedItem(FileModel element) {
|
|
|
|
// infoOnSelectedItem = new LinkedHashMap<String, String>();
|
|
|
|
if ((treeDepthSelectedItem == 4) && (element.isSchema() == true)) { // the
|
|
// selected
|
|
// element
|
|
// is
|
|
// a
|
|
// schema
|
|
|
|
rootLogger.log(Level.SEVERE, "setInfo for selected item schema");
|
|
|
|
// SelectedItemIsSchema = true;
|
|
|
|
// recover database name
|
|
FileModel database = store.getParent(element);
|
|
|
|
String DatabaseName = database.getName();
|
|
|
|
// recover resource name
|
|
FileModel resource = store.getParent(database);
|
|
String ResourceName = resource.getName();
|
|
|
|
element.setResourceName(ResourceName);
|
|
element.setDatabaseName(DatabaseName);
|
|
|
|
// 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
|
|
|
|
rootLogger.log(Level.SEVERE, "setInfo for selected item table");
|
|
|
|
// recover table name
|
|
// TableNameSelected = element.getName();
|
|
|
|
// recover database name
|
|
FileModel database = store.getParent(element);
|
|
|
|
String DatabaseName = database.getName();
|
|
|
|
// recover resource name
|
|
FileModel resource = store.getParent(database);
|
|
String ResourceName = resource.getName();
|
|
|
|
element.setResourceName(ResourceName);
|
|
element.setDatabaseName(DatabaseName);
|
|
|
|
// infoOnSelectedItem.put("ResourceName", ResourceNameSelected);
|
|
// infoOnSelectedItem.put("DatabaseName", DatabaseNameSelected);
|
|
// infoOnSelectedItem.put("SchemaName", "");
|
|
// 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);
|
|
|
|
String DatabaseName = database.getName();
|
|
|
|
// recover resource name
|
|
FileModel resource = store.getParent(database);
|
|
String ResourceName = resource.getName();
|
|
|
|
element.setResourceName(ResourceName);
|
|
element.setDatabaseName(DatabaseName);
|
|
|
|
// 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
|
|
|
|
rootLogger.log(Level.SEVERE, "setInfo for selected item database");
|
|
|
|
// recover database name
|
|
String DatabaseName = element.getName();
|
|
|
|
// recover resource name
|
|
FileModel resource = store.getParent(element);
|
|
String ResourceName = resource.getName();
|
|
|
|
element.setResourceName(ResourceName);
|
|
element.setDatabaseName(DatabaseName);
|
|
// infoOnSelectedItem.put("ResourceName", ResourceNameSelected);
|
|
// infoOnSelectedItem.put("DatabaseName", DatabaseNameSelected);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// // get information about the selected item
|
|
// public LinkedHashMap<String, String> getInfoOnSelectedItem() {
|
|
//
|
|
// return infoOnSelectedItem;
|
|
// }
|
|
|
|
public TreePanel<FileModel> getTreePanel() {
|
|
return this.treePanel;
|
|
}
|
|
|
|
public TreeStore<FileModel> getTreeStore() {
|
|
return this.store;
|
|
}
|
|
|
|
}
|