geonetwork-ui 2.3.0-dev.2c3530dc → 2.3.0-dev.3222f975

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

@@ -15,8 +15,8 @@ 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 {
   CatalogRecord,
   Constraint,
@@ -120,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')),

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/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
+  }
+}

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

@@ -0,0 +1,329 @@
+import {
+  findChildElement,
+  findChildrenElement,
+  findNestedElement,
+  findNestedElements,
+  findParent,
+  readAttribute,
+  XmlElement,
+} from '../xml-utils'
+import {
+  ChainableFunction,
+  combine,
+  filterArray,
+  flattenArray,
+  getAtIndex,
+  map,
+  mapArray,
+  pipe,
+} from '../function-utils'
+import {
+  extractCharacterString,
+  extractDatasetDistributions,
+  extractDateTime,
+  extractRole,
+  extractUrl,
+  findIdentification,
+} from '../iso19139/read-parts'
+import {
+  DatasetDistribution,
+  Individual,
+  Organization,
+  RecordKind,
+  Role,
+} from '../../../../../../libs/common/domain/src/lib/model/record'
+import { matchMimeType } from '../common/distribution.mapper'
+import { fullNameToParts } from '../iso19139/utils/individual-name'
+
+export function readKind(rootEl: XmlElement): RecordKind {
+  return pipe(
+    findNestedElement(
+      'mdb:metadataScope',
+      'mdb:MD_MetadataScope',
+      'mdb:resourceScope',
+      'mcc:MD_ScopeCode'
+    ),
+    readAttribute('codeListValue'),
+    map(
+      (scopeCode): RecordKind =>
+        scopeCode === 'service' ? 'service' : 'dataset'
+    )
+  )(rootEl)
+}
+
+export function findDistribution() {
+  return findNestedElement('mdb:distributionInfo', 'mrd:MD_Distribution')
+}
+
+// from cit:CI_Organisation
+export function extractOrganization(): ChainableFunction<
+  XmlElement,
+  Organization
+> {
+  const getUrl = pipe(
+    findNestedElements(
+      'cit:contactInfo',
+      'cit:CI_Contact',
+      'cit:onlineResource',
+      'cit:CI_OnlineResource',
+      'cit:linkage'
+    ),
+    getAtIndex(0),
+    extractUrl()
+  )
+  return pipe(
+    combine(
+      pipe(findChildElement('cit:name', false), extractCharacterString()),
+      getUrl
+    ),
+    map(([name, website]) => ({
+      name,
+      ...(website && { website }),
+    }))
+  )
+}
+
+// from cit:CI_Individual or cit:CI_Organisation
+export function extractIndividual(
+  role: Role,
+  organization?: Organization,
+  orgContact?: Individual
+): ChainableFunction<XmlElement, Individual> {
+  const getPosition = pipe(
+    findChildElement('cit:positionName'),
+    extractCharacterString()
+  )
+  const getNameParts = pipe(
+    findChildElement('cit:name'),
+    extractCharacterString(),
+    map((fullName) => {
+      if (!fullName) return []
+      return fullNameToParts(fullName)
+    })
+  )
+  const getContact = findNestedElement('cit:contactInfo', 'cit:CI_Contact')
+  const getAddressRoot = pipe(
+    getContact,
+    findNestedElement('cit:address', 'cit:CI_Address')
+  )
+  const getAddress = pipe(
+    getAddressRoot,
+    combine(
+      pipe(
+        findChildElement('cit:deliveryPoint', false),
+        extractCharacterString()
+      ),
+      pipe(findChildElement('cit:city', false), extractCharacterString()),
+      pipe(findChildElement('cit:postalCode', false), extractCharacterString()),
+      pipe(findChildElement('cit:country', false), extractCharacterString())
+    ),
+    map((parts) => parts.filter((p) => !!p).join(', '))
+  )
+  const getPhone = pipe(
+    getContact,
+    findNestedElement('cit:phone', 'cit:CI_Telephone', 'cit:number'),
+    extractCharacterString()
+  )
+  const getEmail = pipe(
+    getAddressRoot,
+    findChildElement('cit:electronicMailAddress', false),
+    extractCharacterString()
+  )
+  const defaultOrg: Organization = {
+    name: 'Missing Organization',
+  }
+
+  let defaultIndividual: Partial<Individual> = {}
+  if (orgContact) {
+    defaultIndividual = {
+      email: orgContact.email,
+      ...(orgContact.address && { address: orgContact.address }),
+      ...(orgContact.phone && { phone: orgContact.phone }),
+      ...(orgContact.position && { position: orgContact.position }),
+      organization,
+    }
+  }
+
+  return pipe(
+    combine(getPosition, getNameParts, getEmail, getAddress, getPhone),
+    map(([position, [firstName, lastName], email, address, phone]) => ({
+      ...defaultIndividual,
+      email: email || defaultIndividual.email || 'missing@missing.com',
+      role,
+      organization: organization || defaultOrg,
+      ...(position && { position }),
+      ...(firstName && { firstName }),
+      ...(lastName && { lastName }),
+      ...(address && { address }),
+      ...(phone && { phone }),
+    }))
+  )
+}
+
+// from cit:CI_Organisation
+export function extractOrganizationIndividuals(
+  role: Role
+): ChainableFunction<XmlElement, Array<Individual>> {
+  return pipe(
+    combine(
+      extractOrganization(),
+      extractIndividual(role),
+      findNestedElements('cit:individual', 'cit:CI_Individual')
+    ),
+    map(([org, orgContact, els]) =>
+      els.length
+        ? els.map((el) => extractIndividual(role, org, orgContact)(el))
+        : [
+            {
+              email: orgContact.email,
+              ...(orgContact.address && { address: orgContact.address }),
+              ...(orgContact.phone && { phone: orgContact.phone }),
+              ...(orgContact.position && { position: orgContact.position }),
+              organization: org,
+              role,
+            },
+          ]
+    )
+  )
+}
+
+// from cit:CI_Responsibility
+export function extractIndividuals(): ChainableFunction<
+  XmlElement,
+  Array<Individual>
+> {
+  const getRole = pipe(findChildElement('cit:role'), extractRole())
+  const getIndividuals = pipe(
+    combine(getRole, findNestedElements('cit:party', 'cit:CI_Individual')),
+    ([role, els]) => els.map((el) => extractIndividual(role)(el))
+  )
+  const getOrgIndividuals = pipe(
+    combine(getRole, findNestedElements('cit:party', 'cit:CI_Organisation')),
+    map(([role, els]) =>
+      els.map((el) => extractOrganizationIndividuals(role)(el))
+    ),
+    flattenArray()
+  )
+
+  return pipe(combine(getIndividuals, getOrgIndividuals), flattenArray())
+}
+
+export function readUniqueIdentifier(rootEl: XmlElement): string {
+  return pipe(
+    findNestedElement(
+      'mdb:metadataIdentifier',
+      'mcc:MD_Identifier',
+      'mcc:code'
+    ),
+    extractCharacterString()
+  )(rootEl)
+}
+
+export function readOwnerOrganization(rootEl: XmlElement): Organization {
+  const contacts = readContacts(rootEl)
+  const pointOfContact = contacts.filter(
+    (c) => c.role === 'point_of_contact'
+  )[0]
+  return (pointOfContact || contacts[0]).organization
+}
+
+export function readContacts(rootEl: XmlElement): Individual[] {
+  return pipe(
+    findNestedElements('mdb:contact', 'cit:CI_Responsibility'),
+    mapArray(extractIndividuals()),
+    flattenArray()
+  )(rootEl)
+}
+
+export function readResourceContacts(rootEl: XmlElement): Individual[] {
+  return pipe(
+    combine(
+      pipe(
+        findIdentification(),
+        findNestedElements(
+          'mri:citation',
+          'cit:CI_Citation',
+          'cit:citedResponsibleParty'
+        )
+      ),
+      pipe(
+        findIdentification(),
+        findChildrenElement('mri:pointOfContact', false)
+      ),
+      pipe(findDistribution(), findChildrenElement('mrd:distributorContact'))
+    ),
+    flattenArray(),
+    mapArray(findChildElement('cit:CI_Responsibility', false)),
+    mapArray(extractIndividuals()),
+    flattenArray()
+  )(rootEl)
+}
+
+export function readLandingPage(rootEl: XmlElement): URL {
+  return pipe(
+    findNestedElement(
+      'mdb:metadataLinkage',
+      'cit:CI_OnlineResource',
+      'cit:linkage'
+    ),
+    extractUrl()
+  )(rootEl)
+}
+
+export function readLineage(rootEl: XmlElement): string {
+  return pipe(
+    findNestedElement('mdb:resourceLineage', 'mrl:LI_Lineage', 'mrl:statement'),
+    extractCharacterString()
+  )(rootEl)
+}
+
+function extractDateInfo(
+  type: 'creation' | 'revision' | 'publication'
+): ChainableFunction<XmlElement, Date> {
+  return pipe(
+    findChildrenElement('mdb:dateInfo', false),
+    filterArray(
+      (el) =>
+        pipe(
+          findChildElement('cit:CI_DateTypeCode'),
+          readAttribute('codeListValue')
+        )(el) === type
+    ),
+    getAtIndex(0),
+    findChildElement('cit:date'),
+    extractDateTime()
+  )
+}
+
+export function readRecordUpdated(rootEl: XmlElement): Date {
+  return extractDateInfo('revision')(rootEl)
+}
+
+export function readRecordCreated(rootEl: XmlElement): Date {
+  return extractDateInfo('creation')(rootEl)
+}
+
+export function readRecordPublished(rootEl: XmlElement): Date {
+  return extractDateInfo('publication')(rootEl)
+}
+
+const getMimeType = pipe(
+  findParent('mrd:MD_Distribution'),
+  findNestedElement(
+    'mrd:distributionFormat',
+    'mrd:MD_Format',
+    'mrd:formatSpecificationCitation',
+    'cit:CI_Citation',
+    'cit:title'
+  ),
+  extractCharacterString(),
+  map(matchMimeType)
+)
+
+export function readDistributions(rootEl: XmlElement): DatasetDistribution[] {
+  return pipe(
+    findNestedElements('mrd:distributionInfo', 'mrd:MD_Distribution'),
+    mapArray(extractDatasetDistributions(getMimeType)),
+    flattenArray()
+  )(rootEl)
+}