001    //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/ogcwebservices/sos/describesensor/SensorDescriptionDocument.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.sos.describesensor;
037    
038    import java.io.IOException;
039    import java.net.URI;
040    import java.net.URL;
041    import java.util.ArrayList;
042    import java.util.Hashtable;
043    import java.util.Iterator;
044    import java.util.List;
045    
046    import javax.xml.transform.TransformerException;
047    
048    import org.deegree.datatypes.QualifiedName;
049    import org.deegree.framework.log.ILogger;
050    import org.deegree.framework.log.LoggerFactory;
051    import org.deegree.framework.xml.XMLParsingException;
052    import org.deegree.framework.xml.XMLTools;
053    import org.deegree.ogcwebservices.OGCWebService;
054    import org.deegree.ogcwebservices.OGCWebServiceException;
055    import org.deegree.ogcwebservices.sos.ComponentDescriptionDocument;
056    import org.deegree.ogcwebservices.sos.WFSRequestGenerator;
057    import org.deegree.ogcwebservices.sos.WFSRequester;
058    import org.deegree.ogcwebservices.sos.XMLFactory;
059    import org.deegree.ogcwebservices.sos.XSLTransformer;
060    import org.deegree.ogcwebservices.sos.configuration.MeasurementConfiguration;
061    import org.deegree.ogcwebservices.sos.configuration.SOSDeegreeParams;
062    import org.deegree.ogcwebservices.sos.configuration.SensorConfiguration;
063    import org.deegree.ogcwebservices.sos.sensorml.BasicResponse;
064    import org.deegree.ogcwebservices.sos.sensorml.Classifier;
065    import org.deegree.ogcwebservices.sos.sensorml.ComponentDescription;
066    import org.deegree.ogcwebservices.sos.sensorml.EngineeringCRS;
067    import org.deegree.ogcwebservices.sos.sensorml.Identifier;
068    import org.deegree.ogcwebservices.sos.sensorml.LocationModel;
069    import org.deegree.ogcwebservices.sos.sensorml.Phenomenon;
070    import org.deegree.ogcwebservices.sos.sensorml.Product;
071    import org.deegree.ogcwebservices.sos.sensorml.ResponseModel;
072    import org.deegree.ogcwebservices.sos.sensorml.TypedQuantity;
073    import org.w3c.dom.Document;
074    import org.w3c.dom.Node;
075    import org.xml.sax.SAXException;
076    
077    /**
078     * reads the metadata of a sensor from the xsl transformed result from a wfs
079     *
080     * @author <a href="mailto:mkulbe@lat-lon.de">Matthias Kulbe </a>
081     *
082     */
083    public class SensorDescriptionDocument extends ComponentDescriptionDocument {
084    
085        /**
086         *
087         */
088        private static final long serialVersionUID = -6126811730624541654L;
089    
090        private static final ILogger LOG = LoggerFactory.getLogger( XMLFactory.class );
091    
092        private static final String XML_TEMPLATE = "DescribeSensorTemplate.xml";
093    
094        /*
095         * (non-Javadoc)
096         *
097         * @see org.deegree.ogcwebservices.sos.ComponentDescriptionDocument#createEmptyDocument()
098         */
099        @Override
100        public void createEmptyDocument()
101                                throws IOException, SAXException {
102            URL url = SensorDescriptionDocument.class.getResource( XML_TEMPLATE );
103            if ( url == null ) {
104                throw new IOException( "The resource '" + XML_TEMPLATE + " could not be found." );
105            }
106            load( url );
107        }
108    
109        /**
110         *
111         * @param deegreeParams
112         * @param typNames
113         * @return the sensot metadata
114         * @throws OGCWebServiceException
115         */
116        public SensorMetadata[] getSensor( SOSDeegreeParams deegreeParams, String[] typNames )
117                                throws OGCWebServiceException {
118            try {
119    
120                // gets the documents from wfs server
121                Document[] docs = getSourceServerDocuments( deegreeParams, typNames );
122    
123                ArrayList<SensorMetadata> sensorMetadata = new ArrayList<SensorMetadata>( docs.length );
124                for ( int d = 0; d < docs.length; d++ ) {
125    
126                    if ( docs[d] != null ) {
127    
128                        List<Node> nl = XMLTools.getNodes( docs[d], "sml:Sensors/sml:Sensor", nsContext );
129    
130                        if ( nl.size() < 1 ) {
131                            LOG.logError( "no sensors found in wfs result document" );
132                        }
133    
134                        // process all sensors in document
135                        for ( int y = 0; y < nl.size(); y++ ) {
136    
137                            Node sensorNode = nl.get( y );
138    
139                            String actIdPropertyValue = XMLTools.getRequiredNodeAsString( sensorNode, "@id", nsContext );
140    
141                            // get identifiedAs
142                            ArrayList<Identifier> identifiers = new ArrayList<Identifier>();
143                            List<Node> identifierList = XMLTools.getNodes( sensorNode, "sml:identifiedAs", nsContext );
144                            if ( ( identifierList == null ) || ( identifierList.size() <= 0 ) ) {
145                                throw new XMLParsingException( "at least one identifiedAs required" );
146    
147                            }
148                            for ( int i = 0; i < identifierList.size(); i++ ) {
149                                identifiers.add( getIdentifiedAs( identifierList.get( i ) ) );
150                            }
151    
152                            // get ClassifiedAs
153                            List<Node> classifierList = XMLTools.getNodes( sensorNode, "sml:classifiedAs", nsContext );
154                            ArrayList<Classifier> classifiers = new ArrayList<Classifier>( classifierList.size() );
155                            for ( int i = 0; i < classifierList.size(); i++ ) {
156                                classifiers.add( getClassifiedAs( classifierList.get( i ) ) );
157                            }
158    
159                            // get attachedTo
160                            String attachedTo = getAttachedTo( XMLTools.getNode( sensorNode, "sml:attachedTo", nsContext ) );
161    
162                            // get hasCRS
163                            EngineeringCRS hasCRS = getHasCRS( XMLTools.getNode( sensorNode, "sml:hasCRS", nsContext ) );
164    
165                            // get locatedUsing
166                            List<Node> locationModelList = XMLTools.getNodes( sensorNode, "sml:locatedUsing", nsContext );
167                            ArrayList<LocationModel> locationModels = new ArrayList<LocationModel>(
168                                                                                                    locationModelList.size() );
169                            for ( int i = 0; i < locationModelList.size(); i++ ) {
170                                locationModels.add( getLocatedUsing( locationModelList.get( i ) ) );
171                            }
172    
173                            // getdescribedBy
174                            ComponentDescription describedBy = getDescribedBy( XMLTools.getNode( sensorNode,
175                                                                                                 "sml:describedBy",
176                                                                                                 nsContext ) );
177    
178                            // TODO---------add the products from Configuration
179                            SensorConfiguration temp = deegreeParams.getSensorConfigurationByIdPropertyValue( actIdPropertyValue );
180    
181                            MeasurementConfiguration[] measurements = temp.getMeasurementConfigurations();
182    
183                            if ( ( measurements == null ) || ( measurements.length < 1 ) ) {
184                                throw new XMLParsingException( "at least one measures needed" );
185                            }
186    
187                            // get measures
188                            ArrayList<Product> measures = new ArrayList<Product>( measurements.length );
189                            for ( int i = 0; i < measurements.length; i++ ) {
190    
191                                // Identifier anlegen
192                                Identifier[] ti = new Identifier[] { new Identifier( measurements[i].getId() ) };
193    
194                                // observable anlegen
195                                Phenomenon phen = new Phenomenon( measurements[i].getPhenomenon(), null, null );
196    
197                                ResponseModel[] resm = null;
198                                if ( measurements[i].getTimeResolution() != null ) {
199                                    // derivedfrom anlegen
200                                    double dd = Double.parseDouble( measurements[i].getTimeResolution() );
201                                    URI uri = new URI( measurements[i].getTimeResolutionType() );
202                                    TypedQuantity typedQan = new TypedQuantity( dd, uri );
203    
204                                    Object[] o = new Object[] { new BasicResponse( typedQan ) };
205                                    resm = new ResponseModel[] { new ResponseModel( null, null, null, null, o ) };
206                                }
207                                // product anlegen und zur liste hinzuf�gen
208                                Product product = new Product( ti, null, null, null, resm, null, phen, null );
209                                measures.add( product );
210                            }
211    
212                            // --end of measurments
213    
214                            // add act Metadata to ArrayList
215                            Identifier[] i1 = identifiers.toArray( new Identifier[identifiers.size()] );
216                            Classifier[] c1 = classifiers.toArray( new Classifier[classifiers.size()] );
217                            LocationModel[] l1 = new LocationModel[locationModels.size()];
218                            l1 = locationModels.toArray( l1 );
219                            Product[] p1 = measures.toArray( new Product[measures.size()] );
220                            sensorMetadata.add( new SensorMetadata( i1, c1, hasCRS, l1, describedBy, attachedTo, p1 ) );
221                        }
222                    }
223                }
224    
225                // return the Array with Sensormetadata
226                return sensorMetadata.toArray( new SensorMetadata[sensorMetadata.size()] );
227    
228            } catch ( Exception e ) {
229                e.printStackTrace();
230                throw new OGCWebServiceException( "scs webservice failure" );
231            }
232        }
233    
234        /**
235         *
236         * @param dp
237         * @param typNames
238         * @return the documents
239         * @throws IOException
240         * @throws IOException
241         * @throws SAXException
242         * @throws XMLParsingException
243         * @throws TransformerException
244         */
245        @SuppressWarnings("deprecation")
246        private Document[] getSourceServerDocuments( SOSDeegreeParams dp, String[] typNames )
247                                throws IOException, SAXException, XMLParsingException, TransformerException,
248                                OGCWebServiceException {
249    
250            ArrayList<Document> transformedDocuments = new ArrayList<Document>();
251    
252            Hashtable<String, ArrayList<String>> servers = new Hashtable<String, ArrayList<String>>();
253    
254            for ( int t = 0; t < typNames.length; t++ ) {
255                String sourceServerId = dp.getSensorConfiguration( typNames[t] ).getSourceServerId();
256    
257                // server schon in liste; nur sensor hinzuf�gen
258                if ( servers.containsKey( sourceServerId ) ) {
259                    servers.get( sourceServerId ).add( typNames[t] );
260                }
261                // server nicht in liste; server hinzuf�gen und sensor hinzuf�gen
262                else {
263                    ArrayList<String> temp = new ArrayList<String>();
264                    temp.add( typNames[t] );
265                    servers.put( sourceServerId, temp );
266                }
267    
268            }
269    
270            // request all servers from servers hashtable
271            Iterator<String> iter = servers.keySet().iterator();
272            while ( iter.hasNext() ) {
273    
274                String key = iter.next();
275                List<String> sensorIds = servers.get( key );
276    
277                String[] idProps = new String[sensorIds.size()];
278                for ( int a = 0; a < sensorIds.size(); a++ ) {
279                    idProps[a] = sensorIds.get( a );
280                }
281    
282                QualifiedName sdft = dp.getSourceServerConfiguration( key ).getSensorDescriptionFeatureType();
283                QualifiedName sdid = dp.getSourceServerConfiguration( key ).getSensorDescriptionIdPropertyName();
284                Document request = WFSRequestGenerator.createIsLikeOperationWFSRequest( idProps, sdft, sdid );
285    
286                OGCWebService ows = dp.getSourceServerConfiguration( key ).getDataService();
287                Document result = null;
288                try {
289                    result = WFSRequester.sendWFSrequest( request, ows );
290                } catch ( Exception e ) {
291                    LOG.logError( "could not sensor data from DataService", e );
292                    throw new OGCWebServiceException( this.getClass().getName(), "could not sensor"
293                                                                                 + " data from DataService"
294                                                                                 + e.getMessage() );
295                }
296                if ( result != null ) {
297                    transformedDocuments.add( XSLTransformer.transformDocument(
298                                                                                result,
299                                                                                dp.getSourceServerConfiguration( key ).getSensorDescriptionXSLTScriptSource() ) );
300                }
301    
302            }
303    
304            return transformedDocuments.toArray( new Document[transformedDocuments.size()] );
305        }
306    }