001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/ogcwebservices/wfs/operation/DescribeFeatureType.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.wfs.operation; 037 038 import java.net.URI; 039 import java.util.HashMap; 040 import java.util.Map; 041 042 import org.deegree.datatypes.QualifiedName; 043 import org.deegree.framework.log.ILogger; 044 import org.deegree.framework.log.LoggerFactory; 045 import org.deegree.framework.util.IDGenerator; 046 import org.deegree.framework.util.KVP2Map; 047 import org.deegree.ogcwebservices.InconsistentRequestException; 048 import org.deegree.ogcwebservices.InvalidParameterValueException; 049 import org.deegree.ogcwebservices.MissingParameterValueException; 050 import org.deegree.ogcwebservices.OGCWebServiceException; 051 import org.deegree.ogcwebservices.wfs.WFService; 052 import org.w3c.dom.Element; 053 054 /** 055 * Represents a <code>DescribeFeatureType</code> request to a web feature service. 056 * <p> 057 * The function of the DescribeFeatureType interface is to provide a client the means to request a 058 * schema definition of any feature type that a particular WFS can service. The description that is 059 * generated will define how a WFS expects a client application to express the state of a feature to 060 * be created or the new state of a feature to be updated. The result of a DescribeFeatureType 061 * request is an XML document, describing one or more feature types serviced by the WFS. 062 * 063 * @author <a href="mailto:poth@lat-lon.de">Andreas Poth </a> 064 * @author <a href="mailto:schneider@lat-lon.de">Markus Schneider</a> 065 * @author last edited by: $Author: mschneider $ 066 * 067 * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $ 068 */ 069 public class DescribeFeatureType extends AbstractWFSRequest { 070 071 private static final long serialVersionUID = 4403179045869238426L; 072 073 private static ILogger LOG = LoggerFactory.getLogger( DescribeFeatureType.class ); 074 075 private String outputFormat; 076 077 private QualifiedName[] typeNames; 078 079 /** 080 * Creates a new <code>DescribeFeatureType</code> instance. 081 * 082 * @param version 083 * @param id 084 * @param handle 085 * @param outputFormat 086 * @param typeNames 087 * @param vendorspecificParameter 088 */ 089 DescribeFeatureType( String version, String id, String handle, String outputFormat, QualifiedName[] typeNames, 090 Map<String, String> vendorspecificParameter ) { 091 super( version, id, handle, vendorspecificParameter ); 092 this.outputFormat = outputFormat; 093 this.typeNames = typeNames; 094 } 095 096 /** 097 * Creates a <code>DescribeFeatureType</code> instance from a document that contains the DOM 098 * representation of the request. 099 * 100 * @param id 101 * @param root 102 * element that contains the DOM representation of the request 103 * @return DescribeFeatureType instance 104 * @throws OGCWebServiceException 105 */ 106 public static DescribeFeatureType create( String id, Element root ) 107 throws OGCWebServiceException { 108 DescribeFeatureTypeDocument doc = new DescribeFeatureTypeDocument(); 109 doc.setRootElement( root ); 110 DescribeFeatureType request; 111 try { 112 request = doc.parse( id ); 113 } catch ( Exception e ) { 114 throw new OGCWebServiceException( "DescribeFeatureType", e.getMessage() ); 115 } 116 return request; 117 } 118 119 /** 120 * Creates a new <code>DescribeFeatureType</code> instance from the given key-value pair 121 * encoded request. 122 * 123 * @param id 124 * request identifier 125 * @param request 126 * @return new <code>DescribeFeatureType</code> request 127 * @throws InvalidParameterValueException 128 * @throws InconsistentRequestException 129 * @throws MissingParameterValueException 130 */ 131 public static DescribeFeatureType create( String id, String request ) 132 throws InconsistentRequestException, InvalidParameterValueException, 133 MissingParameterValueException { 134 Map<String, String> map = KVP2Map.toMap( request ); 135 map.put( "ID", id ); 136 return create( map ); 137 } 138 139 /** 140 * Creates a new <code>DescribeFeatureType</code> request from the given map. 141 * 142 * @param request 143 * @return new <code>DescribeFeatureType</code> request 144 * @throws InconsistentRequestException 145 * @throws InvalidParameterValueException 146 * @throws MissingParameterValueException 147 */ 148 public static DescribeFeatureType create( Map<String, String> request ) 149 throws InconsistentRequestException, InvalidParameterValueException, 150 MissingParameterValueException { 151 checkServiceParameter( request ); 152 String version = checkVersionParameter( request ); 153 boolean is100 = version.equals( "1.0.0" ); 154 // I guess XMLSCHEMA should be used here for 1.0.0, but what the heck, it's also kind of 155 // GML2... 156 // the problem is probably inheritance, since the AbstractWFSRequest defines the Strings 157 String outputFormat = getParam( "OUTPUTFORMAT", request, is100 ? FORMAT_GML2_WFS100 : FORMAT_GML3 ); 158 if ( outputFormat.equalsIgnoreCase( "xmlschema" ) ) { 159 outputFormat = FORMAT_GML2_WFS100; 160 } 161 QualifiedName[] typeNames = extractTypeNames( request ); 162 163 long l = IDGenerator.getInstance().generateUniqueID(); 164 String id = Long.toString( l ); 165 return new DescribeFeatureType( version, id, null, outputFormat, typeNames, request ); 166 } 167 168 /** 169 * Returns the value of the outputFormat attribute. 170 * <p> 171 * The outputFormat attribute, is used to indicate the schema description language that should 172 * be used to describe a feature schema. The only mandated format is XML-Schema denoted by the 173 * XMLSCHEMA element; other vendor specific formats specified in the capabilities document are 174 * also possible. 175 * 176 * @return the value of the outputFormat attribute. 177 */ 178 public String getOutputFormat() { 179 return this.outputFormat; 180 } 181 182 /** 183 * Returns the names of the feature types for which the schema is requested. 184 * <p> 185 * 186 * @return the names of the feature types for which the schema is requested. 187 */ 188 public QualifiedName[] getTypeNames() { 189 return typeNames; 190 } 191 192 /** 193 * Adds missing namespaces in the names of requested feature types. 194 * <p> 195 * If the {@link QualifiedName} of a requested type has a null namespace, the first qualified 196 * feature type name of the given {@link WFService} with the same local name is used instead. 197 * <p> 198 * Note: The method changes this request (the feature type names) and should only be called by 199 * the <code>WFSHandler</code> class. 200 * 201 * @param wfs 202 * {@link WFService} instance that is used for the lookup of proper (qualified) 203 * feature type names 204 */ 205 public void guessMissingNamespaces( WFService wfs ) { 206 for ( int i = 0; i < typeNames.length; i++ ) { 207 QualifiedName typeName = typeNames[i]; 208 if ( typeName.getNamespace() == null ) { 209 if ( typeName.getLocalName().equals( typeName.getLocalName() ) ) { 210 LOG.logWarning( "Requested feature type name has no namespace information. Guessing namespace for feature type '" 211 + typeName.getLocalName() + "' (quirks lookup mode)." ); 212 for ( QualifiedName ftName : wfs.getMappedFeatureTypes().keySet() ) { 213 if ( ftName.getLocalName().equals( typeName.getLocalName() ) ) { 214 LOG.logWarning( "Using feature type '" + ftName + "'." ); 215 typeNames[i] = ftName; 216 break; 217 } 218 } 219 } 220 } 221 } 222 } 223 224 /** 225 * Returns a string representation of the object. 226 * 227 * @return a string representation of the object. 228 */ 229 @Override 230 public String toString() { 231 String ret = this.getClass().getName() + ":\n"; 232 ret += ( outputFormat + "\n" ); 233 if ( typeNames != null ) { 234 for ( int i = 0; i < typeNames.length; i++ ) { 235 ret += ( typeNames[i] + "\n" ); 236 } 237 } 238 return ret; 239 } 240 241 @Override 242 public String getRequestParameter() 243 throws OGCWebServiceException { 244 Map<URI, String> namespaces = new HashMap<URI, String>(); 245 String typename = ""; 246 String namespace = ""; 247 for ( QualifiedName type : typeNames ) { 248 if ( typename.length() != 0 ) { 249 typename += ','; 250 } 251 typename += type.getPrefixedName(); 252 253 if ( type.getNamespace() != null ) { 254 if ( namespaces.get( type.getNamespace() ) != null ) { 255 namespaces.put( type.getNamespace(), type.getPrefix() ); 256 if ( namespace.length() != 0 ) { 257 namespace += ','; 258 } 259 namespace += type.getPrefix() + '=' + type.getNamespace(); 260 } 261 } 262 } 263 264 String request = "request=DescribeFeatureType&version=" + this.getVersion() + "&typename=" + typename; 265 if ( namespace.length() != 0 ) { 266 request += "&namespace=xmlns(" + namespace + ')'; 267 } 268 return request; 269 } 270 271 }