| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

*

* Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

*

* 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

*

* For more information, contact:

*

*  Generalitat Valenciana

*   Conselleria d'Infraestructures i Transport

*   Av. Blasco Ib??ez, 50

*   46010 VALENCIA

*   SPAIN

*

*      +34 963862235

*   gvsig@gva.es

*      www.gvsig.gva.es

*

*    or

*

*   IVER T.I. S.A

*   Salamanca 50

*   46005 Valencia

*   Spain

*

*   +34 963163400

*   dac@iver.es

*/

package es.gva.cit.catalogClient.parsers.csw;

import java.util.Vector;

import es.gva.cit.catalogClient.drivers.CSWCatalogServiceDriver;

import es.gva.cit.catalogClient.metadataXML.XMLNode;

import es.gva.cit.catalogClient.metadataXML.XMLTree;

import es.gva.cit.catalogClient.parsers.SOAPMessageParser;

import es.gva.cit.catalogClient.utils.Strings;

/**

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

 */

public class CswCapabilitiesParser {

    CSWCatalogServiceDriver driver;

    public CswCapabilitiesParser(CSWCatalogServiceDriver driver) {

        this.driver = driver;

    }

    public boolean parse(XMLNode node) {

        String prefix = "";

        XMLNode[] operations = null;

        if (node.getName().equals("ows:ServiceExceptionReport")){

            driver.setServerAnswerReady("El servidor ha devuelto una excepci?n");

            return false;

        }      

        //Vamos a recorrer todas las operaciones. Para cada una de ellas

        //tomaremos las acciones correspondientes

        operations = XMLTree.searchMultipleNode(node,

                "ows:OperationsMetadata->ows:Operation");

        if (!(operations.length == 0)) {

            prefix = "ows:";

        } else {

            operations = XMLTree.searchMultipleNode(node,

                    "OperationsMetadata->Operation");

        }

        if (operations == null) {

            driver.setServerAnswerReady(

                "Se ha encontrado el servidor, pero parece ser " +

                "que no soporta el protocolo CS-W");

            return false;

        }

        if (this.driver.getCommunicationProtocol().equals("GET") &&

                getHTTPExceptions(node)) {

            return false;

        }

        if (this.driver.getCommunicationProtocol().equals("SOAP") &&

                getSOAPExceptions(node)) {

            return false;

        }

        //To save the protocols supported by each operation

        this.driver.setOperations(new CswSupportedProtocolOperations());

        //Operations name

        String sOperation;

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

            sOperation = XMLTree.searchAtribute(operations[i], "name");

            //////////////////Get Capabilities////////////////////

            if (sOperation.equals("GetCapabilities") ||

                    sOperation.equals("CSW-Discovery.getCapabilities")) {

                parseCapabilities(operations[i], prefix);

            }

            ////////////////////DescribeRecord//////////////////

            if (sOperation.equals("DescribeRecord")) {

                parseDescribeRecord(operations[i], prefix);

            }

            ////////////////////GetDomain//////////////////

            if (sOperation.equals("GetDomain")) {

                parseGetDomain(operations[i], prefix);

            }

            ////////////////////GetRecords//////////////////

            if (sOperation.equals("GetRecords") ||

                    sOperation.equals("CSW-Discovery.getRecords")) {

                if (!(parseGetRecords(operations[i], prefix))) {

                    return false;

                }

            }

            ////////////////////GetRecordsById//////////////////

            if (sOperation.equals("GetRecordsById") ||

                    sOperation.equals("CSW-Discovery.getRecordById")) {

                parseGetRecordsByID(operations[i], prefix);

            }

            ////////////////////Transaction//////////////////

            if (sOperation.equals("Transaction") ||

                    sOperation.equals("CSW-Publication.transaction")) {

                parseTransaction(operations[i], prefix);

            }

            ////////////////////Harvest//////////////////

            if (sOperation.equals("Harvest") ||

                    sOperation.equals("CSW-Publication.harvest")) {

                parseHarvest(operations[i], prefix);

            }

        }

        //Escribimos el mensaje de BienVenida

        driver.setServerAnswerReady(XMLTree.searchNodeValue(node,

                prefix + "ServiceIdentification->" + prefix + "Title") + "\n" +

            XMLTree.searchNodeValue(node,

                prefix + "ServiceIdentification->" + prefix + "Abstract"));

        configureConstants();

        return true;

    }

    public void configureConstants() {

        driver.setSortBy("true");

        driver.setStartPosition("1");

        driver.setMaxRecords("10");

    }

    public void parseCapabilities(XMLNode node, String prefix) {

            driver.getOperations().setGetCapabilities(setSupportedProtocols(node,prefix));

    }

    public void parseDescribeRecord(XMLNode node, String prefix) {

            driver.getOperations().setDescribeRecords(setSupportedProtocols(node,prefix));

    }

    public void parseGetRecordsByID(XMLNode node, String prefix) {

            driver.getOperations().setGetRecordsById(setSupportedProtocols(node,prefix));

    }

    public void parseGetDomain(XMLNode node, String prefix) {

            driver.getOperations().setGetDomain(setSupportedProtocols(node,prefix));

    }

    public boolean parseGetRecords(XMLNode node, String prefix) {

            driver.getOperations().setGetRecords(setSupportedProtocols(node,prefix));

            XMLNode[] parameters;

        //Alamacenamos los parametros y los escribimos

        parameters = XMLTree.searchMultipleNode(node, prefix + "Parameter");

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

            String sParameter = XMLTree.searchAtribute(parameters[j], "name");

            String[] values = XMLTree.searchMultipleNodeValue(parameters[j],

                    prefix + "Value");

            String[] defaultValue = XMLTree.searchMultipleNodeValue(parameters[j],

                    prefix + "DefaultValue");

            if (sParameter.equals("TypeName")) {

                driver.setTypeNames(Strings.join(defaultValue, values));

            }

            if (sParameter.equals("outputFormat")) {

                if (!(Strings.find("text/xml", defaultValue) ||

                        Strings.find("text/xml", values))) {

                    if (!(Strings.find("application/xml", defaultValue) ||

                            Strings.find("application/xml", values))) {

                        driver.setServerAnswerReady("El servidor no devuelve " +

                            "texto en formato XML");

                        return false;

                    }

                }

            }

            driver.setOutputFormat("text/xml");

            if (sParameter.equals("outputSchema")) {

                driver.setOutputSchema(Strings.join(defaultValue, values));

            }

            if (sParameter.equals("resultType")) {

                driver.setResultType(Strings.join(defaultValue, values));

            }

            if (sParameter.equals("ElementSetName")) {

                driver.setElementSetName(Strings.join(defaultValue, values));

            }

            if (sParameter.equals("CONSTRAINTLANGUAGE")) {

                driver.setCONSTRAINTLANGUAGE(Strings.join(defaultValue, values));

                for (int i = 0; i < driver.getCONSTRAINTLANGUAGE().length;

                        i++) {

                    if (driver.getCONSTRAINTLANGUAGE()[i].toUpperCase().equals("FILTER")) {

                        break;

                    } else {

                        driver.setServerAnswerReady(

                            "De momento solo se pueden hacer querys " +

                            "usando la codificaci?n FILTER ENCODING que no est?" +

                            "soportada por el servidor");

                    }

                }

            }

        }

        return true;

    }

    public void parseTransaction(XMLNode node, String prefix) {

            driver.getOperations().setTransaction(setSupportedProtocols(node,prefix));

    }

    public void parseHarvest(XMLNode node, String prefix) {

            driver.getOperations().setHarvest(setSupportedProtocols(node,prefix));

    }

    /**

     * This function returns the supported protocols of an operation 

     * defined by node.

     * @param node

     * Node that contains the operation information

     * @param prefix

     * getCapabilities tag prefix

     */

    public String[] setSupportedProtocols(XMLNode node,String prefix){

            Vector operations = new Vector();

            XMLNode protocols = XMLTree.searchNode(node, prefix + "DCP");

            XMLNode HTTPoperations = XMLTree.searchNode(protocols, prefix + "HTTP");

            XMLNode[] childNodes = HTTPoperations.getSubnodes();

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

                    if ((childNodes[i].getName().equals("Get")) ||

                                    (childNodes[i].getName().equals(prefix + "Get"))){

                            operations.add(new String("GET"));

                    }

                    if ((childNodes[i].getName().equals("Post")) ||

                                    (childNodes[i].getName().equals(prefix + "Post"))){

                            operations.add(new String("POST"));

                    }

            }

            String[] output = new String[operations.size()];

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

                    output[i] = (String) operations.get(i);            

            return output;

    }

    /**

     * Parses the HTTP-CSW Exceptions

     * @param node

     * @return

     */

    public boolean getHTTPExceptions(XMLNode node) {

        if (node.getName().equals("ServiceExceptionReport")) {

            driver.setServerAnswerReady(XMLTree.searchNodeValue(node,

                    "ServiceException"));

            return true;

        }

        return false;

    }

    /**

     * It returns the exception code

     * @param node

     * Returned node.

     * @return

     */

    public String getExceptionCode(XMLNode node){

        String code = XMLTree.searchNodeAtribute(node,"ows:OWSException","code");

        if (code == null)

            return "0";

        return code;

    }

    /**

     * It returns the exception Subcode

     * @param node

     * Returned node.

     * @return

     */

    public String getExceptionSubCode(XMLNode node){

        String code = XMLTree.searchNodeAtribute(node,"ows:OWSException","subcode");

        if (code == null)

            return "0";

        return code;

    }

    /**

     * Parses the SOAP-CSW Exceptions

     * @param node

     * @return

     */

    public boolean getSOAPExceptions(XMLNode node) {

        String msg = SOAPMessageParser.getFault(node);

        if (msg != null) {

            driver.setServerAnswerReady(msg);

            return true;

        }

        return false;

    }

}