geonetwork-ui 2.2.0-dev.81737006 → 2.2.0-dev.8a17994e

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

@@ -1,8 +1,10 @@
 import {
+  getArrayItem,
   getAsArray,
   getAsUrl,
   getFirstValue,
   mapContact,
+  mapKeywords,
   selectFallback,
   selectFallbackFields,
   selectField,
@@ -16,16 +18,18 @@ import { Injectable } from '@angular/core'
 import { getStatusFromStatusCode } from '../iso19139/codelists/status.mapper'
 import { getUpdateFrequencyFromFrequencyCode } from '../iso19139/codelists/update-frequency.mapper'
 import {
-  AccessConstraintType,
   CatalogRecord,
+  Constraint,
   DatasetDistribution,
   DatasetDistributionType,
   DatasetDownloadDistribution,
   DatasetServiceDistribution,
+  DatasetSpatialExtent,
   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
 
@@ -90,8 +94,8 @@ export class Gn4FieldMapper {
     },
     cl_topic: (output, source) => ({
       ...output,
-      themes: [
-        ...(output.themes || []),
+      topics: [
+        ...(output.topics || []),
         ...getAsArray(
           selectField<SourceWithUnknownProps[]>(source, 'cl_topic')
         ).map((topic) => selectTranslatedValue<string>(topic, this.lang3)),
@@ -128,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')
@@ -169,51 +189,56 @@ export class Gn4FieldMapper {
         output
       )
     },
-    tag: (output, source) => ({
+    allKeywords: (output, source) => ({
       ...output,
-      keywords: getAsArray(
-        selectField<SourceWithUnknownProps[]>(source, 'tag')
-      ).map((tag) => selectTranslatedValue<string>(tag, this.lang3)),
+      keywords: mapKeywords(
+        selectField<Thesaurus[]>(source, 'allKeywords'),
+        this.lang3
+      ),
     }),
     inspireTheme: (output, source) => ({
       ...output,
-      themes: [
-        ...(output.themes || []),
+      topics: [
+        ...(output.topics || []),
         ...getAsArray(selectField(source, 'inspireTheme_syn')),
       ],
     }),
     MD_ConstraintsUseLimitationObject: (output, source) =>
-      this.constraintField('MD_ConstraintsUseLimitationObject', output, source),
+      this.constraintField(
+        'other',
+        output,
+        getAsArray(selectField(source, 'MD_ConstraintsUseLimitationObject'))
+      ),
     MD_LegalConstraintsUseLimitationObject: (output, source) =>
       this.constraintField(
-        'MD_LegalConstraintsUseLimitationObject',
+        'legal',
         output,
-        source
+        getAsArray(
+          selectField(source, 'MD_LegalConstraintsUseLimitationObject')
+        )
       ),
     MD_LegalConstraintsOtherConstraintsObject: (output, source) =>
       this.constraintField(
-        'MD_LegalConstraintsOtherConstraintsObject',
+        'legal',
         output,
-        source
+        getAsArray(
+          selectField(source, 'MD_LegalConstraintsOtherConstraintsObject')
+        )
       ),
     MD_SecurityConstraintsUseLimitationObject: (output, source) =>
       this.constraintField(
-        'MD_SecurityConstraintsUseLimitationObject',
+        'security',
         output,
-        source
+        getAsArray(
+          selectField(source, 'MD_SecurityConstraintsUseLimitationObject')
+        )
+      ),
+    licenseObject: (output, source) =>
+      this.constraintField(
+        'license',
+        output,
+        getAsArray(selectField(source, 'licenseObject'))
       ),
-    licenseObject: (output, source) => ({
-      ...output,
-      licenses: getAsArray(
-        selectField<SourceWithUnknownProps[]>(source, 'licenseObject')
-      ).map((license) => {
-        const link = getAsUrl(selectField(license, 'link'))
-        return {
-          text: selectTranslatedValue<string>(license, this.lang3),
-          ...(link ? { link } : {}),
-        }
-      }),
-    }),
     lineageObject: (output, source) => ({
       ...output,
       lineage: selectTranslatedField(source, 'lineageObject', this.lang3),
@@ -258,57 +283,98 @@ export class Gn4FieldMapper {
         kind,
       }
     },
+    geom: (output, source) => {
+      const geoms = getAsArray(selectField(source, 'geom'))
+      const shapes = getAsArray(selectField(source, 'shape'))
+      const extentDescriptions = getAsArray(
+        selectField(source, 'extentDescriptionObject')
+      )
+      const spatialExtents = getAsArray(selectField(source, 'spatialExtents'))
+      return {
+        ...output,
+        spatialExtents: [
+          ...spatialExtents,
+          ...geoms.map((geom, index) => {
+            const description = selectTranslatedValue(
+              getArrayItem(extentDescriptions, index),
+              this.lang3
+            )
+            const geometry = shapes[index] ?? geom
+            return {
+              ...(description !== null ? { description } : null),
+              geometry,
+            } as DatasetSpatialExtent
+          }),
+        ],
+      }
+    },
+    resourceTemporalExtentDateRange: (output, source) => {
+      const ranges = getAsArray(
+        selectField(source, 'resourceTemporalExtentDateRange')
+      )
+      return {
+        ...output,
+        temporalExtents: ranges.map((range) => {
+          const start = selectField(range, 'gte')
+          const end = selectField(range, 'lte')
+          return {
+            ...(start !== null ? { start: toDate(start) } : null),
+            ...(end !== null ? { end: toDate(end) } : null),
+          }
+        }),
+      }
+    },
   }
 
   private genericField = (output) => output
 
-  private constraintField = (fieldName: string, output, source) => ({
-    ...output,
-    ...(fieldName.endsWith('UseLimitationObject')
-      ? {
-          legalConstraints:
-            fieldName === 'MD_LegalConstraintsUseLimitationObject'
-              ? [
-                  ...(output.legalConstraints || []),
-                  ...selectField<SourceWithUnknownProps[]>(
-                    source,
-                    fieldName
-                  ).map((source: SourceWithUnknownProps) =>
-                    selectTranslatedValue(source, this.lang3)
-                  ),
-                ]
-              : output.legalConstraints || [],
-          useLimitations: [
-            ...(output.useLimitations || []),
-            ...selectField<SourceWithUnknownProps[]>(source, fieldName).map(
-              (source: SourceWithUnknownProps) =>
-                selectTranslatedValue(source, this.lang3)
-            ),
-          ],
+  private constraintField = (
+    type: 'license' | 'legal' | 'security' | 'other',
+    output: Partial<CatalogRecord>,
+    constraintArray: SourceWithUnknownProps[]
+  ) => {
+    let outputField: string
+    switch (type) {
+      case 'license':
+        outputField = 'licenses'
+        break
+      case 'legal':
+        outputField = 'legalConstraints'
+        break
+      case 'security':
+        outputField = 'securityConstraints'
+        break
+      case 'other':
+        outputField = 'otherConstraints'
+        break
+    }
+    const outputArray: Constraint[] =
+      outputField in output ? output[outputField] : []
+    outputArray.push(
+      ...constraintArray.map((item) => {
+        const text = selectTranslatedValue(item, this.lang3) as string
+        const url = getAsUrl(selectField(item, 'link'))
+        return {
+          text,
+          ...(url ? { url } : {}),
         }
-      : {
-          accessConstraints: [
-            ...(output.accessConstraints || []),
-            ...selectField<SourceWithUnknownProps[]>(source, fieldName).map(
-              (field) => ({
-                text: selectTranslatedValue(field, this.lang3),
-                type: this.getConstraintsType(fieldName),
-              })
-            ),
-          ],
-        }),
-  })
-
-  private getConstraintsType(indexField: string): AccessConstraintType {
-    switch (indexField) {
-      case 'MD_LegalConstraintsUseLimitationObject':
-        return 'legal'
-      case 'MD_SecurityConstraintsUseLimitationObject':
-        return 'security'
-      case 'MD_ConstraintsUseLimitationObject':
-      default:
-        return 'other'
+      })
+    )
+    const result = {
+      ...output,
+      [outputField]: outputArray,
+    }
+    // avoid legal constraints being duplicates of licenses
+    if (
+      'legalConstraints' in result &&
+      (type === 'legal' || type === 'license')
+    ) {
+      result.legalConstraints = result.legalConstraints.filter(
+        (constraint) =>
+          !output.licenses?.some((license) => license.text === constraint.text)
+      )
     }
+    return result
   }
 
   getMappingFn(fieldName: string) {

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

@@ -24,16 +24,20 @@ export class Gn4MetadataMapper extends MetadataBaseMapper<Gn4Record> {
       status: null,
       lineage: null,
       recordUpdated: null,
+      recordPublished: null,
       ownerOrganization: null,
       licenses: [],
+      legalConstraints: [],
+      securityConstraints: [],
+      otherConstraints: [],
       contacts: [],
       contactsForResource: [],
-      accessConstraints: [],
       keywords: [],
-      themes: [],
-      useLimitations: [],
+      topics: [],
       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

@@ -56,15 +56,13 @@ interface SpecificationConformance {
   pass: BooleanString
 }
 
-type Keyword = MultilingualField
-type Keywords = Keyword[]
 type ThesaurusName = string
-interface Thesaurus {
+export interface Thesaurus {
   id?: string
   title?: string
   theme?: string
   link?: string
-  keywords: Keywords
+  keywords: MultilingualField[]
 }
 
 export interface Link {
@@ -152,6 +150,7 @@ export type MetadataObject = Partial<{
   pointOfContactOrg: string
   pointOfContactOrgForResource: string
   popularity: number
+  publicationDateForResource: string
   rating: string
   record: string
   recordGroup: string
@@ -175,7 +174,7 @@ export type MetadataObject = Partial<{
   specificationConformance: MaybeArray<SpecificationConformance>
   standardNameObject: MultilingualField
   standardVersionObject: MultilingualField
-  tag: Keywords
+  tag: MultilingualField[]
   tagNumber: string
   userSavedCount: string
   userinfo: string

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

@@ -0,0 +1,16 @@
+import { KeywordType } from '../../../../../../../libs/common/domain/src/lib/model/record'
+
+export function getKeywordTypeFromKeywordTypeCode(
+  typeCode: string
+): KeywordType {
+  if (!typeCode) return 'other'
+  switch (typeCode) {
+    case 'theme':
+    case 'place':
+    case 'temporal':
+    case 'other':
+      return typeCode
+    default:
+      return 'other'
+  }
+}

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,
+  writeTopics,
   writeTitle,
   writeUniqueIdentifier,
   writeUpdateFrequency,
-  writeUseLimitations,
 } from './write-parts'
 import {
   readAbstract,
-  readAccessConstraints,
   readContacts,
   readDatasetCreated,
   readDatasetUpdated,
@@ -43,21 +43,23 @@ import {
   readIsoTopics,
   readKeywords,
   readKind,
+  readLegalConstraints,
   readLicenses,
   readLineage,
   readOnlineResources,
+  readOtherConstraints,
   readOverviews,
   readOwnerOrganization,
   readRecordUpdated,
+  readRecordPublished,
+  readSecurityConstraints,
   readSpatialExtents,
   readSpatialRepresentation,
   readStatus,
   readTemporalExtents,
-  readThemes,
   readTitle,
   readUniqueIdentifier,
   readUpdateFrequency,
-  readUseLimitations,
 } from './read-parts'
 import { isEqual } from '../convert-utils'
 
@@ -73,16 +75,15 @@ 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 themes = readThemes(rootEl)
-  const accessConstraints = readAccessConstraints(rootEl)
-  const useLimitations = readUseLimitations(rootEl)
+  const topics = readIsoTopics(rootEl)
+  const legalConstraints = readLegalConstraints(rootEl)
+  const otherConstraints = readOtherConstraints(rootEl)
+  const securityConstraints = readSecurityConstraints(rootEl)
   const licenses = readLicenses(rootEl)
   const overviews = readOverviews(rootEl)
 
-  // not used yet
-  const isoTopics = readIsoTopics(rootEl)
-
   if (kind === 'dataset') {
     const status = readStatus(rootEl)
     const datasetCreated = readDatasetCreated(rootEl)
@@ -97,8 +98,10 @@ export function toModel(xml: string): CatalogRecord {
     return {
       uniqueIdentifier,
       kind,
+      languages: [],
       recordCreated,
       recordUpdated,
+      recordPublished,
       status,
       title,
       abstract,
@@ -106,10 +109,11 @@ export function toModel(xml: string): CatalogRecord {
       contacts,
       contactsForResource: [], // FIXME: is that really useful??
       keywords,
-      themes,
-      accessConstraints,
-      useLimitations,
+      topics,
       licenses,
+      legalConstraints,
+      securityConstraints,
+      otherConstraints,
       ...(datasetCreated && { datasetCreated }),
       ...(datasetUpdated && { datasetUpdated }),
       lineage,
@@ -125,17 +129,20 @@ export function toModel(xml: string): CatalogRecord {
     return {
       uniqueIdentifier,
       kind,
+      languages: [],
       recordCreated,
       recordUpdated,
+      recordPublished,
       title,
       abstract,
       ownerOrganization,
       contacts,
       keywords,
-      themes,
-      accessConstraints,
-      useLimitations,
+      topics,
       licenses,
+      legalConstraints,
+      securityConstraints,
+      otherConstraints,
       overviews,
       onlineResources,
     } as ServiceRecord
@@ -163,10 +170,12 @@ export function toXml(record: CatalogRecord, originalXml?: string): string {
   writeAbstract(record, rootEl)
   fieldChanged('contacts') && writeContacts(record, rootEl)
   fieldChanged('keywords') && writeKeywords(record, rootEl)
-  fieldChanged('themes') && writeThemes(record, rootEl)
-  fieldChanged('accessConstraints') && writeAccessConstraints(record, rootEl)
+  fieldChanged('topics') && writeTopics(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)