Application: gvSIG desktop » gvSIG data provider for WFS

/* 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):

 * 2009 {Iver T.I.}   {Task}

 */

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

import java.awt.geom.AffineTransform;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.cresques.cts.ICoordTrans;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.wfs.WFSServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.wfs.WFSServerExplorerParameters;

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

import org.gvsig.fmap.dal.store.gpe.GPEStoreProvider;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

import org.gvsig.gpe.lib.api.exceptions.WriterHandlerCreationException;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.remoteclient.ogc.OGCClientOperation;

import org.gvsig.remoteclient.utils.BoundaryBox;

import org.gvsig.remoteclient.wfs.WFSClient;

import org.gvsig.remoteclient.wfs.WFSFeature;

import org.gvsig.remoteclient.wfs.WFSFeatureField;

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.request.WFSGetFeatureRequestInformation;

import org.gvsig.remoteclient.wfs.request.WFSTransactionRequestInformation;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.evaluator.EvaluatorFieldValue;

import org.gvsig.tools.evaluator.EvaluatorFieldValueMatch;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

import org.gvsig.xmlschema.lib.api.XMLSchemaLocator;

import org.gvsig.xmlschema.lib.api.XMLSchemaManager;

import org.gvsig.xmlschema.lib.api.som.IXSGeometryTypeDefinition;

import org.gvsig.xmlschema.lib.api.som.IXSTypeDefinition;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public class WFSStoreProvider extends AbstractFeatureStoreProvider {

    private static final Logger logger = LoggerFactory.getLogger(WFSStoreProvider.class);

    public static String NAME = "WFSStore";

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

    private static final MetadataManager metadataManager = MetadataLocator.getMetadataManager();

    private static final String METADATA_DEFINITION_NAME = "WFSStore";

    private static final String METADATA_DEFINITION_DESCRIPTION = "WFSStore metadata definition";

    // private IProjection projection;

    private long featureCount = -1;

    private boolean isKnownEnvelope = false;

    /**

     * If the user has selected the filter by area option

     */

    private boolean hasFilterByArea = false;

    /**

     * GML provider used by delegation to read the GML files

     */

    private GPEStoreProvider storeProviderDelegate = null;

    private static final DataManager dataManager = DALLocator.getDataManager();

    private static final XMLSchemaManager xmlSchemaManager = XMLSchemaLocator.getXMLSchemaManager();

    boolean isFilterByAreaSupported = true;

    //WFS Parameters

    private WFSClient wfsClient;

    private WFSStatus wfsStatus;

    public WFSStoreProvider(DataStoreParameters params,

        DataStoreProviderServices storeServices)

    throws InitializeException {

        super(params, storeServices,

            ToolsLocator.getDynObjectManager().createDynObject(metadataManager.getDefinition(METADATA_DEFINITION_NAME)));

        initParams();

        try {

            initFeatureType();

        } catch (WFSException e) {

            throw new InitializeException(e);

        } catch (ReadException e) {

            throw new InitializeException(e);

        }

    }

    private void initParams() throws InitializeException{

        try {

            WFSStoreParameters wfsParameters = getWFSParameters();

            try {

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

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

                    wfsParameters.setVersion(wfsClient.getVersion());

                }else{

                    wfsClient = new WFSClient(wfsParameters.getUrl(), wfsParameters.getVersion(), wfsParameters.getIgnoreCache());

                }

            } catch (IOException e) {

                throw new InitializeException(e);

            }

            wfsStatus = new WFSStatus( wfsParameters.getFeatureType(),

                wfsParameters.getFeatureNamespace());

            wfsStatus.setNamespacePrefix(wfsParameters.getFeaturePrefix());

            wfsStatus.setFields(wfsParameters.getFields());

            //Select the filter by area

            Geometry filterByAreaGeometry = wfsParameters.getFilterByAreaGeometry();

            Envelope filterByAreaEnvelope = wfsParameters.getFilterByAreaEnvelope();

            if (filterByAreaGeometry != null){

                        wfsStatus.setFilterByArea(filterByAreaGeometry, wfsParameters.getFilterByAreaAttribute(),

                wfsParameters.getFilterByAreaCrs(), wfsParameters.getFilterByAreaOperation());

            } else if (filterByAreaEnvelope != null) {

                        wfsStatus.setFilterByArea(filterByAreaEnvelope, wfsParameters.getFilterByAreaAttribute(),

                    wfsParameters.getFilterByAreaCrs(), wfsParameters.getFilterByAreaOperation());

            }

            this.hasFilterByArea = (wfsStatus.getFilterByArea() != null);

            //Select the filter by attribute

            wfsStatus.setFilterByAttribute(wfsParameters.getFilterEncodingByAttribute());

            String _srs = wfsParameters.getFilterByAreaCrs();

            wfsStatus.setSrs(_srs);

            wfsStatus.setTimeout(wfsParameters.getTimeOut());

            wfsStatus.setMaxFeatures(wfsParameters.getMaxFeatures());

            wfsStatus.setUserName(wfsParameters.getUser());

            wfsStatus.setPassword(wfsParameters.getPassword());

            //Setting the envelope for the layer

            wfsClient.getCapabilities(wfsStatus, false, null);

            Envelope envelope = calculateFullEnvelope();

            if (envelope != null){

                this.setDynValue("Envelope", envelope);

                isKnownEnvelope = true;

            }

        } catch (WFSException e) {

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

        }

    }

    private WFSFeature getSelectedWFSFeature() throws ReadException, WFSException{

        WFSStoreParameters wfsParameters = getWFSParameters();

        return  ((WFSServerExplorer)getExplorer()).getFeatureInfo(wfsParameters.getFeatureNamespace(),

            wfsParameters.getFeatureType());

    }

    private void initFeatureType() throws WFSException, ReadException{

        WFSFeature feature  = getSelectedWFSFeature();

        if (feature == null){

            //TODO read from GML

            throw new WFSException("It is not possible to parse the schema");

        }

        IProjection ipro = null;

        try {

            ipro = CRSFactory.getCRS(wfsStatus.getSrs());

            this.setDynValue("CRS", ipro);

        } catch (Exception ex) {

            logger.info("Error: did not set CRS in store provider.", ex);

        }

        EditableFeatureType featureType = getStoreServices().createFeatureType();

        for (int i=0 ; i<feature.getFieldSize() ; i++){

            WFSFeatureField featureField = feature.getFieldAt(i);

            int dataType = DataTypes.STRING;

            String typeName = featureField.getType();

            EditableFeatureAttributeDescriptor attributeDescriptor = null;

            IXSTypeDefinition typeDefinition = null;

            if (typeName != null){

                typeDefinition = xmlSchemaManager.getTypeDefinition(typeName);

            }

            if (typeDefinition != null){

                if (typeDefinition.getDataType() != null){

                    if (typeDefinition.getDataType().getType() == DataTypes.GEOMETRY){

                        dataType = typeDefinition.getDataType().getType();

                    }

                }

                attributeDescriptor = featureType.add(featureField.getName(), dataType);

                if (typeDefinition instanceof IXSGeometryTypeDefinition){

                    if (ipro != null) {

                        attributeDescriptor.setSRS(ipro);

                    } else {

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

                            attributeDescriptor.setSRS(CRSFactory.getCRS((String)feature.getSrs().get(0)));

                        } else {

                            logger.info("Unable to set CRS in feature type.");

                        }

                    }

                    attributeDescriptor.setGeometryType(((IXSGeometryTypeDefinition)typeDefinition).getGeometryType());

                    attributeDescriptor.setGeometrySubType(SUBTYPES.GEOM3D);

                    featureType.setDefaultGeometryAttributeName(featureField.getName());

                }

            }else{

                attributeDescriptor = featureType.add(typeName, dataType);

            }

            // length, relevant for all (strings) except geometry

            attributeDescriptor.setSize(128);

        }

        featureType.setHasOID(true);

        FeatureType defaultType = featureType.getNotEditableCopy();

        List types = new ArrayList(1);

        types.add(defaultType);

        this.getStoreServices().setFeatureTypes(types, defaultType);

    }

    private Envelope calculateFullEnvelope() {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        try{

            WFSFeature feature  = getSelectedWFSFeature();

            if (feature != null){

                String _srs = wfsStatus.getSrs();

                if (_srs != null) {

                    BoundaryBox boundaryBox = feature.getBbox(_srs);

                    //The projection is found

                    if (boundaryBox != null){

                        return geometryManager.createEnvelope(boundaryBox.getXmin(),

                            boundaryBox.getYmin(), boundaryBox.getXmax(), boundaryBox.getYmax(), SUBTYPES.GEOM2D);

                    }

                    //Check if there is a latlon envelope

                    boundaryBox = feature.getLatLonBbox();

                    if (boundaryBox != null){

                        Envelope envelope = geometryManager.createEnvelope(boundaryBox.getXmin(),

                            boundaryBox.getYmin(), boundaryBox.getXmax(), boundaryBox.getYmax(), SUBTYPES.GEOM2D);

                        if (!"EPSG:4326".equals(_srs)){

                            IProjection sourceProjection = CRSFactory.getCRS("EPSG:4326");

                            IProjection destinationProjection = CRSFactory.getCRS(_srs);

                            if (destinationProjection != null){

                                ICoordTrans coordTrans = sourceProjection.getCT(destinationProjection);

                                return envelope.convert(coordTrans);

                            }

                        }

                    }

                }else{

                    //If there is not a SRS is thrown a request for the first 500 features

                    int odlMaxFeatures = wfsStatus.getMaxFeatures();

                    wfsStatus.setMaxFeatures(500);

                    createSet(null, null);

                    return storeProviderDelegate.getEnvelope();

                }

            }

        }catch(CreateEnvelopeException e){

            logger.error("Impossible to create an envelope", e);

        } catch (ReadException e) {

            logger.error("Impossible to create an envelope", e);

        } catch (WFSException e) {

            logger.error("Impossible to create an envelope", e);

        } catch (DataException e) {

            logger.error("Impossible to create an envelope", e);

        }

        return null;

    }

    private WFSStoreParameters getWFSParameters() {

        return (WFSStoreParameters) getParameters();

    }

    /* (non-Javadoc)

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

     */

    public void open() throws OpenException {

        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 registerMetadataDefinition() throws MetadataException {

        if (metadataManager.getDefinition(METADATA_DEFINITION_NAME) == null) {

            DynStruct metadataDefinition = metadataManager.addDefinition(

                METADATA_DEFINITION_NAME, METADATA_DEFINITION_DESCRIPTION);

            metadataDefinition.addDynFieldObject("Envelope").setClassOfValue(Envelope.class).setMandatory(false);

            metadataDefinition.addDynFieldObject("CRS").setClassOfValue(IProjection.class).setMandatory(true);

            metadataDefinition.extend(metadataManager

                .getDefinition(FeatureStore.METADATA_DEFINITION_NAME));

        }

    }

    /* (non-Javadoc)

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

     */

    public DataServerExplorer getExplorer() throws ReadException {

        DataManager manager = DALLocator.getDataManager();

        WFSServerExplorerParameters params;

        try {

            params = (WFSServerExplorerParameters) manager

            .createServerExplorerParameters(WFSServerExplorer.NAME);

            params.setUrl(wfsClient.getHost());

            return manager.openServerExplorer(WFSServerExplorer.NAME,params);

        } catch (Exception e) {

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

        }

    }

    public String getProviderName() {

        return NAME;

    }

    public FeatureSetProvider createSet(FeatureQuery query)

    throws DataException {

        return createSet(query, null);

    }

    public FeatureSetProvider createSet(FeatureQuery query,

        FeatureType featureType) throws DataException {

        if ((featureCount == -1) ||

            (storeProviderDelegate == null) ||

            (featureCount >= wfsStatus.getMaxFeatures())){

            File file = executeSpatialQuery();

            storeProviderDelegate = createProvider(file);

        }

        return storeProviderDelegate.createSet(query, featureType);

    }

    /**

     * It creates the provider that is used to retrieve features from a file.

     * @param file

     * the file that contains the downloaded file

     * @return

     * @throws InitializeException

     * @throws ProviderNotRegisteredException

     */

    private GPEStoreProvider createProvider(File file) throws InitializeException, ProviderNotRegisteredException{

        return new GPEStoreProvider(createStoreParameters(file), getStoreServices());

    }

    private DataStoreParameters createStoreParameters(File file) throws InitializeException, ProviderNotRegisteredException{

        DataStoreParameters parameters = dataManager.createStoreParameters(GPEStoreProvider.NAME);

        parameters.setDynValue("File", file.getAbsolutePath());

        parameters.setDynValue("Envelope", this.getDynValue("Envelope"));

        parameters.setDynValue("useAxisOrderYX", this.getWFSParameters().getUseAxisOrderYX());

        return parameters;

    }

    private File executeSpatialQuery() throws DataException{

        try {

                Envelope filterByAreaEnvelope = getWFSParameters().getFilterByAreaEnvelope();

                Geometry filterByAreaGeometry = getWFSParameters().getFilterByAreaGeometry();

                        if (filterByAreaEnvelope!=null){

                                String crs = getWFSParameters().getFilterByAreaCrs();

                                String the_geom = getWFSParameters().getFilterByAreaAttribute();

                                int operator = getWFSParameters().getFilterByAreaOperation();

                                if (this.getWFSParameters().getUseAxisOrderYX()){

                            Envelope envelope = null;

                                        try {

                                                envelope = (Envelope)filterByAreaEnvelope.clone();

                                        } catch (CloneNotSupportedException e) {

                                                //Do nothing

                                        }

                                        double x = envelope.getLowerCorner().getX();

                                        envelope.getLowerCorner().setX(envelope.getLowerCorner().getY());

                                        envelope.getLowerCorner().setY(x);

                                        x = envelope.getUpperCorner().getX();

                                        envelope.getUpperCorner().setX(envelope.getUpperCorner().getY());

                                        envelope.getUpperCorner().setY(x);

                                        filterByAreaEnvelope = envelope;

                    }

                        wfsStatus.setFilterByArea(filterByAreaEnvelope, the_geom, crs,operator);

                } else if (filterByAreaGeometry!=null){

                                    String crs = getWFSParameters().getFilterByAreaCrs();

                                    String the_geom = getWFSParameters().getFilterByAreaAttribute();

                                    int operator = getWFSParameters().getFilterByAreaOperation();

                                    if (this.getWFSParameters().getUseAxisOrderYX()){

                                    Geometry geom = filterByAreaGeometry.cloneGeometry();

                                                        AffineTransform at = new AffineTransform(0,1,1,0,0,1);

                                                        geom.transform(at);

                                                        filterByAreaGeometry = geom;

                                    }

                            wfsStatus.setFilterByArea(filterByAreaGeometry, the_geom, crs,operator);

                }

            wfsStatus.setProtocol(OGCClientOperation.PROTOCOL_POST);

            //If it is not possible to calculate the

            wfsStatus.setResultType(WFSStatus.RESULTYPE_RESULTS);

            return wfsClient.getFeature(wfsStatus, getWFSParameters().getIgnoreCache(), 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;

        }

    }

    public Object createNewOID() {

        try {

            return String.valueOf(getFeatureCount()+1);

        } catch (DataException e) {

            return String.valueOf(Math.random());

        }

    }

    public long getFeatureCount() throws DataException {

        if (featureCount == -1){

            wfsStatus.setResultType(WFSStatus.RESULTYPE_HITS);

            try {

                //The filter encoding is better supported using POST

                if (hasFilterByArea){

                    wfsStatus.setProtocol(OGCClientOperation.PROTOCOL_POST);

                }else{

                    wfsStatus.setProtocol(OGCClientOperation.PROTOCOL_GET);

                }

                File file = wfsClient.getFeature(wfsStatus, getWFSParameters().getIgnoreCache(), null);

                featureCount = ((WFSGetFeatureRequestInformation)wfsClient.getLastWfsRequestInformation()).getNumberOfFeatures();

                //If the service doesn't support RESULTTYPE_HITS, parse the file and get the FeatureCount

                if (featureCount == -1){

                    storeProviderDelegate = createProvider(file);

                    featureCount = storeProviderDelegate.getFeatureCount();

                }

            } catch (WFSException e) {

                throw new ConnectionServerException("Error calculating the feature count", e);

            }

        }

        return featureCount;

    }

    public int getOIDType() {

        return DataTypes.STRING;

    }

    public ResourceProvider getResource() {

        return storeProviderDelegate.getResource();

    }

    protected FeatureProvider internalGetFeatureProviderByReference(

        FeatureReferenceProviderServices reference, FeatureType featureType)

    throws DataException {

        return storeProviderDelegate.internalGetFeatureProviderByReference(reference, featureType);

    }

    public String getFullName() {

        return getWFSParameters().getUrl() + "_" + getWFSParameters().getFeatureType();

    }

    public String getName() {

        return getWFSParameters().getFeatureType();

    }

    public boolean isKnownEnvelope(){

        return isKnownEnvelope;

    }

    public boolean hasRetrievedFeaturesLimit(){

        return true;

    }

    public int getRetrievedFeaturesLimit(){

        //WFS 1.0.0 can not know where is the limit

        if (getWFSParameters().getVersion().equals("1.0.0")){

            return 0;

        }else{

            return wfsClient.getServiceInformation().getMaxFeatures();

        }

    }

    public void performChanges(Iterator deleteds, Iterator inserteds,

        Iterator updateds, Iterator featureTypesChanged)

    throws DataException {

        wfsStatus.setProtocol(OGCClientOperation.PROTOCOL_POST);

        WFSTTransactionBuilder transactionBuilder = new WFSTTransactionBuilder(wfsStatus, wfsClient);

        //Create the Query

        try {

            //Add new features

            while (inserteds.hasNext()){

                transactionBuilder.addInsertFeature((FeatureProvider)inserteds.next());

            }

            //Add deleted features

            while (deleteds.hasNext()){

                transactionBuilder.addDeleteFeature(

                    internalGetFeatureProviderByReference((FeatureReferenceProviderServices)deleteds.next(), null).getOID().toString());;

            }

            //Add updated features

            while (updateds.hasNext()){

                transactionBuilder.addUpdateFeature((FeatureProvider)updateds.next());

            }

        } catch (WriterHandlerCreationException e) {

            throw new WFSTTRansactionException(e);

        } catch (GeometryOperationNotSupportedException e) {

            throw new WFSTTRansactionException(e);

        } catch (GeometryOperationException e) {

            throw new WFSTTRansactionException(e);

        }

        //Send the query to the server

        try {

            wfsClient.transaction(wfsStatus, true, null);

            WFSTransactionRequestInformation transactionRequestInformation =  (WFSTransactionRequestInformation)wfsClient.getLastWfsRequestInformation();

            if (transactionRequestInformation.getStatus() == WFSTransactionRequestInformation.STATUS_FAILED){

                throw new WFSTTRansactionException(transactionRequestInformation.getMessage());

            }

        } catch (WFSException e) {

            throw new WFSTTRansactionException(e);

        }

    }

    public boolean allowWrite() {

        return wfsClient.getServiceInformation().isOperationSupported("Transaction");

    }

    public Envelope getEnvelope() throws DataException {

        return (Envelope) this.getDynValue("Envelope");

    }

    public FeatureProvider createFeatureProvider(FeatureType type)

    throws DataException {

        return super.createFeatureProvider(type);

    }

}