@igo2/geo 1.12.0 → 1.13.0-alpha.1

package/esm2020/lib/datasource/shared/datasources/wfs-datasource.mjs

@@ -0,0 +1,74 @@
+import olSourceVector from 'ol/source/Vector';
+import * as OlLoadingStrategy from 'ol/loadingstrategy';
+import olProjection from 'ol/proj/Projection';
+import * as olproj from 'ol/proj';
+import { DataSource } from './datasource';
+import { OgcFilterWriter } from '../../../filter/shared/ogc-filter';
+import { defaultFieldNameGeometry, checkWfsParams, getFormatFromOptions, buildUrl } from './wms-wfs.utils';
+import { BehaviorSubject } from 'rxjs';
+export class WFSDataSource extends DataSource {
+    constructor(options, wfsService, authInterceptor) {
+        super(checkWfsParams(options, 'wfs'));
+        this.options = options;
+        this.wfsService = wfsService;
+        this.authInterceptor = authInterceptor;
+        this.mostRecentIdCallOGCFilter = 0;
+        this.ogcFilters$ = new BehaviorSubject(undefined);
+        const ogcFilters = this.options.ogcFilters;
+        const fieldNameGeometry = this.options.paramsWFS.fieldNameGeometry || defaultFieldNameGeometry;
+        const ogcFilterWriter = new OgcFilterWriter();
+        this.options.ogcFilters =
+            ogcFilterWriter.defineOgcFiltersDefaultOptions(ogcFilters, fieldNameGeometry);
+        if (this.options.ogcFilters.enabled &&
+            this.options.ogcFilters.editable &&
+            (options.sourceFields || []).filter(sf => !sf.values).length > 0) {
+            this.wfsService.getSourceFieldsFromWFS(this.options);
+        }
+        if (ogcFilters?.pushButtons) {
+            ogcFilters.pushButtons.selectorType = 'pushButton';
+        }
+        if (ogcFilters?.checkboxes) {
+            ogcFilters.checkboxes.selectorType = 'checkbox';
+        }
+        if (ogcFilters?.radioButtons) {
+            ogcFilters.radioButtons.selectorType = 'radioButton';
+        }
+        if (ogcFilters?.select) {
+            ogcFilters.select.selectorType = 'select';
+        }
+        if (ogcFilters?.autocomplete) {
+            ogcFilters.autocomplete.selectorType = 'autocomplete';
+        }
+        this.setOgcFilters(this.options.ogcFilters, true);
+    }
+    set ogcFilters(value) {
+        this.options.ogcFilters = value;
+    }
+    get ogcFilters() {
+        return this.options.ogcFilters;
+    }
+    createOlSource() {
+        const vectorSource = new olSourceVector({
+            format: getFormatFromOptions(this.options),
+            url: (extent, resolution, proj) => {
+                const paramsWFS = this.options.paramsWFS;
+                const wfsProj = paramsWFS.srsName ? new olProjection({ code: paramsWFS.srsName }) : proj;
+                const ogcFilters = this.options.ogcFilters;
+                const currentExtent = olproj.transformExtent(extent, proj, wfsProj);
+                paramsWFS.srsName = paramsWFS.srsName || proj.getCode();
+                return buildUrl(this.options, currentExtent, wfsProj, ogcFilters);
+            },
+            strategy: OlLoadingStrategy.bbox
+        });
+        return vectorSource;
+    }
+    setOgcFilters(ogcFilters, triggerEvent = false) {
+        this.ogcFilters = ogcFilters;
+        this.mostRecentIdCallOGCFilter += 1;
+        if (triggerEvent) {
+            this.ogcFilters$.next(this.ogcFilters);
+        }
+    }
+    onUnwatch() { }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wfs-datasource.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/datasource/shared/datasources/wfs-datasource.ts"],"names":[],"mappings":"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","sourcesContent":["import olSourceVector from 'ol/source/Vector';\r\nimport * as OlLoadingStrategy from 'ol/loadingstrategy';\r\nimport olProjection from 'ol/proj/Projection';\r\nimport * as olproj from 'ol/proj';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\n\r\nimport { DataSource } from './datasource';\r\nimport { WFSDataSourceOptions } from './wfs-datasource.interface';\r\nimport { WFSService } from './wfs.service';\r\n\r\nimport { OgcFilterWriter } from '../../../filter/shared/ogc-filter';\r\nimport { OgcFilterableDataSourceOptions, OgcFiltersOptions } from '../../../filter/shared/ogc-filter.interface';\r\nimport {\r\n  defaultFieldNameGeometry,\r\n  checkWfsParams,\r\n  getFormatFromOptions,\r\n  buildUrl\r\n} from './wms-wfs.utils';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { AuthInterceptor } from '@igo2/auth';\r\n\r\nexport class WFSDataSource extends DataSource {\r\n  public ol: olSourceVector<OlGeometry>;\r\n  public mostRecentIdCallOGCFilter: number = 0;\r\n\r\n  set ogcFilters(value: OgcFiltersOptions) {\r\n    (this.options as OgcFilterableDataSourceOptions).ogcFilters = value;\r\n  }\r\n  get ogcFilters(): OgcFiltersOptions {\r\n    return (this.options as OgcFilterableDataSourceOptions).ogcFilters;\r\n  }\r\n\r\n  readonly ogcFilters$: BehaviorSubject<OgcFiltersOptions> = new BehaviorSubject(undefined);\r\n\r\n  constructor(\r\n    public options: WFSDataSourceOptions,\r\n    protected wfsService: WFSService,\r\n    private authInterceptor?: AuthInterceptor\r\n  ) {\r\n    super(checkWfsParams(options, 'wfs'));\r\n\r\n    const ogcFilters = (this.options as OgcFilterableDataSourceOptions).ogcFilters;\r\n    const fieldNameGeometry = this.options.paramsWFS.fieldNameGeometry || defaultFieldNameGeometry;\r\n    const ogcFilterWriter = new OgcFilterWriter();\r\n    (this.options as OgcFilterableDataSourceOptions).ogcFilters =\r\n      ogcFilterWriter.defineOgcFiltersDefaultOptions(ogcFilters, fieldNameGeometry);\r\n    if (\r\n      (this.options as OgcFilterableDataSourceOptions).ogcFilters.enabled &&\r\n      (this.options as OgcFilterableDataSourceOptions).ogcFilters.editable &&\r\n      (options.sourceFields || []).filter(sf => !sf.values).length > 0\r\n    ) {\r\n      this.wfsService.getSourceFieldsFromWFS(this.options);\r\n    }\r\n\r\n    if (ogcFilters?.pushButtons){\r\n      ogcFilters.pushButtons.selectorType = 'pushButton';\r\n    }\r\n    if (ogcFilters?.checkboxes){\r\n      ogcFilters.checkboxes.selectorType = 'checkbox';\r\n    }\r\n    if (ogcFilters?.radioButtons){\r\n      ogcFilters.radioButtons.selectorType = 'radioButton';\r\n    }\r\n    if (ogcFilters?.select){\r\n      ogcFilters.select.selectorType = 'select';\r\n    }\r\n    if (ogcFilters?.autocomplete){\r\n      ogcFilters.autocomplete.selectorType = 'autocomplete';\r\n    }\r\n\r\n    this.setOgcFilters((this.options as OgcFilterableDataSourceOptions).ogcFilters, true);\r\n  }\r\n\r\n  protected createOlSource(): olSourceVector<OlGeometry> {\r\n    const vectorSource = new olSourceVector({\r\n      format: getFormatFromOptions(this.options),\r\n      url: (extent, resolution, proj: olProjection) => {\r\n        const paramsWFS = this.options.paramsWFS;\r\n        const wfsProj = paramsWFS.srsName ? new olProjection({ code: paramsWFS.srsName }) : proj;\r\n        const ogcFilters = (this.options as OgcFilterableDataSourceOptions).ogcFilters;\r\n        const currentExtent = olproj.transformExtent(extent, proj, wfsProj);\r\n        paramsWFS.srsName = paramsWFS.srsName || proj.getCode();\r\n        return buildUrl(this.options, currentExtent, wfsProj, ogcFilters);\r\n      },\r\n      strategy: OlLoadingStrategy.bbox\r\n    });\r\n    return vectorSource;\r\n  }\r\n\r\n  setOgcFilters(ogcFilters: OgcFiltersOptions, triggerEvent: boolean = false) {\r\n    this.ogcFilters = ogcFilters;\r\n    this.mostRecentIdCallOGCFilter += 1;\r\n    if (triggerEvent) {\r\n      this.ogcFilters$.next(this.ogcFilters);\r\n    }\r\n  }\r\n\r\n  public onUnwatch() { }\r\n}\r\n"]}

package/esm2020/lib/datasource/shared/datasources/wfs.service.mjs

@@ -0,0 +1,152 @@
+import { Injectable } from '@angular/core';
+import { combineLatest, Observable, of } from 'rxjs';
+import { DataService } from './data.service';
+import { formatWFSQueryString, gmlRegex, defaultEpsg, defaultMaxFeatures, getFormatFromOptions } from './wms-wfs.utils';
+import { concatMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class WFSService extends DataService {
+    constructor(http) {
+        super();
+        this.http = http;
+    }
+    getData() {
+        console.log('This is defining a data service.');
+        return 'This is defining a data service.';
+    }
+    getSourceFieldsFromWFS(dataSourceOptions) {
+        if (!dataSourceOptions.sourceFields || dataSourceOptions.sourceFields.length === 0) {
+            dataSourceOptions.sourceFields = [];
+            this.defineFieldAndValuefromWFS(dataSourceOptions).subscribe(getfeatureSourceField => {
+                dataSourceOptions.sourceFields = getfeatureSourceField;
+            });
+        }
+        else {
+            this.defineFieldAndValuefromWFS(dataSourceOptions).subscribe(getfeatureSourceField => {
+                dataSourceOptions.sourceFields.forEach(sourcefield => {
+                    if (sourcefield.alias === undefined) {
+                        sourcefield.alias = sourcefield.name; // to allow only a list of sourcefield with names
+                    }
+                    if (sourcefield.values === undefined || sourcefield.values.length === 0) {
+                        sourcefield.values = getfeatureSourceField.find(sf => sf.name === sourcefield.name).values;
+                    }
+                });
+            });
+        }
+    }
+    wfsGetFeature(dataSourceOptions, nb = defaultMaxFeatures, epsgCode = defaultEpsg, propertyName, startIndex = 0, forceDefaultOutputFormat = false) {
+        const queryStringValues = formatWFSQueryString(dataSourceOptions, nb, epsgCode, propertyName, startIndex, forceDefaultOutputFormat);
+        const baseUrl = queryStringValues.find(f => f.name === 'getfeature').value;
+        const outputFormat = dataSourceOptions.paramsWFS.outputFormat;
+        if (forceDefaultOutputFormat || gmlRegex.test(outputFormat) || !outputFormat) {
+            return this.http.get(baseUrl, { responseType: 'text' });
+        }
+        else {
+            return this.http.get(baseUrl);
+        }
+    }
+    defineFieldAndValuefromWFS(dataSourceOptions) {
+        return new Observable(d => {
+            const sourceFields = [];
+            let fieldList;
+            let fieldListWoGeom;
+            let fieldListWoGeomStr;
+            let olFormats;
+            let effectiveOlFormats;
+            olFormats = getFormatFromOptions(dataSourceOptions);
+            const gmlDataSourceOptions = JSON.parse(JSON.stringify(dataSourceOptions));
+            delete gmlDataSourceOptions.paramsWFS.outputFormat;
+            delete gmlDataSourceOptions.formatOptions;
+            effectiveOlFormats = getFormatFromOptions(gmlDataSourceOptions);
+            let sourceFieldsToRetrieveValues = dataSourceOptions.sourceFields?.filter(f => !f.values).map(f => f.name);
+            // Validate if the service manage no outputformat (wfs 1.0.0 and GML is the default return)
+            this.wfsGetFeature(dataSourceOptions, 1, undefined, undefined, 0, true).pipe(concatMap(res => String(res).toLowerCase().includes('exception') ? of(false) : of(true)), concatMap(allowGml => {
+                // If the service return GML (return no exception)
+                return this.wfsGetFeature(dataSourceOptions, 1).pipe(concatMap(firstFeature => {
+                    const features = olFormats.readFeatures(firstFeature);
+                    fieldList = features[0].getKeys();
+                    if (dataSourceOptions.sourceFields || dataSourceOptions.sourceFields.length === 0) {
+                        sourceFieldsToRetrieveValues = fieldList;
+                    }
+                    fieldListWoGeom = fieldList.filter(field => sourceFieldsToRetrieveValues.includes(field) &&
+                        field !== features[0].getGeometryName() &&
+                        !field.match(/boundedby/gi));
+                    fieldListWoGeomStr = fieldListWoGeom.join(',');
+                    const processingArray = [];
+                    let startIndex = 0;
+                    // If the service do not allow gml return, dice the call in multiple
+                    // calls by increment of chunkSize with the original outputFormat
+                    if (!allowGml && dataSourceOptions.paramsWFS.version === '2.0.0' &&
+                        dataSourceOptions.paramsWFS.maxFeatures > defaultMaxFeatures) {
+                        const chunkSize = 1000;
+                        while (startIndex < dataSourceOptions.paramsWFS.maxFeatures) {
+                            processingArray.push(this.wfsGetFeature(dataSourceOptions, chunkSize, dataSourceOptions.paramsWFS.srsName, fieldListWoGeomStr, startIndex));
+                            startIndex += chunkSize;
+                        }
+                        effectiveOlFormats = olFormats;
+                    }
+                    else {
+                        processingArray.push(this.wfsGetFeature(dataSourceOptions, dataSourceOptions.paramsWFS.maxFeatures || defaultMaxFeatures, dataSourceOptions.paramsWFS.srsName, fieldListWoGeomStr, 0, true));
+                    }
+                    return combineLatest(processingArray);
+                }));
+            })).subscribe((results) => {
+                let mfeatures = [];
+                results.map((result) => {
+                    const loopFeatures = effectiveOlFormats.readFeatures(result);
+                    mfeatures = mfeatures.concat(loopFeatures);
+                });
+                this.built_properties_value(mfeatures).forEach(element => {
+                    sourceFields.push(element);
+                });
+                d.next(sourceFields);
+                d.complete();
+            });
+        });
+    }
+    built_properties_value(features) {
+        if (features.length === 0) {
+            return [];
+        }
+        const kv = Object.assign({}, features[0].getProperties());
+        delete kv[features[0].getGeometryName()];
+        delete kv.boundedBy;
+        const sourceFields = [];
+        for (const property in kv) {
+            if (kv.hasOwnProperty(property)) {
+                const fieldType = typeof features[0].get(property) === 'object'
+                    ? undefined
+                    : typeof features[0].get(property);
+                sourceFields.push({
+                    name: property,
+                    alias: property,
+                    type: fieldType,
+                    values: [kv[property]]
+                });
+            }
+        }
+        features.every((element) => {
+            const featureProperties = element.getProperties();
+            for (const key in featureProperties) {
+                if (featureProperties.hasOwnProperty(key) && key in kv) {
+                    sourceFields.filter(f => f.name === key).forEach(v => {
+                        if (v.values.indexOf(featureProperties[key]) === -1) {
+                            v.values.push(featureProperties[key]);
+                        }
+                    });
+                }
+            }
+            return true;
+        });
+        return sourceFields;
+    }
+}
+WFSService.ɵfac = function WFSService_Factory(t) { return new (t || WFSService)(i0.ɵɵinject(i1.HttpClient)); };
+WFSService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WFSService, factory: WFSService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WFSService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wfs.service.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/datasource/shared/datasources/wfs.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { combineLatest, Observable, of } from 'rxjs';\r\nimport olFeature from 'ol/Feature';\r\nimport { WFSDataSourceOptions } from './wfs-datasource.interface';\r\nimport { WMSDataSourceOptions } from './wms-datasource.interface';\r\nimport { DataService } from './data.service';\r\nimport { formatWFSQueryString,\r\n          gmlRegex,\r\n          defaultEpsg,\r\n          defaultMaxFeatures,\r\n          getFormatFromOptions} from './wms-wfs.utils';\r\nimport { concatMap } from 'rxjs/operators';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class WFSService extends DataService {\r\n  constructor(private http: HttpClient) {\r\n    super();\r\n  }\r\n\r\n  getData() {\r\n    console.log('This is defining a data service.');\r\n    return 'This is defining a data service.';\r\n  }\r\n\r\n  public getSourceFieldsFromWFS(dataSourceOptions: WFSDataSourceOptions | WMSDataSourceOptions) {\r\n    if (!dataSourceOptions.sourceFields || dataSourceOptions.sourceFields.length === 0 ) {\r\n      dataSourceOptions.sourceFields = [];\r\n      this.defineFieldAndValuefromWFS(dataSourceOptions).subscribe(getfeatureSourceField => {\r\n        dataSourceOptions.sourceFields = getfeatureSourceField;\r\n      });\r\n\r\n    } else {\r\n      this.defineFieldAndValuefromWFS(dataSourceOptions).subscribe(getfeatureSourceField => {\r\n        dataSourceOptions.sourceFields.forEach(sourcefield => {\r\n          if (sourcefield.alias === undefined) {\r\n            sourcefield.alias = sourcefield.name; // to allow only a list of sourcefield with names\r\n          }\r\n          if (sourcefield.values === undefined || sourcefield.values.length === 0) {\r\n            sourcefield.values = getfeatureSourceField.find(sf => sf.name === sourcefield.name).values;\r\n          }\r\n        });\r\n      });\r\n    }\r\n  }\r\n\r\n  private wfsGetFeature(\r\n    dataSourceOptions: WFSDataSourceOptions | WMSDataSourceOptions,\r\n    nb: number = defaultMaxFeatures,\r\n    epsgCode: string = defaultEpsg,\r\n    propertyName?: string,\r\n    startIndex: number = 0,\r\n    forceDefaultOutputFormat: boolean = false\r\n  ): Observable<any> {\r\n    const queryStringValues = formatWFSQueryString(dataSourceOptions, nb, epsgCode, propertyName, startIndex, forceDefaultOutputFormat );\r\n    const baseUrl = queryStringValues.find(f => f.name === 'getfeature').value;\r\n    const outputFormat = dataSourceOptions.paramsWFS.outputFormat;\r\n    if (forceDefaultOutputFormat || gmlRegex.test(outputFormat) || !outputFormat) {\r\n      return this.http.get(baseUrl, { responseType: 'text' });\r\n    } else {\r\n      return this.http.get(baseUrl);\r\n    }\r\n  }\r\n\r\n  defineFieldAndValuefromWFS(\r\n    dataSourceOptions: WFSDataSourceOptions | WMSDataSourceOptions\r\n  ): Observable<any> {\r\n    return new Observable(d => {\r\n      const sourceFields = [];\r\n      let fieldList;\r\n      let fieldListWoGeom;\r\n      let fieldListWoGeomStr;\r\n      let olFormats;\r\n      let effectiveOlFormats;\r\n\r\n      olFormats = getFormatFromOptions(dataSourceOptions);\r\n      const gmlDataSourceOptions: WFSDataSourceOptions | WMSDataSourceOptions = JSON.parse(\r\n        JSON.stringify(dataSourceOptions)\r\n      );\r\n      delete gmlDataSourceOptions.paramsWFS.outputFormat;\r\n      delete (gmlDataSourceOptions as WFSDataSourceOptions).formatOptions;\r\n\r\n      effectiveOlFormats = getFormatFromOptions(gmlDataSourceOptions);\r\n      let sourceFieldsToRetrieveValues = dataSourceOptions.sourceFields?.filter(f => !f.values).map(f => f.name);\r\n\r\n      // Validate if the service manage no outputformat (wfs 1.0.0 and GML is the default return)\r\n      this.wfsGetFeature(dataSourceOptions, 1, undefined, undefined, 0, true).pipe(\r\n        concatMap(res => String(res).toLowerCase().includes('exception') ? of(false) : of(true)),\r\n        concatMap(allowGml => {\r\n          // If the service return GML (return no exception)\r\n          return this.wfsGetFeature(dataSourceOptions, 1).pipe(\r\n            concatMap(firstFeature => {\r\n              const features = olFormats.readFeatures(firstFeature);\r\n              fieldList = features[0].getKeys();\r\n              if (dataSourceOptions.sourceFields || dataSourceOptions.sourceFields.length === 0) {\r\n                sourceFieldsToRetrieveValues = fieldList;\r\n              }\r\n              fieldListWoGeom = fieldList.filter(\r\n                field =>\r\n                  sourceFieldsToRetrieveValues.includes(field) &&\r\n                  field !== features[0].getGeometryName() &&\r\n                  !field.match(/boundedby/gi)\r\n              );\r\n              fieldListWoGeomStr = fieldListWoGeom.join(',');\r\n              const processingArray = [];\r\n              let startIndex = 0;\r\n              // If the service do not allow gml return, dice the call in multiple\r\n              // calls by increment of chunkSize with the original outputFormat\r\n              if (\r\n                !allowGml && dataSourceOptions.paramsWFS.version === '2.0.0' &&\r\n                dataSourceOptions.paramsWFS.maxFeatures > defaultMaxFeatures) {\r\n                const chunkSize = 1000;\r\n                while (startIndex < dataSourceOptions.paramsWFS.maxFeatures) {\r\n                  processingArray.push(this.wfsGetFeature(\r\n                    dataSourceOptions,\r\n                    chunkSize,\r\n                    dataSourceOptions.paramsWFS.srsName,\r\n                    fieldListWoGeomStr,\r\n                    startIndex\r\n                  ));\r\n                  startIndex += chunkSize;\r\n                }\r\n                effectiveOlFormats = olFormats;\r\n              } else {\r\n                processingArray.push(this.wfsGetFeature(\r\n                  dataSourceOptions,\r\n                  dataSourceOptions.paramsWFS.maxFeatures || defaultMaxFeatures,\r\n                  dataSourceOptions.paramsWFS.srsName,\r\n                  fieldListWoGeomStr,\r\n                  0, true\r\n                ));\r\n              }\r\n              return combineLatest(processingArray);\r\n            })\r\n          );\r\n        })).subscribe((results) => {\r\n          let mfeatures: olFeature<OlGeometry>[] = [];\r\n          results.map((result) => {\r\n            const loopFeatures = effectiveOlFormats.readFeatures(result);\r\n            mfeatures = mfeatures.concat(loopFeatures);\r\n          });\r\n          this.built_properties_value(mfeatures).forEach(element => {\r\n            sourceFields.push(element);\r\n          });\r\n          d.next(sourceFields);\r\n          d.complete();\r\n        });\r\n    });\r\n  }\r\n\r\n  private built_properties_value(features: olFeature<OlGeometry>[]): string[] {\r\n    if (features.length === 0) {\r\n      return [];\r\n    }\r\n    const kv = Object.assign({}, features[0].getProperties());\r\n    delete kv[features[0].getGeometryName()];\r\n    delete kv.boundedBy;\r\n    const sourceFields = [];\r\n    for (const property in kv) {\r\n      if (kv.hasOwnProperty(property)) {\r\n        const fieldType =\r\n          typeof features[0].get(property) === 'object'\r\n            ? undefined\r\n            : typeof features[0].get(property);\r\n        sourceFields.push({\r\n          name: property,\r\n          alias: property,\r\n          type: fieldType,\r\n          values: [kv[property]]\r\n        });\r\n      }\r\n    }\r\n    features.every((element) => {\r\n      const featureProperties = element.getProperties();\r\n      for (const key in featureProperties) {\r\n        if (featureProperties.hasOwnProperty(key) && key in kv) {\r\n          sourceFields.filter(f => f.name === key).forEach(v => {\r\n            if (v.values.indexOf(featureProperties[key]) === -1) {\r\n              v.values.push(featureProperties[key]);\r\n            }\r\n          });\r\n        }\r\n      }\r\n      return true;\r\n    });\r\n    return sourceFields;\r\n  }\r\n}\r\n"]}

package/esm2020/lib/datasource/shared/datasources/wms-datasource.mjs

@@ -0,0 +1,205 @@
+import olSourceImageWMS from 'ol/source/ImageWMS';
+import { DataSource } from './datasource';
+import { OgcFilterWriter } from '../../../filter/shared/ogc-filter';
+import { QueryHtmlTarget } from '../../../query/shared/query.enums';
+import { formatWFSQueryString, checkWfsParams, defaultFieldNameGeometry } from './wms-wfs.utils';
+import { ObjectUtils } from '@igo2/utils';
+import { BehaviorSubject } from 'rxjs';
+export class WMSDataSource extends DataSource {
+    constructor(options, wfsService) {
+        super(options);
+        this.options = options;
+        this.wfsService = wfsService;
+        this.ogcFilters$ = new BehaviorSubject(undefined);
+        this.timeFilter$ = new BehaviorSubject(undefined);
+        const sourceParams = options.params;
+        const dpi = sourceParams.DPI || 96;
+        sourceParams.DPI = dpi;
+        sourceParams.MAP_RESOLUTION = dpi;
+        sourceParams.FORMAT_OPTIONS = 'dpi:' + dpi;
+        if (options.refreshIntervalSec && options.refreshIntervalSec > 0) {
+            setInterval(() => {
+                this.refresh();
+            }, options.refreshIntervalSec * 1000); // Convert seconds to MS
+        }
+        let fieldNameGeometry = defaultFieldNameGeometry;
+        // ####   START if paramsWFS
+        if (options.paramsWFS) {
+            const wfsCheckup = checkWfsParams(options, 'wms');
+            ObjectUtils.mergeDeep(options.paramsWFS, wfsCheckup.paramsWFS);
+            fieldNameGeometry =
+                options.paramsWFS.fieldNameGeometry || fieldNameGeometry;
+            options.download = Object.assign({}, options.download, {
+                dynamicUrl: this.buildDynamicDownloadUrlFromParamsWFS(options)
+            });
+        } //  ####   END  if paramsWFS
+        if (!options.sourceFields || options.sourceFields.length === 0) {
+            options.sourceFields = [];
+        }
+        else {
+            options.sourceFields.forEach(sourceField => {
+                sourceField.alias = sourceField.alias
+                    ? sourceField.alias
+                    : sourceField.name;
+                // to allow only a list of sourcefield with names
+            });
+        }
+        const initOgcFilters = options
+            .ogcFilters;
+        const ogcFilterWriter = new OgcFilterWriter();
+        if (!initOgcFilters) {
+            options.ogcFilters = ogcFilterWriter.defineOgcFiltersDefaultOptions(initOgcFilters, fieldNameGeometry, 'wms');
+        }
+        else {
+            initOgcFilters.advancedOgcFilters = (initOgcFilters.pushButtons || initOgcFilters.checkboxes
+                || initOgcFilters.radioButtons || initOgcFilters.select || initOgcFilters.autocomplete)
+                ? false
+                : true;
+            if (initOgcFilters.advancedOgcFilters && initOgcFilters.filters) {
+                const filterDuring = initOgcFilters.filters;
+                if (filterDuring.calendarModeYear) {
+                    initOgcFilters.advancedOgcFilters = false;
+                }
+            }
+            if (initOgcFilters.pushButtons) {
+                initOgcFilters.pushButtons.selectorType = 'pushButton';
+            }
+            if (initOgcFilters.checkboxes) {
+                initOgcFilters.checkboxes.selectorType = 'checkbox';
+            }
+            if (initOgcFilters.radioButtons) {
+                initOgcFilters.radioButtons.selectorType = 'radioButton';
+            }
+            if (initOgcFilters.select) {
+                initOgcFilters.select.selectorType = 'select';
+            }
+            if (initOgcFilters.autocomplete) {
+                initOgcFilters.autocomplete.selectorType = 'autocomplete';
+            }
+        }
+        if (sourceParams.LAYERS.split(',').length > 1 &&
+            initOgcFilters &&
+            initOgcFilters.enabled) {
+            console.log('*******************************');
+            console.log('BE CAREFULL, YOUR WMS LAYERS (' +
+                sourceParams.LAYERS +
+                ') MUST SHARE THE SAME FIELDS TO ALLOW ogcFilters TO WORK !! ');
+            console.log('*******************************');
+        }
+        if (options.paramsWFS &&
+            initOgcFilters &&
+            initOgcFilters.enabled &&
+            initOgcFilters.editable &&
+            (options.sourceFields || []).filter(sf => !sf.values).length > 0) {
+            this.wfsService.getSourceFieldsFromWFS(options);
+        }
+        const filterQueryString = ogcFilterWriter.handleOgcFiltersAppliedValue(options, fieldNameGeometry);
+        sourceParams.FILTER = filterQueryString;
+        this.setOgcFilters(initOgcFilters, true);
+        const timeFilterableDataSourceOptions = options;
+        if (timeFilterableDataSourceOptions?.timeFilterable &&
+            timeFilterableDataSourceOptions?.timeFilter) {
+            this.setTimeFilter(timeFilterableDataSourceOptions.timeFilter, true);
+        }
+    }
+    get params() {
+        return this.options.params;
+    }
+    get queryTitle() {
+        return this.options.queryTitle
+            ? this.options.queryTitle
+            : 'title';
+    }
+    get mapLabel() {
+        return this.options.mapLabel;
+    }
+    get queryHtmlTarget() {
+        return this.options.queryHtmlTarget
+            ? this.options.queryHtmlTarget
+            : QueryHtmlTarget.BLANK;
+    }
+    set ogcFilters(value) {
+        this.options.ogcFilters = value;
+    }
+    get ogcFilters() {
+        return this.options.ogcFilters;
+    }
+    set timeFilter(value) {
+        this.options.timeFilter = value;
+    }
+    get timeFilter() {
+        return this.options.timeFilter;
+    }
+    refresh() {
+        this.ol.updateParams({ igoRefresh: Math.random() });
+    }
+    buildDynamicDownloadUrlFromParamsWFS(asWFSDataSourceOptions) {
+        const queryStringValues = formatWFSQueryString(asWFSDataSourceOptions);
+        const downloadUrl = queryStringValues.find(f => f.name === 'getfeature')
+            .value;
+        return downloadUrl;
+    }
+    createOlSource() {
+        return new olSourceImageWMS(Object.assign({ ratio: 1 }, this.options));
+    }
+    setOgcFilters(ogcFilters, triggerEvent = false) {
+        this.ogcFilters = ogcFilters;
+        if (triggerEvent) {
+            this.ogcFilters$.next(this.ogcFilters);
+        }
+    }
+    setTimeFilter(timeFilter, triggerEvent = false) {
+        this.timeFilter = timeFilter;
+        if (triggerEvent) {
+            this.timeFilter$.next(this.timeFilter);
+        }
+    }
+    getLegend(style, view) {
+        let legend = super.getLegend();
+        if (legend.length > 0 && (style === undefined && !view?.scale)) {
+            return legend;
+        }
+        let contentDependent = false;
+        let projParam;
+        if (view?.size && view?.extent && view?.projection && this.options.contentDependentLegend) {
+            projParam = this.params.VERSION === '1.3.0' || this.params.VERSION === undefined ? 'CRS' : 'SRS';
+            contentDependent = true;
+        }
+        const sourceParams = this.params;
+        let layers = [];
+        if (sourceParams.LAYERS !== undefined) {
+            layers = sourceParams.LAYERS.split(',');
+        }
+        const baseUrl = this.options.url.replace(/\?$/, '');
+        const params = [
+            'REQUEST=GetLegendGraphic',
+            'SERVICE=WMS',
+            'FORMAT=image/png',
+            'SLD_VERSION=1.1.0',
+            `VERSION=${sourceParams.VERSION || '1.3.0'}`
+        ];
+        if (style !== undefined) {
+            params.push(`STYLE=${style}`);
+        }
+        if (view?.scale !== undefined) {
+            params.push(`SCALE=${view.scale}`);
+        }
+        if (contentDependent) {
+            params.push(`WIDTH=${view.size[0]}`);
+            params.push(`HEIGHT=${view.size[1]}`);
+            params.push(`BBOX=${view.extent.join(',')}`);
+            params.push(`${projParam}=${view.projection}`);
+        }
+        legend = layers.map((layer) => {
+            const separator = baseUrl.match(/\?/) ? '&' : '?';
+            return {
+                url: `${baseUrl}${separator}${params.join('&')}&LAYER=${layer}`,
+                title: layers.length > 1 ? layer : undefined,
+                currentStyle: style === undefined ? undefined : style
+            };
+        });
+        return legend;
+    }
+    onUnwatch() { }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wms-datasource.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/datasource/shared/datasources/wms-datasource.ts"],"names":[],"mappings":"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","sourcesContent":["import olSourceImageWMS from 'ol/source/ImageWMS';\r\n\r\nimport { DataSource } from './datasource';\r\nimport { Legend } from './datasource.interface';\r\nimport { WMSDataSourceOptions } from './wms-datasource.interface';\r\nimport { WFSService } from './wfs.service';\r\n\r\nimport { OgcFilterWriter } from '../../../filter/shared/ogc-filter';\r\nimport { OgcFilterableDataSourceOptions, OgcFiltersOptions, OgcFilterDuringOptions } from '../../../filter/shared/ogc-filter.interface';\r\nimport { QueryHtmlTarget } from '../../../query/shared/query.enums';\r\nimport {\r\n  formatWFSQueryString,\r\n  checkWfsParams,\r\n  defaultFieldNameGeometry\r\n} from './wms-wfs.utils';\r\n\r\nimport { ObjectUtils } from '@igo2/utils';\r\nimport { LegendMapViewOptions } from '../../../layer/shared/layers/layer.interface';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { TimeFilterableDataSourceOptions, TimeFilterOptions } from '../../../filter/shared/time-filter.interface';\r\n\r\nexport class WMSDataSource extends DataSource {\r\n  public ol: olSourceImageWMS;\r\n\r\n  get params(): any {\r\n    return this.options.params as any;\r\n  }\r\n\r\n  get queryTitle(): string {\r\n    return (this.options as any).queryTitle\r\n      ? (this.options as any).queryTitle\r\n      : 'title';\r\n  }\r\n\r\n  get mapLabel(): string {\r\n    return (this.options as any).mapLabel;\r\n  }\r\n\r\n  get queryHtmlTarget(): string {\r\n    return (this.options as any).queryHtmlTarget\r\n      ? (this.options as any).queryHtmlTarget\r\n      : QueryHtmlTarget.BLANK;\r\n  }\r\n\r\n  set ogcFilters(value: OgcFiltersOptions) {\r\n    (this.options as OgcFilterableDataSourceOptions).ogcFilters = value;\r\n  }\r\n  get ogcFilters(): OgcFiltersOptions {\r\n    return (this.options as OgcFilterableDataSourceOptions).ogcFilters;\r\n  }\r\n\r\n  readonly ogcFilters$: BehaviorSubject<OgcFiltersOptions> = new BehaviorSubject(undefined);\r\n\r\n  set timeFilter(value: TimeFilterOptions ) {\r\n    (this.options as TimeFilterableDataSourceOptions).timeFilter = value;\r\n  }\r\n  get timeFilter(): TimeFilterOptions {\r\n    return (this.options as TimeFilterableDataSourceOptions).timeFilter;\r\n  }\r\n  readonly timeFilter$: BehaviorSubject<TimeFilterOptions> = new BehaviorSubject(undefined);\r\n\r\n  constructor(\r\n    public options: WMSDataSourceOptions,\r\n    protected wfsService: WFSService\r\n  ) {\r\n    super(options);\r\n    const sourceParams: any = options.params;\r\n\r\n    const dpi = sourceParams.DPI || 96;\r\n    sourceParams.DPI = dpi;\r\n    sourceParams.MAP_RESOLUTION = dpi;\r\n    sourceParams.FORMAT_OPTIONS = 'dpi:' + dpi;\r\n\r\n    if (options.refreshIntervalSec && options.refreshIntervalSec > 0) {\r\n      setInterval(() => {\r\n        this.refresh();\r\n      }, options.refreshIntervalSec * 1000); // Convert seconds to MS\r\n    }\r\n\r\n    let fieldNameGeometry = defaultFieldNameGeometry;\r\n\r\n    // ####   START if paramsWFS\r\n    if (options.paramsWFS) {\r\n      const wfsCheckup = checkWfsParams(options, 'wms');\r\n      ObjectUtils.mergeDeep(options.paramsWFS, wfsCheckup.paramsWFS);\r\n\r\n      fieldNameGeometry =\r\n        options.paramsWFS.fieldNameGeometry || fieldNameGeometry;\r\n\r\n      options.download = Object.assign({}, options.download, {\r\n        dynamicUrl: this.buildDynamicDownloadUrlFromParamsWFS(options)\r\n      });\r\n    } //  ####   END  if paramsWFS\r\n\r\n    if (!options.sourceFields || options.sourceFields.length === 0) {\r\n      options.sourceFields = [];\r\n    } else {\r\n      options.sourceFields.forEach(sourceField => {\r\n        sourceField.alias = sourceField.alias\r\n          ? sourceField.alias\r\n          : sourceField.name;\r\n        // to allow only a list of sourcefield with names\r\n      });\r\n    }\r\n    const initOgcFilters = (options as OgcFilterableDataSourceOptions)\r\n      .ogcFilters;\r\n    const ogcFilterWriter = new OgcFilterWriter();\r\n\r\n    if (!initOgcFilters) {\r\n      (options as OgcFilterableDataSourceOptions).ogcFilters = ogcFilterWriter.defineOgcFiltersDefaultOptions(\r\n        initOgcFilters,\r\n        fieldNameGeometry,\r\n        'wms'\r\n      );\r\n    } else {\r\n      initOgcFilters.advancedOgcFilters = (initOgcFilters.pushButtons || initOgcFilters.checkboxes\r\n        || initOgcFilters.radioButtons || initOgcFilters.select || initOgcFilters.autocomplete)\r\n        ? false\r\n        : true;\r\n      if (initOgcFilters.advancedOgcFilters && initOgcFilters.filters) {\r\n          const filterDuring = initOgcFilters.filters as OgcFilterDuringOptions;\r\n          if(filterDuring.calendarModeYear) {\r\n            initOgcFilters.advancedOgcFilters = false;\r\n          }\r\n      }\r\n      if (initOgcFilters.pushButtons){\r\n        initOgcFilters.pushButtons.selectorType = 'pushButton';\r\n      }\r\n      if (initOgcFilters.checkboxes){\r\n        initOgcFilters.checkboxes.selectorType = 'checkbox';\r\n      }\r\n      if (initOgcFilters.radioButtons){\r\n        initOgcFilters.radioButtons.selectorType = 'radioButton';\r\n      }\r\n      if (initOgcFilters.select){\r\n        initOgcFilters.select.selectorType = 'select';\r\n      }\r\n      if (initOgcFilters.autocomplete){\r\n        initOgcFilters.autocomplete.selectorType = 'autocomplete';\r\n      }\r\n    }\r\n\r\n    if (\r\n      sourceParams.LAYERS.split(',').length > 1 &&\r\n      initOgcFilters &&\r\n      initOgcFilters.enabled\r\n    ) {\r\n      console.log('*******************************');\r\n      console.log(\r\n        'BE CAREFULL, YOUR WMS LAYERS (' +\r\n          sourceParams.LAYERS +\r\n          ') MUST SHARE THE SAME FIELDS TO ALLOW ogcFilters TO WORK !! '\r\n      );\r\n      console.log('*******************************');\r\n    }\r\n\r\n    if (\r\n      options.paramsWFS &&\r\n      initOgcFilters &&\r\n      initOgcFilters.enabled &&\r\n      initOgcFilters.editable &&\r\n      (options.sourceFields || []).filter(sf => !sf.values).length > 0) {\r\n      this.wfsService.getSourceFieldsFromWFS(options);\r\n    }\r\n\r\n    const filterQueryString = ogcFilterWriter.handleOgcFiltersAppliedValue(\r\n      options,\r\n      fieldNameGeometry\r\n    );\r\n    sourceParams.FILTER = filterQueryString;\r\n    this.setOgcFilters(initOgcFilters, true);\r\n\r\n    const timeFilterableDataSourceOptions = (options as TimeFilterableDataSourceOptions);\r\n    if (\r\n      timeFilterableDataSourceOptions?.timeFilterable &&\r\n      timeFilterableDataSourceOptions?.timeFilter) {\r\n      this.setTimeFilter(timeFilterableDataSourceOptions.timeFilter, true);\r\n    }\r\n  }\r\n\r\n  refresh() {\r\n    this.ol.updateParams({ igoRefresh: Math.random() });\r\n  }\r\n\r\n  private buildDynamicDownloadUrlFromParamsWFS(asWFSDataSourceOptions) {\r\n    const queryStringValues = formatWFSQueryString(asWFSDataSourceOptions);\r\n    const downloadUrl = queryStringValues.find(f => f.name === 'getfeature')\r\n      .value;\r\n    return downloadUrl;\r\n  }\r\n\r\n  protected createOlSource(): olSourceImageWMS {\r\n    return new olSourceImageWMS(Object.assign({ratio: 1}, this.options));\r\n  }\r\n\r\n  setOgcFilters(ogcFilters: OgcFiltersOptions, triggerEvent: boolean = false) {\r\n    this.ogcFilters = ogcFilters;\r\n    if (triggerEvent) {\r\n      this.ogcFilters$.next(this.ogcFilters);\r\n    }\r\n  }\r\n\r\n  setTimeFilter(timeFilter: TimeFilterOptions, triggerEvent: boolean = false) {\r\n    this.timeFilter = timeFilter;\r\n    if (triggerEvent) {\r\n      this.timeFilter$.next(this.timeFilter);\r\n    }\r\n  }\r\n\r\n  getLegend(style?: string, view?: LegendMapViewOptions): Legend[] {\r\n    let legend = super.getLegend();\r\n    if (legend.length > 0 && (style === undefined && !view?.scale)) {\r\n      return legend;\r\n    }\r\n\r\n    let contentDependent = false;\r\n    let projParam;\r\n\r\n    if (view?.size && view?.extent && view?.projection && this.options.contentDependentLegend) {\r\n      projParam = this.params.VERSION === '1.3.0' || this.params.VERSION === undefined ? 'CRS' : 'SRS';\r\n      contentDependent = true;\r\n    }\r\n\r\n    const sourceParams = this.params;\r\n\r\n    let layers = [];\r\n    if (sourceParams.LAYERS !== undefined) {\r\n      layers = sourceParams.LAYERS.split(',');\r\n    }\r\n\r\n    const baseUrl = this.options.url.replace(/\\?$/, '');\r\n    const params = [\r\n      'REQUEST=GetLegendGraphic',\r\n      'SERVICE=WMS',\r\n      'FORMAT=image/png',\r\n      'SLD_VERSION=1.1.0',\r\n      `VERSION=${sourceParams.VERSION || '1.3.0'}`\r\n    ];\r\n    if (style !== undefined) {\r\n      params.push(`STYLE=${style}`);\r\n    }\r\n    if (view?.scale !== undefined) {\r\n      params.push(`SCALE=${view.scale}`);\r\n    }\r\n    if (contentDependent) {\r\n      params.push(`WIDTH=${view.size[0]}`);\r\n      params.push(`HEIGHT=${view.size[1]}`);\r\n      params.push(`BBOX=${view.extent.join(',')}`);\r\n      params.push(`${projParam}=${view.projection}`);\r\n    }\r\n\r\n    legend = layers.map((layer: string) => {\r\n      const separator = baseUrl.match(/\\?/) ? '&' : '?';\r\n      return {\r\n        url: `${baseUrl}${separator}${params.join('&')}&LAYER=${layer}`,\r\n        title: layers.length > 1 ? layer : undefined,\r\n        currentStyle: style === undefined ? undefined : style as string\r\n      };\r\n    });\r\n\r\n    return legend;\r\n  }\r\n\r\n  public onUnwatch() {}\r\n}\r\n"]}