Refactor Edition Workspace

packages/geo/src/lib/datasource/shared/datasources/datasource.interface.ts

@@ -82,7 +82,7 @@ export interface EditionOptions {
   messages?: any[];
   addHeaders?: { [key: string]: any };
   modifyHeaders?: { [key: string]: any };
-  modifyProtocol?: string;
+  modifyMethod?: 'post' | 'patch';
   addButton?: boolean;
   modifyButton?: boolean;
   deleteButton?: boolean;
@@ -104,7 +104,6 @@ export interface SourceFieldsValidationParams {
   maxLength?: number;
   minLength?: number;
   readonly?: boolean;
-  send?: boolean;
 }
 
 export interface Legend {

packages/geo/src/lib/workspace/index.ts

@@ -5,3 +5,4 @@ export * from './workspace-selector/workspace-selector.module';
 export * from './workspace-updator/workspace-updator.directive';
 export * from './workspace-updator/workspace-updator.module';
 export * from './widgets/index';
+export * from './new-edition-workspace/new-edition-workspace';

packages/geo/src/lib/workspace/new-edition-workspace/edition-table-template-factory.ts

@@ -0,0 +1,190 @@
+import { EntityTableButton, EntityTableColumnRenderer } from '@igo2/common';
+
+import olFeature from 'ol/Feature';
+
+import { first, skipWhile } from 'rxjs';
+
+import { RelationOptions, SourceFieldsOptionsParams } from '../../datasource';
+import { VectorLayer } from '../../layer/shared';
+import { EditionFeature, NewEditionWorkspace } from './new-edition-workspace';
+
+export class EditionWorkspaceTableTemplateFactory {
+  // TODO add columns type see EntityTableColumn
+  addTemplateToWorkspace(workspace: NewEditionWorkspace, layer: VectorLayer) {
+    const buttons = this.getButtonTemplate(workspace, layer);
+
+    const fields = layer.dataSource.options.sourceFields;
+    if (!fields) {
+      return this.createEmptySourceFieldTemplate(workspace);
+    }
+
+    const sourceFieldsColumns = this.getSourceFieldsTemplate(fields);
+
+    const relations = layer.dataSource.options.relations ?? [];
+    const relationsColumns = this.getRelationsTemplate(relations);
+
+    const columns: unknown[] = sourceFieldsColumns;
+    columns.push(...relationsColumns);
+    columns.push(...buttons);
+    workspace.meta.tableTemplate = {
+      selection: false,
+      sort: true,
+      columns
+    };
+  }
+
+  private createEmptySourceFieldTemplate(workspace: NewEditionWorkspace) {
+    workspace.entityStore.entities$
+      .pipe(
+        skipWhile((val) => val.length === 0),
+        first()
+      )
+      .subscribe((entities) => {
+        const ol = entities[0].ol as olFeature;
+        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: EntityTableColumnRenderer.UnsanitizedHTML
+            };
+          });
+        workspace.meta.tableTemplate = {
+          selection: false,
+          sort: true,
+          columns: columnsFromFeatures
+        };
+      });
+  }
+
+  private getRelationsTemplate(relations: RelationOptions[]) {
+    return relations.map((relation: RelationOptions) => {
+      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: () => {
+          throw Error('Not yet implemented');
+          // if (this.adding$.getValue() === false) {
+          //   this.ws$.next(relation.title);
+          // }
+        },
+        cellClassFunc: () => {
+          return { class_icon: true };
+        }
+      };
+    });
+  }
+
+  private getSourceFieldsTemplate(fields: SourceFieldsOptionsParams[]) {
+    // TODO implement domainValues
+    //  if (field.type === 'list' || field.type === 'autocomplete') {
+
+    return fields.map((field) => {
+      return {
+        name: `properties.${field.name}`,
+        title: field.alias ? field.alias : field.name,
+        renderer: EntityTableColumnRenderer.UnsanitizedHTML,
+        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
+      };
+    });
+  }
+
+  private getButtonTemplate(
+    workspace: NewEditionWorkspace,
+    layer: VectorLayer
+  ) {
+    const confirmButton = {
+      editMode: true,
+      icon: 'check',
+      color: 'primary',
+      disabled: false,
+      click: (feature: EditionFeature) => {
+        workspace.saveFeature(feature);
+      }
+    };
+
+    const cancelButton = {
+      editMode: true,
+      icon: 'alpha-x',
+      color: 'primary',
+      disabled: false,
+      click: (feature: EditionFeature) => {
+        workspace.cancelEdit(feature);
+      }
+    };
+
+    workspace.isLoading$.subscribe((isLoading) => {
+      confirmButton.disabled = isLoading;
+      cancelButton.disabled = isLoading;
+    });
+
+    return [
+      {
+        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: EditionFeature) => {
+                workspace.updateFeature(feature);
+              }
+            },
+            {
+              editMode: false,
+              icon: 'delete',
+              color: 'warn',
+              disabled:
+                layer.dataSource.options.edition.deleteButton === false
+                  ? true
+                  : false,
+              click: (feature: EditionFeature) => {
+                workspace.deleteFeature(feature);
+              }
+            },
+            confirmButton,
+            cancelButton
+          ] as EntityTableButton[];
+        }
+      }
+    ];
+  }
+}

packages/geo/src/lib/workspace/new-edition-workspace/edition-workspace-factory.service.spec.ts

@@ -0,0 +1,68 @@
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+import { TestBed } from '@angular/core/testing';
+import { MatDialogModule } from '@angular/material/dialog';
+
+import { ConfigService } from '@igo2/core/config';
+import { MessageService } from '@igo2/core/message';
+import { StorageService } from '@igo2/core/storage';
+import {
+  DataSourceOptions,
+  FeatureDataSource,
+  NewEditionWorkspace
+} from '@igo2/geo';
+
+import { VectorLayer } from '../../layer/shared';
+import { IgoMap } from '../../map/shared';
+import { EditionWorkspaceFactoryService } from './edition-workspace-factory.service';
+import { createTestIgoMap } from './tests.utils';
+
+describe('EditionWorkspaceFactoryService', () => {
+  let service: EditionWorkspaceFactoryService;
+  let map: IgoMap;
+
+  const dataSourceOptions: DataSourceOptions = {
+    type: 'wfs',
+    edition: {
+      enabled: true,
+      baseUrl: 'http://testing.com',
+      addUrl: '/',
+      modifyUrl: '/',
+      deleteUrl: '/',
+      geomType: 'Point',
+      hasGeometry: true
+    }
+  };
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule, MatDialogModule],
+      providers: [
+        {
+          provide: StorageService,
+          useValue: jasmine.createSpyObj(StorageService, ['get'])
+        },
+        {
+          provide: ConfigService,
+          useValue: jasmine.createSpyObj(ConfigService, ['getConfig'])
+        },
+        { provide: MessageService, useValue: {} }
+      ]
+    });
+    map = createTestIgoMap();
+    map.init();
+    service = TestBed.inject(EditionWorkspaceFactoryService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should create a WFSEditionWorkspace', () => {
+    const layer = new VectorLayer({
+      source: new FeatureDataSource(dataSourceOptions)
+    });
+    map.addLayer(layer);
+    const workspace = service.createWFSEditionWorkspace(layer, map);
+    expect(workspace).toBeInstanceOf(NewEditionWorkspace);
+  });
+});

packages/geo/src/lib/workspace/new-edition-workspace/edition-workspace-factory.service.ts

@@ -0,0 +1,116 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+
+import { ActionStore, EntityStoreFilterSelectionStrategy } from '@igo2/common';
+import { ConfigService } from '@igo2/core/config';
+import { MessageService } from '@igo2/core/message';
+import { StorageService } from '@igo2/core/storage';
+
+import { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';
+import {
+  FeatureMotion,
+  FeatureStore,
+  FeatureStoreInMapExtentStrategy,
+  FeatureStoreInMapResolutionStrategy,
+  FeatureStoreLoadingLayerStrategy,
+  FeatureStoreSelectionStrategy
+} from '../../feature/shared';
+import {
+  GeoWorkspaceOptions,
+  ImageLayer,
+  VectorLayer
+} from '../../layer/shared';
+import { IgoMap } from '../../map/shared';
+import { createFilterInMapExtentOrResolutionStrategy } from '../shared/workspace.utils';
+import { EditionWorkspaceTableTemplateFactory } from './edition-table-template-factory';
+import { NewEditionWorkspace } from './new-edition-workspace';
+import { RestAPIEdition } from './rest-api-edition';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class EditionWorkspaceFactoryService {
+  get zoomAuto(): boolean {
+    return this.storageService.get('zoomAuto') as boolean;
+  }
+
+  private tableTemplateFactory = new EditionWorkspaceTableTemplateFactory();
+
+  constructor(
+    private http: HttpClient,
+    private storageService: StorageService,
+    private configService: ConfigService,
+    private messageService: MessageService,
+    private dialog: MatDialog
+  ) {}
+
+  createWFSEditionWorkspace(
+    layer: VectorLayer,
+    map: IgoMap
+  ): NewEditionWorkspace {
+    const workspace = new RestAPIEdition(
+      this.http,
+      this.dialog,
+      this.messageService,
+      {
+        id: layer.id,
+        title: layer.title,
+        layer,
+        map,
+        editionUrl: this.getEditionUrl(layer),
+        entityStore: this.createFeatureStore(layer, map),
+        actionStore: new ActionStore([]),
+        meta: {
+          tableTemplate: undefined
+        }
+      }
+    );
+
+    this.tableTemplateFactory.addTemplateToWorkspace(workspace, layer);
+    layer.options.workspace = Object.assign({}, layer.options.workspace, {
+      srcId: layer.id,
+      workspaceId: layer.id,
+      enabled: true
+    } as GeoWorkspaceOptions);
+    return workspace;
+  }
+
+  private createFeatureStore(layer: VectorLayer, map: IgoMap): FeatureStore {
+    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
+    }); // TODO check if usefull
+    store.addStrategy(loadingStrategy, true);
+    store.addStrategy(inMapExtentStrategy, true);
+    store.addStrategy(inMapResolutionStrategy, true);
+    store.addStrategy(selectionStrategy, true);
+    store.addStrategy(selectedRecordStrategy, false);
+    store.addStrategy(createFilterInMapExtentOrResolutionStrategy(), true);
+    return store;
+  }
+
+  private getEditionUrl(layer: VectorLayer | ImageLayer): string {
+    const editionUrl = layer.dataSource.options.edition.baseUrl;
+    const baseUrl = this.configService.getConfig('edition.url');
+    return !baseUrl ? editionUrl : new URL(editionUrl, baseUrl).href;
+  }
+}