geonetwork-ui 2.10.0-dev.89f0dfe6f → 2.10.0-dev.8f8114b9e

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

@@ -6,6 +6,7 @@ import {
 import { Injectable, InjectionToken, inject } from '@angular/core'
 import {
   assertValidXml,
+  BaseConverter,
   findConverterForDocument,
   Gn4Converter,
   Gn4SearchResults,
@@ -61,6 +62,12 @@ export const DISABLE_DRAFT = new InjectionToken<boolean>('gnDisableDraft', {
   factory: () => false,
 })
 
+export const DEFAULT_RECORD_CONVERTER = new InjectionToken<
+  BaseConverter<string>
+>('defaultRecordConverter', {
+  factory: () => new Iso19139Converter(),
+})
+
 @Injectable()
 export class Gn4Repository implements RecordsRepositoryInterface {
   private httpClient = inject(HttpClient)
@@ -72,6 +79,7 @@ export class Gn4Repository implements RecordsRepositoryInterface {
   private gn4LanguagesApi = inject(LanguagesApiService)
   private settingsService = inject(Gn4SettingsService)
   private disableDraft = inject(DISABLE_DRAFT, { optional: true }) ?? false
+  private defaultConverter = inject(DEFAULT_RECORD_CONVERTER)
 
   _draftsChanged = new Subject<void>()
   draftsChanged$ = this._draftsChanged.asObservable()
@@ -377,38 +385,52 @@ export class Gn4Repository implements RecordsRepositoryInterface {
   openRecordForDuplication(
     uniqueIdentifier: string
   ): Observable<[CatalogRecord, string, true] | null> {
-    return this.gn4RecordsApi
-      .create(
-        uniqueIdentifier,
-        '2',
-        'METADATA',
-        '',
-        false,
-        undefined,
-        true,
-        false,
-        undefined,
-        'body',
-        false,
-        {
-          httpHeaderAccept: 'application/json',
-          httpContentTypeSelected: 'application/json;charset=UTF-8',
-        }
-      )
-      .pipe(
-        switchMap((uniqueIdentifier) => {
-          return this.getRecordAsXml(uniqueIdentifier)
-        }),
-        switchMap((xml) => {
-          return from(
-            findConverterForDocument(xml)
-              .readRecord(xml)
-              .then((record) => {
-                return [record, xml, true] as [CatalogRecord, string, true]
-              })
+    return this.platformService.getUserPermissionsByGroup().pipe(
+      map((permissions) => {
+        const groupId =
+          permissions.find((p) => p.canApprove)?.groupId?.toString() ??
+          permissions.find((p) => p.canEdit)?.groupId?.toString()
+        if (!groupId)
+          throw new Error(
+            'Current user has no writable group to duplicate into'
+          )
+        return groupId
+      }),
+      switchMap((groupId) =>
+        this.gn4RecordsApi
+          .create(
+            uniqueIdentifier,
+            groupId,
+            'METADATA',
+            '',
+            false,
+            undefined,
+            true,
+            false,
+            undefined,
+            'body',
+            false,
+            {
+              httpHeaderAccept: 'application/json',
+              httpContentTypeSelected: 'application/json;charset=UTF-8',
+            }
+          )
+          .pipe(
+            switchMap((uniqueIdentifier) => {
+              return this.getRecordAsXml(uniqueIdentifier)
+            }),
+            switchMap((xml) => {
+              return from(
+                findConverterForDocument(xml)
+                  .readRecord(xml)
+                  .then((record) => {
+                    return [record, xml, true] as [CatalogRecord, string, true]
+                  })
+              )
+            })
           )
-        })
       )
+    )
   }
 
   saveRecord(
@@ -605,10 +627,10 @@ export class Gn4Repository implements RecordsRepositoryInterface {
     record: CatalogRecord,
     referenceRecordSource?: string
   ): Observable<string> {
-    // if there's a reference record, use that standard; otherwise, use iso19139
+    // if there's a reference record, use that standard; otherwise, use standard based on configuration or default
     const converter = referenceRecordSource
       ? findConverterForDocument(referenceRecordSource)
-      : new Iso19139Converter()
+      : this.defaultConverter
     return from(converter.writeRecord(record, referenceRecordSource))
   }
 

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

@@ -12,11 +12,13 @@ import {
 } from '../../../../../../../libs/common/domain/src/lib/model/record'
 import { KeywordType } from '../../../../../../../libs/common/domain/src/lib/model/thesaurus'
 import { UserModel } from '../../../../../../../libs/common/domain/src/lib/model/user/user.model'
+import { GroupModel } from '../../../../../../../libs/common/domain/src/lib/model/user/group.model'
 import {
   PlatformServiceInterface,
   UploadEvent,
 } from '../../../../../../../libs/common/domain/src/lib/platform.service.interface'
 import {
+  GroupsApiService,
   MeApiService,
   RecordsApiService,
   RegistriesApiService,
@@ -57,6 +59,7 @@ export const DISABLE_AUTH = new InjectionToken<boolean>('gnDisableAuth', {
 export class Gn4PlatformService implements PlatformServiceInterface {
   private meApi = inject(MeApiService)
   private usersApi = inject(UsersApiService)
+  private groupsApi = inject(GroupsApiService)
   private mapper = inject(Gn4PlatformMapper)
   private toolsApiService = inject(ToolsApiService)
   private registriesApiService = inject(RegistriesApiService)
@@ -155,6 +158,49 @@ export class Gn4PlatformService implements PlatformServiceInterface {
     return this.users$
   }
 
+  getUserPermissionsByGroup(): Observable<GroupModel[]> {
+    if (this.disableAuth) return of([])
+    return combineLatest([this.meApi.getMe(), this.groupsApi.getGroups()]).pipe(
+      map(([meResponse, groups]) => {
+        if (!meResponse) return []
+        if (meResponse.admin) {
+          return groups.map((group) => ({
+            groupId: group.id,
+            groupName: group.name,
+            isMember: true,
+            canEdit: true,
+            canApprove: true,
+            canAdministrate: true,
+          }))
+        }
+        const reviewerIds = meResponse.groupsWithReviewer ?? []
+        const editorIds = meResponse.groupsWithEditor ?? []
+        const memberIds = meResponse.groupsWithRegisteredUser ?? []
+        const adminIds = meResponse.groupsWithUserAdmin ?? []
+        const groupsById = new Map(groups.map((g) => [g.id, g]))
+        return [
+          ...new Set([
+            ...reviewerIds,
+            ...editorIds,
+            ...groups.map((g) => g.id),
+          ]),
+        ]
+          .filter((id) => groupsById.has(id))
+          .map((id) => {
+            const group = groupsById.get(id)
+            return {
+              groupId: group.id,
+              groupName: group.name,
+              isMember: memberIds.includes(id),
+              canEdit: editorIds.includes(id),
+              canApprove: reviewerIds.includes(id),
+              canAdministrate: adminIds.includes(id),
+            }
+          })
+      })
+    )
+  }
+
   translateKey(key: string): Observable<string> {
     // if the key is a URI, use the registries API to look for the translation
     if (key.match(/^https?:\/\//)) {

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

@@ -0,0 +1,8 @@
+export interface GroupModel {
+  groupId: number
+  groupName: string
+  isMember: boolean
+  canEdit: boolean
+  canApprove: boolean
+  canAdministrate: boolean
+}

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

@@ -1 +1,2 @@
 export * from './user.model'
+export * from './group.model'

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

@@ -1,5 +1,6 @@
 import type { Observable } from 'rxjs'
 import type { UserModel } from './model/user/user.model'
+import type { GroupModel } from './model/user/group.model'
 import type { Organization } from './model/record/organization.model'
 import { CatalogRecord, Keyword, UserFeedback } from './model/record'
 import { KeywordType } from './model/thesaurus'
@@ -28,6 +29,7 @@ export abstract class PlatformServiceInterface {
   abstract getMe(): Observable<UserModel>
   abstract isAnonymous(): Observable<boolean>
   abstract getUsers(): Observable<UserModel[]>
+  abstract getUserPermissionsByGroup(): Observable<GroupModel[]>
   abstract getUsersByOrganization(
     organisation: Organization
   ): Observable<UserModel[]>

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

@@ -359,7 +359,6 @@ export const simpleDatasetRecordFixture = (): DatasetRecord => ({
   securityConstraints: [],
   otherConstraints: [],
   lineage: 'This record was edited manually to test the conversion processes',
-  sourceRecords: [],
   spatialRepresentation: 'grid',
   overviews: [],
   spatialExtents: [],
@@ -1000,7 +999,6 @@ export const multilingualDatasetFixture: () => DatasetRecord = () => ({
       },
     },
   ],
-  sourceRecords: [],
   onlineResources: [],
   licenses: [],
   legalConstraints: [],

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

@@ -1,5 +1,5 @@
 import { Injectable, inject } from '@angular/core'
-import { forkJoin, Observable, of, switchMap } from 'rxjs'
+import { Observable, switchMap } from 'rxjs'
 import { map, tap } from 'rxjs/operators'
 import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
 import { EditorConfig } from '../models/'

package/src/libs/util/app-config/src/lib/app-config.ts

@@ -2,6 +2,7 @@ import * as TOML from '@ltd/j-toml'
 import {
   checkMetadataLanguage,
   checkNewRecordDefaultLanguage,
+  checkNewRecordStandard,
   parseConfigSection,
   parseMultiConfigSection,
   parseTranslationsConfigSection,
@@ -297,7 +298,7 @@ export function loadAppConfig(configUrl = 'assets/configuration/default.toml') {
         parsed,
         'editing',
         [],
-        ['new_record_default_language'],
+        ['new_record_default_language', 'new_record_standard'],
         warnings,
         errors
       )
@@ -310,6 +311,15 @@ export function loadAppConfig(configUrl = 'assets/configuration/default.toml') {
           warnings
         )
       }
+      if (
+        parsedEditingSection !== null &&
+        parsedEditingSection.new_record_standard !== undefined
+      ) {
+        parsedEditingSection = checkNewRecordStandard(
+          parsedEditingSection,
+          warnings
+        )
+      }
       editorConfig =
         parsedEditingSection === null
           ? null
@@ -318,6 +328,9 @@ export function loadAppConfig(configUrl = 'assets/configuration/default.toml') {
                 parsedEditingSection.new_record_default_language as
                   | string
                   | undefined,
+              NEW_RECORD_STANDARD: parsedEditingSection.new_record_standard as
+                | EditorConfig['NEW_RECORD_STANDARD']
+                | undefined,
             } as EditorConfig)
 
       customTranslations = parseTranslationsConfigSection(

package/src/libs/util/app-config/src/lib/model.ts

@@ -69,8 +69,11 @@ export interface MetadataQualityConfig {
   ENABLED: boolean
 }
 
+export type NewRecordStandard = 'iso19139' | 'iso19115-3'
+
 export interface EditorConfig {
   NEW_RECORD_DEFAULT_LANGUAGE?: string
+  NEW_RECORD_STANDARD?: NewRecordStandard
 }
 
 export type CustomTranslations = { [translationKey: string]: string }

package/src/libs/util/app-config/src/lib/parse-utils.ts

@@ -159,3 +159,30 @@ export function checkNewRecordDefaultLanguage(
     new_record_default_language: lang2,
   }
 }
+
+export function checkNewRecordStandard(
+  parsedConfigSection: any,
+  outWarnings: string[]
+) {
+  const standard = parsedConfigSection.new_record_standard
+  const normalizedStandard =
+    typeof standard === 'string' ? standard.trim().toLowerCase() : null
+
+  if (
+    normalizedStandard === 'iso19139' ||
+    normalizedStandard === 'iso19115-3'
+  ) {
+    return {
+      ...parsedConfigSection,
+      new_record_standard: normalizedStandard,
+    }
+  }
+
+  outWarnings.push(
+    `In the [editing] section: new_record_standard = "${standard}" is not a supported metadata standard`
+  )
+  return {
+    ...parsedConfigSection,
+    new_record_standard: undefined,
+  }
+}

package/src/libs/util/shared/src/lib/links/link-utils.ts

@@ -266,7 +266,7 @@ export function checkFileFormat(
       new RegExp(`[./]${format}`, 'i').test(link.name.toLowerCase())) ||
     ('url' in link &&
       new RegExp(`[./]${format}`, 'i').test(link.url.toString())) ||
-    ('name' in link && link.name.toLowerCase().includes(format))
+    ('name' in link && new RegExp(`\\b${format}\\b`, 'i').test(link.name))
   )
 }