geonetwork-ui 2.2.0-dev.0eef2738 → 2.2.0-dev.1189d390

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

@@ -12,7 +12,6 @@ import {
 } from '../xml-utils'
 import {
   writeAbstract,
-  writeAccessConstraints,
   writeContacts,
   writeDatasetCreated,
   writeDatasetUpdated,
@@ -20,22 +19,23 @@ import {
   writeGraphicOverviews,
   writeKeywords,
   writeKind,
+  writeLegalConstraints,
   writeLicenses,
   writeLineage,
   writeOnlineResources,
+  writeOtherConstraints,
   writeOwnerOrganization,
   writeRecordUpdated,
+  writeSecurityConstraints,
   writeSpatialRepresentation,
   writeStatus,
   writeThemes,
   writeTitle,
   writeUniqueIdentifier,
   writeUpdateFrequency,
-  writeUseLimitations,
 } from './write-parts'
 import {
   readAbstract,
-  readAccessConstraints,
   readContacts,
   readDatasetCreated,
   readDatasetUpdated,
@@ -43,12 +43,15 @@ import {
   readIsoTopics,
   readKeywords,
   readKind,
+  readLegalConstraints,
   readLicenses,
   readLineage,
   readOnlineResources,
+  readOtherConstraints,
   readOverviews,
   readOwnerOrganization,
   readRecordUpdated,
+  readSecurityConstraints,
   readSpatialExtents,
   readSpatialRepresentation,
   readStatus,
@@ -57,7 +60,6 @@ import {
   readTitle,
   readUniqueIdentifier,
   readUpdateFrequency,
-  readUseLimitations,
 } from './read-parts'
 import { isEqual } from '../convert-utils'
 
@@ -75,8 +77,9 @@ export function toModel(xml: string): CatalogRecord {
   const recordCreated = recordUpdated
   const keywords = readKeywords(rootEl)
   const themes = readThemes(rootEl)
-  const accessConstraints = readAccessConstraints(rootEl)
-  const useLimitations = readUseLimitations(rootEl)
+  const legalConstraints = readLegalConstraints(rootEl)
+  const otherConstraints = readOtherConstraints(rootEl)
+  const securityConstraints = readSecurityConstraints(rootEl)
   const licenses = readLicenses(rootEl)
   const overviews = readOverviews(rootEl)
 
@@ -107,9 +110,10 @@ export function toModel(xml: string): CatalogRecord {
       contactsForResource: [], // FIXME: is that really useful??
       keywords,
       themes,
-      accessConstraints,
-      useLimitations,
       licenses,
+      legalConstraints,
+      securityConstraints,
+      otherConstraints,
       ...(datasetCreated && { datasetCreated }),
       ...(datasetUpdated && { datasetUpdated }),
       lineage,
@@ -133,9 +137,10 @@ export function toModel(xml: string): CatalogRecord {
       contacts,
       keywords,
       themes,
-      accessConstraints,
-      useLimitations,
       licenses,
+      legalConstraints,
+      securityConstraints,
+      otherConstraints,
       overviews,
       onlineResources,
     } as ServiceRecord
@@ -164,9 +169,11 @@ export function toXml(record: CatalogRecord, originalXml?: string): string {
   fieldChanged('contacts') && writeContacts(record, rootEl)
   fieldChanged('keywords') && writeKeywords(record, rootEl)
   fieldChanged('themes') && writeThemes(record, rootEl)
-  fieldChanged('accessConstraints') && writeAccessConstraints(record, rootEl)
+  fieldChanged('legalConstraints') && writeLegalConstraints(record, rootEl)
+  fieldChanged('securityConstraints') &&
+    writeSecurityConstraints(record, rootEl)
   fieldChanged('licenses') && writeLicenses(record, rootEl)
-  fieldChanged('useLimitations') && writeUseLimitations(record, rootEl)
+  fieldChanged('otherConstraints') && writeOtherConstraints(record, rootEl)
 
   if (record.kind === 'dataset') {
     writeStatus(record, rootEl)

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

@@ -1,12 +1,10 @@
 import {
-  AccessConstraint,
-  AccessConstraintType,
+  Constraint,
   DatasetDistribution,
   DatasetSpatialExtent,
   DatasetTemporalExtent,
   GraphicOverview,
   Individual,
-  License,
   Organization,
   RecordKind,
   RecordStatus,
@@ -183,59 +181,69 @@ function extractStatus(): ChainableFunction<XmlElement, RecordStatus> {
 }
 
 // from gmd:resourceConstraints
-function extractAccessConstraints(): ChainableFunction<
+function extractLegalConstraints(): ChainableFunction<
   XmlElement,
-  Array<AccessConstraint>
+  Array<Constraint>
 > {
-  const getOtherConstraints = pipe(
+  return pipe(
     findChildrenElement('gmd:MD_LegalConstraints', false),
     filterArray(
       pipe(
         findChildrenElement('gmd:MD_RestrictionCode'),
         mapArray(readAttribute('codeListValue')),
-        map(
-          (values) =>
-            values.indexOf('license') === -1 &&
-            values.indexOf('otherRestrictions') > -1
-        )
+        map((values) => values.indexOf('license') === -1)
+      )
+    ),
+    mapArray(
+      combine(
+        findChildrenElement('gmd:otherConstraints'),
+        findChildrenElement('gmd:useLimitation')
       )
     ),
-    mapArray(findChildrenElement('gmd:otherConstraints')),
     flattenArray(),
-    mapArray(extractCharacterString()),
-    mapArray((text) => ({
+    flattenArray(),
+    mapArray(combine(extractCharacterString(), extractUrl())),
+    mapArray(([text, url]) => ({
+      ...(url && { url }),
       text,
-      type: 'other' as AccessConstraintType,
     }))
   )
-  const getSecurityConstraints = pipe(
+}
+
+// from gmd:resourceConstraints
+function extractSecurityConstraints(): ChainableFunction<
+  XmlElement,
+  Array<Constraint>
+> {
+  return pipe(
     findNestedElements('gmd:MD_SecurityConstraints', 'gmd:useLimitation'),
-    mapArray(extractCharacterString()),
-    mapArray((text) => ({
+    flattenArray(),
+    mapArray(combine(extractCharacterString(), extractUrl())),
+    mapArray(([text, url]) => ({
+      ...(url && { url }),
       text,
-      type: 'security' as AccessConstraintType,
     }))
   )
-  return pipe(
-    combine(getOtherConstraints, getSecurityConstraints),
-    flattenArray()
-  )
 }
 
 // from gmd:resourceConstraints
-function extractUseLimitations(): ChainableFunction<XmlElement, Array<string>> {
+function extractOtherConstraints(): ChainableFunction<
+  XmlElement,
+  Array<Constraint>
+> {
   return pipe(
-    combine(
-      findNestedElements('gmd:MD_Constraints', 'gmd:useLimitation'),
-      findNestedElements('gmd:MD_LegalConstraints', 'gmd:useLimitation')
-    ),
+    findNestedElements('gmd:MD_Constraints', 'gmd:useLimitation'),
     flattenArray(),
-    mapArray(extractCharacterString())
+    mapArray(combine(extractCharacterString(), extractUrl())),
+    mapArray(([text, url]) => ({
+      ...(url && { url }),
+      text,
+    }))
   )
 }
 
 // from gmd:resourceConstraints
-function extractLicenses(): ChainableFunction<XmlElement, Array<License>> {
+function extractLicenses(): ChainableFunction<XmlElement, Array<Constraint>> {
   return pipe(
     findChildrenElement('gmd:MD_LegalConstraints', false),
     filterArray(
@@ -246,15 +254,18 @@ function extractLicenses(): ChainableFunction<XmlElement, Array<License>> {
       )
     ),
     mapArray(
-      pipe(
-        findChildElement('gmd:otherConstraints'),
-        combine(extractCharacterString(), extractUrl()),
-        map(([text, url]) => ({
-          ...(url && { url }),
-          text,
-        }))
+      combine(
+        findChildrenElement('gmd:otherConstraints'),
+        findChildrenElement('gmd:useLimitation')
       )
-    )
+    ),
+    flattenArray(),
+    flattenArray(),
+    mapArray(combine(extractCharacterString(), extractUrl())),
+    mapArray(([text, url]) => ({
+      ...(url && { url }),
+      text,
+    }))
   )
 }
 
@@ -579,24 +590,32 @@ const getConstraints = pipe(
   findChildrenElement('gmd:resourceConstraints', false)
 )
 
-export function readAccessConstraints(rootEl: XmlElement): AccessConstraint[] {
+export function readLegalConstraints(rootEl: XmlElement): Constraint[] {
   return pipe(
     getConstraints,
-    mapArray(extractAccessConstraints()),
+    mapArray(extractLegalConstraints()),
     flattenArray(),
     flattenArray()
   )(rootEl)
 }
 
-export function readUseLimitations(rootEl: XmlElement): string[] {
+export function readSecurityConstraints(rootEl: XmlElement): Constraint[] {
+  return pipe(
+    getConstraints,
+    mapArray(extractSecurityConstraints()),
+    flattenArray()
+  )(rootEl)
+}
+
+export function readOtherConstraints(rootEl: XmlElement): Constraint[] {
   return pipe(
     getConstraints,
-    mapArray(extractUseLimitations()),
+    mapArray(extractOtherConstraints()),
     flattenArray()
   )(rootEl)
 }
 
-export function readLicenses(rootEl: XmlElement): License[] {
+export function readLicenses(rootEl: XmlElement): Constraint[] {
   return pipe(
     getConstraints,
     mapArray(extractLicenses()),

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

@@ -1,11 +1,10 @@
 import {
-  AccessConstraint,
   CatalogRecord,
+  Constraint,
   DatasetDistribution,
   DatasetRecord,
   DatasetServiceDistribution,
   Individual,
-  License,
   RecordStatus,
   Role,
   ServiceEndpoint,
@@ -374,35 +373,11 @@ function appendKeywords(keywords: string[], type: string | null) {
   )
 }
 
-function removeAccessConstraints() {
-  const securityConstraintsFilter = pipe(
-    findChildrenElement('gmd:MD_SecurityConstraints'),
-    (array) => array.length > 0
-  )
-
-  // remove legal constraints that *only* have 'otherRestrictions'
-  const otherConstraintsFilter = pipe(
-    findNestedElements(
-      'gmd:MD_LegalConstraints',
-      'gmd:accessConstraints',
-      'gmd:MD_RestrictionCode'
-    ),
-    mapArray(readAttribute('codeListValue')),
-    (restrictionCodes) =>
-      restrictionCodes.every((code) => code === 'otherRestrictions')
-  )
-  return removeChildren(
-    pipe(
-      findChildrenElement('gmd:resourceConstraints'),
-      filterArray(
-        (el) => securityConstraintsFilter(el) || otherConstraintsFilter(el)
-      )
-    )
-  )
-}
-
-function createAccessConstraint(constraint: AccessConstraint) {
-  if (constraint.type === 'security') {
+function createConstraint(
+  constraint: Constraint,
+  type: 'legal' | 'security' | 'other'
+) {
+  if (type === 'security') {
     return pipe(
       createElement('gmd:resourceConstraints'),
       createChild('gmd:MD_SecurityConstraints'),
@@ -422,29 +397,41 @@ function createAccessConstraint(constraint: AccessConstraint) {
         )
       )
     )
+  } else if (type === 'legal') {
+    return pipe(
+      createElement('gmd:resourceConstraints'),
+      createChild('gmd:MD_LegalConstraints'),
+      appendChildren(
+        pipe(
+          createElement('gmd:accessConstraints'),
+          createChild('gmd:MD_RestrictionCode'),
+          addAttribute(
+            'codeList',
+            'http://standards.iso.org/iso/19139/resources/gmxCodelists.xml#MD_RestrictionCode'
+          ),
+          addAttribute('codeListValue', 'otherRestrictions')
+        ),
+        pipe(
+          createElement('gmd:otherConstraints'),
+          writeCharacterString(constraint.text)
+        )
+      )
+    )
   }
+
   return pipe(
     createElement('gmd:resourceConstraints'),
-    createChild('gmd:MD_LegalConstraints'),
+    createChild('gmd:MD_Constraints'),
     appendChildren(
       pipe(
-        createElement('gmd:accessConstraints'),
-        createChild('gmd:MD_RestrictionCode'),
-        addAttribute(
-          'codeList',
-          'http://standards.iso.org/iso/19139/resources/gmxCodelists.xml#MD_RestrictionCode'
-        ),
-        addAttribute('codeListValue', 'otherRestrictions')
-      ),
-      pipe(
-        createElement('gmd:otherConstraints'),
+        createElement('gmd:useLimitation'),
         writeCharacterString(constraint.text)
       )
     )
   )
 }
 
-function removeUseLimitations() {
+function removeOtherConstraints() {
   return removeChildren(
     pipe(
       findChildrenElement('gmd:resourceConstraints'),
@@ -458,12 +445,37 @@ function removeUseLimitations() {
   )
 }
 
-function createUseLimitation(useLimitation: string) {
-  return pipe(
-    createElement('gmd:resourceConstraints'),
-    createChild('gmd:MD_Constraints'),
-    createChild('gmd:useLimitation'),
-    writeCharacterString(useLimitation)
+function removeSecurityConstraints() {
+  return removeChildren(
+    pipe(
+      findChildrenElement('gmd:resourceConstraints'),
+      filterArray(
+        pipe(
+          findNestedElements('gmd:MD_SecurityConstraints', 'gmd:useLimitation'),
+          (array) => array.length > 0
+        )
+      )
+    )
+  )
+}
+
+function removeLegalConstraints() {
+  return removeChildren(
+    pipe(
+      findChildrenElement('gmd:resourceConstraints'),
+      filterArray(
+        pipe(
+          findNestedElements(
+            'gmd:MD_LegalConstraints',
+            'gmd:accessConstraints',
+            'gmd:MD_RestrictionCode'
+          ),
+          mapArray(readAttribute('codeListValue')),
+          (restrictionCodes) =>
+            restrictionCodes.every((code) => code !== 'license')
+        )
+      )
+    )
   )
 }
 
@@ -487,7 +499,7 @@ function removeLicenses() {
   )
 }
 
-function createLicense(license: License) {
+function createLicense(license: Constraint) {
   return pipe(
     createElement('gmd:resourceConstraints'),
     createChild('gmd:MD_LegalConstraints'),
@@ -741,30 +753,50 @@ export function writeThemes(record: CatalogRecord, rootEl: XmlElement) {
   )(rootEl)
 }
 
-export function writeAccessConstraints(
+export function writeLicenses(record: CatalogRecord, rootEl: XmlElement) {
+  pipe(
+    findOrCreateIdentification(),
+    removeLicenses(),
+    appendChildren(...record.licenses.map(createLicense))
+  )(rootEl)
+}
+
+export function writeLegalConstraints(
   record: CatalogRecord,
   rootEl: XmlElement
 ) {
   pipe(
     findOrCreateIdentification(),
-    removeAccessConstraints(),
-    appendChildren(...record.accessConstraints.map(createAccessConstraint))
+    removeLegalConstraints(),
+    appendChildren(
+      ...record.legalConstraints.map((c) => createConstraint(c, 'legal'))
+    )
   )(rootEl)
 }
 
-export function writeLicenses(record: CatalogRecord, rootEl: XmlElement) {
+export function writeSecurityConstraints(
+  record: CatalogRecord,
+  rootEl: XmlElement
+) {
   pipe(
     findOrCreateIdentification(),
-    removeLicenses(),
-    appendChildren(...record.licenses.map(createLicense))
+    removeSecurityConstraints(),
+    appendChildren(
+      ...record.securityConstraints.map((c) => createConstraint(c, 'security'))
+    )
   )(rootEl)
 }
 
-export function writeUseLimitations(record: CatalogRecord, rootEl: XmlElement) {
+export function writeOtherConstraints(
+  record: CatalogRecord,
+  rootEl: XmlElement
+) {
   pipe(
     findOrCreateIdentification(),
-    removeUseLimitations(),
-    appendChildren(...record.useLimitations.map(createUseLimitation))
+    removeOtherConstraints(),
+    appendChildren(
+      ...record.otherConstraints.map((c) => createConstraint(c, 'other'))
+    )
   )(rootEl)
 }
 

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

@@ -6,3 +6,5 @@ export * from './auth'
 export * from './favorites/favorites.service'
 export * from './selection/selection.service'
 export * from './gn4.provider'
+export * from './platform/gn4-platform.service'
+export * from './platform/gn4-platform.mapper'

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

@@ -45,12 +45,23 @@ export class Gn4PlatformMapper {
     return { ...apiUser, id: id.toString() } as UserModel
   }
 
-  thesaurusFromApi(thesaurus: any[]): ThesaurusModel {
+  thesaurusFromApi(thesaurus: any[], lang3?: string): ThesaurusModel {
     return thesaurus.map((keyword) => {
-      const { uri, value } = keyword
+      let key = keyword.uri
+      // sometines GN can prefix an URI with an "all thesaurus" URI; only keep the last one
+      if (key.indexOf('@@@') > -1) {
+        key = key.split('@@@')[1]
+      }
+      const label =
+        lang3 && lang3 in keyword.values ? keyword.values[lang3] : keyword.value
+      const description =
+        lang3 && lang3 in keyword.definitions
+          ? keyword.definitions[lang3]
+          : keyword.definition
       return {
-        key: uri,
-        label: value,
+        key,
+        label,
+        description,
       }
     })
   }

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

@@ -14,8 +14,10 @@ import { Organization } from '../../../../../../../libs/common/domain/src/lib/mo
 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'
 
 const minApiVersion = '4.2.2'
+
 @Injectable()
 export class Gn4PlatformService implements PlatformServiceInterface {
   private readonly type = 'GeoNetwork'
@@ -50,13 +52,20 @@ export class Gn4PlatformService implements PlatformServiceInterface {
     shareReplay(1)
   )
 
+  /**
+   * A map of already loaded thesauri (groups of keywords); the key is a URI
+   * @private
+   */
+  private thesauri: Record<string, Observable<ThesaurusModel>> = {}
+
   constructor(
     private siteApiService: SiteApiService,
     private meApi: MeApiService,
     private usersApi: UsersApiService,
     private mapper: Gn4PlatformMapper,
     private toolsApiService: ToolsApiService,
-    private registriesApiService: RegistriesApiService
+    private registriesApiService: RegistriesApiService,
+    private langService: LangService
   ) {
     this.me$ = this.meApi.getMe().pipe(
       switchMap((apiUser) => this.mapper.userFromMeApi(apiUser)),
@@ -98,17 +107,47 @@ export class Gn4PlatformService implements PlatformServiceInterface {
   }
 
   translateKey(key: string): Observable<string> {
+    // if the key is a URI, use the registries API to look for the translation
+    if (key.match(/^https?:\/\//)) {
+      // 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(
+        map((thesaurus) => {
+          for (const item of thesaurus) {
+            if (item.key === key) return item.label
+          }
+          return key
+        })
+      )
+    }
     return this.keyTranslations$.pipe(map((translations) => translations[key]))
   }
 
-  getThesaurusByLang(
-    thesaurusName: string,
-    lang: string
-  ): Observable<ThesaurusModel> {
-    return this.registriesApiService
-      .searchKeywords(null, lang, 1000, 0, null, [thesaurusName])
+  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[]))
+        map((thesaurus) =>
+          this.mapper.thesaurusFromApi(
+            thesaurus as any[],
+            this.langService.iso3
+          )
+        ),
+        shareReplay(1)
       )
+    return this.thesauri[uri]
   }
 }