Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.geodb;

import java.util.ArrayList;

import java.util.List;

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 org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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.JDBCStoreParameters;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

/**

 *

 * @author fdiaz

 */

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;

    private boolean isView;

    private Boolean readOnly;

    private boolean requireGeometry;

    public TableInfo(JDBCStoreParameters parameters, boolean requireGeometry, boolean isView) {

        super(getLabelForTable(parameters), parameters);

        this.columnChecksModel = new DefaultListSelectionModel();

        this.selected = false;

        this.documentName = parameters.getTable();

        this.projection = parameters.getCRS();

        this.isView = isView;

        this.readOnly = null;

        this.requireGeometry = this.requireGeometry;

    }

    private static String getLabelForTable(JDBCStoreParameters parameters) {

        String schema = parameters.getSchema();

        String tableName = parameters.getTable();

        if (StringUtils.isBlank(schema)) {

            return tableName;

        }

        return schema + "." + tableName;

    }

    public void fetch(JDBCStoreParameters parameters) {

        this.projection = parameters.getCRS();

    }

    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) {

                AbstractWizardDB.LOGGER.trace("Can't get feature type.", ex); // To allow set break points

            }

        }

        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((FeatureAttributeDescriptor o1, FeatureAttributeDescriptor o2) -> 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;

    }

    void setIdFieldSelected(int selectedIndex) {

        this.idFieldSelected = selectedIndex;

    }

    void setGeomFieldSelected(int selectedIndex) {

        this.geomFieldSelected = selectedIndex;

    }

    public boolean requireGeometry() {

        return requireGeometry;

    }

    boolean hasValidValues() {

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

            return false;

        }

        JDBCStoreParameters p = this.getParameters();

        try {

            p.validate();

            return true;

        } catch (ValidateDataParametersException ex) {

            return false;

        }

    }

    public boolean isView() {

        return this.isView;

    }

    public boolean isReadOnly() {

        if (this.readOnly != null) {

            return this.readOnly;

        }

        JDBCStoreParameters params = this.getParameters();

        DataManager manager = DALLocator.getDataManager();

        FeatureStore store = null;

        try {

            store = (FeatureStore) manager.openStore(params.getProviderName(), params);

            this.readOnly = !store.allowWrite();

            return this.readOnly;

        } catch (Exception ex) {

            AbstractWizardDB.LOGGER.warn("Can't get if store allow write", ex);

            this.readOnly = false;

            return this.readOnly;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

}