    001    // $HeadURL:
    002    // /cvsroot/deegree/src/org/deegree/ogcwebservices/csw/capabilities/CatalogCapabilitiesDocument.java,v
    003    // 1.22 2004/08/05 15:40:08 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.wass.common;
    039
    040    import java.io.IOException;
    041    import java.net.MalformedURLException;
    042    import java.net.URI;
    043    import java.net.URISyntaxException;
    044    import java.net.URL;
    045    import java.util.ArrayList;
    046    import java.util.List;
    047
    048    import org.deegree.datatypes.Code;
    049    import org.deegree.datatypes.xlink.SimpleLink;
    050    import org.deegree.framework.xml.XMLParsingException;
    051    import org.deegree.framework.xml.XMLTools;
    052    import org.deegree.i18n.Messages;
    053    import org.deegree.model.metadata.iso19115.Keywords;
    054    import org.deegree.ogcbase.CommonNamespaces;
    055    import org.deegree.ogcwebservices.getcapabilities.DCPType;
    056    import org.deegree.ogcwebservices.getcapabilities.InvalidCapabilitiesException;
    057    import org.deegree.ogcwebservices.getcapabilities.ServiceIdentification;
    058    import org.deegree.ogcwebservices.getcapabilities.ServiceProvider;
    059    import org.deegree.owscommon.OWSCommonCapabilitiesDocument;
    060    import org.deegree.owscommon.OWSDomainType;
    061    import org.deegree.owscommon.OWSMetadata;
    062    import org.w3c.dom.Element;
    063    import org.w3c.dom.Node;
    064    import org.xml.sax.SAXException;
    065
    066    /**
    067     * The owscapabilities 1.0 specification parser. This class is able to parse the changes made in the
    068     * ows capabilites specifications 1.0.
    069     *
    070     *
    071     * @author <a href="mailto:bezema@lat-lon.de">Rutger Bezema</a>
    072     * @author last edited by: $Author: mschneider $
    073     *
    074     * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18. Jun 2009) $
    075     */
    076    public abstract class OWSCapabilitiesBaseDocument_1_0 extends OWSCommonCapabilitiesDocument {
    077
    078        private static final long serialVersionUID = -3518136831402464466L;
    079
    080        private static final String PRE = CommonNamespaces.OWS_PREFIX + ":";
    081
    082        /**
    083         * Creates an empty document loaded from the template given.
    084         *
    085         * @param template
    086         *            the location/name of the template
    087         * @throws IOException
    088         * @throws SAXException
    089         */
    090        public void createEmptyDocument( String template )
    091                                throws IOException, SAXException {
    092            URL url = OWSCapabilitiesBaseDocument_1_0.class.getResource( template );
    093            if ( url == null ) {
    094                throw new IOException( Messages.getMessage( "WASS_ERROR_RESOURCE_NOT_FOUND", template ) );
    095            }
    096            load( url );
    097        }
    098
    099        /**
    100         * Returns the class representation for the <code>ServiceIdentification</code> section of the
    101         * document, according to the ows 1.0 spec.
    102         *
    103         * @return class representation for the <code>ServiceIdentification</code> section
    104         * @throws XMLParsingException
    105         */
    106        public ServiceIdentification parseServiceIdentification()
    107                                throws XMLParsingException {
    108
    109            Element element = (Element) XMLTools.getRequiredNode( getRootElement(), PRE + "ServiceIdentification",
    110                                                                  nsContext );
    111
    112            // 'ServiceType' element (mandatory)
    113            Element serviceTypeElement = (Element) XMLTools.getRequiredNode( element, PRE + "ServiceType", nsContext );
    114            Code serviceType = null;
    115            try {
    116                String codeSpace = XMLTools.getAttrValue( serviceTypeElement, null, "codeSpace", null );
    117                URI uri = codeSpace != null ? new URI( codeSpace ) : null;
    118                serviceType = new Code( XMLTools.getStringValue( serviceTypeElement ), uri );
    119            } catch ( URISyntaxException e ) {
    120                String s = XMLTools.getAttrValue( serviceTypeElement, null, "codeSpace", null );
    121                throw new XMLParsingException( Messages.getMessage( "WASS_ERROR_CODESPACE_NOT_URI",
    122                                                                new Object[] { s, OWSNS.toString() } ) );
    123            }
    124
    125            // 'ServiceTypeVersion' elements (mandatory)
    126            String[] serviceTypeVersions = XMLTools.getRequiredNodeAsStrings( element, PRE + "ServiceTypeVersion",
    127                                                                              nsContext, ",;" );
    128
    129            // 'Title' element (optional)
    130            String title = XMLTools.getNodeAsString( element, PRE + "Title", nsContext,
    131                                                     Messages.getMessage( "WASS_NO_TITLE" ) );
    132
    133            // 'Abstract' element (optional)
    134            String serviceAbstract = XMLTools.getNodeAsString(
    135                                                               element,
    136                                                               PRE + "Abstract",
    137                                                               nsContext,
    138                                                               Messages.getMessage( "WASS_NO_ABSTRACT_DOCUMENTATION" ) );
    139
    140            // 'Keywords' elements (optional)
    141            List<Node> keywordsList = XMLTools.getNodes( element, PRE + "Keywords", nsContext );
    142            Keywords[] keywords = getKeywords( keywordsList );
    143
    144            // 'Fees' element (optional)
    145            String fees = XMLTools.getNodeAsString( element, PRE + "Fees", nsContext, null );
    146
    147            // 'AccessConstraints' elements (optional)
    148            String[] accessConstraints = XMLTools.getNodesAsStrings( element, PRE + "AccessConstraints", nsContext );
    149
    150            ServiceIdentification serviceIdentification = new ServiceIdentification( serviceType, serviceTypeVersions,
    151                                                                                     title, serviceAbstract, keywords,
    152                                                                                     fees, accessConstraints );
    153            return serviceIdentification;
    154        }
    155
    156        /**
    157         * Wrapper to make it consistent.
    158         *
    159         * @return the ServiceProvider representation
    160         * @throws XMLParsingException
    161         */
    162        public ServiceProvider parseServiceProvider()
    163                                throws XMLParsingException {
    164            return getServiceProvider();
    165        }
    166
    167        /**
    168         * @return the OperationsMetada representation
    169         * @throws XMLParsingException
    170         * @throws InvalidCapabilitiesException
    171         * @throws URISyntaxException
    172         */
    173        public OperationsMetadata_1_0 parseOperationsMetadata()
    174                                throws XMLParsingException, InvalidCapabilitiesException, URISyntaxException {
    175
    176            Element root = (Element) XMLTools.getRequiredNode( getRootElement(), PRE + "OperationsMetadata", nsContext );
    177
    178            ArrayList<Operation_1_0> operations = new ArrayList<Operation_1_0>();
    179
    180            List<Node> nl = XMLTools.getRequiredNodes( root, PRE + "Operation", nsContext );
    181
    182            for ( int i = 0; i < nl.size(); ++i ) {
    183                operations.add( parseOperation( (Element) nl.get( i ) ) );
    184            }
    185
    186            List<Node> parameterList = XMLTools.getNodes( root, PRE + "Parameter", nsContext );
    187            OWSDomainType[] parameters = new OWSDomainType[parameterList.size()];
    188            for ( int i = 0; i < parameters.length; i++ ) {
    189                parameters[i] = parseOWSDomainType_1_0( (Element) parameterList.get( i ) );
    190            }
    191
    192            List<Node> constraintList = XMLTools.getNodes( root, PRE + "Constraint", nsContext );
    193            OWSDomainType[] constraints = new OWSDomainType[constraintList.size()];
    194            for ( int i = 0; i < constraints.length; i++ ) {
    195                constraints[i] = parseOWSDomainType_1_0( (Element) constraintList.get( i ) );
    196            }
    197
    198            String extendedCapabilities = XMLTools.getNodeAsString( root, PRE + "ExtendedCapabilities", nsContext, null );
    199
    200            // find the !not specified in the gdinrw! describeuser
    201            Operation_1_0 describeUser = null;
    202            // and find the GetCapabilities operation too.
    203            Operation_1_0 getCapa = null;
    204            for ( int i = 0; i < operations.size(); ++i ) {
    205                if ( operations.get( i ).getName().equalsIgnoreCase( "describeUser" ) ) {
    206                    describeUser = operations.get( i );
    207                }
    208                if ( operations.get( i ).getName().equalsIgnoreCase( "GetCapabilities" ) ) {
    209                    getCapa = operations.get( i );
    210                }
    211            }
    212
    213            if ( getCapa == null ) {
    214                throw new InvalidCapabilitiesException(
    215                                                        Messages.getMessage(
    216                                                                         "WASS_ERROR_CAPABILITIES_MISSING_REQUIRED_OPERATION",
    217                                                                         "GetCapabilities" ) );
    218            }
    219            if ( describeUser == null ) {
    220                throw new InvalidCapabilitiesException(
    221                                                        Messages.getMessage(
    222                                                                         "WASS_ERROR_CAPABILITIES_MISSING_REQUIRED_OPERATION",
    223                                                                         "DescribeUser" ) );
    224            }
    225
    226            OperationsMetadata_1_0 om = new OperationsMetadata_1_0(
    227                                                                    operations.toArray( new Operation_1_0[operations.size()] ),
    228                                                                    parameters, constraints, extendedCapabilities,
    229                                                                    describeUser, getCapa );
    230
    231
    232
    233            return om;
    234        }
    235
    236        /**
    237         * @param root
    238         *            the root node of the Operation xml fragment.
    239         * @return The operation representation 1.0 conform
    240         * @throws XMLParsingException
    241         * @throws URISyntaxException
    242         */
    243        @SuppressWarnings("unchecked")
    244        public Operation_1_0 parseOperation( Element root )
    245                                throws XMLParsingException, URISyntaxException {
    246
    247            DCPType[] dcps = getDCPs( XMLTools.getRequiredElements( root, PRE + "DCP", nsContext ) );
    248
    249            String name = XMLTools.getAttrValue( root, null, "name", null );
    250
    251            List parameterList = XMLTools.getNodes( root, PRE + "Parameter", nsContext );
    252            OWSDomainType[] parameters = new OWSDomainType[parameterList.size()];
    253            for ( int i = 0; i < parameters.length; i++ ) {
    254                parameters[i] = parseOWSDomainType_1_0( (Element) parameterList.get( i ) );
    255            }
    256
    257            List constraintList = XMLTools.getNodes( root, PRE + "Constraint", nsContext );
    258            OWSDomainType[] constraints = new OWSDomainType[constraintList.size()];
    259            for ( int i = 0; i < constraints.length; i++ ) {
    260                constraints[i] = parseOWSDomainType_1_0( (Element) constraintList.get( i ) );
    261            }
    262
    263            List metadata = XMLTools.getNodes( root, PRE + "Metadata", nsContext );
    264
    265            ArrayList<OWSMetadata> metadatas = new ArrayList<OWSMetadata>();
    266
    267            for ( int i = 0; i < metadata.size(); ++i ) {
    268                metadatas.add( parseOWSMetadata( (Element) metadata.get( i ), name ) );
    269            }
    270
    271            Operation_1_0 operation = new Operation_1_0(
    272                                                         name,
    273                                                         dcps,
    274                                                         parameters,
    275                                                         constraints,
    276                                                         (OWSMetadata[]) metadata.toArray( new OWSMetadata[metadata.size()] ) );
    277
    278
    279            return operation;
    280        }
    281
    282        private OWSMetadata parseOWSMetadata( Element root, String name )
    283                                throws XMLParsingException, URISyntaxException {
    284
    285            SimpleLink link = parseSimpleLink( root );
    286            URI about = new URI( XMLTools.getAttrValue( root, null, "about", null ) );
    287
    288            // TODO: find out real name
    289            OWSMetadata md = new OWSMetadata( about, link, name );
    290
    291            return md;
    292        }
    293
    294        /**
    295         * @param element
    296         *            The element to get the Domaintype from.
    297         * @return the OWSDomainType representation.
    298         * @throws XMLParsingException
    299         *
    300         */
    301        private OWSDomainType parseOWSDomainType_1_0( Element element )
    302                                throws XMLParsingException {
    303            return getOWSDomainType( null, element );
    304        }
    305
    306        /**
    307         * @param nameSpace
    308         *            The namespace of the supportedauthenticationlist should be wss or was
    309         * @return ArrayList<SupportedAuthenticationMethod>
    310         * @throws XMLParsingException
    311         * @throws MalformedURLException
    312         */
    313        public ArrayList<SupportedAuthenticationMethod> parseSupportedAuthenticationMethods( String nameSpace )
    314                                throws XMLParsingException, MalformedURLException {
    315            Element capability = (Element) XMLTools.getRequiredNode( getRootElement(), nameSpace + ":Capability", nsContext );
    316            Element methodList = (Element) XMLTools.getRequiredNode( capability, nameSpace
    317                                                                                 + ":SupportedAuthenticationMethodList",
    318                                                                     nsContext );
    319            ArrayList<SupportedAuthenticationMethod> result = new AuthenticationDocument().parseSupportedAuthenticationMethodList( methodList );
    320
    321            return result;
    322        }
    323
    324    }