    001    // $HeadURL:
    002    // /cvsroot/deegree/src/org/deegree/ogcwebservices/getcapabilities/CapabilitiesDocument.java,v
    003    // 1.7 2004/06/22 13:25:14 ap Exp $
    004    /*----------------------------------------------------------------------------
    005     This file is part of deegree, http://deegree.org/
    006     Copyright (C) 2001-2009 by:
    007       Department of Geography, University of Bonn
    008     and
    009       lat/lon GmbH
    010
    011     This library is free software; you can redistribute it and/or modify it under
    012     the terms of the GNU Lesser General Public License as published by the Free
    013     Software Foundation; either version 2.1 of the License, or (at your option)
    014     any later version.
    015     This library is distributed in the hope that it will be useful, but WITHOUT
    016     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    017     FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
    018     details.
    019     You should have received a copy of the GNU Lesser General Public License
    020     along with this library; if not, write to the Free Software Foundation, Inc.,
    021     59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    022
    023     Contact information:
    024
    025     lat/lon GmbH
    026     Aennchenstr. 19, 53177 Bonn
    027     Germany
    028     http://lat-lon.de/
    029
    030     Department of Geography, University of Bonn
    031     Prof. Dr. Klaus Greve
    032     Postfach 1147, 53001 Bonn
    033     Germany
    034     http://www.geographie.uni-bonn.de/deegree/
    035
    036     e-mail: info@deegree.org
    037    ----------------------------------------------------------------------------*/
    038    package org.deegree.ogcwebservices.getcapabilities;
    039
    040    import java.net.MalformedURLException;
    041    import java.net.URI;
    042    import java.net.URISyntaxException;
    043    import java.net.URL;
    044
    045    import org.deegree.framework.util.StringTools;
    046    import org.deegree.framework.xml.ElementList;
    047    import org.deegree.framework.xml.XMLParsingException;
    048    import org.deegree.framework.xml.XMLTools;
    049    import org.deegree.ogcbase.CommonNamespaces;
    050    import org.deegree.ogcwebservices.ExceptionFormat;
    051    import org.deegree.ogcwebservices.MetadataLink;
    052    import org.deegree.ogcwebservices.MetadataType;
    053    import org.w3c.dom.Element;
    054    import org.w3c.dom.Node;
    055
    056    /**
    057     *
    058     * @author <a href="mailto:poth@lat-lon.de">Andreas Poth </a>
    059     *
    060     * @author last edited by: $Author: mschneider $
    061     *
    062     * @version 1.0. $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18. Jun 2009) $
    063     *
    064     * @since 2.0
    065     */
    066    public abstract class OGCStandardCapabilitiesDocument extends OGCCapabilitiesDocument {
    067
    068        protected static final URI OGCNS = CommonNamespaces.OGCNS;
    069
    070        protected static final URI GMLNS = CommonNamespaces.GMLNS;
    071
    072        /**
    073         * returns the value of the version attribute of the capabilities document
    074         *
    075         * @return the value of the version attribute of the capabilities document
    076         */
    077        @Override
    078        public String parseVersion() {
    079            return this.getRootElement().getAttribute( "version" );
    080        }
    081
    082        /**
    083         * returns the service section of the configuration/capabilities. vendorspecific capabilities
    084         * are not supported yet
    085         *
    086         * @param namespaceURI
    087         *
    088         * @return the service section of the configuration/capabilities. vendorspecific capabilities
    089         *         are not supported yet
    090         * @throws InvalidCapabilitiesException
    091         */
    092        public Capability getCapabilitySection( URI namespaceURI )
    093                                throws InvalidCapabilitiesException {
    094            try {
    095                Node root = this.getRootElement();
    096
    097                Element element = XMLTools.getRequiredChildElement( "Capability", namespaceURI, root );
    098                Element elem = XMLTools.getRequiredChildElement( "Request", namespaceURI, element );
    099                OperationsMetadata request = parseOperations( elem, namespaceURI );
    100
    101                elem = XMLTools.getRequiredChildElement( "Exception", namespaceURI, element );
    102                ExceptionFormat eFormat = getExceptionFormat( elem, namespaceURI );
    103
    104                // vendorspecific capabilities are not supported yet
    105                // elem = XMLTools.getRequiredChildByName(
    106                // "VendorSpecificCapabilities", WCSNS, element);
    107
    108                String version = element.getAttribute( "version" );
    109                if ( version == null || version.equals( "" ) ) {
    110                    version = this.parseVersion();
    111                }
    112                String updateSequence = element.getAttribute( "updateSequence" );
    113                if ( updateSequence == null || updateSequence.equals( "" ) ) {
    114                    updateSequence = this.getRootElement().getAttribute( "updateSequence" );
    115                }
    116
    117                return new Capability( version, updateSequence, request, eFormat, null );
    118
    119            } catch ( XMLParsingException e ) {
    120                String s = e.getMessage();
    121                throw new InvalidCapabilitiesException( "Error while parsing the Capability "
    122                                                        + "Section of the capabilities\n" + s
    123                                                        + StringTools.stackTraceToString( e ) );
    124            }
    125        }
    126
    127        /**
    128         * creates a <tt>Request</tt> object (instance of WCSCapabilityRequest) from the passed
    129         * element encapsulating the Request part of the WCS Capabiliy section
    130         *
    131         * @param element
    132         * @return created <tt>Request</tt>
    133         * @throws XMLParsingException
    134         */
    135        protected abstract OperationsMetadata parseOperations( Element element, URI namespaceURI )
    136                                throws XMLParsingException;
    137
    138        /**
    139         * creates a <tt>MetadataLink</tt> object from the passed element.
    140         *
    141         * @param element
    142         * @return created <tt>MetadataLink</tt>
    143         * @throws XMLParsingException
    144         */
    145        @Override
    146        protected MetadataLink parseMetadataLink( Element element )
    147                                throws XMLParsingException {
    148            if ( element == null )
    149                return null;
    150
    151            try {
    152                URL reference = new URL( XMLTools.getAttrValue( element, "xlink:href" ) );
    153                String title = XMLTools.getAttrValue( element, "xlink:title" );
    154                URI about = new URI( XMLTools.getAttrValue( element, null, "about", null ) );
    155                String tmp = XMLTools.getAttrValue( element, null, "metadataType", null );
    156                MetadataType metadataType = new MetadataType( tmp );
    157                return new MetadataLink( reference, title, about, metadataType );
    158            } catch ( MalformedURLException e ) {
    159                throw new XMLParsingException( "Couldn't parse metadataLink reference\n"
    160                                               + StringTools.stackTraceToString( e ) );
    161            } catch ( URISyntaxException e ) {
    162                throw new XMLParsingException( "Couldn't parse metadataLink about\n" + StringTools.stackTraceToString( e ) );
    163            }
    164        }
    165
    166        /**
    167         * Creates an <tt>ExceptionFormat</tt> instance from the passed element.
    168         *
    169         * @param element
    170         * @return the new instance
    171         */
    172        protected ExceptionFormat getExceptionFormat( Element element, URI namespaceURI ) {
    173            ElementList el = XMLTools.getChildElements( "Format", namespaceURI, element );
    174            String[] formats = new String[el.getLength()];
    175            for ( int i = 0; i < formats.length; i++ ) {
    176                formats[i] = XMLTools.getStringValue( el.item( i ) );
    177            }
    178            return new ExceptionFormat( formats );
    179        }
    180
    181        /**
    182         * Creates a <code>DCPType</code> object from the passed <code>DCPType</code> element.
    183         * <p>
    184         * NOTE: Currently the <code>OnlineResources</code> included in the <code>DCPType</code> are
    185         * just stored as simple <code>URLs</code> (not as <code>OnLineResource</code> instances)!
    186         * <p>
    187         * NOTE: In an <code>OGCStandardCapabilitiesDocument</code> the <code>XLinks</code> (the
    188         * <code>URLs</code>) are stored in separate elements (<code>OnlineResource</code>), in
    189         * an <code>OGCCommonCapabilitiesDocument</code> they are the
    190         * <code>Get<code>/<code>Post</code> elements themselves.
    191         *
    192         * @param element
    193         * @param namespaceURI
    194         * @return created <code>DCPType</code>
    195         * @throws XMLParsingException
    196         * @see org.deegree.owscommon.OWSCommonCapabilities
    197         */
    198        protected DCPType getDCPType( Element element, URI namespaceURI )
    199                                throws XMLParsingException {
    200            try {
    201                Element elem = XMLTools.getRequiredChildElement( "HTTP", namespaceURI, element );
    202                ElementList el = XMLTools.getChildElements( "Get", namespaceURI, elem );
    203
    204                URL[] get = new URL[el.getLength()];
    205                for ( int i = 0; i < get.length; i++ ) {
    206                    Element ell = XMLTools.getRequiredChildElement( "OnlineResource", namespaceURI, el.item( i ) );
    207                    String s = XMLTools.getRequiredAttrValue( "href", XLNNS, ell );
    208                    get[i] = new URL( s );
    209                }
    210                el = XMLTools.getChildElements( "Post", namespaceURI, elem );
    211
    212                URL[] post = new URL[el.getLength()];
    213                for ( int i = 0; i < post.length; i++ ) {
    214                    Element ell = XMLTools.getRequiredChildElement( "OnlineResource", namespaceURI, el.item( i ) );
    215                    String s = XMLTools.getRequiredAttrValue( "href", XLNNS, ell );
    216                    post[i] = new URL( s );
    217                }
    218                Protocol protocol = new HTTP( get, post );
    219                return new DCPType( protocol );
    220            } catch ( MalformedURLException e ) {
    221                throw new XMLParsingException( "Couldn't parse DCPType onlineresoure URL about\n"
    222                                               + StringTools.stackTraceToString( e ) );
    223            }
    224        }
    225
    226        /**
    227         * Creates an array of <code>DCPType</code> objects from the passed element list.
    228         *
    229         * NOTE: Currently the <code>OnlineResources</code> included in the <code>DCPType</code> are
    230         * just stored as simple <code>URLs</code> (not as <code>OnLineResource</code> instances)!
    231         *
    232         * @param el
    233         * @param namespaceURI
    234         * @return the dcp types
    235         * @throws XMLParsingException
    236         */
    237        protected DCPType[] getDCPTypes( ElementList el, URI namespaceURI )
    238                                throws XMLParsingException {
    239            DCPType[] dcpTypes = new DCPType[el.getLength()];
    240            for ( int i = 0; i < dcpTypes.length; i++ ) {
    241                dcpTypes[i] = getDCPType( el.item( i ), namespaceURI );
    242            }
    243            return dcpTypes;
    244        }
    245    }