geonetwork-ui 2.4.0-dev.fdf8f64b → 2.4.0

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

@@ -1,26 +1,35 @@
 import { NamedNode, Statement, Store } from 'rdflib'
 import { DCAT, DCTERMS, FOAF, LOCN, RDF, SKOS, VCARD } from './namespaces'
-import { findNodeLocalized } from './utils/graph-utils'
+import { readLocalizedValue } from './utils/graph-utils'
 import {
   DatasetDownloadDistribution,
   DatasetServiceDistribution,
   DatasetSpatialExtent,
   Individual,
   Keyword,
+  LanguageCode,
   OnlineLinkResource,
   OnlineResource,
+  OnlineResourceTranslations,
   Organization,
+  RecordTranslations,
 } 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'
+import { LANG_3_TO_2_MAPPER } from '../../../../../../libs/util/i18n/src/lib/language-codes'
 
-function getDataset(dataStore: Store, recordNode: NamedNode): NamedNode {
+function getDatasetNode(dataStore: Store, recordNode: NamedNode): NamedNode {
   return (dataStore.the(recordNode, FOAF('primaryTopic'), null) ||
     dataStore.the(null, RDF('type'), DCAT('Dataset'))) as NamedNode
 }
 
+function getCatalogNode(dataStore: Store, recordNode: NamedNode): NamedNode {
+  return (dataStore.the(null, DCAT('record'), recordNode) ||
+    dataStore.the(null, RDF('type'), DCAT('Catalog'))) as NamedNode
+}
+
 export function readUniqueIdentifier(
   dataStore: Store,
   recordNode: NamedNode
@@ -28,21 +37,42 @@ export function readUniqueIdentifier(
   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 readTitle(
+  dataStore: Store,
+  recordNode: NamedNode,
+  translations: RecordTranslations,
+  defaultLanguage: LanguageCode
+): string {
+  const dataset = getDatasetNode(dataStore, recordNode)
+  const [title] = readLocalizedValue<RecordTranslations>(
+    dataStore,
+    dataset,
+    DCTERMS('title'),
+    null,
+    'title',
+    translations,
+    defaultLanguage
+  )
+  return title
 }
 
-export function readAbstract(dataStore: Store, recordNode: NamedNode): string {
-  const dataset = getDataset(dataStore, recordNode)
-  return findNodeLocalized(
+export function readAbstract(
+  dataStore: Store,
+  recordNode: NamedNode,
+  translations: RecordTranslations,
+  defaultLanguage: LanguageCode
+): string {
+  const dataset = getDatasetNode(dataStore, recordNode)
+  const [abstract] = readLocalizedValue<RecordTranslations>(
     dataStore,
     dataset,
     DCTERMS('description'),
     null,
-    'en'
-  )?.value
+    'abstract',
+    translations,
+    defaultLanguage
+  )
+  return abstract
 }
 
 function mapContactFromStatement(
@@ -89,7 +119,7 @@ export function readContactsForResource(
   dataStore: Store,
   recordNode: NamedNode
 ): Individual[] {
-  const dataset = getDataset(dataStore, recordNode)
+  const dataset = getDatasetNode(dataStore, recordNode)
   const statements = dataStore.statementsMatching(
     dataset,
     DCAT('contactPoint'),
@@ -99,69 +129,84 @@ export function readContactsForResource(
 }
 
 export function readLandingPage(dataStore: Store, recordNode: NamedNode): URL {
-  const dataset = getDataset(dataStore, recordNode)
+  const dataset = getDatasetNode(dataStore, recordNode)
   const landingPage = dataStore.the(dataset, DCAT('landingPage'), null)
   return landingPage !== null ? getAsValidUrl(landingPage.value) : undefined
 }
 
 function readOnlineLinkResource(
   dataStore: Store,
-  distributionNode: NamedNode
+  distributionNode: NamedNode,
+  defaultLanguage: LanguageCode
 ): OnlineLinkResource {
   const accessUrl = dataStore.the(distributionNode, DCAT('accessURL'), null)
-  const description = findNodeLocalized(
+  const translations: OnlineResourceTranslations = {}
+  const [description] = readLocalizedValue(
     dataStore,
     distributionNode,
     DCTERMS('description'),
     null,
-    'en'
+    'description',
+    translations,
+    defaultLanguage
   )
-  const title = findNodeLocalized(
+  const [name] = readLocalizedValue(
     dataStore,
     distributionNode,
     DCTERMS('title'),
     null,
-    'en'
+    'name',
+    translations,
+    defaultLanguage
   )
   return {
     url: getAsValidUrl(accessUrl?.value),
     type: 'link',
-    ...(title && { name: title?.value }),
-    ...(description && { description: description?.value }),
+    ...(name !== null && { name }),
+    ...(description !== null && { description }),
+    translations,
   }
 }
 
 function readDownloadDistribution(
   dataStore: Store,
-  distributionNode: NamedNode
+  distributionNode: NamedNode,
+  defaultLanguage: LanguageCode
 ): DatasetDownloadDistribution {
   const downloadUrl = dataStore.the(distributionNode, DCAT('downloadURL'), null)
-  const description = findNodeLocalized(
+  const translations: OnlineResourceTranslations = {}
+  const [description] = readLocalizedValue(
     dataStore,
     distributionNode,
     DCTERMS('description'),
     null,
-    'en'
+    'description',
+    translations,
+    defaultLanguage
   )
-  const title = findNodeLocalized(
+  const [name] = readLocalizedValue(
     dataStore,
     distributionNode,
     DCTERMS('title'),
     null,
-    'en'
+    'name',
+    translations,
+    defaultLanguage
   )
   // todo mime type
   return {
     url: getAsValidUrl(downloadUrl?.value),
     type: 'download',
-    ...(title && { name: title?.value }),
-    ...(description && { description: description?.value }),
+    ...(name !== null && { name }),
+    ...(description !== null && { description }),
+    translations,
   }
 }
 
 function readServiceDistribution(
   dataStore: Store,
-  distributionNode: NamedNode
+  distributionNode: NamedNode,
+  defaultLanguage: LanguageCode
 ): DatasetServiceDistribution {
   const service = dataStore.the(
     distributionNode,
@@ -170,32 +215,39 @@ function readServiceDistribution(
   ) as NamedNode
   const conformsTo = dataStore.the(service, DCTERMS('conformsTo'), null)
   const accessUrl = dataStore.the(distributionNode, DCAT('accessURL'), null)
-  const description = findNodeLocalized(
+  const translations: OnlineResourceTranslations = {}
+  const [description] = readLocalizedValue(
     dataStore,
     distributionNode,
     DCTERMS('description'),
     null,
-    'en'
+    'description',
+    translations,
+    defaultLanguage
   )
-  const title = findNodeLocalized(
+  const [name] = readLocalizedValue(
     dataStore,
     distributionNode,
     DCTERMS('title'),
     null,
-    'en'
+    'name',
+    translations,
+    defaultLanguage
   )
   return {
     url: getAsValidUrl(accessUrl?.value),
     type: 'service',
     accessServiceProtocol: matchProtocol(conformsTo?.value),
-    ...(title && { name: title?.value }),
-    ...(description && { description: description?.value }),
+    ...(name !== null && { name }),
+    ...(description !== null && { description }),
+    translations,
   }
 }
 
 export function mapOnlineResource(
   dataStore: Store,
-  distributionNode: NamedNode
+  distributionNode: NamedNode,
+  defaultLanguage: LanguageCode
 ): OnlineResource {
   if (dataStore.holds(distributionNode, DCAT('accessService'), null)) {
     const service = dataStore.the(
@@ -205,27 +257,37 @@ export function mapOnlineResource(
     ) as NamedNode
     const conformsTo = dataStore.the(service, DCTERMS('conformsTo'), null)
     if (conformsTo) {
-      return readServiceDistribution(dataStore, distributionNode)
+      return readServiceDistribution(
+        dataStore,
+        distributionNode,
+        defaultLanguage
+      )
     }
   }
   if (dataStore.holds(distributionNode, DCAT('downloadURL'), null)) {
-    return readDownloadDistribution(dataStore, distributionNode)
+    return readDownloadDistribution(
+      dataStore,
+      distributionNode,
+      defaultLanguage
+    )
   }
-  return readOnlineLinkResource(dataStore, distributionNode)
+  return readOnlineLinkResource(dataStore, distributionNode, defaultLanguage)
 }
 
 export function readOnlineResources(
   dataStore: Store,
-  recordNode: NamedNode
+  recordNode: NamedNode,
+  translations: RecordTranslations,
+  defaultLanguage: LanguageCode
 ): OnlineResource[] {
-  const dataset = getDataset(dataStore, recordNode)
+  const dataset = getDatasetNode(dataStore, recordNode)
   const statements = dataStore.statementsMatching(
     dataset,
     DCAT('distribution'),
     null
   )
   return statements.map((statement) =>
-    mapOnlineResource(dataStore, statement.object as NamedNode)
+    mapOnlineResource(dataStore, statement.object as NamedNode, defaultLanguage)
   )
 }
 
@@ -233,7 +295,7 @@ export function readSpatialExtents(
   dataStore: Store,
   recordNode: NamedNode
 ): DatasetSpatialExtent[] {
-  const dataset = getDataset(dataStore, recordNode)
+  const dataset = getDatasetNode(dataStore, recordNode)
   const statements = dataStore.statementsMatching(
     dataset,
     DCTERMS('spatial'),
@@ -261,7 +323,7 @@ export function readKeywords(
   dataStore: Store,
   recordNode: NamedNode
 ): Keyword[] {
-  const dataset = getDataset(dataStore, recordNode)
+  const dataset = getDatasetNode(dataStore, recordNode)
   const statements = dataStore.statementsMatching(
     dataset,
     DCAT('keyword'),
@@ -276,7 +338,7 @@ export function readKeywords(
 }
 
 export function readTopics(dataStore: Store, recordNode: NamedNode): string[] {
-  const dataset = getDataset(dataStore, recordNode)
+  const dataset = getDatasetNode(dataStore, recordNode)
   const statements = dataStore.statementsMatching(dataset, DCAT('theme'), null)
   return statements.map((statement) => {
     const prefLabel = dataStore.the(
@@ -310,7 +372,7 @@ export function readResourceCreated(
   dataStore: Store,
   recordNode: NamedNode
 ): Date {
-  const dataset = getDataset(dataStore, recordNode)
+  const dataset = getDatasetNode(dataStore, recordNode)
   const dateString = dataStore.the(dataset, DCTERMS('issued'), null)?.value
   if (dateString) return new Date(dateString)
   return null
@@ -320,7 +382,7 @@ export function readResourceUpdated(
   dataStore: Store,
   recordNode: NamedNode
 ): Date {
-  const dataset = getDataset(dataStore, recordNode)
+  const dataset = getDatasetNode(dataStore, recordNode)
   const dateString = dataStore.the(dataset, DCTERMS('modified'), null)?.value
   if (dateString) return new Date(dateString)
   return null
@@ -342,7 +404,7 @@ export function readOwnerOrganization(dataStore: Store): Organization {
 }
 
 export function readLicenses(dataStore: Store, recordNode: NamedNode) {
-  const dataset = getDataset(dataStore, recordNode)
+  const dataset = getDatasetNode(dataStore, recordNode)
   const distributions = dataStore.statementsMatching(
     dataset,
     DCAT('distribution'),
@@ -368,3 +430,34 @@ export function readLicenses(dataStore: Store, recordNode: NamedNode) {
         ) === index
     )
 }
+
+export function readDefaultLanguage(dataStore: Store, recordNode: NamedNode) {
+  const dataset = getDatasetNode(dataStore, recordNode)
+  const catalog = getCatalogNode(dataStore, recordNode)
+  let statements = dataStore.statementsMatching(
+    recordNode,
+    DCTERMS('language'),
+    null
+  )
+  if (!statements.length && dataset) {
+    statements = dataStore.statementsMatching(
+      dataset,
+      DCTERMS('language'),
+      null
+    )
+  }
+  if (!statements.length && catalog) {
+    statements = dataStore.statementsMatching(
+      catalog,
+      DCTERMS('language'),
+      null
+    )
+  }
+  if (!statements.length) return null
+  const languageNode = statements[0].object as NamedNode
+  let language = languageNode.value.split('/').pop().toLowerCase()
+  if (language.length === 3) {
+    language = LANG_3_TO_2_MAPPER[language] ?? language
+  }
+  return language.substring(0, 2)
+}

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

@@ -1,86 +1,101 @@
-import { lit, Literal, Node, parse, Statement, Store } from 'rdflib'
+import { lit, Literal, 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'
+import {
+  FieldTranslation,
+  LanguageCode,
+  ModelTranslations,
+} from '../../../../../../../libs/common/domain/src/lib/model/record'
 
-export function findNodeLocalized(
+/**
+ * This will find all literal nodes matching the criteria
+ * and store their values inside the translations object. It will then
+ * return the value in the default language
+ */
+export function readLocalizedValue<T extends ModelTranslations>(
   dataStore: Store,
   subject: Quad_Subject,
   predicate: Quad_Predicate,
   object: Quad_Object,
-  language: string
-): Node | null {
+  fieldName: string,
+  translations: T,
+  defaultLanguage: string
+): [string | null, T] {
+  function readNodeLanguage(node: Literal): string {
+    return node.language.toLowerCase().substring(0, 2)
+  }
+
   const literals = dataStore
     .each(subject, predicate, object)
     .filter((node): node is Literal => node instanceof Literal)
-  const matchingLang = literals.find((node) =>
-    node.language.startsWith(language)
+
+  if (!literals.length) return [null, translations]
+
+  const matchingDefault = literals.find(
+    (node) => readNodeLanguage(node) === defaultLanguage
   )
   const noLang = literals.find((node) => !node.language)
-  const anyLang = literals[0]
-  return matchingLang ?? noLang ?? anyLang
+  const defaultValue =
+    matchingDefault?.value ?? noLang?.value ?? '(value not found)'
+  const translationsSafe = translations ?? ({} as T)
+
+  for (const literal of literals) {
+    const language = readNodeLanguage(literal)
+    if (language === defaultLanguage || !language) continue
+    translationsSafe[fieldName] = {
+      ...translationsSafe[fieldName],
+      [language]: literal.value,
+    }
+  }
+
+  return [defaultValue, translationsSafe]
 }
 
 export function getOrAddStatement(
   dataStore: Store,
   subject: Quad_Subject,
   predicate: Quad_Predicate,
-  object: Quad_Object | string
+  object: Quad_Object
 ): Statement {
-  let statement = dataStore.statementsMatching(
-    subject,
-    predicate,
-    typeof object === 'string' ? null : object
-  )[0]
+  let statement = dataStore.statementsMatching(subject, predicate, object)[0]
   if (!statement) {
     statement = dataStore.add(subject, predicate, object) as Statement
   }
   return statement
 }
 
-export function getOrAddLiteral(
+export function writeLiteral(
   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
+  literalValue: string
+): void {
+  dataStore.removeStatements(
+    dataStore.statementsMatching(subject, predicate, null)
+  )
+  dataStore.add(subject, predicate, lit(literalValue))
 }
 
-export function getOrAddLocalizedLiteral(
+export function writeLocalizedLiteral(
   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)
+  literalValue: string,
+  translations: FieldTranslation,
+  defaultLanguage: LanguageCode
+): void {
+  dataStore.removeStatements(
+    dataStore.statementsMatching(subject, predicate, null)
   )
-  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)
+  dataStore.add(subject, predicate, lit(literalValue, defaultLanguage))
+  if (!translations) {
+    return
+  }
+  for (const language in translations) {
+    const translatedValue = translations[language]
+    dataStore.add(subject, predicate, lit(translatedValue, language))
   }
-  return statement
 }
 
 export function loadGraph(

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

@@ -4,12 +4,17 @@ import { DCAT, FOAF, RDF } from '../namespaces'
 import { createDocument, NAMESPACES, xmlToString } from '../../xml-utils'
 import { BASE_URI } from './uri'
 
-function fullNameToXml(fullName: string): [string, string] {
+function fullNameToXml(dataStore: Store, fullName: string): [string, string] {
   for (const key in NAMESPACES) {
     if (fullName.startsWith(NAMESPACES[key])) {
       return [key, fullName.replace(NAMESPACES[key], '')]
     }
   }
+  for (const key in dataStore.namespaces) {
+    if (fullName.startsWith(dataStore.namespaces[key])) {
+      return [key, fullName.replace(dataStore.namespaces[key], '')]
+    }
+  }
   return [null, fullName]
 }
 
@@ -28,18 +33,30 @@ function createXmlElementFromNode(
     // filtering out the rdf:type statements because they are already used above
     .filter((statement) => statement.predicate.value !== RDF('type').value)
     .map((statement) => {
+      // this is a loop: skip it
       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`, {
+      // special cases:some predicates which usually target the Dataset node
+      if (
+        statement.predicate.value === FOAF('primaryTopic').value ||
+        statement.predicate.value === FOAF('topic').value ||
+        statement.predicate.value === DCAT('servesDataset').value
+      ) {
+        const [namespace, name] = fullNameToXml(
+          dataStore,
+          statement.predicate.value
+        )
+        return new XmlElement(`${namespace}:${name}`, {
           'rdf:resource': statement.object.value,
         })
       }
 
-      const [namespace, name] = fullNameToXml(statement.predicate.value)
+      const [namespace, name] = fullNameToXml(
+        dataStore,
+        statement.predicate.value
+      )
       const objectNode = createXmlElementFromNode(
         dataStore,
         statement.object as NamedNode
@@ -55,10 +72,17 @@ function createXmlElementFromNode(
         )
       }
       // wrap the object node in the predicate one
-      return new XmlElement(`${namespace}:${name}`, {}, [objectNode])
+      const predicateEl = new XmlElement(`${namespace}:${name}`, {}, [
+        objectNode,
+      ])
+      // if the child is a literal, set the value on the predicate element
+      if (statement.object instanceof Literal && statement.object.language) {
+        predicateEl.attributes['xml:lang'] = statement.object.language
+      }
+      return predicateEl
     })
     .filter((child) => !!child)
-  const [namespace, name] = fullNameToXml(type.value)
+  const [namespace, name] = fullNameToXml(dataStore, type.value)
   const attributes =
     node instanceof BlankNode
       ? {}
@@ -82,6 +106,7 @@ export function exportGraphToXml(dataStore: Store): string {
   )[0]?.subject as NamedNode
   if (!catalogNode) {
     const recordNode = dataStore.the(null, RDF('type'), DCAT('CatalogRecord'))
+    const datasetNode = dataStore.the(null, RDF('type'), DCAT('Dataset'))
     const statement = dataStore.add(
       sym(`${BASE_URI}catalog`),
       RDF('type'),
@@ -89,9 +114,14 @@ export function exportGraphToXml(dataStore: Store): string {
     ) as Statement
     catalogNode = statement.subject as NamedNode
     dataStore.add(catalogNode, DCAT('record'), recordNode)
+    dataStore.add(catalogNode, DCAT('dataset'), datasetNode)
   }
   const rootEl = new XmlElement('rdf:RDF', {}, [
     createXmlElementFromNode(dataStore, catalogNode),
   ])
+  // add namespaces from the datastore first
+  for (const key in dataStore.namespaces) {
+    rootEl.attributes[`xmlns:${key}`] = dataStore.namespaces[key]
+  }
   return xmlToString(createDocument(rootEl))
 }