geonetwork-ui 2.2.0-dev.f866474c → 2.3.0-dev.139106e0

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,
@@ -13,19 +15,21 @@ import {
 } from './atomic-operations'
 import { MetadataUrlService } from './metadata-url.service'
 import { Injectable } from '@angular/core'
-import { getStatusFromStatusCode } from '../iso19139/codelists/status.mapper'
-import { getUpdateFrequencyFromFrequencyCode } from '../iso19139/codelists/update-frequency.mapper'
+import { getStatusFromStatusCode } from '../iso19139/utils/status.mapper'
+import { getUpdateFrequencyFromFrequencyCode } from '../iso19139/utils/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)),
@@ -116,10 +120,16 @@ export class Gn4FieldMapper {
     }),
     creationDateForResource: (output, source) => ({
       ...output,
-      datasetCreated: toDate(
+      resourceCreated: toDate(
         getFirstValue(selectField<string>(source, 'creationDateForResource'))
       ),
     }),
+    revisionDateForResource: (output, source) => ({
+      ...output,
+      resourceUpdated: toDate(
+        getFirstValue(selectField<string>(source, 'revisionDateForResource'))
+      ),
+    }),
     createDate: (output, source) => ({
       ...output,
       recordCreated: toDate(selectField<string>(source, 'createDate')),
@@ -128,6 +138,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 +195,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 +289,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/index.ts

@@ -0,0 +1,3 @@
+export * from './gn4.converter'
+export * from './atomic-operations'
+export * from './types'

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/iso19115-3/index.ts

@@ -0,0 +1 @@
+export * from './iso19115-3.converter'

package/src/libs/api/metadata-converter/src/lib/iso19115-3/iso19115-3.converter.ts

@@ -0,0 +1,176 @@
+import { Iso19139Converter } from '../iso19139'
+import {
+  readContacts,
+  readDistributions,
+  readKind,
+  readLandingPage,
+  readLineage,
+  readOwnerOrganization,
+  readRecordCreated,
+  readRecordPublished,
+  readRecordUpdated,
+  readResourceContacts,
+  readUniqueIdentifier,
+} from './read-parts'
+import {
+  writeContacts,
+  writeContactsForResource,
+  writeDistributions,
+  writeKind,
+  writeLandingPage,
+  writeLineage,
+  writeOwnerOrganization,
+  writeRecordCreated,
+  writeRecordPublished,
+  writeRecordUpdated,
+  writeResourceCreated,
+  writeResourcePublished,
+  writeResourceUpdated,
+  writeSpatialRepresentation,
+  writeStatus,
+  writeUniqueIdentifier,
+} from './write-parts'
+import { XmlElement } from '@rgrove/parse-xml'
+import { renameElements } from '../xml-utils'
+import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
+
+export class Iso191153Converter extends Iso19139Converter {
+  constructor() {
+    super()
+
+    this.readers['uniqueIdentifier'] = readUniqueIdentifier
+    this.readers['kind'] = readKind
+    this.readers['recordUpdated'] = readRecordUpdated
+    this.readers['recordCreated'] = readRecordCreated
+    this.readers['recordPublished'] = readRecordPublished
+    this.readers['contacts'] = readContacts
+    this.readers['contactsForResource'] = readResourceContacts
+    this.readers['ownerOrganization'] = readOwnerOrganization
+    this.readers['landingPage'] = readLandingPage
+    this.readers['lineage'] = readLineage
+    this.readers['distributions'] = readDistributions
+
+    this.writers['uniqueIdentifier'] = writeUniqueIdentifier
+    this.writers['kind'] = writeKind
+    this.writers['recordUpdated'] = writeRecordUpdated
+    this.writers['recordCreated'] = writeRecordCreated
+    this.writers['recordPublished'] = writeRecordPublished
+    this.writers['resourceUpdated'] = writeResourceUpdated
+    this.writers['resourceCreated'] = writeResourceCreated
+    this.writers['resourcePublished'] = writeResourcePublished
+    this.writers['contacts'] = writeContacts
+    this.writers['contactsForResource'] = writeContactsForResource
+    this.writers['ownerOrganization'] = writeOwnerOrganization
+    this.writers['landingPage'] = writeLandingPage
+    this.writers['lineage'] = writeLineage
+    this.writers['distributions'] = writeDistributions
+    this.writers['status'] = writeStatus
+    this.writers['spatialRepresentation'] = writeSpatialRepresentation
+  }
+
+  beforeDocumentCreation(rootEl: XmlElement) {
+    renameElements(rootEl, {
+      gmd: 'mdb',
+      'gmd:characterEncoding': 'lan:characterEncoding',
+      'gmd:MD_CharacterSetCode': 'lan:MD_CharacterSetCode',
+      'gmd:MD_DataIdentification': 'mri:MD_DataIdentification',
+      'gmd:citation': 'mri:citation',
+      'gmd:abstract': 'mri:abstract',
+      'gmd:title': 'cit:title',
+      'gmd:CI_Citation': 'cit:CI_Citation',
+      'gmx:Anchor': 'gcx:Anchor',
+
+      // languages
+      'gmd:PT_Locale': 'lan:PT_Locale',
+      'gmd:languageCode': 'lan:languageCode',
+      'gmd:LanguageCode': 'lan:LanguageCode',
+
+      // status
+      'gmd:status': 'mri:status',
+      'gmd:MD_ProgressCode': 'mri:MD_ProgressCode',
+
+      // dates
+      'gmd:date': 'cit:date',
+      'gmd:CI_Date': 'cit:CI_Date',
+      'gmd:dateType': 'cit:dateType',
+      'gmd:CI_DateTypeCode': 'cit:CI_DateTypeCode',
+
+      // contacts
+      'gmd:CI_Responsibility': 'cit:CI_Responsibility',
+      'gmd:role': 'cit:role',
+      'gmd:CI_RoleCode': 'cit:CI_RoleCode',
+
+      // keywords
+      'gmd:descriptiveKeywords': 'mri:descriptiveKeywords',
+      'gmd:MD_Keywords': 'mri:MD_Keywords',
+      'gmd:type': 'mri:type',
+      'gmd:MD_KeywordTypeCode': 'mri:MD_KeywordTypeCode',
+      'gmd:thesaurusName': 'mri:thesaurusName',
+      'gmd:keyword': 'mri:keyword',
+      'gmd:identifier': 'cit:identifier',
+      'gmd:MD_Identifier': 'mcc:MD_Identifier',
+      'gmd:code': 'mcc:code',
+
+      // distributions
+      'gmd:MD_Distribution': 'mrd:MD_Distribution',
+      'gmd:transferOptions': 'mrd:transferOptions',
+      'gmd:MD_DigitalTransferOptions': 'mrd:MD_DigitalTransferOptions',
+      'gmd:onLine': 'mrd:onLine',
+      'gmd:distributionFormat': 'mrd:distributionFormat',
+      'gmd:MD_Format': 'mrd:MD_Format',
+      'gmd:CI_OnlineResource': 'cit:CI_OnlineResource',
+      'gmd:linkage': 'cit:linkage',
+      'gmd:name': 'cit:name',
+      'gmd:description': 'cit:description',
+      'gmd:CI_OnLineFunctionCode': 'cit:CI_OnLineFunctionCode',
+      'gmd:function': 'cit:function',
+      'gmd:protocol': 'cit:protocol',
+
+      // topic
+      'gmd:topicCategory': 'mri:topicCategory',
+      'gmd:MD_TopicCategoryCode': 'mri:MD_TopicCategoryCode',
+
+      // update frequency
+      'gmd:resourceMaintenance': 'mri:resourceMaintenance',
+      'gmd:MD_MaintenanceInformation': 'mmi:MD_MaintenanceInformation',
+      'gmd:userDefinedMaintenanceFrequency':
+        'mmi:userDefinedMaintenanceFrequency',
+      'gts:TM_PeriodDuration': 'gco:TM_PeriodDuration',
+
+      // constraints
+      'gmd:resourceConstraints': 'mri:resourceConstraints',
+      'gmd:MD_Constraints': 'mco:MD_Constraints',
+      'gmd:MD_LegalConstraints': 'mco:MD_LegalConstraints',
+      'gmd:MD_SecurityConstraints': 'mco:MD_SecurityConstraints',
+      'gmd:useLimitation': 'mco:useLimitation',
+      'gmd:useConstraints': 'mco:useConstraints',
+      'gmd:accessConstraints': 'mco:accessConstraints',
+      'gmd:otherConstraints': 'mco:otherConstraints',
+      'gmd:MD_RestrictionCode': 'mco:MD_RestrictionCode',
+      'gmd:classification': 'mco:classification',
+      'gmd:MD_ClassificationCode': 'mco:MD_ClassificationCode',
+
+      // overviews
+      'gmd:graphicOverview': 'mri:graphicOverview',
+      'gmd:MD_BrowseGraphic': 'mcc:MD_BrowseGraphic',
+      'gmd:fileName': 'mcc:fileName',
+      'gmd:fileDescription': 'mcc:fileDescription',
+
+      // no more URL elements
+      'gmd:URL': 'gco:CharacterString',
+    })
+  }
+
+  async writeRecord(
+    record: CatalogRecord,
+    reference?: string
+  ): Promise<string> {
+    let result = await super.writeRecord(record, reference)
+    // fix gco namespace definition (changes between iso19139 and iso19115-3
+    result = result.replace(
+      '"http://www.isotc211.org/2005/gco"',
+      '"http://standards.iso.org/iso/19115/-3/gco/1.0"'
+    )
+    return result
+  }
+}