001: //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/trunk/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 08:39:07 -0800 (Thu, 27 Dec 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:
088: private ISO19115Document iso = new ISO19115Document();
089:
090: /**
091: * @param contents the service specific contents
092: * @return the data object containing all parsed information.
093: * @throws XMLParsingException
094: */
095: public OWSCommonCapabilities parseCapabilities(
096: Map<String, Content> contents) throws XMLParsingException {
097: Element root = getRootElement();
098:
099: String version = XMLTools.getRequiredNodeAsString(root,
100: "@version", nsContext);
101: String updateSequence = XMLTools.getNodeAsString(root,
102: "@updateSequence", nsContext, null);
103:
104: Element elem = (Element) XMLTools.getNode(root, POWS
105: + "ServiceIdentification", nsContext);
106: ServiceIdentification serviceIdentification = null;
107: if (elem != null)
108: serviceIdentification = parseServiceIdentification(elem);
109:
110: elem = (Element) XMLTools.getNode(root, POWS
111: + "ServiceProvider", nsContext);
112: ServiceProvider serviceProvider = null;
113: if (elem != null)
114: serviceProvider = parseServiceProvider(elem);
115:
116: OperationsMetadata operationsMetadata = null;
117: elem = (Element) XMLTools.getNode(root, POWS
118: + "OperationsMetadata", nsContext);
119: if (elem != null)
120: operationsMetadata = parseOperationsMetadata(elem);
121:
122: OWSCommonCapabilities capabilities = new OWSCommonCapabilities(
123: version, updateSequence, serviceIdentification,
124: serviceProvider, operationsMetadata, contents);
125: return capabilities;
126: }
127:
128: private OperationsMetadata parseOperationsMetadata(Element root)
129: throws XMLParsingException {
130: List<Element> operationElements = XMLTools.getRequiredElements(
131: root, POWS + "Operation", nsContext);
132: if (operationElements.size() < 2) {
133: throw new XMLParsingException(
134: "Too few operations defined in the Operations"
135: + "Metadata element.");
136: }
137:
138: List<Operation> operations = new ArrayList<Operation>();
139: for (Element element : operationElements) {
140: operations.add(parseOperation(element));
141: }
142:
143: List<Element> parameterElements = XMLTools.getElements(root,
144: POWS + "Parameter", nsContext);
145: List<Parameter> parameters = new ArrayList<Parameter>();
146:
147: for (Element parameter : parameterElements) {
148: parameters.add(parseDomainType(parameter, true, true,
149: false, false));
150: }
151:
152: List<Element> constraintElements = XMLTools.getElements(root,
153: POWS + "Constraint", nsContext);
154: List<DomainType> constraints = new ArrayList<DomainType>();
155:
156: for (Element constraint : constraintElements) {
157: constraints.add(parseDomainType(constraint, true, true,
158: false, false));
159: }
160:
161: // extended capabilities are ignored for now
162:
163: OperationsMetadata result = new OperationsMetadata(parameters,
164: constraints, operations, null);
165: return result;
166: }
167:
168: private Operation parseOperation(Element root)
169: throws XMLParsingException {
170: QualifiedName name = XMLTools.getRequiredNodeAsQualifiedName(
171: root, "@name", nsContext);
172:
173: List<DCP> dcps = parseDCPs(root);
174:
175: List<Element> parameterElements = XMLTools.getElements(root,
176: POWS + "Parameter", nsContext);
177: List<Parameter> parameters = new ArrayList<Parameter>();
178:
179: for (Element parameter : parameterElements)
180: parameters.add(parseDomainType(parameter, true, true,
181: false, false));
182:
183: List<Element> constraintElements = XMLTools.getElements(root,
184: POWS + "Constraint", nsContext);
185: List<DomainType> constraints = new ArrayList<DomainType>();
186:
187: for (Element constraint : constraintElements)
188: constraints.add(parseDomainType(constraint, true, true,
189: false, false));
190:
191: List<Element> metadataElements = XMLTools.getElements(root,
192: POWS + "Metadata", nsContext);
193: List<Metadata> metadatas = new ArrayList<Metadata>();
194:
195: for (Element metadata : metadataElements)
196: metadatas.add(parseMetadata(metadata));
197:
198: Operation result = new Operation(name, dcps, parameters,
199: constraints, metadatas, "n/a");
200: return result;
201: }
202:
203: // parameter should be the element containing the DCP element
204: private List<DCP> parseDCPs(Element root)
205: throws XMLParsingException {
206: List<DCP> result = new ArrayList<DCP>();
207: List<Element> dcps = XMLTools.getElements(root, POWS + "DCP",
208: nsContext);
209:
210: for (Element dcp : dcps)
211: result.add(parseHTTP(dcp));
212:
213: return result;
214: }
215:
216: private HTTP parseHTTP(Element root) throws XMLParsingException {
217:
218: List<Element> get = XMLTools.getElements(root, POWS + "HTTP/"
219: + POWS + "Get", nsContext);
220: List<Element> post = XMLTools.getElements(root, POWS + "HTTP/"
221: + POWS + "Post", nsContext);
222:
223: if ((get.size() + post.size()) == 0)
224: throw new XMLParsingException(
225: "At least one of Get or Post "
226: + "must be specified under DCP/HTTP.");
227:
228: List<HTTP.Type> types = new ArrayList<HTTP.Type>();
229: List<OnlineResource> links = new ArrayList<OnlineResource>();
230: List<List<DomainType>> constraints = new ArrayList<List<DomainType>>();
231:
232: for (Element elem : get) {
233: OnlineResource link = iso.parseOnlineResource(elem);
234: List<Element> constraintElements = XMLTools.getElements(
235: elem, POWS + "Constraint", nsContext);
236: List<DomainType> myConstr = new ArrayList<DomainType>();
237: for (Element constraint : constraintElements)
238: myConstr.add(parseDomainType(constraint, true, true,
239: false, false));
240:
241: types.add(HTTP.Type.Get);
242: constraints.add(myConstr);
243: links.add(link);
244: }
245:
246: for (Element elem : post) {
247: OnlineResource link = iso.parseOnlineResource(elem);
248: List<Element> constraintElements = XMLTools.getElements(
249: elem, POWS + "Constraint", nsContext);
250: List<DomainType> myConstr = new ArrayList<DomainType>();
251: for (Element constraint : constraintElements)
252: myConstr.add(parseDomainType(constraint, true, true,
253: false, false));
254:
255: types.add(HTTP.Type.Post);
256: constraints.add(myConstr);
257: links.add(link);
258: }
259:
260: return new HTTP(links, constraints, types);
261: }
262:
263: private Metadata parseMetadata(Element root)
264: throws XMLParsingException {
265: SimpleLink link = parseSimpleLink(root);
266: URI about = XMLTools.getNodeAsURI(root, "@about", nsContext,
267: null);
268: return new Metadata(link, about, null);
269: }
270:
271: private DomainType parseDomainType(Element root, boolean optional,
272: boolean repeatable, boolean noValuesAllowed,
273: boolean anyValueAllowed) throws XMLParsingException {
274: String[] valueArray = XMLTools.getRequiredNodesAsStrings(root,
275: POWS + "Value", nsContext);
276: List<TypedLiteral> values = new ArrayList<TypedLiteral>();
277: URI stringURI = null;
278: try {
279: stringURI = new URI(null, "String", null);
280: } catch (URISyntaxException e) {
281: // cannot happen, why do I have to catch this?
282: }
283: for (String value : valueArray)
284: values.add(new TypedLiteral(value, stringURI));
285:
286: List<Element> metadataElements = XMLTools.getElements(root,
287: POWS + "Metadata", nsContext);
288: List<Metadata> metadata = new ArrayList<Metadata>();
289:
290: for (Element element : metadataElements)
291: metadata.add(parseMetadata(element));
292:
293: QualifiedName name = XMLTools.getRequiredNodeAsQualifiedName(
294: root, "@name", nsContext);
295:
296: DomainType result = new DomainType(optional, repeatable, "n/a",
297: 0, name, values, null, null, anyValueAllowed, null,
298: noValuesAllowed, null, null, null, metadata);
299: return result;
300: }
301:
302: private ServiceProvider parseServiceProvider(Element root)
303: throws XMLParsingException {
304: String providerName = XMLTools.getRequiredNodeAsString(root,
305: POWS + "ProviderName", nsContext);
306:
307: OnlineResource providerSite = null;
308: Element siteElement = (Element) XMLTools.getNode(root, POWS
309: + "ProviderSite", nsContext);
310: if (siteElement != null)
311: providerSite = iso.parseOnlineResource(siteElement);
312:
313: Element partyElement = (Element) XMLTools.getRequiredNode(root,
314: POWS + "ServiceContact", nsContext);
315: CitedResponsibleParty party = iso
316: .parseCitedResponsibleParty(partyElement);
317:
318: ServiceProvider result = new ServiceProvider(providerName,
319: providerSite, party);
320: return result;
321: }
322:
323: private ServiceIdentification parseServiceIdentification(
324: Element root) throws XMLParsingException {
325: Element elem = (Element) XMLTools.getRequiredNode(root, POWS
326: + "ServiceType", nsContext);
327: Code serviceType = iso.parseCode(elem);
328:
329: List<String> versions = Arrays.asList(XMLTools
330: .getRequiredNodesAsStrings(root, POWS
331: + "ServiceTypeVersion", nsContext));
332:
333: String fee = XMLTools.getNodeAsString(root, POWS + "Fees",
334: nsContext, null);
335:
336: List<Element> constraintElements = XMLTools.getElements(root,
337: POWS + "AccessConstraints", nsContext);
338: List<Constraints> constraints = new ArrayList<Constraints>();
339:
340: for (Element constraint : constraintElements)
341: constraints.add(iso.parseConstraint(constraint, fee));
342:
343: String title = XMLTools.getNodeAsString(root, POWS + "Title",
344: nsContext, null);
345: String abstractString = XMLTools.getNodeAsString(root, POWS
346: + "Abstract", nsContext, null);
347:
348: List<Element> keywordsElements = XMLTools.getElements(root,
349: POWS + "Keywords", nsContext);
350: List<Keywords> keywords = new ArrayList<Keywords>();
351: for (Element keyword : keywordsElements)
352: keywords.add(iso.parseKeywords(keyword));
353:
354: // the next one is an extension
355: List<String> alternativeTitles = Arrays.asList(XMLTools
356: .getNodesAsStrings(root, POWS + "AlternateTitle",
357: nsContext));
358:
359: Date date = new Date(System.currentTimeMillis());
360:
361: String identification = title;
362:
363: ServiceIdentification result = new ServiceIdentification(
364: serviceType, versions, title, alternativeTitles, date,
365: identification, abstractString, keywords, constraints);
366: return result;
367: }
368:
369: }
|