Application: gvSIG desktop

/* 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.csw.parsers;

import java.net.URL;

import java.util.Vector;

import es.gva.cit.catalogClient.csw.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.profiles.Profile;

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

/**

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

 */

public class CswCapabilitiesParser {

    private CSWCatalogServiceDriver driver;

    private URL url;

    private XMLNode rootNode;

    /**

     * @param driver

     * Protocol Driver

     * @param url

     * Server Protocol

     */

    public CswCapabilitiesParser(CSWCatalogServiceDriver driver,URL url) {

        this.driver = driver;

        this.url = url;        

    }

    public boolean parse(XMLNode node) {

        rootNode = node;

        String prefix = "";

        XMLNode[] operations = null;

        if (httpServerIsReady() == false){

            return false;

        }

        if (soapServerIsReady() == false){

            return false;

        }

        discoverServerProfile(node);

        if (driver.getServerProfile().equals(Profile.EBRIM)){

            boolean b = new CswIDECCapabilitiesParser(driver).parse();

            if (b){

                setWelcomeMessage(node,"");

            }

            return b;

        }        

        //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("errorNotCSWSupportedProtocol");

            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

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

            }

        }      

        setWelcomeMessage(node,prefix);

        setConstantValues();

        return true;

    }

    /**

     * This method is used to detect some common problems when the 

     * used protocol has been HTTP

     * @return

     * true if all is OK

     */

    private boolean httpServerIsReady(){

        if (rootNode == null){

            driver.setServerAnswerReady("errorNotSupportedProtocol");

            return false;

        }

        if (rootNode.getName().equals("SRW:explainResponse")){

            driver.setServerAnswerReady("errorIsASRWServer");

            return false;

        }  

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

            driver.setServerAnswerReady("errorServerException");

            return false;

        }  

        return true;

    }

    /**

     * This method is used to detect some common problems when the 

     * used protocol has been SOAP

     * @return

     * true if all is OK

     */

    private boolean soapServerIsReady(){

        if (XMLTree.searchNode(rootNode,"SOAP-ENV:Body->SOAP-ENV:Fault") != null){

            driver.setServerAnswerReady("errorSOAPProtocol");

            return false;

        }  

        return true;

    }

    /**

     * This method is used to discover the CSW server profile. The value

     * can be ebRIM or ISO19115

     * @param node

     */

    private void discoverServerProfile(XMLNode node){

        if ((url.getHost().equals("delta.icc.es")) || 

                (url.getHost().equals("indicio.demo.galdosinc.com"))){   

            driver.setServerProfile(Profile.EBRIM);

        }else{

            driver.setServerProfile(Profile.ISO19115);

        }

    }

    /**

     * Sets the welcome message

     *

     */

    private void setWelcomeMessage(XMLNode node,String prefix){

        //Escribimos el mensaje de BienVenida

        driver.setServerAnswerReady(XMLTree.searchNodeValue(node,

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

            XMLTree.searchNodeValue(node,

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

    }

    /**

     * Sets some constant values

     *

     */

    private void setConstantValues() {

        driver.setSortBy("true");

        driver.setStartPosition("1");

        driver.setMaxRecords("10");

    }

    private void parseCapabilities(XMLNode node, String prefix) {

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

    }

    private void parseDescribeRecord(XMLNode node, String prefix) {

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

    }

    private void parseGetRecordsByID(XMLNode node, String prefix) {

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

    }

    private void parseGetDomain(XMLNode node, String prefix) {

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

    }

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

                driver.setServerProfile(Profile.DUBLINCORE);

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

                    if (driver.getOutputSchema()[i].equals(Profile.ISO19115))

                        driver.setServerProfile(Profile.ISO19115);

                            break;

                }

            }

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

                    }

                }

            }

        }

        return true;

    }

    private void parseTransaction(XMLNode node, String prefix) {

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

    }

    private 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

     */

    private 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

     */

    private 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

     */

    private boolean getSOAPExceptions(XMLNode node) {

        String msg = SOAPMessageParser.getFault(node);

        if (msg != null) {

            driver.setServerAnswerReady(msg);

            return true;

        }

        return false;

    }

}