@igo2/geo 1.15.3 → 16.0.0-rc.0

package/esm2022/lib/datasource/shared/capabilities.service.mjs

@@ -0,0 +1,448 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Observable, forkJoin, of } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import { Cacheable } from 'ts-cacheable';
+import { WMSCapabilities, WMTSCapabilities, EsriJSON } from 'ol/format';
+import { optionsFromCapabilities } from 'ol/source/WMTS.js';
+import olAttribution from 'ol/control/Attribution';
+import { ObjectUtils } from '@igo2/utils';
+import { MapService } from '../../map/shared/map.service';
+import { getResolutionFromScale } from '../../map/shared/map.utils';
+import { EsriStyleGenerator } from '../../style/shared/datasource/esri-style-generator';
+import { QueryFormat, QueryFormatMimeType } from '../../query/shared/query.enums';
+import { TimeFilterType, TimeFilterStyle } from '../../filter/shared/time-filter.enum';
+import * as olproj from 'ol/proj';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../map/shared/map.service";
+export var TypeCapabilities;
+(function (TypeCapabilities) {
+    TypeCapabilities["wms"] = "wms";
+    TypeCapabilities["wmts"] = "wmts";
+    TypeCapabilities["arcgisrest"] = "esriJSON";
+    TypeCapabilities["imagearcgisrest"] = "esriJSON";
+    TypeCapabilities["tilearcgisrest"] = "esriJSON";
+})(TypeCapabilities || (TypeCapabilities = {}));
+export class CapabilitiesService {
+    http;
+    mapService;
+    parsers = {
+        wms: new WMSCapabilities(),
+        wmts: new WMTSCapabilities(),
+        esriJSON: new EsriJSON()
+    };
+    constructor(http, mapService) {
+        this.http = http;
+        this.mapService = mapService;
+    }
+    getWMSOptions(baseOptions) {
+        const url = baseOptions.url;
+        const version = baseOptions.params.VERSION;
+        return this.getCapabilities('wms', url, version).pipe(map((capabilities) => {
+            return capabilities
+                ? this.parseWMSOptions(baseOptions, capabilities)
+                : undefined;
+        }));
+    }
+    getWMTSOptions(baseOptions) {
+        const url = baseOptions.url;
+        const version = baseOptions.version;
+        const options = this.getCapabilities('wmts', url, version).pipe(map((capabilities) => {
+            return capabilities
+                ? this.parseWMTSOptions(baseOptions, capabilities)
+                : undefined;
+        }));
+        return options;
+    }
+    getCartoOptions(baseOptions) {
+        const baseUrl = 'https://' +
+            baseOptions.account +
+            '.carto.com/api/v2/viz/' +
+            baseOptions.mapId +
+            '/viz.json';
+        return this.http
+            .jsonp(baseUrl, 'callback')
+            .pipe(map((cartoOptions) => this.parseCartoOptions(baseOptions, cartoOptions)));
+    }
+    getArcgisOptions(baseOptions) {
+        const baseUrl = baseOptions.url + '/' + baseOptions.layer + '?f=json';
+        const serviceCapabilities = this.getCapabilities('arcgisrest', baseOptions.url);
+        const arcgisOptions = this.http.get(baseUrl);
+        return forkJoin([arcgisOptions, serviceCapabilities]).pipe(map((res) => {
+            return this.parseArcgisOptions(baseOptions, res[0], res[1]);
+        }));
+    }
+    getImageArcgisOptions(baseOptions) {
+        const baseUrl = baseOptions.url + '/' + baseOptions.layer + '?f=json';
+        const legendUrl = baseOptions.url + '/legend?f=json';
+        const serviceCapabilities = this.getCapabilities('imagearcgisrest', baseOptions.url);
+        const arcgisOptions = this.http.get(baseUrl);
+        const legend = this.http.get(legendUrl).pipe(map((res) => res), catchError((err) => {
+            console.log('No legend associated with this Image Service');
+            return of(err);
+        }));
+        return forkJoin([arcgisOptions, legend, serviceCapabilities]).pipe(map((res) => {
+            return this.parseTileOrImageArcgisOptions(baseOptions, res[0], res[1], res[2]);
+        }));
+    }
+    getTileArcgisOptions(baseOptions) {
+        const baseUrl = baseOptions.url + '/' + baseOptions.layer + '?f=json';
+        const legendUrl = baseOptions.url + '/legend?f=json';
+        const serviceCapabilities = this.getCapabilities('tilearcgisrest', baseOptions.url);
+        const arcgisOptions = this.http.get(baseUrl);
+        const legendInfo = this.http.get(legendUrl).pipe(map((res) => res), catchError((err) => {
+            console.log('No legend associated with this Tile Service');
+            return of(err);
+        }));
+        return forkJoin([arcgisOptions, legendInfo, serviceCapabilities]).pipe(map((res) => this.parseTileOrImageArcgisOptions(baseOptions, res[0], res[1], res[2])));
+    }
+    getCapabilities(service, baseUrl, version) {
+        const params = new HttpParams({
+            fromObject: {
+                request: 'GetCapabilities',
+                service: service.toUpperCase(),
+                version: version || '1.3.0',
+                _i: 'true'
+            }
+        });
+        let request;
+        if (TypeCapabilities[service] === 'esriJSON') {
+            request = this.http.get(baseUrl + '?f=json');
+        }
+        else {
+            request = this.http.get(baseUrl, {
+                params,
+                responseType: 'text'
+            });
+        }
+        return request.pipe(map((res) => {
+            if (TypeCapabilities[service] === 'esriJSON') {
+                return res;
+            }
+            if (String(res).toLowerCase().includes('serviceexception') &&
+                String(res).toLowerCase().includes('access denied')) {
+                throw {
+                    error: {
+                        message: 'Service error getCapabilities: Access is denied'
+                    }
+                };
+            }
+            else {
+                return this.parsers[service].read(res);
+            }
+        }), catchError((e) => {
+            if (typeof e.error !== 'undefined') {
+                e.error.caught = true;
+            }
+            throw e;
+        }));
+    }
+    parseWMSOptions(baseOptions, capabilities) {
+        const layers = baseOptions.params.LAYERS;
+        const layer = this.findDataSourceInCapabilities(capabilities.Capability.Layer, layers);
+        if (!layer) {
+            throw {
+                error: {
+                    message: 'Layer not found'
+                }
+            };
+        }
+        const metadata = layer.DataURL ? layer.DataURL[0] : undefined;
+        const abstract = layer.Abstract ? layer.Abstract : undefined;
+        const keywordList = layer.KeywordList ? layer.KeywordList : undefined;
+        let queryable = layer.queryable;
+        const timeFilter = this.getTimeFilter(layer);
+        const timeFilterable = timeFilter && Object.keys(timeFilter).length > 0;
+        const legendOptions = layer.Style ? this.getStyle(layer.Style) : undefined;
+        let isExtentInGeographic = true;
+        if (layer.EX_GeographicBoundingBox) {
+            layer.EX_GeographicBoundingBox.forEach((coord, index) => {
+                if (index < 2 && (coord > 180 || coord < -180)) {
+                    isExtentInGeographic = false;
+                }
+                if (index >= 2 && (coord > 90 || coord < -90)) {
+                    isExtentInGeographic = false;
+                }
+            });
+        }
+        else {
+            isExtentInGeographic = false;
+        }
+        const extent = isExtentInGeographic
+            ? olproj.transformExtent(layer.EX_GeographicBoundingBox, 'EPSG:4326', this.mapService.getMap().projection)
+            : undefined;
+        let queryFormat;
+        const queryFormatMimeTypePriority = [
+            QueryFormatMimeType.GEOJSON,
+            QueryFormatMimeType.GEOJSON2,
+            QueryFormatMimeType.GML3,
+            QueryFormatMimeType.GML2,
+            QueryFormatMimeType.JSON,
+            QueryFormatMimeType.HTML
+        ];
+        for (const mimeType of queryFormatMimeTypePriority) {
+            if (capabilities.Capability.Request.GetFeatureInfo.Format.indexOf(mimeType) !== -1) {
+                const keyEnum = Object.keys(QueryFormatMimeType).find((key) => QueryFormatMimeType[key] === mimeType);
+                queryFormat = QueryFormat[keyEnum];
+                break;
+            }
+        }
+        if (!queryFormat) {
+            queryable = false;
+        }
+        const options = ObjectUtils.removeUndefined({
+            _layerOptionsFromSource: {
+                title: layer.Title,
+                maxResolution: getResolutionFromScale(layer.MaxScaleDenominator),
+                minResolution: getResolutionFromScale(layer.MinScaleDenominator),
+                extent,
+                metadata: {
+                    url: metadata ? metadata.OnlineResource : undefined,
+                    extern: metadata ? true : undefined,
+                    abstract,
+                    keywordList
+                },
+                legendOptions
+            },
+            queryable,
+            queryFormat,
+            timeFilter: timeFilterable ? timeFilter : undefined,
+            timeFilterable: timeFilterable ? true : undefined,
+            minDate: timeFilterable ? timeFilter.min : undefined,
+            maxDate: timeFilterable ? timeFilter.max : undefined,
+            stepDate: timeFilterable ? timeFilter.step : undefined
+        });
+        return ObjectUtils.mergeDeep(options, baseOptions);
+    }
+    parseWMTSOptions(baseOptions, capabilities) {
+        // Put Title source in _layerOptionsFromSource. (For source & catalog in _layerOptionsFromSource, if not already on config)
+        const layer = capabilities.Contents.Layer.find((el) => el.Identifier === baseOptions.layer);
+        const options = optionsFromCapabilities(capabilities, baseOptions);
+        const ouputOptions = Object.assign(options, baseOptions);
+        const sourceOptions = ObjectUtils.removeUndefined({
+            _layerOptionsFromSource: {
+                title: layer.Title
+            }
+        });
+        return ObjectUtils.mergeDeep(sourceOptions, ouputOptions);
+    }
+    parseCartoOptions(baseOptions, cartoOptions) {
+        const layers = [];
+        const params = cartoOptions.layers[1].options.layer_definition;
+        params.layers.forEach((element) => {
+            layers.push({
+                type: element.type.toLowerCase(),
+                options: element.options,
+                legend: element.legend
+            });
+        });
+        const options = ObjectUtils.removeUndefined({
+            config: {
+                version: params.version,
+                layers
+            }
+        });
+        return ObjectUtils.mergeDeep(options, baseOptions);
+    }
+    parseArcgisOptions(baseOptions, arcgisOptions, serviceCapabilities) {
+        const title = arcgisOptions.name;
+        let legendInfo;
+        if (arcgisOptions.drawingInfo?.renderer) {
+            legendInfo = arcgisOptions.drawingInfo.renderer;
+        }
+        else {
+            legendInfo = undefined;
+        }
+        let style;
+        if (arcgisOptions.drawingInfo) {
+            const styleGenerator = new EsriStyleGenerator();
+            const units = arcgisOptions.units === 'esriMeters' ? 'm' : 'degrees';
+            style = styleGenerator.generateStyle(arcgisOptions, units);
+        }
+        const attributions = new olAttribution({
+            target: arcgisOptions.copyrightText
+        });
+        let timeExtent;
+        let timeFilter;
+        if (arcgisOptions.timeInfo) {
+            const time = arcgisOptions.timeInfo.timeExtent;
+            timeExtent = time[0] + ',' + time[1];
+            const min = new Date();
+            min.setTime(time[0]);
+            const max = new Date();
+            max.setTime(time[1]);
+            timeFilter = {
+                min: min.toUTCString(),
+                max: max.toUTCString(),
+                range: true,
+                type: TimeFilterType.DATETIME,
+                style: TimeFilterStyle.CALENDAR
+            };
+        }
+        const params = Object.assign({}, {
+            style,
+            LAYERS: baseOptions.layer ? 'show:' + baseOptions.layer : undefined,
+            time: timeExtent
+        });
+        const options = ObjectUtils.removeUndefined({
+            params,
+            _layerOptionsFromSource: {
+                title,
+                minResolution: getResolutionFromScale(arcgisOptions.maxScale),
+                maxResolution: getResolutionFromScale(arcgisOptions.minScale),
+                metadata: {
+                    extern: false,
+                    abstract: arcgisOptions.description || serviceCapabilities.serviceDescription
+                }
+            },
+            legendInfo,
+            timeFilter,
+            sourceFields: arcgisOptions.fields,
+            queryTitle: arcgisOptions.displayField
+        });
+        options.attributions = attributions;
+        return ObjectUtils.mergeDeep(options, baseOptions);
+    }
+    parseTileOrImageArcgisOptions(baseOptions, arcgisOptions, legend, serviceCapabilities) {
+        const title = arcgisOptions.name;
+        const legendInfo = legend.layers
+            ? legend.layers.find((x) => x.layerName === title)
+            : undefined;
+        const attributions = new olAttribution({
+            target: arcgisOptions.copyrightText
+        });
+        let timeExtent;
+        let timeFilter;
+        if (arcgisOptions.timeInfo) {
+            const time = arcgisOptions.timeInfo.timeExtent;
+            timeExtent = time[0] + ',' + time[1];
+            const min = new Date();
+            min.setTime(time[0]);
+            const max = new Date();
+            max.setTime(time[1]);
+            timeFilter = {
+                min: min.toUTCString(),
+                max: max.toUTCString(),
+                range: true,
+                type: TimeFilterType.DATETIME,
+                style: TimeFilterStyle.CALENDAR
+            };
+        }
+        const params = Object.assign({}, {
+            LAYERS: baseOptions.layer ? 'show:' + baseOptions.layer : undefined,
+            time: timeExtent
+        });
+        const options = ObjectUtils.removeUndefined({
+            params,
+            _layerOptionsFromSource: {
+                title,
+                minResolution: getResolutionFromScale(arcgisOptions.maxScale),
+                maxResolution: getResolutionFromScale(arcgisOptions.minScale),
+                metadata: {
+                    extern: false,
+                    abstract: arcgisOptions.description || serviceCapabilities.serviceDescription
+                }
+            },
+            legendInfo,
+            timeFilter,
+            sourceFields: arcgisOptions.fields,
+            queryTitle: arcgisOptions.displayField
+        });
+        options.attributions = attributions;
+        return ObjectUtils.mergeDeep(options, baseOptions);
+    }
+    findDataSourceInCapabilities(layerArray, name) {
+        if (Array.isArray(layerArray)) {
+            let layer;
+            layerArray.find((value) => {
+                layer = this.findDataSourceInCapabilities(value, name);
+                return layer !== undefined;
+            }, this);
+            return layer;
+        }
+        else if (layerArray.Layer) {
+            return this.findDataSourceInCapabilities(layerArray.Layer, name);
+        }
+        else {
+            if (layerArray.Name && layerArray.Name === name) {
+                return layerArray;
+            }
+            return undefined;
+        }
+    }
+    getTimeFilter(layer) {
+        let dimension;
+        if (layer.Dimension) {
+            const timeFilter = {};
+            dimension = layer.Dimension[0];
+            if (dimension.values) {
+                const minMaxDim = dimension.values.split('/');
+                timeFilter.min = minMaxDim[0] !== undefined ? minMaxDim[0] : undefined;
+                timeFilter.max = minMaxDim[1] !== undefined ? minMaxDim[1] : undefined;
+                timeFilter.step = minMaxDim[2] !== undefined ? minMaxDim[2] : undefined;
+            }
+            if (dimension.default) {
+                timeFilter.value = dimension.default;
+            }
+            return timeFilter;
+        }
+    }
+    getStyle(Style) {
+        const styleOptions = Style.map((style) => {
+            return {
+                name: style.Name,
+                title: style.Title
+            };
+        })
+            // Handle repeat the style "default" in output  (MapServer or OpenLayer)
+            .filter((item, index, self) => self.findIndex((i) => i.name === item.name) ===
+            index);
+        const legendOptions = {
+            stylesAvailable: styleOptions
+        };
+        return legendOptions;
+    }
+    static ɵfac = function CapabilitiesService_Factory(t) { return new (t || CapabilitiesService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.MapService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CapabilitiesService, factory: CapabilitiesService.ɵfac, providedIn: 'root' });
+}
+__decorate([
+    Cacheable({
+        maxCacheCount: 20
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Observable)
+], CapabilitiesService.prototype, "getArcgisOptions", null);
+__decorate([
+    Cacheable({
+        maxCacheCount: 20
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Observable)
+], CapabilitiesService.prototype, "getImageArcgisOptions", null);
+__decorate([
+    Cacheable({
+        maxCacheCount: 20
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Observable)
+], CapabilitiesService.prototype, "getTileArcgisOptions", null);
+__decorate([
+    Cacheable({
+        maxCacheCount: 20
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Observable)
+], CapabilitiesService.prototype, "getCapabilities", null);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CapabilitiesService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.MapService }]; }, { getArcgisOptions: [], getImageArcgisOptions: [], getTileArcgisOptions: [], getCapabilities: [] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capabilities.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/datasource/shared/capabilities.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient, HttpParams } from '@angular/common/http';\r\nimport { Observable, forkJoin, of } from 'rxjs';\r\nimport { map, catchError } from 'rxjs/operators';\r\nimport { Cacheable } from 'ts-cacheable';\r\n\r\nimport { WMSCapabilities, WMTSCapabilities, EsriJSON } from 'ol/format';\r\nimport { optionsFromCapabilities } from 'ol/source/WMTS.js';\r\nimport olAttribution from 'ol/control/Attribution';\r\n\r\nimport { ObjectUtils } from '@igo2/utils';\r\nimport { MapService } from '../../map/shared/map.service';\r\nimport { getResolutionFromScale } from '../../map/shared/map.utils';\r\nimport { EsriStyleGenerator } from '../../style/shared/datasource/esri-style-generator';\r\nimport {\r\n  QueryFormat,\r\n  QueryFormatMimeType\r\n} from '../../query/shared/query.enums';\r\n\r\nimport {\r\n  WMTSDataSourceOptions,\r\n  WMSDataSourceOptions,\r\n  CartoDataSourceOptions,\r\n  ArcGISRestDataSourceOptions,\r\n  TileArcGISRestDataSourceOptions,\r\n  ArcGISRestImageDataSourceOptions\r\n} from './datasources';\r\nimport {\r\n  LegendOptions,\r\n  ItemStyleOptions\r\n} from '../../layer/shared/layers/legend.interface';\r\nimport {\r\n  TimeFilterType,\r\n  TimeFilterStyle\r\n} from '../../filter/shared/time-filter.enum';\r\nimport * as olproj from 'ol/proj';\r\n\r\nexport enum TypeCapabilities {\r\n  wms = 'wms',\r\n  wmts = 'wmts',\r\n  arcgisrest = 'esriJSON',\r\n  imagearcgisrest = 'esriJSON',\r\n  tilearcgisrest = 'esriJSON'\r\n}\r\n\r\nexport type TypeCapabilitiesStrings = keyof typeof TypeCapabilities;\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CapabilitiesService {\r\n  private parsers = {\r\n    wms: new WMSCapabilities(),\r\n    wmts: new WMTSCapabilities(),\r\n    esriJSON: new EsriJSON()\r\n  };\r\n\r\n  constructor(\r\n    private http: HttpClient,\r\n    private mapService: MapService\r\n  ) {}\r\n\r\n  getWMSOptions(\r\n    baseOptions: WMSDataSourceOptions\r\n  ): Observable<WMSDataSourceOptions> {\r\n    const url = baseOptions.url;\r\n    const version = (baseOptions.params as any).VERSION;\r\n\r\n    return this.getCapabilities('wms', url, version).pipe(\r\n      map((capabilities: any) => {\r\n        return capabilities\r\n          ? this.parseWMSOptions(baseOptions, capabilities)\r\n          : undefined;\r\n      })\r\n    );\r\n  }\r\n\r\n  getWMTSOptions(\r\n    baseOptions: WMTSDataSourceOptions\r\n  ): Observable<WMTSDataSourceOptions> {\r\n    const url = baseOptions.url;\r\n    const version = baseOptions.version;\r\n\r\n    const options = this.getCapabilities('wmts', url, version).pipe(\r\n      map((capabilities: any) => {\r\n        return capabilities\r\n          ? this.parseWMTSOptions(baseOptions, capabilities)\r\n          : undefined;\r\n      })\r\n    );\r\n    return options;\r\n  }\r\n\r\n  getCartoOptions(\r\n    baseOptions: CartoDataSourceOptions\r\n  ): Observable<CartoDataSourceOptions> {\r\n    const baseUrl =\r\n      'https://' +\r\n      baseOptions.account +\r\n      '.carto.com/api/v2/viz/' +\r\n      baseOptions.mapId +\r\n      '/viz.json';\r\n\r\n    return this.http\r\n      .jsonp(baseUrl, 'callback')\r\n      .pipe(\r\n        map((cartoOptions: any) =>\r\n          this.parseCartoOptions(baseOptions, cartoOptions)\r\n        )\r\n      );\r\n  }\r\n\r\n  @Cacheable({\r\n    maxCacheCount: 20\r\n  })\r\n  getArcgisOptions(\r\n    baseOptions: ArcGISRestDataSourceOptions\r\n  ): Observable<ArcGISRestDataSourceOptions> {\r\n    const baseUrl = baseOptions.url + '/' + baseOptions.layer + '?f=json';\r\n    const serviceCapabilities = this.getCapabilities(\r\n      'arcgisrest',\r\n      baseOptions.url\r\n    );\r\n    const arcgisOptions = this.http.get(baseUrl);\r\n    return forkJoin([arcgisOptions, serviceCapabilities]).pipe(\r\n      map((res: any) => {\r\n        return this.parseArcgisOptions(baseOptions, res[0], res[1]);\r\n      })\r\n    );\r\n  }\r\n\r\n  @Cacheable({\r\n    maxCacheCount: 20\r\n  })\r\n  getImageArcgisOptions(\r\n    baseOptions:\r\n      | ArcGISRestImageDataSourceOptions\r\n      | TileArcGISRestDataSourceOptions\r\n  ): Observable<\r\n    ArcGISRestImageDataSourceOptions | TileArcGISRestDataSourceOptions\r\n  > {\r\n    const baseUrl = baseOptions.url + '/' + baseOptions.layer + '?f=json';\r\n    const legendUrl = baseOptions.url + '/legend?f=json';\r\n    const serviceCapabilities = this.getCapabilities(\r\n      'imagearcgisrest',\r\n      baseOptions.url\r\n    );\r\n    const arcgisOptions = this.http.get(baseUrl);\r\n    const legend = this.http.get(legendUrl).pipe(\r\n      map((res: any) => res),\r\n      catchError((err) => {\r\n        console.log('No legend associated with this Image Service');\r\n        return of(err);\r\n      })\r\n    );\r\n    return forkJoin([arcgisOptions, legend, serviceCapabilities]).pipe(\r\n      map((res: any) => {\r\n        return this.parseTileOrImageArcgisOptions(\r\n          baseOptions,\r\n          res[0],\r\n          res[1],\r\n          res[2]\r\n        );\r\n      })\r\n    );\r\n  }\r\n\r\n  @Cacheable({\r\n    maxCacheCount: 20\r\n  })\r\n  getTileArcgisOptions(\r\n    baseOptions: TileArcGISRestDataSourceOptions\r\n  ): Observable<\r\n    ArcGISRestImageDataSourceOptions | TileArcGISRestDataSourceOptions\r\n  > {\r\n    const baseUrl = baseOptions.url + '/' + baseOptions.layer + '?f=json';\r\n    const legendUrl = baseOptions.url + '/legend?f=json';\r\n    const serviceCapabilities = this.getCapabilities(\r\n      'tilearcgisrest',\r\n      baseOptions.url\r\n    );\r\n    const arcgisOptions = this.http.get(baseUrl);\r\n    const legendInfo = this.http.get(legendUrl).pipe(\r\n      map((res: any) => res),\r\n      catchError((err) => {\r\n        console.log('No legend associated with this Tile Service');\r\n        return of(err);\r\n      })\r\n    );\r\n    return forkJoin([arcgisOptions, legendInfo, serviceCapabilities]).pipe(\r\n      map((res: any) =>\r\n        this.parseTileOrImageArcgisOptions(baseOptions, res[0], res[1], res[2])\r\n      )\r\n    );\r\n  }\r\n\r\n  @Cacheable({\r\n    maxCacheCount: 20\r\n  })\r\n  getCapabilities(\r\n    service: TypeCapabilitiesStrings,\r\n    baseUrl: string,\r\n    version?: string\r\n  ): Observable<any> {\r\n    const params = new HttpParams({\r\n      fromObject: {\r\n        request: 'GetCapabilities',\r\n        service: service.toUpperCase(),\r\n        version: version || '1.3.0',\r\n        _i: 'true'\r\n      }\r\n    });\r\n\r\n    let request;\r\n    if (TypeCapabilities[service] === 'esriJSON') {\r\n      request = this.http.get(baseUrl + '?f=json');\r\n    } else {\r\n      request = this.http.get(baseUrl, {\r\n        params,\r\n        responseType: 'text'\r\n      });\r\n    }\r\n\r\n    return request.pipe(\r\n      map((res) => {\r\n        if (TypeCapabilities[service] === 'esriJSON') {\r\n          return res as object;\r\n        }\r\n        if (\r\n          String(res).toLowerCase().includes('serviceexception') &&\r\n          String(res).toLowerCase().includes('access denied')\r\n        ) {\r\n          throw {\r\n            error: {\r\n              message: 'Service error getCapabilities: Access is denied'\r\n            }\r\n          };\r\n        } else {\r\n          return this.parsers[service].read(res);\r\n        }\r\n      }),\r\n      catchError((e) => {\r\n        if (typeof e.error !== 'undefined') {\r\n          e.error.caught = true;\r\n        }\r\n        throw e;\r\n      })\r\n    );\r\n  }\r\n\r\n  private parseWMSOptions(\r\n    baseOptions: WMSDataSourceOptions,\r\n    capabilities: any\r\n  ): WMSDataSourceOptions {\r\n    const layers = (baseOptions.params as any).LAYERS;\r\n    const layer = this.findDataSourceInCapabilities(\r\n      capabilities.Capability.Layer,\r\n      layers\r\n    );\r\n\r\n    if (!layer) {\r\n      throw {\r\n        error: {\r\n          message: 'Layer not found'\r\n        }\r\n      };\r\n    }\r\n    const metadata = layer.DataURL ? layer.DataURL[0] : undefined;\r\n    const abstract = layer.Abstract ? layer.Abstract : undefined;\r\n    const keywordList = layer.KeywordList ? layer.KeywordList : undefined;\r\n    let queryable = layer.queryable;\r\n    const timeFilter = this.getTimeFilter(layer);\r\n    const timeFilterable = timeFilter && Object.keys(timeFilter).length > 0;\r\n    const legendOptions = layer.Style ? this.getStyle(layer.Style) : undefined;\r\n    let isExtentInGeographic = true;\r\n    if (layer.EX_GeographicBoundingBox) {\r\n      layer.EX_GeographicBoundingBox.forEach((coord, index) => {\r\n        if (index < 2 && (coord > 180 || coord < -180)) {\r\n          isExtentInGeographic = false;\r\n        }\r\n        if (index >= 2 && (coord > 90 || coord < -90)) {\r\n          isExtentInGeographic = false;\r\n        }\r\n      });\r\n    } else {\r\n      isExtentInGeographic = false;\r\n    }\r\n\r\n    const extent = isExtentInGeographic\r\n      ? olproj.transformExtent(\r\n          layer.EX_GeographicBoundingBox,\r\n          'EPSG:4326',\r\n          this.mapService.getMap().projection\r\n        )\r\n      : undefined;\r\n\r\n    let queryFormat: QueryFormat;\r\n    const queryFormatMimeTypePriority = [\r\n      QueryFormatMimeType.GEOJSON,\r\n      QueryFormatMimeType.GEOJSON2,\r\n      QueryFormatMimeType.GML3,\r\n      QueryFormatMimeType.GML2,\r\n      QueryFormatMimeType.JSON,\r\n      QueryFormatMimeType.HTML\r\n    ];\r\n\r\n    for (const mimeType of queryFormatMimeTypePriority) {\r\n      if (\r\n        capabilities.Capability.Request.GetFeatureInfo.Format.indexOf(\r\n          mimeType\r\n        ) !== -1\r\n      ) {\r\n        const keyEnum = Object.keys(QueryFormatMimeType).find(\r\n          (key) => QueryFormatMimeType[key] === mimeType\r\n        );\r\n        queryFormat = QueryFormat[keyEnum];\r\n        break;\r\n      }\r\n    }\r\n    if (!queryFormat) {\r\n      queryable = false;\r\n    }\r\n\r\n    const options: WMSDataSourceOptions = ObjectUtils.removeUndefined({\r\n      _layerOptionsFromSource: {\r\n        title: layer.Title,\r\n        maxResolution: getResolutionFromScale(layer.MaxScaleDenominator),\r\n        minResolution: getResolutionFromScale(layer.MinScaleDenominator),\r\n        extent,\r\n        metadata: {\r\n          url: metadata ? metadata.OnlineResource : undefined,\r\n          extern: metadata ? true : undefined,\r\n          abstract,\r\n          keywordList\r\n        },\r\n        legendOptions\r\n      },\r\n      queryable,\r\n      queryFormat,\r\n      timeFilter: timeFilterable ? timeFilter : undefined,\r\n      timeFilterable: timeFilterable ? true : undefined,\r\n      minDate: timeFilterable ? timeFilter.min : undefined,\r\n      maxDate: timeFilterable ? timeFilter.max : undefined,\r\n      stepDate: timeFilterable ? timeFilter.step : undefined\r\n    });\r\n\r\n    return ObjectUtils.mergeDeep(options, baseOptions);\r\n  }\r\n\r\n  private parseWMTSOptions(\r\n    baseOptions: WMTSDataSourceOptions,\r\n    capabilities: any\r\n  ): WMTSDataSourceOptions {\r\n    // Put Title source in _layerOptionsFromSource. (For source & catalog in _layerOptionsFromSource, if not already on config)\r\n    const layer = capabilities.Contents.Layer.find(\r\n      (el) => el.Identifier === baseOptions.layer\r\n    );\r\n\r\n    const options = optionsFromCapabilities(capabilities, baseOptions);\r\n\r\n    const ouputOptions = Object.assign(options, baseOptions);\r\n    const sourceOptions = ObjectUtils.removeUndefined({\r\n      _layerOptionsFromSource: {\r\n        title: layer.Title\r\n      }\r\n    });\r\n\r\n    return ObjectUtils.mergeDeep(sourceOptions, ouputOptions);\r\n  }\r\n\r\n  private parseCartoOptions(\r\n    baseOptions: CartoDataSourceOptions,\r\n    cartoOptions: any\r\n  ): CartoDataSourceOptions {\r\n    const layers = [];\r\n    const params = cartoOptions.layers[1].options.layer_definition;\r\n    params.layers.forEach((element) => {\r\n      layers.push({\r\n        type: element.type.toLowerCase(),\r\n        options: element.options,\r\n        legend: element.legend\r\n      });\r\n    });\r\n    const options = ObjectUtils.removeUndefined({\r\n      config: {\r\n        version: params.version,\r\n        layers\r\n      }\r\n    });\r\n    return ObjectUtils.mergeDeep(options, baseOptions);\r\n  }\r\n\r\n  private parseArcgisOptions(\r\n    baseOptions: ArcGISRestDataSourceOptions,\r\n    arcgisOptions: any,\r\n    serviceCapabilities: any\r\n  ): ArcGISRestDataSourceOptions {\r\n    const title = arcgisOptions.name;\r\n    let legendInfo: any;\r\n\r\n    if (arcgisOptions.drawingInfo?.renderer) {\r\n      legendInfo = arcgisOptions.drawingInfo.renderer;\r\n    } else {\r\n      legendInfo = undefined;\r\n    }\r\n\r\n    let style;\r\n    if (arcgisOptions.drawingInfo) {\r\n      const styleGenerator = new EsriStyleGenerator();\r\n      const units = arcgisOptions.units === 'esriMeters' ? 'm' : 'degrees';\r\n      style = styleGenerator.generateStyle(arcgisOptions, units);\r\n    }\r\n    const attributions = new olAttribution({\r\n      target: arcgisOptions.copyrightText\r\n    });\r\n    let timeExtent;\r\n    let timeFilter;\r\n    if (arcgisOptions.timeInfo) {\r\n      const time = arcgisOptions.timeInfo.timeExtent;\r\n      timeExtent = time[0] + ',' + time[1];\r\n      const min = new Date();\r\n      min.setTime(time[0]);\r\n      const max = new Date();\r\n      max.setTime(time[1]);\r\n      timeFilter = {\r\n        min: min.toUTCString(),\r\n        max: max.toUTCString(),\r\n        range: true,\r\n        type: TimeFilterType.DATETIME,\r\n        style: TimeFilterStyle.CALENDAR\r\n      };\r\n    }\r\n    const params = Object.assign(\r\n      {},\r\n      {\r\n        style,\r\n        LAYERS: baseOptions.layer ? 'show:' + baseOptions.layer : undefined,\r\n        time: timeExtent\r\n      }\r\n    );\r\n    const options = ObjectUtils.removeUndefined({\r\n      params,\r\n      _layerOptionsFromSource: {\r\n        title,\r\n        minResolution: getResolutionFromScale(arcgisOptions.maxScale),\r\n        maxResolution: getResolutionFromScale(arcgisOptions.minScale),\r\n        metadata: {\r\n          extern: false,\r\n          abstract:\r\n            arcgisOptions.description || serviceCapabilities.serviceDescription\r\n        }\r\n      },\r\n      legendInfo,\r\n      timeFilter,\r\n      sourceFields: arcgisOptions.fields,\r\n      queryTitle: arcgisOptions.displayField\r\n    });\r\n    options.attributions = attributions;\r\n    return ObjectUtils.mergeDeep(options, baseOptions);\r\n  }\r\n\r\n  private parseTileOrImageArcgisOptions(\r\n    baseOptions:\r\n      | TileArcGISRestDataSourceOptions\r\n      | ArcGISRestImageDataSourceOptions,\r\n    arcgisOptions: any,\r\n    legend: any,\r\n    serviceCapabilities: any\r\n  ): TileArcGISRestDataSourceOptions | ArcGISRestImageDataSourceOptions {\r\n    const title = arcgisOptions.name;\r\n    const legendInfo = legend.layers\r\n      ? legend.layers.find((x) => x.layerName === title)\r\n      : undefined;\r\n    const attributions = new olAttribution({\r\n      target: arcgisOptions.copyrightText\r\n    });\r\n    let timeExtent;\r\n    let timeFilter;\r\n    if (arcgisOptions.timeInfo) {\r\n      const time = arcgisOptions.timeInfo.timeExtent;\r\n      timeExtent = time[0] + ',' + time[1];\r\n      const min = new Date();\r\n      min.setTime(time[0]);\r\n      const max = new Date();\r\n      max.setTime(time[1]);\r\n      timeFilter = {\r\n        min: min.toUTCString(),\r\n        max: max.toUTCString(),\r\n        range: true,\r\n        type: TimeFilterType.DATETIME,\r\n        style: TimeFilterStyle.CALENDAR\r\n      };\r\n    }\r\n    const params = Object.assign(\r\n      {},\r\n      {\r\n        LAYERS: baseOptions.layer ? 'show:' + baseOptions.layer : undefined,\r\n        time: timeExtent\r\n      }\r\n    );\r\n    const options = ObjectUtils.removeUndefined({\r\n      params,\r\n      _layerOptionsFromSource: {\r\n        title,\r\n        minResolution: getResolutionFromScale(arcgisOptions.maxScale),\r\n        maxResolution: getResolutionFromScale(arcgisOptions.minScale),\r\n        metadata: {\r\n          extern: false,\r\n          abstract:\r\n            arcgisOptions.description || serviceCapabilities.serviceDescription\r\n        }\r\n      },\r\n      legendInfo,\r\n      timeFilter,\r\n      sourceFields: arcgisOptions.fields,\r\n      queryTitle: arcgisOptions.displayField\r\n    });\r\n    options.attributions = attributions;\r\n    return ObjectUtils.mergeDeep(options, baseOptions);\r\n  }\r\n\r\n  private findDataSourceInCapabilities(layerArray, name): any {\r\n    if (Array.isArray(layerArray)) {\r\n      let layer;\r\n      layerArray.find((value) => {\r\n        layer = this.findDataSourceInCapabilities(value, name);\r\n        return layer !== undefined;\r\n      }, this);\r\n\r\n      return layer;\r\n    } else if (layerArray.Layer) {\r\n      return this.findDataSourceInCapabilities(layerArray.Layer, name);\r\n    } else {\r\n      if (layerArray.Name && layerArray.Name === name) {\r\n        return layerArray;\r\n      }\r\n      return undefined;\r\n    }\r\n  }\r\n\r\n  getTimeFilter(layer) {\r\n    let dimension;\r\n\r\n    if (layer.Dimension) {\r\n      const timeFilter: any = {};\r\n      dimension = layer.Dimension[0];\r\n\r\n      if (dimension.values) {\r\n        const minMaxDim = dimension.values.split('/');\r\n        timeFilter.min = minMaxDim[0] !== undefined ? minMaxDim[0] : undefined;\r\n        timeFilter.max = minMaxDim[1] !== undefined ? minMaxDim[1] : undefined;\r\n        timeFilter.step = minMaxDim[2] !== undefined ? minMaxDim[2] : undefined;\r\n      }\r\n\r\n      if (dimension.default) {\r\n        timeFilter.value = dimension.default;\r\n      }\r\n      return timeFilter;\r\n    }\r\n  }\r\n\r\n  getStyle(Style): LegendOptions {\r\n    const styleOptions: ItemStyleOptions[] = Style.map((style) => {\r\n      return {\r\n        name: style.Name,\r\n        title: style.Title\r\n      };\r\n    })\r\n      // Handle repeat the style \"default\" in output  (MapServer or OpenLayer)\r\n      .filter(\r\n        (item, index, self) =>\r\n          self.findIndex((i: ItemStyleOptions) => i.name === item.name) ===\r\n          index\r\n      );\r\n\r\n    const legendOptions: LegendOptions = {\r\n      stylesAvailable: styleOptions\r\n    } as LegendOptions;\r\n\r\n    return legendOptions;\r\n  }\r\n}\r\n"]}