001 //$HeadURL: svn+ssh://rbezema@svn.wald.intevation.org/deegree/base/branches/2.2_testing/src/org/deegree/owscommon_new/OWSCommonCapabilitiesDocument.java $
002 /*---------------- FILE HEADER ------------------------------------------
003
004 This file is part of deegree.
005 Copyright (C) 2001-2008 by:
006 EXSE, Department of Geography, University of Bonn
007 http://www.giub.uni-bonn.de/deegree/
008 lat/lon GmbH
009 http://www.lat-lon.de
010
011 This library is free software; you can redistribute it and/or
012 modify it under the terms of the GNU Lesser General Public
013 License as published by the Free Software Foundation; either
014 version 2.1 of the License, or (at your option) any later version.
015
016 This library is distributed in the hope that it will be useful,
017 but WITHOUT ANY WARRANTY; without even the implied warranty of
018 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
019 Lesser General Public License for more details.
020
021 You should have received a copy of the GNU Lesser General Public
022 License along with this library; if not, write to the Free Software
023 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
024
025 Contact:
026
027 Andreas Poth
028 lat/lon GmbH
029 Aennchenstr. 19
030 53115 Bonn
031 Germany
032 E-Mail: poth@lat-lon.de
033
034 Prof. Dr. Klaus Greve
035 Department of Geography
036 University of Bonn
037 Meckenheimer Allee 166
038 53115 Bonn
039 Germany
040 E-Mail: greve@giub.uni-bonn.de
041
042
043 ---------------------------------------------------------------------------*/
044 package org.deegree.owscommon_new;
045
046 import java.net.URI;
047 import java.net.URISyntaxException;
048 import java.util.ArrayList;
049 import java.util.Arrays;
050 import java.util.Date;
051 import java.util.List;
052 import java.util.Map;
053
054 import org.deegree.datatypes.Code;
055 import org.deegree.datatypes.QualifiedName;
056 import org.deegree.datatypes.values.TypedLiteral;
057 import org.deegree.datatypes.xlink.SimpleLink;
058 import org.deegree.framework.xml.XMLFragment;
059 import org.deegree.framework.xml.XMLParsingException;
060 import org.deegree.framework.xml.XMLTools;
061 import org.deegree.model.metadata.iso19115.CitedResponsibleParty;
062 import org.deegree.model.metadata.iso19115.Constraints;
063 import org.deegree.model.metadata.iso19115.ISO19115Document;
064 import org.deegree.model.metadata.iso19115.Keywords;
065 import org.deegree.model.metadata.iso19115.OnlineResource;
066 import org.deegree.ogcbase.CommonNamespaces;
067 import org.w3c.dom.Element;
068
069 /**
070 * <code>OWSCommonCapabilitiesDocument</code> is the parser class for the
071 * <code>OWSCommonCapabilities</code> data class.
072 *
073 * @author <a href="mailto:schmitz@lat-lon.de">Andreas Schmitz</a>
074 * @author last edited by: $Author: apoth $
075 *
076 * @version 2.0, $Revision: 9346 $, $Date: 2007-12-27 17:39:07 +0100 (Do, 27 Dez 2007) $
077 *
078 * @since 2.0
079 */
080
081 public class OWSCommonCapabilitiesDocument extends XMLFragment {
082
083 private static final long serialVersionUID = 5069379023892304513L;
084
085 private static final String POWS = CommonNamespaces.OWS_PREFIX + ":";
086
087 private ISO19115Document iso = new ISO19115Document();
088
089 /**
090 * @param contents the service specific contents
091 * @return the data object containing all parsed information.
092 * @throws XMLParsingException
093 */
094 public OWSCommonCapabilities parseCapabilities( Map<String, Content> contents )
095 throws XMLParsingException {
096 Element root = getRootElement();
097
098 String version = XMLTools.getRequiredNodeAsString( root, "@version", nsContext );
099 String updateSequence = XMLTools.getNodeAsString( root, "@updateSequence", nsContext, null );
100
101 Element elem = (Element) XMLTools.getNode( root, POWS + "ServiceIdentification", nsContext );
102 ServiceIdentification serviceIdentification = null;
103 if ( elem != null )
104 serviceIdentification = parseServiceIdentification( elem );
105
106 elem = (Element) XMLTools.getNode( root, POWS + "ServiceProvider", nsContext );
107 ServiceProvider serviceProvider = null;
108 if ( elem != null )
109 serviceProvider = parseServiceProvider( elem );
110
111 OperationsMetadata operationsMetadata = null;
112 elem = (Element) XMLTools.getNode( root, POWS + "OperationsMetadata", nsContext );
113 if ( elem != null )
114 operationsMetadata = parseOperationsMetadata( elem );
115
116 OWSCommonCapabilities capabilities = new OWSCommonCapabilities( version, updateSequence,
117 serviceIdentification,
118 serviceProvider,
119 operationsMetadata,
120 contents );
121 return capabilities;
122 }
123
124 private OperationsMetadata parseOperationsMetadata( Element root )
125 throws XMLParsingException {
126 List<Element> operationElements = XMLTools.getRequiredElements( root, POWS + "Operation",
127 nsContext );
128 if ( operationElements.size() < 2 ) {
129 throw new XMLParsingException( "Too few operations defined in the Operations"
130 + "Metadata element." );
131 }
132
133 List<Operation> operations = new ArrayList<Operation>();
134 for ( Element element : operationElements ) {
135 operations.add( parseOperation( element ) );
136 }
137
138 List<Element> parameterElements = XMLTools.getElements( root, POWS + "Parameter", nsContext );
139 List<Parameter> parameters = new ArrayList<Parameter>();
140
141 for ( Element parameter : parameterElements ) {
142 parameters.add( parseDomainType( parameter, true, true, false, false ) );
143 }
144
145 List<Element> constraintElements = XMLTools.getElements( root, POWS + "Constraint", nsContext );
146 List<DomainType> constraints = new ArrayList<DomainType>();
147
148 for ( Element constraint : constraintElements ) {
149 constraints.add( parseDomainType( constraint, true, true, false, false ) );
150 }
151
152 // extended capabilities are ignored for now
153
154 OperationsMetadata result = new OperationsMetadata( parameters, constraints, operations,
155 null );
156 return result;
157 }
158
159 private Operation parseOperation( Element root )
160 throws XMLParsingException {
161 QualifiedName name = XMLTools.getRequiredNodeAsQualifiedName( root, "@name", nsContext );
162
163 List<DCP> dcps = parseDCPs( root );
164
165 List<Element> parameterElements = XMLTools.getElements( root, POWS + "Parameter", nsContext );
166 List<Parameter> parameters = new ArrayList<Parameter>();
167
168 for ( Element parameter : parameterElements )
169 parameters.add( parseDomainType( parameter, true, true, false, false ) );
170
171 List<Element> constraintElements = XMLTools.getElements( root, POWS + "Constraint", nsContext );
172 List<DomainType> constraints = new ArrayList<DomainType>();
173
174 for ( Element constraint : constraintElements )
175 constraints.add( parseDomainType( constraint, true, true, false, false ) );
176
177 List<Element> metadataElements = XMLTools.getElements( root, POWS + "Metadata", nsContext );
178 List<Metadata> metadatas = new ArrayList<Metadata>();
179
180 for ( Element metadata : metadataElements )
181 metadatas.add( parseMetadata( metadata ) );
182
183 Operation result = new Operation( name, dcps, parameters, constraints, metadatas, "n/a" );
184 return result;
185 }
186
187 // parameter should be the element containing the DCP element
188 private List<DCP> parseDCPs( Element root )
189 throws XMLParsingException {
190 List<DCP> result = new ArrayList<DCP>();
191 List<Element> dcps = XMLTools.getElements( root, POWS + "DCP", nsContext );
192
193 for ( Element dcp : dcps )
194 result.add( parseHTTP( dcp ) );
195
196 return result;
197 }
198
199 private HTTP parseHTTP( Element root )
200 throws XMLParsingException {
201
202 List<Element> get = XMLTools.getElements( root, POWS + "HTTP/" + POWS + "Get", nsContext );
203 List<Element> post = XMLTools.getElements( root, POWS + "HTTP/" + POWS + "Post", nsContext );
204
205 if ( ( get.size() + post.size() ) == 0 )
206 throw new XMLParsingException( "At least one of Get or Post "
207 + "must be specified under DCP/HTTP." );
208
209 List<HTTP.Type> types = new ArrayList<HTTP.Type>();
210 List<OnlineResource> links = new ArrayList<OnlineResource>();
211 List<List<DomainType>> constraints = new ArrayList<List<DomainType>>();
212
213 for ( Element elem : get ) {
214 OnlineResource link = iso.parseOnlineResource( elem );
215 List<Element> constraintElements = XMLTools.getElements( elem, POWS + "Constraint",
216 nsContext );
217 List<DomainType> myConstr = new ArrayList<DomainType>();
218 for ( Element constraint : constraintElements )
219 myConstr.add( parseDomainType( constraint, true, true, false, false ) );
220
221 types.add( HTTP.Type.Get );
222 constraints.add( myConstr );
223 links.add( link );
224 }
225
226 for ( Element elem : post ) {
227 OnlineResource link = iso.parseOnlineResource( elem );
228 List<Element> constraintElements = XMLTools.getElements( elem, POWS + "Constraint",
229 nsContext );
230 List<DomainType> myConstr = new ArrayList<DomainType>();
231 for ( Element constraint : constraintElements )
232 myConstr.add( parseDomainType( constraint, true, true, false, false ) );
233
234 types.add( HTTP.Type.Post );
235 constraints.add( myConstr );
236 links.add( link );
237 }
238
239 return new HTTP( links, constraints, types );
240 }
241
242 private Metadata parseMetadata( Element root )
243 throws XMLParsingException {
244 SimpleLink link = parseSimpleLink( root );
245 URI about = XMLTools.getNodeAsURI( root, "@about", nsContext, null );
246 return new Metadata( link, about, null );
247 }
248
249 private DomainType parseDomainType( Element root, boolean optional, boolean repeatable,
250 boolean noValuesAllowed, boolean anyValueAllowed )
251 throws XMLParsingException {
252 String[] valueArray = XMLTools.getRequiredNodesAsStrings( root, POWS + "Value", nsContext );
253 List<TypedLiteral> values = new ArrayList<TypedLiteral>();
254 URI stringURI = null;
255 try {
256 stringURI = new URI( null, "String", null );
257 } catch ( URISyntaxException e ) {
258 // cannot happen, why do I have to catch this?
259 }
260 for ( String value : valueArray )
261 values.add( new TypedLiteral( value, stringURI ) );
262
263 List<Element> metadataElements = XMLTools.getElements( root, POWS + "Metadata", nsContext );
264 List<Metadata> metadata = new ArrayList<Metadata>();
265
266 for ( Element element : metadataElements )
267 metadata.add( parseMetadata( element ) );
268
269 QualifiedName name = XMLTools.getRequiredNodeAsQualifiedName( root, "@name", nsContext );
270
271 DomainType result = new DomainType( optional, repeatable, "n/a", 0, name, values, null,
272 null, anyValueAllowed, null, noValuesAllowed, null,
273 null, null, metadata );
274 return result;
275 }
276
277 private ServiceProvider parseServiceProvider( Element root )
278 throws XMLParsingException {
279 String providerName = XMLTools.getRequiredNodeAsString( root, POWS + "ProviderName",
280 nsContext );
281
282 OnlineResource providerSite = null;
283 Element siteElement = (Element) XMLTools.getNode( root, POWS + "ProviderSite", nsContext );
284 if ( siteElement != null )
285 providerSite = iso.parseOnlineResource( siteElement );
286
287 Element partyElement = (Element) XMLTools.getRequiredNode( root, POWS + "ServiceContact",
288 nsContext );
289 CitedResponsibleParty party = iso.parseCitedResponsibleParty( partyElement );
290
291 ServiceProvider result = new ServiceProvider( providerName, providerSite, party );
292 return result;
293 }
294
295 private ServiceIdentification parseServiceIdentification( Element root )
296 throws XMLParsingException {
297 Element elem = (Element) XMLTools.getRequiredNode( root, POWS + "ServiceType", nsContext );
298 Code serviceType = iso.parseCode( elem );
299
300 List<String> versions = Arrays.asList( XMLTools.getRequiredNodesAsStrings(
301 root,
302 POWS
303 + "ServiceTypeVersion",
304 nsContext ) );
305
306 String fee = XMLTools.getNodeAsString( root, POWS + "Fees", nsContext, null );
307
308 List<Element> constraintElements = XMLTools.getElements( root, POWS + "AccessConstraints",
309 nsContext );
310 List<Constraints> constraints = new ArrayList<Constraints>();
311
312 for ( Element constraint : constraintElements )
313 constraints.add( iso.parseConstraint( constraint, fee ) );
314
315 String title = XMLTools.getNodeAsString( root, POWS + "Title", nsContext, null );
316 String abstractString = XMLTools.getNodeAsString( root, POWS + "Abstract", nsContext, null );
317
318 List<Element> keywordsElements = XMLTools.getElements( root, POWS + "Keywords", nsContext );
319 List<Keywords> keywords = new ArrayList<Keywords>();
320 for ( Element keyword : keywordsElements )
321 keywords.add( iso.parseKeywords( keyword ) );
322
323 // the next one is an extension
324 List<String> alternativeTitles = Arrays.asList( XMLTools.getNodesAsStrings(
325 root,
326 POWS
327 + "AlternateTitle",
328 nsContext ) );
329
330 Date date = new Date( System.currentTimeMillis() );
331
332 String identification = title;
333
334 ServiceIdentification result = new ServiceIdentification( serviceType, versions, title,
335 alternativeTitles, date,
336 identification, abstractString,
337 keywords, constraints );
338 return result;
339 }
340
341 }