geonetwork-ui 2.2.0-dev.6695ae4d → 2.2.0-dev.70a9dc16

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,7 +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',
@@ -12,13 +13,18 @@ import { UiInputsModule } from '../../../../../../libs/ui/inputs/src'
   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/lib/map-context/map-context.service.ts

@@ -58,6 +58,8 @@ export class MapContextService {
   ): Map {
     if (mapConfig) {
       mapContext = this.mergeMapConfigWithContext(mapContext, mapConfig)
+    } else {
+      mapContext.layers = this.addDefaultBaselayerContext(mapContext.layers)
     }
     if (
       !mapContext.view?.extent &&
@@ -179,6 +181,14 @@ export class MapContextService {
     return view
   }
 
+  addDefaultBaselayerContext(
+    layers: MapContextLayerModel[]
+  ): MapContextLayerModel[] {
+    return layers.includes(DEFAULT_BASELAYER_CONTEXT)
+      ? layers
+      : [DEFAULT_BASELAYER_CONTEXT, ...layers]
+  }
+
   mergeMapConfigWithContext(
     mapContext: MapContextModel,
     mapConfig: MapConfig

package/src/libs/feature/record/src/lib/data-view-permalink/data-view-permalink.component.ts

@@ -29,18 +29,18 @@ export class DataViewPermalinkComponent {
       if (config) {
         const { aggregation, xProperty, yProperty, chartType } = config
         const url = new URL(`${this.wcEmbedderBaseUrl}`, window.location.origin)
-        url.search = `?v=${this.version}
-&e=gn-dataset-view-chart
-&a=api-url=${this.config.basePath}
-&a=dataset-id=${metadata.uniqueIdentifier}
-&a=primary-color=%230f4395
-&a=secondary-color=%238bc832
-&a=main-color=%23555
-&a=background-color=%23fdfbff
-&a=aggregation=${aggregation}
-&a=x-property=${xProperty}
-&a=y-property=${yProperty}
-&a=chart-type=${chartType}`
+        url.searchParams.set('v', `${this.version}`)
+        url.searchParams.append('e', `gn-dataset-view-chart`)
+        url.searchParams.append('a', `api-url=${this.config.basePath}`)
+        url.searchParams.append('a', `dataset-id=${metadata.uniqueIdentifier}`)
+        url.searchParams.append('a', `primary-color=#0f4395`)
+        url.searchParams.append('a', `secondary-color=#8bc832`)
+        url.searchParams.append('a', `main-color=#555`)
+        url.searchParams.append('a', `background-color=#fdfbff`)
+        url.searchParams.append('a', `aggregation=${aggregation}`)
+        url.searchParams.append('a', `x-property=${xProperty}`)
+        url.searchParams.append('a', `y-property=${yProperty}`)
+        url.searchParams.append('a', `chart-type=${chartType}`)
         return url.toString()
       }
       return ''

package/src/libs/feature/search/src/lib/favorites/favorite-star/favorite-star.component.html

@@ -1,6 +1,6 @@
-<div class="flex flex-row content-center">
+<div class="flex flex-row items-center">
   <span
-    class="align-text-top mr-1.5 mt-1.5 favorite-count"
+    class="align-text-top mr-1.5 favorite-count"
     *ngIf="hasFavoriteCount && displayCount"
     >{{ favoriteCount }}</span
   >
@@ -8,10 +8,9 @@
     [toggled]="isFavorite$ | async"
     (newValue)="toggleFavorite($event)"
     [disabled]="loading || (isAnonymous$ | async)"
-    class="mt-1"
   ></gn-ui-star-toggle>
   <span
-    class="align-text-top ml-1.5 favorite-count mt-1.5"
+    class="align-text-top ml-1.5 favorite-count"
     *ngIf="!displayCount"
     translate="datahub.record.addToFavorites"
   ></span>

package/src/libs/feature/search/src/lib/utils/service/fields.service.ts

@@ -4,12 +4,12 @@ import {
   FieldValue,
   FullTextSearchField,
   IsSpatialSearchField,
-  KeySearchField,
   LicenseSearchField,
+  MultilingualSearchField,
   OrganizationSearchField,
   OwnerSearchField,
   SimpleSearchField,
-  ThesaurusField,
+  TranslatedSearchField,
 } from './fields'
 import { forkJoin, Observable, of } from 'rxjs'
 import { map } from 'rxjs/operators'
@@ -21,6 +21,7 @@ export type FieldValues = Record<string, FieldValue[] | FieldValue>
 
 marker('search.filters.format')
 marker('search.filters.inspireKeyword')
+marker('search.filters.keyword')
 marker('search.filters.isSpatial')
 marker('search.filters.license')
 marker('search.filters.publicationYear')
@@ -37,29 +38,33 @@ marker('search.filters.contact')
 export class FieldsService {
   private fields = {
     publisher: new OrganizationSearchField(this.injector),
-    format: new SimpleSearchField('format', 'asc', this.injector),
-    resourceType: new KeySearchField('resourceType', 'asc', this.injector),
-    representationType: new KeySearchField(
+    format: new SimpleSearchField('format', this.injector, 'asc'),
+    resourceType: new TranslatedSearchField(
+      'resourceType',
+      this.injector,
+      'asc'
+    ),
+    representationType: new TranslatedSearchField(
       'cl_spatialRepresentationType.key',
-      'asc',
-      this.injector
+      this.injector,
+      'asc'
     ),
     publicationYear: new SimpleSearchField(
       'publicationYearForResource',
-      'desc',
-      this.injector
+      this.injector,
+      'desc'
     ),
-    topic: new KeySearchField('cl_topic.key', 'asc', this.injector),
-    inspireKeyword: new ThesaurusField(
+    topic: new TranslatedSearchField('cl_topic.key', this.injector, 'asc'),
+    inspireKeyword: new TranslatedSearchField(
       'th_httpinspireeceuropaeutheme-theme.link',
-      'external.theme.httpinspireeceuropaeutheme-theme',
-      'asc',
-      this.injector
+      this.injector,
+      'asc'
     ),
+    keyword: new MultilingualSearchField('tag', this.injector, 'desc', 'count'),
     documentStandard: new SimpleSearchField(
       'documentStandard',
-      'asc',
-      this.injector
+      this.injector,
+      'asc'
     ),
     isSpatial: new IsSpatialSearchField(this.injector),
     q: new FullTextSearchField(),