@igo2/geo 1.10.0 → 1.12.0

package/esm2015/lib/workspace/shared/edition-workspace.service.js

@@ -0,0 +1,646 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { ActionStore, EntityStoreFilterCustomFuncStrategy, EntityStoreFilterSelectionStrategy, EntityTableColumnRenderer } from '@igo2/common';
+import { catchError, map, skipWhile, take } from 'rxjs/operators';
+import { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';
+import { FeatureMotion, FeatureStore, FeatureStoreInMapExtentStrategy, FeatureStoreInMapResolutionStrategy, FeatureStoreLoadingLayerStrategy, FeatureStoreSelectionStrategy } from '../../feature';
+import { LinkedProperties, VectorLayer } from '../../layer';
+import { EditionWorkspace } from './edition-workspace';
+import { BehaviorSubject, throwError } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../layer";
+import * as i2 from "@igo2/core";
+import * as i3 from "@angular/common/http";
+import * as i4 from "@angular/material/dialog";
+import * as i5 from "../../layer/shared/style.service";
+import * as i6 from "@igo2/auth";
+export class EditionWorkspaceService {
+    constructor(layerService, storageService, configService, messageService, languageService, http, dialog, styleService, authInterceptor) {
+        this.layerService = layerService;
+        this.storageService = storageService;
+        this.configService = configService;
+        this.messageService = messageService;
+        this.languageService = languageService;
+        this.http = http;
+        this.dialog = dialog;
+        this.styleService = styleService;
+        this.authInterceptor = authInterceptor;
+        this.ws$ = new BehaviorSubject(undefined);
+        this.adding$ = new BehaviorSubject(false);
+        this.relationLayers$ = new BehaviorSubject(undefined);
+        this.rowsInMapExtentCheckCondition$ = new BehaviorSubject(true);
+        this.loading = false;
+    }
+    get zoomAuto() {
+        return this.storageService.get('zoomAuto');
+    }
+    createWorkspace(layer, map) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        if (((_a = layer.options.workspace) === null || _a === void 0 ? void 0 : _a.enabled) !== true || layer.dataSource.options.edition.enabled !== true) {
+            return;
+        }
+        let wksConfig;
+        if (layer.options.workspace) {
+            wksConfig = layer.options.workspace;
+        }
+        else {
+            wksConfig = {};
+        }
+        wksConfig.srcId = layer.id;
+        wksConfig.workspaceId = layer.id;
+        wksConfig.enabled = true;
+        wksConfig.pageSize = (_b = layer.options.workspace) === null || _b === void 0 ? void 0 : _b.pageSize;
+        wksConfig.pageSizeOptions = (_c = layer.options.workspace) === null || _c === void 0 ? void 0 : _c.pageSizeOptions;
+        const dataSource = layer.dataSource;
+        const wmsLinkId = layer.id + '.WmsWorkspaceTableSrc';
+        const wfsLinkId = layer.id + '.WfsWorkspaceTableDest';
+        if (!layer.options.linkedLayers) {
+            layer.options.linkedLayers = { linkId: wmsLinkId, links: [] };
+        }
+        const linkProperties = {
+            bidirectionnal: true,
+            syncedDelete: true,
+            linkedIds: [wfsLinkId],
+            properties: [
+                LinkedProperties.ZINDEX,
+                LinkedProperties.VISIBLE
+            ]
+        };
+        if (!((_d = layer.options.workspace) === null || _d === void 0 ? void 0 : _d.minResolution)) {
+            linkProperties.properties.push(LinkedProperties.MINRESOLUTION);
+        }
+        let hasOgcFilters = false;
+        if ((_e = dataSource.options.ogcFilters) === null || _e === void 0 ? void 0 : _e.enabled) {
+            linkProperties.properties.push(LinkedProperties.OGCFILTERS);
+            hasOgcFilters = true;
+        }
+        if (!((_f = layer.options.workspace) === null || _f === void 0 ? void 0 : _f.maxResolution)) {
+            linkProperties.properties.push(LinkedProperties.MAXRESOLUTION);
+        }
+        let clonedLinks = [];
+        if (layer.options.linkedLayers.links) {
+            clonedLinks = JSON.parse(JSON.stringify(layer.options.linkedLayers.links));
+        }
+        clonedLinks.push(linkProperties);
+        layer.options.linkedLayers.linkId = layer.options.linkedLayers.linkId ? layer.options.linkedLayers.linkId : wmsLinkId,
+            layer.options.linkedLayers.links = clonedLinks;
+        let wks;
+        this.layerService
+            .createAsyncLayer({
+            id: wfsLinkId,
+            linkedLayers: {
+                linkId: wfsLinkId
+            },
+            workspace: {
+                srcId: layer.id,
+                workspaceId: undefined,
+                enabled: false,
+                queryOptions: {
+                    mapQueryOnOpenTab: (_h = (_g = layer.options.workspace) === null || _g === void 0 ? void 0 : _g.queryOptions) === null || _h === void 0 ? void 0 : _h.mapQueryOnOpenTab,
+                    tabQuery: false
+                },
+                pageSize: (_j = layer.options.workspace) === null || _j === void 0 ? void 0 : _j.pageSize,
+                pageSizeOptions: (_k = layer.options.workspace) === null || _k === void 0 ? void 0 : _k.pageSizeOptions
+            },
+            showInLayerList: false,
+            opacity: 0,
+            title: layer.title,
+            minResolution: ((_l = layer.options.workspace) === null || _l === void 0 ? void 0 : _l.minResolution) || layer.minResolution || 0,
+            maxResolution: ((_m = layer.options.workspace) === null || _m === void 0 ? void 0 : _m.maxResolution) || layer.maxResolution || Infinity,
+            style: this.styleService.createStyle({
+                fill: {
+                    "color": "rgba(255, 255, 255, 0.01)"
+                },
+                stroke: {
+                    "color": "rgba(255, 255, 255, 0.01)"
+                },
+                circle: {
+                    fill: {
+                        color: "rgba(255, 255, 255, 0.01)"
+                    },
+                    stroke: {
+                        color: "rgba(255, 255, 255, 0.01)"
+                    },
+                    radius: 5
+                }
+            }),
+            sourceOptions: {
+                download: dataSource.options.download,
+                type: 'wfs',
+                url: dataSource.options.urlWfs || dataSource.options.url,
+                queryable: true,
+                relations: dataSource.options.relations,
+                queryTitle: dataSource.options.queryTitle,
+                params: dataSource.options.paramsWFS,
+                ogcFilters: Object.assign({}, dataSource.ogcFilters$.value, { enabled: hasOgcFilters }),
+                sourceFields: dataSource.options.sourceFields || undefined,
+                edition: dataSource.options.edition
+            }
+        })
+            .subscribe((workspaceLayer) => {
+            map.addLayer(workspaceLayer);
+            layer.ol.setProperties({ linkedLayers: { linkId: layer.options.linkedLayers.linkId, links: clonedLinks } }, false);
+            workspaceLayer.dataSource.ol.refresh();
+            wks = new EditionWorkspace({
+                id: layer.id,
+                title: layer.title,
+                layer: workspaceLayer,
+                map,
+                entityStore: this.createFeatureStore(workspaceLayer, map),
+                actionStore: new ActionStore([]),
+                meta: {
+                    tableTemplate: undefined
+                }
+            }, this, this.dialog, this.configService);
+            this.createTableTemplate(wks, workspaceLayer);
+            workspaceLayer.options.workspace.workspaceId = workspaceLayer.id;
+            layer.options.workspace = Object.assign({}, layer.options.workspace, {
+                wksConfig
+            });
+            delete dataSource.options.download;
+            return wks;
+        });
+        return wks;
+    }
+    createFeatureStore(layer, map) {
+        const store = new FeatureStore([], { map });
+        store.bindLayer(layer);
+        const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});
+        const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});
+        const inMapResolutionStrategy = new FeatureStoreInMapResolutionStrategy({});
+        const selectedRecordStrategy = new EntityStoreFilterSelectionStrategy({});
+        const selectionStrategy = new FeatureStoreSelectionStrategy({
+            layer: new VectorLayer({
+                zIndex: 300,
+                source: new FeatureDataSource(),
+                style: undefined,
+                showInLayerList: false,
+                exportable: false,
+                browsable: false
+            }),
+            map,
+            hitTolerance: 15,
+            motion: this.zoomAuto ? FeatureMotion.Default : FeatureMotion.None,
+            many: true,
+            dragBox: true
+        });
+        store.addStrategy(loadingStrategy, true);
+        store.addStrategy(inMapExtentStrategy, true);
+        store.addStrategy(inMapResolutionStrategy, true);
+        store.addStrategy(selectionStrategy, true);
+        store.addStrategy(selectedRecordStrategy, false);
+        store.addStrategy(this.createFilterInMapExtentOrResolutionStrategy(), true);
+        return store;
+    }
+    createTableTemplate(workspace, layer) {
+        const fields = layer.dataSource.options.sourceFields || [];
+        const relations = layer.dataSource.options.relations || [];
+        let rendererType = EntityTableColumnRenderer.UnsanitizedHTML;
+        let buttons = [];
+        let columns = [];
+        let relationsColumn = [];
+        buttons = [{
+                name: 'edition',
+                title: undefined,
+                renderer: EntityTableColumnRenderer.ButtonGroup,
+                primary: false,
+                valueAccessor: () => {
+                    return [{
+                            editMode: false,
+                            icon: 'pencil',
+                            color: 'primary',
+                            disabled: layer.dataSource.options.edition.modifyButton === false ? true : false,
+                            click: (feature) => { workspace.editFeature(feature, workspace); }
+                        },
+                        {
+                            editMode: false,
+                            icon: 'delete',
+                            color: 'warn',
+                            disabled: layer.dataSource.options.edition.deleteButton === false ? true : false,
+                            click: (feature) => { workspace.deleteFeature(feature, workspace); }
+                        },
+                        {
+                            editMode: true,
+                            icon: 'check',
+                            color: 'primary',
+                            disabled: this.loading,
+                            click: (feature) => { this.saveFeature(feature, workspace); }
+                        },
+                        {
+                            editMode: true,
+                            icon: 'alpha-x',
+                            color: 'primary',
+                            disabled: this.loading,
+                            click: (feature) => { this.cancelEdit(workspace, feature); }
+                        }];
+                }
+            }];
+        if (fields.length === 0) {
+            workspace.entityStore.entities$.pipe(skipWhile(val => val.length === 0), take(1)).subscribe(entities => {
+                const ol = entities[0].ol;
+                const columnsFromFeatures = ol.getKeys()
+                    .filter(col => !col.startsWith('_') &&
+                    col !== 'geometry' &&
+                    col !== ol.getGeometryName() &&
+                    !col.match(/boundedby/gi))
+                    .map(key => {
+                    return {
+                        name: `properties.${key}`,
+                        title: key,
+                        renderer: rendererType,
+                    };
+                });
+                workspace.meta.tableTemplate = {
+                    selection: false,
+                    sort: true,
+                    columns: columnsFromFeatures
+                };
+            });
+            return;
+        }
+        columns = fields.map((field) => {
+            let column = {
+                name: `properties.${field.name}`,
+                title: field.alias ? field.alias : field.name,
+                renderer: rendererType,
+                valueAccessor: undefined,
+                cellClassFunc: () => {
+                    const cellClass = {};
+                    if (field.type) {
+                        cellClass[`class_${field.type}`] = true;
+                        return cellClass;
+                    }
+                },
+                primary: field.primary === true ? true : false,
+                visible: field.visible,
+                validation: field.validation,
+                linkColumnForce: field.linkColumnForce,
+                type: field.type,
+                domainValues: undefined,
+                relation: undefined,
+                multiple: field.multiple,
+                step: field.step,
+                tooltip: field.tooltip
+            };
+            if (field.type === 'list' || field.type === 'autocomplete') {
+                this.getDomainValues(field.relation).subscribe(result => {
+                    column.domainValues = result;
+                    column.relation = field.relation;
+                });
+            }
+            return column;
+        });
+        relationsColumn = relations.map((relation) => {
+            return {
+                name: `properties.${relation.name}`,
+                title: relation.alias ? relation.alias : relation.name,
+                renderer: EntityTableColumnRenderer.Icon,
+                icon: relation.icon,
+                parent: relation.parent,
+                type: 'relation',
+                tooltip: relation.tooltip,
+                onClick: () => {
+                    if (this.adding$.getValue() === false) {
+                        this.ws$.next(relation.title);
+                    }
+                },
+                cellClassFunc: () => {
+                    return { 'class_icon': true };
+                }
+            };
+        });
+        columns.push(...relationsColumn);
+        columns.push(...buttons);
+        workspace.meta.tableTemplate = {
+            selection: false,
+            sort: true,
+            columns
+        };
+    }
+    createFilterInMapExtentOrResolutionStrategy() {
+        const filterClauseFunc = (record) => {
+            return record.state.inMapExtent === true && record.state.inMapResolution === true;
+        };
+        return new EntityStoreFilterCustomFuncStrategy({ filterClauseFunc });
+    }
+    saveFeature(feature, workspace) {
+        if (!this.validateFeature(feature, workspace)) {
+            return false;
+        }
+        this.sanitizeParameter(feature, workspace);
+        let url = this.configService.getConfig('edition.url');
+        if (workspace.layer.dataSource.options.edition.baseUrl) {
+            url += workspace.layer.dataSource.options.edition.baseUrl;
+        }
+        if (feature.newFeature) {
+            url += workspace.layer.dataSource.options.edition.addUrl;
+            const addHeaders = workspace.layer.dataSource.options.edition.addHeaders;
+            const headers = new HttpHeaders(addHeaders);
+            this.addFeature(feature, workspace, url, headers);
+        }
+        else {
+            if (workspace.layer.dataSource.options.edition.modifyProtocol !== "post") {
+                url += '?' + workspace.layer.dataSource.options.edition.modifyUrl + feature.idkey;
+            }
+            else {
+                url += workspace.layer.dataSource.options.edition.modifyUrl;
+            }
+            const protocole = workspace.layer.dataSource.options.edition.modifyProtocol;
+            const modifyHeaders = workspace.layer.dataSource.options.edition.modifyHeaders;
+            const headers = new HttpHeaders(modifyHeaders);
+            this.modifyFeature(feature, workspace, url, headers, protocole);
+        }
+    }
+    addFeature(feature, workspace, url, headers) {
+        var _a, _b;
+        // TODO: adapt to any kind of geometry
+        if (workspace.layer.dataSource.options.edition.hasGeometry) {
+            //feature.properties[geom] = feature.geometry;
+            feature.properties["longitude"] = feature.geometry.coordinates[0];
+            feature.properties["latitude"] = feature.geometry.coordinates[1];
+        }
+        for (const property in feature.properties) {
+            for (const sf of workspace.layer.dataSource.options.sourceFields) {
+                if ((sf.name === property && ((_a = sf.validation) === null || _a === void 0 ? void 0 : _a.readonly)) || (sf.name === property && ((_b = sf.validation) === null || _b === void 0 ? void 0 : _b.send) === false)) {
+                    delete feature.properties[property];
+                }
+            }
+        }
+        this.loading = true;
+        this.http.post(`${url}`, feature.properties, { headers: headers }).subscribe(() => {
+            this.loading = false;
+            workspace.entityStore.stateView.clear();
+            workspace.deleteDrawings();
+            workspace.entityStore.delete(feature);
+            const message = this.languageService.translate.instant('igo.geo.workspace.addSuccess');
+            this.messageService.success(message);
+            this.refreshMap(workspace.layer, workspace.layer.map);
+            this.adding$.next(false);
+            this.rowsInMapExtentCheckCondition$.next(true);
+        }, error => {
+            this.loading = false;
+            error.error.caught = true;
+            const genericErrorMessage = this.languageService.translate.instant('igo.geo.workspace.addError');
+            const messages = workspace.layer.dataSource.options.edition.messages;
+            if (messages) {
+                let text;
+                messages.forEach(message => {
+                    const key = Object.keys(message)[0];
+                    if (error.error.message.includes(key)) {
+                        text = message[key];
+                        this.messageService.error(text);
+                    }
+                });
+                if (!text) {
+                    this.messageService.error(genericErrorMessage);
+                }
+            }
+            else {
+                this.messageService.error(genericErrorMessage);
+            }
+        });
+    }
+    deleteFeature(workspace, url) {
+        this.loading = true;
+        this.http.delete(`${url}`, {}).subscribe(() => {
+            this.loading = false;
+            const message = this.languageService.translate.instant('igo.geo.workspace.deleteSuccess');
+            this.messageService.success(message);
+            this.refreshMap(workspace.layer, workspace.layer.map);
+            for (const relation of workspace.layer.options.sourceOptions.relations) {
+                workspace.map.layers.forEach((layer) => {
+                    if (layer.title === relation.title) {
+                        layer.dataSource.ol.refresh();
+                    }
+                });
+            }
+        }, error => {
+            this.loading = false;
+            error.error.caught = true;
+            const genericErrorMessage = this.languageService.translate.instant('igo.geo.workspace.addError');
+            const messages = workspace.layer.dataSource.options.edition.messages;
+            if (messages) {
+                let text;
+                messages.forEach(message => {
+                    const key = Object.keys(message)[0];
+                    if (error.error.message.includes(key)) {
+                        text = message[key];
+                        this.messageService.error(text);
+                    }
+                });
+                if (!text) {
+                    this.messageService.error(genericErrorMessage);
+                }
+            }
+            else {
+                this.messageService.error(genericErrorMessage);
+            }
+        });
+    }
+    modifyFeature(feature, workspace, url, headers, protocole = 'patch') {
+        var _a, _b;
+        //TODO: adapt to any kind of geometry
+        if (workspace.layer.dataSource.options.edition.hasGeometry) {
+            //feature.properties[geom] = feature.geometry;
+            feature.properties["longitude"] = feature.geometry.coordinates[0];
+            feature.properties["latitude"] = feature.geometry.coordinates[1];
+        }
+        for (const property in feature.properties) {
+            for (const sf of workspace.layer.dataSource.options.sourceFields) {
+                if ((sf.name === property && ((_a = sf.validation) === null || _a === void 0 ? void 0 : _a.readonly)) || (sf.name === property && ((_b = sf.validation) === null || _b === void 0 ? void 0 : _b.send) === false)
+                    || property === 'boundedBy') {
+                    delete feature.properties[property];
+                }
+            }
+        }
+        this.loading = true;
+        this.http[protocole](`${url}`, feature.properties, { headers: headers }).subscribe(() => {
+            this.loading = false;
+            this.cancelEdit(workspace, feature, true);
+            const message = this.languageService.translate.instant('igo.geo.workspace.modifySuccess');
+            this.messageService.success(message);
+            this.refreshMap(workspace.layer, workspace.layer.map);
+            let relationLayers = [];
+            for (const relation of workspace.layer.options.sourceOptions.relations) {
+                workspace.map.layers.forEach((layer) => {
+                    if (layer.title === relation.title) {
+                        relationLayers.push(layer);
+                        layer.dataSource.ol.refresh();
+                    }
+                });
+            }
+            this.relationLayers$.next(relationLayers);
+        }, error => {
+            this.loading = false;
+            error.error.caught = true;
+            const genericErrorMessage = this.languageService.translate.instant('igo.geo.workspace.addError');
+            const messages = workspace.layer.dataSource.options.edition.messages;
+            if (messages) {
+                let text;
+                messages.forEach(message => {
+                    const key = Object.keys(message)[0];
+                    if (error.error.message.includes(key)) {
+                        text = message[key];
+                        this.messageService.error(text);
+                    }
+                });
+                if (!text) {
+                    this.messageService.error(genericErrorMessage);
+                }
+            }
+            else {
+                this.messageService.error(genericErrorMessage);
+            }
+        });
+    }
+    cancelEdit(workspace, feature, fromSave = false) {
+        feature.edition = false;
+        this.adding$.next(false);
+        workspace.deleteDrawings();
+        workspace.entityStore.stateView.clear();
+        if (feature.newFeature) {
+            workspace.entityStore.delete(feature);
+            workspace.deactivateDrawControl();
+            this.rowsInMapExtentCheckCondition$.next(true);
+        }
+        else {
+            if (!fromSave) {
+                feature.properties = feature.original_properties;
+                feature.geometry = feature.original_geometry;
+            }
+            delete feature.original_properties;
+            delete feature.original_geometry;
+        }
+    }
+    getDomainValues(relation) {
+        let url = relation.url;
+        if (!url) {
+            url = this.configService.getConfig('edition.url') + relation.table;
+        }
+        return this.http.get(url).pipe(map(result => {
+            return result;
+        }), catchError((err) => {
+            err.error.caught = true;
+            return throwError(err);
+        }));
+    }
+    /*
+     * Refresh both wms and wfs layer
+     * A new wfs loader is used to ensure cache is not retrieving old data
+     * WMS params are updated to ensure layer is correctly refreshed
+     */
+    refreshMap(layer, map) {
+        var _a, _b;
+        const wfsOlLayer = layer.dataSource.ol;
+        const loader = (extent, resolution, proj, success, failure) => {
+            layer.customWFSLoader(layer.ol.getSource(), layer.options.sourceOptions, this.authInterceptor, extent, resolution, proj, success, failure, true);
+        };
+        wfsOlLayer.setLoader(loader);
+        wfsOlLayer.refresh();
+        for (const lay of map.layers) {
+            if (lay.id !== layer.id &&
+                ((_a = lay.options.linkedLayers) === null || _a === void 0 ? void 0 : _a.linkId.includes(layer.id.substr(0, layer.id.indexOf('.') - 1))) &&
+                ((_b = lay.options.linkedLayers) === null || _b === void 0 ? void 0 : _b.linkId.includes('WmsWorkspaceTableSrc'))) {
+                const wmsOlLayer = lay.dataSource.ol;
+                let params = wmsOlLayer.getParams();
+                params._t = new Date().getTime();
+                wmsOlLayer.updateParams(params);
+            }
+        }
+    }
+    validateFeature(feature, workspace) {
+        const translate = this.languageService.translate;
+        let message;
+        let key;
+        let valid = true;
+        workspace.meta.tableTemplate.columns.forEach(column => {
+            if (column.hasOwnProperty('validation') && column.validation) {
+                key = getColumnKeyWithoutPropertiesTag(column.name);
+                Object.keys(column.validation).forEach((type) => {
+                    switch (type) {
+                        case 'mandatory': {
+                            if (column.validation[type] && (!feature.properties.hasOwnProperty(key) || !feature.properties[key])) {
+                                valid = false;
+                                message = translate.instant('igo.geo.formValidation.mandatory', {
+                                    column: column.title
+                                });
+                                this.messageService.error(message);
+                            }
+                            break;
+                        }
+                        case 'minValue': {
+                            if (feature.properties.hasOwnProperty(key) && feature.properties[key] && feature.properties[key] < column.validation[type]) {
+                                valid = false;
+                                message = translate.instant('igo.geo.formValidation.minValue', {
+                                    column: column.title,
+                                    value: column.validation[type]
+                                });
+                                this.messageService.error(message);
+                            }
+                            break;
+                        }
+                        case 'maxValue': {
+                            if (feature.properties.hasOwnProperty(key) && feature.properties[key] && feature.properties[key] > column.validation[type]) {
+                                valid = false;
+                                message = translate.instant('igo.geo.formValidation.maxValue', {
+                                    column: column.title,
+                                    value: column.validation[type]
+                                });
+                                this.messageService.error(message);
+                            }
+                            break;
+                        }
+                        case 'minLength': {
+                            if (feature.properties.hasOwnProperty(key) && feature.properties[key] &&
+                                feature.properties[key].length < column.validation[type]) {
+                                valid = false;
+                                message = translate.instant('igo.geo.formValidation.minLength', {
+                                    column: column.title,
+                                    value: column.validation[type]
+                                });
+                                this.messageService.error(message);
+                            }
+                            break;
+                        }
+                        case 'maxLength': {
+                            if (feature.properties.hasOwnProperty(key) && feature.properties[key] &&
+                                feature.properties[key].length > column.validation[type]) {
+                                valid = false;
+                                message = translate.instant('igo.geo.formValidation.maxLength', {
+                                    column: column.title,
+                                    value: column.validation[type]
+                                });
+                                this.messageService.error(message);
+                            }
+                            break;
+                        }
+                    }
+                });
+            }
+        });
+        return valid;
+    }
+    sanitizeParameter(feature, workspace) {
+        workspace.meta.tableTemplate.columns.forEach(column => {
+            if (column.type === 'list' && feature.properties[getColumnKeyWithoutPropertiesTag(column.name)]) {
+                feature.properties[getColumnKeyWithoutPropertiesTag(column.name)] =
+                    feature.properties[getColumnKeyWithoutPropertiesTag(column.name)].toString();
+            }
+        });
+    }
+}
+EditionWorkspaceService.ɵfac = function EditionWorkspaceService_Factory(t) { return new (t || EditionWorkspaceService)(i0.ɵɵinject(i1.LayerService), i0.ɵɵinject(i2.StorageService), i0.ɵɵinject(i2.ConfigService), i0.ɵɵinject(i2.MessageService), i0.ɵɵinject(i2.LanguageService), i0.ɵɵinject(i3.HttpClient), i0.ɵɵinject(i4.MatDialog), i0.ɵɵinject(i5.StyleService), i0.ɵɵinject(i6.AuthInterceptor)); };
+EditionWorkspaceService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EditionWorkspaceService, factory: EditionWorkspaceService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EditionWorkspaceService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.LayerService }, { type: i2.StorageService }, { type: i2.ConfigService }, { type: i2.MessageService }, { type: i2.LanguageService }, { type: i3.HttpClient }, { type: i4.MatDialog }, { type: i5.StyleService }, { type: i6.AuthInterceptor }]; }, null); })();
+function getColumnKeyWithoutPropertiesTag(column) {
+    if (column.includes('properties.')) {
+        return column.split('.')[1];
+    }
+    return column;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"edition-workspace.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/workspace/shared/edition-workspace.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient, HttpErrorResponse, HttpHeaders } from '@angular/common/http';\r\nimport { MatDialog } from '@angular/material/dialog';\r\n\r\nimport {\r\n  ActionStore,\r\n  EntityRecord,\r\n  EntityStoreFilterCustomFuncStrategy,\r\n  EntityStoreFilterSelectionStrategy,\r\n  EntityStoreStrategyFuncOptions,\r\n  EntityTableColumnRenderer,\r\n  EntityTableTemplate,\r\n  EntityTableButton} from '@igo2/common';\r\nimport { ConfigService, LanguageService, MessageService, StorageService } from '@igo2/core';\r\nimport { AuthInterceptor } from '@igo2/auth';\r\nimport { catchError, map, skipWhile, take } from 'rxjs/operators';\r\nimport { RelationOptions, SourceFieldsOptionsParams, WMSDataSource } from '../../datasource';\r\nimport { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';\r\nimport { WFSDataSourceOptions } from '../../datasource/shared/datasources/wfs-datasource.interface';\r\nimport {\r\n  Feature,\r\n  FeatureMotion,\r\n  FeatureStore,\r\n  FeatureStoreInMapExtentStrategy,\r\n  FeatureStoreInMapResolutionStrategy,\r\n  FeatureStoreLoadingLayerStrategy,\r\n  FeatureStoreSelectionStrategy} from '../../feature';\r\n\r\nimport { OgcFilterableDataSourceOptions } from '../../filter/shared/ogc-filter.interface';\r\nimport { ImageLayer, LayerService, LayersLinkProperties, LinkedProperties, VectorLayer } from '../../layer';\r\nimport { StyleService } from '../../layer/shared/style.service';\r\nimport { GeoWorkspaceOptions } from '../../layer/shared/layers/layer.interface';\r\nimport { IgoMap } from '../../map';\r\nimport { QueryableDataSourceOptions } from '../../query/shared/query.interfaces';\r\nimport { EditionWorkspace } from './edition-workspace';\r\n\r\nimport olFeature from 'ol/Feature';\r\nimport olSourceImageWMS from 'ol/source/ImageWMS';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\nimport { BehaviorSubject, Observable, throwError } from 'rxjs';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class EditionWorkspaceService {\r\n\r\n  public ws$ = new BehaviorSubject<string>(undefined);\r\n  public adding$ = new BehaviorSubject<boolean>(false);\r\n  public relationLayers$ = new BehaviorSubject<ImageLayer[] | VectorLayer[]>(undefined);\r\n  public rowsInMapExtentCheckCondition$ = new BehaviorSubject<boolean>(true);\r\n  public loading = false;\r\n\r\n  get zoomAuto(): boolean {\r\n    return this.storageService.get('zoomAuto') as boolean;\r\n  }\r\n\r\n  constructor(\r\n    private layerService: LayerService,\r\n    private storageService: StorageService,\r\n    private configService: ConfigService,\r\n    private messageService: MessageService,\r\n    private languageService: LanguageService,\r\n    private http: HttpClient,\r\n    private dialog: MatDialog,\r\n    private styleService: StyleService,\r\n    public authInterceptor?: AuthInterceptor) { }\r\n\r\n  createWorkspace(layer: ImageLayer, map: IgoMap): EditionWorkspace {\r\n    if (layer.options.workspace?.enabled !== true || layer.dataSource.options.edition.enabled !== true) {\r\n      return;\r\n    }\r\n    let wksConfig;\r\n    if (layer.options.workspace) {\r\n      wksConfig = layer.options.workspace;\r\n    } else {\r\n      wksConfig = {};\r\n    }\r\n    wksConfig.srcId = layer.id;\r\n    wksConfig.workspaceId = layer.id;\r\n    wksConfig.enabled = true;\r\n    wksConfig.pageSize = layer.options.workspace?.pageSize;\r\n    wksConfig.pageSizeOptions = layer.options.workspace?.pageSizeOptions;\r\n\r\n    const dataSource: WMSDataSource = layer.dataSource as WMSDataSource ;\r\n    const wmsLinkId = layer.id + '.WmsWorkspaceTableSrc';\r\n    const wfsLinkId = layer.id + '.WfsWorkspaceTableDest';\r\n    if (!layer.options.linkedLayers) {\r\n      layer.options.linkedLayers = { linkId: wmsLinkId, links: [] };\r\n    }\r\n    const linkProperties = {\r\n      bidirectionnal: true,\r\n      syncedDelete: true,\r\n      linkedIds: [wfsLinkId],\r\n      properties: [\r\n        LinkedProperties.ZINDEX,\r\n        LinkedProperties.VISIBLE]\r\n    } as LayersLinkProperties;\r\n\r\n    if (!layer.options.workspace?.minResolution) {\r\n       linkProperties.properties.push(LinkedProperties.MINRESOLUTION);\r\n    }\r\n    let hasOgcFilters = false;\r\n    if ((dataSource.options as OgcFilterableDataSourceOptions).ogcFilters?.enabled) {\r\n      linkProperties.properties.push(LinkedProperties.OGCFILTERS);\r\n      hasOgcFilters = true;\r\n    }\r\n    if (!layer.options.workspace?.maxResolution) {\r\n      linkProperties.properties.push(LinkedProperties.MAXRESOLUTION);\r\n    }\r\n\r\n    let clonedLinks: LayersLinkProperties[] = [];\r\n    if (layer.options.linkedLayers.links) {\r\n      clonedLinks = JSON.parse(JSON.stringify(layer.options.linkedLayers.links));\r\n    }\r\n    clonedLinks.push(linkProperties);\r\n\r\n    layer.options.linkedLayers.linkId = layer.options.linkedLayers.linkId ? layer.options.linkedLayers.linkId : wmsLinkId,\r\n      layer.options.linkedLayers.links = clonedLinks;\r\n    interface WFSoptions extends WFSDataSourceOptions, OgcFilterableDataSourceOptions { }\r\n    let wks;\r\n    this.layerService\r\n      .createAsyncLayer({\r\n        id: wfsLinkId,\r\n        linkedLayers: {\r\n          linkId: wfsLinkId\r\n        },\r\n        workspace: {\r\n          srcId: layer.id,\r\n          workspaceId: undefined,\r\n          enabled: false,\r\n          queryOptions: {\r\n            mapQueryOnOpenTab: layer.options.workspace?.queryOptions?.mapQueryOnOpenTab,\r\n            tabQuery: false\r\n          },\r\n          pageSize: layer.options.workspace?.pageSize,\r\n          pageSizeOptions: layer.options.workspace?.pageSizeOptions\r\n        },\r\n        showInLayerList: false,\r\n        opacity: 0,\r\n        title: layer.title,\r\n        minResolution: layer.options.workspace?.minResolution || layer.minResolution || 0,\r\n        maxResolution: layer.options.workspace?.maxResolution || layer.maxResolution || Infinity,\r\n        style: this.styleService.createStyle(\r\n          {\r\n            fill: {\r\n              \"color\": \"rgba(255, 255, 255, 0.01)\"\r\n            },\r\n            stroke: {\r\n              \"color\": \"rgba(255, 255, 255, 0.01)\"\r\n            },\r\n            circle: {\r\n              fill: {\r\n                color: \"rgba(255, 255, 255, 0.01)\"\r\n              },\r\n              stroke: {\r\n                color: \"rgba(255, 255, 255, 0.01)\"\r\n              },\r\n              radius: 5\r\n            }\r\n          }),\r\n          sourceOptions: {\r\n          download: dataSource.options.download,\r\n          type: 'wfs',\r\n          url: dataSource.options.urlWfs || dataSource.options.url,\r\n          queryable: true,\r\n          relations: dataSource.options.relations,\r\n          queryTitle: (dataSource.options as QueryableDataSourceOptions).queryTitle,\r\n          params: dataSource.options.paramsWFS,\r\n          ogcFilters: Object.assign({}, dataSource.ogcFilters$.value, {enabled: hasOgcFilters}),\r\n          sourceFields: dataSource.options.sourceFields || undefined,\r\n          edition: dataSource.options.edition\r\n        } as WFSoptions\r\n      })\r\n      .subscribe((workspaceLayer: VectorLayer) => {\r\n        map.addLayer(workspaceLayer);\r\n        layer.ol.setProperties({ linkedLayers: { linkId: layer.options.linkedLayers.linkId, links: clonedLinks } }, false);\r\n        workspaceLayer.dataSource.ol.refresh();\r\n\r\n        wks = new EditionWorkspace({\r\n          id: layer.id,\r\n          title: layer.title,\r\n          layer: workspaceLayer,\r\n          map,\r\n          entityStore: this.createFeatureStore(workspaceLayer, map),\r\n          actionStore: new ActionStore([]),\r\n          meta: {\r\n            tableTemplate: undefined\r\n          }\r\n        }, this, this.dialog, this.configService);\r\n        this.createTableTemplate(wks, workspaceLayer);\r\n\r\n        workspaceLayer.options.workspace.workspaceId = workspaceLayer.id;\r\n        layer.options.workspace = Object.assign({}, layer.options.workspace,\r\n          {\r\n            wksConfig\r\n          } as GeoWorkspaceOptions);\r\n\r\n        delete dataSource.options.download;\r\n        return wks;\r\n\r\n      });\r\n\r\n    return wks;\r\n  }\r\n\r\n  private createFeatureStore(layer: VectorLayer, map: IgoMap): FeatureStore {\r\n    const store = new FeatureStore([], { map });\r\n    store.bindLayer(layer);\r\n\r\n    const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});\r\n    const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});\r\n    const inMapResolutionStrategy = new FeatureStoreInMapResolutionStrategy({});\r\n    const selectedRecordStrategy = new EntityStoreFilterSelectionStrategy({});\r\n    const selectionStrategy = new FeatureStoreSelectionStrategy({\r\n      layer: new VectorLayer({\r\n        zIndex: 300,\r\n        source: new FeatureDataSource(),\r\n        style: undefined,\r\n        showInLayerList: false,\r\n        exportable: false,\r\n        browsable: false\r\n      }),\r\n      map,\r\n      hitTolerance: 15,\r\n      motion: this.zoomAuto ? FeatureMotion.Default : FeatureMotion.None,\r\n      many: true,\r\n      dragBox: true\r\n    });\r\n    store.addStrategy(loadingStrategy, true);\r\n    store.addStrategy(inMapExtentStrategy, true);\r\n    store.addStrategy(inMapResolutionStrategy, true);\r\n    store.addStrategy(selectionStrategy, true);\r\n    store.addStrategy(selectedRecordStrategy, false);\r\n    store.addStrategy(this.createFilterInMapExtentOrResolutionStrategy(), true);\r\n    return store;\r\n  }\r\n\r\n  private createTableTemplate(workspace: EditionWorkspace, layer: VectorLayer): EntityTableTemplate {\r\n    const fields = layer.dataSource.options.sourceFields || [];\r\n\r\n    const relations = layer.dataSource.options.relations || [];\r\n\r\n    let rendererType = EntityTableColumnRenderer.UnsanitizedHTML;\r\n    let buttons = [];\r\n    let columns = [];\r\n    let relationsColumn = [];\r\n\r\n    buttons = [{\r\n      name: 'edition',\r\n      title: undefined,\r\n      renderer: EntityTableColumnRenderer.ButtonGroup,\r\n      primary: false,\r\n      valueAccessor: () => {\r\n        return [{\r\n          editMode: false,\r\n          icon: 'pencil',\r\n          color: 'primary',\r\n          disabled: layer.dataSource.options.edition.modifyButton === false ? true : false,\r\n          click: (feature) => { workspace.editFeature(feature, workspace); }\r\n        },\r\n        {\r\n          editMode: false,\r\n          icon: 'delete',\r\n          color: 'warn',\r\n          disabled: layer.dataSource.options.edition.deleteButton === false ? true : false,\r\n          click: (feature) => { workspace.deleteFeature(feature, workspace); }\r\n        },\r\n        {\r\n          editMode: true,\r\n          icon: 'check',\r\n          color: 'primary',\r\n          disabled: this.loading,\r\n          click: (feature) => { this.saveFeature(feature, workspace); }\r\n        },\r\n        {\r\n          editMode: true,\r\n          icon: 'alpha-x',\r\n          color: 'primary',\r\n          disabled: this.loading,\r\n          click: (feature) => { this.cancelEdit(workspace, feature); }\r\n        }] as EntityTableButton[];\r\n      }\r\n    }];\r\n\r\n\r\n    if (fields.length === 0) {\r\n      workspace.entityStore.entities$.pipe(\r\n        skipWhile(val => val.length === 0),\r\n        take(1)\r\n      ).subscribe(entities => {\r\n        const ol = (entities[0] as Feature).ol as olFeature<OlGeometry>;\r\n        const columnsFromFeatures = ol.getKeys()\r\n          .filter(\r\n            col => !col.startsWith('_') &&\r\n              col !== 'geometry' &&\r\n              col !== ol.getGeometryName() &&\r\n              !col.match(/boundedby/gi))\r\n          .map(key => {\r\n            return {\r\n              name: `properties.${key}`,\r\n              title: key,\r\n              renderer: rendererType,\r\n            };\r\n          });\r\n        workspace.meta.tableTemplate = {\r\n          selection: false,\r\n          sort: true,\r\n          columns: columnsFromFeatures\r\n        };\r\n      });\r\n      return;\r\n    }\r\n\r\n    columns = fields.map((field: SourceFieldsOptionsParams) => {\r\n\r\n      let column = {\r\n        name: `properties.${field.name}`,\r\n        title: field.alias ? field.alias : field.name,\r\n        renderer: rendererType,\r\n        valueAccessor: undefined,\r\n        cellClassFunc: () => {\r\n          const cellClass = {};\r\n          if (field.type) {\r\n            cellClass[`class_${field.type}`] = true;\r\n            return cellClass;\r\n          }\r\n        },\r\n        primary: field.primary === true ? true : false,\r\n        visible: field.visible,\r\n        validation: field.validation,\r\n        linkColumnForce: field.linkColumnForce,\r\n        type: field.type,\r\n        domainValues: undefined,\r\n        relation: undefined,\r\n        multiple: field.multiple,\r\n        step: field.step,\r\n        tooltip: field.tooltip\r\n      };\r\n\r\n      if (field.type === 'list' || field.type === 'autocomplete') {\r\n        this.getDomainValues(field.relation).subscribe(result => {\r\n          column.domainValues = result;\r\n          column.relation = field.relation;\r\n        });\r\n      }\r\n      return column;\r\n    });\r\n\r\n    relationsColumn = relations.map((relation: RelationOptions) => {\r\n      return {\r\n        name: `properties.${relation.name}`,\r\n        title: relation.alias ? relation.alias : relation.name,\r\n        renderer: EntityTableColumnRenderer.Icon,\r\n        icon: relation.icon,\r\n        parent: relation.parent,\r\n        type: 'relation',\r\n        tooltip: relation.tooltip,\r\n        onClick: () => {\r\n          if (this.adding$.getValue() === false) {\r\n            this.ws$.next(relation.title);\r\n          }\r\n        },\r\n        cellClassFunc: () => {\r\n          return { 'class_icon': true };\r\n        }\r\n      };\r\n    });\r\n\r\n    columns.push(...relationsColumn);\r\n    columns.push(...buttons);\r\n\r\n    workspace.meta.tableTemplate = {\r\n      selection: false,\r\n      sort: true,\r\n      columns\r\n    };\r\n  }\r\n\r\n  private createFilterInMapExtentOrResolutionStrategy(): EntityStoreFilterCustomFuncStrategy {\r\n    const filterClauseFunc = (record: EntityRecord<object>) => {\r\n      return record.state.inMapExtent === true && record.state.inMapResolution === true;\r\n    };\r\n    return new EntityStoreFilterCustomFuncStrategy({filterClauseFunc} as EntityStoreStrategyFuncOptions);\r\n  }\r\n\r\n  public saveFeature(feature, workspace: EditionWorkspace) {\r\n    if (!this.validateFeature(feature, workspace)){\r\n      return false;\r\n    }\r\n\r\n    this.sanitizeParameter(feature, workspace);\r\n\r\n    let url = this.configService.getConfig('edition.url');\r\n\r\n    if (workspace.layer.dataSource.options.edition.baseUrl) {\r\n      url += workspace.layer.dataSource.options.edition.baseUrl;\r\n    }\r\n\r\n    if (feature.newFeature) {\r\n      url += workspace.layer.dataSource.options.edition.addUrl;\r\n\r\n      const addHeaders = workspace.layer.dataSource.options.edition.addHeaders;\r\n      const headers = new HttpHeaders(addHeaders);\r\n\r\n      this.addFeature(feature, workspace, url, headers);\r\n    } else {\r\n      if (workspace.layer.dataSource.options.edition.modifyProtocol !== \"post\") {\r\n        url += '?' + workspace.layer.dataSource.options.edition.modifyUrl + feature.idkey;\r\n      }\r\n      else {\r\n        url += workspace.layer.dataSource.options.edition.modifyUrl;\r\n      }\r\n\r\n      const protocole = workspace.layer.dataSource.options.edition.modifyProtocol;\r\n      const modifyHeaders = workspace.layer.dataSource.options.edition.modifyHeaders;\r\n      const headers = new HttpHeaders(modifyHeaders);\r\n\r\n      this.modifyFeature(feature, workspace, url, headers, protocole);\r\n    }\r\n  }\r\n\r\n  public addFeature(feature, workspace: EditionWorkspace, url: string, headers: {[key: string]: any}) {\r\n    // TODO: adapt to any kind of geometry\r\n    if (workspace.layer.dataSource.options.edition.hasGeometry) {\r\n      //feature.properties[geom] = feature.geometry;\r\n      feature.properties[\"longitude\"] = feature.geometry.coordinates[0];\r\n      feature.properties[\"latitude\"] = feature.geometry.coordinates[1];\r\n    }\r\n\r\n    for (const property in feature.properties) {\r\n      for (const sf of workspace.layer.dataSource.options.sourceFields) {\r\n        if ((sf.name === property && sf.validation?.readonly) || (sf.name === property && sf.validation?.send === false)) {\r\n          delete feature.properties[property];\r\n        }\r\n      }\r\n    }\r\n\r\n    this.loading = true;\r\n    this.http.post(`${url}`, feature.properties, { headers: headers }).subscribe(\r\n      () => {\r\n        this.loading = false;\r\n        workspace.entityStore.stateView.clear();\r\n        workspace.deleteDrawings();\r\n        workspace.entityStore.delete(feature);\r\n\r\n        const message = this.languageService.translate.instant(\r\n          'igo.geo.workspace.addSuccess'\r\n        );\r\n        this.messageService.success(message);\r\n\r\n        this.refreshMap(workspace.layer as VectorLayer, workspace.layer.map);\r\n        this.adding$.next(false);\r\n        this.rowsInMapExtentCheckCondition$.next(true);\r\n      },\r\n      error => {\r\n        this.loading = false;\r\n        error.error.caught = true;\r\n        const genericErrorMessage = this.languageService.translate.instant(\r\n          'igo.geo.workspace.addError'\r\n        );\r\n        const messages = workspace.layer.dataSource.options.edition.messages;\r\n        if (messages) {\r\n          let text;\r\n          messages.forEach(message => {\r\n            const key = Object.keys(message)[0];\r\n            if (error.error.message.includes(key)) {\r\n              text = message[key];\r\n              this.messageService.error(text);\r\n            }\r\n          });\r\n          if (!text) {\r\n            this.messageService.error(genericErrorMessage);\r\n          }\r\n        } else {\r\n          this.messageService.error(genericErrorMessage);\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  public deleteFeature(workspace: EditionWorkspace, url: string) {\r\n    this.loading = true;\r\n    this.http.delete(`${url}`, {}).subscribe(\r\n      () => {\r\n        this.loading = false;\r\n        const message = this.languageService.translate.instant(\r\n          'igo.geo.workspace.deleteSuccess'\r\n        );\r\n        this.messageService.success(message);\r\n\r\n        this.refreshMap(workspace.layer as VectorLayer, workspace.layer.map);\r\n        for (const relation of workspace.layer.options.sourceOptions.relations) {\r\n          workspace.map.layers.forEach((layer) => {\r\n            if (layer.title === relation.title) {\r\n              layer.dataSource.ol.refresh();\r\n            }\r\n          });\r\n        }\r\n      },\r\n      error => {\r\n        this.loading = false;\r\n        error.error.caught = true;\r\n          const genericErrorMessage = this.languageService.translate.instant(\r\n            'igo.geo.workspace.addError'\r\n          );\r\n          const messages = workspace.layer.dataSource.options.edition.messages;\r\n          if (messages) {\r\n            let text;\r\n            messages.forEach(message => {\r\n              const key = Object.keys(message)[0];\r\n              if (error.error.message.includes(key)) {\r\n                text = message[key];\r\n                this.messageService.error(text);\r\n              }\r\n            });\r\n            if (!text) {\r\n              this.messageService.error(genericErrorMessage);\r\n            }\r\n          } else {\r\n            this.messageService.error(genericErrorMessage);\r\n          }\r\n      }\r\n    );\r\n  }\r\n\r\n  public modifyFeature(feature, workspace: EditionWorkspace, url: string, headers: {[key: string]: any}, protocole = 'patch' ) {\r\n    //TODO: adapt to any kind of geometry\r\n    if (workspace.layer.dataSource.options.edition.hasGeometry) {\r\n      //feature.properties[geom] = feature.geometry;\r\n      feature.properties[\"longitude\"] = feature.geometry.coordinates[0];\r\n      feature.properties[\"latitude\"] = feature.geometry.coordinates[1];\r\n    }\r\n\r\n    for (const property in feature.properties) {\r\n      for (const sf of workspace.layer.dataSource.options.sourceFields) {\r\n        if ((sf.name === property && sf.validation?.readonly) || (sf.name === property && sf.validation?.send === false)\r\n          || property === 'boundedBy') {\r\n          delete feature.properties[property];\r\n        }\r\n      }\r\n    }\r\n\r\n    this.loading = true;\r\n    this.http[protocole](`${url}`, feature.properties, { headers: headers }).subscribe(\r\n      () => {\r\n        this.loading = false;\r\n        this.cancelEdit(workspace, feature, true);\r\n\r\n        const message = this.languageService.translate.instant(\r\n          'igo.geo.workspace.modifySuccess'\r\n        );\r\n        this.messageService.success(message);\r\n\r\n        this.refreshMap(workspace.layer as VectorLayer, workspace.layer.map);\r\n\r\n        let relationLayers = [];\r\n        for (const relation of workspace.layer.options.sourceOptions.relations) {\r\n          workspace.map.layers.forEach((layer) => {\r\n            if (layer.title === relation.title) {\r\n              relationLayers.push(layer);\r\n              layer.dataSource.ol.refresh();\r\n            }\r\n          });\r\n        }\r\n        this.relationLayers$.next(relationLayers);\r\n      },\r\n      error => {\r\n        this.loading = false;\r\n        error.error.caught = true;\r\n        const genericErrorMessage = this.languageService.translate.instant(\r\n          'igo.geo.workspace.addError'\r\n        );\r\n        const messages = workspace.layer.dataSource.options.edition.messages;\r\n        if (messages) {\r\n          let text;\r\n          messages.forEach(message => {\r\n            const key = Object.keys(message)[0];\r\n            if (error.error.message.includes(key)) {\r\n              text = message[key];\r\n              this.messageService.error(text);\r\n            }\r\n          });\r\n          if (!text) {\r\n            this.messageService.error(genericErrorMessage);\r\n          }\r\n        } else {\r\n          this.messageService.error(genericErrorMessage);\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  cancelEdit(workspace: EditionWorkspace, feature, fromSave = false) {\r\n    feature.edition = false;\r\n    this.adding$.next(false);\r\n    workspace.deleteDrawings();\r\n    workspace.entityStore.stateView.clear();\r\n\r\n    if (feature.newFeature) {\r\n      workspace.entityStore.delete(feature);\r\n      workspace.deactivateDrawControl();\r\n\r\n      this.rowsInMapExtentCheckCondition$.next(true);\r\n    } else {\r\n      if (!fromSave) {\r\n        feature.properties = feature.original_properties;\r\n        feature.geometry = feature.original_geometry;\r\n      }\r\n      delete feature.original_properties;\r\n      delete feature.original_geometry;\r\n    }\r\n  }\r\n\r\n  getDomainValues(relation: RelationOptions): Observable<any> {\r\n    let url = relation.url;\r\n    if (!url) {\r\n      url = this.configService.getConfig('edition.url') + relation.table;\r\n    }\r\n\r\n    return this.http.get<any>(url).pipe(\r\n      map(result => {\r\n        return result;\r\n      }),\r\n      catchError((err: HttpErrorResponse) => {\r\n        err.error.caught = true;\r\n        return throwError(err);\r\n      })\r\n    );\r\n  }\r\n\r\n  /*\r\n   * Refresh both wms and wfs layer\r\n   * A new wfs loader is used to ensure cache is not retrieving old data\r\n   * WMS params are updated to ensure layer is correctly refreshed\r\n   */\r\n  refreshMap(layer: VectorLayer, map: IgoMap) {\r\n    const wfsOlLayer = layer.dataSource.ol;\r\n    const loader = (extent, resolution, proj, success, failure) => {\r\n      layer.customWFSLoader(\r\n        layer.ol.getSource(),\r\n        layer.options.sourceOptions,\r\n        this.authInterceptor,\r\n        extent,\r\n        resolution,\r\n        proj,\r\n        success,\r\n        failure,\r\n        true\r\n      );\r\n    };\r\n    wfsOlLayer.setLoader(loader);\r\n    wfsOlLayer.refresh();\r\n\r\n    for (const lay of map.layers) {\r\n      if (\r\n        lay.id !== layer.id &&\r\n        lay.options.linkedLayers?.linkId.includes(layer.id.substr(0, layer.id.indexOf('.') - 1)) &&\r\n        lay.options.linkedLayers?.linkId.includes('WmsWorkspaceTableSrc')\r\n      )\r\n        {\r\n          const wmsOlLayer = lay.dataSource.ol as olSourceImageWMS;\r\n          let params = wmsOlLayer.getParams();\r\n          params._t = new Date().getTime();\r\n          wmsOlLayer.updateParams(params);\r\n        }\r\n    }\r\n  }\r\n\r\n  validateFeature(feature, workspace: EditionWorkspace) {\r\n    const translate = this.languageService.translate;\r\n    let message ;\r\n    let key;\r\n    let valid = true;\r\n    workspace.meta.tableTemplate.columns.forEach(column => {\r\n      if (column.hasOwnProperty('validation') && column.validation) {\r\n        key = getColumnKeyWithoutPropertiesTag(column.name);\r\n        Object.keys( column.validation).forEach((type) => {\r\n          switch (type) {\r\n            case 'mandatory': {\r\n              if (column.validation[type] && (!feature.properties.hasOwnProperty(key) || !feature.properties[key])) {\r\n                valid = false;\r\n                  message = translate.instant('igo.geo.formValidation.mandatory',\r\n                  {\r\n                    column: column.title\r\n                  }\r\n                );\r\n                this.messageService.error(message);\r\n              }\r\n              break;\r\n            }\r\n            case 'minValue': {\r\n              if (feature.properties.hasOwnProperty(key) && feature.properties[key] && feature.properties[key] < column.validation[type]) {\r\n                valid = false;\r\n                message = translate.instant('igo.geo.formValidation.minValue',\r\n                  {\r\n                    column: column.title,\r\n                    value: column.validation[type]\r\n                  }\r\n                );\r\n                this.messageService.error(message);\r\n              }\r\n              break;\r\n            }\r\n            case 'maxValue': {\r\n              if (feature.properties.hasOwnProperty(key) && feature.properties[key] && feature.properties[key] > column.validation[type]) {\r\n                valid = false;\r\n                message = translate.instant('igo.geo.formValidation.maxValue',\r\n                  {\r\n                    column: column.title,\r\n                    value: column.validation[type]\r\n                  }\r\n                );\r\n                this.messageService.error(message);\r\n              }\r\n              break;\r\n            }\r\n            case 'minLength': {\r\n              if (\r\n                feature.properties.hasOwnProperty(key) && feature.properties[key] &&\r\n                feature.properties[key].length < column.validation[type])\r\n              {\r\n                valid = false;\r\n                message = translate.instant('igo.geo.formValidation.minLength',\r\n                  {\r\n                    column: column.title,\r\n                    value: column.validation[type]\r\n                  }\r\n                );\r\n                this.messageService.error(message);\r\n              }\r\n              break;\r\n            }\r\n            case 'maxLength': {\r\n              if (\r\n                feature.properties.hasOwnProperty(key) && feature.properties[key] &&\r\n                feature.properties[key].length > column.validation[type])\r\n              {\r\n                valid = false;\r\n                message = translate.instant('igo.geo.formValidation.maxLength',\r\n                  {\r\n                    column: column.title,\r\n                    value: column.validation[type]\r\n                  }\r\n                );\r\n                this.messageService.error(message);\r\n              }\r\n              break;\r\n            }\r\n            }\r\n          });\r\n      }\r\n    });\r\n    return valid;\r\n  }\r\n\r\n  sanitizeParameter(feature, workspace: EditionWorkspace) {\r\n    workspace.meta.tableTemplate.columns.forEach(column => {\r\n      if (column.type === 'list' && feature.properties[getColumnKeyWithoutPropertiesTag(column.name)]) {\r\n        feature.properties[getColumnKeyWithoutPropertiesTag(column.name)] =\r\n          feature.properties[getColumnKeyWithoutPropertiesTag(column.name)].toString();\r\n      }\r\n\r\n    });\r\n  }\r\n\r\n}\r\n\r\nfunction getColumnKeyWithoutPropertiesTag(column: string) {\r\n  if (column.includes('properties.')) {\r\n    return column.split('.')[1];\r\n  }\r\n  return column;\r\n}\r\n"]}