Source: Scene/GetFeatureInfoFormat.js

  1. /*global define*/
  2. define([
  3.         '../Core/Cartographic',
  4.         '../Core/defaultValue',
  5.         '../Core/defined',
  6.         '../Core/DeveloperError',
  7.         '../Core/RuntimeError',
  8.         './ImageryLayerFeatureInfo'
  9.     ], function(
  10.         Cartographic,
  11.         defaultValue,
  12.         defined,
  13.         DeveloperError,
  14.         RuntimeError,
  15.         ImageryLayerFeatureInfo) {
  16.     'use strict';
  18.     /**
  19.      * Describes the format in which to request GetFeatureInfo from a Web Map Service (WMS) server.
  20.      *
  21.      * @alias GetFeatureInfoFormat
  22.      * @constructor
  23.      *
  24.      * @param {String} type The type of response to expect from a GetFeatureInfo request.  Valid
  25.      *        values are 'json', 'xml', 'html', or 'text'.
  26.      * @param {String} [format] The info format to request from the WMS server.  This is usually a
  27.      *        MIME type such as 'application/json' or text/xml'.  If this parameter is not specified, the provider will request 'json'
  28.      *        using 'application/json', 'xml' using 'text/xml', 'html' using 'text/html', and 'text' using 'text/plain'.
  29.      * @param {Function} [callback] A function to invoke with the GetFeatureInfo response from the WMS server
  30.      *        in order to produce an array of picked {@link ImageryLayerFeatureInfo} instances.  If this parameter is not specified,
  31.      *        a default function for the type of response is used.
  32.      */
  33.     function GetFeatureInfoFormat(type, format, callback) {
  34.         //>>includeStart('debug', pragmas.debug);
  35.         if (!defined(type)) {
  36.             throw new DeveloperError('type is required.');
  37.         }
  38.         //>>includeEnd('debug');
  40.         this.type = type;
  42.         if (!defined(format)) {
  43.             if (type === 'json') {
  44.                 format = 'application/json';
  45.             } else if (type === 'xml') {
  46.                 format = 'text/xml';
  47.             } else if (type === 'html') {
  48.                 format = 'text/html';
  49.             } else if (type === 'text') {
  50.                 format = 'text/plain';
  51.             }
  52.             //>>includeStart('debug', pragmas.debug);
  53.             else {
  54.                 throw new DeveloperError('format is required when type is not "json", "xml", "html", or "text".');
  55.             }
  56.             //>>includeEnd('debug');
  57.         }
  59.         this.format = format;
  61.         if (!defined(callback)) {
  62.             if (type === 'json') {
  63.                 callback = geoJsonToFeatureInfo;
  64.             } else if (type === 'xml') {
  65.                 callback = xmlToFeatureInfo;
  66.             } else if (type === 'html') {
  67.                 callback = textToFeatureInfo;
  68.             } else if (type === 'text') {
  69.                 callback = textToFeatureInfo;
  70.             }
  71.             //>>includeStart('debug', pragmas.debug);
  72.             else {
  73.                 throw new DeveloperError('callback is required when type is not "json", "xml", "html", or "text".');
  74.             }
  75.             //>>includeEnd('debug');
  76.         }
  78.         this.callback = callback;
  79.     }
  81.     function geoJsonToFeatureInfo(json) {
  82.         var result = [];
  84.         var features = json.features;
  85.         for (var i = 0; i < features.length; ++i) {
  86.             var feature = features[i];
  88.             var featureInfo = new ImageryLayerFeatureInfo();
  89.             featureInfo.data = feature;
  90.             featureInfo.properties = feature.properties;
  91.             featureInfo.configureNameFromProperties(feature.properties);
  92.             featureInfo.configureDescriptionFromProperties(feature.properties);
  94.             // If this is a point feature, use the coordinates of the point.
  95.             if (defined(feature.geometry) && feature.geometry.type === 'Point') {
  96.                 var longitude = feature.geometry.coordinates[0];
  97.                 var latitude = feature.geometry.coordinates[1];
  98.                 featureInfo.position = Cartographic.fromDegrees(longitude, latitude);
  99.             }
  101.             result.push(featureInfo);
  102.         }
  104.         return result;
  105.     }
  107.     var mapInfoMxpNamespace = 'http://www.mapinfo.com/mxp';
  108.     var esriWmsNamespace = 'http://www.esri.com/wms';
  109.     var wfsNamespace = 'http://www.opengis.net/wfs';
  110.     var gmlNamespace = 'http://www.opengis.net/gml';
  112.     function xmlToFeatureInfo(xml) {
  113.         var documentElement = xml.documentElement;
  114.         if (documentElement.localName === 'MultiFeatureCollection' && documentElement.namespaceURI === mapInfoMxpNamespace) {
  115.             // This looks like a MapInfo MXP response
  116.             return mapInfoXmlToFeatureInfo(xml);
  117.         } else if (documentElement.localName === 'FeatureInfoResponse' && documentElement.namespaceURI === esriWmsNamespace) {
  118.             // This looks like an Esri WMS response
  119.             return esriXmlToFeatureInfo(xml);
  120.         } else if (documentElement.localName === 'FeatureCollection' && documentElement.namespaceURI === wfsNamespace) {
  121.             // This looks like a WFS/GML response.
  122.             return gmlToFeatureInfo(xml);
  123.         } else if (documentElement.localName === 'ServiceExceptionReport') {
  124.             // This looks like a WMS server error, so no features picked.
  125.             throw new RuntimeError(new XMLSerializer().serializeToString(documentElement));
  126.         } else if (documentElement.localName === 'msGMLOutput') {
  127.                 return msGmlToFeatureInfo(xml);
  128.         } else {
  129.             // Unknown response type, so just dump the XML itself into the description.
  130.             return unknownXmlToFeatureInfo(xml);
  131.         }
  132.     }
  134.     function mapInfoXmlToFeatureInfo(xml) {
  135.         var result = [];
  137.         var multiFeatureCollection = xml.documentElement;
  139.         var features = multiFeatureCollection.getElementsByTagNameNS(mapInfoMxpNamespace, 'Feature');
  140.         for (var featureIndex = 0; featureIndex < features.length; ++featureIndex) {
  141.             var feature = features[featureIndex];
  143.             var properties = {};
  145.             var propertyElements = feature.getElementsByTagNameNS(mapInfoMxpNamespace, 'Val');
  146.             for (var propertyIndex = 0; propertyIndex < propertyElements.length; ++propertyIndex) {
  147.                 var propertyElement = propertyElements[propertyIndex];
  148.                 if (propertyElement.hasAttribute('ref')) {
  149.                     var name = propertyElement.getAttribute('ref');
  150.                     var value = propertyElement.textContent.trim();
  151.                     properties[name] = value;
  152.                 }
  153.             }
  155.             var featureInfo = new ImageryLayerFeatureInfo();
  156.             featureInfo.data = feature;
  157.             featureInfo.properties = properties;
  158.             featureInfo.configureNameFromProperties(properties);
  159.             featureInfo.configureDescriptionFromProperties(properties);
  160.             result.push(featureInfo);
  161.         }
  163.         return result;
  164.     }
  166.     function esriXmlToFeatureInfo(xml) {
  167.         var featureInfoResponse = xml.documentElement;
  168.         var result = [];
  169.         var properties;
  171.         var features = featureInfoResponse.getElementsByTagNameNS('*', 'FIELDS');
  172.         if (features.length > 0) {
  173.             // Standard esri format
  174.             for (var featureIndex = 0; featureIndex < features.length; ++featureIndex) {
  175.                 var feature = features[featureIndex];
  177.                 properties = {};
  179.                 var propertyAttributes = feature.attributes;
  180.                 for (var attributeIndex = 0; attributeIndex < propertyAttributes.length; ++attributeIndex) {
  181.                     var attribute = propertyAttributes[attributeIndex];
  182.                     properties[attribute.name] = attribute.value;
  183.                 }
  185.                 result.push(imageryLayerFeatureInfoFromDataAndProperties(feature, properties));
  186.             }
  187.         } else {
  188.             // Thredds format -- looks like esri, but instead of containing FIELDS, contains FeatureInfo element
  189.             var featureInfoElements = featureInfoResponse.getElementsByTagNameNS('*', 'FeatureInfo');
  190.             for (var featureInfoElementIndex = 0; featureInfoElementIndex < featureInfoElements.length; ++featureInfoElementIndex) {
  191.                 var featureInfoElement = featureInfoElements[featureInfoElementIndex];
  193.                 properties = {};
  195.                 // node.children is not supported in IE9-11, so use childNodes and check that child.nodeType is an element
  196.                 var featureInfoChildren = featureInfoElement.childNodes;
  197.                 for (var childIndex = 0; childIndex < featureInfoChildren.length; ++childIndex) {
  198.                     var child = featureInfoChildren[childIndex];
  199.                     if (child.nodeType === Node.ELEMENT_NODE) {
  200.                         properties[child.localName] = child.textContent;
  201.                     }
  202.                 }
  204.                 result.push(imageryLayerFeatureInfoFromDataAndProperties(featureInfoElement, properties));
  205.             }
  206.         }
  208.         return result;
  209.     }
  211.     function gmlToFeatureInfo(xml) {
  212.         var result = [];
  214.         var featureCollection = xml.documentElement;
  216.         var featureMembers = featureCollection.getElementsByTagNameNS(gmlNamespace, 'featureMember');
  217.         for (var featureIndex = 0; featureIndex < featureMembers.length; ++featureIndex) {
  218.             var featureMember = featureMembers[featureIndex];
  220.             var properties = {};
  221.             getGmlPropertiesRecursively(featureMember, properties);
  222.             result.push(imageryLayerFeatureInfoFromDataAndProperties(featureMember, properties));
  223.         }
  225.         return result;
  226.     }
  228.     // msGmlToFeatureInfo is similar to gmlToFeatureInfo, but assumes different XML structure
  229.     // eg. <msGMLOutput> <ABC_layer> <ABC_feature> <foo>bar</foo> ... </ABC_feature> </ABC_layer> </msGMLOutput>
  231.     function msGmlToFeatureInfo(xml) {
  232.         var result = [];
  234.         // Find the first child. Except for IE, this would work:
  235.         // var layer = xml.documentElement.children[0];
  236.         var layer;
  237.         var children = xml.documentElement.childNodes;
  238.         for (var i = 0; i < children.length; i++) {
  239.             if (children[i].nodeType === Node.ELEMENT_NODE) {
  240.                 layer = children[i];
  241.                 break;
  242.             }
  243.         }
  245.         var featureMembers = layer.childNodes;
  246.         for (var featureIndex = 0; featureIndex < featureMembers.length; ++featureIndex) {
  247.             var featureMember = featureMembers[featureIndex];
  248.             if (featureMember.nodeType === Node.ELEMENT_NODE) {
  249.                 var properties = {};
  250.                 getGmlPropertiesRecursively(featureMember, properties);
  251.                 result.push(imageryLayerFeatureInfoFromDataAndProperties(featureMember, properties));
  252.             }
  253.         }
  255.         return result;
  256.     }
  258.     function getGmlPropertiesRecursively(gmlNode, properties) {
  259.         var isSingleValue = true;
  261.         for (var i = 0; i < gmlNode.childNodes.length; ++i) {
  262.             var child = gmlNode.childNodes[i];
  264.             if (child.nodeType === Node.ELEMENT_NODE) {
  265.                 isSingleValue = false;
  266.             }
  268.             if (child.localName === 'Point' || child.localName === 'LineString' || child.localName === 'Polygon' || child.localName === 'boundedBy') {
  269.                 continue;
  270.             }
  272.             if (child.hasChildNodes() && getGmlPropertiesRecursively(child, properties)) {
  273.                 properties[child.localName] = child.textContent;
  274.             }
  275.         }
  277.         return isSingleValue;
  278.     }
  280.     function imageryLayerFeatureInfoFromDataAndProperties(data, properties) {
  281.         var featureInfo = new ImageryLayerFeatureInfo();
  282.         featureInfo.data = data;
  283.         featureInfo.properties = properties;
  284.         featureInfo.configureNameFromProperties(properties);
  285.         featureInfo.configureDescriptionFromProperties(properties);
  286.         return featureInfo;
  287.     }
  289.     function unknownXmlToFeatureInfo(xml) {
  290.         var xmlText = new XMLSerializer().serializeToString(xml);
  292.         var element = document.createElement('div');
  293.         var pre = document.createElement('pre');
  294.         pre.textContent = xmlText;
  295.         element.appendChild(pre);
  297.         var featureInfo = new ImageryLayerFeatureInfo();
  298.         featureInfo.data = xml;
  299.         featureInfo.description = element.innerHTML;
  300.         return [featureInfo];
  301.     }
  303.     var emptyBodyRegex= /<body>\s*<\/body>/im;
  304.     var wmsServiceExceptionReportRegex = /<ServiceExceptionReport([\s\S]*)<\/ServiceExceptionReport>/im;
  305.     var titleRegex = /<title>([\s\S]*)<\/title>/im;
  307.     function textToFeatureInfo(text) {
  308.         // If the text is HTML and it has an empty body tag, assume it means no features were found.
  309.         if (emptyBodyRegex.test(text)) {
  310.             return undefined;
  311.         }
  313.         // If this is a WMS exception report, treat it as "no features found" rather than showing
  314.         // bogus feature info.
  315.         if (wmsServiceExceptionReportRegex.test(text)) {
  316.             return undefined;
  317.         }
  319.         // If the text has a <title> element, use it as the name.
  320.         var name;
  321.         var title = titleRegex.exec(text);
  322.         if (title && title.length > 1) {
  323.             name = title[1];
  324.         }
  326.         var featureInfo = new ImageryLayerFeatureInfo();
  327.         featureInfo.name = name;
  328.         featureInfo.description = text;
  329.         featureInfo.data = text;
  330.         return [featureInfo];
  331.     }
  333.     return GetFeatureInfoFormat;
  334. });