Application: gvSIG desktop

package org.gvsig.geodb;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListModel;

import javax.swing.DefaultListSelectionModel;

import javax.swing.ListModel;

import javax.swing.ListSelectionModel;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.app.gui.WizardPanel;

import org.gvsig.app.prepareAction.PrepareContextView;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.expressionevaluator.swing.ExpressionPickerController;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

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

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

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

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.dal.swing.DataSwingManager;

import org.gvsig.fmap.dal.swing.dataStoreParameters.DataStoreParametersPanel;

import org.gvsig.fmap.dal.swing.dataStoreParameters.DataStoreParametersPanelManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

import org.gvsig.tools.swing.api.windowmanager.Dialog;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractWizardDB extends WizardPanel {

    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractWizardDB.class);

    protected class TableInfo extends LabeledValueImpl<JDBCStoreParameters> {

        private final ListSelectionModel columnChecksModel;

        private FeatureType featureType;

        private int geomFieldSelected = -1;

        private int idFieldSelected = -1;

        private ComboBoxModel<String> idFieldComboModel;

        private ComboBoxModel<String> geomFieldComboModel;

        private List<FeatureAttributeDescriptor> attributeDescriptors;

        private ListModel<LabeledValue<FeatureAttributeDescriptor>> columnsListModel;

        private Expression filter;

        private IProjection projection;

        private boolean selected;

        private String documentName;

        public TableInfo(JDBCStoreParameters parameters) {

            super(parameters.getTable(), parameters);

            this.columnChecksModel = new DefaultListSelectionModel();

            this.selected = false;

            this.documentName = parameters.getTable();

        }

        public String getDocumentName() {

            return this.documentName;

        }

        public void setDocumentName(String name) {

            this.documentName = name;

        }

        public boolean isSelected() {

            return selected;

        }

        public void setSelected(boolean selected) {

            this.selected = selected;

        }

        public ListSelectionModel getColumnChecksModel() {

            return this.columnChecksModel;

        }

        public JDBCStoreParameters getParameters() {

            JDBCStoreParameters p = this.getValue();

            StringBuilder fields = new StringBuilder();

            List<FeatureAttributeDescriptor> attributes = this.getAttributeDescriptors();

            boolean allSelected = true;

            for (int i = 0; i < attributes.size(); i++) {

                if (this.columnChecksModel.isSelectedIndex(i)) {

                    if (fields.length() > 0) {

                        fields.append(",");

                    }

                    fields.append(attributes.get(i).getName());

                } else {

                    allSelected = false;

                }

            }

            if( !allSelected ) {

                p.setFields(fields.toString());

            }

            p.setPkFields(this.getFieldId());

            p.setCRS(this.getProjection());

            p.setDefaultGeometryField(this.getGeomField());

            if (!ExpressionUtils.isEmpty(this.filter)) {

                p.setBaseFilter(this.filter.toString());

            } else {

                p.setBaseFilter(null);

            }

            return p;

        }

        public void setProjection(IProjection projection) {

            this.projection = projection;

        }

        public IProjection getProjection() {

            return projection;

        }

        public String getFieldId() {

            if (this.idFieldSelected < 0) {

                return null;

            }

            return this.idFieldComboModel.getElementAt(this.idFieldSelected);

        }

        public String getGeomField() {

            if (this.geomFieldSelected < 0) {

                return null;

            }

            return this.geomFieldComboModel.getElementAt(this.geomFieldSelected);

        }

        public FeatureType getFeatureType() {

            if (this.featureType == null) {

                DataManager dataManager = DALLocator.getDataManager();

                try {

                    JDBCStoreParameters params = this.getValue();

                    FeatureStore store = (FeatureStore) dataManager.openStore(

                            params.getDataStoreName(),

                            params

                    );

                    this.featureType = store.getDefaultFeatureType();

                } catch (Exception ex) {

                }

            }

            return this.featureType;

        }

        public ComboBoxModel getGeomFieldComboModel() {

            if (this.geomFieldComboModel == null) {

                DefaultComboBoxModel<String> geomModel = new DefaultComboBoxModel<>();

                geomModel.addElement(" ");

                int geomIndex = -1;

                int n = 1;

                for (FeatureAttributeDescriptor attr : this.getAttributeDescriptors()) {

                    if (geomIndex < 0 && attr.getType() == DataTypes.GEOMETRY) {

                        geomIndex = n;

                    }

                    int dataType = attr.getType();

                    if (dataType == DataTypes.GEOMETRY

                            || dataType == DataTypes.BYTEARRAY

                            || dataType == DataTypes.STRING) {

                        geomModel.addElement(attr.getName());

                        n++;

                    }

                }

                if (geomIndex < 0) {

                    geomIndex = 0;

                }

                this.geomFieldComboModel = geomModel;

                this.geomFieldSelected = geomIndex;

            }

            return this.geomFieldComboModel;

        }

        public int getGeomFieldSelected() {

            return this.geomFieldSelected;

        }

        public ComboBoxModel getIdFieldComboModel() {

            if (this.idFieldComboModel == null) {

                StringBuilder pkName = new StringBuilder();

                for (FeatureAttributeDescriptor attr : this.getAttributeDescriptors()) {

                    if (attr.isPrimaryKey()) {

                        if (!StringUtils.isBlank(pkName)) {

                            pkName.append(",");

                        }

                        pkName.append(attr.getName());

                    }

                }

                DefaultComboBoxModel<String> idsModel = new DefaultComboBoxModel<>();

                idsModel.addElement(" ");

                int idsIndex = -1;

                int n = 1;

                if (!StringUtils.isBlank(pkName) && StringUtils.contains(pkName, "/")) {

                    idsModel.addElement(pkName.toString());

                    idsIndex = n++;

                }

                for (FeatureAttributeDescriptor attr : getAttributeDescriptors()) {

                    if (idsIndex < 0 && attr.isPrimaryKey()) {

                        idsIndex = n;

                    }

                    idsModel.addElement(attr.getName());

                    n++;

                }

                if (idsIndex < 0) {

                    idsIndex = 0;

                }

                this.idFieldComboModel = idsModel;

                this.idFieldSelected = idsIndex;

            }

            return this.idFieldComboModel;

        }

        public List<FeatureAttributeDescriptor> getAttributeDescriptors() {

            if (this.attributeDescriptors == null) {

                List<FeatureAttributeDescriptor> attrs = new ArrayList<>();

                for (FeatureAttributeDescriptor attr : this.getFeatureType()) {

                    attrs.add(attr);

                }

                attrs.sort(new Comparator<FeatureAttributeDescriptor>() {

                    @Override

                    public int compare(FeatureAttributeDescriptor o1, FeatureAttributeDescriptor o2) {

                        return o1.getName().compareTo(o2.getName());

                    }

                });

                this.columnChecksModel.setSelectionInterval(0, attrs.size());

                this.attributeDescriptors = attrs;

            }

            return this.attributeDescriptors;

        }

        public ListModel<LabeledValue<FeatureAttributeDescriptor>> getColumnsListModel() {

            if (this.columnsListModel == null) {

                DefaultListModel<LabeledValue<FeatureAttributeDescriptor>> model = new DefaultListModel<>();

                for (FeatureAttributeDescriptor attr : this.getAttributeDescriptors()) {

                    model.addElement(new LabeledValueImpl<>(

                            attr.getName() + " [" + attr.getDataTypeName() + "]",

                            attr

                    )

                    );

                }

                this.columnsListModel = model;

            }

            return this.columnsListModel;

        }

        public FeatureAttributeDescriptor getAttributeDescriptor(String attrName) {

            return this.getFeatureType().getAttributeDescriptor(attrName);

        }

        public int getIdFieldSelected() {

            return this.idFieldSelected;

        }

        public Expression getFilter() {

            return this.filter;

        }

        public void setFilter(Expression filter) {

            this.filter = filter;

        }

        private void setIdFieldSelected(int selectedIndex) {

            this.idFieldSelected = selectedIndex;

        }

        private void setGeomFieldSelected(int selectedIndex) {

            this.geomFieldSelected = selectedIndex;

        }

        private boolean hasValidValues() {

            if (this.getGeomFieldSelected() < 0 && requireGeometry()) {

                return false;

            }

            JDBCStoreParameters p = this.getParameters();

            try {

                p.validate();

                return true;

            } catch (ValidateDataParametersException ex) {

                return false;

            }

        }

    }

    private AbstractWizardDBView view;

    private PickerController<JDBCServerExplorerParameters> pickerConnection;

    private PickerController<IProjection> pickerProjection;

    private ExpressionPickerController pickerFilter;

    private JListWithCheckbox lwcTables;

    private JListWithCheckbox lwcColumns;

    private Map<String, TableInfo> tablesInfo = null;

    public AbstractWizardDB() {

        initComponents();

    }

    private void initComponents() {

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();

        this.view = new AbstractWizardDBView();

        toolsSwingManager.translate(this.view.btnDeselectAllColumns);

        toolsSwingManager.translate(this.view.btnSelectAllColumns);

        toolsSwingManager.translate(this.view.lblColumns);

        toolsSwingManager.translate(this.view.lblConnection);

        toolsSwingManager.translate(this.view.lblFilter);

        toolsSwingManager.translate(this.view.lblGeometryField);

        toolsSwingManager.translate(this.view.lblIdField);

        toolsSwingManager.translate(this.view.lblName);

        toolsSwingManager.translate(this.view.lblProjection);

        toolsSwingManager.translate(this.view.lblTable);

        toolsSwingManager.addClearButton(this.view.txtName);

        toolsSwingManager.setDefaultPopupMenu(this.view.txtName);

        this.lwcTables = toolsSwingManager.createJListWithCheckbox(

                this.view.lstTables

        );

        this.lwcColumns = toolsSwingManager.createJListWithCheckbox(

                this.view.lstColumns

        );

        this.pickerConnection = dataSwingManager.createJDBCConnectionPickerController(

                this.view.cboConnection,

                this.view.btnConnection

        );

        this.pickerConnection.addChangeListener(new ChangeListener() {

            @Override

            public void stateChanged(ChangeEvent e) {

                doUpdateTables();

                setEditableTables(true);

            }

        });

        this.pickerProjection = dataSwingManager.createProjectionPickerController(

                this.view.txtProjection,

                this.view.btnProjection

        );

        this.pickerFilter = expressionSwingManager.createExpressionPickerController(

                this.view.txtFilter,

                this.view.btnFilter,

                this.view.btnFilterBookmarks,

                this.view.btnFilterHistory

        );

        this.lwcTables.addListSelectionListener(new ListSelectionListener() {

            @Override

            public void valueChanged(ListSelectionEvent e) {

                doChangeTableSelected();

            }

        });

        this.lwcTables.addChecksListener(new ListSelectionListener() {

            @Override

            public void valueChanged(ListSelectionEvent e) {

                doChangeTableSelected();

            }

        });

        this.view.cboGeometryField.addItemListener(new ItemListener() {

            @Override

            public void itemStateChanged(ItemEvent e) {

                if (e.getStateChange() == ItemEvent.SELECTED) {

                    doChangeGeometryField();

                }

            }

        });

        this.view.btnDeselectAllColumns.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doDeselectAllColumns();

            }

        });

        this.view.btnSelectAllColumns.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doSelectAllColumns();

            }

        });

        this.view.btnAdvancedProperties.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doShowAdvancedProperties();

            }

        });

        this.clearTables();

        this.setEditableTables(false);

        this.setLayout(new BorderLayout());

        this.add(this.view, BorderLayout.CENTER);

        this.setPreferredSize(new Dimension(500, 400));

    }

    protected abstract boolean requireGeometry();

    protected Collection<TableInfo> getTablesInformation() {

        if( this.tablesInfo == null ) {

            this.tablesInfo = new HashMap<>();

        }

        return this.tablesInfo.values();

    }

    private void doDeselectAllColumns() {

        TableInfo info = this.getCurrentTableInfo();

        if (info == null) {

            return;

        }

        info.getColumnChecksModel().clearSelection();

    }

    private void doSelectAllColumns() {

        TableInfo info = this.getCurrentTableInfo();

        if (info == null) {

            return;

        }

        info.getColumnChecksModel().setSelectionInterval(0, info.getAttributeDescriptors().size());

    }

    private void doShowAdvancedProperties() {

        final TableInfo info = this.getCurrentTableInfo();

        if (info == null) {

            return;

        }

        this.fetch(info);

        I18nManager i18n = ToolsLocator.getI18nManager();

        WindowManager_v2 winmgr = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

        DataStoreParametersPanelManager paramsPanelManager = DALSwingLocator.getDataStoreParametersPanelManager();

        final DataStoreParametersPanel panel = paramsPanelManager.createDataStoreParametersPanel(info.getParameters());

        final Dialog dialog = winmgr.createDialog(

                panel.asJComponent(),

                i18n.getTranslation("_Connection_parameters"),

                null, 

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        dialog.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                if( dialog.getAction()==WindowManager_v2.BUTTON_OK ) {

                    panel.fetchParameters(info.getParameters());

                }

            }

        });

        dialog.show(WindowManager.MODE.DIALOG);

    }

    private void clearTables() {

        this.lwcTables.setModel(new DefaultListModel());

        this.lwcTables.getCheckedModel().clearSelection();

        this.clearTableConfig();

    }

    private void clearTableConfig() {

        this.lwcColumns.setModel(new DefaultListModel());

        this.lwcColumns.getCheckedModel().clearSelection();

        this.view.txtName.setText("");

        this.view.cboGeometryField.setModel(new DefaultComboBoxModel());

        this.view.cboIdField.setModel(new DefaultComboBoxModel());

        this.pickerProjection.set(null);

        this.pickerFilter.set(null);

    }

    private void setEditableTables(boolean enable) {

        this.view.lstTables.setEnabled(enable);

        this.setEditableTableConfig(enable);

        this.view.btnDeselectAllColumns.setEnabled(enable);

        this.view.btnSelectAllColumns.setEnabled(enable);

    }

    private void setEditableTableConfig(boolean enable) {

        this.view.lstColumns.setEnabled(enable);

        this.view.txtName.setEditable(enable);

        this.view.cboGeometryField.setEnabled(enable);

        this.view.cboIdField.setEnabled(enable);

        this.pickerProjection.setEditable(enable);

        this.pickerFilter.setEditable(enable);

    }

    private TableInfo getCurrentTableInfo() {

        TableInfo xx = (TableInfo) this.view.lstTables.getSelectedValue();

        return xx;

    }

    private void doChangeGeometryField() {

        TableInfo info = this.getCurrentTableInfo();

        if (info == null) {

            return;

        }

        String attrName = (String) this.view.cboGeometryField.getSelectedItem();

        if (StringUtils.isBlank(attrName)) {

            return;

        }

        FeatureAttributeDescriptor attr = info.getAttributeDescriptor(attrName);

        IProjection srs = attr.getSRS();

        if (srs == null) {

            return;

        }

        this.pickerProjection.set(srs);

    }

    private void doUpdateTables() {

        JDBCServerExplorerParameters connection = this.pickerConnection.get();

        if (connection == null) {

            this.clearTables();

            return;

        }

        DataManager dataManager = DALLocator.getDataManager();

        try {

            DataServerExplorer explorer = dataManager.openServerExplorer(

                    connection.getDataStoreName(),

                    connection

            );

            List<TableInfo> parameters = new ArrayList<>();

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

                parameters.add(new TableInfo((JDBCStoreParameters) params));

            }

            parameters.sort(new Comparator<TableInfo>() {

                @Override

                public int compare(TableInfo o1, TableInfo o2) {

                    return o1.getDocumentName().compareTo(o2.getDocumentName());

                }

            });

            this.tablesInfo = new HashMap<>();

            DefaultListModel<TableInfo> model = new DefaultListModel<>();

            for (TableInfo x : parameters) {

                model.addElement(x);

                this.tablesInfo.put(x.getDocumentName(), x);

            }

            this.lwcTables.setModel(model);

            this.lwcTables.getCheckedModel().clearSelection();

        } catch (Exception ex) {

        }

    }

    private void doChangeTableSelected() {

        TableInfo tableInfo = (TableInfo) this.lwcTables.getSelectedValue();

        if (tableInfo == null) {

            this.clearTableConfig();

            this.setEditableTableConfig(false);

            return;

        }

        String previousTableName = this.view.txtName.getText();

        TableInfo previousInfo = this.tablesInfo.get(previousTableName);

        if (previousInfo != null) {

            this.fetch(previousInfo);

        }

        this.put(tableInfo);

        this.checkFinishable();

    }

    private void put(TableInfo tableInfo) {

        this.lwcColumns.setModel(tableInfo.getColumnsListModel());

        this.lwcColumns.setCheckedModel(tableInfo.getColumnChecksModel());

        this.view.cboGeometryField.setModel(tableInfo.getGeomFieldComboModel());

        this.view.cboGeometryField.setSelectedIndex(tableInfo.getGeomFieldSelected());

        this.view.cboIdField.setModel(tableInfo.getIdFieldComboModel());

        this.view.cboIdField.setSelectedIndex(tableInfo.getIdFieldSelected());

        this.pickerProjection.set(tableInfo.getProjection());

        this.pickerFilter.set(tableInfo.getFilter());

        this.view.txtName.setText(tableInfo.getDocumentName());

    }

    private void fetch(TableInfo tableInfo) {

        tableInfo.setIdFieldSelected(this.view.cboIdField.getSelectedIndex());

        tableInfo.setGeomFieldSelected(this.view.cboGeometryField.getSelectedIndex());

        tableInfo.setFilter(this.pickerFilter.get());

        tableInfo.setProjection(this.pickerProjection.get());

        tableInfo.setDocumentName(this.view.txtName.getText());

        int index = this.lwcTables.getSelectedIndex();

        tableInfo.setSelected(this.lwcTables.getCheckedModel().isSelectedIndex(index));

    }

    @Override

    public void initWizard() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        setTabName(i18n.getTranslation("_Database"));

    }

    @Override

    public boolean areSettingsValid() {

        boolean hasInvalidValues = false;

        boolean hasSelectedTables = false;

        for (TableInfo tableInfo : this.getTablesInformation() ) {

            if (tableInfo.isSelected()) {

                hasSelectedTables = true;

                if (!tableInfo.hasValidValues()) {

                    hasInvalidValues = true;

                }

            }

        }

        return hasSelectedTables && !hasInvalidValues;

    }

    @Override

    public DataStoreParameters[] getParameters() {

        int sz = 0;

        for (TableInfo tableInfo : this.getTablesInformation() ) {

            if( tableInfo.isSelected() ) {

                sz++;

            }

        }

        if( sz == 0 ) {

            return null;

        }

        DataStoreParameters[] dbParameters = new DataStoreParameters[sz];

        int n = 0;

        for (TableInfo tableInfo : this.getTablesInformation() ) {

            if( tableInfo.isSelected() ) {

                dbParameters[n++] = tableInfo.getParameters();

            }

        }

        return dbParameters;

    }

    @Override

    public void execute() {

        executeWizard();

    }

    @Override

    public void close() {

    }

    protected void checkFinishable() {

        boolean finishable = areSettingsValid();

        callStateChanged(finishable);

    }

}