Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3

 * 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.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.remoteclient.wfs;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import org.gvsig.compat.CompatLocator;

import org.gvsig.compat.lang.StringUtils;

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

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

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

import org.gvsig.remoteclient.RemoteClientStatus;

import org.gvsig.remoteclient.wfs.edition.WFSTTransaction;

import org.gvsig.remoteclient.wfs.filters.AbstractFilter;

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

import org.gvsig.remoteclient.wfs.filters.operations.WFSEnvelopeFilterOperation;

import org.gvsig.remoteclient.wfs.filters.operations.WFSGeometryFilterOperation;

import org.gvsig.remoteclient.wfs.filters.operations.WFSSpatialFilterOperation;

/**

 * The status of the current WFS connection

 * 

 * @author Jorge Piera Llodr? (piera_jor@gva.es)

 * @see <a href="http://www.opengeospatial.org/standards/wfs">OpenGIS Web Feature Service (WFS) Implementation Specification</a>

 */

public class WFSStatus extends RemoteClientStatus{

    private static final StringUtils stringUtils = CompatLocator.getStringUtils();

    /**

         *  The optional resultType attribute is used to control how 

         *  a web feature service responds to a GetFeature request.

         *  The possible values for the attribute are defined in 

         *  some constants in this class.

         */

        private int resultType = RESULTYPE_RESULTS;

        /**

         * The default value results indicates that a web feature 

         * service should generate a complete response that 

         * contains all the features that satisfy the request.

         */

        public static final int RESULTYPE_RESULTS = 0;

        /**

         * The value hits indicates that a web feature service should process the

         * GetFeature request and rather than return the entire result set, 

         * it should simply indicate the number of feature instance of 

         * the requested feature type(s) that satisfy the request.

         */

        public static final int RESULTYPE_HITS = 1;

        static final String LOCKACTION_ALL = "ALL"; 

        static final String LOCKACTION_SOME = "SOME"; 

        //WFS attributes

        private String featureName = null;

        private String namespacePrefix = null;

        private String namespaceLocation = null;

        private String[] fields = null;

        private String onlineResource = null;

        private Integer timeout = new Integer(10000);

        private Integer maxFeatures = new Integer(100);        

        private String filterByAttribute = null;

        private WFSSpatialFilterOperation filterByArea = null;

        //Geometry manager

        private static GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        //WFS-T LockFeature attributes

        private String userName = null;

        private String password = null;

        private ArrayList featuresToLock = new ArrayList();

        private ArrayList featuresToLockPropertieName = new ArrayList();

        private ArrayList featuresToLockPropertieValue = new ArrayList();

        private ArrayList featuresLocked = new ArrayList();

        private int expiry = -1;

        private String lockAction = null;

        private Rectangle2D lockedArea = null;

        private String lockedAreaProperty = null;

        //WFS-T Transaction

        private WFSTTransaction transaction = null;

        public WFSStatus(String featureName){

                this(featureName, null);

        }

        public WFSStatus(String featureName, String namespace){

                this.featureName = featureName;

                this.namespaceLocation = namespace;

                setFeatureName(featureName);

                lockAction = LOCKACTION_ALL;

                featuresLocked = new ArrayList();

                featuresLocked = new ArrayList();

                featuresToLockPropertieName = new ArrayList();

                featuresToLockPropertieValue = new ArrayList();                

        }

        /**

         * @return Returns the buffer.

         */

        public Integer getMaxFeatures() {

                return maxFeatures;

        }

        /**

         * @param buffer The buffer to set.

         */

        public void setMaxFeatures(Integer buffer) {

                if (buffer != null){

                        this.maxFeatures = buffer;

                }

        }

        /**

         * @return Returns the featureName.

         */

        public String getFeatureName() {

                return featureName;

        }

        public String getFeatureFullName(){

            if (namespacePrefix == null){

                return featureName;

            }else{

                return namespacePrefix + ":" + featureName;

            }

        }

        /**

         * @param featureName The featureName to set.

         */

        public void setFeatureName(String featureName) {

            if (featureName != null){

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

            if (index>0){

                this.featureName = featureName.substring(index+1, featureName.length());

                namespacePrefix = featureName.substring(0, index);

            }else{

                this.featureName = featureName;

            }

        }           

        }

        /**

         * @return Returns the fields.

         */

        public String[] getFields() {

                if (fields == null){

                        fields = new String[0];

                }

                return fields;

        }

        /**

         * @param fields The fields to set.

         */

        public void setFields(String[] fields) {

                this.fields = fields;

        }

        public void setFields(String fields) {

                if (fields == null){

                        return;

                }

                this.fields = stringUtils.split(fields, ",");                

        }

        /**

         * @return Returns the password.

         */

        public String getPassword() {

                return password;

        }

        /**

         * @param password The password to set.

         */

        public void setPassword(String password) {

                this.password = password;

        }

        /**

         * @return Returns the timeout.

         */

        public Integer getTimeout() {

                return timeout;

        }

        /**

         * @param timeout The timeout to set.

         */

        public void setTimeout(Integer timeout) {

                if (timeout != null){

                        this.timeout = timeout;

                }

        }

        /**

         * @return Returns the userName.

         */

        public String getUserName() {

                return userName;

        }

        /**

         * @param userName The userName to set.

         */

        public void setUserName(String userName) {

                this.userName = userName;

        }

        public String getOnlineResource() {

                return onlineResource;

        }

        public void setOnlineResource(String url) {

                onlineResource = url;

        }

        /**

         * @return Returns the filterQuery.

         */

        public String getFilterByAttribute() {

                return filterByAttribute;

        }

        /**

         * @param filterQuery The filterQuery to set.

         */

        public void setFilterByAttribute(String filterQuery) {

                this.filterByAttribute = filterQuery;

        }        

        /**

         * @param filterByArea 

         * the filterByArea to set

         * @param operation

         * The geometric operation to apply. It has to be a value from 

         * {@link AbstractFilter}

         */

        public void setFilterByArea(Geometry geometry, String attributeName, String srs, Integer operation) {

                if (geometry == null){

                        return;

                }

                if (attributeName == null){

                        attributeName = "the_geom";

                }

                if (operation == null){

                        operation = new Integer(AbstractFilter.GEOMETRIC_OPERATOR_INTERSECT);

                }

                //TODO add a manager to register this

                this.filterByArea = new WFSGeometryFilterOperation(geometry,

                                operation.intValue(),

                                attributeName, 

                                getNamespacePrefix(),

                                getNamespaceLocation(),

                                srs);                                

        }        

        public void removeFilterByArea(){

            this.filterByArea = null;

        }

        public void removeFilterByAttribute(){

            this.filterByAttribute = null;

        }

        public void removeAllFilters(){

            removeFilterByArea();

            removeFilterByAttribute();

        }

        /**

         * @param filterByArea 

         * the filterByArea to set

         * @param operation

         * The geometric operation to apply. It has to be a value from 

         * {@link AbstractFilter}

         */

        public void setFilterByArea(Envelope envelope, String attributeName, String srs, Integer operation) {

                if (envelope == null){

                        return;

                }

                if (attributeName == null){

                        attributeName = "the_geom";

                }

                if (operation == null){

                        operation = new Integer(AbstractFilter.GEOMETRIC_OPERATOR_INTERSECT);

                }

                this.filterByArea = new WFSEnvelopeFilterOperation(envelope,

                                operation.intValue(),

                                attributeName, 

                                getNamespacePrefix(),

                                getNamespaceLocation(),

                                srs);                                

        }        

        /**

         * @return the filterByArea

         */

        public WFSSpatialFilterOperation getFilterByArea() {

                return filterByArea;

        }

        /**

         * @return the filterQueryLocked

         */

        public String getFilterQueryLocked() {

                FilterEncoding filter = new FilterEncoding(this);

                filter.setQualified(true);

                filter.setNamepacePrefix(null);

                filter.setHasBlankSpaces(false);

                return getFilterQueryLocked(filter);        

        }

        /**

         * @return the filterQueryLocked

         */

        public String getFilterQueryLockedPost() {

                FilterEncoding filter = new FilterEncoding(this);

                filter.setQualified(true);

                return getFilterQueryLocked(filter);

        }

        /**

         * Create a filter encoding request

         * @param filter

         * @return

         */

        private String getFilterQueryLocked(FilterEncoding filter){

                if ((featuresToLock.size() == 0) && 

                                (getLockedArea() == null) &&

                                (featuresToLockPropertieName.size() == 0)){

                        return null;

                }

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

                        filter.addFeatureById(featuresToLock.get(i));

                }

                if (featuresToLockPropertieName.size() > 0){

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

                                filter.addAndClause((String)featuresToLockPropertieName.get(i),

                                                (String)featuresToLockPropertieValue.get(i));                                                

                        }                                

                }

                if (lockedArea != null){

                        GeneralPathX generalPath = new GeneralPathX();

                        generalPath.moveTo(lockedArea.getMinX(), lockedArea.getMinY());

                        generalPath.lineTo(lockedArea.getMaxX(), lockedArea.getMinY());

                        generalPath.lineTo(lockedArea.getMaxX(), lockedArea.getMaxY());

                        generalPath.lineTo(lockedArea.getMinX(), lockedArea.getMaxY());

                        generalPath.lineTo(lockedArea.getMinX(), lockedArea.getMinY());

                        try {

                                filter.clearSpatialFilters();

                                filter.addSpatialFilter(geometryManager.createSurface(generalPath, SUBTYPES.GEOM2D),

                                                lockedAreaProperty, 

                                                getNamespacePrefix(),

                                                getNamespaceLocation(),

                                                getSrs(), 

                                                AbstractFilter.BBOX_ENCLOSES);

                        } catch (CreateGeometryException e) {

                                return null;

                        }

                }

                return filter.toString();        

        }

        /**

         * @return the expiry

         */

        public int getExpiry() {

                return expiry;

        }

        /**

         * @param expiry the expiry to set

         */

        public void setExpiry(int expiry) {

                this.expiry = expiry;

        }

        /**

         * @return the lockAction

         */

        public String getLockAction() {

                return lockAction;

        }

        /**

         * Set the lock action to all

         */

        public void setLockActionToAll() {

                lockAction = LOCKACTION_ALL;

        }

        /**

         * Set teh lock action to some

         */

        public void setLockActionToSome() {

                lockAction = LOCKACTION_SOME;

        }

        public WFSTTransaction createNewTransaction(){

            transaction = new WFSTTransaction(this);

            return transaction;

        }

        public WFSTTransaction getTransaction(){

            return transaction;

        }

        /**

         * @return the neumber of features blocked

         */

        public int getFeaturesToLockSize() {

                return featuresToLock.size();

        }

        /**

         * Gets an identifier of a feature that is blocked

         * @param i

         * The id position

         * @return

         * The Id

         */

        public String getFeatureToLockAt(int i){

                if (i>featuresToLock.size()){

                        return null;

                }

                return (String)featuresToLock.get(i);

        }

        /**

         * Remove all the features to lock

         */

        public void removeFeaturesToLock() {

                featuresToLock.clear();

                featuresLocked.clear();

                featuresToLockPropertieName.clear();

                featuresToLockPropertieValue.clear();

        }

        /**

         * Adds a new feature locked

         * @param idFeature

         * the feature id

         */

        public void addFeatureToLock(String idFeature) {

                featuresToLock.add(idFeature);

        }

        /**

         * Adds a new feature locked

         * @param idFeature

         * the feature id

         */

        public void addFeatureToLock(String propertyName, String propertyValue){

                featuresToLockPropertieName.add(propertyName);

                featuresToLockPropertieValue.add(propertyValue);

        }

        /**

         * @return the idsLocked size

         */

        public int getFeaturesLocked() {

                return featuresLocked.size();

        }

        /**

         * Gets an identifier tha is blocked

         * @param i

         * The id position

         * @return

         * The Id

         */

        public String getFeatureLockedAt(int i){

                if (i>featuresLocked.size()){

                        return null;

                }

                return (String)featuresLocked.get(i);

        }

        /**

         * Adds a new Id

         * @param idLocked

         * the idLocked to add

         */

        public void addFeatureLocked(String lockId) {

                featuresLocked.add(lockId);

        }

        /**

         * @return the lockedArea

         */

        public Rectangle2D getLockedArea() {

                return lockedArea;

        }

        /**

         * @param lockedArea the lockedArea to set

         */

        public void setLockedArea(Rectangle2D lockedArea, String lockedAreaProperty) {

                this.lockedArea = lockedArea;

                this.lockedAreaProperty = lockedAreaProperty;

        }

        /**

         * @return the namespace prefix

         */

        public String getNamespacePrefix(){

                return namespacePrefix;

        }

        /**

         * @return the namespace URL

         */

        public String getNamespaceLocation(){

                return namespaceLocation;

        }

        /**

         * @param namespaceprefix the namespaceprefix to set

         */

        public void setNamespacePrefix(String namespacePrefix) {

                this.namespacePrefix = namespacePrefix;

        }

        /**

         * @param namespace the namespace to set

         */

        public void setNamespaceLocation(String namespaceLocation) {

                this.namespaceLocation = namespaceLocation;                

        }

        /**

         * @return the resultType

         */

        public int getResultType() {

                return resultType;

        }

        /**

         * @param resultType the resultType to set

         */

        public void setResultType(int resultType) {

                this.resultType = resultType;

        }

}