| /* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for | |
| * full list of contributors). Published under the Clear BSD license. | |
| * See http://svn.openlayers.org/trunk/openlayers/license.txt for the | |
| * full text of the license. */ | |
| /** | |
| * @requires OpenLayers/Format/XML.js | |
| * @requires OpenLayers/Format/WFST.js | |
| */ | |
| /** | |
| * Class: OpenLayers.Format.WFST.v1 | |
| * Superclass for WFST parsers. | |
| * | |
| * Inherits from: | |
| * - <OpenLayers.Format.XML> | |
| */ | |
| OpenLayers.Format.WFST.v1 = OpenLayers.Class(OpenLayers.Format.XML, { | |
| /** | |
| * Property: namespaces | |
| * {Object} Mapping of namespace aliases to namespace URIs. | |
| */ | |
| namespaces: { | |
| xlink: "http://www.w3.org/1999/xlink", | |
| xsi: "http://www.w3.org/2001/XMLSchema-instance", | |
| wfs: "http://www.opengis.net/wfs", | |
| gml: "http://www.opengis.net/gml", | |
| ogc: "http://www.opengis.net/ogc" | |
| }, | |
| /** | |
| * Property: defaultPrefix | |
| */ | |
| defaultPrefix: "wfs", | |
| /** | |
| * Property: version | |
| * {String} WFS version number. | |
| */ | |
| version: null, | |
| /** | |
| * Property: schemaLocation | |
| * {String} Schema location for a particular minor version. | |
| */ | |
| schemaLocations: null, | |
| /** | |
| * APIProperty: srsName | |
| * {String} URI for spatial reference system. | |
| */ | |
| srsName: null, | |
| /** | |
| * APIProperty: extractAttributes | |
| * {Boolean} Extract attributes from GML. Default is true. | |
| */ | |
| extractAttributes: true, | |
| /** | |
| * APIProperty: xy | |
| * {Boolean} Order of the GML coordinate true:(x,y) or false:(y,x) | |
| * Changing is not recommended, a new Format should be instantiated. | |
| */ | |
| xy: true, | |
| /** | |
| * Property: stateName | |
| * {Object} Maps feature states to node names. | |
| */ | |
| stateName: null, | |
| /** | |
| * Constructor: OpenLayers.Format.WFST.v1 | |
| * Instances of this class are not created directly. Use the | |
| * <OpenLayers.Format.WFST.v1_0_0> or <OpenLayers.Format.WFST.v1_1_0> | |
| * constructor instead. | |
| * | |
| * Parameters: | |
| * options - {Object} An optional object whose properties will be set on | |
| * this instance. | |
| */ | |
| initialize: function(options) { | |
| // set state name mapping | |
| this.stateName = {}; | |
| this.stateName[OpenLayers.State.INSERT] = "wfs:Insert"; | |
| this.stateName[OpenLayers.State.UPDATE] = "wfs:Update"; | |
| this.stateName[OpenLayers.State.DELETE] = "wfs:Delete"; | |
| OpenLayers.Format.XML.prototype.initialize.apply(this, [options]); | |
| }, | |
| /** | |
| * Method: getSrsName | |
| */ | |
| getSrsName: function(feature, options) { | |
| var srsName = options && options.srsName; | |
| if(!srsName) { | |
| if(feature && feature.layer) { | |
| srsName = feature.layer.projection.getCode(); | |
| } else { | |
| srsName = this.srsName; | |
| } | |
| } | |
| return srsName; | |
| }, | |
| /** | |
| * APIMethod: read | |
| * Parse the response from a transaction. Because WFS is split into | |
| * Transaction requests (create, update, and delete) and GetFeature | |
| * requests (read), this method handles parsing of both types of | |
| * responses. | |
| * | |
| * Parameters: | |
| * data - {String | Document} The WFST document to read | |
| * options - {Object} Options for the reader | |
| * | |
| * Valid options properties: | |
| * output - {String} either "features" or "object". The default is | |
| * "features", which means that the method will return an array of | |
| * features. If set to "object", an object with a "features" property | |
| * and other properties read by the parser will be returned. | |
| * | |
| * Returns: | |
| * {Array | Object} Output depending on the output option. | |
| */ | |
| read: function(data, options) { | |
| options = options || {}; | |
| OpenLayers.Util.applyDefaults(options, { | |
| output: "features" | |
| }); | |
| if(typeof data == "string") { | |
| data = OpenLayers.Format.XML.prototype.read.apply(this, [data]); | |
| } | |
| if(data && data.nodeType == 9) { | |
| data = data.documentElement; | |
| } | |
| var obj = {}; | |
| if(data) { | |
| this.readNode(data, obj); | |
| } | |
| if(obj.features && options.output === "features") { | |
| obj = obj.features; | |
| } | |
| return obj; | |
| }, | |
| /** | |
| * Property: readers | |
| * Contains public functions, grouped by namespace prefix, that will | |
| * be applied when a namespaced node is found matching the function | |
| * name. The function will be applied in the scope of this parser | |
| * with two arguments: the node being read and a context object passed | |
| * from the parent. | |
| */ | |
| readers: { | |
| "wfs": { | |
| "FeatureCollection": function(node, obj) { | |
| obj.features = []; | |
| this.readChildNodes(node, obj); | |
| } | |
| } | |
| }, | |
| /** | |
| * Method: write | |
| * Given an array of features, write a WFS transaction. This assumes | |
| * the features have a state property that determines the operation | |
| * type - insert, update, or delete. | |
| * | |
| * Parameters: | |
| * features - {Array(<OpenLayers.Feature.Vector>)} A list of features. | |
| * | |
| * Returns: | |
| * {String} A serialized WFS transaction. | |
| */ | |
| write: function(features) { | |
| var node = this.writeNode("wfs:Transaction", features); | |
| var value = this.schemaLocationAttr(); | |
| if(value) { | |
| this.setAttributeNS( | |
| node, this.namespaces["xsi"], "xsi:schemaLocation", value | |
| ) | |
| } | |
| return OpenLayers.Format.XML.prototype.write.apply(this, [node]); | |
| }, | |
| /** | |
| * Property: writers | |
| * As a compliment to the readers property, this structure contains public | |
| * writing functions grouped by namespace alias and named like the | |
| * node names they produce. | |
| */ | |
| writers: { | |
| "wfs": { | |
| "GetFeature": function(options) { | |
| var node = this.createElementNSPlus("wfs:GetFeature", { | |
| attributes: { | |
| service: "WFS", | |
| version: this.version, | |
| outputFormat: options && options.outputFormat, | |
| maxFeatures: options && options.maxFeatures, | |
| "xsi:schemaLocation": this.schemaLocationAttr(options) | |
| } | |
| }); | |
| if (typeof this.featureType == "string") { | |
| this.writeNode("Query", options, node); | |
| } else { | |
| for (var i=0,len = this.featureType.length; i<len; i++) { | |
| options.featureType = this.featureType[i]; | |
| this.writeNode("Query", options, node); | |
| } | |
| } | |
| return node; | |
| }, | |
| "Transaction": function(features) { | |
| var node = this.createElementNSPlus("wfs:Transaction", { | |
| attributes: { | |
| service: "WFS", | |
| version: this.version | |
| } | |
| }); | |
| if(features) { | |
| var name, feature; | |
| for(var i=0, len=features.length; i<len; ++i) { | |
| feature = features[i]; | |
| name = this.stateName[feature.state]; | |
| if(name) { | |
| this.writeNode(name, feature, node); | |
| } | |
| } | |
| } | |
| return node; | |
| }, | |
| "Insert": function(feature) { | |
| var node = this.createElementNSPlus("wfs:Insert"); | |
| this.srsName = this.getSrsName(feature); | |
| this.writeNode("feature:_typeName", feature, node); | |
| return node; | |
| }, | |
| "Update": function(feature) { | |
| var node = this.createElementNSPlus("wfs:Update", { | |
| attributes: { | |
| typeName: (this.featureNS ? this.featurePrefix + ":" : "") + | |
| this.featureType | |
| } | |
| }); | |
| if(this.featureNS) { | |
| node.setAttribute("xmlns:" + this.featurePrefix, this.featureNS); | |
| } | |
| // add in geometry | |
| if (this.geometryName !== null) { | |
| this.writeNode( | |
| "Property", {name: this.geometryName, value: feature}, node | |
| ); | |
| } | |
| // add in attributes | |
| for(var key in feature.attributes) { | |
| if(feature.attributes[key] !== undefined) { | |
| this.writeNode( | |
| "Property", {name: key, value: feature.attributes[key]}, node | |
| ); | |
| } | |
| } | |
| // add feature id filter | |
| this.writeNode("ogc:Filter", new OpenLayers.Filter.FeatureId({ | |
| fids: [feature.fid] | |
| }), node); | |
| return node; | |
| }, | |
| "Property": function(obj) { | |
| var node = this.createElementNSPlus("wfs:Property"); | |
| this.writeNode("Name", obj.name, node); | |
| if(obj.value !== null) { | |
| this.writeNode("Value", obj.value, node); | |
| } | |
| return node; | |
| }, | |
| "Name": function(name) { | |
| return this.createElementNSPlus("wfs:Name", {value: name}); | |
| }, | |
| "Value": function(obj) { | |
| var node; | |
| if(obj instanceof OpenLayers.Feature.Vector) { | |
| node = this.createElementNSPlus("wfs:Value"); | |
| this.srsName = this.getSrsName(obj); | |
| var geom = this.writeNode("feature:_geometry", obj.geometry).firstChild; | |
| node.appendChild(geom); | |
| } else { | |
| node = this.createElementNSPlus("wfs:Value", {value: obj}); | |
| } | |
| return node; | |
| }, | |
| "Delete": function(feature) { | |
| var node = this.createElementNSPlus("wfs:Delete", { | |
| attributes: { | |
| typeName: (this.featureNS ? this.featurePrefix + ":" : "") + | |
| this.featureType | |
| } | |
| }); | |
| if(this.featureNS) { | |
| node.setAttribute("xmlns:" + this.featurePrefix, this.featureNS); | |
| } | |
| this.writeNode("ogc:Filter", new OpenLayers.Filter.FeatureId({ | |
| fids: [feature.fid] | |
| }), node); | |
| return node; | |
| } | |
| } | |
| }, | |
| /** | |
| * Method: schemaLocationAttr | |
| * Generate the xsi:schemaLocation attribute value. | |
| * | |
| * Returns: | |
| * {String} The xsi:schemaLocation attribute or undefined if none. | |
| */ | |
| schemaLocationAttr: function(options) { | |
| options = OpenLayers.Util.extend({ | |
| featurePrefix: this.featurePrefix, | |
| schema: this.schema | |
| }, options); | |
| var schemaLocations = OpenLayers.Util.extend({}, this.schemaLocations); | |
| if(options.schema) { | |
| schemaLocations[options.featurePrefix] = options.schema; | |
| } | |
| var parts = []; | |
| var uri; | |
| for(var key in schemaLocations) { | |
| uri = this.namespaces[key]; | |
| if(uri) { | |
| parts.push(uri + " " + schemaLocations[key]); | |
| } | |
| } | |
| var value = parts.join(" ") || undefined; | |
| return value; | |
| }, | |
| /** | |
| * Method: setFilterProperty | |
| * Set the property of each spatial filter. | |
| * | |
| * Parameters: | |
| * filter - {<OpenLayers.Filter>} | |
| */ | |
| setFilterProperty: function(filter) { | |
| if(filter.filters) { | |
| for(var i=0, len=filter.filters.length; i<len; ++i) { | |
| this.setFilterProperty(filter.filters[i]); | |
| } | |
| } else { | |
| if(filter instanceof OpenLayers.Filter.Spatial) { | |
| // got a spatial filter, set its property | |
| filter.property = this.geometryName; | |
| } | |
| } | |
| }, | |
| CLASS_NAME: "OpenLayers.Format.WFST.v1" | |
| }); | |