geonetwork-ui 2.4.0-dev.e97caaf2 → 2.4.0-dev.f5019723

package/src/libs/api/metadata-converter/src/lib/dcat-ap/read-parts.ts

@@ -0,0 +1,370 @@
+import { NamedNode, Statement, Store } from 'rdflib'
+import { DCAT, DCTERMS, FOAF, LOCN, RDF, SKOS, VCARD } from './namespaces'
+import { findNodeLocalized } from './utils/graph-utils'
+import {
+  DatasetDownloadDistribution,
+  DatasetServiceDistribution,
+  DatasetSpatialExtent,
+  Individual,
+  Keyword,
+  OnlineLinkResource,
+  OnlineResource,
+  Organization,
+} from '../../../../../../libs/common/domain/src/lib/model/record'
+import { getAsValidUrl } from '../common/url'
+import { fullNameToParts } from '../iso19139/utils/individual-name'
+import { readLicenseFromString } from '../common/license'
+import { matchProtocol } from '../common/distribution.mapper'
+
+function getDataset(dataStore: Store, recordNode: NamedNode): NamedNode {
+  return (dataStore.the(recordNode, FOAF('primaryTopic'), null) ||
+    dataStore.the(null, RDF('type'), DCAT('Dataset'))) as NamedNode
+}
+
+export function readUniqueIdentifier(
+  dataStore: Store,
+  recordNode: NamedNode
+): string {
+  return dataStore.the(recordNode, DCTERMS('identifier'), null)?.value
+}
+
+export function readTitle(dataStore: Store, recordNode: NamedNode): string {
+  const dataset = getDataset(dataStore, recordNode)
+  return findNodeLocalized(dataStore, dataset, DCTERMS('title'), null, 'en')
+    ?.value
+}
+
+export function readAbstract(dataStore: Store, recordNode: NamedNode): string {
+  const dataset = getDataset(dataStore, recordNode)
+  return findNodeLocalized(
+    dataStore,
+    dataset,
+    DCTERMS('description'),
+    null,
+    'en'
+  )?.value
+}
+
+function mapContactFromStatement(
+  dataStore: Store,
+  statement: Statement
+): Individual {
+  const contactNode = statement.object as NamedNode
+  const fullName =
+    dataStore.the(contactNode, VCARD('fn'), null) ??
+    dataStore.the(contactNode, VCARD('title'), null) ??
+    dataStore.the(contactNode, VCARD('organisation-name'), null)
+  let firstName, lastName
+  if (fullName) {
+    const parts = fullNameToParts(fullName.value)
+    firstName = parts[0]
+    lastName = parts[1]
+  }
+  const role = dataStore.the(contactNode, VCARD('role'), null)
+  const email = dataStore.the(contactNode, VCARD('hasEmail'), null)
+  const emailValue = email
+    ? email.value.replace(/^mailto:/, '')
+    : 'missing@missing.com'
+  return {
+    role: role?.value ?? 'point_of_contact',
+    email: emailValue,
+    ...(firstName && { firstName }),
+    ...(lastName && { lastName }),
+  }
+}
+
+export function readContacts(
+  dataStore: Store,
+  recordNode: NamedNode
+): Individual[] {
+  const statements = dataStore.statementsMatching(
+    recordNode,
+    DCAT('contactPoint'),
+    null
+  )
+  return statements.map((s) => mapContactFromStatement(dataStore, s))
+}
+
+export function readContactsForResource(
+  dataStore: Store,
+  recordNode: NamedNode
+): Individual[] {
+  const dataset = getDataset(dataStore, recordNode)
+  const statements = dataStore.statementsMatching(
+    dataset,
+    DCAT('contactPoint'),
+    null
+  )
+  return statements.map((s) => mapContactFromStatement(dataStore, s))
+}
+
+export function readLandingPage(dataStore: Store, recordNode: NamedNode): URL {
+  const dataset = getDataset(dataStore, recordNode)
+  const landingPage = dataStore.the(dataset, DCAT('landingPage'), null)
+  return landingPage !== null ? getAsValidUrl(landingPage.value) : undefined
+}
+
+function readOnlineLinkResource(
+  dataStore: Store,
+  distributionNode: NamedNode
+): OnlineLinkResource {
+  const accessUrl = dataStore.the(distributionNode, DCAT('accessURL'), null)
+  const description = findNodeLocalized(
+    dataStore,
+    distributionNode,
+    DCTERMS('description'),
+    null,
+    'en'
+  )
+  const title = findNodeLocalized(
+    dataStore,
+    distributionNode,
+    DCTERMS('title'),
+    null,
+    'en'
+  )
+  return {
+    url: getAsValidUrl(accessUrl?.value),
+    type: 'link',
+    ...(title && { name: title?.value }),
+    ...(description && { description: description?.value }),
+  }
+}
+
+function readDownloadDistribution(
+  dataStore: Store,
+  distributionNode: NamedNode
+): DatasetDownloadDistribution {
+  const downloadUrl = dataStore.the(distributionNode, DCAT('downloadURL'), null)
+  const description = findNodeLocalized(
+    dataStore,
+    distributionNode,
+    DCTERMS('description'),
+    null,
+    'en'
+  )
+  const title = findNodeLocalized(
+    dataStore,
+    distributionNode,
+    DCTERMS('title'),
+    null,
+    'en'
+  )
+  // todo mime type
+  return {
+    url: getAsValidUrl(downloadUrl?.value),
+    type: 'download',
+    ...(title && { name: title?.value }),
+    ...(description && { description: description?.value }),
+  }
+}
+
+function readServiceDistribution(
+  dataStore: Store,
+  distributionNode: NamedNode
+): DatasetServiceDistribution {
+  const service = dataStore.the(
+    distributionNode,
+    DCAT('accessService'),
+    null
+  ) as NamedNode
+  const conformsTo = dataStore.the(service, DCTERMS('conformsTo'), null)
+  const accessUrl = dataStore.the(distributionNode, DCAT('accessURL'), null)
+  const description = findNodeLocalized(
+    dataStore,
+    distributionNode,
+    DCTERMS('description'),
+    null,
+    'en'
+  )
+  const title = findNodeLocalized(
+    dataStore,
+    distributionNode,
+    DCTERMS('title'),
+    null,
+    'en'
+  )
+  return {
+    url: getAsValidUrl(accessUrl?.value),
+    type: 'service',
+    accessServiceProtocol: matchProtocol(conformsTo?.value),
+    ...(title && { name: title?.value }),
+    ...(description && { description: description?.value }),
+  }
+}
+
+export function mapOnlineResource(
+  dataStore: Store,
+  distributionNode: NamedNode
+): OnlineResource {
+  if (dataStore.holds(distributionNode, DCAT('accessService'), null)) {
+    const service = dataStore.the(
+      distributionNode,
+      DCAT('accessService'),
+      null
+    ) as NamedNode
+    const conformsTo = dataStore.the(service, DCTERMS('conformsTo'), null)
+    if (conformsTo) {
+      return readServiceDistribution(dataStore, distributionNode)
+    }
+  }
+  if (dataStore.holds(distributionNode, DCAT('downloadURL'), null)) {
+    return readDownloadDistribution(dataStore, distributionNode)
+  }
+  return readOnlineLinkResource(dataStore, distributionNode)
+}
+
+export function readOnlineResources(
+  dataStore: Store,
+  recordNode: NamedNode
+): OnlineResource[] {
+  const dataset = getDataset(dataStore, recordNode)
+  const statements = dataStore.statementsMatching(
+    dataset,
+    DCAT('distribution'),
+    null
+  )
+  return statements.map((statement) =>
+    mapOnlineResource(dataStore, statement.object as NamedNode)
+  )
+}
+
+export function readSpatialExtents(
+  dataStore: Store,
+  recordNode: NamedNode
+): DatasetSpatialExtent[] {
+  const dataset = getDataset(dataStore, recordNode)
+  const statements = dataStore.statementsMatching(
+    dataset,
+    DCTERMS('spatial'),
+    null
+  )
+  return statements
+    .map((statement) => {
+      const geom = dataStore.the(
+        statement.object as NamedNode,
+        LOCN('geometry'),
+        null
+      )
+      if (!geom)
+        return {
+          description: statement.object.value,
+        }
+      return {
+        geometry: JSON.parse(geom.value),
+      }
+    })
+    .filter((statement) => !!statement)
+}
+
+export function readKeywords(
+  dataStore: Store,
+  recordNode: NamedNode
+): Keyword[] {
+  const dataset = getDataset(dataStore, recordNode)
+  const statements = dataStore.statementsMatching(
+    dataset,
+    DCAT('keyword'),
+    null
+  )
+  return statements.map((statement) => {
+    return {
+      label: statement.object.value,
+      type: 'theme',
+    }
+  })
+}
+
+export function readTopics(dataStore: Store, recordNode: NamedNode): string[] {
+  const dataset = getDataset(dataStore, recordNode)
+  const statements = dataStore.statementsMatching(dataset, DCAT('theme'), null)
+  return statements.map((statement) => {
+    const prefLabel = dataStore.the(
+      statement.object as NamedNode,
+      SKOS('prefLabel'),
+      null
+    )
+    return prefLabel?.value ?? statement.object.value
+  })
+}
+
+export function readRecordCreated(
+  dataStore: Store,
+  recordNode: NamedNode
+): Date {
+  const dateString = dataStore.the(recordNode, DCTERMS('issued'), null)?.value
+  if (dateString) return new Date(dateString)
+  return null
+}
+
+export function readRecordUpdated(
+  dataStore: Store,
+  recordNode: NamedNode
+): Date {
+  const dateString = dataStore.the(recordNode, DCTERMS('modified'), null)?.value
+  if (dateString) return new Date(dateString)
+  return new Date() // record updated is a mandatory field
+}
+
+export function readResourceCreated(
+  dataStore: Store,
+  recordNode: NamedNode
+): Date {
+  const dataset = getDataset(dataStore, recordNode)
+  const dateString = dataStore.the(dataset, DCTERMS('issued'), null)?.value
+  if (dateString) return new Date(dateString)
+  return null
+}
+
+export function readResourceUpdated(
+  dataStore: Store,
+  recordNode: NamedNode
+): Date {
+  const dataset = getDataset(dataStore, recordNode)
+  const dateString = dataStore.the(dataset, DCTERMS('modified'), null)?.value
+  if (dateString) return new Date(dateString)
+  return null
+}
+
+export function readOwnerOrganization(dataStore: Store): Organization {
+  const publisherStatements = dataStore.statementsMatching(
+    null,
+    DCTERMS('publisher'),
+    null
+  )
+  if (!publisherStatements.length) return null
+  const publisher = publisherStatements[0].object as NamedNode
+  const nameNode = dataStore.the(publisher, FOAF('name'), null)
+  const name = nameNode ? nameNode.value : publisher.value
+  return {
+    name,
+  }
+}
+
+export function readLicenses(dataStore: Store, recordNode: NamedNode) {
+  const dataset = getDataset(dataStore, recordNode)
+  const distributions = dataStore.statementsMatching(
+    dataset,
+    DCAT('distribution'),
+    null
+  )
+  return distributions
+    .map(
+      (statement) =>
+        dataStore.the(
+          statement.object as NamedNode,
+          DCTERMS('license'),
+          null
+        ) as NamedNode
+    )
+    .filter((license) => !!license)
+    .map((s) => readLicenseFromString(s.value))
+    .filter(
+      (license, index, array) =>
+        array.findIndex(
+          (l) =>
+            l.url?.toString() === license.url?.toString() &&
+            l.text === license.text
+        ) === index
+    )
+}

package/src/libs/api/metadata-converter/src/lib/dcat-ap/utils/graph-utils.ts

@@ -0,0 +1,95 @@
+import { lit, Literal, Node, parse, Statement, Store } from 'rdflib'
+import { Quad_Object, Quad_Predicate, Quad_Subject } from 'rdflib/lib/tf-types'
+import { ContentType } from 'rdflib/lib/types'
+import { BASE_URI } from './uri'
+
+export function findNodeLocalized(
+  dataStore: Store,
+  subject: Quad_Subject,
+  predicate: Quad_Predicate,
+  object: Quad_Object,
+  language: string
+): Node | null {
+  const literals = dataStore
+    .each(subject, predicate, object)
+    .filter((node): node is Literal => node instanceof Literal)
+  const matchingLang = literals.find((node) =>
+    node.language.startsWith(language)
+  )
+  const noLang = literals.find((node) => !node.language)
+  const anyLang = literals[0]
+  return matchingLang ?? noLang ?? anyLang
+}
+
+export function getOrAddStatement(
+  dataStore: Store,
+  subject: Quad_Subject,
+  predicate: Quad_Predicate,
+  object: Quad_Object | string
+): Statement {
+  let statement = dataStore.statementsMatching(
+    subject,
+    predicate,
+    typeof object === 'string' ? null : object
+  )[0]
+  if (!statement) {
+    statement = dataStore.add(subject, predicate, object) as Statement
+  }
+  return statement
+}
+
+export function getOrAddLiteral(
+  dataStore: Store,
+  subject: Quad_Subject,
+  predicate: Quad_Predicate,
+  objectValue: string
+) {
+  let statement = dataStore.statementsMatching(subject, predicate, null)[0]
+  if (!statement) {
+    statement = dataStore.add(subject, predicate, lit(objectValue)) as Statement
+  } else {
+    statement.object = lit(objectValue)
+  }
+  return statement
+}
+
+export function getOrAddLocalizedLiteral(
+  dataStore: Store,
+  subject: Quad_Subject,
+  predicate: Quad_Predicate,
+  objectValue: string,
+  language: string
+) {
+  const statements = dataStore.statementsMatching(subject, predicate, null)
+  const withMatchingLanguage = statements.filter(
+    (statement) =>
+      statement.object instanceof Literal &&
+      statement.object.language.startsWith(language)
+  )
+  const withNoLanguage = statements.filter(
+    (statement) =>
+      statement.object instanceof Literal && !statement.object.language
+  )
+  let statement = withMatchingLanguage[0] || withNoLanguage[0]
+  if (!statement) {
+    statement = dataStore.add(
+      subject,
+      predicate,
+      lit(objectValue, language)
+    ) as Statement
+  } else {
+    statement.object = lit(objectValue, language)
+  }
+  return statement
+}
+
+export function loadGraph(
+  dataStore: Store,
+  document: string,
+  contentType: ContentType,
+  base = BASE_URI
+) {
+  return new Promise((resolve) =>
+    parse(document, dataStore, base, contentType, resolve)
+  )
+}

package/src/libs/api/metadata-converter/src/lib/dcat-ap/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/dcat-ap/utils/keyword.mapper.ts

@@ -0,0 +1,16 @@
+import { KeywordType } from '../../../../../../../libs/common/domain/src/lib/model/thesaurus'
+
+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/dcat-ap/utils/role.mapper.ts

@@ -0,0 +1,48 @@
+import { Role } from '../../../../../../../libs/common/domain/src/lib/model/record'
+
+export function getRoleFromRoleCode(roleCode: string): Role {
+  if (!roleCode) return 'unspecified'
+  switch (roleCode) {
+    case 'author':
+    case 'coAuthor':
+      return 'author'
+    case 'originator':
+      return 'originator'
+    case 'principalInvestigator':
+      return 'principal_investigator'
+    case 'resourceProvider':
+      return 'resource_provider'
+    case 'processor':
+      return 'processor'
+    case 'custodian':
+      return 'custodian'
+    case 'owner':
+      return 'owner'
+    case 'pointOfContact':
+      return 'point_of_contact'
+    case 'publisher':
+      return 'publisher'
+    case 'distributor':
+      return 'distributor'
+    case 'user':
+      return 'user'
+    case 'collaborator':
+      return 'collaborator'
+    case 'editor':
+      return 'editor'
+    case 'contributor':
+      return 'contributor'
+    case 'stakeholder':
+      return 'stakeholder'
+    case 'sponsor':
+      return 'sponsor'
+    case 'funder':
+      return 'funder'
+    case 'rightsHolder':
+      return 'rights_holder'
+    case 'mediator':
+      return 'mediator'
+    default:
+      return 'other'
+  }
+}

package/src/libs/api/metadata-converter/src/lib/dcat-ap/utils/serialize-to-xml.ts

@@ -0,0 +1,97 @@
+import { BlankNode, Literal, NamedNode, Statement, Store, sym } from 'rdflib'
+import { XmlElement, XmlText } from '@rgrove/parse-xml'
+import { DCAT, FOAF, RDF } from '../namespaces'
+import { createDocument, NAMESPACES, xmlToString } from '../../xml-utils'
+import { BASE_URI } from './uri'
+
+function fullNameToXml(fullName: string): [string, string] {
+  for (const key in NAMESPACES) {
+    if (fullName.startsWith(NAMESPACES[key])) {
+      return [key, fullName.replace(NAMESPACES[key], '')]
+    }
+  }
+  return [null, fullName]
+}
+
+function createXmlElementFromNode(
+  dataStore: Store,
+  node: NamedNode | Literal
+): XmlElement | XmlText {
+  if (node instanceof Literal) {
+    return new XmlText(node.value)
+  }
+  const type = dataStore.the(node, RDF('type')) as NamedNode
+  if (!type) return null
+
+  const statements = dataStore.statementsMatching(node, null, null)
+  const children = statements
+    // filtering out the rdf:type statements because they are already used above
+    .filter((statement) => statement.predicate.value !== RDF('type').value)
+    .map((statement) => {
+      if (statement.object.toString() === statement.subject.toString()) {
+        return null
+      }
+
+      // special cases: foaf:primaryTopic in dcat:CatalogRecord
+      if (statement.predicate.value === FOAF('primaryTopic').value) {
+        return new XmlElement(`foaf:primaryTopic`, {
+          'rdf:resource': statement.object.value,
+        })
+      }
+
+      const [namespace, name] = fullNameToXml(statement.predicate.value)
+      const objectNode = createXmlElementFromNode(
+        dataStore,
+        statement.object as NamedNode
+      )
+      if (!objectNode) {
+        // no object node: simply use the object value
+        return new XmlElement(
+          `${namespace}:${name}`,
+          {
+            'rdf:resource': statement.object.value,
+          },
+          []
+        )
+      }
+      // wrap the object node in the predicate one
+      return new XmlElement(`${namespace}:${name}`, {}, [objectNode])
+    })
+    .filter((child) => !!child)
+  const [namespace, name] = fullNameToXml(type.value)
+  const attributes =
+    node instanceof BlankNode
+      ? {}
+      : {
+          'rdf:about': node.value,
+        }
+  return new XmlElement(`${namespace}:${name}`, attributes, children)
+}
+
+/**
+ * This will output an XML document serialized as string, tailored in a way that it
+ * can be understood and indexed by GN4 dcat-ap plugin
+ * @param dataStore
+ */
+export function exportGraphToXml(dataStore: Store): string {
+  // we start with the catalog node (which is created if missing)
+  let catalogNode = dataStore.statementsMatching(
+    null,
+    RDF('type'),
+    DCAT('Catalog')
+  )[0]?.subject as NamedNode
+  if (!catalogNode) {
+    const recordNode = dataStore.the(null, RDF('type'), DCAT('CatalogRecord'))
+    const statement = dataStore.add(
+      sym(`${BASE_URI}catalog`),
+      RDF('type'),
+      DCAT('Catalog')
+    ) as Statement
+    catalogNode = statement.subject as NamedNode
+    dataStore.add(catalogNode, DCAT('record'), recordNode)
+  }
+  const rootEl = new XmlElement('rdf:RDF', {}, [
+    createXmlElementFromNode(dataStore, catalogNode),
+  ])
+  return xmlToString(createDocument(rootEl))
+}

package/src/libs/api/metadata-converter/src/lib/dcat-ap/utils/status.mapper.ts

@@ -0,0 +1,19 @@
+import { RecordStatus } from '../../../../../../../libs/common/domain/src/lib/model/record'
+
+export function getStatusFromStatusCode(statusCode: string): RecordStatus {
+  switch (statusCode) {
+    case 'completed':
+      return 'completed'
+    case 'historicalArchive':
+      return 'removed'
+    case 'obsolete':
+      return 'deprecated'
+    case 'onGoing':
+      return 'ongoing'
+    case 'planned':
+    case 'required':
+    case 'underDevelopment':
+    default:
+      return 'under_development'
+  }
+}