geonetwork-ui 2.2.0-dev.886aae61 → 2.2.0-dev.95b40cd8

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

@@ -1,4 +1,5 @@
 import {
+  getArrayItem,
   getAsArray,
   getAsUrl,
   getFirstValue,
@@ -16,12 +17,13 @@ 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'
@@ -183,37 +185,41 @@ export class Gn4FieldMapper {
       ],
     }),
     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 +264,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
+          }),
+        ],
+      }
+    },
+    resourceTemporalDateRange: (output, source) => {
+      const ranges = getAsArray(
+        selectField(source, 'resourceTemporalDateRange')
+      )
+      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

@@ -26,14 +26,16 @@ export class Gn4MetadataMapper extends MetadataBaseMapper<Gn4Record> {
       recordUpdated: null,
       ownerOrganization: null,
       licenses: [],
+      legalConstraints: [],
+      securityConstraints: [],
+      otherConstraints: [],
       contacts: [],
       contactsForResource: [],
-      accessConstraints: [],
       keywords: [],
       themes: [],
-      useLimitations: [],
       spatialExtents: [],
       temporalExtents: [],
+      overviews: [],
     }
     const record: CatalogRecord = Object.keys(_source).reduce(
       (prev, fieldName) =>

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()),