Add filterType source param and use QGIS EXP_FILTER when param is qgis

src/controls/offline/wfs.js

@@ -10,23 +10,26 @@ wfs.request = function request(layer) {
   sourceOptions.filter = layer.get('filter');
   sourceOptions.projectionCode = viewer.getProjectionCode();
   sourceOptions.extent = layer.get('extent');
-  sourceOptions.projectionCode = viewer.getProjectionCode();
 
   const req = createRequest(sourceOptions);
   return req;
 
   function createRequest(options) {
-    console.log('createRequest')
+    console.log('createRequest');
     const format = new GeoJSONFormat({
       geometryName: options.geometryName
     });
 
     const serverUrl = options.url;
     let queryFilter;
 
-    // If cql filter then bbox must be used in the filter.
     if (options.filter) {
+      if (options.filterType === 'qgis') {
+        queryFilter = `&BBOX=${options.extent.join(',')},${options.projectionCode}&EXP_FILTER=${options.filter}`;
+      } else {
+    // If cql filter then bbox must be used in the filter.
       queryFilter = `&CQL_FILTER=${options.filter} AND BBOX(${options.geometryName},${options.extent.join(',')},'${options.projectionCode}')`;
+      }
     } else {
       queryFilter = `&BBOX=${options.extent.join(',')},${options.projectionCode}`;
     }

src/getfeature.js

@@ -10,12 +10,13 @@ export default function getfeature(id, layer, source, projCode, proj, extent) {
   projectionCode = projCode;
   projection = proj;
   const serverUrl = source[layer.get('sourceName')].url;
+  const filterType = source[layer.get('sourceName')].filterType;
   const type = layer.get('type');
   // returns a promise with features as result
   if (type === 'AGS_FEATURE') {
     return sourceType.AGS_FEATURE(id, layer, serverUrl);
   }
-  return sourceType.WFS(id, layer, serverUrl, extent);
+  return sourceType.WFS(id, layer, serverUrl, filterType, extent);
 }
 
 function fail(response) {
@@ -53,7 +54,7 @@ sourceType.AGS_FEATURE = function agsFeature(id, layer, serverUrl) {
   })).catch(error => console.error(error));
 };
 
-sourceType.WFS = function wfsSourceType(id, layer, serverUrl, extent) {
+sourceType.WFS = function wfsSourceType(id, layer, serverUrl, filterType, extent) {
   const geometryName = layer.get('geometryName');
   const format = new GeoJSONFormat({
     geometryName
@@ -77,14 +78,22 @@ sourceType.WFS = function wfsSourceType(id, layer, serverUrl, extent) {
       minExtent = layerExtent;
     }
     if (filter) {
-      if (minExtent) {
+      if (minExtent && filterType === 'qgis') {
+        queryFilter = `&EXP_FILTER=${filter}&BBOX=${minExtent.toString()}`;
+      } else if (minExtent) {
         queryFilter = layer.get('geometryName') ? `&CQL_FILTER=${filter} AND BBOX(${layer.get('geometryName')},${minExtent.toString()})` : `&CQL_FILTER=${filter}&BBOX=${minExtent.toString()}`;
+      } else if (filterType === 'qgis') {
+        queryFilter = `&EXP_FILTER=${filter}`;
       } else {
         queryFilter = `&CQL_FILTER=${filter}`;
       }
+    } else if (!layer.get('geometryName') || (minExtent && filterType === 'qgis')) {
+      queryFilter = `&BBOX=${minExtent.toString()}`;
     } else if (minExtent) {
-      queryFilter = layer.get('geometryName') ? `&CQL_FILTER=BBOX(${layer.get('geometryName')},${minExtent.toString()})` : `&BBOX=${minExtent.toString()}`;
+      queryFilter = `&CQL_FILTER=BBOX(${layer.get('geometryName')},${minExtent.toString()})`;
     }
+  } else if (filterType === 'qgis') {
+    queryFilter = `&featureId=${layer.get('name')}.${id}`;
   } else {
     queryFilter = `&featureId=${id}`;
   }

src/layer/wfs.js

@@ -7,7 +7,9 @@ export default function wfs(layerOptions, viewer) {
   const wfsDefault = {
     layerType: 'vector'
   };
-  const sourceDefault = {};
+  const sourceDefault = {
+    filterType: 'cql'
+  };
   const wfsOptions = Object.assign({}, wfsDefault, layerOptions);
   const sourceOptions = Object.assign({}, sourceDefault, viewer.getMapSource()[layerOptions.sourceName]);
   sourceOptions.featureType = wfsOptions.id;

src/layer/wfssource.js

@@ -63,49 +63,97 @@ class WfsSource extends VectorSource {
   }
 
   /**
-   * Helper to reuse code. Consider it to be private to this class
-   * @param {any} extent
-   * @param {any} cql if provided, extent is ignored
+   * Generate a wfs query filter according to the wfs layer source's `filterType`. Combines
+   * the custom filter parameter with any layer filters already present.
+   * @param {string} filterType The filter type used by the layer source (`cql`|`qgis`)
+   * @param {string} customFilter custom filter to combine with preconfigured layer filters
+   * @param {any} extent ignored when customFilter is supplied
    */
-  async _loaderHelper(extent, cql) {
-    const serverUrl = this._options.url;
-
-    // Set up the cql filter as a combination of the layer filter and the temporary cql parameter
-    let cqlfilter = '';
-    if (this._options.filter) {
-      cqlfilter = replacer.replace(this._options.filter, window);
-      if (cql) {
-        cqlfilter += ' AND ';
-      }
+  createQueryFilter(filterType, customFilter, extent) {
+    let queryFilter = '';
+    let layerFilter = '';
+    if (this.getOptions().filter) {
+      layerFilter = replacer.replace(this.getOptions().filter, window);
     }
-    if (cql) {
-      cqlfilter += `${replacer.replace(cql, window)}`;
+
+    // Transform the extent if necessary
+    let requestExtent = extent;
+    if (extent && this.getOptions().dataProjection !== this.getOptions().projectionCode) {
+      requestExtent = transformExtent(extent, this.getOptions().projectionCode, this.getOptions().dataProjection);
     }
 
-    // Create the complete CQL query string
-    let queryFilter = '';
-    if (this._options.strategy === 'all' || cql || this._options.isTable) {
-      queryFilter = cqlfilter ? `&CQL_FILTER=${cqlfilter}` : '';
-    } else {
-      // Extent should be used. Depending if there also is a filter, the queryfilter looks different
-      let requestExtent;
-      if (this._options.dataProjection !== this._options.projectionCode) {
-        requestExtent = transformExtent(extent, this._options.projectionCode, this._options.dataProjection);
-      } else {
-        requestExtent = extent;
-      }
-      if (cqlfilter) {
-        queryFilter = `&CQL_FILTER=${cqlfilter} AND BBOX(${this._options.geometryName},${requestExtent.join(',')},'${this._options.dataProjection}')`;
-      } else {
-        queryFilter = `&BBOX=${requestExtent.join(',')},${this._options.dataProjection}`;
+    // When using BBOX mode and no filters, just use the BBOX WFS parameter
+    if (extent && this.getOptions().strategy !== 'all' && !this.getOptions().isTable && !customFilter && !layerFilter) {
+      queryFilter = `&BBOX=${requestExtent.join(',')},${this.getOptions().dataProjection}`;
+    } else { // Otherwise, integrate provided layer filters, `customFilter` and extent into a single query filter
+      switch (filterType) {
+        case 'cql': {
+          // Set up the filter as a combination of the layer filter and the temporary filter parameter
+          let cqlfilter = layerFilter;
+          if (layerFilter && customFilter) {
+            cqlfilter += ' AND ';
+          }
+          if (customFilter) {
+            cqlfilter += `${replacer.replace(customFilter, window)}`;
+          }
+
+          // If using extent, no `customFilter`, and the layer is not a geometryless table, integrate it into the query filter
+          if (extent && this.getOptions().strategy !== 'all' && !customFilter && !this.getOptions().isTable) {
+            if (cqlfilter) {
+              cqlfilter += ' AND ';
+            }
+            cqlfilter += `BBOX(${this.getOptions().geometryName},${requestExtent.join(',')},'${this.getOptions().dataProjection}')`;
+          }
+
+          // Create the complete CQL query string
+          if (cqlfilter) {
+            queryFilter = `&CQL_FILTER=${cqlfilter}`;
+          }
+          break;
+        }
+        case 'qgis': {
+          // Set up the filter as a combination of the layer filter and the temporary filter parameter
+          let qgisFilter = layerFilter;
+          if (layerFilter && customFilter) {
+            qgisFilter += ' AND ';
+          }
+          if (customFilter) {
+            qgisFilter += `${replacer.replace(customFilter, window)}`;
+          }
+          // Create the complete QGIS EXP_FILTER query string
+          if (qgisFilter) {
+            qgisFilter = `&EXP_FILTER=${qgisFilter}`;
+          }
+
+          // If using extent, no `customFilter`, and the layer is not a geometryless table, add a BBOX WFS parameter
+          // Because of QGIS Server's lack of support for any SRS other than EPSG:4326 in GeoJSON, layers must be requested
+          // in EPSG:4326. EXP_FILTER comparisons still expects the SRS of the data to be used, which Origo then doesn't know.
+          if (extent && this.getOptions().strategy !== 'all' && !customFilter && !this.getOptions().isTable) {
+            queryFilter = `&BBOX=${requestExtent.join(',')},${this.getOptions().dataProjection}${qgisFilter}`;
+          } else {
+            queryFilter = qgisFilter;
+          }
+          break;
+        }
+        default: break;
       }
     }
+    return queryFilter;
+  }
+
+  /**
+   * Helper to reuse code. Consider it to be private to this class
+   * @param {any} extent
+   * @param {any} filter if provided, extent is ignored
+   */
+  async _loaderHelper(extent, filter) {
+    const serverUrl = this._options.url;
 
     // Create the complete URL
     let url = [`${serverUrl}${serverUrl.indexOf('?') < 0 ? '?' : '&'}service=WFS`,
       `&version=1.1.0&request=GetFeature&typeName=${this._options.featureType}&outputFormat=application/json`,
       `&srsname=${this._options.dataProjection}`].join('');
-    url += queryFilter;
+    url += this.createQueryFilter(this._options.filterType, filter, extent);
     url = encodeURI(url);
 
     // Actually fetch some features
@@ -125,12 +173,12 @@ class WfsSource extends VectorSource {
   }
 
   /**
-   * Makes a call to the server with the provided cql filter and adds all matching records to the layer.
+   * Makes a call to the server with the provided query filter and adds all matching records to the layer.
    * If the layer has a filter it is honoured.
-   * @param {any} cql
+   * @param {any} filter
    */
-  async ensureLoaded(cql) {
-    await this._loaderHelper(null, cql);
+  async ensureLoaded(filter) {
+    await this._loaderHelper(null, filter);
   }
 }