Application: gvSIG desktop

import java.io.File;

import java.util.ArrayList;

import java.util.Iterator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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.resource.spi.ResourceProvider;

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

import org.gvsig.remoteclient.wfs.WFSFeatureField;

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

import org.gvsig.tools.dataTypes.DataTypesManager;

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;

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 int featureCount = -1;

    private boolean isKnownEnvelope = 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 DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

    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.setVersion(wfsClient.getVersion());

                }else{

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

                }

            } catch (IOException e) {

                throw new InitializeException(e);

            }

            wfsStatus = new WFSStatus( wfsParameters.getFeatureType(),

                wfsParameters.getFeatureNamespace());

            wfsStatus.setNamespacePrefix(wfsParameters.getFeaturePrefix());

            wfsStatus.setFields(wfsParameters.getFields());

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

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

        }

        projection = CRSFactory.getCRS(getEPSGCode(feature.getDefaultSRS()));

        this.setDynValue("CRS", projection);

        EditableFeatureType featureType = getStoreServices().createFeatureType();

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

            WFSFeatureField featureField = feature.getFieldAt(i);           

            int dataType = DataTypes.OBJECT;               

            String typeName = featureField.getType();

            EditableFeatureAttributeDescriptor attributeDescriptor = null;

            IXSTypeDefinition typeDefinition = xmlSchemaManager.getTypeDefinition(typeName);

            if (typeDefinition != null){             

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

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

                }

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

                if (typeDefinition instanceof IXSGeometryTypeDefinition){

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

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

                    }                    

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

                    attributeDescriptor.setGeometrySubType(SUBTYPES.GEOM2D);

                    featureType.setDefaultGeometryAttributeName(featureField.getName());

                }                               

            }else{

                attributeDescriptor = featureType.add(typeName, dataType);    

            }                 

        }

        featureType.add("gid", DataTypes.LONG);

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

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

                    String srs = feature.getDefaultSRS();                  

                    BoundaryBox boundaryBox = feature.getBbox(srs);

                    if (boundaryBox == null)

                    {

                        boundaryBox = feature.getBbox(getEPSGCode(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);

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

                        IProjection destinationProjection = CRSFactory.getCRS(getEPSGCode(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);

        }

    }

    /* (non-Javadoc)

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

     */

    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 {

        File file = null;

        if (query == null){

            file = executeQuery();   

        }else{

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

            if (query.getFilter() != null){

                file = executeSpatialQuery(query);

            }else{

                file = executeQuery();   

            }	

        }

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

        return parameters;

    }

    /**

     * It executes a wfs Query without spatial filter

     * @throws DataException

     */

    private File executeQuery() throws DataException{

        try{

            wfsStatus.setResultType(WFSStatus.RESULTYPE_RESULTS);

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

                        return executeSpatialQueryFromEnvelope(evaluatorFieldValueMatch.getFieldName(),

                            (Envelope)area);					

                    }else if (area instanceof Geometry){

                        return executeSpatialQueryFromGeometry(evaluatorFieldValueMatch.getFieldName(),

                            (Geometry)area);						

                    }

                }

            }			

        }

        return null;

    }

    private File executeSpatialQueryFromGeometry(String the_geom, Geometry geometry) throws DataException{

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

            FilterEncoding.GEOMETRIC_OPERATOR_CONTAINS);

        return executeSpatialQuery();

    }

    private File executeSpatialQueryFromEnvelope(String the_geom, Envelope envelope) throws DataException{

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

            FilterEncoding.GEOMETRIC_OPERATOR_CONTAINS);		

        return executeSpatialQuery();

    }

    private File executeSpatialQuery() throws DataException{

        try {

            wfsStatus.setProtocol(OGCClientOperation.PROTOCOL_POST);

            //If it is not possible to calculate the 

            wfsStatus.setResultType(WFSStatus.RESULTYPE_RESULTS);

            return 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;

        }

    }

    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;

    }		

    public Object createNewOID() {

        // TODO Auto-generated method stub

        return null;

    }

    public long getFeatureCount() throws DataException {

        if (featureCount == -1){

            wfsStatus.setResultType(WFSStatus.RESULTYPE_HITS);

            try {

                wfsClient.getFeature(wfsStatus, true, null);

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

            } catch (WFSException e) {

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

            }

        }

        return featureCount;

    }

    public int getOIDType() {

        // TODO Auto-generated method stub

        return 0;

    }

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

    }

    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 {

        // FIXME exception

        throw new UnsupportedOperationException();

    }

    public boolean allowWrite() {

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

    }

    public Envelope getEnvelope() throws DataException {        

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

    }