001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/ogcwebservices/wps/XMLFactory.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.ogcwebservices.wps;
037
038 import static org.deegree.ogcbase.CommonNamespaces.WPSNS;
039
040 import java.io.ByteArrayOutputStream;
041 import java.io.IOException;
042 import java.io.StringReader;
043 import java.io.UnsupportedEncodingException;
044 import java.net.URI;
045 import java.net.URL;
046 import java.net.URLEncoder;
047 import java.util.Iterator;
048 import java.util.List;
049 import java.util.Map;
050
051 import org.deegree.datatypes.Code;
052 import org.deegree.datatypes.values.TypedLiteral;
053 import org.deegree.datatypes.values.ValueRange;
054 import org.deegree.framework.util.CharsetUtils;
055 import org.deegree.framework.xml.XMLFragment;
056 import org.deegree.framework.xml.XMLTools;
057 import org.deegree.model.feature.FeatureCollection;
058 import org.deegree.model.feature.FeatureException;
059 import org.deegree.model.feature.GMLFeatureAdapter;
060 import org.deegree.model.spatialschema.Envelope;
061 import org.deegree.model.spatialschema.Position;
062 import org.deegree.ogcwebservices.ExceptionReport;
063 import org.deegree.ogcwebservices.MetadataType;
064 import org.deegree.ogcwebservices.OGCWebServiceException;
065 import org.deegree.ogcwebservices.getcapabilities.Contents;
066 import org.deegree.ogcwebservices.getcapabilities.OperationsMetadata;
067 import org.deegree.ogcwebservices.getcapabilities.ServiceIdentification;
068 import org.deegree.ogcwebservices.getcapabilities.ServiceProvider;
069 import org.deegree.ogcwebservices.wps.capabilities.ProcessOfferings;
070 import org.deegree.ogcwebservices.wps.capabilities.WPSCapabilities;
071 import org.deegree.ogcwebservices.wps.capabilities.WPSCapabilitiesDocument;
072 import org.deegree.ogcwebservices.wps.describeprocess.ComplexData;
073 import org.deegree.ogcwebservices.wps.describeprocess.InputDescription;
074 import org.deegree.ogcwebservices.wps.describeprocess.LiteralInput;
075 import org.deegree.ogcwebservices.wps.describeprocess.LiteralOutput;
076 import org.deegree.ogcwebservices.wps.describeprocess.OutputDescription;
077 import org.deegree.ogcwebservices.wps.describeprocess.ProcessDescription;
078 import org.deegree.ogcwebservices.wps.describeprocess.ProcessDescriptions;
079 import org.deegree.ogcwebservices.wps.describeprocess.ProcessDescriptionsDocument;
080 import org.deegree.ogcwebservices.wps.describeprocess.SupportedCRSs;
081 import org.deegree.ogcwebservices.wps.describeprocess.SupportedComplexData;
082 import org.deegree.ogcwebservices.wps.describeprocess.SupportedUOMs;
083 import org.deegree.ogcwebservices.wps.describeprocess.ProcessDescription.DataInputs;
084 import org.deegree.ogcwebservices.wps.describeprocess.ProcessDescription.ProcessOutputs;
085 import org.deegree.ogcwebservices.wps.execute.ComplexValue;
086 import org.deegree.ogcwebservices.wps.execute.ExecuteDataInputs;
087 import org.deegree.ogcwebservices.wps.execute.ExecuteResponse;
088 import org.deegree.ogcwebservices.wps.execute.ExecuteResponseDocument;
089 import org.deegree.ogcwebservices.wps.execute.IOValue;
090 import org.deegree.ogcwebservices.wps.execute.OutputDefinition;
091 import org.deegree.ogcwebservices.wps.execute.OutputDefinitions;
092 import org.deegree.ogcwebservices.wps.execute.ProcessFailed;
093 import org.deegree.ogcwebservices.wps.execute.ProcessStarted;
094 import org.deegree.ogcwebservices.wps.execute.Status;
095 import org.deegree.ogcwebservices.wps.execute.IOValue.ComplexValueReference;
096 import org.deegree.owscommon.OWSMetadata;
097 import org.deegree.owscommon.com110.OWSAllowedValues;
098 import org.w3c.dom.Document;
099 import org.w3c.dom.Element;
100 import org.w3c.dom.Node;
101 import org.xml.sax.SAXException;
102
103 /**
104 * XMLFactory.java
105 *
106 * Created on 08.03.2006. 23:28:46h
107 *
108 * @author <a href="mailto:christian@kiehle.org">Christian Kiehle</a>
109 * @author <a href="mailto:christian.heier@gmx.de">Christian Heier</a>
110 *
111 * @version 1.0.
112 *
113 * @since 2.0
114 */
115 public class XMLFactory extends org.deegree.owscommon.XMLFactory {
116
117 /**
118 *
119 * @param capabilities
120 * @return an WPSCapabilitiesDocument for the capabilities
121 * @throws IOException
122 */
123 public static WPSCapabilitiesDocument export( WPSCapabilities capabilities )
124 throws IOException {
125
126 WPSCapabilitiesDocument capabilitiesDocument = new WPSCapabilitiesDocument();
127
128 try {
129 capabilitiesDocument.createEmptyDocument();
130 Element root = capabilitiesDocument.getRootElement();
131
132 ServiceIdentification serviceIdentification = capabilities.getServiceIdentification();
133 if ( serviceIdentification != null ) {
134 appendServiceIdentification( root, serviceIdentification );
135 }
136
137 ServiceProvider serviceProvider = capabilities.getServiceProvider();
138 if ( serviceProvider != null ) {
139 appendServiceProvider( root, capabilities.getServiceProvider() );
140 }
141
142 OperationsMetadata operationsMetadata = capabilities.getOperationsMetadata();
143 if ( operationsMetadata != null ) {
144 appendOperationsMetadata( root, operationsMetadata );
145 }
146 Contents contents = capabilities.getContents();
147 if ( contents != null ) {
148 // appendContents(root, contents);
149 }
150 ProcessOfferings processOfferings = capabilities.getProcessOfferings();
151 if ( null != processOfferings ) {
152 appendProcessOfferings( root, processOfferings );
153 }
154
155 } catch ( SAXException e ) {
156 LOG.logError( e.getMessage(), e );
157 }
158
159 return capabilitiesDocument;
160 }
161
162 /**
163 * Appends the DOM representation of the <code>wps:ProcessOfferings</code>- section to the
164 * passed <code>Element</code>.
165 *
166 * @param root
167 * @param processOfferings
168 */
169 private static void appendProcessOfferings( Element root, ProcessOfferings processOfferings ) {
170
171 // Add a <wps:ProcessOfferings>node to the <wps:Capabilities> node
172 Element processOfferingsNode = XMLTools.appendElement( root, WPSNS, "wps:ProcessOfferings", null );
173 // Add <wps:Process> nodes to the <wps:ProcessOfferings> node
174 List<ProcessBrief> processBriefTypeList = processOfferings.getProcessBriefTypesList();
175 if ( null != processBriefTypeList && 0 != processBriefTypeList.size() ) {
176 int size = processBriefTypeList.size();
177 for ( int i = 0; i < size; i++ ) {
178 appendProcessBriefType( processOfferingsNode, processBriefTypeList.get( i ) );
179 }
180 }
181
182 }
183
184 /**
185 * Appends the DOM representation of the <code>ProcessBriefType</code> instance to the passed
186 * <code>Element</code>.
187 *
188 * @param processOfferingsNode
189 * @param processBriefType
190 */
191 private static void appendProcessBriefType( Element processOfferingsNode, ProcessBrief processBriefType ) {
192
193 // Add a <wps:Process> node to the <wps:ProcessOfferings> node
194 Element processBriefTypeNode = XMLTools.appendElement( processOfferingsNode, WPSNS, "wps:Process" );
195 // Add optional attribute "processVersion" to <wps:Process> node if
196 // present
197 String processVersion = processBriefType.getProcessVersion();
198 if ( null != processVersion && !"".equals( processVersion ) ) {
199 processBriefTypeNode.setAttribute( "processVersion", processVersion );
200 }
201
202 // Add mandatory node <ows:Identifier>
203 Code identifier = processBriefType.getIdentifier();
204 if ( null != identifier ) {
205 appendIdentifier( processBriefTypeNode, identifier );
206 } else {
207 LOG.logError( "identifier is null." );
208 }
209
210 // Add mandatory node <ows:Title>
211 String title = processBriefType.getTitle();
212 if ( null != title ) {
213 appendTitle( processBriefTypeNode, title );
214 } else {
215 LOG.logError( "title is null." );
216 }
217
218 // Add optional node <ows:Abstract/>
219
220 String _abstract = processBriefType.getAbstract();
221 if ( null != _abstract ) {
222 appendAbstract( processBriefTypeNode, _abstract );
223 }
224
225 // Add optional nodes <ows:Metadata/>
226 List<MetadataType> metaDataTypeList = processBriefType.getMetadata();
227 if ( null != metaDataTypeList && 0 != metaDataTypeList.size() ) {
228 int size = metaDataTypeList.size();
229 for ( int i = 0; i < size; i++ ) {
230 appendMetaDataType( processBriefTypeNode, metaDataTypeList.get( i ) );
231 }
232 }
233
234 }
235
236 /**
237 *
238 * @param e
239 * @param identifier
240 */
241 private static void appendIdentifier( Element e, Code identifier ) {
242
243 String identifierString = identifier.getCode();
244
245 if ( null != identifierString && !"".equals( identifierString ) ) {
246 XMLTools.appendElement( e, OWSNS, "ows:Identifier", identifierString );
247 } else {
248 LOG.logError( "identifier is empty." );
249 }
250
251 }
252
253 /**
254 *
255 * @param e
256 * @param title
257 */
258 private static void appendTitle( Element e, String title ) {
259
260 if ( !"".equals( title ) ) {
261 XMLTools.appendElement( e, OWSNS, "ows:Title", title );
262 } else {
263 LOG.logError( "title is empty." );
264 }
265
266 }
267
268 /**
269 * Appends the DOM representation of the <code>MetadataType</code> instance to the passed
270 * <code>Element</code>.
271 *
272 * @param e
273 * @param metaDataType
274 */
275 private static void appendMetaDataType( Element e, MetadataType metaDataType ) {
276
277 // Add optional node <ows:Metadata>
278 String metadataTypeValue = metaDataType.value;
279 if ( null != metadataTypeValue && !"".equals( metadataTypeValue ) ) {
280 Element metadataNode = XMLTools.appendElement( e, OWSNS, "ows:Metadata" );
281 metadataNode.setAttributeNS( XLNNS.toString(), "xlink:title", metadataTypeValue );
282 }
283
284 }
285
286 /**
287 *
288 * @param processDescriptions
289 * @return a ProcessDescriptionDocument for the process description
290 * @throws IOException
291 */
292 public static ProcessDescriptionsDocument export( ProcessDescriptions processDescriptions )
293 throws IOException {
294 ProcessDescriptionsDocument processDescriptionsDocument = new ProcessDescriptionsDocument();
295 try {
296 processDescriptionsDocument.createEmptyDocument();
297 Element root = processDescriptionsDocument.getRootElement();
298 List<ProcessDescription> processDescriptionList = processDescriptions.getProcessDescription();
299 if ( null != processDescriptionList ) {
300 int processDescriptionListSize = processDescriptionList.size();
301 for ( int i = 0; i < processDescriptionListSize; i++ ) {
302 ProcessDescription processDescription = processDescriptionList.get( i );
303 appendProcessDescription( root, processDescription );
304 }
305 }
306 } catch ( SAXException sex ) {
307 LOG.logError( sex.getMessage(), sex );
308 }
309
310 return processDescriptionsDocument;
311 }
312
313 /**
314 * Appends the DOM representation of the <code>ProcessDescription</code> instance to the
315 * passed <code>Element</code>..
316 *
317 * @param root
318 * @param processDescription
319 */
320 private static void appendProcessDescription( Element root, ProcessDescription processDescription ) {
321
322 // Add a <wps:ProcessDescription> node to the <wps:ProcessDescriptions>
323 // node
324 Element processDescriptionNode = XMLTools.appendElement( root, WPSNS, "wps:ProcessDescription", null );
325
326 String statusSupported = Boolean.toString( processDescription.isStatusSupported() );
327 processDescriptionNode.setAttribute( "statusSupported", statusSupported );
328
329 String storeSupported = Boolean.toString( processDescription.isStoreSupported() );
330 processDescriptionNode.setAttribute( "storeSupported", storeSupported );
331
332 String processVersion = processDescription.getProcessVersion();
333 processDescriptionNode.setAttribute( "processVersion", processVersion );
334
335 Code identifier = processDescription.getIdentifier();
336 if ( null != identifier ) {
337 appendIdentifier( processDescriptionNode, identifier );
338 } else {
339 LOG.logError( "Identifier is null." );
340 }
341
342 String title = processDescription.getTitle();
343 if ( null != title ) {
344 appendTitle( processDescriptionNode, title );
345 } else {
346 LOG.logError( "title is null." );
347 }
348
349 String _abstract = processDescription.getAbstract();
350 if ( null != _abstract ) {
351 appendAbstract( processDescriptionNode, _abstract );
352 }
353
354 Element metaDataTypeNode = null;
355
356 MetadataType metadataType = null;
357 List<MetadataType> metaDataTypeList = processDescription.getMetadata();
358 int metaDataTypeListSize = metaDataTypeList.size();
359 for ( int i = 0; i < metaDataTypeListSize; i++ ) {
360 metadataType = metaDataTypeList.get( i );
361 metaDataTypeNode = XMLTools.appendElement( processDescriptionNode, OWSNS, "ows:Metadata" );
362 metaDataTypeNode.setAttributeNS( XLNNS.toString(), "xlink:title", metadataType.value );
363 }
364
365 DataInputs dataInputs = processDescription.getDataInputs();
366 appendDataInputs( processDescriptionNode, dataInputs );
367
368 ProcessOutputs processOutputs = processDescription.getProcessOutputs();
369 appendProcessOutputs( processDescriptionNode, processOutputs );
370
371 }
372
373 /**
374 *
375 * @param e
376 * @param _abstract
377 */
378 private static void appendAbstract( Element e, String _abstract ) {
379 if ( !"".equals( _abstract ) ) {
380 XMLTools.appendElement( e, OWSNS, "ows:Abstract", _abstract );
381 } else {
382 LOG.logError( "abstract is empty." );
383 }
384
385 }
386
387 /**
388 *
389 * @param processDescriptionNode
390 * @param dataInputs
391 */
392 private static void appendDataInputs( Element processDescriptionNode, DataInputs dataInputs ) {
393
394 // Add a <wps:DataInputs> node to the <wps:ProcessDescription> node
395 Element dataInputsNode = XMLTools.appendElement( processDescriptionNode, WPSNS, "wps:DataInputs", null );
396 if ( null != dataInputs ) {
397 List<InputDescription> dataInputsList = dataInputs.getInputDescriptions();
398 InputDescription inputDescription = null;
399 int dataInputListSize = dataInputsList.size();
400 for ( int i = 0; i < dataInputListSize; i++ ) {
401 inputDescription = dataInputsList.get( i );
402 appendDataInput( dataInputsNode, inputDescription );
403 }
404 }
405
406 }
407
408 /**
409 *
410 * @param dataInputsNode
411 * @param inputDescription
412 */
413 private static void appendDataInput( Element dataInputsNode, InputDescription inputDescription ) {
414
415 // Add a <wps:DataInput> node to the <wps:DataInputs> node
416 Element inputNode = XMLTools.appendElement( dataInputsNode, WPSNS, "wps:Input", null );
417
418 if ( null != inputNode ) {
419
420 Code identifier = inputDescription.getIdentifier();
421 if ( null != identifier ) {
422 appendIdentifier( inputNode, identifier );
423 } else {
424 LOG.logError( "identifier is null." );
425 }
426
427 String title = inputDescription.getTitle();
428 if ( null != title ) {
429 appendTitle( inputNode, title );
430 } else {
431 LOG.logError( "title is null." );
432 }
433
434 String _abstract = inputDescription.getAbstract();
435 if ( null != _abstract ) {
436 appendAbstract( inputNode, _abstract );
437 }
438
439 try {
440
441 SupportedCRSs supportedCRSs = inputDescription.getBoundingBoxData();
442 ComplexData complexData = inputDescription.getComplexData();
443 LiteralInput literalInput = inputDescription.getLiteralData();
444
445 if ( null != supportedCRSs ) {
446 appendBoundingBoxData( inputNode, supportedCRSs );
447 } else if ( null != complexData ) {
448 appendComplexData( inputNode, complexData );
449 } else if ( null != literalInput ) {
450 appendLiteralInput( inputNode, literalInput );
451 } else {
452 LOG.logError( "a required datatype description is missing." );
453 }
454
455 } catch ( Exception e ) {
456 LOG.logError( e.getMessage(), e );
457 }
458
459 XMLTools.appendElement( inputNode, WPSNS, "wps:MinimumOccurs",
460 String.valueOf( inputDescription.getMinimumOccurs() ) );
461 }
462
463 }
464
465 /**
466 *
467 * @param root
468 * @param processOutputs
469 */
470 private static void appendProcessOutputs( Element root, ProcessOutputs processOutputs ) {
471
472 if ( null != processOutputs ) {
473 // Add a <wps:ProcessOutputs> node to the <wps:ProcessDescription>
474 // node
475 Element processOutputsNode = XMLTools.appendElement( root, WPSNS, "wps:ProcessOutputs", null );
476 OutputDescription outputDescription = null;
477 List<OutputDescription> outputDescriptionList = processOutputs.getOutput();
478 int outputDescriptionListSize = outputDescriptionList.size();
479 for ( int i = 0; i < outputDescriptionListSize; i++ ) {
480 outputDescription = outputDescriptionList.get( i );
481 appendOutputDescription( processOutputsNode, outputDescription );
482 }
483 }
484
485 }
486
487 /**
488 *
489 * @param processOutputsNode
490 * @param outputDescription
491 */
492 private static void appendOutputDescription( Element processOutputsNode, OutputDescription outputDescription ) {
493
494 if ( null != outputDescription ) {
495
496 Element outputNode = XMLTools.appendElement( processOutputsNode, WPSNS, "wps:Output", null );
497
498 Code identifier = outputDescription.getIdentifier();
499 if ( null != identifier ) {
500 appendIdentifier( outputNode, identifier );
501 } else {
502 LOG.logError( "identifier is null." );
503 }
504
505 String title = outputDescription.getTitle();
506 if ( null != title ) {
507 appendTitle( outputNode, title );
508 } else {
509 LOG.logError( "title is null." );
510 }
511
512 String _abstract = outputDescription.getAbstract();
513 if ( null != _abstract ) {
514 appendAbstract( outputNode, _abstract );
515 }
516
517 SupportedCRSs supportedCRSs = outputDescription.getBoundingBoxOutput();
518 ComplexData complexData = outputDescription.getComplexOutput();
519 LiteralOutput literalOutput = outputDescription.getLiteralOutput();
520
521 if ( null != supportedCRSs ) {
522 appendBoundingBoxOutput( outputNode, supportedCRSs );
523 } else if ( null != complexData ) {
524 appendComplexOutput( outputNode, complexData );
525 } else if ( null != literalOutput ) {
526 appendLiteralOutput( outputNode, literalOutput );
527 } else {
528 LOG.logError( "a required output datatype description is missing." );
529 }
530 }
531
532 }
533
534 /**
535 *
536 * @param outputNode
537 * @param complexData
538 */
539 private static void appendComplexOutput( Element outputNode, ComplexData complexData ) {
540
541 String defaultEncoding = complexData.getDefaultEncoding();
542 String defaultFormat = complexData.getDefaultFormat();
543 String defaultSchema = complexData.getDefaultSchema();
544 Element complexDataNode = XMLTools.appendElement( outputNode, WPSNS, "wps:ComplexOutput", null );
545
546 if ( null != defaultFormat && !"".equals( defaultFormat ) ) {
547 complexDataNode.setAttribute( "defaultFormat", defaultFormat );
548 }
549 if ( null != defaultEncoding && !"".equals( defaultEncoding ) ) {
550 complexDataNode.setAttribute( "defaultEncoding", defaultEncoding );
551 }
552 if ( null != defaultSchema && !"".equals( defaultSchema ) ) {
553 complexDataNode.setAttribute( "defaultSchema", defaultSchema );
554 }
555
556 List<SupportedComplexData> supportedComplexDataList = complexData.getSupportedComplexData();
557 int supporteComplexDataListSize = supportedComplexDataList.size();
558 for ( int i = 0; i < supporteComplexDataListSize; i++ ) {
559 appendSupportedComplexData( complexDataNode, supportedComplexDataList.get( i ) );
560 }
561
562 }
563
564 /**
565 *
566 * @param outputNode
567 * @param supportedCRSs
568 */
569 private static void appendBoundingBoxOutput( Element outputNode, SupportedCRSs supportedCRSs ) {
570
571 URI defaultCrs = supportedCRSs.getDefaultCRS();
572 Element defaultCRSs = XMLTools.appendElement( outputNode, WPSNS, "wps:BoundingBoxOutput", null );
573 defaultCRSs.setAttribute( "defaultCRS", defaultCrs.toString() );
574
575 List<URI> crsList = supportedCRSs.getCRS();
576 int crsListSize = crsList.size();
577 for ( int i = 0; i < crsListSize; i++ ) {
578 URI uri = crsList.get( i );
579 XMLTools.appendElement( defaultCRSs, WPSNS, "wps:CRS", uri.toString() );
580 }
581
582 }
583
584 /**
585 *
586 * @param outputNode
587 * @param literalOutput
588 */
589 private static void appendLiteralOutput( Element outputNode, LiteralOutput literalOutput ) {
590
591 Element literalOutputNode = XMLTools.appendElement( outputNode, WPSNS, "wps:LiteralOutput", null );
592 Element owsDataType = XMLTools.appendElement( literalOutputNode, OWSNS, "ows:DataType",
593 literalOutput.getDataType().getName() );
594 owsDataType.setAttribute( "ows:reference", literalOutput.getDataType().getLink().getHref().toString() );
595 Element supportedUOMsNode = XMLTools.appendElement( literalOutputNode, WPSNS, "wps:SupportedUOMs", null );
596
597 supportedUOMsNode.setAttribute( "defaultUOM",
598 literalOutput.getSupportedUOMs().getDefaultUOM().getLink().getHref().toString() );
599
600 List<OWSMetadata> supportedUOMs = literalOutput.getSupportedUOMs().getUOM();
601 int size = supportedUOMs.size();
602 for ( int i = 0; i < size; i++ ) {
603 OWSMetadata uom = supportedUOMs.get( i );
604 Element uomNode = XMLTools.appendElement( supportedUOMsNode, OWSNS, "ows:UOM", null );
605 uomNode.setAttribute( "ows:reference", uom.getLink().getHref().toString() );
606 }
607
608 }
609
610 /**
611 *
612 * @param inputNode
613 * @param complexData
614 */
615 private static void appendComplexData( Element inputNode, ComplexData complexData ) {
616
617 String defaultEncoding = complexData.getDefaultEncoding();
618 String defaultFormat = complexData.getDefaultFormat();
619 String defaultSchema = complexData.getDefaultSchema();
620 Element complexDataNode = XMLTools.appendElement( inputNode, WPSNS, "wps:ComplexData", null );
621
622 if ( null != defaultFormat && !"".equals( defaultFormat ) ) {
623 complexDataNode.setAttribute( "defaultFormat", defaultFormat );
624 }
625 if ( null != defaultEncoding && !"".equals( defaultEncoding ) ) {
626 complexDataNode.setAttribute( "defaultEncoding", defaultEncoding );
627 }
628 if ( null != defaultSchema && !"".equals( defaultSchema ) ) {
629 complexDataNode.setAttribute( "defaultSchema", defaultSchema );
630 }
631
632 List<SupportedComplexData> supportedComplexDataList = complexData.getSupportedComplexData();
633 int supporteComplexDataListSize = supportedComplexDataList.size();
634 for ( int i = 0; i < supporteComplexDataListSize; i++ ) {
635 appendSupportedComplexData( complexDataNode, supportedComplexDataList.get( i ) );
636 }
637
638 }
639
640 /**
641 *
642 * @param complexDataNode
643 * @param supportedComplexData
644 */
645 private static void appendSupportedComplexData( Element complexDataNode, SupportedComplexData supportedComplexData ) {
646
647 Element supportedComplexDataNode = XMLTools.appendElement( complexDataNode, WPSNS, "wps:SupportedComplexData",
648 null );
649
650 XMLTools.appendElement( supportedComplexDataNode, WPSNS, "wps:Format", supportedComplexData.getFormat() );
651
652 XMLTools.appendElement( supportedComplexDataNode, WPSNS, "wps:Encoding", supportedComplexData.getEncoding() );
653
654 XMLTools.appendElement( supportedComplexDataNode, WPSNS, "wps:Schema", supportedComplexData.getSchema() );
655
656 }
657
658 /**
659 *
660 * @param inputNode
661 * @param literalInput
662 */
663 private static void appendLiteralInput( Element inputNode, LiteralInput literalInput ) {
664
665 Element literalDataNode = XMLTools.appendElement( inputNode, WPSNS, "wps:LiteralData", null );
666 Element owsDataType = XMLTools.appendElement( literalDataNode, OWSNS, "ows:DataType",
667 literalInput.getDataType().getName() );
668 owsDataType.setAttribute( "ows:reference", literalInput.getDataType().getLink().getHref().toString() );
669 appendLiteralInputTypes( literalDataNode, literalInput );
670
671 }
672
673 /**
674 *
675 * @param literalDataNode
676 * @param literalInput
677 */
678 private static void appendLiteralInputTypes( Element literalDataNode, LiteralInput literalInput ) {
679
680 Element supportedUOMsNode = XMLTools.appendElement( literalDataNode, WPSNS, "wps:SupportedUOMs", null );
681
682 SupportedUOMs supportedUOMs = literalInput.getSupportedUOMs();
683 if ( null != supportedUOMs ) {
684
685 OWSMetadata defaultUOM = literalInput.getSupportedUOMs().getDefaultUOM();
686 if ( null != defaultUOM ) {
687 supportedUOMsNode.setAttribute(
688 "defaultUOM",
689 literalInput.getSupportedUOMs().getDefaultUOM().getLink().getHref().toString() );
690 }
691
692 List<OWSMetadata> supportedUOMsList = literalInput.getSupportedUOMs().getUOM();
693 int size = supportedUOMsList.size();
694 for ( int i = 0; i < size; i++ ) {
695 OWSMetadata uom = supportedUOMsList.get( i );
696 Element uomNode = XMLTools.appendElement( supportedUOMsNode, OWSNS, "ows:UOM", null );
697 uomNode.setAttribute( "ows:reference", uom.getLink().getHref().toString() );
698 }
699 }
700
701 // append <ows:AllowedValues> on <LiteralData>
702 OWSAllowedValues owsAllowedValues = literalInput.getAllowedValues();
703 if ( null != owsAllowedValues ) {
704 Element allowedValuesNode = XMLTools.appendElement( literalDataNode, OWSNS, "ows:AllowedValues", null );
705 TypedLiteral[] typedLiteralArray = owsAllowedValues.getOwsValues();
706 if ( null != typedLiteralArray ) {
707 for ( int i = 0; i < typedLiteralArray.length; i++ ) {
708 // append <ows:Value/> on <ows:AllowedValues>
709 XMLTools.appendElement( allowedValuesNode, OWSNS, "ows:Value", typedLiteralArray[i].getValue() );
710 }
711 }
712 // append <ows:Range> on <ows:AllowedValues>
713 ValueRange[] valueRangeArray = owsAllowedValues.getValueRanges();
714 if ( null != valueRangeArray ) {
715 for ( int i = 0; i < valueRangeArray.length; i++ ) {
716 Element owsRangeNode = XMLTools.appendElement( allowedValuesNode, OWSNS, "ows:Range" );
717 String closure = valueRangeArray[i].getClosure().value;
718 if ( null != closure ) {
719 owsRangeNode.setAttribute( "ows:rangeClosure", closure );
720 }
721 String minimumValue = valueRangeArray[i].getMin().getValue();
722 if ( null != minimumValue ) {
723 XMLTools.appendElement( owsRangeNode, OWSNS, "ows:MinimumValue", minimumValue );
724 }
725 String maximumValue = valueRangeArray[i].getMax().getValue();
726 if ( null != maximumValue ) {
727 XMLTools.appendElement( owsRangeNode, OWSNS, "ows:MaximumValue", maximumValue );
728 }
729 TypedLiteral typedLiteralSpacing = valueRangeArray[i].getSpacing();
730 if ( null != typedLiteralSpacing ) {
731 String spacing = typedLiteralSpacing.getValue();
732 if ( null != spacing ) {
733 XMLTools.appendElement( owsRangeNode, OWSNS, "ows:Spacing", spacing );
734 }
735 }
736
737 }
738 }
739 }
740
741 // append <ows:AnyValue> on <LiteralData>
742 boolean anyValueAllowed = literalInput.getAnyValue();
743 if ( false != anyValueAllowed ) {
744 XMLTools.appendElement( literalDataNode, OWSNS, "ows:AnyValue" );
745 }
746
747 // append <ows:ValuesReference> on <LiteralData>
748 OWSMetadata owsValuesReference = literalInput.getValuesReference();
749 if ( null != owsValuesReference ) {
750 Element valuesReference = XMLTools.appendElement( literalDataNode, OWSNS, "ows:ValuesReference",
751 owsValuesReference.getName() );
752 String reference = owsValuesReference.getLink().getHref().toString();
753 if ( null != reference && !"".equals( reference ) ) {
754 valuesReference.setAttribute( "ows:reference", reference );
755 }
756 }
757
758 // append <ows:DefaultValue> on <LiteralData>
759 ValueRange defaultValue = literalInput.getDefaultValue();
760 if ( null != defaultValue ) {
761 Element owsRangeNode = XMLTools.appendElement( literalDataNode, OWSNS, "ows:DefaultValue" );
762 String closure = defaultValue.getClosure().value;
763 if ( null != closure ) {
764 owsRangeNode.setAttribute( "ows:rangeClosure", closure );
765 }
766 String minimumValue = defaultValue.getMin().getValue();
767 if ( null != minimumValue ) {
768 XMLTools.appendElement( owsRangeNode, OWSNS, "ows:MinimumValue", minimumValue );
769 }
770 String maximumValue = defaultValue.getMax().getValue();
771 if ( null != maximumValue ) {
772 XMLTools.appendElement( owsRangeNode, OWSNS, "ows:MaximumValue", maximumValue );
773 }
774 String spacing = defaultValue.getSpacing().getValue();
775 if ( null != spacing ) {
776 XMLTools.appendElement( owsRangeNode, OWSNS, "ows:Spacing", spacing );
777 }
778 }
779
780 }
781
782 /**
783 *
784 * @param inputNode
785 * @param supportedCRSs
786 */
787 private static void appendBoundingBoxData( Element inputNode, SupportedCRSs supportedCRSs ) {
788
789 URI defaultCrs = supportedCRSs.getDefaultCRS();
790 Element defaultCRSs = XMLTools.appendElement( inputNode, WPSNS, "wps:BoundingBoxData", null );
791 defaultCRSs.setAttribute( "defaultCRS", defaultCrs.toString() );
792
793 List<URI> crsList = supportedCRSs.getCRS();
794 int crsListSize = crsList.size();
795 for ( int i = 0; i < crsListSize; i++ ) {
796 URI uri = crsList.get( i );
797 XMLTools.appendElement( defaultCRSs, WPSNS, "wps:CRS", uri.toString() );
798
799 }
800
801 }
802
803 /**
804 *
805 * @param executeResponse
806 * @return an ExecuteResponseDocument for the execute response
807 */
808 public static ExecuteResponseDocument export( ExecuteResponse executeResponse ) {
809
810 ExecuteResponseDocument executeResponseDocument = new ExecuteResponseDocument();
811
812 try {
813 // Prepare empty ExecuteResponseDocument
814 executeResponseDocument.createEmptyDocument();
815
816 // Get root of execute
817 Element root = executeResponseDocument.getRootElement();
818
819 // Append optional statusLocation attribute
820 String statusLocation = executeResponse.getStatusLocation();
821 if ( null != statusLocation ) {
822 root.setAttribute( "statusLocation", statusLocation );
823 }
824
825 // Append mandatory <ows:Identifier> node
826 Code identifier = executeResponse.getIdentifier();
827 if ( null != identifier ) {
828 appendIdentifier( root, identifier );
829 } else {
830 LOG.logError( "identifier is null." );
831 }
832
833 // Append mandatory <Status> node
834 appendStatus( root, executeResponse.getStatus() );
835
836 // Append optional <DataInputs> node
837 ExecuteDataInputs executeDataInputs = executeResponse.getDataInputs();
838 if ( null != executeDataInputs ) {
839 appendExecuteDataInputs( root, executeResponse.getDataInputs() );
840 }
841
842 // Append optional <OutputDefinitions> node
843 OutputDefinitions outputDefinitions = executeResponse.getOutputDefinitions();
844 if ( null != outputDefinitions ) {
845 appendOutputDefinitions( root, outputDefinitions );
846 }
847
848 // Append optional <ProcessOutputs> node
849 ExecuteResponse.ProcessOutputs processOutputs = executeResponse.getProcessOutputs();
850 if ( null != processOutputs ) {
851 appendExecuteProcessOutputs( root, processOutputs );
852 }
853
854 } catch ( IOException e ) {
855 LOG.logError( e.getMessage(), e );
856 } catch ( SAXException e ) {
857 LOG.logError( e.getMessage(), e );
858 }
859
860 return executeResponseDocument;
861 }
862
863 /**
864 *
865 * @param root
866 * @param status
867 */
868 private static void appendStatus( Element root, Status status ) {
869
870 Element statusNode = XMLTools.appendElement( root, WPSNS, "Status" );
871
872 String processSucceeded = status.getProcessSucceeded();
873
874 ProcessFailed processFailed = status.getProcessFailed();
875
876 String processAccepted = status.getProcessAccepted();
877
878 ProcessStarted processStarted = status.getProcessStarted();
879
880 if ( null != processSucceeded ) {
881 if ( "".equals( processSucceeded ) ) {
882 XMLTools.appendElement( statusNode, WPSNS, "ProcessSucceeded" );
883 } else {
884 XMLTools.appendElement( statusNode, WPSNS, "ProcessSucceeded", processSucceeded );
885 }
886 }
887
888 else if ( null != processFailed ) {
889
890 Element processfailedNode = XMLTools.appendElement( statusNode, WPSNS, "ProcessFailed" );
891
892 ExceptionReport exceptionReport = processFailed.getExceptionReport();
893 if ( null != exceptionReport ) {
894 Element execeptionReportNode = XMLTools.appendElement( processfailedNode, OWSNS, "ows:ExceptionReport" );
895 String version = exceptionReport.getVersion();
896 if ( null != version && !"".equals( version ) ) {
897 execeptionReportNode.setAttribute( "version", version );
898 }
899 OGCWebServiceException[] ogcWebserviceExceptions = exceptionReport.getExceptions();
900 int size = ogcWebserviceExceptions.length;
901 if ( 0 < size ) {
902 for ( int i = 0; i < size; i++ ) {
903 appendException( execeptionReportNode, ogcWebserviceExceptions[i] );
904 }
905 }
906 }
907 }
908
909 else if ( null != processAccepted ) {
910
911 if ( "".equals( processAccepted ) ) {
912 XMLTools.appendElement( statusNode, WPSNS, "ProcessAccepted" );
913 } else {
914 XMLTools.appendElement( statusNode, WPSNS, "ProcessAccepted", processAccepted );
915 }
916 }
917
918 else if ( null != processStarted ) {
919
920 Element processStartedNode = null;
921 String processStartedMessage = processStarted.getValue();
922 if ( "".equals( processStartedMessage ) ) {
923 processStartedNode = XMLTools.appendElement( statusNode, WPSNS, "ProcessStarted" );
924 } else {
925 processStartedNode = XMLTools.appendElement( statusNode, WPSNS, "ProcessStarted", processStartedMessage );
926 }
927 int percentCompleted = processStarted.getPercentCompleted();
928 if ( 0 >= percentCompleted && percentCompleted <= 100 ) {
929 processStartedNode.setAttribute( "PercentCompleted", String.valueOf( percentCompleted ) );
930 }
931 }
932
933 }
934
935 /**
936 * appends a xml representation of an <tt>OGCWebServiceException</tt> to the passed
937 * <tt>Element</tt> Overriding method of superclass because the nodes appended from that
938 * method do not conform with current ows specification
939 *
940 * @param node
941 * @param ex
942 */
943 protected static void appendException( Element node, OGCWebServiceException ex ) {
944
945 Element exceptionNode = XMLTools.appendElement( node, OWSNS, "ows:Exception" );
946
947 if ( null != ex.getCode() ) {
948 exceptionNode.setAttribute( "exceptionCode", ex.getCode().value );
949 }
950 String locator = ex.getLocator();
951 try {
952 if ( null != locator ) {
953 locator = URLEncoder.encode( locator, CharsetUtils.getSystemCharset() );
954 } else {
955 locator = "-";
956 }
957 } catch ( UnsupportedEncodingException e ) {
958 //nottin
959 }
960 exceptionNode.setAttribute( "locator", locator );
961
962 }
963
964 /**
965 *
966 * @param root
967 * @param executeDataInputs
968 */
969 private static void appendExecuteDataInputs( Element root, ExecuteDataInputs executeDataInputs ) {
970
971 Map<String, IOValue> inputs = executeDataInputs.getInputs();
972
973 if ( null != inputs ) {
974
975 int size = inputs.size();
976
977 if ( 0 < size ) {
978
979 Iterator<String> it = inputs.keySet().iterator();
980
981 Element dataInputsNode = XMLTools.appendElement( root, WPSNS, "DataInputs" );
982
983 while ( it.hasNext() ) {
984
985 IOValue ioValue = inputs.get( it.next() );
986
987 appendInput( dataInputsNode, ioValue );
988 }
989 }
990 }
991
992 }
993
994 /**
995 *
996 * @param dataInputsNode
997 * @param ioValue
998 */
999 private static void appendInput( Element dataInputsNode, IOValue ioValue ) {
1000
1001 Element inputNode = XMLTools.appendElement( dataInputsNode, WPSNS, "Input" );
1002
1003 Code identifier = ioValue.getIdentifier();
1004 if ( null != identifier ) {
1005 appendIdentifier( inputNode, identifier );
1006 } else {
1007 LOG.logError( "identifier is null." );
1008 }
1009
1010 String title = ioValue.getTitle();
1011 if ( null != title ) {
1012 appendTitle( inputNode, title );
1013 } else {
1014 LOG.logError( "title is null." );
1015 }
1016
1017 String _abstract = ioValue.getAbstract();
1018 if ( null != _abstract ) {
1019 appendAbstract( inputNode, _abstract );
1020 }
1021
1022 ComplexValue complexValue = ioValue.getComplexValue();
1023 ComplexValueReference complexValueReference = ioValue.getComplexValueReference();
1024 TypedLiteral literalValue = ioValue.getLiteralValue();
1025 Envelope boundingBoxValue = ioValue.getBoundingBoxValue();
1026
1027 if ( null != complexValue ) {
1028 appendComplexValue( inputNode, complexValue );
1029 } else if ( null != complexValueReference ) {
1030 appendComplexValueReference( inputNode, complexValueReference );
1031 } else if ( null != literalValue ) {
1032 appendLiteralValue( inputNode, literalValue );
1033 } else if ( null != boundingBoxValue ) {
1034 appendBoundingBoxValue( inputNode, boundingBoxValue );
1035 } else {
1036 LOG.logError( "a required input element is missing." );
1037 }
1038
1039 }
1040
1041 /**
1042 *
1043 * @param e
1044 * @param complexValue
1045 */
1046 private static void appendComplexValue( Element e, ComplexValue complexValue ) {
1047
1048 Element complexValueNode = XMLTools.appendElement( e, WPSNS, "ComplexValue" );
1049
1050 String format = complexValue.getFormat();
1051 if ( null != format && !"".equals( format ) ) {
1052 complexValueNode.setAttribute( "format", format );
1053 }
1054
1055 URI encoding = complexValue.getEncoding();
1056 if ( null != encoding ) {
1057 complexValueNode.setAttribute( "encoding", encoding.toString() );
1058 }
1059
1060 URL schema = complexValue.getSchema();
1061 if ( null != schema ) {
1062 complexValueNode.setAttribute( "schema", schema.toString() );
1063 }
1064
1065 Object content = complexValue.getContent();
1066
1067 if ( content instanceof FeatureCollection ) {
1068
1069 // TODO weird hack! are there better ways to append a
1070 // featurecollection to an element?
1071 FeatureCollection fc = (FeatureCollection) content;
1072 ByteArrayOutputStream bos = new ByteArrayOutputStream();
1073
1074 try {
1075 new GMLFeatureAdapter().export( fc, bos );
1076 } catch ( IOException ioe ) {
1077 LOG.logError( "error exporting featurecollection." + ioe.getMessage());
1078 } catch ( FeatureException fe ) {
1079 LOG.logError( "error exporting featurecollection." + fe.getMessage());
1080 }
1081
1082 String gmlString = null;
1083 try {
1084 gmlString = bos.toString( "UTF-8" );
1085 } catch ( UnsupportedEncodingException e1 ) {
1086 //nottin
1087 }
1088
1089 XMLFragment xmlFragment = null;
1090 try {
1091 xmlFragment = new XMLFragment( new StringReader( gmlString ), XMLFragment.DEFAULT_URL );
1092 } catch ( SAXException saxe ) {
1093 LOG.logError( "error converting featurecollection to xmlfragment." + saxe.getMessage());
1094 } catch ( IOException ioex ) {
1095 LOG.logError( "error converting featurecollection to xmlfragment." + ioex.getMessage());
1096 }
1097
1098 Node fcElement = xmlFragment.getRootElement();
1099
1100 Document owner = complexValueNode.getOwnerDocument();
1101
1102 complexValueNode.appendChild( owner.importNode( fcElement, true ) );
1103
1104 } else {
1105 LOG.logDebug( "Content is not of type FeatureCollection. This is currently not supported." );
1106 // TODO implement output methods for complex value types other than
1107 // featurecollection
1108 }
1109
1110 }
1111
1112 /**
1113 *
1114 * @param inputNode
1115 * @param complexValueReference
1116 */
1117 private static void appendComplexValueReference( Element inputNode, ComplexValueReference complexValueReference ) {
1118
1119 Element complexValueReferenceNode = XMLTools.appendElement( inputNode, WPSNS, "ComplexValueReference" );
1120
1121 String format = complexValueReference.getFormat();
1122 if ( null != format && !"".equals( format ) ) {
1123 complexValueReferenceNode.setAttribute( "format", format );
1124 }
1125
1126 URI encoding = complexValueReference.getEncoding();
1127 if ( null != encoding ) {
1128 complexValueReferenceNode.setAttribute( "encoding", encoding.toString() );
1129 }
1130
1131 URL schema = complexValueReference.getSchema();
1132 if ( null != schema ) {
1133 complexValueReferenceNode.setAttribute( "schema", schema.toString() );
1134 }
1135
1136 URL reference = complexValueReference.getReference();
1137 if ( null != reference ) {
1138 complexValueReferenceNode.setAttributeNS( OWSNS.toString(), "ows:reference", reference.toString() );
1139 }
1140
1141 }
1142
1143 /**
1144 *
1145 * @param inputNode
1146 * @param literalValue
1147 */
1148 private static void appendLiteralValue( Element inputNode, TypedLiteral literalValue ) {
1149
1150 Element literalValueNode = XMLTools.appendElement( inputNode, WPSNS, "LiteralValue" );
1151
1152 URI dataType = literalValue.getType();
1153 if ( null != dataType ) {
1154 literalValueNode.setAttribute( "dataType", dataType.toString() );
1155 }
1156
1157 URI uom = literalValue.getUom();
1158 if ( null != uom ) {
1159 literalValueNode.setAttribute( "uom", uom.toString() );
1160 }
1161
1162 String value = literalValue.getValue();
1163 if ( null != value && !"".equals( value ) ) {
1164 literalValueNode.setTextContent( value );
1165 }
1166
1167 }
1168
1169 /**
1170 *
1171 * @param inputNode
1172 * @param boundingBoxValue
1173 */
1174 private static void appendBoundingBoxValue( Element inputNode, Envelope boundingBoxValue ) {
1175
1176 Element boundingBoxValueNode = XMLTools.appendElement( inputNode, WPSNS, "BoundingBoxValue" );
1177
1178 String crs = boundingBoxValue.getCoordinateSystem().getIdentifier();
1179 if ( null != crs ) {
1180 boundingBoxValueNode.setAttribute( "crs", crs );
1181 }
1182
1183 int dimensions = boundingBoxValue.getCoordinateSystem().getDimension();
1184 if ( 0 != dimensions ) {
1185 boundingBoxValueNode.setAttribute( "dimensions", String.valueOf( dimensions ) );
1186 }
1187
1188 Position positionMin = boundingBoxValue.getMin();
1189 if ( null != positionMin ) {
1190 XMLTools.appendElement( boundingBoxValueNode, OWSNS, "ows:LowerCorner",
1191 String.valueOf( positionMin.getX() ) + " " + String.valueOf( positionMin.getY() ) );
1192 }
1193
1194 Position positionMax = boundingBoxValue.getMax();
1195 if ( null != positionMax ) {
1196 XMLTools.appendElement( boundingBoxValueNode, OWSNS, "ows:UpperCorner",
1197 String.valueOf( positionMax.getX() ) + " " + String.valueOf( positionMax.getY() ) );
1198 }
1199
1200 }
1201
1202 /**
1203 *
1204 * @param root
1205 * @param outputDefintions
1206 */
1207 private static void appendOutputDefinitions( Element root, OutputDefinitions outputDefintions ) {
1208
1209 Element outputDefinitionsNode = XMLTools.appendElement( root, WPSNS, "OutputDefinitions" );
1210
1211 List<OutputDefinition> outputDefinitionsList = outputDefintions.getOutputDefinitions();
1212
1213 if ( null != outputDefinitionsList ) {
1214
1215 int size = outputDefinitionsList.size();
1216
1217 if ( 0 < size ) {
1218 for ( int i = 0; i < outputDefinitionsList.size(); i++ ) {
1219
1220 appendOutputDefinition( outputDefinitionsNode, outputDefinitionsList.get( i ) );
1221
1222 }
1223 }
1224 }
1225
1226 }
1227
1228 /**
1229 *
1230 * @param outputDefinitionsNode
1231 * @param outputDefinition
1232 */
1233 private static void appendOutputDefinition( Element outputDefinitionsNode, OutputDefinition outputDefinition ) {
1234
1235 Element outputNode = XMLTools.appendElement( outputDefinitionsNode, WPSNS, "Output" );
1236
1237 String format = outputDefinition.getFormat();
1238 if ( null != format && !"".equals( format ) ) {
1239 outputNode.setAttribute( "format", format );
1240 }
1241
1242 URI encoding = outputDefinition.getEncoding();
1243 if ( null != encoding ) {
1244 outputNode.setAttribute( "encoding", encoding.toString() );
1245 }
1246
1247 URL schema = outputDefinition.getSchema();
1248 if ( null != schema ) {
1249 outputNode.setAttribute( "schema", schema.toString() );
1250 }
1251
1252 URI uom = outputDefinition.getUom();
1253 if ( null != uom ) {
1254 outputNode.setAttribute( "uom", uom.toString() );
1255 }
1256
1257 Code identifier = outputDefinition.getIdentifier();
1258 if ( null != identifier ) {
1259 appendIdentifier( outputNode, identifier );
1260 } else {
1261 LOG.logError( "identifier is null." );
1262 }
1263
1264 String title = outputDefinition.getTitle();
1265 if ( null != title ) {
1266 appendTitle( outputNode, title );
1267 } else {
1268 LOG.logError( "title is null." );
1269 }
1270
1271 String _abstract = outputDefinition.getAbstract();
1272 if ( null != _abstract ) {
1273 appendAbstract( outputNode, _abstract );
1274 }
1275
1276 }
1277
1278 /**
1279 *
1280 * @param root
1281 * @param processOutputs
1282 */
1283 private static void appendExecuteProcessOutputs( Element root, ExecuteResponse.ProcessOutputs processOutputs ) {
1284
1285 Element processOutputsNode = XMLTools.appendElement( root, WPSNS, "ProcessOutputs" );
1286
1287 List<IOValue> processOutputsList = processOutputs.getOutputs();
1288 if ( null != processOutputsList ) {
1289
1290 int size = processOutputsList.size();
1291 if ( 0 < size ) {
1292
1293 for ( int i = 0; i < size; i++ ) {
1294 appendExecuteProcessOutput( processOutputsNode, processOutputsList.get( i ) );
1295 }
1296 }
1297 }
1298
1299 }
1300
1301 /**
1302 *
1303 * @param processOutputsNode
1304 * @param processOutput
1305 */
1306 private static void appendExecuteProcessOutput( Element processOutputsNode, IOValue processOutput ) {
1307
1308 Element outputNode = XMLTools.appendElement( processOutputsNode, WPSNS, "Output" );
1309
1310 Code identifier = processOutput.getIdentifier();
1311 if ( null != identifier ) {
1312 appendIdentifier( outputNode, identifier );
1313 } else {
1314 LOG.logError( "identifier is null." );
1315 }
1316
1317 String title = processOutput.getTitle();
1318 if ( null != title ) {
1319 appendTitle( outputNode, title );
1320 } else {
1321 LOG.logError( "title is null." );
1322 }
1323
1324 String _abstract = processOutput.getAbstract();
1325 if ( null != _abstract ) {
1326 appendAbstract( outputNode, _abstract );
1327 }
1328
1329 ComplexValue complexValue = processOutput.getComplexValue();
1330 ComplexValueReference complexValueReference = processOutput.getComplexValueReference();
1331 TypedLiteral literalValue = processOutput.getLiteralValue();
1332 Envelope boundingBoxValue = processOutput.getBoundingBoxValue();
1333
1334 if ( null != complexValue ) {
1335 appendComplexValue( outputNode, complexValue );
1336 } else if ( null != complexValueReference ) {
1337 appendComplexValueReference( outputNode, complexValueReference );
1338 } else if ( null != literalValue ) {
1339 appendLiteralValue( outputNode, literalValue );
1340 } else if ( null != boundingBoxValue ) {
1341 appendBoundingBoxValue( outputNode, boundingBoxValue );
1342 } else {
1343 LOG.logError( "a required output element is missing." );
1344 }
1345
1346 }
1347
1348 }