001 //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.3_testing/src/org/deegree/owscommon_new/OWSCommonCapabilitiesDocument.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 package org.deegree.owscommon_new;
037
038 import java.net.URI;
039 import java.net.URISyntaxException;
040 import java.util.ArrayList;
041 import java.util.Arrays;
042 import java.util.Date;
043 import java.util.List;
044 import java.util.Map;
045
046 import org.deegree.datatypes.Code;
047 import org.deegree.datatypes.QualifiedName;
048 import org.deegree.datatypes.values.TypedLiteral;
049 import org.deegree.datatypes.xlink.SimpleLink;
050 import org.deegree.framework.xml.XMLFragment;
051 import org.deegree.framework.xml.XMLParsingException;
052 import org.deegree.framework.xml.XMLTools;
053 import org.deegree.model.metadata.iso19115.CitedResponsibleParty;
054 import org.deegree.model.metadata.iso19115.Constraints;
055 import org.deegree.model.metadata.iso19115.ISO19115Document;
056 import org.deegree.model.metadata.iso19115.Keywords;
057 import org.deegree.model.metadata.iso19115.OnlineResource;
058 import org.deegree.ogcbase.CommonNamespaces;
059 import org.w3c.dom.Element;
060
061 /**
062 * <code>OWSCommonCapabilitiesDocument</code> is the parser class for the
063 * <code>OWSCommonCapabilities</code> data class.
064 *
065 * @author <a href="mailto:schmitz@lat-lon.de">Andreas Schmitz</a>
066 * @author last edited by: $Author: mschneider $
067 *
068 * @version 2.0, $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18. Jun 2009) $
069 *
070 * @since 2.0
071 */
072
073 public class OWSCommonCapabilitiesDocument extends XMLFragment {
074
075 private static final long serialVersionUID = 5069379023892304513L;
076
077 private static final String POWS = CommonNamespaces.OWS_PREFIX + ":";
078
079 private ISO19115Document iso = new ISO19115Document();
080
081 /**
082 * @param contents
083 * the service specific contents
084 * @return the data object containing all parsed information.
085 * @throws XMLParsingException
086 */
087 public OWSCommonCapabilities parseCapabilities( Map<String, Content> contents )
088 throws XMLParsingException {
089 Element root = getRootElement();
090
091 String version = XMLTools.getRequiredNodeAsString( root, "@version", nsContext );
092 String updateSequence = XMLTools.getNodeAsString( root, "@updateSequence", nsContext, null );
093
094 Element elem = (Element) XMLTools.getNode( root, POWS + "ServiceIdentification", nsContext );
095 ServiceIdentification serviceIdentification = null;
096 if ( elem != null )
097 serviceIdentification = parseServiceIdentification( elem );
098
099 elem = (Element) XMLTools.getNode( root, POWS + "ServiceProvider", nsContext );
100 ServiceProvider serviceProvider = null;
101 if ( elem != null )
102 serviceProvider = parseServiceProvider( elem );
103
104 OperationsMetadata operationsMetadata = null;
105 elem = (Element) XMLTools.getNode( root, POWS + "OperationsMetadata", nsContext );
106 if ( elem != null )
107 operationsMetadata = parseOperationsMetadata( elem );
108
109 OWSCommonCapabilities capabilities = new OWSCommonCapabilities( version, updateSequence, serviceIdentification,
110 serviceProvider, operationsMetadata, contents );
111 return capabilities;
112 }
113
114 private OperationsMetadata parseOperationsMetadata( Element root )
115 throws XMLParsingException {
116 List<Element> operationElements = XMLTools.getRequiredElements( root, POWS + "Operation", nsContext );
117 if ( operationElements.size() < 2 ) {
118 throw new XMLParsingException( "Too few operations defined in the Operations" + "Metadata element." );
119 }
120
121 List<Operation> operations = new ArrayList<Operation>();
122 for ( Element element : operationElements ) {
123 operations.add( parseOperation( element ) );
124 }
125
126 List<Element> parameterElements = XMLTools.getElements( root, POWS + "Parameter", nsContext );
127 List<Parameter> parameters = new ArrayList<Parameter>();
128
129 for ( Element parameter : parameterElements ) {
130 parameters.add( parseDomainType( parameter, true, true, false, false ) );
131 }
132
133 List<Element> constraintElements = XMLTools.getElements( root, POWS + "Constraint", nsContext );
134 List<DomainType> constraints = new ArrayList<DomainType>();
135
136 for ( Element constraint : constraintElements ) {
137 constraints.add( parseDomainType( constraint, true, true, false, false ) );
138 }
139
140 // extended capabilities are ignored for now
141
142 OperationsMetadata result = new OperationsMetadata( parameters, constraints, operations, null );
143 return result;
144 }
145
146 private Operation parseOperation( Element root )
147 throws XMLParsingException {
148 QualifiedName name = XMLTools.getRequiredNodeAsQualifiedName( root, "@name", nsContext );
149
150 List<DCP> dcps = parseDCPs( root );
151
152 List<Element> parameterElements = XMLTools.getElements( root, POWS + "Parameter", nsContext );
153 List<Parameter> parameters = new ArrayList<Parameter>();
154
155 for ( Element parameter : parameterElements )
156 parameters.add( parseDomainType( parameter, true, true, false, false ) );
157
158 List<Element> constraintElements = XMLTools.getElements( root, POWS + "Constraint", nsContext );
159 List<DomainType> constraints = new ArrayList<DomainType>();
160
161 for ( Element constraint : constraintElements )
162 constraints.add( parseDomainType( constraint, true, true, false, false ) );
163
164 List<Element> metadataElements = XMLTools.getElements( root, POWS + "Metadata", nsContext );
165 List<Metadata> metadatas = new ArrayList<Metadata>();
166
167 for ( Element metadata : metadataElements )
168 metadatas.add( parseMetadata( metadata ) );
169
170 Operation result = new Operation( name, dcps, parameters, constraints, metadatas, "n/a" );
171 return result;
172 }
173
174 // parameter should be the element containing the DCP element
175 private List<DCP> parseDCPs( Element root )
176 throws XMLParsingException {
177 List<DCP> result = new ArrayList<DCP>();
178 List<Element> dcps = XMLTools.getElements( root, POWS + "DCP", nsContext );
179
180 for ( Element dcp : dcps )
181 result.add( parseHTTP( dcp ) );
182
183 return result;
184 }
185
186 private HTTP parseHTTP( Element root )
187 throws XMLParsingException {
188
189 List<Element> get = XMLTools.getElements( root, POWS + "HTTP/" + POWS + "Get", nsContext );
190 List<Element> post = XMLTools.getElements( root, POWS + "HTTP/" + POWS + "Post", nsContext );
191
192 if ( ( get.size() + post.size() ) == 0 )
193 throw new XMLParsingException( "At least one of Get or Post " + "must be specified under DCP/HTTP." );
194
195 List<HTTP.Type> types = new ArrayList<HTTP.Type>();
196 List<OnlineResource> links = new ArrayList<OnlineResource>();
197 List<List<DomainType>> constraints = new ArrayList<List<DomainType>>();
198
199 for ( Element elem : get ) {
200 OnlineResource link = iso.parseOnlineResource( elem );
201 List<Element> constraintElements = XMLTools.getElements( elem, POWS + "Constraint", nsContext );
202 List<DomainType> myConstr = new ArrayList<DomainType>();
203 for ( Element constraint : constraintElements )
204 myConstr.add( parseDomainType( constraint, true, true, false, false ) );
205
206 types.add( HTTP.Type.Get );
207 constraints.add( myConstr );
208 links.add( link );
209 }
210
211 for ( Element elem : post ) {
212 OnlineResource link = iso.parseOnlineResource( elem );
213 List<Element> constraintElements = XMLTools.getElements( elem, POWS + "Constraint", nsContext );
214 List<DomainType> myConstr = new ArrayList<DomainType>();
215 for ( Element constraint : constraintElements )
216 myConstr.add( parseDomainType( constraint, true, true, false, false ) );
217
218 types.add( HTTP.Type.Post );
219 constraints.add( myConstr );
220 links.add( link );
221 }
222
223 return new HTTP( links, constraints, types );
224 }
225
226 private Metadata parseMetadata( Element root )
227 throws XMLParsingException {
228 SimpleLink link = parseSimpleLink( root );
229 URI about = XMLTools.getNodeAsURI( root, "@about", nsContext, null );
230 return new Metadata( link, about, null );
231 }
232
233 private DomainType parseDomainType( Element root, boolean optional, boolean repeatable, boolean noValuesAllowed,
234 boolean anyValueAllowed )
235 throws XMLParsingException {
236 String[] valueArray = XMLTools.getRequiredNodesAsStrings( root, POWS + "Value", nsContext );
237 List<TypedLiteral> values = new ArrayList<TypedLiteral>();
238 URI stringURI = null;
239 try {
240 stringURI = new URI( null, "String", null );
241 } catch ( URISyntaxException e ) {
242 // cannot happen, why do I have to catch this?
243 }
244 for ( String value : valueArray )
245 values.add( new TypedLiteral( value, stringURI ) );
246
247 List<Element> metadataElements = XMLTools.getElements( root, POWS + "Metadata", nsContext );
248 List<Metadata> metadata = new ArrayList<Metadata>();
249
250 for ( Element element : metadataElements )
251 metadata.add( parseMetadata( element ) );
252
253 QualifiedName name = XMLTools.getRequiredNodeAsQualifiedName( root, "@name", nsContext );
254
255 DomainType result = new DomainType( optional, repeatable, "n/a", 0, name, values, null, null, anyValueAllowed,
256 null, noValuesAllowed, null, null, null, metadata );
257 return result;
258 }
259
260 private ServiceProvider parseServiceProvider( Element root )
261 throws XMLParsingException {
262 String providerName = XMLTools.getRequiredNodeAsString( root, POWS + "ProviderName", nsContext );
263
264 OnlineResource providerSite = null;
265 Element siteElement = (Element) XMLTools.getNode( root, POWS + "ProviderSite", nsContext );
266 if ( siteElement != null )
267 providerSite = iso.parseOnlineResource( siteElement );
268
269 Element partyElement = (Element) XMLTools.getRequiredNode( root, POWS + "ServiceContact", nsContext );
270 CitedResponsibleParty party = iso.parseCitedResponsibleParty( partyElement );
271
272 ServiceProvider result = new ServiceProvider( providerName, providerSite, party );
273 return result;
274 }
275
276 private ServiceIdentification parseServiceIdentification( Element root )
277 throws XMLParsingException {
278 Element elem = (Element) XMLTools.getRequiredNode( root, POWS + "ServiceType", nsContext );
279 Code serviceType = iso.parseCode( elem );
280
281 List<String> versions = Arrays.asList( XMLTools.getRequiredNodesAsStrings( root, POWS + "ServiceTypeVersion",
282 nsContext ) );
283
284 String fee = XMLTools.getNodeAsString( root, POWS + "Fees", nsContext, null );
285
286 List<Element> constraintElements = XMLTools.getElements( root, POWS + "AccessConstraints", nsContext );
287 List<Constraints> constraints = new ArrayList<Constraints>();
288
289 for ( Element constraint : constraintElements )
290 constraints.add( iso.parseConstraint( constraint, fee ) );
291
292 String title = XMLTools.getNodeAsString( root, POWS + "Title", nsContext, null );
293 String abstractString = XMLTools.getNodeAsString( root, POWS + "Abstract", nsContext, null );
294
295 List<Element> keywordsElements = XMLTools.getElements( root, POWS + "Keywords", nsContext );
296 List<Keywords> keywords = new ArrayList<Keywords>();
297 for ( Element keyword : keywordsElements )
298 keywords.add( iso.parseKeywords( keyword ) );
299
300 // the next one is an extension
301 List<String> alternativeTitles = Arrays.asList( XMLTools.getNodesAsStrings( root, POWS + "AlternateTitle",
302 nsContext ) );
303
304 Date date = new Date( System.currentTimeMillis() );
305
306 String identification = title;
307
308 ServiceIdentification result = new ServiceIdentification( serviceType, versions, title, alternativeTitles,
309 date, identification, abstractString, keywords,
310 constraints );
311 return result;
312 }
313
314 }