@igo2/geo 1.15.3 → 16.0.0-rc.0

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

@@ -0,0 +1,79 @@
+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';
+export class WFSDataSource extends DataSource {
+    options;
+    wfsService;
+    authInterceptor;
+    mostRecentIdCallOGCFilter = 0;
+    set ogcFilters(value) {
+        this.options.ogcFilters = value;
+    }
+    get ogcFilters() {
+        return this.options.ogcFilters;
+    }
+    constructor(options, wfsService, authInterceptor) {
+        super(checkWfsParams(options, 'wfs'));
+        this.options = options;
+        this.wfsService = wfsService;
+        this.authInterceptor = authInterceptor;
+        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);
+    }
+    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.ol.notify('ogcFilters', 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 {\r\n  OgcFilterableDataSourceOptions,\r\n  OgcFiltersOptions\r\n} 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 { AuthInterceptor } from '@igo2/auth';\r\n\r\nexport class WFSDataSource extends DataSource {\r\n  public declare 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  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)\r\n      .ogcFilters;\r\n    const fieldNameGeometry =\r\n      this.options.paramsWFS.fieldNameGeometry || defaultFieldNameGeometry;\r\n    const ogcFilterWriter = new OgcFilterWriter();\r\n    (this.options as OgcFilterableDataSourceOptions).ogcFilters =\r\n      ogcFilterWriter.defineOgcFiltersDefaultOptions(\r\n        ogcFilters,\r\n        fieldNameGeometry\r\n      );\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(\r\n      (this.options as OgcFilterableDataSourceOptions).ogcFilters,\r\n      true\r\n    );\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\r\n          ? new olProjection({ code: paramsWFS.srsName })\r\n          : proj;\r\n        const ogcFilters = (this.options as OgcFilterableDataSourceOptions)\r\n          .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.ol.notify('ogcFilters', this.ogcFilters);\r\n    }\r\n  }\r\n\r\n  public onUnwatch() {}\r\n}\r\n"]}

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

@@ -0,0 +1,169 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+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 {
+    http;
+    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;
+    }
+    static ɵfac = function WFSService_Factory(t) { return new (t || WFSService)(i0.ɵɵinject(i1.HttpClient)); };
+    static ɵ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 {\r\n  formatWFSQueryString,\r\n  gmlRegex,\r\n  defaultEpsg,\r\n  defaultMaxFeatures,\r\n  getFormatFromOptions\r\n} 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(\r\n    dataSourceOptions: WFSDataSourceOptions | WMSDataSourceOptions\r\n  ) {\r\n    if (\r\n      !dataSourceOptions.sourceFields ||\r\n      dataSourceOptions.sourceFields.length === 0\r\n    ) {\r\n      dataSourceOptions.sourceFields = [];\r\n      this.defineFieldAndValuefromWFS(dataSourceOptions).subscribe(\r\n        (getfeatureSourceField) => {\r\n          dataSourceOptions.sourceFields = getfeatureSourceField;\r\n        }\r\n      );\r\n    } else {\r\n      this.defineFieldAndValuefromWFS(dataSourceOptions).subscribe(\r\n        (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 (\r\n              sourcefield.values === undefined ||\r\n              sourcefield.values.length === 0\r\n            ) {\r\n              sourcefield.values = getfeatureSourceField.find(\r\n                (sf) => sf.name === sourcefield.name\r\n              ).values;\r\n            }\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(\r\n      dataSourceOptions,\r\n      nb,\r\n      epsgCode,\r\n      propertyName,\r\n      startIndex,\r\n      forceDefaultOutputFormat\r\n    );\r\n    const baseUrl = queryStringValues.find(\r\n      (f) => f.name === 'getfeature'\r\n    ).value;\r\n    const outputFormat = dataSourceOptions.paramsWFS.outputFormat;\r\n    if (\r\n      forceDefaultOutputFormat ||\r\n      gmlRegex.test(outputFormat) ||\r\n      !outputFormat\r\n    ) {\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 =\r\n        JSON.parse(JSON.stringify(dataSourceOptions));\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\r\n        ?.filter((f) => !f.values)\r\n        .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)\r\n        .pipe(\r\n          concatMap((res) =>\r\n            String(res).toLowerCase().includes('exception')\r\n              ? of(false)\r\n              : of(true)\r\n          ),\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 (\r\n                  dataSourceOptions.sourceFields ||\r\n                  dataSourceOptions.sourceFields.length === 0\r\n                ) {\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 &&\r\n                  dataSourceOptions.paramsWFS.version === '2.0.0' &&\r\n                  dataSourceOptions.paramsWFS.maxFeatures > defaultMaxFeatures\r\n                ) {\r\n                  const chunkSize = 1000;\r\n                  while (startIndex < dataSourceOptions.paramsWFS.maxFeatures) {\r\n                    processingArray.push(\r\n                      this.wfsGetFeature(\r\n                        dataSourceOptions,\r\n                        chunkSize,\r\n                        dataSourceOptions.paramsWFS.srsName,\r\n                        fieldListWoGeomStr,\r\n                        startIndex\r\n                      )\r\n                    );\r\n                    startIndex += chunkSize;\r\n                  }\r\n                  effectiveOlFormats = olFormats;\r\n                } else {\r\n                  processingArray.push(\r\n                    this.wfsGetFeature(\r\n                      dataSourceOptions,\r\n                      dataSourceOptions.paramsWFS.maxFeatures ||\r\n                        defaultMaxFeatures,\r\n                      dataSourceOptions.paramsWFS.srsName,\r\n                      fieldListWoGeomStr,\r\n                      0,\r\n                      true\r\n                    )\r\n                  );\r\n                }\r\n                return combineLatest(processingArray);\r\n              })\r\n            );\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\r\n            .filter((f) => f.name === key)\r\n            .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/esm2022/lib/datasource/shared/datasources/wms-datasource.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,218 @@
+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 {
+    options;
+    wfsService;
+    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;
+    }
+    timeFilter$ = new BehaviorSubject(undefined);
+    constructor(options, wfsService) {
+        super(options);
+        this.options = options;
+        this.wfsService = wfsService;
+        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.ol.updateParams({ FILTER: sourceParams.FILTER });
+        this.setOgcFilters(initOgcFilters, true);
+        const timeFilterableDataSourceOptions = options;
+        if (timeFilterableDataSourceOptions?.timeFilterable &&
+            timeFilterableDataSourceOptions?.timeFilter) {
+            this.setTimeFilter(timeFilterableDataSourceOptions.timeFilter, true);
+        }
+    }
+    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.ol.notify('ogcFilters', this.ogcFilters);
+        }
+    }
+    setTimeFilter(timeFilter, triggerEvent = false) {
+        this.timeFilter = timeFilter;
+        if (triggerEvent) {
+            this.timeFilter$.next(this.timeFilter);
+            this.ol.notify('timeFilter', this.ogcFilters);
+        }
+    }
+    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 {\r\n  TimeFilterableDataSourceOptions,\r\n  WMSDataSourceOptions\r\n} from './wms-datasource.interface';\r\nimport { WFSService } from './wfs.service';\r\n\r\nimport { OgcFilterWriter } from '../../../filter/shared/ogc-filter';\r\nimport {\r\n  OgcFilterableDataSourceOptions,\r\n  OgcFiltersOptions,\r\n  OgcFilterDuringOptions\r\n} 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/legend.interface';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { TimeFilterOptions } from '../../../filter';\r\n\r\nexport interface TimeFilterableDataSource extends WMSDataSource {\r\n  options: TimeFilterableDataSourceOptions;\r\n  timeFilter$: BehaviorSubject<TimeFilterOptions>;\r\n  setTimeFilter(ogcFilters: TimeFilterOptions, triggerEvent?: boolean);\r\n  filterByDate(date: Date | [Date, Date]);\r\n  filterByYear(year: string | [string, string]);\r\n}\r\n\r\nexport class WMSDataSource extends DataSource {\r\n  public declare 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  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> =\r\n    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 =\r\n        ogcFilterWriter.defineOgcFiltersDefaultOptions(\r\n          initOgcFilters,\r\n          fieldNameGeometry,\r\n          'wms'\r\n        );\r\n    } else {\r\n      initOgcFilters.advancedOgcFilters =\r\n        initOgcFilters.pushButtons ||\r\n        initOgcFilters.checkboxes ||\r\n        initOgcFilters.radioButtons ||\r\n        initOgcFilters.select ||\r\n        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    ) {\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.ol.updateParams({ FILTER: sourceParams.FILTER });\r\n    this.setOgcFilters(initOgcFilters, true);\r\n\r\n    const timeFilterableDataSourceOptions =\r\n      options as TimeFilterableDataSourceOptions;\r\n    if (\r\n      timeFilterableDataSourceOptions?.timeFilterable &&\r\n      timeFilterableDataSourceOptions?.timeFilter\r\n    ) {\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(\r\n      (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.ol.notify('ogcFilters', 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      this.ol.notify('timeFilter', this.ogcFilters);\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 (\r\n      view?.size &&\r\n      view?.extent &&\r\n      view?.projection &&\r\n      this.options.contentDependentLegend\r\n    ) {\r\n      projParam =\r\n        this.params.VERSION === '1.3.0' || this.params.VERSION === undefined\r\n          ? 'CRS'\r\n          : '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\r\nexport interface TimeFilterableDataSource extends WMSDataSource {\r\n  options: TimeFilterableDataSourceOptions;\r\n  timeFilter$: BehaviorSubject<TimeFilterOptions>;\r\n  setTimeFilter(ogcFilters: TimeFilterOptions, triggerEvent?: boolean);\r\n  filterByDate(date: Date | [Date, Date]);\r\n  filterByYear(year: string | [string, string]);\r\n}\r\n"]}