Application: gvSIG desktop

package org.gvsig.geodb.databaseworkspace;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import javax.swing.DefaultListModel;

import javax.swing.JComponent;

import javax.swing.ListModel;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.tree.TreeModel;

import javax.swing.tree.TreePath;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.table.TableDocument;

import org.gvsig.app.project.documents.table.TableManager;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorer;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.operations.SingleLayer;

import org.gvsig.tools.swing.api.Component;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.ToolsSwingManager;

import org.gvsig.tools.swing.api.ToolsSwingUtils;

import org.gvsig.tools.swing.api.pickercontroller.PickerController;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class RepositoryAddTablePanel

        extends RepositoryAddTablePanelView

        implements Component {

    private static final Logger LOGGER = LoggerFactory.getLogger(RepositoryAddTablePanel.class);

    private static final int TAB_LAYERS = 0;

    private static final int TAB_TABLES = 1;

    private static final int TAB_DATABASETABLES = 2;

    private PickerController<JDBCServerExplorerParameters> connectionPicker;

    public RepositoryAddTablePanel() {

        this.initComponents();

    }

    private void initComponents() {

        ApplicationManager application = ApplicationLocator.getManager();

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        TreeModel layersModel = application.createProjectLayersTreeModel();

        this.treeLayers.setModel(layersModel);

        this.treeLayers.getSelectionModel().addTreeSelectionListener((TreeSelectionEvent e) -> {

            doUpdateTableName();

        });

        Project project = application.getCurrentProject();

        final List<Document> docs = project.getDocuments(TableManager.TYPENAME);

        if (docs != null) {

            DefaultListModel<LabeledValue<FeatureStore>> tablesModel = new DefaultListModel<>();

            for (Document doc : docs) {

                TableDocument table = (TableDocument) doc;

                tablesModel.addElement(

                        new LabeledValueImpl<>(table.getName(), table.getFeatureStore())

                );

            }

            this.lstTables.setModel(tablesModel);

            this.lstTables.addListSelectionListener((ListSelectionEvent e) -> {

                if (e.getValueIsAdjusting()) {

                    return;

                }

                doUpdateTableName();

            });

            toolsSwingManager.addClearButton(this.txtTableName);

            toolsSwingManager.setDefaultPopupMenu(this.txtTableName);

        }

        this.connectionPicker = DALSwingLocator.getSwingManager().createJDBCConnectionPickerController(

                this.cboConnections,

                this.btnAddConnection

        );

        this.connectionPicker.addChangeListener((ChangeEvent e) -> {

            doUpdateDatabaseTables();

        });

        this.lstDatabaseTables.addListSelectionListener((ListSelectionEvent e) -> {

            if (e.getValueIsAdjusting()) {

                return;

            }

            doUpdateTableName();

        });

        ToolsSwingUtils.ensureRowsCols(this, 20, 60, 25, 100);

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    private void doUpdateDatabaseTables() {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorerParameters explorerParams = this.connectionPicker.get();

            JDBCServerExplorer explorer = (JDBCServerExplorer) dataManager.openServerExplorer(explorerParams.getProviderName(), explorerParams);

            List<LabeledValue<JDBCStoreParameters>> tables = new ArrayList<>();

            for (DataStoreParameters dataStoreParameters : explorer.list()) {

                JDBCStoreParameters p = (JDBCStoreParameters) dataStoreParameters;

                tables.add(new LabeledValueImpl<>(p.getTable(), p));

            }

            Collections.sort(tables, new Comparator<LabeledValue<JDBCStoreParameters>>() {

                @Override

                public int compare(LabeledValue<JDBCStoreParameters> o1, LabeledValue<JDBCStoreParameters> o2) {

                    return StringUtils.compare(o1.getLabel(), o2.getLabel());

                }

            });

            DefaultListModel<LabeledValue<JDBCStoreParameters>> tablesModel = new DefaultListModel<>();

            for (LabeledValue<JDBCStoreParameters> table : tables) {

                tablesModel.addElement(table);

            }

            this.lstDatabaseTables.setModel(tablesModel);

        } catch (Exception ex) {

            LOGGER.warn("Can't update list of database tables.", ex);

        }

    }

    private void doUpdateTableName() {

        switch (this.tabStores.getSelectedIndex()) {

            case TAB_LAYERS:

                TreePath selected = this.treeLayers.getSelectionPath();

                FLayer layer = (FLayer) selected.getLastPathComponent();

                if (layer instanceof SingleLayer) {

                    this.txtTableName.setText(layer.getName());

                }

                break;

            case TAB_TABLES:

                int[] selecteds = this.lstTables.getSelectedIndices();

                if (selecteds.length > 1) {

                    this.txtTableName.setText("");

                    this.txtTableName.setEnabled(false);

                } else {

                    this.txtTableName.setEnabled(true);

                    LabeledValue<FeatureStore> item = (LabeledValue<FeatureStore>) this.lstTables.getSelectedValue();

                    if (item != null) {

                        this.txtTableName.setText(item.getLabel());

                    }

                }

                break;

            case TAB_DATABASETABLES:

                int[] dbselecteds = this.lstTables.getSelectedIndices();

                if (dbselecteds.length > 1) {

                    this.txtTableName.setText("");

                    this.txtTableName.setEnabled(false);

                } else {

                    this.txtTableName.setEnabled(true);

                    LabeledValue<JDBCStoreParameters> item = (LabeledValue<JDBCStoreParameters>) this.lstDatabaseTables.getSelectedValue();

                    if (item != null) {

                        this.txtTableName.setText(item.getLabel());

                    }

                }

                break;

            default:

                break;

        }

    }

    public List<LabeledValue<DataStoreParameters>> getDataStoreParameters() {

        switch (this.tabStores.getSelectedIndex()) {

            case TAB_LAYERS:

                TreePath selectedPath = this.treeLayers.getSelectionPath();

                FLayer layer = (FLayer) selectedPath.getLastPathComponent();

                if (layer instanceof SingleLayer) {

                    DataStore store = ((SingleLayer) layer).getDataStore();

                    DataStoreParameters params = store.getParameters();

                    return Collections.singletonList(new LabeledValueImpl<>(store.getName(), params));

                }

                return Collections.EMPTY_LIST;

            case TAB_TABLES:

                List<LabeledValue<DataStoreParameters>> parameters = new ArrayList<>();

                ListModel<LabeledValue<FeatureStore>> tablesModel = this.lstTables.getModel();

                int[] selectedsTables = this.lstTables.getSelectedIndices();

                for (int selected : selectedsTables) {

                    LabeledValue<FeatureStore> selectedTable = tablesModel.getElementAt(selected);

                    parameters.add(new LabeledValueImpl<>(selectedTable.getLabel(), selectedTable.getValue().getParameters()));

                }

                return parameters;

            case TAB_DATABASETABLES:

                List<LabeledValue<DataStoreParameters>> dbparameters = new ArrayList<>();

                ListModel<LabeledValue<JDBCStoreParameters>> dbtablesModel = this.lstDatabaseTables.getModel();

                int[] dbselectedsTables = this.lstDatabaseTables.getSelectedIndices();

                for (int selected : dbselectedsTables) {

                    LabeledValue<JDBCStoreParameters> selectedTable = dbtablesModel.getElementAt(selected);

                    dbparameters.add(new LabeledValueImpl<>(selectedTable.getLabel(), selectedTable.getValue()));

                }

                return dbparameters;

            default:

                return Collections.EMPTY_LIST;

        }

    }

}