geonetwork-ui 2.2.0-dev.723017a4 → 2.2.0-dev.751c5530

package/src/libs/api/metadata-converter/src/lib/fixtures/geocat-ch.records.ts

@@ -27,6 +27,7 @@ export const GEOCAT_CH_DATASET_RECORD: DatasetRecord = {
   ],
   contactsForResource: [],
   recordCreated: new Date('2022-02-22T19:40:06'),
+  recordPublished: new Date('2022-02-22T19:40:06'),
   recordUpdated: new Date('2022-02-22T19:40:06'),
   datasetCreated: new Date('1999-01-01T00:00:00'),
   datasetUpdated: new Date('2009-01-01'),
@@ -327,6 +328,7 @@ Die Quelle ist zu bezeichnen: „Quelle: Stadt Zürich“.`,
   temporalExtents: [],
   status: 'completed',
   updateFrequency: 'asNeeded',
+  languages: [],
 }
 
 export const GEOCAT_CH_SERVICE_RECORD: ServiceRecord = {
@@ -359,6 +361,7 @@ export const GEOCAT_CH_SERVICE_RECORD: ServiceRecord = {
     },
   ],
   recordCreated: new Date('2022-03-07T01:15:51+01:00'),
+  recordPublished: new Date('2022-03-07T01:15:51+01:00'),
   recordUpdated: new Date('2022-03-07T01:15:51+01:00'),
   title: 'Verkehrsregelungsanlagen (WMS)',
   abstract: `Diese Karte beinhaltet die Verkehrsregelungsanlagen des Kantons St.Gallen.`,
@@ -420,4 +423,5 @@ export const GEOCAT_CH_SERVICE_RECORD: ServiceRecord = {
   legalConstraints: [],
   securityConstraints: [],
   otherConstraints: [],
+  languages: [],
 }

package/src/libs/api/metadata-converter/src/lib/gn4/gn4.field.mapper.ts

@@ -28,8 +28,8 @@ import {
   OnlineLinkResource,
 } from '../../../../../../libs/common/domain/src/lib/model/record'
 import { matchProtocol } from '../common/distribution.mapper'
-import { LangService } from '../../../../../../libs/util/i18n/src'
 import { Thesaurus } from './types'
+import { LANG_3_TO_2_MAPPER, LangService } from '../../../../../../libs/util/i18n/src'
 
 type ESResponseSource = SourceWithUnknownProps
 
@@ -132,6 +132,22 @@ export class Gn4FieldMapper {
       ...output,
       recordUpdated: toDate(selectField<string>(source, 'changeDate')),
     }),
+    publicationDateForResource: (output, source) => ({
+      ...output,
+      recordPublished: toDate(
+        selectField<string>(source, 'publicationDateForResource')
+      ),
+    }),
+    resourceLanguage: (output, source) => {
+      const langList = getAsArray(
+        selectField<string>(source, 'resourceLanguage')
+      )
+      const languages = langList.map((lang) => LANG_3_TO_2_MAPPER[lang])
+      return {
+        ...output,
+        languages,
+      }
+    },
     link: (output, source) => {
       const rawLinks = getAsArray(
         selectField<SourceWithUnknownProps[]>(source, 'link')
@@ -292,9 +308,9 @@ export class Gn4FieldMapper {
         ],
       }
     },
-    resourceTemporalDateRange: (output, source) => {
+    resourceTemporalExtentDateRange: (output, source) => {
       const ranges = getAsArray(
-        selectField(source, 'resourceTemporalDateRange')
+        selectField(source, 'resourceTemporalExtentDateRange')
       )
       return {
         ...output,

package/src/libs/api/metadata-converter/src/lib/gn4/gn4.metadata.mapper.ts

@@ -24,6 +24,7 @@ export class Gn4MetadataMapper extends MetadataBaseMapper<Gn4Record> {
       status: null,
       lineage: null,
       recordUpdated: null,
+      recordPublished: null,
       ownerOrganization: null,
       licenses: [],
       legalConstraints: [],
@@ -36,6 +37,7 @@ export class Gn4MetadataMapper extends MetadataBaseMapper<Gn4Record> {
       spatialExtents: [],
       temporalExtents: [],
       overviews: [],
+      languages: [],
     }
     const record: CatalogRecord = Object.keys(_source).reduce(
       (prev, fieldName) =>

package/src/libs/api/metadata-converter/src/lib/gn4/types/metadata.model.ts

@@ -150,6 +150,7 @@ export type MetadataObject = Partial<{
   pointOfContactOrg: string
   pointOfContactOrgForResource: string
   popularity: number
+  publicationDateForResource: string
   rating: string
   record: string
   recordGroup: string

package/src/libs/api/metadata-converter/src/lib/iso19139/converter.ts

@@ -51,6 +51,7 @@ import {
   readOverviews,
   readOwnerOrganization,
   readRecordUpdated,
+  readRecordPublished,
   readSecurityConstraints,
   readSpatialExtents,
   readSpatialRepresentation,
@@ -74,6 +75,7 @@ export function toModel(xml: string): CatalogRecord {
   const contacts = readContacts(rootEl)
   const recordUpdated = readRecordUpdated(rootEl)
   const recordCreated = recordUpdated
+  const recordPublished = readRecordPublished(rootEl)
   const keywords = readKeywords(rootEl)
   const topics = readIsoTopics(rootEl)
   const legalConstraints = readLegalConstraints(rootEl)
@@ -96,8 +98,10 @@ export function toModel(xml: string): CatalogRecord {
     return {
       uniqueIdentifier,
       kind,
+      languages: [],
       recordCreated,
       recordUpdated,
+      recordPublished,
       status,
       title,
       abstract,
@@ -125,8 +129,10 @@ export function toModel(xml: string): CatalogRecord {
     return {
       uniqueIdentifier,
       kind,
+      languages: [],
       recordCreated,
       recordUpdated,
+      recordPublished,
       title,
       abstract,
       ownerOrganization,

package/src/libs/api/metadata-converter/src/lib/iso19139/read-parts.ts

@@ -450,7 +450,7 @@ function findIdentification() {
   }
 }
 
-function extractCitationDate(type: 'creation' | 'revision') {
+function extractCitationDate(type: 'creation' | 'revision' | 'publication') {
   return pipe(
     findIdentification(),
     findNestedElements('gmd:citation', 'gmd:CI_Citation', 'gmd:date'),
@@ -517,6 +517,10 @@ export function readRecordUpdated(rootEl: XmlElement): Date {
   return pipe(findChildElement('gmd:dateStamp'), extractDateTime())(rootEl)
 }
 
+export function readRecordPublished(rootEl: XmlElement): Date {
+  return pipe(findChildElement('gmd:dateStamp'), extractDateTime())(rootEl)
+}
+
 export function readTitle(rootEl: XmlElement): string {
   return pipe(
     findIdentification(),

package/src/libs/api/metadata-converter/src/lib/iso19139/write-parts.ts

@@ -291,7 +291,10 @@ function appendResponsibleParty(contact: Individual) {
   )
 }
 
-function updateCitationDate(date: Date, type: 'revision' | 'creation') {
+function updateCitationDate(
+  date: Date,
+  type: 'revision' | 'creation' | 'publication'
+) {
   return pipe(
     findNestedElements('gmd:date', 'gmd:CI_Date'),
     filterArray(
@@ -308,7 +311,10 @@ function updateCitationDate(date: Date, type: 'revision' | 'creation') {
   )
 }
 
-function appendCitationDate(date, type: 'revision' | 'creation') {
+function appendCitationDate(
+  date,
+  type: 'revision' | 'creation' | 'publication'
+) {
   return appendChildren(
     pipe(
       createElement('gmd:date'),

package/src/libs/api/repository/src/lib/gn4/elasticsearch/elasticsearch.service.ts

@@ -133,7 +133,7 @@ export class ElasticsearchService {
     title: string,
     uuid: string,
     size = 6,
-    _source = ES_SOURCE_SUMMARY
+    _source = [...ES_SOURCE_SUMMARY, 'allKeywords', 'createDate']
   ): EsSearchParams {
     return {
       query: {

package/src/libs/common/domain/src/lib/model/record/metadata.model.ts

@@ -73,6 +73,8 @@ export interface Keyword {
   type: KeywordType
   thesaurus?: KeywordThesaurus
 }
+// languages should be expressed using two-letters ISO 639-1 codes
+export type LanguageCode = string
 
 export interface BaseRecord {
   uniqueIdentifier: Uuid
@@ -82,6 +84,8 @@ export interface BaseRecord {
   abstract: string
   recordCreated?: Date
   recordUpdated: Date
+  recordPublished?: Date
+  languages: Array<LanguageCode>
   kind: RecordKind
   topics: Array<string> // TODO: handle codelists
   keywords: Array<Keyword>

package/src/libs/common/fixtures/src/lib/elasticsearch/full-response.ts

@@ -131,7 +131,7 @@ export const ES_FIXTURE_FULL_RESPONSE = deepFreeze({
           creationDateForResource: ['2012-01-01T00:00:00.000Z'],
           creationYearForResource: '2012',
           creationMonthForResource: '2012-01',
-          publicationDateForResource: ['2021-04-01T00:00:00.000Z'],
+          publicationDateForResource: '2021-04-01T00:00:00.000Z',
           publicationYearForResource: '2021',
           publicationMonthForResource: '2021-04',
           resourceDate: [

package/src/libs/common/fixtures/src/lib/records.fixtures.ts

@@ -71,19 +71,19 @@ Cette section contient des *caractères internationaux* (ainsi que des "caractè
     ],
     keywords: [
       {
-        thesaurusId: 'geonetwork.thesaurus.local',
+        thesaurus: { id: 'geonetwork.thesaurus.local' },
         type: 'other',
-        value: 'international',
+        label: 'international',
       },
       {
-        thesaurusId: 'geonetwork.thesaurus.local',
+        thesaurus: { id: 'geonetwork.thesaurus.local' },
         type: 'other',
-        value: 'test',
+        label: 'test',
       },
       {
-        thesaurusId: 'geonetwork.thesaurus.local',
+        thesaurus: { id: 'geonetwork.thesaurus.local' },
         type: 'other',
-        value: '_another_keyword_',
+        label: '_another_keyword_',
       },
     ],
     topics: ['testData', 'exampleData'],
@@ -149,6 +149,7 @@ As such, **it is not very interesting at all.**`,
       updatedTimes: 3,
       per: 'month',
     },
+    languages: ['en'],
   },
   {
     uniqueIdentifier: '7d002c4c-92ef-4b9f-a568-d732f740b99e',
@@ -186,11 +187,31 @@ Malgré l'attention portée à la création de ces données, il est rappelé que
       },
     ],
     keywords: [
-      'planification',
-      'PLU',
-      "Plan local d'urbanisme",
-      'données ouvertes',
-      'Avrigny*60036',
+      {
+        thesaurus: { id: 'geonetwork.thesaurus.local' },
+        type: 'other',
+        label: 'planification',
+      },
+      {
+        thesaurus: { id: 'geonetwork.thesaurus.local' },
+        type: 'other',
+        label: 'PLU',
+      },
+      {
+        thesaurus: { id: 'geonetwork.thesaurus.local' },
+        type: 'other',
+        label: "Plan local d'urbanisme",
+      },
+      {
+        thesaurus: { id: 'geonetwork.thesaurus.local' },
+        type: 'other',
+        label: 'données ouvertes',
+      },
+      {
+        thesaurus: { id: 'geonetwork.thesaurus.local' },
+        type: 'other',
+        label: 'Avrigny*60036',
+      },
     ],
     topics: ['Usage des sols', "document d'urbanisme"],
     spatialRepresentation: 'vector',
@@ -220,5 +241,6 @@ Ce lot de données produit en 2019, a été numérisé à partir du PCI Vecteur
     temporalExtents: [],
     status: 'completed',
     updateFrequency: 'unknown',
+    languages: ['fr', 'de'],
   },
 ])

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

@@ -1,3 +1,8 @@
+export * from './lib/+state/editor.facade'
+export * from './lib/+state/editor.models'
+export * from './lib/+state/editor.selectors'
+export * from './lib/+state/editor.reducer'
+export * from './lib/+state/editor.actions'
 export * from './lib/feature-editor.module'
 export * from './lib/services/editor.service'
 export * from './lib/record-form/record-form.component'

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>