Source: src/data/store/WfsFeatures.js

  1. /* Copyright (c) 2015-present The Open Source Geospatial Foundation
  2.  *
  3.  * This program is free software: you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation, either version 3 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15.  */
  16. /**
  17.  * A data store loading features from an OGC WFS.
  18.  *
  19.  * @class GeoExt.data.store.WfsFeatures
  20.  */
  21. Ext.define('GeoExt.data.store.WfsFeatures', {
  22.   extend: 'GeoExt.data.store.Features',
  23.   mixins: ['GeoExt.mixin.SymbolCheck', 'GeoExt.util.OGCFilter'],
  25.   /**
  26.    * If autoLoad is true, this store's loadWfs method is automatically called
  27.    * after creation.
  28.    * @cfg {boolean}
  29.    */
  30.   autoLoad: true,
  32.   /**
  33.    * Default to using server side sorting
  34.    * @cfg {boolean}
  35.    */
  36.   remoteSort: true,
  38.   /**
  39.    * Default to using server side filtering
  40.    * @cfg {boolean}
  41.    */
  42.   remoteFilter: true,
  44.   /**
  45.    * Default logical comperator to combine filters sent to WFS
  46.    * @cfg {string}
  47.    */
  48.   logicalFilterCombinator: 'And',
  50.   /**
  51.    * Default request method to use in AJAX requests
  52.    * @cfg {string}
  53.    */
  54.   requestMethod: 'GET',
  56.   /**
  57.    * The 'service' param value used in the WFS request.
  58.    * @cfg {string}
  59.    */
  60.   service: 'WFS',
  62.   /**
  63.    * The 'version' param value used in the WFS request.
  64.    * This should be '2.0.0' or higher at least if the paging mechanism
  65.    * should be used.
  66.    * @cfg {string}
  67.    */
  68.   version: '2.0.0',
  70.   /**
  71.    * The 'request' param value used in the WFS request.
  72.    * @cfg {string}
  73.    */
  74.   request: 'GetFeature',
  76.   /**
  77.    * The 'typeName' param value used in the WFS request.
  78.    * @cfg {string}
  79.    */
  80.   typeName: null,
  82.   /**
  83.    * The 'srsName' param value used in the WFS request. If not set
  84.    * it is automatically set to the map projection when available.
  85.    * @cfg {string}
  86.    */
  87.   srsName: null,
  88.   /**
  89.    * The 'outputFormat' param value used in the WFS request.
  90.    * @cfg {string}
  91.    */
  92.   outputFormat: 'application/json',
  94.   /**
  95.    * The 'startIndex' param value used in the WFS request.
  96.    * @cfg {string}
  97.    */
  98.   startIndex: 0,
  100.   /**
  101.    * The 'count' param value used in the WFS request.
  102.    * @cfg {string}
  103.    */
  104.   count: null,
  106.   /**
  107.    * A comma-separated list of property names to retrieve
  108.    * from the server. If left as null all properties are returned.
  109.    * @cfg {string}
  110.    */
  111.   propertyName: null,
  113.   /**
  114.    * Offset to add to the #startIndex in the WFS request.
  115.    * @cfg {number}
  116.    */
  117.   startIndexOffset: 0,
  119.   /**
  120.    * The OL format used to parse the WFS GetFeature response.
  121.    * @cfg {ol.format.Feature}
  122.    */
  123.   format: null,
  125.   /**
  126.    * The attribution added to the created vector layer source. Only has an
  127.    * effect if #createLayer is set to `true`
  128.    * @cfg {string}
  129.    */
  130.   layerAttribution: null,
  132.   /**
  133.    * Additional OpenLayers properties to apply to the created vector layer.
  134.    * Only has an effect if #createLayer is set to `true`
  135.    * @cfg {string}
  136.    */
  137.   layerOptions: null,
  139.   /**
  140.    * Cache the total number of features be queried from when the store is
  141.    * first loaded to use for the remaining life of the store.
  142.    * This uses resultType=hits to get the number of features and can improve
  143.    * performance rather than calculating on each request. It should be used
  144.    * for read-only layers, or when the server does not return the
  145.    * feature count on each request.
  146.    * @cfg {boolean}
  147.    */
  148.   cacheFeatureCount: false,
  150.   /**
  151.    * The outputFormat sent with the resultType=hits request.
  152.    * Defaults to GML3 as some WFS servers do not support this
  153.    * request type when using application/json.
  154.    * Only has an effect if #cacheFeatureCount is set to `true`
  155.    * @cfg {boolean}
  156.    */
  157.   featureCountOutputFormat: 'gml3',
  159.   /**
  160.    * Time any request will be debounced. This will prevent too
  161.    * many successive request.
  162.    * @cfg {number}
  163.    */
  164.   debounce: 300,
  166.   /**
  167.    * Constructs the WFS feature store.
  168.    *
  169.    * @param {Object} config The configuration object.
  170.    * @private
  171.    */
  172.   constructor: function (config) {
  173.     const me = this;
  175.     config = config || {};
  177.     // apply count as store's pageSize
  178.     config.pageSize = config.count || me.count;
  180.     if (config.pageSize > 0) {
  181.       // calculate initial page
  182.       const startIndex = config.startIndex || me.startIndex;
  183.       config.currentPage = Math.floor(startIndex / config.pageSize) + 1;
  184.     }
  186.     // avoid creation of vector layer by parent class (raises error when
  187.     // applying WFS data) so we can create the WFS vector layer on our own
  188.     // (if needed)
  189.     const createLayer = config.createLayer;
  190.     config.createLayer = false;
  191.     config.passThroughFilter = false; // only has effect for layers
  193.     me.callParent([config]);
  195.     me.loadWfsTask_ = new Ext.util.DelayedTask();
  197.     if (!me.url) {
  198.       Ext.raise('No URL given to WfsFeaturesStore');
  199.     }
  201.     if (createLayer) {
  202.       // the WFS vector layer showing the WFS features on the map
  203.       me.source = new ol.source.Vector({
  204.         features: new ol.Collection(),
  205.         attributions: me.layerAttribution,
  206.       });
  208.       const layerOptions = {
  209.         source: me.source,
  210.         style: me.style,
  211.       };
  213.       if (me.layerOptions) {
  214.         Ext.applyIf(layerOptions, me.layerOptions);
  215.       }
  217.       me.layer = new ol.layer.Vector(layerOptions);
  219.       me.layerCreated = true;
  220.     }
  222.     if (me.cacheFeatureCount === true) {
  223.       me.cacheTotalFeatureCount(!me.autoLoad);
  224.     } else {
  225.       if (me.autoLoad) {
  226.         // initial load of the WFS data
  227.         me.loadWfs();
  228.       }
  229.     }
  231.     // before the store gets re-loaded (e.g. by a paging toolbar) we trigger
  232.     // the re-loading of the WFS, so the data keeps in sync
  233.     me.on('beforeload', me.loadWfs, me);
  235.     // add layer to connected map, if available
  236.     if (me.map && me.layer) {
  237.       me.map.addLayer(me.layer);
  238.     }
  239.   },
  241.   /**
  242.    * Detects the total amount of features (without paging) of the given
  243.    * WFS response. The detection is based on the response format (currently
  244.    * GeoJSON and GML >=v3 are supported).
  245.    *
  246.    * @private
  247.    * @param  {Object} wfsResponse The XMLHttpRequest object
  248.    * @return {number}            Total amount of features
  249.    */
  250.   getTotalFeatureCount: function (wfsResponse) {
  251.     let totalCount = -1;
  252.     // get the response type from the header
  253.     const contentType = wfsResponse.getResponseHeader('Content-Type');
  255.     try {
  256.       if (contentType.indexOf('application/json') !== -1) {
  257.         const respJson = Ext.decode(wfsResponse.responseText);
  258.         totalCount = respJson.numberMatched;
  259.       } else {
  260.         // assume GML
  261.         const xml = wfsResponse.responseXML;
  262.         if (xml && xml.firstChild) {
  263.           const total = xml.firstChild.getAttribute('numberMatched');
  264.           totalCount = parseInt(total, 10);
  265.         }
  266.       }
  267.     } catch (e) {
  268.       Ext.Logger.warn(
  269.         'Error while detecting total feature count from ' + 'WFS response',
  270.       );
  271.     }
  273.     return totalCount;
  274.   },
  276.   /**
  277.    * Sends the sortBy parameter to the WFS Server
  278.    * If multiple sorters are specified then multiple fields are
  279.    * sent to the server.
  280.    * Ascending sorts will append ASC and descending sorts DESC
  281.    * E.g. sortBy=attribute1 DESC,attribute2 ASC
  282.    * @private
  283.    * @return {string} The sortBy string
  284.    */
  285.   createSortByParameter: function () {
  286.     const me = this;
  287.     const sortStrings = [];
  288.     let direction;
  289.     let property;
  291.     me.getSorters().each(function (sorter) {
  292.       // direction will be ASC or DESC
  293.       direction = sorter.getDirection();
  294.       property = sorter.getProperty();
  295.       sortStrings.push(Ext.String.format('{0} {1}', property, direction));
  296.     });
  298.     return sortStrings.join(',');
  299.   },
  301.   /**
  302.    * Create filter parameter string (according to Filter Encoding standard)
  303.    * based on the given instances in filters ({Ext.util.FilterCollection}) of
  304.    * the store.
  305.    *
  306.    * @private
  307.    * @return {string} The filter XML encoded as string
  308.    */
  309.   createOgcFilter: function () {
  310.     const me = this;
  311.     const filters = [];
  312.     me.getFilters().each(function (item) {
  313.       filters.push(item);
  314.     });
  315.     if (filters.length === 0) {
  316.       return null;
  317.     }
  318.     return GeoExt.util.OGCFilter.getOgcWfsFilterFromExtJsFilter(
  319.       filters,
  320.       me.logicalFilterCombinator,
  321.       me.version,
  322.     );
  323.   },
  325.   /**
  326.    * Gets the number of features for the WFS typeName
  327.    * using resultType=hits and caches it so it only needs to be calculated
  328.    * the first time the store is used.
  329.    *
  330.    * @param  {boolean} skipLoad Avoids loading the store if set to `true`
  331.    * @private
  332.    */
  333.   cacheTotalFeatureCount: function (skipLoad) {
  334.     const me = this;
  335.     const url = me.url;
  336.     me.cachedTotalCount = 0;
  338.     const params = {
  339.       service: me.service,
  340.       version: me.version,
  341.       request: me.request,
  342.       typeName: me.typeName,
  343.       outputFormat: me.featureCountOutputFormat,
  344.       resultType: 'hits',
  345.     };
  347.     Ext.Ajax.request({
  348.       url: url,
  349.       method: me.requestMethod,
  350.       params: params,
  351.       success: function (resp) {
  352.         // set number of total features (needed for paging)
  353.         me.cachedTotalCount = me.getTotalFeatureCount(resp);
  354.         if (!skipLoad) {
  355.           me.loadWfs();
  356.         }
  357.       },
  358.       failure: function (resp) {
  359.         Ext.Logger.warn(
  360.           'Error while requesting features from WFS: ' +
  361.             resp.responseText +
  362.             ' Status: ' +
  363.             resp.status,
  364.         );
  365.       },
  366.     });
  367.   },
  369.   /**
  370.    * Handles the 'filterchange'-event.
  371.    * Reload data using updated filter config.
  372.    * @private
  373.    */
  374.   onFilterChange: function () {
  375.     const me = this;
  376.     if (me.getFilters() && me.getFilters().length > 0) {
  377.       me.loadWfs();
  378.     }
  379.   },
  381.   /**
  382.    * Create a parameters object used to make a WFS feature request
  383.    * @return {Object} A object of WFS parameter keys and values
  384.    */
  385.   createParameters: function () {
  386.     const me = this;
  388.     const params = {
  389.       service: me.service,
  390.       version: me.version,
  391.       request: me.request,
  392.       typeName: me.typeName,
  393.       outputFormat: me.outputFormat,
  394.     };
  396.     // add a propertyName parameter if set
  397.     if (me.propertyName !== null) {
  398.       params.propertyName = me.propertyName;
  399.     }
  401.     // add a srsName parameter
  402.     if (me.srsName) {
  403.       params.srsName = me.srsName;
  404.     } else {
  405.       // if it has not been set manually retrieve from the map
  406.       if (me.map) {
  407.         params.srsName = me.map.getView().getProjection().getCode();
  408.       }
  409.     }
  411.     // send the sortBy parameter only when remoteSort is true
  412.     // as it is not supported by all WFS servers
  413.     if (me.remoteSort === true) {
  414.       const sortBy = me.createSortByParameter();
  415.       if (sortBy) {
  416.         params.sortBy = sortBy;
  417.       }
  418.     }
  420.     // create filter string if remoteFilter is activated
  421.     if (me.remoteFilter === true) {
  422.       const filter = me.createOgcFilter();
  423.       if (filter) {
  424.         params.filter = filter;
  425.       }
  426.     }
  428.     // apply paging parameters if necessary
  429.     if (me.pageSize) {
  430.       me.startIndex = (me.currentPage - 1) * me.pageSize + me.startIndexOffset;
  431.       params.startIndex = me.startIndex;
  432.       params.count = me.pageSize;
  433.     }
  435.     return params;
  436.   },
  438.   /**
  439.    * Loads the data from the connected WFS.
  440.    * @private
  441.    */
  442.   loadWfs: function () {
  443.     const me = this;
  445.     if (me.loadWfsTask_.id === null) {
  446.       me.loadWfsTask_.delay(me.debounce, function () {});
  447.       me.loadWfsInternal();
  448.     } else {
  449.       me.loadWfsTask_.delay(me.debounce, function () {
  450.         me.loadWfsInternal();
  451.       });
  452.     }
  453.   },
  455.   loadWfsInternal: function () {
  456.     const me = this;
  458.     const url = me.url;
  459.     const params = me.createParameters();
  461.     // fire event 'gx-wfsstoreload-beforeload' and skip loading if listener
  462.     // function returns false
  463.     if (me.fireEvent('gx-wfsstoreload-beforeload', me, params) === false) {
  464.       return;
  465.     }
  467.     // request features from WFS
  468.     Ext.Ajax.request({
  469.       url: url,
  470.       method: me.requestMethod,
  471.       params: params,
  472.       success: function (resp) {
  473.         if (!me.format) {
  474.           Ext.Logger.warn(
  475.             'No format given for WfsFeatureStore. ' +
  476.               'Skip parsing feature data.',
  477.           );
  478.           return;
  479.         }
  481.         if (me.cacheFeatureCount === true) {
  482.           // me.totalCount is reset to 0 on each load so reset it here
  483.           me.totalCount = me.cachedTotalCount;
  484.         } else {
  485.           // set number of total features (needed for paging)
  486.           me.totalCount = me.getTotalFeatureCount(resp);
  487.         }
  489.         // parse WFS response to OL features
  491.         let wfsFeats = [];
  493.         try {
  494.           wfsFeats = me.format.readFeatures(resp.responseText);
  495.         } catch (error) {
  496.           Ext.Logger.warn(
  497.             'Error parsing features into the ' +
  498.               'OpenLayers format. Check the server response.',
  499.           );
  500.         }
  502.         // set data for store
  503.         me.setData(wfsFeats);
  505.         if (me.layer) {
  506.           // add features to WFS layer
  507.           me.source.clear();
  508.           me.source.addFeatures(wfsFeats);
  509.         }
  511.         me.fireEvent('gx-wfsstoreload', me, wfsFeats, true);
  512.       },
  513.       failure: function (resp) {
  514.         if (resp.aborted !== true) {
  515.           Ext.Logger.warn(
  516.             'Error while requesting features from WFS: ' +
  517.               resp.responseText +
  518.               ' Status: ' +
  519.               resp.status,
  520.           );
  521.         }
  522.         me.fireEvent('gx-wfsstoreload', me, null, false);
  523.       },
  524.     });
  525.   },
  527.   doDestroy: function () {
  528.     const me = this;
  530.     if (me.loadWfsTask_.id !== null) {
  531.       me.loadWfsTask_.cancel();
  532.     }
  534.     me.callParent(arguments);
  535.   },
  536. });