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

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

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.util.ContainerUtils;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.gvsig.tools.util.PropertiesSupport;

import org.gvsig.tools.util.PropertiesSupportHelper;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author fdiaz

 */

public class TableInfo extends LabeledValueImpl<JDBCStoreParameters> implements PropertiesSupport {

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

    private final ListSelectionModel columnChecksModel;

    protected FeatureType featureType;

    protected int geomFieldSelected = -1;

    protected int idFieldSelected = -1;

    protected ComboBoxModel<String> idFieldComboModel;

    protected ComboBoxModel<String> geomFieldComboModel;

    protected List<FeatureAttributeDescriptor> attributeDescriptors;

    protected ListModel<LabeledValue<FeatureAttributeDescriptor>> columnsListModel;

    protected Expression filter;

    protected IProjection projection;

    protected boolean selected;

    protected String documentName;

    protected boolean isView;

    protected Boolean readOnly;

    protected boolean requireGeometry;

    protected PropertiesSupportHelper propertiesHelper;

    protected final String id;

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

        super(getLabelForTable(parameters), parameters.getCopy());

        this.id = id;

        this.columnChecksModel = new DefaultListSelectionModel();

        this.selected = false;

        this.documentName = parameters.getTable();

        this.projection = parameters.getCRS();

        this.isView = isView;

        this.readOnly = null;

        this.requireGeometry = requireGeometry;

        this.propertiesHelper = new PropertiesSupportHelper();

    }

    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.value = parameters.getCopy();

        this.projection = parameters.getCRS();

        this.setGeomFieldSelected(parameters.getDefaultGeometryField());

        if(StringUtils.isBlank(parameters.getBaseFilter())){

            this.filter = null;

        } else {

            this.filter = ExpressionUtils.createExpression(parameters.getBaseFilter());

        }

        if(StringUtils.isBlank(parameters.getPkFieldsString()) || StringUtils.contains(parameters.getPkFieldsString(), ',')){

            this.setIdFieldSelected(-1);

        } else {

            this.setIdFieldSelected(parameters.getPkFieldsString());

        }

        String[] fieldsArray = parameters.getFields();

        if(fieldsArray == null){

            this.columnChecksModel.setSelectionInterval(0, this.getColumnsListModel().getSize()-1);

        } else {

            ListModel<LabeledValue<FeatureAttributeDescriptor>> model = this.getColumnsListModel();

            List<String> fields = Arrays.asList(fieldsArray);

            this.columnChecksModel.clearSelection();

            for (int i = 0; i < model.getSize(); i++) {

                FeatureAttributeDescriptor attr = model.getElementAt(i).getValue();

                if(ContainerUtils.contains(fields, attr.getName(), ContainerUtils.EQUALS_IGNORECASE_COMPARATOR)) {

                    this.columnChecksModel.addSelectionInterval(i, i);

                }

            }

        }

    }

    public String getId() {

        return id;

    }

    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.fetchFromStore();

        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());

        }

        if(this.idFieldSelected >= 0){

            p.setPkFields(this.getFieldId());

        }

        p.setCRS(this.getProjection());

        p.setDefaultGeometryField(this.getGeomField());

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

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

        } 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.getIdFieldComboModel().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) {

            fetchFromStore();

        }

        return this.featureType;

    }

    protected void fetchFromStore() {

        DataManager dataManager = DALLocator.getDataManager();

        if (this.featureType != null) {

            return;

        }

        FeatureStore store = null;

        try {

            JDBCStoreParameters params = this.getValue();

            store = (FeatureStore) dataManager.openStore(params.getDataStoreName(), params);

            this.featureType = store.getDefaultFeatureType();

            FeatureAttributeDescriptor attr = this.featureType.getDefaultGeometryAttribute();

            if (attr != null) {

                GeometryType geomType = attr.getGeomType();

                if (geomType != null) {

                    if (this.getGeometryType() == Geometry.TYPES.UNKNOWN) {

                        this.setGeometryType(geomType.getType());

                    }

                    if (this.getGeometrySubtype() == Geometry.SUBTYPES.UNKNOWN) {

                        this.setGeometrySubtype(geomType.getSubType());

                    }

                }

                if (this.getProjection() == null) {

                    this.setProjection(attr.getSRS());

                }

            }

            if (this.readOnly == null) {

                this.readOnly = !store.allowWrite();

            }

            // this force calculate some required values of tableinfo

            this.getGeomFieldComboModel();

            this.getIdFieldComboModel();

        } catch (Exception ex) {

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

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    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<String> 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 setIdFieldSelected(String selected) {

        ComboBoxModel<String> model = getIdFieldComboModel();

        for (int i = 0; i < model.getSize(); i++) {

            if(StringUtils.equalsIgnoreCase(selected, model.getElementAt(i))){

                this.idFieldSelected = i;

                return;

            }

        }

        this.idFieldSelected = -1;

    }

    void setGeomFieldSelected(int selectedIndex) {

        this.geomFieldSelected = selectedIndex;

    }

    void setGeomFieldSelected(String selected) {

        ComboBoxModel<String> model = getGeomFieldComboModel();

        for (int i = 0; i < model.getSize(); i++) {

            if(StringUtils.equalsIgnoreCase(selected, model.getElementAt(i))){

                this.geomFieldSelected = i;

                return;

            }

        }

        this.geomFieldSelected = -1;

    }

    public boolean requireGeometry() {

        return requireGeometry;

    }

    public boolean hasValidValues() {

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

            return false;

        }

        if (this.requireGeometry()) {

            FeatureType featType = this.getFeatureType();

            if (StringUtils.isBlank(this.getGeomField())) {

                return false;

            }

            if (this.getGeometryType() == Geometry.TYPES.NULL || this.getGeometryType() == Geometry.TYPES.UNKNOWN) {

                return false;

            }

            if (this.getGeometrySubtype() == Geometry.SUBTYPES.UNKNOWN) {

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

            fetchFromStore();

        }

        return this.readOnly;

    }

    @Override

    public Object getProperty(String name) {

        return this.propertiesHelper.getProperty(name);

    }

    @Override

    public void setProperty(String name, Object value) {

        this.propertiesHelper.setProperty(name, value);

    }

    @Override

    public Map<String, Object> getProperties() {

        return this.propertiesHelper.getProperties();

    }

    protected JDBCServerExplorer getExplorer() throws DataException, ValidateDataParametersException {

        DataManager manager = DALLocator.getDataManager();

        JDBCStoreParameters storeParameters = getParameters();

        DataServerExplorerParameters explorerParameters = manager.createServerExplorerParameters(storeParameters.getProviderName());

        ToolsLocator.getDynObjectManager().copy(storeParameters, explorerParameters);

        DataServerExplorer explorer = manager.openServerExplorer(storeParameters.getProviderName(), explorerParameters);

        return (JDBCServerExplorer) explorer;

    }

    public boolean existsDALInfo() {

        try {

            JDBCStoreParameters storeParameters = getParameters();

            JDBCServerExplorer explorer = getExplorer();

            ResourcesStorage resources = explorer.getResourcesStorage(storeParameters);

            return resources.exists("dal");

        } catch (Exception ex) {

            //FIXME: LOGGER

            return false;

        }

    }

    public void removeDALInfo() {

        try {

            JDBCStoreParameters storeParameters = getParameters();

            JDBCServerExplorer explorer = getExplorer();

            ResourcesStorage resources = explorer.getResourcesStorage(storeParameters);

            if(resources.exists("dal")) {

                resources.remove("dal");

                JDBCStoreParameters params = (JDBCStoreParameters) explorer.get(storeParameters.getTable());

                this.value = params;

                this.featureType = null;

            }

            DisposeUtils.disposeQuietly(explorer);

        } catch (Exception ex) {

            throw new RuntimeException("Can't remove DAL resource.", ex);

        }

    }

    public int getGeometryType(){

        return this.getValue().getGeometryType();

    }

    public int getGeometrySubtype(){

        return this.getValue().getGeometrySubtype();

    }

    public void setGeometryType(int geomType){

        this.getValue().setGeometryType(geomType);

    }

    public void setGeometrySubtype(int geomSubtype){

        this.getValue().setGeometrySubtype(geomSubtype);

    }

}