Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2010 Prodevelop S.L. main development

 * http://www.prodevelop.es

 */

package org.gvsig.fmap.dal.store.arcims;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Vector;

import org.gvsig.fmap.crs.CRSFactory;

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultFeature;

import org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProvider;

import org.gvsig.fmap.dal.feature.spi.DefaultFeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;

import org.gvsig.fmap.dal.feature.spi.FeatureSetProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices;

import org.gvsig.fmap.dal.resource.file.FileResource;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.serverexplorer.arcims.ArcImsServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.arcims.ArcImsServerExplorerParameters;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.remoteclient.arcims.ArcImsClient;

import org.gvsig.remoteclient.arcims.ArcImsFeatureClient;

import org.gvsig.remoteclient.arcims.ArcImsProtFeatureHandler;

import org.gvsig.remoteclient.arcims.ArcImsStatus;

import org.gvsig.remoteclient.arcims.ArcImsVectStatus;

import org.gvsig.remoteclient.arcims.exceptions.ArcImsException;

import org.gvsig.remoteclient.arcims.utils.ArcImsFeature;

import org.gvsig.remoteclient.arcims.utils.FieldInformation;

import org.gvsig.remoteclient.arcims.utils.ServiceInformation;

import org.gvsig.remoteclient.arcims.utils.ServiceInformationLayerFeatures;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * ArcIMS datastore parameters

 * 

 * @author vsanjaime version 2.0

 * 

 */

public class ArcImsStoreProvider extends AbstractFeatureStoreProvider implements

                ResourceConsumer {

        private static final Logger logger = LoggerFactory

                        .getLogger(ArcImsStoreProvider.class);

        public static String NAME = "ArcIMSStore";

        public static String DESCRIPTION = "ArcIMS store to load ArcIMS resources";

        private static final String DYNCLASS_NAME = "ArcIMSStore";

        protected static DynClass DYNCLASS = null;

        // ArcIms Parameters

        private ArcImsClient arcimsClient;

        private ArcImsStatus arcimsStatus;

        private int numFeats = 0;

        protected boolean isOpen = false;

        private List<Feature> features = new ArrayList<Feature>();

        /**

         * Constructor

         * 

         * @param params

         * @param storeServices

         * @throws InitializeException

         */

        public ArcImsStoreProvider(DataStoreParameters params,

                        DataStoreProviderServices storeServices) throws InitializeException {

                super(params, storeServices, ToolsLocator.getDynObjectManager()

                                .createDynObject(DYNCLASS));

                // build status from parameters

                ArcImsStoreParameters pa = (ArcImsStoreParameters) params;

                arcimsClient = new ArcImsFeatureClient(pa.getServerUrl(), pa

                                .getServiceName());

                arcimsStatus = new ArcImsVectStatus();

                arcimsStatus.setLayersIdsSelected(pa.getSelectedLayers());

                arcimsStatus.setServiceInformation(pa.getServiceInfo());

                arcimsStatus.setSrs(pa.getSRS().getAbrev());

                arcimsStatus.setEnvelope(pa.getEnvelope());

                // initialize default feature type

                this.initDefaultFeatureType();

        }

        /**

         * 

         */

        protected static void registerDynClass() {

                DynObjectManager dynman = ToolsLocator.getDynObjectManager();

                DynClass dynClass;

                if (DYNCLASS == null) {

                        dynClass = dynman.add(DYNCLASS_NAME);

                        dynClass.extend(dynman.get(FeatureStore.DYNCLASS_NAME));

                        DYNCLASS = dynClass;

                }

        }

        /**

         * 

         */

        @Override

        protected FeatureProvider internalGetFeatureProviderByReference(

                        FeatureReferenceProviderServices reference, FeatureType featureType)

                        throws DataException {

                logger

                                .info("ArcImsStoreProvider: internalGetFeatureProviderByReference");

                return null;

        }

        /**

         * 

         */

        public boolean closeResourceRequested(ResourceProvider resource) {

                logger.info("ArcImsStoreProvider: closeResourceRequested");

                return false;

        }

        /**

         * 

         */

        public void resourceChanged(ResourceProvider resource) {

                logger.info("ArcImsStoreProvider: resourceChanged");

        }

        /**

         * 

         */

        public Object createNewOID() {

                logger.info("ArcImsStoreProvider: createNewOID");

                return null;

        }

        /**

         * 

         */

        public FeatureSetProvider createSet(FeatureQuery query,

                        FeatureType featureType) throws DataException {

                logger.info("ArcImsStoreProvider: createSet");

                // isOpen = false;

                open();

                return new ArcImsSetProvider(this, query);

        }

        /**

         * 

         */

        public long getFeatureCount() throws DataException {

                logger.info("ArcImsStoreProvider: getFeatureCount");

                return features.size();

        }

        /**

         * 

         */

        public String getName() {

                return NAME;

        }

        /**

         * 

         */

        public int getOIDType() {

                logger.info("ArcImsStoreProvider: getOIDType");

                return 0;

        }

        public ResourceProvider getResource() {

                logger.info("ArcImsStoreProvider: getResource");

                ResourceProvider res = null;

                try {

                        res = this.createResource(FileResource.NAME, new Object[] { "" });

                } catch (InitializeException e) {

                        e.printStackTrace();

                }

                return res;

        }

        public Object getSourceId() {

                logger.info("ArcImsStoreProvider: getSourceId");

                return arcimsClient.getHost();

        }

        public void open() throws OpenException {

                logger.info("ArcImsStoreProvider: open");

                if (isOpen) {

                        return;

                }

                this.numFeats = 0;

                FeatureStoreProviderServices store = (FeatureStoreProviderServices) this

                                .getFeatureStore();

                // add features to store

                List<List<ArcImsFeature>> feats = null;

                try {

                        feats = ((ArcImsProtFeatureHandler) arcimsClient.getHandler())

                                        .getMap((ArcImsVectStatus) arcimsStatus);

                } catch (ArcImsException e) {

                        logger.debug("Error getting the atributes", e);

                }

                if (feats != null && feats.size() > 0) {

                        // TODO Por ahora solo el primer elemento

                        List<ArcImsFeature> feats2 = feats.get(0);

                        for (ArcImsFeature aFeat : feats2) {

                                if (aFeat.isValid()) {

                                        try {

                                                this.addFeatureToStore((FeatureStore) store, aFeat);

                                                this.numFeats++;

                                        } catch (DataException e) {

                                                logger.error("Error adding feature", e);

                                                continue;

                                        }

                                }

                        }

                }

                isOpen = true;

        }

        /**

         * 

         * @param store

         * @param feature

         * @throws DataException

         */

        public void addFeatureToStore(FeatureStore store, ArcImsFeature feature)

                        throws DataException {

                if (store != null) {

                        FeatureType dfType = store.getDefaultFeatureType();

                        String pk = feature.getFieldPK();

                        Object opk = feature.get(pk);

                        FeatureProvider data = new DefaultFeatureProvider(dfType, opk);

                        data.setDefaultGeometry(feature.getGeometry());

                        Iterator<Map.Entry<String, Object>> it = feature.entrySet()

                                        .iterator();

                        while (it.hasNext()) {

                                Map.Entry<String, Object> entry = it.next();

                                String key = entry.getKey();

                                Object value = entry.getValue();

                                if (key.compareToIgnoreCase("#SHAPE#") != 0) {

                                        data.set(key, value);

                                }

                        }

                        Feature fe = ((FeatureStoreProviderServices) store)

                                        .createFeature(data);

                        DefaultFeature dfeat = (DefaultFeature) fe;

                        FeatureReference ref = dfeat.getReference();

                        features.add(fe);

                }

        }

        /**

         * 

         * @param params

         * @param layerId

         * @param status

         * @return

         */

        private FeatureType createFeatureType(ArcImsStoreParameters params,

                        String layerId, ArcImsStatus status) {

                logger.info("ArcImsStoreProvider: createFeatureType");

                EditableFeatureType eFType = ((FeatureStoreProviderServices) this

                                .getFeatureStore()).createFeatureType();

                ServiceInformation infoService = status.getServiceInfo();

                ServiceInformationLayerFeatures infoLayer = (ServiceInformationLayerFeatures) infoService

                                .getLayerById(layerId);

                Vector<FieldInformation> fieldsInfo = infoLayer.getFieldsInfo();

                for (FieldInformation fieldInfo : fieldsInfo) {

                        logger.info("Name: " + fieldInfo.getName() + " Type: "

                                        + fieldInfo.getType());

                        if (parseType(fieldInfo.getType()) == DataTypes.GEOMETRY) {

                                // TYPES.GEOMETRY

                                String geometryType = status.getServiceInfo().getType();

                                int geomType = TYPES.SURFACE;

                                if (geometryType.compareToIgnoreCase("line") == 0) {

                                        geomType = TYPES.CURVE;

                                }

                                if (geometryType.compareToIgnoreCase("point") == 0) {

                                        geomType = TYPES.POINT;

                                }

                                EditableFeatureAttributeDescriptor attributeDescriptor = eFType

                                                .add("geom", DataTypes.GEOMETRY).setGeometryType(

                                                                geomType);

                                attributeDescriptor.setGeometrySubType(SUBTYPES.GEOM2D);

                                attributeDescriptor.setSRS(CRSFactory.getCRS(arcimsStatus

                                                .getSrs()));

                                // attributeDescriptor.setIsPrimaryKey(true);

                                eFType.setDefaultGeometryAttributeName("geom");

                        } else {

                                eFType.add(fieldInfo.getName(), parseType(fieldInfo.getType()));

                                if (fieldInfo.getType() == -99) {

                                        int si = eFType.size();

                                        FeatureAttributeDescriptor attri = eFType

                                                        .getAttributeDescriptor(si - 1);

                                        ((EditableFeatureAttributeDescriptor) attri)

                                                        .setIsPrimaryKey(true);

                                        eFType.setHasOID(true);

                                }

                        }

                }

                return eFType.getNotEditableCopy();

        }

        /**

         * It executes a wfs Query without spatial filter

         * 

         * @throws DataException

         */

        private void executeQuery() throws DataException {

                logger.info("ArcImsStoreProvider: executeQuery");

        }

        /*

         * (non-Javadoc)

         * 

         * @see

         * org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProvider#getExplorer()

         */

        public DataServerExplorer getExplorer() throws ReadException {

                logger.info("ArcImsStoreProvider: getExplorer");

                DataManager manager = DALLocator.getDataManager();

                ArcImsServerExplorerParameters params;

                try {

                        params = (ArcImsServerExplorerParameters) manager

                                        .createServerExplorerParameters(ArcImsServerExplorer.NAME);

                        params.setUrl(arcimsClient.getHost());

                        params.setVersion(arcimsStatus.getServerVersion());

                        return manager.createServerExplorer(params);

                } catch (Exception e) {

                        throw new ReadException(this.getName(), e);

                }

        }

        /**

         * 

         */

        private void initDefaultFeatureType() {

                FeatureStoreProviderServices store = (FeatureStoreProviderServices) this

                                .getFeatureStore();

                // Add Feature type

                FeatureType defaultFType = this.createFeatureType(

                                getArcImsParameters(), arcimsStatus.getLayersIdsSelected().get(

                                                0), arcimsStatus);

                List<FeatureType> types = new ArrayList<FeatureType>(1);

                types.add(defaultFType);

                store.setFeatureTypes(types, defaultFType);

        }

        /**

         * Get number

         * 

         * @return

         */

        public int getNumFeats() {

                return numFeats;

        }

        /**

         * 

         * @return

         * @throws DataException

         */

        public HashMap getMapFeatures() throws DataException {

                HashMap feats = new HashMap();

                FeatureStore store = this.getFeatureStore();

                FeatureSelection sel = store.getFeatureSelection();

                sel.selectAll();

                Iterator<Feature> it = sel.iterator();

                int id = 0;

                while (it.hasNext()) {

                        Feature feat = it.next();

                        feats.put(id, feat);

                        id++;

                }

                return feats;

        }

        /**

         * Parse arcims attribute type to gvsig attribute type

         * 

         * @param arcimsType

         * @return

         */

        private int parseType(int arcimsType) {

                switch (arcimsType) {

                case FieldInformation.BOOLEAN:

                        return DataTypes.BOOLEAN;

                case FieldInformation.SHAPE:

                        return DataTypes.GEOMETRY;

                case FieldInformation.STRING:

                        return DataTypes.STRING;

                case FieldInformation.DATE:

                        return DataTypes.DATE;

                case FieldInformation.FLOAT:

                        return DataTypes.FLOAT;

                case FieldInformation.DOUBLE:

                        return DataTypes.DOUBLE;

                case FieldInformation.SMALLINT:

                        return DataTypes.INT;

                case FieldInformation.BIGINT:

                        return DataTypes.INT;

                case FieldInformation.ID:

                        return DataTypes.STRING;

                case FieldInformation.INTEGER:

                        return DataTypes.INT;

                default:

                        return DataTypes.UNKNOWN;

                }

        }

        /**

         * Get arcims parameters

         * 

         * @return

         */

        private ArcImsStoreParameters getArcImsParameters() {

                return (ArcImsStoreParameters) getParameters();

        }

        /**

         * 

         * @return

         */

        public List<Feature> getFeatures() {

                return features;

        }

}