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