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.io.IOException;

import java.util.List;

import java.util.Vector;

import org.cresques.cts.IProjection;

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

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

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

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

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

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

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;

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

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.remoteclient.ogc.OGCClientOperation;

import org.gvsig.remoteclient.wfs.WFSClient;

import org.gvsig.remoteclient.wfs.WFSFeature;

import org.gvsig.remoteclient.wfs.WFSStatus;

import org.gvsig.remoteclient.wfs.exceptions.WFSException;

import org.gvsig.remoteclient.wfs.filters.filterencoding.FilterEncoding;

import org.gvsig.remoteclient.wfs.schema.XMLElement;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.evaluator.EvaluatorFieldValue;

import org.gvsig.tools.evaluator.EvaluatorFieldValueMatch;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author vsanjaime

 */

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;

        private IProjection projection;

        boolean isFilterByAreaSupported = true;

        // WFS Parameters

        private WFSClient wfsClient;

        private WFSStatus wfsStatus;

        public ArcImsStoreProvider(DataStoreParameters params,

                        DataStoreProviderServices storeServices) throws InitializeException {

                super(params, storeServices, ToolsLocator.getDynObjectManager()

                                .createDynObject(DYNCLASS));

        }

        protected void retrieveFile() throws InitializeException {

                try {

                        ArcImsStoreParameters wfsParameters = getWFSParameters();

                        try {

                                if (wfsParameters.getVersion() == null) {

                                        wfsClient = new WFSClient(wfsParameters.getUrl());

                                        wfsParameters.setVersion(wfsClient.getVersion());

                                } else {

                                        wfsClient = new WFSClient(wfsParameters.getUrl(),

                                                        wfsParameters.getVersion());

                                }

                        } catch (IOException e) {

                                throw new InitializeException(e);

                        }

                        wfsStatus = new WFSStatus(wfsParameters.getFeatureType(),

                                        wfsParameters.getFeaturePrefix());

                        wfsStatus.setNamespace(wfsParameters.getFeatureNamespace());

                        wfsStatus.setFields(wfsParameters.getFields());

                        // wfsStatus.setFilterQuery(wfsParameters.getFilterEncoding());

                        wfsStatus.setTimeout(wfsParameters.getTimeOut());

                        wfsStatus.setBuffer(wfsParameters.getMaxFeatures());

                        wfsStatus.setUserName(wfsParameters.getUser());

                        wfsStatus.setPassword(wfsParameters.getPassword());

                        m_Fich = wfsClient.getFeature(wfsStatus, true, null);

                } catch (WFSException e) {

                        throw new InitializeException("Impossible to retrieve the file", e);

                }

        }

        private ArcImsStoreParameters getWFSParameters() {

                return (ArcImsStoreParameters) getParameters();

        }

        /*

         * (non-Javadoc)

         * 

         * @see org.gvsig.fmap.dal.store.gpe.GPEStoreProvider#open()

         */

        public void open() throws OpenException {

                super.open();

                try {

                        List featureTypes = this.getFeatureStore().getFeatureTypes();

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

                                FeatureType featureType = (FeatureType) featureTypes.get(i);

                        }

                } catch (DataException e) {

                        throw new OpenException("Reading the geometry type", e);

                }

        }

        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;

                }

        }

        /*

         * (non-Javadoc)

         * 

         * @see

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

         */

        public DataServerExplorer getExplorer() throws ReadException {

                DataManager manager = DALLocator.getDataManager();

                ArcImsServerExplorerParameters params;

                try {

                        params = (ArcImsServerExplorerParameters) manager

                                        .createServerExplorerParameters(ArcImsServerExplorer.NAME);

                        params.setUrl(wfsClient.getHost());

                        return manager.createServerExplorer(params);

                } catch (Exception e) {

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

                }

        }

        /*

         * (non-Javadoc)

         * 

         * @see org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider#getName()

         */

        public String getName() {

                return NAME;

        }

        /*

         * (non-Javadoc)

         * 

         * @see

         * org.gvsig.fmap.dal.store.gpe.GPEStoreProvider#createSet(org.gvsig.fmap

         * .dal.feature.FeatureQuery)

         */

        @Override

        public FeatureSetProvider createSet(FeatureQuery query)

                        throws DataException {

                return createSet(query, null);

        }

        /*

         * (non-Javadoc)

         * 

         * @see

         * org.gvsig.fmap.dal.store.gpe.GPEStoreProvider#createSet(org.gvsig.fmap

         * .dal.feature.FeatureQuery, org.gvsig.fmap.dal.feature.FeatureType)

         */

        @Override

        public FeatureSetProvider createSet(FeatureQuery query,

                        FeatureType featureType) throws DataException {

                // If it is possible to execute a spatial query...

                // if (!executeSpatialQuery(query)){

                executeQuery();

                // }

                isOpen = false;

                open();

                return super.createSet(query, featureType);

        }

        /**

         * It executes a wfs Query without spatial filter

         * 

         * @throws DataException

         */

        private void executeQuery() throws DataException {

                try {

                        wfsStatus.setResultType(WFSStatus.RESULTYPE_RESULTS);

                        m_Fich = wfsClient.getFeature(wfsStatus, true, null);

                } catch (WFSException e) {

                        throw new InitializeException("Impossible to retrieve the file", e);

                }

        }

        /**

         * Executes a new query sending the FilterEncoding request to the server

         * 

         * @param query

         *            The Query to send

         * @throws InitializeException

         *             If there is a problem with the request or the parsing process

         */

        private boolean executeSpatialQuery(FeatureQuery query)

                        throws DataException {

                EvaluatorFieldsInfo fieldsInfo = query.getFilter().getFieldsInfo();

                String[] fields = fieldsInfo.getFieldNames();

                for (int i = 0; i < fields.length; i++) {

                        EvaluatorFieldValue[] evaluatorFieldValues = fieldsInfo

                                        .getFieldValues(fields[i]);

                        for (int j = 0; j < evaluatorFieldValues.length; j++) {

                                if (EvaluatorFieldValue.MATCH == evaluatorFieldValues[j]

                                                .getType()) {

                                        EvaluatorFieldValueMatch evaluatorFieldValueMatch = (EvaluatorFieldValueMatch) evaluatorFieldValues[j];

                                        Object area = evaluatorFieldValueMatch.getValue();

                                        if (area instanceof Envelope) {

                                                executeSpatialQueryFromEnvelope(

                                                                evaluatorFieldValueMatch.getFieldName(),

                                                                (Envelope) area);

                                                return true;

                                        } else if (area instanceof Geometry) {

                                                executeSpatialQueryFromGeometry(

                                                                evaluatorFieldValueMatch.getFieldName(),

                                                                (Geometry) area);

                                                return true;

                                        }

                                }

                        }

                }

                return false;

        }

        private void executeSpatialQueryFromGeometry(String the_geom,

                        Geometry geometry) throws DataException {

                wfsStatus.setFilterByArea(geometry, the_geom, projection.getAbrev(),

                                FilterEncoding.GEOMETRIC_OPERATOR_CONTAINS);

                executeSpatialQuery();

        }

        private void executeSpatialQueryFromEnvelope(String the_geom,

                        Envelope envelope) throws DataException {

                wfsStatus.setFilterByArea(envelope, the_geom, projection.getAbrev(),

                                FilterEncoding.GEOMETRIC_OPERATOR_CONTAINS);

                executeSpatialQuery();

        }

        private void executeSpatialQuery() throws DataException {

                try {

                        wfsStatus.setProtocol(OGCClientOperation.PROTOCOL_POST);

                        // wfsStatus.setResultType(WFSStatus.RESULTYPE_HITS);

                        // wfsClient.getFeature(wfsStatus, true, null);

                        // WFSGetFeatureRequestInformation requestInformation =

                        // (WFSGetFeatureRequestInformation)wfsClient.getLastWfsRequestInformation();

                        // WFSServiceInformation serviceInformation =

                        // wfsClient.getServiceInformation();

                        // if (requestInformation.getNumberOfFeatures() != 0){

                        // //TODO DefaultMaxFeatures

                        // if (requestInformation.getNumberOfFeatures() ==

                        // wfsStatus.getBuffer()){

                        // //Divide the space in 4 rectangles

                        // WFSSpatialFilterOperation spatialFilterOperation =

                        // wfsStatus.getFilterByArea();

                        //                                        

                        // }

                        // }

                        // If it is not possible to calculate the

                        wfsStatus.setResultType(WFSStatus.RESULTYPE_RESULTS);

                        m_Fich = wfsClient.getFeature(wfsStatus, true, null);

                } catch (WFSException e) {

                        throw new InitializeException("Impossible to retrieve the file", e);

                }

        }

        public Object getSourceId() {

                StringBuffer sourceID = new StringBuffer(getWFSParameters().getUrl());

                sourceID.append("_" + getWFSParameters().getFeatureType());

                int hash = sourceID.hashCode();

                if (sourceID.length() > 60) {

                        return sourceID.substring(0, 60) + "_" + hash;

                } else {

                        return sourceID.toString() + "_" + hash;

                }

        }

        protected IProjection getSRS() {

                if (projection == null) {

                        try {

                                wfsClient.getCapabilities(wfsStatus, false, null);

                                wfsClient.describeFeatureType(wfsStatus, false, null);

                                WFSFeature feature = (WFSFeature) wfsClient.getFeatures().get(

                                                wfsStatus.getFeatureName());

                                if (feature.getSrs().size() > 0) {

                                        projection = CRSFactory.getCRS(getEPSGCode((String) feature

                                                        .getSrs().get(0)));

                                }

                        } catch (WFSException e) {

                                logger.error("Error retrieving the feature type");

                        }

                }

                return projection;

        }

        private String getEPSGCode(String srs) {

                if (srs == null) {

                        return null;

                }

                if (srs.startsWith("urn:x-ogc:def:crs:")) {

                        String newString = srs.substring(srs.lastIndexOf(":") + 1, srs

                                        .length());

                        if (srs.indexOf("EPSG") > 0) {

                                if (newString.indexOf("EPSG") < 0) {

                                        newString = "EPSG:" + newString;

                                }

                        }

                        return newString;

                }

                if (srs.toLowerCase().startsWith("crs:")) {

                        return srs.substring(4, srs.length());

                }

                return srs;

        }

        protected int getGeometryType() {

                WFSFeature feature = (WFSFeature) wfsClient.getFeatures().get(

                                wfsStatus.getFeatureName());

                Vector field = feature.getFields();

                if (field.size() > 0) {

                        XMLElement rootElement = (XMLElement) field.get(0);

                        Vector children = rootElement.getChildren();

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

                                XMLElement child = (XMLElement) children.get(i);

                                String type = child.getEntityType().getName();

                                if (type != null) {

                                        int index = type.indexOf(":");

                                        if (index > -1) {

                                                type = type.substring(index + 1);

                                        }

                                        Object obj = xmlSchemaManager

                                                        .getApplicationGeometryTypeByFormat("gml", type);

                                        if (obj != null) {

                                                return (Integer) obj;

                                        }

                                }

                        }

                }

                return TYPES.GEOMETRY;

        }

}