layer/ogc.js

  1. 'use strict';
  2. const yxList = require('./reversedAxis.json');
  4. function getFeatureInfoBuilder(esriBundle) {
  5.     /**
  6.      * Handles click events for WMS layers (makes a WMS GetFeatureInfo call behind the scenes).
  7.      *
  8.      * @param {WMSLayer} wmsLayer an ESRI WMSLayer object to be queried
  9.      * @param {Object} clickEvent an ESRI map click event (used for screen coordinates)
  10.      * @param {Array} layerList a list of strings identifying the WMS layers to be queried
  11.      * @param {String} mimeType the format to be requested for the response
  12.      * @returns {Promise} a promise which resolves with the raw text of the GetFeatureInfo response
  13.      */
  14.     return (wmsLayer, clickEvent, layerList, mimeType) => {
  15.         let wkid;
  16.         let req;
  17.         const esriMap = wmsLayer.getMap();
  18.         const ext = esriMap.extent;
  19.         const srList = wmsLayer.spatialReferences;
  20.         const layers = layerList.join(',');
  22.         if (srList && srList.length > 1) {
  23.             wkid = srList[0];
  24.         } else if (esriMap.spatialReference.wkid) {
  25.             wkid = esriMap.spatialReference.wkid;
  26.         }
  27.         if (wmsLayer.version === '1.3' || wmsLayer.version === '1.3.0') {
  28.             req = { CRS: 'EPSG:' + wkid, I: clickEvent.screenPoint.x, J: clickEvent.screenPoint.y,
  29.                     STYLES: '', FORMAT: wmsLayer.imageFormat };
  30.             if (yxList.indexOf(String(wkid)) > -1) {
  31.                 req.BBOX = `${ext.ymin},${ext.xmin},${ext.ymax},${ext.xmax}`;
  32.             }
  33.         } else {
  34.             req = { SRS: 'EPSG:' + wkid, X: clickEvent.screenPoint.x, Y: clickEvent.screenPoint.y };
  35.         }
  36.         if (!req.hasOwnProperty('BBOX')) {
  37.             req.BBOX = `${ext.xmin},${ext.ymin},${ext.xmax},${ext.ymax}`;
  38.         }
  39.         const settings = {
  40.             SERVICE: 'WMS',
  41.             REQUEST: 'GetFeatureInfo',
  42.             VERSION: wmsLayer.version,
  43.             WIDTH: esriMap.width,
  44.             HEIGHT: esriMap.height,
  45.             QUERY_LAYERS: layers,
  46.             LAYERS: layers,
  47.             INFO_FORMAT: mimeType
  48.         };
  50.         Object.keys(settings).forEach(key => req[key] = settings[key]);
  52.         return Promise.resolve(esriBundle.esriRequest({
  53.             url: wmsLayer.url.split('?')[0],
  54.             content: req,
  55.             handleAs: 'text'
  56.         }));
  57.     };
  58. }
  60. function parseCapabilitiesBuilder(esriBundle) {
  62.     const query = esriBundle.dojoQuery;
  64.     /**
  65.      * Fetch layer data from a WMS endpoint.  This method will execute a WMS GetCapabilities
  66.      * request against the specified URL, it requests WMS 1.3 and it is capable of parsing
  67.      * 1.3 or 1.1.1 responses.  It returns a promise which will resolve with basic layer
  68.      * metadata and querying information.
  69.      *
  70.      * metadata response format:
  71.      *   { queryTypes: [mimeType(str)],
  72.      *     layers: [
  73.      *       {name(str), desc(str), queryable(bool), layers:[recursive] }
  74.      *     ] }
  75.      *
  76.      * @param {string} wmsEndpoint a URL pointing to a WMS server (it must not include a query string)
  77.      * @return {Promise} a promise resolving with a metadata object (as specified above)
  78.      */
  79.     return (wmsEndpoint) => {
  80.         const reqPromise = new Promise(resolve => {
  81.             getCapabilities()
  82.                 .then(data => resolve(data)) // if successful, pass straight back
  83.                 .catch(() => { // if errors, try again; see fgpv-vpgf/fgpv-vpgf#908 issue
  84.                     console.error('Get capabilities failed; trying the second time;');
  85.                     resolve(getCapabilities());
  86.                 });
  87.         });
  89.         // there might already be a way to do this in the parsing API
  90.         // I don't know XML parsing well enough (and I don't want to)
  91.         // this has now been ported from RAMP to FGPV and I still, happily,
  92.         // do not know any more about XML parsing now
  93.         function getImmediateChild(node, childName) {
  94.             for (let i = 0; i < node.childNodes.length; ++i) {
  95.                 if (node.childNodes[i].nodeName === childName) {
  96.                     return node.childNodes[i];
  97.                 }
  98.             }
  99.             return undefined;
  100.         }
  102.         // find all <Layer> nodes under the given XML node
  103.         // pick title, name and queryable nodes/attributes
  104.         // recursively called on all child <Layer> nodes
  105.         function getLayers(xmlNode) {
  106.             return query('> Layer', xmlNode).map(layer => {
  107.                 const nameNode = getImmediateChild(layer, 'Name');
  108.                 const titleNode = getImmediateChild(layer, 'Title');
  109.                 return {
  110.                     name: nameNode ? nameNode.textContent : null,
  111.                     desc: titleNode.textContent,
  112.                     queryable: layer.getAttribute('queryable') === '1',
  113.                     layers: getLayers(layer)
  114.                 };
  115.             });
  116.         }
  118.         function getCapabilities() {
  119.             let url = wmsEndpoint;
  121.             // if url has a '?' do not append to avoid errors, user must add this manually
  122.             if (wmsEndpoint.indexOf('?') === -1) {
  123.                 url += '?service=WMS&version=1.3&request=GetCapabilities';
  124.             }
  126.             return Promise.resolve(new esriBundle.esriRequest({
  127.                 url,
  128.                 handleAs: 'xml'
  129.             }).promise);
  130.         }
  132.         return reqPromise.then(data => ({
  133.             layers: getLayers(query('Capability', data)[0]),
  134.             queryTypes: query('GetFeatureInfo > Format', data).map(node => node.textContent)
  135.         }));
  136.     };
  138. }
  140. /**
  141.  * Recursively crawl a wms layer info structure. Store any legends in the provided map object.
  142.  *
  143.  * @private
  144.  * @param {Array} layerInfos array of ESRI WMSLayerInfo objects
  145.  * @param {Map} urlMap a Map of sublayer names to legend urls
  146.  */
  147. function crawlLayerInfos(layerInfos, urlMap) {
  148.     layerInfos.forEach(li => {
  149.         if (li.name) {
  150.             urlMap.set(li.name, li.legendURL);
  151.         }
  152.         if (li.subLayers.length > 0) {
  153.             crawlLayerInfos(li.subLayers, urlMap);
  154.         }
  155.     });
  156. }
  158. /**
  159.  * Finds the appropriate legend URLs for WMS layers.
  160.  *
  161.  * @param {WMSLayer} wmsLayer an ESRI WMSLayer object to be queried
  162.  * @param {Array} layerList a list of strings identifying the WMS layers to be queried
  163.  * @returns {Array} a list of strings containing URLs for specified layers (order is preserved)
  164.  */
  165. function getLegendUrls(wmsLayer, layerList) {
  166.     const liMap = new Map(); // use Map in case someone clever uses a WMS layer name that matches an Object's default properties
  167.     crawlLayerInfos(wmsLayer.layerInfos, liMap);
  168.     return layerList.map(l => liMap.get(l));
  169. }
  171. module.exports = esriBundle => {
  172.     return {
  173.         WmsLayer: esriBundle.WmsLayer,
  174.         getFeatureInfo: getFeatureInfoBuilder(esriBundle),
  175.         parseCapabilities: parseCapabilitiesBuilder(esriBundle),
  176.         getLegendUrls
  177.     };
  178. };