geonetwork-ui 2.2.0-dev.f866474c → 2.2.0

package/src/libs/feature/editor/src/lib/+state/editor.actions.ts

@@ -0,0 +1,24 @@
+import { createAction, props } from '@ngrx/store'
+import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
+import { SaveRecordError } from './editor.models'
+
+export const openRecord = createAction(
+  '[Editor] Open record',
+  props<{ record: CatalogRecord }>()
+)
+
+export const updateRecordField = createAction(
+  '[Editor] Update record field',
+  props<{ field: string; value: unknown }>()
+)
+
+export const markRecordAsChanged = createAction(
+  '[Editor] Mark record as changed'
+)
+
+export const saveRecord = createAction('[Editor] Save record')
+export const saveRecordSuccess = createAction('[Editor] Save record success')
+export const saveRecordFailure = createAction(
+  '[Editor] Save record failure',
+  props<{ error: SaveRecordError }>()
+)

package/src/libs/feature/editor/src/lib/+state/editor.effects.ts

@@ -0,0 +1,49 @@
+import { inject, Injectable } from '@angular/core'
+import { Actions, createEffect, ofType } from '@ngrx/effects'
+import { of, withLatestFrom } from 'rxjs'
+import { catchError, map, switchMap } from 'rxjs/operators'
+import * as EditorActions from './editor.actions'
+import { EditorService } from '../services/editor.service'
+import { Store } from '@ngrx/store'
+import { selectRecord, selectRecordFieldsConfig } from './editor.selectors'
+
+@Injectable()
+export class EditorEffects {
+  private actions$ = inject(Actions)
+  private editorService = inject(EditorService)
+  private store = inject(Store)
+
+  saveRecord$ = createEffect(() =>
+    this.actions$.pipe(
+      ofType(EditorActions.saveRecord),
+      withLatestFrom(
+        this.store.select(selectRecord),
+        this.store.select(selectRecordFieldsConfig)
+      ),
+      switchMap(([, record, fieldsConfig]) =>
+        this.editorService.saveRecord(record, fieldsConfig).pipe(
+          switchMap((newRecord) =>
+            of(
+              EditorActions.saveRecordSuccess(),
+              EditorActions.openRecord({ record: newRecord })
+            )
+          ),
+          catchError((error) =>
+            of(
+              EditorActions.saveRecordFailure({
+                error: error.message,
+              })
+            )
+          )
+        )
+      )
+    )
+  )
+
+  markAsChanged$ = createEffect(() =>
+    this.actions$.pipe(
+      ofType(EditorActions.updateRecordField),
+      map(() => EditorActions.markRecordAsChanged())
+    )
+  )
+}

package/src/libs/feature/editor/src/lib/+state/editor.facade.ts

@@ -0,0 +1,30 @@
+import { inject, Injectable } from '@angular/core'
+import { select, Store } from '@ngrx/store'
+import * as EditorActions from './editor.actions'
+import * as EditorSelectors from './editor.selectors'
+import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
+
+@Injectable()
+export class EditorFacade {
+  private readonly store = inject(Store)
+
+  record$ = this.store.pipe(select(EditorSelectors.selectRecord))
+  saving$ = this.store.pipe(select(EditorSelectors.selectRecordSaving))
+  saveError$ = this.store.pipe(select(EditorSelectors.selectRecordSaveError))
+  changedSinceSave$ = this.store.pipe(
+    select(EditorSelectors.selectRecordChangedSinceSave)
+  )
+  recordFields$ = this.store.pipe(select(EditorSelectors.selectRecordFields))
+
+  openRecord(record: CatalogRecord) {
+    this.store.dispatch(EditorActions.openRecord({ record }))
+  }
+
+  saveRecord() {
+    this.store.dispatch(EditorActions.saveRecord())
+  }
+
+  updateRecordField(field: string, value: unknown) {
+    this.store.dispatch(EditorActions.updateRecordField({ field, value }))
+  }
+}

package/src/libs/feature/editor/src/lib/+state/editor.models.ts

@@ -0,0 +1 @@
+export type SaveRecordError = string

package/src/libs/feature/editor/src/lib/+state/editor.reducer.ts

@@ -0,0 +1,68 @@
+import { Action, createReducer, on } from '@ngrx/store'
+import * as EditorActions from './editor.actions'
+import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
+import { SaveRecordError } from './editor.models'
+import { EditorFieldsConfig } from '../models/fields.model'
+import { DEFAULT_FIELDS } from '../fields.config'
+
+export const EDITOR_FEATURE_KEY = 'editor'
+
+export interface EditorState {
+  record: CatalogRecord | null
+  saving: boolean
+  saveError: SaveRecordError | null
+  changedSinceSave: boolean
+  fieldsConfig: EditorFieldsConfig
+}
+
+export interface EditorPartialState {
+  readonly [EDITOR_FEATURE_KEY]: EditorState
+}
+
+export const initialEditorState: EditorState = {
+  record: null,
+  saving: false,
+  saveError: null,
+  changedSinceSave: false,
+  fieldsConfig: DEFAULT_FIELDS,
+}
+
+const reducer = createReducer(
+  initialEditorState,
+  on(EditorActions.openRecord, (state, { record }) => ({
+    ...state,
+    changedSinceSave: false,
+    record,
+  })),
+  on(EditorActions.saveRecord, (state) => ({
+    ...state,
+    saving: true,
+    saveError: null,
+  })),
+  on(EditorActions.saveRecordSuccess, (state) => ({
+    ...state,
+    saving: false,
+    saveError: null,
+    changedSinceSave: false,
+  })),
+  on(EditorActions.saveRecordFailure, (state, { error }) => ({
+    ...state,
+    saving: false,
+    saveError: error,
+  })),
+  on(EditorActions.updateRecordField, (state, { field, value }) => ({
+    ...state,
+    record: {
+      ...state.record,
+      [field]: value,
+    },
+  })),
+  on(EditorActions.markRecordAsChanged, (state) => ({
+    ...state,
+    changedSinceSave: true,
+  }))
+)
+
+export function editorReducer(state: EditorState | undefined, action: Action) {
+  return reducer(state, action)
+}

package/src/libs/feature/editor/src/lib/+state/editor.selectors.ts

@@ -0,0 +1,39 @@
+import { createFeatureSelector, createSelector } from '@ngrx/store'
+import { EDITOR_FEATURE_KEY, EditorState } from './editor.reducer'
+
+export const selectEditorState =
+  createFeatureSelector<EditorState>(EDITOR_FEATURE_KEY)
+
+export const selectRecord = createSelector(
+  selectEditorState,
+  (state: EditorState) => state.record
+)
+
+export const selectRecordSaving = createSelector(
+  selectEditorState,
+  (state: EditorState) => state.saving
+)
+
+export const selectRecordSaveError = createSelector(
+  selectEditorState,
+  (state: EditorState) => state.saveError
+)
+
+export const selectRecordChangedSinceSave = createSelector(
+  selectEditorState,
+  (state: EditorState) => state.changedSinceSave
+)
+
+export const selectRecordFieldsConfig = createSelector(
+  selectEditorState,
+  (state: EditorState) => state.fieldsConfig
+)
+
+export const selectRecordFields = createSelector(
+  selectEditorState,
+  (state: EditorState) =>
+    state.fieldsConfig.map((fieldConfig) => ({
+      config: fieldConfig,
+      value: state.record?.[fieldConfig.model] || null,
+    }))
+)

package/src/libs/feature/editor/src/lib/expressions.ts

@@ -0,0 +1,16 @@
+import { EditorFieldState, EditorFieldValue } from './models/fields.model'
+
+export type ExpressionEvaluator = (field: EditorFieldState) => EditorFieldValue
+
+export function evaluate(expression: string): ExpressionEvaluator {
+  if (expression.match(/^\${.*}$/)) {
+    return evaluate(expression.slice(2, -1))
+  }
+  const operator = expression.split('(')[0]
+  switch (operator) {
+    case 'dateNow':
+      return () => new Date()
+    default:
+      throw new Error(`Unknown operator: ${operator}`)
+  }
+}

package/src/libs/feature/editor/src/lib/feature-editor.module.ts

@@ -10,6 +10,11 @@ import { TranslateModule } from '@ngx-translate/core'
 import { WizardSummarizeComponent } from './components/wizard-summarize/wizard-summarize.component'
 import { CommonModule } from '@angular/common'
 import { HttpClientModule, HttpClientXsrfModule } from '@angular/common/http'
+import { StoreModule } from '@ngrx/store'
+import { EffectsModule } from '@ngrx/effects'
+import * as fromEditor from './+state/editor.reducer'
+import { EditorEffects } from './+state/editor.effects'
+import { EditorFacade } from './+state/editor.facade'
 
 @NgModule({
   declarations: [
@@ -27,8 +32,14 @@ import { HttpClientModule, HttpClientXsrfModule } from '@angular/common/http'
     MatFormFieldModule,
     HttpClientModule,
     HttpClientXsrfModule,
+    StoreModule.forFeature(
+      fromEditor.EDITOR_FEATURE_KEY,
+      fromEditor.editorReducer
+    ),
+    EffectsModule.forFeature([EditorEffects]),
   ],
   exports: [WizardComponent, WizardSummarizeComponent],
+  providers: [EditorFacade],
 })
 export class FeatureEditorModule {}
 export * from './services/wizard.service'

package/src/libs/feature/editor/src/lib/fields.config.ts

@@ -0,0 +1,35 @@
+import { EditorFieldsConfig } from './models/fields.model'
+
+export const DEFAULT_FIELDS: EditorFieldsConfig = [
+  {
+    model: 'title',
+    formFieldConfig: {
+      labelKey: 'Metadata title',
+      type: 'text',
+    },
+  },
+  {
+    model: 'abstract',
+    formFieldConfig: {
+      labelKey: 'Abstract',
+      type: 'rich',
+    },
+  },
+  {
+    model: 'uniqueIdentifier',
+    formFieldConfig: {
+      labelKey: 'Unique identifier',
+      type: 'text',
+      locked: true,
+    },
+  },
+  {
+    model: 'recordUpdated',
+    formFieldConfig: {
+      labelKey: 'Record Updated',
+      type: 'text',
+      locked: true,
+    },
+    onSaveProcess: '${dateNow()}',
+  },
+]

package/src/libs/feature/editor/src/lib/models/fields.model.ts

@@ -0,0 +1,29 @@
+import { FormFieldConfig } from '../../../../../../libs/ui/inputs/src'
+
+// Expressions should be enclosed in `${}` to be recognized as such
+// eg. ${dateNow()}
+export type EditorFieldExpression = `$\{${string}}`
+
+export interface EditorFieldConfig {
+  // configuration of the form field used as presentation; optional, nothing shown if not defined
+  formFieldConfig?: FormFieldConfig
+
+  // name of the target field in the record; will not change the record directly if not defined
+  model?: string
+
+  // a hidden field won't show but can still be used to modify the record
+  // FIXME: currently this is redundant with an absence of formFieldConfig but necessary for clarity
+  hidden?: boolean
+
+  // the result of this expression will replace the field value on save
+  onSaveProcess?: EditorFieldExpression
+}
+
+export type EditorFieldsConfig = EditorFieldConfig[]
+
+export type EditorFieldValue = string | number | boolean | unknown
+
+export interface EditorFieldState {
+  config: EditorFieldConfig
+  value: string | number | boolean | unknown
+}

package/src/libs/feature/editor/src/lib/record-form/record-form.component.html

@@ -1,8 +1,10 @@
-<div class="flex flex-col gap-6">
-  <gn-ui-form-field
-    *ngFor="let field of editorService.fields$ | async; trackBy: fieldTracker"
-    [config]="field.config"
-    [value]="field.value"
-    (valueChange)="handleFieldValueChange(field.config.model, $event)"
-  ></gn-ui-form-field>
+<div class="flex flex-col gap-6 p-6">
+  <ng-container *ngFor="let field of fields$ | async; trackBy: fieldTracker">
+    <gn-ui-form-field
+      *ngIf="field.config.formFieldConfig && !field.config.hidden"
+      [config]="field.config.formFieldConfig"
+      [value]="field.value"
+      (valueChange)="handleFieldValueChange(field, $event)"
+    ></gn-ui-form-field>
+  </ng-container>
 </div>

package/src/libs/feature/editor/src/lib/record-form/record-form.component.ts

@@ -1,6 +1,8 @@
 import { CommonModule } from '@angular/common'
 import { ChangeDetectionStrategy, Component } from '@angular/core'
-import { EditorService, FormField } from '../services/editor.service'
+import { UiInputsModule } from '../../../../../../libs/ui/inputs/src'
+import { EditorFacade } from '../+state/editor.facade'
+import { EditorFieldState, EditorFieldValue } from '../models/fields.model'
 
 @Component({
   selector: 'gn-ui-record-form',
@@ -8,16 +10,21 @@ import { EditorService, FormField } from '../services/editor.service'
   styleUrls: ['./record-form.component.css'],
   changeDetection: ChangeDetectionStrategy.OnPush,
   standalone: true,
-  imports: [CommonModule],
+  imports: [CommonModule, UiInputsModule],
 })
 export class RecordFormComponent {
-  constructor(public editorService: EditorService) {}
+  fields$ = this.facade.recordFields$
 
-  handleFieldValueChange(fieldName: string, value: unknown) {
-    this.editorService.updateRecordField(fieldName, value)
+  constructor(public facade: EditorFacade) {}
+
+  handleFieldValueChange(field: EditorFieldState, newValue: EditorFieldValue) {
+    if (!field.config.model) {
+      return
+    }
+    this.facade.updateRecordField(field.config.model, newValue)
   }
 
-  fieldTracker(index: number, field: FormField) {
+  fieldTracker(index: number, field: EditorFieldState) {
     return field.config.model
   }
 }

package/src/libs/feature/editor/src/lib/services/editor.service.ts

@@ -1,59 +1,27 @@
 import { Inject, Injectable, Optional } from '@angular/core'
 import { toModel, toXml } from '../../../../../../libs/api/metadata-converter/src'
 import { Configuration } from '../../../../../../libs/data-access/gn4/src'
-import { BehaviorSubject, Observable } from 'rxjs'
-import { finalize, map, switchMap, take, tap } from 'rxjs/operators'
+import { Observable } from 'rxjs'
+import { map } from 'rxjs/operators'
 import { HttpClient } from '@angular/common/http'
-import { FormFieldConfig } from '../../../../../../libs/ui/inputs/src'
 import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
-
-export interface FormField {
-  config: FormFieldConfig
-  value: string | number | boolean | unknown
-}
+import { EditorFieldsConfig } from '../models/fields.model'
+import { evaluate } from '../expressions'
 
 @Injectable({
   providedIn: 'root',
 })
 export class EditorService {
-  private record$ = new BehaviorSubject<CatalogRecord | null>(null)
-  private fieldsConfig: FormFieldConfig[] = [
-    {
-      model: 'title',
-      labelKey: 'Metadata title',
-      type: 'text',
-    },
-    {
-      model: 'abstract',
-      labelKey: 'Abstract',
-      type: 'rich',
-    },
-    {
-      model: 'uniqueIdentifier',
-      labelKey: 'Unique identifier',
-      type: 'text',
-      locked: true,
-    },
-  ]
-
   private apiUrl = `${this.apiConfiguration?.basePath || '/geonetwork/srv/api'}`
 
-  fields$: Observable<FormField[]> = this.record$.pipe(
-    map((record) =>
-      this.fieldsConfig.map((fieldConfig) => ({
-        config: fieldConfig,
-        value: record?.[fieldConfig.model] || null,
-      }))
-    )
-  )
-  saving$ = new BehaviorSubject(false)
-
   constructor(
     private http: HttpClient,
     @Optional()
     @Inject(Configuration)
     private apiConfiguration: Configuration
   ) {}
+
+  // TODO: use the catalog repository instead
   loadRecordByUuid(uuid: string): Observable<CatalogRecord> {
     return this.http
       .get(`${this.apiUrl}/records/${uuid}/formatters/xml`, {
@@ -65,43 +33,36 @@ export class EditorService {
       .pipe(map((response) => toModel(response.toString())))
   }
 
-  saveCurrentRecord(): Observable<void> {
-    return this.record$.pipe(
-      take(1),
-      tap((record) => {
-        if (!record)
-          throw new Error('Save record failed: no record currently open')
-        this.saving$.next(true)
-      }),
-      switchMap((record) =>
-        this.http.put(
-          `${this.apiUrl}/records?metadataType=METADATA&uuidProcessing=OVERWRITE&transformWith=_none_&publishToAll=on`,
-          toXml(record),
-          {
-            headers: {
-              'Content-Type': 'application/xml',
-            },
-            withCredentials: true,
-          }
-        )
-      ),
-      map(() => undefined),
-      finalize(() => {
-        this.saving$.next(false)
-      })
-    )
-  }
+  // returns the record as it was when saved
+  saveRecord(
+    record: CatalogRecord,
+    fieldsConfig: EditorFieldsConfig
+  ): Observable<CatalogRecord> {
+    const savedRecord = { ...record }
 
-  setCurrentRecord(record: CatalogRecord) {
-    this.record$.next(record)
-  }
+    // run onSave processes
+    for (const field of fieldsConfig) {
+      if (field.onSaveProcess && field.model) {
+        const evaluator = evaluate(field.onSaveProcess)
+        savedRecord[field.model] = evaluator({
+          config: field,
+          value: record[field.model],
+        })
+      }
+    }
 
-  updateRecordField(fieldName: string, value: unknown) {
-    this.record$
-      .pipe(
-        take(1),
-        map((record) => ({ ...record, [fieldName]: value }))
+    // TODO: use the catalog repository instead
+    return this.http
+      .put(
+        `${this.apiUrl}/records?metadataType=METADATA&uuidProcessing=OVERWRITE&transformWith=_none_&publishToAll=on`,
+        toXml(savedRecord),
+        {
+          headers: {
+            'Content-Type': 'application/xml',
+          },
+          withCredentials: true,
+        }
       )
-      .subscribe((record) => this.record$.next(record))
+      .pipe(map(() => savedRecord))
   }
 }

package/src/libs/feature/map/src/index.ts

@@ -17,3 +17,4 @@ export * from './lib/layers-panel/layers-panel.component'
 export * from './lib/add-layer-from-catalog/add-layer-from-catalog.component'
 export * from './lib/add-layer-from-catalog/add-layer-record-preview/add-layer-record-preview.component'
 export * from './lib/map-container/map-container.component'
+export * from './lib/geocoding/geocoding.component'

package/src/libs/feature/map/src/lib/add-layer-from-file/add-layer-from-file.component.html

@@ -0,0 +1,21 @@
+<div class="flex flex-col gap-2 my-2">
+  <div class="flex items-center gap-4">
+    <div class="flex-grow rounded-md border-2 border-gray-200">
+      <gn-ui-drag-and-drop-file-input
+        (fileChange)="handleFileChange($event)"
+        [accept]="acceptedMimeType.join(',')"
+        [placeholder]="'map.addFromFile.placeholder' | translate"
+        class="placeholder-grey"
+      ></gn-ui-drag-and-drop-file-input>
+    </div>
+  </div>
+  <p class="text-sm text-gray-600" translate>map.help.addFromFile</p>
+</div>
+
+<div *ngIf="errorMessage" class="text-red-500 mt-2">
+  {{ errorMessage }}
+</div>
+
+<div *ngIf="successMessage" class="text-green-500 mt-2">
+  {{ successMessage }}
+</div>

package/src/libs/feature/map/src/lib/add-layer-from-file/add-layer-from-file.component.ts

@@ -0,0 +1,107 @@
+import { ChangeDetectorRef, Component } from '@angular/core'
+import { MapContextLayerModel } from '../map-context/map-context.model'
+import { MapFacade } from '../+state/map.facade'
+
+const INVALID_FILE_FORMAT_ERROR_MESSAGE = 'Invalid file format'
+
+@Component({
+  selector: 'gn-ui-add-layer-from-file',
+  templateUrl: './add-layer-from-file.component.html',
+  styleUrls: ['./add-layer-from-file.component.css'],
+})
+export class AddLayerFromFileComponent {
+  errorMessage: string | null = null
+  successMessage: string | null = null
+  loading = false
+  readonly acceptedMimeType = ['.geojson']
+  readonly maxFileSize = 5000000
+
+  constructor(
+    private mapFacade: MapFacade,
+    private changeDetectorRef: ChangeDetectorRef
+  ) {}
+
+  async handleFileChange(file: File) {
+    if (!file) {
+      this.displayMessage(INVALID_FILE_FORMAT_ERROR_MESSAGE, 'error')
+      return
+    }
+    if (file.size > this.maxFileSize) {
+      this.displayMessage('File size exceeds the limit of 5MB', 'error')
+      return
+    }
+    await this.addLayer(file)
+  }
+
+  private async addLayer(file: File) {
+    this.errorMessage = null
+    this.loading = true
+    try {
+      if (!this.isFileFormatValid(file)) {
+        this.displayMessage(INVALID_FILE_FORMAT_ERROR_MESSAGE, 'error')
+        return
+      }
+
+      const fileExtension = this.getFileExtension(file)
+      switch (fileExtension) {
+        case 'geojson':
+          await this.addGeoJsonLayer(file)
+          break
+        default:
+          this.displayMessage(INVALID_FILE_FORMAT_ERROR_MESSAGE, 'error')
+          break
+      }
+    } catch (error) {
+      const err = error as Error
+      this.displayMessage('Error loading file: ' + err.message, 'error')
+    } finally {
+      this.loading = false
+    }
+  }
+
+  private addGeoJsonLayer(file: File) {
+    return new Promise<void>((resolve, reject) => {
+      try {
+        const reader = new FileReader()
+        reader.onload = () => {
+          const result = reader.result as string
+          const title = file.name.split('.').slice(0, -1).join('.')
+          const layerToAdd: MapContextLayerModel = {
+            type: 'geojson',
+            data: result,
+          }
+          this.mapFacade.addLayer({ ...layerToAdd, title: title })
+          this.displayMessage('File successfully added to map', 'success')
+          resolve()
+        }
+        reader.onerror = reject
+        reader.readAsText(file)
+      } catch (error) {
+        reject(error)
+      }
+    })
+  }
+
+  private isFileFormatValid(file: File): boolean {
+    const fileExtension = this.getFileExtension(file)
+    return this.acceptedMimeType.includes(`.${fileExtension}`)
+  }
+
+  private getFileExtension(file: File): string | undefined {
+    return file.name.split('.').pop()
+  }
+
+  private displayMessage(message: string, type: 'success' | 'error') {
+    if (type === 'success') {
+      this.successMessage = message
+    } else if (type === 'error') {
+      this.errorMessage = message
+    }
+
+    setTimeout(() => {
+      this.successMessage = null
+      this.errorMessage = null
+      this.changeDetectorRef.detectChanges()
+    }, 5000)
+  }
+}