geonetwork-ui 2.3.2 → 2.4.0-dev.0925104f

package/src/libs/api/repository/src/lib/gn4/platform/gn4-platform.service.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@angular/core'
-import { Observable, of, switchMap } from 'rxjs'
+import { combineLatest, Observable, of, switchMap } from 'rxjs'
 import { catchError, map, shareReplay, tap } from 'rxjs/operators'
 import {
   MeApiService,
@@ -12,13 +12,19 @@ import {
 import { PlatformServiceInterface } from '../../../../../../../libs/common/domain/src/lib/platform.service.interface'
 import { UserModel } from '../../../../../../../libs/common/domain/src/lib/model/user/user.model'
 import {
+  Keyword,
   Organization,
   UserFeedback,
 } from '../../../../../../../libs/common/domain/src/lib/model/record'
 import { Gn4PlatformMapper } from './gn4-platform.mapper'
 import { ltr } from 'semver'
-import { ThesaurusModel } from '../../../../../../../libs/common/domain/src/lib/model/thesaurus/thesaurus.model'
 import { LangService } from '../../../../../../../libs/util/i18n/src'
+import { HttpClient } from '@angular/common/http'
+import {
+  KeywordApiResponse,
+  ThesaurusApiResponse,
+} from '../../../../../../../libs/api/metadata-converter/src'
+import { KeywordType } from '../../../../../../../libs/common/domain/src/lib/model/thesaurus'
 
 const minApiVersion = '4.2.2'
 
@@ -60,7 +66,7 @@ export class Gn4PlatformService implements PlatformServiceInterface {
    * A map of already loaded thesauri (groups of keywords); the key is a URI
    * @private
    */
-  private thesauri: Record<string, Observable<ThesaurusModel>> = {}
+  private keywordsByThesauri: Record<string, Observable<Keyword[]>> = {}
 
   constructor(
     private siteApiService: SiteApiService,
@@ -70,7 +76,8 @@ export class Gn4PlatformService implements PlatformServiceInterface {
     private toolsApiService: ToolsApiService,
     private registriesApiService: RegistriesApiService,
     private langService: LangService,
-    private userfeedbackApiService: UserfeedbackApiService
+    private userfeedbackApiService: UserfeedbackApiService,
+    private httpClient: HttpClient
   ) {
     this.me$ = this.meApi.getMe().pipe(
       switchMap((apiUser) => this.mapper.userFromMeApi(apiUser)),
@@ -121,7 +128,7 @@ export class Gn4PlatformService implements PlatformServiceInterface {
       // the thesaurus URI is inferred by removing a part of the keyword URI
       // this is not exact science but it's OK, we'll still end up loading a bunch of keywords at once anyway
       const thesaurusUri = key.replace(/\/([^/]+)$/, '/')
-      return this.getThesaurusByUri(thesaurusUri).pipe(
+      return this.getKeywordsByUri(thesaurusUri).pipe(
         map((thesaurus) => {
           for (const item of thesaurus) {
             if (item.key === key) return item.label
@@ -133,32 +140,116 @@ export class Gn4PlatformService implements PlatformServiceInterface {
     return this.keyTranslations$.pipe(map((translations) => translations[key]))
   }
 
-  getThesaurusByUri(uri: string): Observable<ThesaurusModel> {
-    if (this.thesauri[uri]) {
-      return this.thesauri[uri]
-    }
-    this.thesauri[uri] = this.registriesApiService
-      .searchKeywords(
-        null,
-        this.langService.iso3,
-        1000,
-        0,
-        null,
-        null,
-        null,
-        `${uri}*`
-      )
-      .pipe(
-        map((thesaurus) =>
-          this.mapper.thesaurusFromApi(
-            thesaurus as any[],
-            this.langService.iso3
+  private allThesaurus$ = this.httpClient
+    .get(
+      `${this.registriesApiService.configuration.basePath}/thesaurus?_content_type=json`
+    )
+    .pipe(
+      map((thesaurus) => {
+        return thesaurus[0] as ThesaurusApiResponse[]
+      }),
+      shareReplay(1)
+    )
+
+  searchKeywords(
+    query: string,
+    keywordTypes: KeywordType[]
+  ): Observable<Keyword[]> {
+    const keywords$: Observable<KeywordApiResponse[]> = this.allThesaurus$.pipe(
+      switchMap((thesaurus) => {
+        const selectedThesauri = []
+        keywordTypes.map((keywordType) => {
+          selectedThesauri.push(
+            ...thesaurus.filter((thes) => thes.dname === keywordType)
           )
-        ),
-        shareReplay(1)
-      )
+        })
+
+        return this.registriesApiService.searchKeywords(
+          query,
+          this.langService.iso3,
+          10,
+          0,
+          null,
+          selectedThesauri.map((thes) => thes.key),
+          null,
+          `*${query}*`
+        ) as Observable<KeywordApiResponse[]>
+      })
+    )
 
-    return this.thesauri[uri]
+    return combineLatest([keywords$, this.allThesaurus$]).pipe(
+      map(([keywords, thesaurus]) => {
+        return this.mapper.keywordsFromApi(
+          keywords,
+          thesaurus,
+          this.langService.iso3
+        )
+      })
+    )
+  }
+
+  getKeywordsByUri(uri: string): Observable<Keyword[]> {
+    if (this.keywordsByThesauri[uri]) {
+      return this.keywordsByThesauri[uri]
+    }
+    const keywords$ = this.registriesApiService.searchKeywords(
+      null,
+      this.langService.iso3,
+      1000,
+      0,
+      null,
+      null,
+      null,
+      `${uri}*`
+    ) as Observable<KeywordApiResponse[]>
+
+    this.keywordsByThesauri[uri] = combineLatest([
+      keywords$,
+      this.allThesaurus$,
+    ]).pipe(
+      map(([keywords, thesaurus]) => {
+        return this.mapper.keywordsFromApi(
+          keywords,
+          thesaurus,
+          this.langService.iso3
+        )
+      }),
+      shareReplay(1)
+    )
+
+    return this.keywordsByThesauri[uri]
+  }
+
+  searchKeywordsInThesaurus(query: string, thesaurusId: string) {
+    return this.allThesaurus$.pipe(
+      switchMap((thesauri) => {
+        const strippedThesaurusId = thesaurusId.replace(
+          'geonetwork.thesaurus.',
+          ''
+        )
+        if (!thesauri.find((thes) => thes.key === strippedThesaurusId))
+          return of([])
+        return this.registriesApiService
+          .searchKeywords(
+            query,
+            this.langService.iso3,
+            100,
+            0,
+            null,
+            [strippedThesaurusId],
+            null
+          )
+          .pipe(
+            map((keywords: KeywordApiResponse[]) =>
+              this.mapper.keywordsFromApi(
+                keywords,
+                thesauri,
+                this.langService.iso3
+              )
+            )
+          )
+      })
+    )
   }
 
   getUserFeedbacks(uuid: string): Observable<UserFeedback[]> {

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

@@ -1,4 +1,5 @@
 import { Organization } from './organization.model'
+import { marker } from '@biesbjerg/ngx-translate-extract-marker'
 
 export const RoleValues = [
   'unspecified',
@@ -24,6 +25,33 @@ export const RoleValues = [
   'user', // Party who uses the resource
 ]
 
+export const RoleLabels = new Map<Role, string>([
+  ['unspecified', marker('domain.contact.role.unspecified')],
+  ['other', marker('domain.contact.role.other')],
+  ['author', marker('domain.contact.role.author')],
+  ['collaborator', marker('domain.contact.role.collaborator')],
+  ['contributor', marker('domain.contact.role.contributor')],
+  ['custodian', marker('domain.contact.role.custodian')],
+  ['distributor', marker('domain.contact.role.distributor')],
+  ['editor', marker('domain.contact.role.editor')],
+  ['funder', marker('domain.contact.role.funder')],
+  ['mediator', marker('domain.contact.role.mediator')],
+  ['originator', marker('domain.contact.role.originator')],
+  ['owner', marker('domain.contact.role.owner')],
+  ['point_of_contact', marker('domain.contact.role.point_of_contact')],
+  [
+    'principal_investigator',
+    marker('domain.contact.role.principal_investigator'),
+  ],
+  ['processor', marker('domain.contact.role.processor')],
+  ['publisher', marker('domain.contact.role.publisher')],
+  ['resource_provider', marker('domain.contact.role.resource_provider')],
+  ['rights_holder', marker('domain.contact.role.rights_holder')],
+  ['sponsor', marker('domain.contact.role.sponsor')],
+  ['stakeholder', marker('domain.contact.role.stakeholder')],
+  ['user', marker('domain.contact.role.user')],
+])
+
 export type Role = typeof RoleValues[number]
 
 export interface Individual {

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

@@ -2,6 +2,7 @@ import { marker } from '@biesbjerg/ngx-translate-extract-marker'
 import type { Individual } from './contact.model'
 import type { Organization } from './organization.model'
 import type { Geometry } from 'geojson'
+import { KeywordType, ThesaurusModel } from '../thesaurus'
 
 type Uuid = string
 
@@ -60,18 +61,13 @@ export type SpatialRepresentationType =
   | 'table'
   | 'point'
 
-export type KeywordType = 'place' | 'temporal' | 'theme' | 'other'
-
-export type KeywordThesaurus = {
-  id: string
-  name?: string
-  url?: URL
-}
-
 export interface Keyword {
+  key?: string
   label: string
+  description?: string
   type: KeywordType
-  thesaurus?: KeywordThesaurus
+  thesaurus?: ThesaurusModel
+  bbox?: [number, number, number, number]
 }
 // languages should be expressed using two-letters ISO 639-1 codes
 export type LanguageCode = string
@@ -164,7 +160,8 @@ export interface GraphicOverview {
 }
 
 export interface DatasetSpatialExtent {
-  geometry: Geometry
+  bbox?: [number, number, number, number]
+  geometry?: Geometry
   description?: string
 }
 

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

@@ -1,5 +1,6 @@
 export interface Organization {
   name: string
+  email?: string
   description?: string
   website?: URL
   logoUrl?: URL

package/src/libs/common/domain/src/lib/model/thesaurus/thesaurus.model.ts

@@ -1,7 +1,14 @@
-export interface ThesaurusItemModel {
-  key: string
-  label: string
-  description?: string
-}
+export type KeywordType = 'place' | 'temporal' | 'theme' | 'other'
 
-export type ThesaurusModel = ThesaurusItemModel[]
+export interface ThesaurusModel {
+  id: string
+  name?: string
+  url?: URL
+  thesaurusKey?: string
+  definition?: string
+  definitions?: object
+  uri?: string
+  value?: string
+  values?: object
+  type?: KeywordType
+}

package/src/libs/common/domain/src/lib/model/user/user.model.ts

@@ -5,6 +5,6 @@ export interface UserModel {
   name: string
   surname: string
   email: string
-  organisation: string
+  organisation?: string
   profileIcon?: string
 }

package/src/libs/common/domain/src/lib/platform.service.interface.ts

@@ -1,8 +1,8 @@
 import type { Observable } from 'rxjs'
 import type { UserModel } from './model/user/user.model'
 import type { Organization } from './model/record/organization.model'
-import type { ThesaurusModel } from './model/thesaurus/'
-import { UserFeedback } from './model/record'
+import { Keyword, UserFeedback } from './model/record'
+import { KeywordType } from './model/thesaurus'
 
 export abstract class PlatformServiceInterface {
   abstract getType(): string
@@ -16,7 +16,15 @@ export abstract class PlatformServiceInterface {
   ): Observable<UserModel[]>
   abstract getOrganizations(): Observable<Organization[]>
   abstract translateKey(key: string): Observable<string>
-  abstract getThesaurusByUri(uri: string): Observable<ThesaurusModel>
+  abstract searchKeywords(
+    query: string,
+    keywordTypes: KeywordType[]
+  ): Observable<Keyword[]>
+  abstract getKeywordsByUri(uri: string): Observable<Keyword[]>
+  abstract searchKeywordsInThesaurus(
+    query: string,
+    thesaurusId: string
+  ): Observable<Keyword[]>
   abstract getUserFeedbacks(recordUuid: string): Observable<UserFeedback[]>
   abstract postUserFeedbacks(recordUuid: UserFeedback): Observable<void>
 }

package/src/libs/common/domain/src/lib/repository/records-repository.interface.ts

@@ -11,12 +11,70 @@ import { CatalogRecord } from '../model/record'
 export abstract class RecordsRepositoryInterface {
   abstract search(params: SearchParams): Observable<SearchResults>
   abstract getMatchesCount(filters: FieldFilters): Observable<number>
-  abstract getByUniqueIdentifier(
-    uniqueIdentifier: string
-  ): Observable<CatalogRecord | null>
+  abstract getRecord(uniqueIdentifier: string): Observable<CatalogRecord | null>
   abstract aggregate(params: AggregationsParams): Observable<Aggregations>
   abstract getSimilarRecords(
     similarTo: CatalogRecord
   ): Observable<CatalogRecord[]>
   abstract fuzzySearch(query: string): Observable<SearchResults>
+
+  /**
+   * This emits once:
+   * - record object; if a draft exists, this will return it
+   * - serialized representation of the record as text
+   * - boolean indicating if the record has been saved at least once in a final version (i.e. not only as draft)
+   * @param uniqueIdentifier
+   * @returns Observable<[CatalogRecord, string, boolean] | null>
+   */
+  abstract openRecordForEdition(
+    uniqueIdentifier: string
+  ): Observable<[CatalogRecord, string, boolean] | null>
+
+  /**
+   * This emits once:
+   * - record object with a new unique identifier and suffixed title
+   * - serialized representation of the record as text
+   * - false, as the duplicated record is always a draft
+   * @param uniqueIdentifier
+   * @returns Observable<[CatalogRecord, string, false] | null>
+   */
+  abstract openRecordForDuplication(
+    uniqueIdentifier: string
+  ): Observable<[CatalogRecord, string, false] | null>
+
+  /**
+   * @param record
+   * @param referenceRecordSource
+   * @returns Observable<string> Returns the unique identifier of the record as it was when saved
+   */
+  abstract saveRecord(
+    record: CatalogRecord,
+    referenceRecordSource?: string
+  ): Observable<string>
+
+  /**
+   * @param uniqueIdentifier
+   * @returns Observable<void> Returns when record is deleted
+   */
+  abstract deleteRecord(uniqueIdentifier: string): Observable<void>
+
+  abstract generateTemporaryId(): string
+
+  /**
+   * @param record
+   * @param referenceRecordSource
+   * @returns Observable<string> Returns the source of the record as it was serialized when saved
+   */
+  abstract saveRecordAsDraft(
+    record: CatalogRecord,
+    referenceRecordSource?: string
+  ): Observable<string>
+
+  abstract clearRecordDraft(uniqueIdentifier: string): void
+  abstract recordHasDraft(uniqueIdentifier: string): boolean
+  abstract isRecordNotYetSaved(uniqueIdentifier: string): boolean
+
+  /** will return all pending drafts, both published and not published */
+  abstract getAllDrafts(): Observable<CatalogRecord[]>
+  abstract draftsChanged$: Observable<void>
 }

package/src/libs/common/fixtures/src/index.ts

@@ -4,10 +4,12 @@ export * from './lib/search'
 
 export * from './lib/geojson.fixtures'
 export * from './lib/link.fixtures'
-export * from './lib/ol-feature.fixture'
+export * from './lib/ol-feature.fixtures'
 export * from './lib/organisations.fixture'
 export * from './lib/record-link.fixtures'
 export * from './lib/records.fixtures'
 export * from './lib/repository.fixtures'
 export * from './lib/user.fixtures'
 export * from './lib/user-feedbacks.fixtures'
+
+export * from './lib/editor'

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

@@ -0,0 +1,156 @@
+export const editorConfigFixture = () => ({
+  pages: [
+    {
+      labelKey: 'Resource description',
+      sections: [editorSectionAboutFixture()],
+    },
+    {
+      labelKey: 'Resources',
+      sections: [editorSectionClassificationFixture()],
+    },
+    {
+      labelKey: 'Access and contact',
+      sections: [
+        editorSectionUseAndAccessConditionsFixture(),
+        editorSectionDataManagerFixture(),
+      ],
+    },
+  ],
+})
+
+export const editorSectionAboutFixture = () => ({
+  labelKey: 'About the resource',
+  descriptionKey: 'This section describes the resource.',
+  hidden: false,
+  fields: [
+    editorFieldTitleFixture(),
+    editorFieldAbstractFixture(),
+    editorFieldResourceUpdatedFixture(),
+    editorFieldRecordUpdatedFixture(),
+    editorFieldUpdateFrequencyFixture(),
+    editorFieldTemporalExtentsFixture(),
+  ],
+})
+
+export const editorSectionDataManagerFixture = () => ({
+  labelKey: 'Data manager',
+  descriptionKey: '',
+  hidden: false,
+  fields: [],
+})
+
+export const editorSectionUseAndAccessConditionsFixture = () => ({
+  labelKey: 'Data manager',
+  descriptionKey: '',
+  hidden: false,
+  fields: [editorFieldLicenseFixture()],
+})
+
+export const editorSectionClassificationFixture = () => ({
+  labelKey: 'Classification',
+  descriptionKey: 'The classification has an impact on the access to the data.',
+  hidden: false,
+  fields: [editorFieldKeywordsFixture(), editorFieldUniqueIdentifierFixture()],
+})
+
+export const editorFieldTitleFixture = () => ({
+  model: 'title',
+  hidden: false,
+  value: 'Accroches vélos MEL',
+  formFieldConfig: {
+    labelKey: 'editor.record.form.field.title',
+  },
+})
+
+export const editorFieldAbstractFixture = () => ({
+  model: 'abstract',
+  hidden: false,
+  value: 'Abstract',
+  formFieldConfig: {
+    labelKey: 'editor.record.form.field.abstract',
+  },
+})
+
+export const editorFieldResourceUpdatedFixture = () => ({
+  model: 'resourceUpdated',
+  hidden: false,
+  formFieldConfig: {
+    labelKey: 'editor.record.form.field.resourceUpdated',
+  },
+})
+
+export const editorFieldRecordUpdatedFixture = () => ({
+  model: 'recordUpdated',
+  hidden: false,
+  formFieldConfig: {
+    labelKey: 'editor.record.form.field.recordUpdated',
+    locked: true,
+  },
+  value: '2024-07-16T05:18:53.000Z',
+  onSaveProcess: '${dateNow()}',
+})
+
+export const editorFieldUpdateFrequencyFixture = () => ({
+  model: 'updateFrequency',
+  hidden: false,
+  formFieldConfig: {
+    labelKey: 'editor.record.form.field.updateFrequency',
+  },
+  value: 'unknown',
+})
+
+export const editorFieldTemporalExtentsFixture = () => ({
+  model: 'temporalExtents',
+  hidden: false,
+  formFieldConfig: {
+    labelKey: 'editor.record.form.field.temporalExtents',
+  },
+  value: [],
+})
+
+export const editorFieldSpatialExtentsFixture = () => ({
+  model: 'spatialExtents',
+  hidden: false,
+  formFieldConfig: {
+    labelKey: 'editor.record.form.field.spatialExtents',
+  },
+})
+
+export const editorFieldKeywordsFixture = () => ({
+  model: 'keywords',
+  hidden: false,
+  formFieldConfig: {
+    labelKey: 'editor.record.form.field.keywords',
+  },
+})
+
+export const editorFieldUniqueIdentifierFixture = () => ({
+  model: 'uniqueIdentifier',
+  hidden: false,
+  formFieldConfig: {
+    labelKey: 'editor.record.form.field.uniqueIdentifier',
+    locked: true,
+  },
+  value: 'accroche_velos',
+})
+
+export const editorFieldLicenseFixture = () => ({
+  model: 'licenses',
+  hidden: false,
+  formFieldConfig: {
+    labelKey: 'editor.record.form.field.license',
+    locked: true,
+  },
+})
+
+export const editorFieldsFixture = () => [
+  editorFieldTitleFixture(),
+  editorFieldAbstractFixture(),
+  editorFieldResourceUpdatedFixture(),
+  editorFieldRecordUpdatedFixture(),
+  editorFieldUpdateFrequencyFixture(),
+  editorFieldTemporalExtentsFixture(),
+  editorFieldSpatialExtentsFixture(),
+  editorFieldKeywordsFixture(),
+  editorFieldUniqueIdentifierFixture(),
+]

package/src/libs/common/fixtures/src/lib/editor/index.ts

@@ -0,0 +1 @@
+export * from './editor.fixtures'

package/src/libs/common/fixtures/src/lib/elasticsearch/{aggregations-request.ts → aggregations-request.fixtures.ts}

@@ -1,6 +1,4 @@
-import { deepFreeze } from '../utils/freeze'
-
-export const ES_FIXTURE_AGGS_REQUEST = deepFreeze({
+export const elasticAggsRequestFixture = () => ({
   'tag.default': { terms: { field: 'tag.default', include: '.*', size: 10 } },
   availableInServices: {
     filters: {

package/src/libs/common/fixtures/src/lib/elasticsearch/{aggregations-response.ts → aggregations-response.fixtures.ts}

@@ -1,6 +1,4 @@
-import { deepFreeze } from '../utils/freeze'
-
-const BUCKETS = deepFreeze([
+const elasticBucketsFixture = () => [
   { key: 'Hungary', doc_count: 20 },
   {
     key: 'Austria',
@@ -16,13 +14,13 @@ const BUCKETS = deepFreeze([
     key: 'Cyprus',
     doc_count: 5,
   },
-])
+]
 
-export const ES_FIXTURE_AGGS_RESPONSE = deepFreeze({
+export const elasticAggsResponseFixture = () => ({
   'tag.default': {
     doc_count_error_upper_bound: 0,
     sum_other_doc_count: 458,
-    buckets: BUCKETS,
+    buckets: elasticBucketsFixture(),
   },
   availableInServices: {
     buckets: {
@@ -66,12 +64,12 @@ export const ES_FIXTURE_AGGS_RESPONSE = deepFreeze({
   },
 })
 
-export const ES_FIXTURE_AGGS_RESPONSE_MORE = deepFreeze({
+export const elasticAggsResponseMoreFixture = () => ({
   'tag.default': {
     doc_count_error_upper_bound: 0,
     sum_other_doc_count: 456,
     buckets: [
-      ...BUCKETS,
+      ...elasticBucketsFixture(),
       { key: 'Spain', doc_count: 86 },
       { key: 'United Kingdom', doc_count: 84 },
     ],

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

@@ -1,6 +1,4 @@
-import { deepFreeze } from '../utils/freeze'
-
-export const ES_FIXTURE_FULL_RESPONSE = deepFreeze({
+export const elasticFullResponseFixture = () => ({
   took: 1,
   timed_out: false,
   _shards: { total: 1, successful: 1, skipped: 0, failed: 0 },

package/src/libs/common/fixtures/src/lib/elasticsearch/index.ts

@@ -1,6 +1,6 @@
-export * from './search-requests'
-export * from './search-responses'
-export * from './aggregations-request'
-export * from './aggregations-response'
-export * from './full-response'
+export * from './search-requests.fixtures'
+export * from './search-responses.fixtures'
+export * from './aggregations-request.fixtures'
+export * from './aggregations-response.fixtures'
+export * from './full-response.fixtures'
 export * from './metadata-links.fixtures'

package/src/libs/common/fixtures/src/lib/elasticsearch/metadata-links.fixtures.ts

@@ -1,6 +1,4 @@
-import { deepFreeze } from '../utils'
-
-export const ES_LINK_FIXTURES: Record<string, unknown> = deepFreeze({
+export const elasticLinkFixture = (): Record<string, unknown> => ({
   readmeLink: {
     protocol: 'WWW:LINK',
     description: 'Readme page',