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

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,
+  Keyword,
+  KeywordThesaurus,
   Organization,
   RecordKind,
   RecordStatus,
@@ -16,8 +14,8 @@ import {
   UpdateFrequency,
   UpdateFrequencyCustom,
 } from '../../../../../../libs/common/domain/src/lib/model/record'
-import { getStatusFromStatusCode } from './codelists/status.mapper'
-import { getUpdateFrequencyFromFrequencyCode } from './codelists/update-frequency.mapper'
+import { getStatusFromStatusCode } from './utils/status.mapper'
+import { getUpdateFrequencyFromFrequencyCode } from './utils/update-frequency.mapper'
 import {
   findChildElement,
   findChildrenElement,
@@ -39,10 +37,15 @@ import {
   mapArray,
   pipe,
 } from '../function-utils'
-import { getRoleFromRoleCode } from './codelists/role.mapper'
+import { getRoleFromRoleCode } from './utils/role.mapper'
 import { matchMimeType, matchProtocol } from '../common/distribution.mapper'
+import { getKeywordTypeFromKeywordTypeCode } from './utils/keyword.mapper'
+import { fullNameToParts } from './utils/individual-name'
 
-function extractCharacterString(): ChainableFunction<XmlElement, string> {
+export function extractCharacterString(): ChainableFunction<
+  XmlElement,
+  string
+> {
   return pipe(
     fallback(
       findChildElement('gco:CharacterString', false),
@@ -52,7 +55,7 @@ function extractCharacterString(): ChainableFunction<XmlElement, string> {
   )
 }
 
-function extractDateTime(): ChainableFunction<XmlElement, Date> {
+export function extractDateTime(): ChainableFunction<XmlElement, Date> {
   return pipe(
     fallback(
       findChildElement('gco:DateTime', false),
@@ -63,7 +66,7 @@ function extractDateTime(): ChainableFunction<XmlElement, Date> {
   )
 }
 
-function extractUrl(): ChainableFunction<XmlElement, URL> {
+export function extractUrl(): ChainableFunction<XmlElement, URL> {
   const getUrl = pipe(findChildElement('gmd:URL', false), readText())
   const getCharacterString = pipe(
     findChildElement('gco:CharacterString', false),
@@ -85,12 +88,12 @@ function extractUrl(): ChainableFunction<XmlElement, URL> {
   )
 }
 
-function extractMandatoryUrl() {
+export function extractMandatoryUrl() {
   return fallback(extractUrl(), () => new URL('http://missing'))
 }
 
 // from gmd:role
-function extractRole(): ChainableFunction<XmlElement, Role> {
+export function extractRole(): ChainableFunction<XmlElement, Role> {
   return pipe(
     findChildElement('gmd:CI_RoleCode'),
     readAttribute('codeListValue'),
@@ -99,7 +102,10 @@ function extractRole(): ChainableFunction<XmlElement, Role> {
 }
 
 // from gmd:CI_ResponsibleParty
-function extractOrganization(): ChainableFunction<XmlElement, Organization> {
+export function extractOrganization(): ChainableFunction<
+  XmlElement,
+  Organization
+> {
   const getUrl = pipe(
     findNestedElements(
       'gmd:contactInfo',
@@ -127,10 +133,7 @@ function extractOrganization(): ChainableFunction<XmlElement, Organization> {
 }
 
 // from gmd:CI_ResponsibleParty
-function extractIndividuals(): ChainableFunction<
-  XmlElement,
-  Array<Individual>
-> {
+export function extractIndividual(): ChainableFunction<XmlElement, Individual> {
   const getRole = pipe(findChildElement('gmd:role'), extractRole())
   const getPosition = pipe(
     findChildElement('gmd:positionName'),
@@ -141,40 +144,70 @@ function extractIndividuals(): ChainableFunction<
     extractCharacterString(),
     map((fullName) => {
       if (!fullName) return []
-      const parts = fullName.split(/\s+/)
-      if (!parts.length) return [fullName, null]
-      const first = parts.shift()
-      return [first, parts.join(' ')]
+      return fullNameToParts(fullName)
     })
   )
   const getOrganization = extractOrganization()
+  const getContactRoot = findNestedElement('gmd:contactInfo', 'gmd:CI_Contact')
   const getEmail = pipe(
+    getContactRoot,
     findChildElement('gmd:electronicMailAddress'),
     extractCharacterString(),
     map((email) => (email === null ? 'missing@missing.com' : email))
   )
+  const getAddress = pipe(
+    getContactRoot,
+    findNestedElement('gmd:address', 'gmd:CI_Address'),
+    combine(
+      pipe(
+        findChildElement('gmd:deliveryPoint', false),
+        extractCharacterString()
+      ),
+      pipe(findChildElement('gmd:city', false), extractCharacterString()),
+      pipe(findChildElement('gmd:postalCode', false), extractCharacterString()),
+      pipe(findChildElement('gmd:country', false), extractCharacterString())
+    ),
+    map((parts) => parts.filter((p) => !!p).join(', '))
+  )
+  const getPhone = pipe(
+    getContactRoot,
+    findNestedElement('gmd:phone', 'gmd:CI_Telephone', 'gmd:voice'),
+    extractCharacterString()
+  )
   return pipe(
     combine(
       getRole,
       getPosition,
       getNameParts,
       getOrganization,
-      pipe(findChildrenElement('gmd:contactInfo'), mapArray(getEmail))
+      getEmail,
+      getAddress,
+      getPhone
     ),
-    map(([role, position, [firstName, lastName], organization, emails]) =>
-      emails.map((email) => ({
+    map(
+      ([
+        role,
+        position,
+        [firstName, lastName],
+        organization,
+        email,
+        address,
+        phone,
+      ]) => ({
         email,
         role,
         organization,
         ...(position && { position }),
         ...(firstName && { firstName }),
         ...(lastName && { lastName }),
-      }))
+        ...(address && { address }),
+        ...(phone && { phone }),
+      })
     )
   )
 }
 
-function extractStatus(): ChainableFunction<XmlElement, RecordStatus> {
+export function extractStatus(): ChainableFunction<XmlElement, RecordStatus> {
   return pipe(
     findChildElement('gmd:MD_ProgressCode'),
     readAttribute('codeListValue'),
@@ -183,59 +216,72 @@ function extractStatus(): ChainableFunction<XmlElement, RecordStatus> {
 }
 
 // from gmd:resourceConstraints
-function extractAccessConstraints(): ChainableFunction<
+export 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
+export 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>> {
+export 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>> {
+export function extractLicenses(): ChainableFunction<
+  XmlElement,
+  Array<Constraint>
+> {
   return pipe(
     findChildrenElement('gmd:MD_LegalConstraints', false),
     filterArray(
@@ -246,30 +292,35 @@ 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,
+    }))
   )
 }
 
-// from gmd:MD_Distribution
-function extractDatasetDistributions(): ChainableFunction<
-  XmlElement,
-  DatasetDistribution[]
-> {
-  const getFormat = pipe(
-    findParent('gmd:MD_Distribution'),
-    findNestedElement('gmd:distributionFormat', 'gmd:MD_Format', 'gmd:name'),
-    extractCharacterString(),
-    map(matchMimeType)
-  )
+const getMimeType = pipe(
+  findParent('gmd:MD_Distribution'),
+  findNestedElement('gmd:distributionFormat', 'gmd:MD_Format', 'gmd:name'),
+  extractCharacterString(),
+  map(matchMimeType)
+)
 
+/**
+ * Extract distributions from a MD_Distribution element
+ * @param getMimeTypeFn This function starts from a gmd:transferOptions element
+ */
+export function extractDatasetDistributions(
+  getMimeTypeFn: ChainableFunction<XmlElement, string>
+): ChainableFunction<XmlElement, DatasetDistribution[]> {
   const getUrl = pipe(findChildElement('gmd:linkage'), extractMandatoryUrl())
   const getProtocolStr = pipe(
     findChildElement('gmd:protocol'),
@@ -312,11 +363,11 @@ function extractDatasetDistributions(): ChainableFunction<
         getUrl,
         getName,
         getDescription,
-        getFormat
+        getMimeTypeFn
       )
     ),
     mapArray(
-      ([isService, isDownload, protocol, url, name, description, format]) => {
+      ([isService, isDownload, protocol, url, name, description, mimeType]) => {
         if (isService) {
           const hasIdentifier = protocol === 'wms' || protocol === 'wfs'
           return {
@@ -328,7 +379,6 @@ function extractDatasetDistributions(): ChainableFunction<
             ...(description && { description }),
           }
         } else if (isDownload) {
-          const mimeType = format
           return {
             type: 'download',
             url: url,
@@ -349,7 +399,7 @@ function extractDatasetDistributions(): ChainableFunction<
   )
 }
 
-function getUpdateFrequencyFromCustomPeriod(
+export function getUpdateFrequencyFromCustomPeriod(
   isoPeriod: string
 ): UpdateFrequencyCustom {
   if (!isoPeriod) return null
@@ -401,7 +451,7 @@ function getUpdateFrequencyFromCustomPeriod(
 }
 
 // from gmd:MD_MaintenanceInformation
-function extractUpdateFrequency(): ChainableFunction<
+export function extractUpdateFrequency(): ChainableFunction<
   XmlElement,
   UpdateFrequency
 > {
@@ -425,18 +475,24 @@ function extractUpdateFrequency(): ChainableFunction<
 
 /**
  * Looks for srv:SV_ServiceIdentification or gmd:MD_DataIdentification element
- * depending on record type
+ * Will find the first one that exists, not reading the type of the record
+ * (this allows using this function in other similar schemas)
  */
-function findIdentification() {
-  return (rootEl: XmlElement) => {
-    const kind = readKind(rootEl)
-    let eltName = 'gmd:MD_DataIdentification'
-    if (kind === 'service') eltName = 'srv:SV_ServiceIdentification'
-    return findNestedElement('gmd:identificationInfo', eltName)(rootEl)
-  }
+export function findIdentification() {
+  return pipe(
+    findChildElement('gmd:identificationInfo', false),
+    combine(
+      findChildElement('gmd:MD_DataIdentification', false),
+      findChildElement('srv:SV_ServiceIdentification', false)
+    ),
+    filterArray((el) => el !== null),
+    getAtIndex(0)
+  )
 }
 
-function extractCitationDate(type: 'creation' | 'revision') {
+export function extractIdentificationDate(
+  type: 'creation' | 'revision' | 'publication'
+) {
   return pipe(
     findIdentification(),
     findNestedElements('gmd:citation', 'gmd:CI_Citation', 'gmd:date'),
@@ -459,7 +515,7 @@ function extractCitationDate(type: 'creation' | 'revision') {
   )
 }
 
-function getSpatialRepresentationFromCode(
+export function getSpatialRepresentationFromCode(
   spatialRepresentationCode: string
 ): SpatialRepresentationType | null {
   switch (spatialRepresentationCode) {
@@ -499,6 +555,18 @@ export function readOwnerOrganization(rootEl: XmlElement): Organization {
   )(rootEl)
 }
 
+export function readResourceUpdated(rootEl: XmlElement): Date {
+  return extractIdentificationDate('revision')(rootEl)
+}
+
+export function readResourceCreated(rootEl: XmlElement): Date {
+  return extractIdentificationDate('creation')(rootEl)
+}
+
+export function readResourcePublished(rootEl: XmlElement): Date {
+  return extractIdentificationDate('publication')(rootEl)
+}
+
 export function readRecordUpdated(rootEl: XmlElement): Date {
   return pipe(findChildElement('gmd:dateStamp'), extractDateTime())(rootEl)
 }
@@ -519,51 +587,81 @@ export function readAbstract(rootEl: XmlElement): string {
   )(rootEl)
 }
 
-export function readDatasetCreated(rootEl: XmlElement): Date {
-  return extractCitationDate('creation')(rootEl)
-}
-
-export function readDatasetUpdated(rootEl: XmlElement): Date {
-  return extractCitationDate('revision')(rootEl)
+export function readContacts(rootEl: XmlElement): Individual[] {
+  return pipe(
+    findChildrenElement('gmd:contact', false),
+    mapArray(findChildElement('gmd:CI_ResponsibleParty', false)),
+    mapArray(extractIndividual())
+  )(rootEl)
 }
 
-export function readContacts(rootEl: XmlElement): Individual[] {
+export function readContactsForResource(rootEl: XmlElement): Individual[] {
   return pipe(
     findIdentification(),
     combine(
-      findChildrenElement('gmd:contact'),
-      findChildrenElement('gmd:pointOfContact')
+      findChildrenElement('gmd:contact', false),
+      findChildrenElement('gmd:pointOfContact', false)
     ),
     flattenArray(),
     mapArray(findChildElement('gmd:CI_ResponsibleParty', false)),
-    mapArray(extractIndividuals()),
-    flattenArray()
+    mapArray(extractIndividual())
   )(rootEl)
 }
 
-function readKeywordsOfType(isTheme: boolean) {
-  return pipe(
-    findIdentification(),
-    findNestedElements('gmd:descriptiveKeywords', 'gmd:MD_Keywords'),
-    filterArray(
-      pipe(
-        findChildrenElement('gmd:MD_KeywordTypeCode'),
-        mapArray(readAttribute('codeListValue')),
-        map((values) => isTheme === values.indexOf('theme') > -1)
-      )
-    ),
-    mapArray(findChildrenElement('gmd:keyword')),
-    flattenArray(),
-    mapArray(extractCharacterString())
+// from gmd:thesaurusName
+export function readThesaurus(rootEl: XmlElement): KeywordThesaurus {
+  if (!rootEl) return null
+
+  const findIdentifier = findNestedElement(
+    'gmd:CI_Citation',
+    'gmd:identifier',
+    'gmd:MD_Identifier',
+    'gmd:code'
   )
+  const id = pipe(findIdentifier, extractCharacterString())(rootEl)
+  const url = pipe(findIdentifier, extractUrl())(rootEl)
+  const name = pipe(
+    findNestedElement('gmd:CI_Citation', 'gmd:title'),
+    extractCharacterString()
+  )(rootEl)
+  return {
+    id,
+    ...(name && { name }),
+    ...(url && { url }),
+  }
 }
 
-export function readKeywords(rootEl: XmlElement): string[] {
-  return readKeywordsOfType(false)(rootEl)
+// from gmd:MD_Keywords
+export function readKeywordGroup(rootEl: XmlElement): Keyword[] {
+  const type = pipe(
+    findChildrenElement('gmd:MD_KeywordTypeCode'),
+    mapArray(readAttribute('codeListValue')),
+    map((values) => getKeywordTypeFromKeywordTypeCode(values[0]))
+  )(rootEl)
+  const thesaurus = pipe(
+    findNestedElement('gmd:thesaurusName'),
+    readThesaurus
+  )(rootEl)
+  return pipe(
+    findChildrenElement('gmd:keyword'),
+    mapArray((el) => {
+      const label = extractCharacterString()(el)
+      return {
+        ...(thesaurus ? { thesaurus } : {}),
+        label,
+        type,
+      } as Keyword
+    })
+  )(rootEl)
 }
 
-export function readThemes(rootEl: XmlElement): string[] {
-  return readKeywordsOfType(true)(rootEl)
+export function readKeywords(rootEl: XmlElement): Keyword[] {
+  return pipe(
+    findIdentification(),
+    findNestedElements('gmd:descriptiveKeywords', 'gmd:MD_Keywords'),
+    mapArray(readKeywordGroup),
+    flattenArray()
+  )(rootEl)
 }
 
 export function readStatus(rootEl: XmlElement): RecordStatus {
@@ -579,24 +677,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(extractUseLimitations()),
+    mapArray(extractSecurityConstraints()),
     flattenArray()
   )(rootEl)
 }
 
-export function readLicenses(rootEl: XmlElement): License[] {
+export function readOtherConstraints(rootEl: XmlElement): Constraint[] {
+  return pipe(
+    getConstraints,
+    mapArray(extractOtherConstraints()),
+    flattenArray()
+  )(rootEl)
+}
+
+export function readLicenses(rootEl: XmlElement): Constraint[] {
   return pipe(
     getConstraints,
     mapArray(extractLicenses()),
@@ -608,7 +714,7 @@ export function readLicenses(rootEl: XmlElement): License[] {
 export function readIsoTopics(rootEl: XmlElement): string[] {
   return pipe(
     findIdentification(),
-    findChildrenElement('gmd:MD_TopicCategoryCode', false),
+    findChildrenElement('gmd:MD_TopicCategoryCode', true),
     mapArray(readText())
   )(rootEl)
 }
@@ -644,16 +750,6 @@ export function readOverviews(rootEl: XmlElement): GraphicOverview[] {
   )(rootEl)
 }
 
-export function readSpatialExtents(rootEl: XmlElement): DatasetSpatialExtent[] {
-  return [] // TODO
-}
-
-export function readTemporalExtents(
-  rootEl: XmlElement
-): DatasetTemporalExtent[] {
-  return [] // TODO
-}
-
 export function readLineage(rootEl: XmlElement): string {
   return pipe(
     findNestedElement(
@@ -670,7 +766,7 @@ export function readLineage(rootEl: XmlElement): string {
 export function readDistributions(rootEl: XmlElement): DatasetDistribution[] {
   return pipe(
     findNestedElements('gmd:distributionInfo', 'gmd:MD_Distribution'),
-    mapArray(extractDatasetDistributions()),
+    mapArray(extractDatasetDistributions(getMimeType)),
     flattenArray()
   )(rootEl)
 }

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

@@ -0,0 +1,20 @@
+/**
+ * Parts are [firstName, lastName]
+ * Second part will be null if no separation could be done
+ * @param fullName
+ */
+export function fullNameToParts(fullName: string): [string, string | null] {
+  const parts = fullName.trim().split(/\s+/)
+  const first = parts.shift()
+  return [first, parts.join(' ').trim() || null]
+}
+
+export function namePartsToFull(
+  firstName: string | null,
+  lastName: string | null
+): string | null {
+  const first = firstName?.trim()
+  const last = lastName?.trim()
+  if (!first && !last) return null
+  return last && first ? `${first} ${last}` : last || first
+}

package/src/libs/api/metadata-converter/src/lib/iso19139/utils/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'
+  }
+}