001    //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/ogcwebservices/wpvs/capabilities/WPVSCapabilitiesDocument.java $
002    /*----------------------------------------------------------------------------
003     This file is part of deegree, http://deegree.org/
004     Copyright (C) 2001-2009 by:
005       Department of Geography, University of Bonn
006     and
007       lat/lon GmbH
008    
009     This library is free software; you can redistribute it and/or modify it under
010     the terms of the GNU Lesser General Public License as published by the Free
011     Software Foundation; either version 2.1 of the License, or (at your option)
012     any later version.
013     This library is distributed in the hope that it will be useful, but WITHOUT
014     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015     FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016     details.
017     You should have received a copy of the GNU Lesser General Public License
018     along with this library; if not, write to the Free Software Foundation, Inc.,
019     59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020    
021     Contact information:
022    
023     lat/lon GmbH
024     Aennchenstr. 19, 53177 Bonn
025     Germany
026     http://lat-lon.de/
027    
028     Department of Geography, University of Bonn
029     Prof. Dr. Klaus Greve
030     Postfach 1147, 53001 Bonn
031     Germany
032     http://www.geographie.uni-bonn.de/deegree/
033    
034     e-mail: info@deegree.org
035    ----------------------------------------------------------------------------*/
036    
037    package org.deegree.ogcwebservices.wpvs.capabilities;
038    
039    import java.io.IOException;
040    import java.net.MalformedURLException;
041    import java.net.URI;
042    import java.net.URL;
043    import java.util.ArrayList;
044    import java.util.Arrays;
045    import java.util.HashMap;
046    import java.util.List;
047    import java.util.Map;
048    import java.util.Queue;
049    import java.util.concurrent.LinkedBlockingQueue;
050    
051    import org.deegree.datatypes.values.TypedLiteral;
052    import org.deegree.datatypes.values.ValueRange;
053    import org.deegree.datatypes.xlink.SimpleLink;
054    import org.deegree.framework.log.ILogger;
055    import org.deegree.framework.log.LoggerFactory;
056    import org.deegree.framework.util.StringTools;
057    import org.deegree.framework.xml.NamespaceContext;
058    import org.deegree.framework.xml.XMLParsingException;
059    import org.deegree.framework.xml.XMLTools;
060    import org.deegree.i18n.Messages;
061    import org.deegree.model.crs.CRSFactory;
062    import org.deegree.model.crs.CoordinateSystem;
063    import org.deegree.model.crs.UnknownCRSException;
064    import org.deegree.model.metadata.iso19115.Keywords;
065    import org.deegree.model.metadata.iso19115.OnlineResource;
066    import org.deegree.model.spatialschema.Envelope;
067    import org.deegree.model.spatialschema.GeometryFactory;
068    import org.deegree.ogcbase.CommonNamespaces;
069    import org.deegree.ogcwebservices.InvalidParameterValueException;
070    import org.deegree.ogcwebservices.MissingParameterValueException;
071    import org.deegree.ogcwebservices.OGCWebServiceException;
072    import org.deegree.ogcwebservices.getcapabilities.DCPType;
073    import org.deegree.ogcwebservices.getcapabilities.HTTP;
074    import org.deegree.ogcwebservices.getcapabilities.InvalidCapabilitiesException;
075    import org.deegree.ogcwebservices.getcapabilities.OGCCapabilities;
076    import org.deegree.ogcwebservices.getcapabilities.OperationsMetadata;
077    import org.deegree.ogcwebservices.getcapabilities.Protocol;
078    import org.deegree.owscommon.OWSCommonCapabilitiesDocument;
079    import org.deegree.owscommon.OWSMetadata;
080    import org.deegree.owscommon.com110.HTTP110;
081    import org.deegree.owscommon.com110.OWSAllowedValues;
082    import org.deegree.owscommon.com110.OWSDomainType110;
083    import org.deegree.owscommon.com110.OWSRequestMethod;
084    import org.deegree.owscommon.com110.Operation110;
085    import org.w3c.dom.Element;
086    import org.w3c.dom.Node;
087    import org.xml.sax.SAXException;
088    
089    /**
090     * This class represents a <code>WPVSCapabilitiesDocument</code> object.
091     *
092     * @author <a href="mailto:mays@lat-lon.de">Judit Mays</a>
093     * @author last edited by: $Author: mschneider $
094     *
095     * $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
096     *
097     */
098    public class WPVSCapabilitiesDocument extends OWSCommonCapabilitiesDocument {
099    
100        private ArrayList<String> datasetIdentifiers = new ArrayList<String>();
101    
102        private ArrayList<String> styleIdentifiers = new ArrayList<String>();
103    
104        /**
105         *
106         */
107        private static final long serialVersionUID = 2633513531080190745L;
108    
109        private static final ILogger LOG = LoggerFactory.getLogger( WPVSCapabilitiesDocument.class );
110    
111        private static final String XML_TEMPLATE = "WPVSCapabilitiesTemplate.xml";
112    
113        private static String PRE_WPVS = CommonNamespaces.WPVS_PREFIX + ":";
114    
115        private static String PRE_OWS = CommonNamespaces.OWS_PREFIX + ":";
116    
117        /**
118         * Creates a skeleton capabilities document that contains the mandatory elements only.
119         *
120         * @throws IOException
121         * @throws SAXException
122         */
123        public void createEmptyDocument()
124                                         throws IOException, SAXException {
125            URL url = WPVSCapabilitiesDocument.class.getResource( XML_TEMPLATE );
126            if ( url == null ) {
127                throw new IOException( "The resource '" + XML_TEMPLATE + " could not be found." );
128            }
129            load( url );
130        }
131    
132        /**
133         * @see org.deegree.ogcwebservices.getcapabilities.OGCCapabilitiesDocument#parseCapabilities()
134         */
135        @Override
136        public OGCCapabilities parseCapabilities()
137                                                  throws InvalidCapabilitiesException {
138            WPVSCapabilities wpvsCapabilities = null;
139    
140            try {
141                wpvsCapabilities = new WPVSCapabilities( parseVersion(),
142                                                         parseUpdateSequence(),
143                                                         getServiceIdentification(),
144                                                         getServiceProvider(),
145                                                         parseOperationsMetadata( null ),
146                                                         null,
147                                                         getDataset() );
148    
149            } catch ( XMLParsingException e ) {
150                throw new InvalidCapabilitiesException( e.getMessage() + "\n" + StringTools.stackTraceToString( e ) );
151    
152            } catch ( MissingParameterValueException e ) {
153                throw new InvalidCapabilitiesException( e.getMessage() + "\n" + StringTools.stackTraceToString( e ) );
154    
155            } catch ( InvalidParameterValueException e ) {
156                throw new InvalidCapabilitiesException( e.getMessage() + "\n" + StringTools.stackTraceToString( e ) );
157    
158            } catch ( OGCWebServiceException e ) {
159                throw new InvalidCapabilitiesException( e.getMessage() + "\n" + StringTools.stackTraceToString( e ) );
160            }
161    
162            return wpvsCapabilities;
163        }
164    
165        /**
166         * Gets the <code>Dataset</code> object from the root element of the WPVSCapabilities element.
167         *
168         *
169         * @return Returns the Dataset object form root element.
170         * @throws XMLParsingException
171         * @throws OGCWebServiceException
172         * @throws InvalidParameterValueException
173         * @throws MissingParameterValueException
174         */
175        private Dataset getDataset()
176                                    throws XMLParsingException, MissingParameterValueException,
177                                    InvalidParameterValueException, OGCWebServiceException {
178    
179            Element datasetElement = (Element) XMLTools.getRequiredNode( getRootElement(), PRE_WPVS + "Dataset", nsContext );
180            Dataset dataset = parseDataset( datasetElement, null, null, null );
181    
182            return dataset;
183        }
184    
185        /**
186         * Creates and returns a new <code>Dataset</code> object from the given <code>Element</code> and the parent
187         * <code>Dataset</code> object.
188         *
189         * @param datasetElement
190         * @param parent
191         *            may be null if root node
192         * @param defaultCoordinateSystem
193         * @param defaultElevationModel
194         * @return Returns a new Dataset object.
195         * @throws XMLParsingException
196         * @throws OGCWebServiceException
197         * @throws InvalidParameterValueException
198         */
199        private Dataset parseDataset( Element datasetElement, Dataset parent, CoordinateSystem defaultCoordinateSystem,
200                                      ElevationModel defaultElevationModel )
201                                                                            throws XMLParsingException,
202                                                                            InvalidParameterValueException,
203                                                                            OGCWebServiceException {
204    
205            // attributes are all optional
206            boolean queryable = XMLTools.getNodeAsBoolean( datasetElement, "@queryable", nsContext, false );
207            boolean opaque = XMLTools.getNodeAsBoolean( datasetElement, "@opaque", nsContext, false );
208            boolean noSubsets = XMLTools.getNodeAsBoolean( datasetElement, "@noSubsets", nsContext, false );
209            int fixedWidth = XMLTools.getNodeAsInt( datasetElement, "@fixedWidth", nsContext, 0 );
210            int fixedHeight = XMLTools.getNodeAsInt( datasetElement, "@fixedHeight", nsContext, 0 );
211    
212            // elements
213            String name = XMLTools.getNodeAsString( datasetElement, PRE_WPVS + "Name/text()", nsContext, null );
214            String title = XMLTools.getRequiredNodeAsString( datasetElement, PRE_WPVS + "Title/text()", nsContext );
215            String abstract_ = XMLTools.getNodeAsString( datasetElement, PRE_WPVS + "Abstract/text()", nsContext, null );
216            // keywords == optional
217            Keywords[] keywords = getKeywords( XMLTools.getNodes( datasetElement, PRE_OWS + "Keywords", nsContext ) );
218            // crsstrings == optional
219            String[] crsStrings = XMLTools.getNodesAsStrings( datasetElement, PRE_WPVS + "CRS/text()", nsContext );
220            List<CoordinateSystem> crsList = parseCoordinateSystems( crsStrings );
221            ElevationModel elevationModel = parseElevationModel( datasetElement, defaultElevationModel );
222            // create a default ElevationModel if not exists allready, a little HACK to circumvent the
223            // optional deegree:dataset:ElevationModel mapping onto the mandatory
224            // ogc:dataset:ElevationModel
225            if ( defaultElevationModel == null && elevationModel != null ) {
226                defaultElevationModel = elevationModel;
227                // found an ElevationModel setting it to default
228                // and update the parents of this dataset, until we have the root,
229    
230                if ( parent != null ) {
231                    // first find root parent
232                    Dataset tmpParent = parent;
233                    while ( tmpParent.getParent() != null ) {
234                        tmpParent = tmpParent.getParent();
235                    }
236                    // now iterate over all so far created children to set an default elevationmodel
237                    tmpParent.setElevationModel( defaultElevationModel );
238                    Queue<Dataset> children = new LinkedBlockingQueue<Dataset>( Arrays.asList( tmpParent.getDatasets() ) );
239                    while ( !children.isEmpty() ) {
240                        Dataset child = children.poll();
241                        if ( child != null ) {
242                            child.setElevationModel( defaultElevationModel );
243                            for ( Dataset dataset : child.getDatasets() ) {
244                                children.offer( dataset );
245                            }
246                        }
247                    }
248                }
249            }
250            // now find a defaultcoordinatesystem to use if no crs is given in a child dataset
251            if ( parent == null ) { // root dataset
252                if ( crsList.size() == 0 || crsList.get( 0 ) == null ) {
253                    throw new InvalidCapabilitiesException( Messages.getMessage( "WPVS_NO_TOPLEVEL_DATASET_CRS", title ) );
254                }
255                defaultCoordinateSystem = crsList.get( 0 );
256            }
257    
258            String[] format = XMLTools.getRequiredNodesAsStrings( datasetElement, PRE_WPVS + "Format/text()", nsContext );
259            // wgs84 == mandatory
260            Element boundingBoxElement = (Element) XMLTools.getRequiredNode( datasetElement,
261                                                                             PRE_OWS + "WGS84BoundingBox",
262                                                                             nsContext );
263            Envelope wgs84BoundingBox = getWGS84BoundingBoxType( boundingBoxElement );
264    
265            // boundingboxes can be used to make a more precise specification of the useable area of
266            // this dataset in it's native crs's, the wgs84 bbox can be inaccurate
267            Envelope[] boundingBoxes = getBoundingBoxes( datasetElement, defaultCoordinateSystem );
268    
269            // optional
270            Dimension[] dimensions = parseDimensions( datasetElement );
271    
272            // optional
273            DataProvider dataProvider = parseDataProvider( datasetElement );
274    
275            // mandatory
276            Identifier identifier = parseDatasetIdentifier( datasetElement, PRE_WPVS + "Identifier" );
277    
278            // optional
279            MetaData[] metaData = parseMetaData( datasetElement );
280    
281            // optional
282            DatasetReference[] datasetRefs = parseDatasetReferences( datasetElement );
283    
284            // optional
285            FeatureListReference[] featureListRefs = parseFeatureListReferences( datasetElement );
286    
287            // optional
288            Style[] style = parseStyles( datasetElement );
289    
290            // mandatory
291            double minScaleDenom = XMLTools.getRequiredNodeAsDouble( datasetElement,
292                                                                     PRE_WPVS + "MinimumScaleDenominator/text()",
293                                                                     nsContext );
294            // mandatory
295            double maxScaleDenom = XMLTools.getRequiredNodeAsDouble( datasetElement,
296                                                                     PRE_WPVS + "MaximumScaleDenominator/text()",
297                                                                     nsContext );
298    
299            if ( minScaleDenom > maxScaleDenom ) {
300                throw new InvalidCapabilitiesException( Messages.getMessage( "WPVS_WRONG_SCALE_DENOMINATORS" ) );
301            }
302    
303            // create new root dataset
304            Dataset dataset = new Dataset( queryable,
305                                           opaque,
306                                           noSubsets,
307                                           fixedWidth,
308                                           fixedHeight,
309                                           name,
310                                           title,
311                                           abstract_,
312                                           keywords,
313                                           crsList,
314                                           format,
315                                           wgs84BoundingBox,
316                                           boundingBoxes,
317                                           dimensions,
318                                           dataProvider,
319                                           identifier,
320                                           metaData,
321                                           datasetRefs,
322                                           featureListRefs,
323                                           style,
324                                           minScaleDenom,
325                                           maxScaleDenom,
326                                           null,
327                                           elevationModel,
328                                           null,
329                                           parent );
330    
331            // get child datasets
332            List<Node> nl = XMLTools.getNodes( datasetElement, PRE_WPVS + "Dataset", nsContext );
333            Dataset[] childDatasets = new Dataset[nl.size()];
334            for ( int i = 0; i < childDatasets.length; i++ ) {
335                childDatasets[i] = parseDataset( (Element) nl.get( i ),
336                                                 dataset,
337                                                 defaultCoordinateSystem,
338                                                 defaultElevationModel );
339            }
340    
341            // set child datasets
342            dataset.setDatasets( childDatasets );
343    
344            return dataset;
345        }
346    
347        /**
348         * @param coordinateStrings
349         *            the Strings to create the coordinates from
350         * @return a List of coordinatesystems, if no coordinateString were given (null || length==0 ) an emtpy list is
351         *         returned.
352         */
353        protected List<CoordinateSystem> parseCoordinateSystems( String[] coordinateStrings ) {
354            if ( coordinateStrings == null )
355                return new ArrayList<CoordinateSystem>();
356            ArrayList<CoordinateSystem> crsList = new ArrayList<CoordinateSystem>( coordinateStrings.length );
357            for ( String tmpCRS : coordinateStrings ) {
358                try {
359                    CoordinateSystem crs = CRSFactory.create( tmpCRS );
360                    crsList.add( crs );
361                } catch ( UnknownCRSException e ) {
362                    // fail configuration notify the user
363                    LOG.logError( e.getLocalizedMessage(), e );
364                }
365            }
366            return crsList;
367        }
368    
369        /**
370         * Creates and returns a new <code>ElevationModel</code> object from the given <code>Element</code>.
371         *
372         * This OGC ElevationModel contains only a String. ATTENTION ogc elevation model is mandatory, we IGNORE this and
373         * say it's mandatory.
374         *
375         * @param datasetElement
376         * @param defaultElevationModel
377         *            the defaultElevationModel will be used if no elevationmodel was defined in this dataset(for example
378         *            the topdatasets dgm-name)
379         * @return Returns the ElevationModel object or <code>null</code> if none defined (optional)
380         * @throws XMLParsingException
381         */
382        private ElevationModel parseElevationModel( Element datasetElement, ElevationModel defaultElevationModel )
383                                                                                                                  throws XMLParsingException {
384            // ATTENTION ogc elevation model is mandatory, we IGNORE it for the capabilities.
385            String name = XMLTools.getNodeAsString( datasetElement, PRE_WPVS + "ElevationModel/text()", nsContext, null );
386            if ( name == null ) {
387                if ( defaultElevationModel == null ) {
388                    return null;
389                }
390                return defaultElevationModel;
391            }
392            ElevationModel elevationModel = new ElevationModel( name );
393    
394            return elevationModel;
395        }
396    
397        /**
398         * Creates and returns a new array of <code>Style</code> objects from the given <code>Element</code>.
399         *
400         * @param datasetElement
401         * @return Returns a new array of Style objects or <code>null</code> if none were defined
402         * @throws XMLParsingException
403         * @throws InvalidCapabilitiesException
404         */
405        protected Style[] parseStyles( Element datasetElement )
406                                                               throws XMLParsingException, InvalidCapabilitiesException {
407    
408            List<Node> styleList = XMLTools.getNodes( datasetElement, PRE_WPVS + "Style", nsContext );
409            // optional therefore return null if not present
410            if ( styleList.size() == 0 ) {
411                return null;
412            }
413    
414            Style[] styles = new Style[styleList.size()];
415    
416            for ( int i = 0; i < styles.length; i++ ) {
417    
418                Element styleElement = (Element) styleList.get( i );
419    
420                String name = XMLTools.getRequiredNodeAsString( styleElement, PRE_WPVS + "Name/text()", nsContext );
421                String title = XMLTools.getRequiredNodeAsString( styleElement, PRE_WPVS + "Title/text()", nsContext );
422                String abstract_ = XMLTools.getRequiredNodeAsString( styleElement, PRE_WPVS + "Abstract/text()", nsContext );
423                // optional
424                Keywords[] keywords = getKeywords( XMLTools.getNodes( styleElement, PRE_OWS + "Keywords", nsContext ) );
425                // mandatory
426                Identifier identifier = parseStyleIdentifier( styleElement, PRE_WPVS + "Identifier" );
427    
428                // optional
429                LegendURL[] legendURLs = parseLegendURLs( styleElement );
430    
431                // optional
432                StyleSheetURL styleSheetURL = parseStyleSheetURL( styleElement );
433                StyleURL styleURL = parseStyleURL( styleElement );
434    
435                styles[i] = new Style( name, title, abstract_, keywords, identifier, legendURLs, styleSheetURL, styleURL );
436            }
437    
438            return styles;
439        }
440    
441        /**
442         * Creates and returns a new <code>StyleURL</code> object from the given <code>Element</code>.
443         *
444         * @param styleElement
445         * @return Returns a new StyleURL object or <code>null</code> if not defined (optional)
446         * @throws XMLParsingException
447         * @throws InvalidCapabilitiesException
448         */
449        private StyleURL parseStyleURL( Element styleElement )
450                                                              throws XMLParsingException, InvalidCapabilitiesException {
451    
452            Element styleURLElement = (Element) XMLTools.getNode( styleElement, PRE_WPVS + "StyleURL", nsContext );
453            if ( styleURLElement == null ) {
454                return null;
455            }
456            String format = XMLTools.getRequiredNodeAsString( styleURLElement, PRE_WPVS + "Format/text()", nsContext );
457    
458            // optional
459            URI onlineResourceURI = XMLTools.getNodeAsURI( styleURLElement,
460                                                           PRE_WPVS + "OnlineResource/@xlink:href",
461                                                           nsContext,
462                                                           null );
463            URL onlineResource = null;
464            if ( onlineResourceURI != null ) {
465                try {
466                    onlineResource = onlineResourceURI.toURL();
467                } catch ( MalformedURLException e ) {
468                    throw new InvalidCapabilitiesException( onlineResourceURI + " does not represent a valid URL: "
469                                                            + e.getMessage() );
470                }
471            }
472            return new StyleURL( format, onlineResource );
473        }
474    
475        /**
476         * Creates and returns a new <code>StyleSheetURL</code> object from the given <code>Element</code>.
477         *
478         * @param styleElement
479         * @return Returns a new StyleSheetURL object or <code>null</code> if no stylSheetURL was given (optional)
480         * @throws XMLParsingException
481         * @throws InvalidCapabilitiesException
482         */
483        private StyleSheetURL parseStyleSheetURL( Element styleElement )
484                                                                        throws XMLParsingException,
485                                                                        InvalidCapabilitiesException {
486    
487            Element styleSheetURLElement = (Element) XMLTools.getNode( styleElement, PRE_WPVS + "StyleSheetURL", nsContext );
488            if ( styleSheetURLElement == null ) {
489                return null;
490            }
491            String format = XMLTools.getRequiredNodeAsString( styleSheetURLElement, PRE_WPVS + "Format/text()", nsContext );
492    
493            // optional onlineResource
494            URI onlineResourceURI = XMLTools.getNodeAsURI( styleSheetURLElement,
495                                                           PRE_WPVS + "OnlineResource/@xlink:href",
496                                                           nsContext,
497                                                           null );
498            URL onlineResource = null;
499            if ( onlineResourceURI != null ) {
500                try {
501                    onlineResource = onlineResourceURI.toURL();
502                } catch ( MalformedURLException e ) {
503                    throw new InvalidCapabilitiesException( onlineResourceURI + " does not represent a valid URL: "
504                                                            + e.getMessage() );
505                }
506            }
507    
508            return new StyleSheetURL( format, onlineResource );
509        }
510    
511        /**
512         * Creates and returns a new array of <code>LegendURL</code> objects from the given <code>Element</code>.
513         *
514         * @param styleElement
515         * @return Returns a new array of LegendURL objects or <code>null</code> if none were defined (optional).
516         * @throws XMLParsingException
517         * @throws InvalidCapabilitiesException
518         */
519        private LegendURL[] parseLegendURLs( Element styleElement )
520                                                                   throws XMLParsingException, InvalidCapabilitiesException {
521    
522            List<Node> legendList = XMLTools.getNodes( styleElement, PRE_WPVS + "LegendURL", nsContext );
523            if ( legendList.size() == 0 ) {
524                return null;
525            }
526    
527            LegendURL[] legendURLs = new LegendURL[legendList.size()];
528    
529            for ( int i = 0; i < legendURLs.length; i++ ) {
530    
531                Element legendURLElement = (Element) legendList.get( i );
532    
533                int width = XMLTools.getRequiredNodeAsInt( legendURLElement, "@width", nsContext );
534                int height = XMLTools.getRequiredNodeAsInt( legendURLElement, "@height", nsContext );
535                if ( width < 0 || height < 0 ) {
536                    throw new InvalidCapabilitiesException( "The attributes width and height of '" + legendURLElement.getNodeName()
537                                                            + "' must be positive!" );
538                }
539    
540                String format = XMLTools.getRequiredNodeAsString( legendURLElement, PRE_WPVS + "Format/text()", nsContext );
541                // optional
542                URI onlineResourceURI = XMLTools.getNodeAsURI( legendURLElement,
543                                                               PRE_WPVS + "OnlineResource/@xlink:href",
544                                                               nsContext,
545                                                               null );
546    
547                URL onlineResource = null;
548                if ( onlineResourceURI != null ) {
549                    try {
550                        onlineResource = onlineResourceURI.toURL();
551                    } catch ( MalformedURLException e ) {
552                        throw new InvalidCapabilitiesException( onlineResourceURI + " does not represent a valid URL: "
553                                                                + e.getMessage() );
554                    }
555                }
556    
557                legendURLs[i] = new LegendURL( width, height, format, onlineResource );
558            }
559            return legendURLs;
560        }
561    
562        /**
563         * Creates and returns a new array of <code>FeatureListReference</code> objects from the given
564         * <code>Element</code>.
565         *
566         * @param datasetElement
567         * @return Returns an array of FeatureListReference instances or <code>null</code> if none were defined
568         *         (optional).
569         * @throws XMLParsingException
570         * @throws InvalidCapabilitiesException
571         */
572        protected FeatureListReference[] parseFeatureListReferences( Element datasetElement )
573                                                                                             throws XMLParsingException,
574                                                                                             InvalidCapabilitiesException {
575    
576            List<Node> featureList = XMLTools.getNodes( datasetElement, PRE_WPVS + "FeatureListReference", nsContext );
577            if ( featureList.size() == 0 ) {
578                return null;
579            }
580            FeatureListReference[] featureRefs = new FeatureListReference[featureList.size()];
581            for ( int i = 0; i < featureRefs.length; i++ ) {
582    
583                Element featureRefElement = (Element) featureList.get( i );
584    
585                String format = XMLTools.getRequiredNodeAsString( featureRefElement, PRE_WPVS + "Format/text()", nsContext );
586    
587                URI onlineResourceURI = XMLTools.getNodeAsURI( featureRefElement,
588                                                               PRE_WPVS + "OnlineResource/@xlink:href",
589                                                               nsContext,
590                                                               null );
591                URL onlineResource = null;
592                if ( onlineResourceURI != null ) {
593                    try {
594                        onlineResource = onlineResourceURI.toURL();
595                    } catch ( MalformedURLException e ) {
596                        throw new InvalidCapabilitiesException( onlineResourceURI + " does not represent a valid URL: "
597                                                                + e.getMessage() );
598                    }
599                }
600                featureRefs[i] = new FeatureListReference( format, onlineResource );
601            }
602            return featureRefs;
603        }
604    
605        /**
606         * Creates and returns a new array of <code>DatasetReference</code> objects from the given <code>Element</code>.
607         *
608         * @param datasetElement
609         * @return Returns a new array of DatasetReference objects or <code>null</code> if no DatasetReferences are
610         *         specified in this dataset (optional)
611         * @throws XMLParsingException
612         * @throws InvalidCapabilitiesException
613         */
614        protected DatasetReference[] parseDatasetReferences( Element datasetElement )
615                                                                                     throws XMLParsingException,
616                                                                                     InvalidCapabilitiesException {
617    
618            List<Node> datasetRefList = XMLTools.getNodes( datasetElement, PRE_WPVS + "DatasetReference", nsContext );
619            if ( datasetRefList == null ) {
620                return null;
621            }
622            DatasetReference[] datasetRefs = new DatasetReference[datasetRefList.size()];
623    
624            for ( int i = 0; i < datasetRefs.length; i++ ) {
625    
626                Element datasetRefElement = (Element) datasetRefList.get( i );
627    
628                String format = XMLTools.getRequiredNodeAsString( datasetRefElement, PRE_WPVS + "Format/text()", nsContext );
629    
630                URI onlineResourceURI = XMLTools.getNodeAsURI( datasetRefElement,
631                                                               PRE_WPVS + "OnlineResource/@xlink:href",
632                                                               nsContext,
633                                                               null );
634                URL onlineResource = null;
635                if ( onlineResourceURI != null ) {
636                    try {
637                        onlineResource = onlineResourceURI.toURL();
638                    } catch ( MalformedURLException e ) {
639                        throw new InvalidCapabilitiesException( onlineResourceURI + " does not represent a valid URL: "
640                                                                + e.getMessage() );
641                    }
642                }
643                datasetRefs[i] = new DatasetReference( format, onlineResource );
644            }
645    
646            return datasetRefs;
647        }
648    
649        /**
650         * Creates and returns a new <code>MetaData</code> object from the given <code>Element</code>.
651         *
652         * @param datasetElement
653         * @return Returns an array of MetaData objects, or <code>null</code> if no metadata was specified in the dataset
654         *         (optional).
655         * @throws XMLParsingException
656         * @throws InvalidCapabilitiesException
657         */
658        protected MetaData[] parseMetaData( Element datasetElement )
659                                                                    throws XMLParsingException,
660                                                                    InvalidCapabilitiesException {
661    
662            List<Node> metaDataList = XMLTools.getNodes( datasetElement, PRE_WPVS + "MetaData", nsContext );
663            if ( metaDataList.size() == 0 ) {
664                return null;
665            }
666            MetaData[] metaData = new MetaData[metaDataList.size()];
667    
668            for ( int i = 0; i < metaData.length; i++ ) {
669    
670                Element metaDataElement = (Element) metaDataList.get( i );
671    
672                String type = XMLTools.getRequiredNodeAsString( metaDataElement, "@type", nsContext );
673    
674                String format = XMLTools.getRequiredNodeAsString( metaDataElement, PRE_WPVS + "Format/text()", nsContext );
675                URI onlineResourceURI = XMLTools.getNodeAsURI( metaDataElement,
676                                                               PRE_WPVS + "OnlineResource/@xlink:href",
677                                                               nsContext,
678                                                               null );
679                URL onlineResource = null;
680                if ( onlineResourceURI != null ) {
681                    try {
682                        onlineResource = onlineResourceURI.toURL();
683                    } catch ( MalformedURLException e ) {
684                        throw new InvalidCapabilitiesException( onlineResourceURI + " does not represent a valid URL: "
685                                                                + e.getMessage() );
686                    }
687                }
688    
689                metaData[i] = new MetaData( type, format, onlineResource );
690            }
691    
692            return metaData;
693        }
694    
695        /**
696         * Creates and returns a new <code>Identifier</code> object from the given <code>Element</code> and the given
697         * <cod>xPathQuery</code>.
698         *
699         * @param element
700         * @param xPathQuery
701         * @return Returns a new Identifier object.
702         * @throws XMLParsingException
703         * @throws InvalidCapabilitiesException
704         *             if no (valid) identifier is found
705         */
706        protected Identifier parseStyleIdentifier( Element element, String xPathQuery )
707                                                                                       throws XMLParsingException,
708                                                                                       InvalidCapabilitiesException {
709    
710            Element identifierElement = (Element) XMLTools.getRequiredNode( element, xPathQuery, nsContext );
711    
712            String value = XMLTools.getStringValue( identifierElement ).trim();
713            if ( "".equals( value ) ) {
714                throw new InvalidCapabilitiesException( Messages.getMessage( "WPVS_NO_VALID_IDENTIFIER", "style" ) );
715            }
716            URI codeSpace = XMLTools.getNodeAsURI( identifierElement, "@codeSpace", nsContext, null );
717    
718            Identifier id = new Identifier( value, codeSpace );
719            if ( styleIdentifiers.contains( id.toString() ) ) {
720                throw new InvalidCapabilitiesException( Messages.getMessage( "WPVS_NO_UNIQUE_IDENTIFIER",
721                                                                             "styles",
722                                                                             id.toString() ) );
723    
724            }
725            styleIdentifiers.add( id.toString() );
726            return id;
727        }
728    
729        /**
730         * Creates and returns a new <code>Identifier</code> object from the given <code>Element</code> and the given
731         * <cod>xPathQuery</code>.
732         *
733         * @param element
734         * @param xPathQuery
735         * @return Returns a new Identifier object.
736         * @throws XMLParsingException
737         * @throws InvalidCapabilitiesException
738         *             if no (valid) identifier is found
739         */
740        protected Identifier parseDatasetIdentifier( Element element, String xPathQuery )
741                                                                                         throws XMLParsingException,
742                                                                                         InvalidCapabilitiesException {
743    
744            Element identifierElement = (Element) XMLTools.getRequiredNode( element, xPathQuery, nsContext );
745    
746            String value = XMLTools.getStringValue( identifierElement ).trim();
747            if ( "".equals( value ) ) {
748                throw new InvalidCapabilitiesException( Messages.getMessage( "WPVS_NO_VALID_IDENTIFIER", "dataset" ) );
749            }
750            URI codeSpace = XMLTools.getNodeAsURI( identifierElement, "@codeSpace", nsContext, null );
751            Identifier id = new Identifier( value, codeSpace );
752            if ( datasetIdentifiers.contains( id.toString() ) ) {
753                throw new InvalidCapabilitiesException( Messages.getMessage( "WPVS_NO_UNIQUE_IDENTIFIER",
754                                                                             "datasets",
755                                                                             id.toString() ) );
756    
757            }
758            datasetIdentifiers.add( id.toString() );
759    
760            return id;
761        }
762    
763        /**
764         * Creates and returns a new <code>DataProvider</code> object from the given <code>Element</code>.
765         *
766         * @param datasetElement
767         * @return Returns a new DataProvider object or <code>null</code>if no provider was defined.
768         * @throws XMLParsingException
769         * @throws InvalidCapabilitiesException
770         */
771        protected DataProvider parseDataProvider( Element datasetElement )
772                                                                          throws XMLParsingException,
773                                                                          InvalidCapabilitiesException {
774    
775            String providerName = null;
776            URL providerSite = null;
777            LogoURL logoURL = null;
778    
779            Element dataProviderElement = (Element) XMLTools.getNode( datasetElement, PRE_WPVS + "DataProvider", nsContext );
780            if ( dataProviderElement == null )
781                return null;
782    
783            providerName = XMLTools.getNodeAsString( dataProviderElement, PRE_WPVS + "ProviderName/text()", nsContext, null );
784            URI providerSiteURI = XMLTools.getNodeAsURI( dataProviderElement,
785                                                         PRE_WPVS + "ProviderSite/@xlink:href",
786                                                         nsContext,
787                                                         null );
788            if ( providerSiteURI != null ) {
789                try {
790                    providerSite = providerSiteURI.toURL();
791                } catch ( MalformedURLException e ) {
792                    throw new InvalidCapabilitiesException( providerSiteURI + " does not represent a valid URL: "
793                                                            + e.getMessage() );
794                }
795            }
796    
797            Node logoURLElement = XMLTools.getNode( dataProviderElement, PRE_WPVS + "LogoURL", nsContext );
798            if ( logoURLElement != null ) {
799    
800                int width = XMLTools.getRequiredNodeAsInt( logoURLElement, "@width", nsContext );
801                int height = XMLTools.getRequiredNodeAsInt( logoURLElement, "@height", nsContext );
802                if ( width < 0 || height < 0 ) {
803                    throw new InvalidCapabilitiesException( "width and height of '" + logoURLElement
804                                                            + "' must be positive!" );
805                }
806    
807                String format = XMLTools.getRequiredNodeAsString( logoURLElement, PRE_WPVS + "Format/text()", nsContext );
808    
809                URI onlineResourceURI = XMLTools.getNodeAsURI( logoURLElement,
810                                                               PRE_WPVS + "OnlineResource/@xlink:href",
811                                                               nsContext,
812                                                               null );
813                URL onlineResource = null;
814                if ( onlineResourceURI != null ) {
815                    try {
816                        onlineResource = onlineResourceURI.toURL();
817                    } catch ( MalformedURLException e ) {
818                        throw new InvalidCapabilitiesException( onlineResourceURI + " does not represent a valid URL: "
819                                                                + e.getMessage() );
820                    }
821                }
822    
823                logoURL = new LogoURL( width, height, format, onlineResource );
824            }
825            return new DataProvider( providerName, providerSite, logoURL );
826        }
827    
828        /**
829         *
830         * @param element
831         * @return the Dimensions of a given element or <code>null</code> if no dimension is found (optional).
832         * @throws XMLParsingException
833         */
834        protected Dimension[] parseDimensions( Element element )
835                                                                throws XMLParsingException {
836    
837            List<Node> nl = XMLTools.getNodes( element, PRE_WPVS + "Dimension", nsContext );
838            if ( nl.size() == 0 ) {
839                return null;
840            }
841            Dimension[] dimensions = new Dimension[nl.size()];
842    
843            for ( int i = 0; i < dimensions.length; i++ ) {
844                Node dimNode = nl.get( i );
845                String name = XMLTools.getRequiredNodeAsString( dimNode, "@name", nsContext );
846                String units = XMLTools.getRequiredNodeAsString( dimNode, "@units", nsContext );
847                String unitSymbol = XMLTools.getNodeAsString( dimNode, "@unitSymbol", nsContext, null );
848                String default_ = XMLTools.getNodeAsString( dimNode, "@default", nsContext, null );
849                Boolean multipleValues = Boolean.valueOf( XMLTools.getNodeAsBoolean( dimNode,
850                                                                                     "@multipleValues",
851                                                                                     nsContext,
852                                                                                     true ) );
853                Boolean nearestValues = Boolean.valueOf( XMLTools.getNodeAsBoolean( dimNode,
854                                                                                    "@nearestValues",
855                                                                                    nsContext,
856                                                                                    true ) );
857                Boolean current = Boolean.valueOf( XMLTools.getNodeAsBoolean( dimNode,
858                                                                              "@current",
859                                                                              nsContext,
860                                                                              true ) );
861                String value = XMLTools.getNodeAsString( dimNode, ".", nsContext, null );
862    
863                dimensions[i] = new Dimension( name,
864                                               units,
865                                               unitSymbol,
866                                               default_,
867                                               multipleValues,
868                                               nearestValues,
869                                               current,
870                                               value );
871            }
872    
873            return dimensions;
874        }
875    
876        /**
877         * Gets an array of <code>boundingBoxes</code> from the given <code>Element</code>. This method returns all
878         * boundingBoxes together in one array.
879         *
880         * @param element
881         * @param defaultCoordinateSystem
882         *            to be used for not defined coordinate system attribute in the bbox element
883         * @return Returns an array of boundingBoxes.
884         * @throws XMLParsingException
885         * @throws InvalidParameterValueException
886         */
887        protected Envelope[] getBoundingBoxes( Element element, CoordinateSystem defaultCoordinateSystem )
888                                                                                                          throws XMLParsingException,
889                                                                                                          InvalidParameterValueException {
890    
891            List<Node> boundingBoxList = XMLTools.getNodes( element, PRE_OWS + "BoundingBox", nsContext );
892    
893            List<Envelope> bboxesList = new ArrayList<Envelope>( boundingBoxList.size() );
894    
895            for ( int i = 0; i < boundingBoxList.size(); i++ ) {
896                bboxesList.add( parseBoundingBox( (Element) boundingBoxList.get( i ), defaultCoordinateSystem ) );
897            }
898    
899            // The ogc_wpvs schema says: wgs84 is mandatory therefore-> not checking parents to use it's
900            // bboxes.
901    
902            // if ( parent != null ) {
903            // Envelope[] boundingBoxes = parent.getBoundingBoxes();
904            // for ( int i = 0; i < boundingBoxes.length; i++ ) {
905            // bboxesList.add( boundingBoxes[i] );
906            // }
907            // }
908    
909            Envelope[] boxes = bboxesList.toArray( new Envelope[bboxesList.size()] );
910            return boxes;
911        }
912    
913        /**
914         * Usable with any BoundingBox. Changed crs from null to given attribute value of crs. Added check for min values to
915         * be smaler than max values.
916         *
917         * Creates an <code>Envelope</code> object from the given element of type <code>ows:WGS84BoundingBox</code> or
918         * <code>ows:BoundingBox</code>.
919         *
920         * @param element
921         * @param defaultCoordinateSystem
922         *            if the crs-attribute of the bbox element is not defined
923         * @return a boundingbox of a dataset
924         * @throws XMLParsingException
925         * @throws InvalidParameterValueException
926         */
927        protected Envelope parseBoundingBox( Element element, CoordinateSystem defaultCoordinateSystem )
928                                                                                                        throws XMLParsingException,
929                                                                                                        InvalidParameterValueException {
930    
931            // Envelope env = getWGS84BoundingBoxType( element );
932    
933            String crsAtt = element.getAttribute( "crs" );
934            CoordinateSystem crs = null;
935            if ( crsAtt == null ) {
936                crs = defaultCoordinateSystem;
937            } else {
938                try {
939                    crs = CRSFactory.create( crsAtt );
940                } catch ( UnknownCRSException e ) {
941                    throw new InvalidParameterValueException( e.getMessage() );
942                }
943            }
944    
945            double[] lowerCorner = XMLTools.getRequiredNodeAsDoubles( element,
946                                                                      PRE_OWS + "LowerCorner/text()",
947                                                                      nsContext,
948                                                                      " " );
949            if ( lowerCorner.length < 2 ) {
950                throw new XMLParsingException( Messages.getMessage( "WPVS_NO_VALID_BBOX_POINT", PRE_OWS + "LowerCorner" ) );
951            }
952            double[] upperCorner = XMLTools.getRequiredNodeAsDoubles( element,
953                                                                      PRE_OWS + "UpperCorner/text()",
954                                                                      nsContext,
955                                                                      " " );
956            if ( upperCorner.length < 2 ) {
957                throw new XMLParsingException( Messages.getMessage( "WPVS_NO_VALID_BBOX_POINT", PRE_OWS + "UpperCorner" ) );
958            }
959            if ( upperCorner.length != lowerCorner.length ) {
960                throw new XMLParsingException( Messages.getMessage( "WPVS_DIFFERENT_BBOX_DIMENSIONS",
961                                                                    PRE_OWS + "LowerCorner",
962                                                                    PRE_OWS + "UpperCorner" ) );
963            }
964    
965            for ( int i = 0; i < upperCorner.length; ++i ) {
966                if ( lowerCorner[i] >= upperCorner[i] ) {
967                    throw new InvalidParameterValueException( Messages.getMessage( "WPVS_WRONG_BBOX_POINT_POSITIONS",
968                                                                                   new Integer( i ),
969                                                                                   new Double( lowerCorner[i] ),
970                                                                                   PRE_OWS + "LowerCorner",
971                                                                                   new Double( upperCorner[i] ),
972                                                                                   PRE_OWS + "UpperCorner" ) );
973    
974                }
975            }
976    
977            return GeometryFactory.createEnvelope( lowerCorner[0], lowerCorner[1], upperCorner[0], upperCorner[1], crs );
978    
979        }
980    
981        /**
982         * Creates and returns a new <code>OperationsMetadata</code> object.
983         *
984         * @param defaultOnlineResource
985         *            to fill in the left out dcp's or <code>null</code> if no default URL was given.
986         *
987         * @return Returns a new OperationsMetadata object.
988         * @throws XMLParsingException
989         * @throws InvalidCapabilitiesException
990         */
991        protected OperationsMetadata parseOperationsMetadata( OnlineResource defaultOnlineResource )
992                                                                                                    throws XMLParsingException,
993                                                                                                    InvalidCapabilitiesException {
994    
995            Node operationMetadata = XMLTools.getRequiredNode( getRootElement(), PRE_OWS + "OperationsMetadata", nsContext );
996            List<Node> operationElementList = XMLTools.getNodes( operationMetadata, PRE_OWS + "Operation", nsContext );
997    
998            Map<String, Element> operations = new HashMap<String, Element>();
999            for ( int i = 0; i < operationElementList.size(); i++ ) {
1000                operations.put( XMLTools.getRequiredNodeAsString( operationElementList.get( i ), "@name", nsContext ),
1001                                (Element) operationElementList.get( i ) );
1002            }
1003    
1004            Operation110 getCapabilities = getOperation110( OperationsMetadata.GET_CAPABILITIES_NAME,
1005                                                            true,
1006                                                            operations,
1007                                                            defaultOnlineResource );
1008            Operation110 getView = getOperation110( WPVSOperationsMetadata.GET_VIEW_NAME,
1009                                                    true,
1010                                                    operations,
1011                                                    defaultOnlineResource );
1012            Operation110 getDescription = getOperation110( WPVSOperationsMetadata.GET_DESCRIPTION_NAME,
1013                                                           false,
1014                                                           operations,
1015                                                           defaultOnlineResource );
1016    
1017            Operation110 get3DFeatureInfo = getOperation110( WPVSOperationsMetadata.GET_3D_FEATURE_INFO,
1018                                                             false,
1019                                                             operations,
1020                                                             defaultOnlineResource );
1021    
1022            Operation110 getLegendGraphics = getOperation110( WPVSOperationsMetadata.GET_LEGEND_GRAPHIC_NAME,
1023                                                              false,
1024                                                              operations,
1025                                                              defaultOnlineResource );
1026    
1027            List<Node> parameterElementList = XMLTools.getNodes( operationMetadata, PRE_OWS + "Parameter", nsContext );
1028            OWSDomainType110[] parameters = new OWSDomainType110[parameterElementList.size()];
1029            for ( int i = 0; i < parameters.length; i++ ) {
1030                parameters[i] = getOWSDomainType110( (Element) parameterElementList.get( i ) );
1031            }
1032    
1033            List<Node> constraintElementList = XMLTools.getNodes( operationMetadata, PRE_OWS + "Constraint", nsContext );
1034            OWSDomainType110[] constraints = new OWSDomainType110[constraintElementList.size()];
1035            for ( int i = 0; i < constraints.length; i++ ) {
1036                constraints[i] = getOWSDomainType110( (Element) constraintElementList.get( i ) );
1037            }
1038    
1039            List<Node> extendedCapsList = XMLTools.getNodes( operationMetadata, PRE_OWS + "ExtendedCapabilities", nsContext );
1040            Object[] extendedCapabilities = new Object[extendedCapsList.size()];
1041            for ( int i = 0; i < extendedCapabilities.length; i++ ) {
1042                extendedCapabilities[i] = extendedCapsList.get( i );
1043            }
1044    
1045            WPVSOperationsMetadata metadata = new WPVSOperationsMetadata( getCapabilities,
1046                                                                          getView,
1047                                                                          getDescription,
1048                                                                          getLegendGraphics,
1049                                                                          parameters,
1050                                                                          constraints,
1051                                                                          extendedCapabilities,
1052                                                                          get3DFeatureInfo );
1053    
1054            return metadata;
1055        }
1056    
1057        /**
1058         * FIXME needs to be handled, when OWSDomainType110 ceases to exist.
1059         *
1060         * @see org.deegree.owscommon.OWSCommonCapabilitiesDocument#getOperation(String, boolean, Map)
1061         *
1062         * @param name
1063         * @param isMandatory
1064         * @param operations
1065         * @return the Operation110 with the given name from the map
1066         * @throws XMLParsingException
1067         * @throws InvalidCapabilitiesException
1068         */
1069        private Operation110 getOperation110( String name, boolean isMandatory, Map<String, Element> operations,
1070                                              OnlineResource defaultOnlineResource )
1071                                                                                    throws XMLParsingException,
1072                                                                                    InvalidCapabilitiesException {
1073    
1074            Operation110 operation = null;
1075            Element operationElement = operations.get( name );
1076            if ( operationElement == null ) {
1077                if ( isMandatory ) {
1078                    throw new XMLParsingException( "Mandatory operation '" + name
1079                                                   + "' not defined in "
1080                                                   + "'OperationsMetadata'-section." );
1081                }
1082            } else {
1083                // 'ows:DCP' - elements
1084                DCPType[] dcps = getDCPs( XMLTools.getRequiredElements( operationElement, PRE_OWS + "DCP", nsContext ) );
1085                //fill in the default online resource if one is missing.
1086                if ( defaultOnlineResource != null ) {
1087                    for ( DCPType dcp : dcps ) {
1088                        Protocol pr = dcp.getProtocol();
1089                        if ( pr != null ) {
1090                            if ( pr instanceof HTTP ) {
1091                                if ( ( (HTTP) pr ).getGetOnlineResources() == null || ( (HTTP) pr ).getGetOnlineResources().length == 0 ) {
1092                                    ( (HTTP) pr ).setGetOnlineResources( new URL[] { defaultOnlineResource.getLinkage()
1093                                                                                                          .getHref() } );
1094                                }
1095                                if ( ( (HTTP) pr ).getPostOnlineResources() == null || ( (HTTP) pr ).getPostOnlineResources().length == 0 ) {
1096                                    ( (HTTP) pr ).setPostOnlineResources( new URL[] { defaultOnlineResource.getLinkage()
1097                                                                                                           .getHref() } );
1098                                }
1099                            }
1100                        }
1101                    }
1102                }
1103    
1104                // 'Parameter' - elements
1105                List<Node> parameterList = XMLTools.getNodes( operationElement, PRE_OWS + "Parameter", nsContext );
1106                OWSDomainType110[] parameters = new OWSDomainType110[parameterList.size()];
1107                for ( int i = 0; i < parameters.length; i++ ) {
1108                    parameters[i] = getOWSDomainType110( (Element) parameterList.get( i ) );
1109                }
1110                // 'Constraint' - elements
1111                List<Node> constraintList = XMLTools.getNodes( operationElement, PRE_OWS + "Constraint", nsContext );
1112                OWSDomainType110[] constraints = new OWSDomainType110[constraintList.size()];
1113                for ( int i = 0; i < constraintList.size(); i++ ) {
1114                    constraints[i] = getOWSDomainType110( (Element) constraintList.get( i ) );
1115                }
1116                // 'ows:Metadata' - element
1117                List<Node> metadataList = XMLTools.getNodes( operationElement, PRE_OWS + "Metadata", nsContext );
1118                OWSMetadata[] metadata = new OWSMetadata[metadataList.size()];
1119                for ( int i = 0; i < metadata.length; i++ ) {
1120                    metadata[i] = getOWSMetadata( operationElement, PRE_OWS + "Metadata", nsContext );
1121                }
1122    
1123                // return new Operation110 object
1124                operation = new Operation110( name, dcps, parameters, constraints, metadata );
1125            }
1126    
1127            return operation;
1128        }
1129    
1130        /**
1131         * FIXME there is a similar method in org.deegree.owscommon.OWSCommonCapabilitiesDocument#getDCP. overrides that
1132         * method!
1133         *
1134         * Creates a <code>DCPType</code> object from the passed <code>DCP</code> element.
1135         *
1136         * @param element
1137         * @return created <code>DCPType</code>
1138         * @throws XMLParsingException
1139         * @see org.deegree.ogcwebservices.getcapabilities.OGCStandardCapabilities
1140         */
1141        @Override
1142        protected DCPType getDCP( Element element )
1143                                                   throws XMLParsingException {
1144            DCPType dcpType = null;
1145            Element httpElement = (Element) XMLTools.getRequiredNode( element, PRE_OWS + "HTTP", nsContext );
1146    
1147            try {
1148                List<Node> requestList = XMLTools.getNodes( httpElement, PRE_OWS + "Get", nsContext );
1149                OWSRequestMethod[] getRequests = new OWSRequestMethod[requestList.size()];
1150                for ( int i = 0; i < getRequests.length; i++ ) {
1151    
1152                    List<Node> constraintList = XMLTools.getNodes( requestList.get( i ), PRE_OWS + "Constraint", nsContext );
1153                    OWSDomainType110[] constraint = new OWSDomainType110[constraintList.size()];
1154                    for ( int j = 0; j < constraint.length; j++ ) {
1155                        constraint[j] = getOWSDomainType110( (Element) constraintList.get( i ) );
1156                    }
1157    
1158                    SimpleLink link = parseSimpleLink( (Element) requestList.get( i ) );
1159    
1160                    getRequests[i] = new OWSRequestMethod( link, constraint );
1161                }
1162    
1163                requestList = XMLTools.getNodes( httpElement, PRE_OWS + "Post", nsContext );
1164                OWSRequestMethod[] postRequests = new OWSRequestMethod[requestList.size()];
1165                for ( int i = 0; i < postRequests.length; i++ ) {
1166    
1167                    List<Node> constraintList = XMLTools.getNodes( requestList.get( i ), PRE_OWS + "Constraint", nsContext );
1168                    OWSDomainType110[] constraint = new OWSDomainType110[constraintList.size()];
1169                    for ( int j = 0; j < constraint.length; j++ ) {
1170                        constraint[j] = getOWSDomainType110( (Element) constraintList.get( i ) );
1171                    }
1172    
1173                    SimpleLink link = parseSimpleLink( (Element) requestList.get( i ) );
1174    
1175                    postRequests[i] = new OWSRequestMethod( link, constraint );
1176                }
1177    
1178                Protocol protocol = new HTTP110( getRequests, postRequests );
1179                dcpType = new DCPType( protocol );
1180    
1181            } catch ( InvalidCapabilitiesException e ) {
1182                throw new XMLParsingException( "Couldn't parse the OWSDomainType110 within DCPType: " + StringTools.stackTraceToString( e ) );
1183            }
1184    
1185            return dcpType;
1186        }
1187    
1188        /**
1189         * FIXME needs to be handled, when OWSDomainType110 ceases to exist.
1190         *
1191         * @see org.deegree.owscommon.OWSCommonCapabilitiesDocument#getOWSDomainType(String, Element)
1192         *
1193         * @param element
1194         * @return Returns owsDomainType110 object.
1195         * @throws InvalidCapabilitiesException
1196         */
1197        private OWSDomainType110 getOWSDomainType110( Element element )
1198                                                                       throws XMLParsingException,
1199                                                                       InvalidCapabilitiesException {
1200    
1201            // 'name' - attribute
1202            String name = XMLTools.getRequiredNodeAsString( element, "@name", nsContext );
1203    
1204            // 'ows:AllowedValues' - element
1205            Element allowedElement = (Element) XMLTools.getNode( element, PRE_OWS + "AllowedValues", nsContext );
1206            OWSAllowedValues allowedValues = null;
1207            if ( allowedElement != null ) {
1208    
1209                // 'ows:Value' - elements
1210                String[] values = XMLTools.getNodesAsStrings( allowedElement, PRE_OWS + "Value/text()", nsContext );
1211                TypedLiteral[] literals = null;
1212                if ( values != null ) {
1213                    literals = new TypedLiteral[values.length];
1214                    for ( int i = 0; i < literals.length; i++ ) {
1215                        literals[i] = new TypedLiteral( values[i], null );
1216                    }
1217                }
1218    
1219                // 'ows:Range' - elements
1220                List<Node> rangeList = XMLTools.getNodes( allowedElement, PRE_OWS + "Range", nsContext );
1221                ValueRange[] ranges = new ValueRange[rangeList.size()];
1222                for ( int i = 0; i < ranges.length; i++ ) {
1223                    String minimum = XMLTools.getNodeAsString( rangeList.get( i ),
1224                                                               PRE_OWS + "MinimumValue",
1225                                                               nsContext,
1226                                                               null );
1227                    String maximum = XMLTools.getNodeAsString( rangeList.get( i ),
1228                                                               PRE_OWS + "MaximumValue",
1229                                                               nsContext,
1230                                                               null );
1231                    String spacing = XMLTools.getNodeAsString( rangeList.get( i ),
1232                                                               PRE_OWS + "Spacing",
1233                                                               nsContext,
1234                                                               null );
1235                    TypedLiteral min = new TypedLiteral( minimum, null );
1236                    TypedLiteral max = new TypedLiteral( maximum, null );
1237                    TypedLiteral space = new TypedLiteral( spacing, null );
1238    
1239                    ranges[i] = new ValueRange( min, max, space );
1240                }
1241    
1242                if ( values.length < 1 && ranges.length < 1 ) {
1243                    throw new XMLParsingException( "At least one 'ows:Value'-element or one 'ows:Range'-element must be defined " + "in each element of type 'ows:AllowedValues'." );
1244                }
1245    
1246                allowedValues = new OWSAllowedValues( literals, ranges );
1247            }
1248    
1249            // FIXME manage elements: ows:AnyValue, ows:NoValues.
1250            boolean anyValue = false;
1251            boolean noValues = false;
1252    
1253            // 'ows:ValuesListReference' - element
1254            OWSMetadata valuesListReference = getOWSMetadata( element, PRE_OWS + "ValuesListReference", nsContext );
1255    
1256            // 'ows:DefaulValue' - element
1257            String defaultValue = XMLTools.getNodeAsString( element, PRE_OWS + "DefaultValue/text()", nsContext, null );
1258    
1259            // 'ows:Meaning' - element
1260            OWSMetadata meaning = getOWSMetadata( element, PRE_OWS + "Meaning", nsContext );
1261    
1262            // 'ows:DataType - element
1263            OWSMetadata dataType = getOWSMetadata( element, PRE_OWS + "DataType", nsContext );
1264    
1265            // choose up to one measurement element
1266            String measurementType = null;
1267            // 'ows:ReferenceSystem' - element
1268            Element referenceElement = (Element) XMLTools.getNode( element, PRE_OWS + "ReferenceSystem", nsContext );
1269            // 'ows:UOM' - element
1270            Element uomElement = (Element) XMLTools.getNode( element, PRE_OWS + "UOM", nsContext );
1271            OWSMetadata measurement = null;
1272    
1273            if ( referenceElement != null && uomElement != null ) {
1274                throw new InvalidCapabilitiesException( "Within an 'ows:DomainType'-Element only one " + "of the following elements is allowed: "
1275                                                        + "'ows:ReferenceSystem' OR 'ows:UOM'." );
1276            } else if ( referenceElement != null ) {
1277                measurementType = OWSDomainType110.REFERENCE_SYSTEM;
1278                measurement = getOWSMetadata( element, PRE_OWS + "ReferenceSystem", nsContext );
1279            } else if ( uomElement != null ) {
1280                measurementType = OWSDomainType110.UOM;
1281                measurement = getOWSMetadata( element, PRE_OWS + "UOM", nsContext );
1282            }
1283    
1284            // 'ows:Metadata' - elements
1285            List<Node> metaList = XMLTools.getNodes( element, PRE_OWS + "Metadata", nsContext );
1286            OWSMetadata[] metadata = new OWSMetadata[metaList.size()];
1287            for ( int i = 0; i < metadata.length; i++ ) {
1288                metadata[i] = getOWSMetadata( (Element) metaList.get( i ), PRE_OWS + "Metadata", nsContext );
1289            }
1290    
1291            // return new OWSDomainType110
1292            OWSDomainType110 domainType110 = null;
1293            if ( allowedValues != null && !anyValue && !noValues && valuesListReference == null ) {
1294                domainType110 = new OWSDomainType110( allowedValues,
1295                                                      defaultValue,
1296                                                      meaning,
1297                                                      dataType,
1298                                                      measurementType,
1299                                                      measurement,
1300                                                      metadata,
1301                                                      name );
1302            } else if ( ( anyValue || noValues ) && allowedValues == null && valuesListReference == null ) {
1303                domainType110 = new OWSDomainType110( anyValue,
1304                                                      noValues,
1305                                                      defaultValue,
1306                                                      meaning,
1307                                                      dataType,
1308                                                      measurementType,
1309                                                      measurement,
1310                                                      metadata,
1311                                                      name );
1312            } else if ( valuesListReference != null && allowedValues == null && !anyValue && !noValues ) {
1313                domainType110 = new OWSDomainType110( valuesListReference,
1314                                                      defaultValue,
1315                                                      meaning,
1316                                                      dataType,
1317                                                      measurementType,
1318                                                      measurement,
1319                                                      metadata,
1320                                                      name );
1321            } else {
1322                throw new InvalidCapabilitiesException( "Only one of the following elements may be " + "contained within an 'ows:DomainType': 'ows:AllowedValues', 'ows:AnyValue', "
1323                                                        + "'ows:NoValues' or 'ows:ValuesListReference'." );
1324            }
1325    
1326            return domainType110;
1327        }
1328    
1329        /**
1330         * FIXME check, wether the URIs go to the correct address within OWSMetadata. So far, no example was given to check
1331         * this with.
1332         *
1333         * Creates and returns a new <code>OWSMetadata</code> object (or null) from the given <code>Element</code> at
1334         * the given <code>XPath</code>.
1335         *
1336         * @param element
1337         * @param xPath
1338         * @param nsContext
1339         * @return Returns a new OWSMetadata object (may be null).
1340         * @throws XMLParsingException
1341         */
1342        private OWSMetadata getOWSMetadata( Element element, String xPath, NamespaceContext nsContext )
1343                                                                                                       throws XMLParsingException {
1344    
1345            Element child = (Element) XMLTools.getNode( element, xPath, nsContext );
1346    
1347            if ( child == null ) {
1348                return null;
1349            }
1350    
1351            // attrib about
1352            URI about = XMLTools.getNodeAsURI( child, "@about", nsContext, null );
1353    
1354            // attribs for SimpleLink
1355            URI href = XMLTools.getNodeAsURI( child, "@xlink:href", nsContext, null );
1356            URI role = XMLTools.getNodeAsURI( child, "@xlink:role", nsContext, null );
1357            URI arcrole = XMLTools.getNodeAsURI( child, "@xlink:arcrole", nsContext, null );
1358            String title = XMLTools.getNodeAsString( child, "@xlink:title", nsContext, null );
1359            String show = XMLTools.getNodeAsString( child, "@xlink:show", nsContext, null );
1360            String actuate = XMLTools.getNodeAsString( child, "@xlink:actuate", nsContext, null );
1361    
1362            // ows:name (ows:AbstractMetaData)
1363            String name = XMLTools.getNodeAsString( child, "text()", nsContext, null );
1364    
1365            SimpleLink link = new SimpleLink( href, role, arcrole, title, show, actuate );
1366    
1367            return new OWSMetadata( about, link, name );
1368        }
1369    
1370    }