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.filters.filterencoding;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Set;

import org.gvsig.compat.CompatLocator;

import org.gvsig.compat.lang.StringUtils;

import org.gvsig.remoteclient.wfs.WFSStatus;

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

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

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

import org.gvsig.remoteclient.wfs.filters.BinaryTree.Node;

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

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

import org.gvsig.remoteclient.wfs.filters.filterencoding.wfs_1_0_0.EnvelopeFEQuery1_0_0;

import org.gvsig.remoteclient.wfs.filters.filterencoding.wfs_1_1_0.EnvelopeFEQuery1_1_0;

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

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

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

/**

 * This class implements the Filter Encoding Language. It is used to

 * create querys in this language

 * 

 * Name: OpenGIS? Filter Encoding Implementation Specification

 * Version: 1.1.0

 * Project Document: OGC 04-095 

 * @see http://portal.opengeospatial.org/files/?artifact_id=8340

 * 

 * @author Jorge Piera Llodra (piera_jor@gva.es)

 */

public class FilterEncoding extends AbstractFilter {

    public static final int RELATIONSHIP_PROPERTY = 0;

    public static final int RELATIONSHIP_VAUES = 1;

    private StringBuffer currentQuery = null;

    //Operation types

    private static final int OPERATION_PROPERTYNAME = 0;

    private static final int OPERATION_LITERAL = 1;

    //Filter namespace. 

    private String nameSpacePrefix = null;

    private String nameSpaceLocation = null;

    //If the Filter can have blanckSpaces

    private boolean hasBlankSpaces = true;

    private String defaultBlankSpace = "%20";

    //This character must be replaced by any set of characters (typically "*")

    private String wildCardChar = null;

    //This character must be replaced by one character (typically "?")

    private String singleChar = null;

    //Escape character (typically "\")

    private String escapeChar = null;

    //Default values

    public static final String DEFAULT_NAMESPACE_PREFIX = "ogc";

    public static final String DEFAULT_WILDCARD = "*";

    public static final String DEFAULT_SINGLECHAR = "?";

    public static final String DEFAULT_ESCAPE = "\\";

    public static final String DEFAULT_NAMESPACE = "xmlns:ogc=\"http://www.opengis.net/ogc\"";

    private Hashtable filterAttributes = new Hashtable();

    /**

     * If the namespace XML is qualified

     */

    private boolean isQualified = false;

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

    /**

     * Create a new Filter Encoding Parser

     * 

     * 

     * @param nameSpacePrefix

     * Filter namespace. (typically "ogc")

     * @param wildCardChar 

     * This character must be replaced by any set of characters (typically "*")

     * @param singleChar 

     * This character must be replaced by one character (typically "?")

     * @param escape 

     * Escape character

     * @param filterAttribute Sometimes, "Field" label needs an attribute.

     */

    public FilterEncoding(ISQLExpressionFormat formatter,String namesPacePrefix, String wildCard, String singleChar, String escape, Hashtable filterAttributes) {        

        super(formatter);

        if (namesPacePrefix == null){

            setQualified(false);

        }else{

            setQualified(true);

        }

        this.wildCardChar = wildCard;

        this.singleChar = singleChar;

        this.escapeChar = escape;

        this.filterAttributes = filterAttributes;

    } 

    /**

     * Create a new Filter Encoding Parser

     * @param formatter

     */

    public FilterEncoding(ISQLExpressionFormat formatter) {        

        this(formatter,null,DEFAULT_WILDCARD,DEFAULT_SINGLECHAR,

            DEFAULT_ESCAPE,new Hashtable());

    } 

    /**

     * Create a new Filter Encoding Parser

     */

    FilterEncoding() {        

        this(new DefaultSQLExpressionFormat());                

    }         

    /**

     * Create a new Filter Encoding Parser

     */

    public FilterEncoding(WFSStatus status) {        

        this();        

        this.nameSpacePrefix = status.getNamespacePrefix();

        this.nameSpaceLocation = status.getNamespaceLocation();

        setQueryByAttribute(status.getFilterByAttribute());

        clearSpatialFilters();

        addSpatialFilter(status.getFilterByArea());                

    } 

    /*

     *  (non-Javadoc)

     * @see org.gvsig.remoteClient.filterEncoding.QueryLanguage#toString(org.gvsig.remoteClient.filterEncoding.BinaryTree)

     */

    public String toString(BinaryTree tree, String version) {

        //If is a filter by ids...

        StringBuffer idQuery = null;

        if (getIds() != null){

            idQuery = new StringBuffer();

            ArrayList ids = getIds();

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

                if (ids.get(i) != null){

                    Hashtable attributes = new Hashtable();

                    attributes.put("fid","\"" + ids.get(i).toString() + "\"");

                    idQuery.append(setTag("FeatureId", attributes, null));

                }

            }

            return enclosesWithFilterTag(idQuery.toString());

        }

        //If is a filter by attributes...

        String filterQuery = null;

        if ((tree.getRoot() == null) && (getSpatialFiltersCount() == 0)){

            return null;

        }

        if (tree.getRoot() != null){

            currentQuery = new StringBuffer();

            filterQuery = getFilterNode(tree.getRoot());

            if (getSpatialFiltersCount() == 0){

                return enclosesWithFilterTag(filterQuery);

            }

        }

        //If is a filter by area

        String bboxQuery = null;

        if (getSpatialFiltersCount() > 0){

            for (int i=0 ; i<getSpatialFiltersCount() ; i++){

                WFSSpatialFilterOperation spatialFilter = getSpatialFilterAt(i);

                SpatialFEQuery feQuery = null;

                if (spatialFilter instanceof WFSGeometryFilterOperation){

                    feQuery = new GeometryFEQuery((WFSGeometryFilterOperation)spatialFilter);

                }else if (spatialFilter instanceof WFSEnvelopeFilterOperation){

                    //TODO add this for a manager

                    if (version.equals("1.0.0")){

                        feQuery = new EnvelopeFEQuery1_0_0((WFSEnvelopeFilterOperation)spatialFilter);

                    }else{

                        feQuery = new EnvelopeFEQuery1_1_0((WFSEnvelopeFilterOperation)spatialFilter);  

                    }                                   

                }

                //If there is a spatial query

                if (feQuery != null){

                    bboxQuery = feQuery.getFilterEncoding();

                    if (tree.getRoot() == null){

                        String filter_bbox = enclosesWithFilterTag(bboxQuery); 

                        return filter_bbox;

                    }        

                }

            }

        }                

        return enclosesWithFilterTag(filterQuery + bboxQuery);

    }

    /**

     * Gets the filter code from a node

     * @param node

     */

    private String getFilterNode(Node node){

        if (node.isField()){

            return getExpression(node.getValue());

        }else{

            String left = "";

            String rigth = "";

            if (node.getLeftNode() != null){

                left = getFilterNode(node.getLeftNode());

            }

            if (node.getRigthNode() != null){

                rigth = getFilterNode(node.getRigthNode());

            }

            int operationCode = getLogicalOperator(node.getValue());

            String operation = getLogicalOperator(operationCode);

            return enterLabel(left+rigth, operation);

        }                

    }   

    /**

     * Parses a expresion like 'A op B' and returns the

     * expresion using the filter encoding language

     * @param expression

     * @return

     */

    private String getExpression(String expression){

        String[] words = stringUtils.split(expression, " ");

        //Param

        String param = words[0];

        if (param.charAt(0) == '"'){

            param = param.substring(1,param.length());

        }

        if (param.charAt(param.length()-1) == '"'){

            param = param.substring(0,param.length()-1);

        }

        //Operator

        String operator = words[1];

        //Value

        String value = words[2];                

        for (int i=3 ; i<words.length ; i++){

            value = value + " " + words[i];

        }

        if (value.charAt(0) == '\''){

            value = value.substring(1,value.length());

        }

        if (value.charAt(value.length()-1) == '\''){

            value = value.substring(0,value.length()-1);

        }

        int operatorCode = getRelationalOperator(operator);

        operator = getRelationalOperator(operatorCode);

        return createExpression(operator,param,value);

    }

    /**

     * It writes a "PropertyIsXXX" part of a filtyer encoding query

     * 

     * 

     * @return The part of the query

     * @param property Possible Values: PropertIsLike, PropertyIsLess, PropertyIsGreater,... See

     * the Filter Encoding documentation

     * @param parameter Parameter name

     * @param value Parameter value

     * @param type Values: "P" (to comparate two propertyes) or "L" (to comparate one property

     * and one literal value)

     */

    private String createExpression(String property, String parameter, String value) {        

        String cadena = "";

        cadena = "<" + WFSTTags.OGC_NAMESPACE_PREFIX + ":" + property;

        if (property.equals("PropertyIsLike")) {

            if (wildCardChar != null) {

                cadena = cadena + " wildCard=\"" + this.wildCardChar + "\"";

            }

            if (singleChar != null) {

                cadena = cadena + " singleChar=\"" + this.singleChar + "\"";

            }

            if (escapeChar != null) {

                cadena = cadena + " escape=\"" + this.escapeChar + "\"";

            }

        }

        cadena = cadena + ">" + enterLabel(nameSpacePrefix + ":" + parameter, "PropertyName");

        cadena = cadena + enterLabel(value, "Literal");

        return cadena + "</" + WFSTTags.OGC_NAMESPACE_PREFIX + ":" + property + ">";

    }         

    /**

     * Envuelve a una pregunta con una etiqueta

     * 

     * 

     * @return String : parte de la query en el lenguaje soportado

     * @param pregunta Pregunta a envolver

     * @param etiqueta Nombre de la etiqueta

     */

    private String enterLabel(String value, String tagName) {        

        if (tagName.equals("Filter") && (!(filterAttributes.isEmpty()))) {

            return setTag(tagName,filterAttributes,value);

        } else {

            return setTag(tagName,null,value);

        }

    } 

    /**

     * Envolves a value with an XML tag

     * 

     * @return String

     * XML tag with its value

     * @param tagName 

     * XML tag name

     * @param attributes

     * XML tag attributes

     * @param value 

     * Tag value

     */

    public String setTag(String tagName, Hashtable attributes, String value) {        

        StringBuffer tag = new StringBuffer();

        tag.append("<");

        tag.append(WFSTTags.OGC_NAMESPACE_PREFIX + ":");

        tag.append(tagName);            

        if (attributes != null){

            Set keys = attributes.keySet();

            if (attributes.size() > 0){

                Iterator it = keys.iterator();

                while (it.hasNext()){

                    String key = (String)it.next();

                    if (hasBlankSpaces){

                        tag.append(" ");

                    }else{

                        tag.append(defaultBlankSpace);

                    }

                    tag.append(key + "=" + (String)attributes.get(key));

                }

            }

        }

        if (value == null){

            tag.append("/>");

        }else{

            tag.append(">" + value);

            tag.append("</");

            tag.append(WFSTTags.OGC_NAMESPACE_PREFIX + ":");

            tag.append(tagName);

            tag.append(">");

        }

        return tag.toString();

    }

    /**

     * Encloses a query with the filter tag

     * @param query

     * @return

     */

    private String enclosesWithFilterTag(String query){

        StringBuffer filter = new StringBuffer();

        filter.append("<ogc:Filter");

        if (!isQualified){

            filter.append(" ");

            addNamespace(filter, WFSTTags.OGC_NAMESPACE_PREFIX, WFSTTags.OGC_NAMESPACE);

            addNamespace(filter, WFSTTags.GML_NAMESPACE_PREFIX, WFSTTags.GML_NAMESPACE);

            if (nameSpacePrefix != null){

                addNamespace(filter, nameSpacePrefix, nameSpaceLocation);

            }

            filter.append("xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" ");      

            filter.append("xsi:schemaLocation=\"http://www.opengis.net/ogc ../filter/1.0.0/filter.xsd http://www.opengis.net/gml ../gml/2.1.2/geometry.xsd\"");

        }

        filter.append(">");

        filter.append(query);

        filter.append("</ogc:Filter>");

        return filter.toString();

    }

    private void addNamespace(StringBuffer buffer, String nameSpacePrefix, String nameSpaceLocation){

        buffer.append(WFSTTags.XMLNS + ":" + nameSpacePrefix + "=\"" + nameSpaceLocation + "\" ");

    }

    /*

     *  (non-Javadoc)

     * @see org.gvsig.remoteClient.filterEncoding.AQueryLanguage#getLogicOperator(int)

     */

    public String getLogicalOperator(int operator) {

        switch (operator){

        case LOGICAL_OPERATOR_AND:

            return "And";

        case LOGICAL_OPERATOR_OR:

            return "Or";

        case LOGICAL_OPERATOR_NOT:

            return "Not";

        default:

            return "And";

        }    

    } 

    /*

     *  (non-Javadoc)

     * @see org.gvsig.remoteClient.filterEncoding.AQueryLanguage#getRelationalOperator(int)

     */

    public String getRelationalOperator(int operator) {

        switch (operator){

        case RELATIONAL_OPERATOR_IS_EQUALS_TO:

            return "PropertyIsEqualTo";

        case RELATIONAL_OPERATOR_IS_NOT_EQUALS_TO:

            return "PropertyIsNotEqualTo";

        case RELATIONAL_OPERATOR_IS_LESS_THAN:

            return "PropertyIsLessThan";

        case RELATIONAL_OPERATOR_IS_GREATER_THAN:

            return "PropertyIsGreaterThan";

        case RELATIONAL_OPERATOR_IS_LESS_THAN_OR_EQUAL_TO:

            return "PropertyIsLessThanOrEqualTo";

        case RELATIONAL_OPERATOR_IS_GREATER_THAN_OR_EQUAL_TO:

            return "PropertyIsGreaterThanOrEqualTo";

        case RELATIONAL_OPERATOR_IS_LIKE:

            return "PropertyIsLike";

        case RELATIONAL_OPERATOR_IS_NULL:

            return "PropertyIsNull";

        case RELATIONAL_OPERATOR_IS_BETWEEN:

            return "PropertyIsBetween";

        default:

            return "PropertyIsLike";

        }

    }

    /*

     *  (non-Javadoc)

     * @see org.gvsig.remoteClient.filterEncoding.AQueryLanguage#getGeometricOperator(int)

     */

    public String getGeometricOperator(int operator) {

        switch (operator){

        case GEOMETRIC_OPERATOR_EQUALS:

            return "Equals";

        case GEOMETRIC_OPERATOR_DISJOINT:

            return "Disjoint";

        case GEOMETRIC_OPERATOR_TOUCHES:

            return "Touches";

        case GEOMETRIC_OPERATOR_WITHIN:

            return "Within";

        case GEOMETRIC_OPERATOR_OVERLAPS:

            return "Overlaps";

        case GEOMETRIC_OPERATOR_CROSSES:

            return "Crosses";

        case GEOMETRIC_OPERATOR_INTERSECT:

            return "Intersect";

        case GEOMETRIC_OPERATOR_CONTAINS:

            return "Contains";

        case GEOMETRIC_OPERATOR_DWITHIN:

            return "Dwithin";

        case GEOMETRIC_OPERATOR_BEYOND:

            return "Beyond";

        case GEOMETRIC_OPERATOR_BBOX:

            return "BBOX";

        default:

            return "Equals";

        } 

    }

    public String getSeparator(int separator) {

        return null;

    }

    /**

     * @param isQualified the isQualified to set

     */

    public void setQualified(boolean isQualified) {

        this.isQualified = isQualified;

        if (isQualified){

            nameSpacePrefix = DEFAULT_NAMESPACE_PREFIX + ":";

        }else{

            nameSpacePrefix = "";

        }

    }

    /**

     * @param namepacePrefix the namepacePrefix to set

     */

    public void setNamepacePrefix(String namepacePrefix) {

        if ((namepacePrefix == null) || (namepacePrefix.equals(""))){

            this.nameSpacePrefix = "";

        }else{

            this.nameSpacePrefix = namepacePrefix + ":";

        }

    }

    /**

     * @param hasBlankSpaces the hasBlankSpaces to set

     */

    public void setHasBlankSpaces(boolean hasBlankSpaces) {

        this.hasBlankSpaces = hasBlankSpaces;

    }

}