geonetwork-ui 2.1.0-initial

package/src/libs/api/metadata-converter/src/lib/function-utils.ts

@@ -0,0 +1,171 @@
+export type ChainableFunction<T, U> = (input: T) => U
+
+export function pipe(): ChainableFunction<void, void>
+export function pipe<U, V>(
+  fn1: ChainableFunction<U, V>
+): ChainableFunction<U, V>
+export function pipe<U, V, W>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<V, W>
+): ChainableFunction<U, W>
+export function pipe<U, V, W, X>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<V, W>,
+  fn3: ChainableFunction<W, X>
+): ChainableFunction<U, X>
+export function pipe<U, V, W, X, Y>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<V, W>,
+  fn3: ChainableFunction<W, X>,
+  fn4: ChainableFunction<X, Y>
+): ChainableFunction<U, Y>
+export function pipe<U, V, W, X, Y, Z>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<V, W>,
+  fn3: ChainableFunction<W, X>,
+  fn4: ChainableFunction<X, Y>,
+  fn5: ChainableFunction<Y, Z>
+): ChainableFunction<U, Z>
+export function pipe<U, V, W, X, Y, Z, A>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<V, W>,
+  fn3: ChainableFunction<W, X>,
+  fn4: ChainableFunction<X, Y>,
+  fn5: ChainableFunction<Y, Z>,
+  fn6: ChainableFunction<Z, A>
+): ChainableFunction<U, A>
+export function pipe<U, V, W, X, Y, Z, A, B>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<V, W>,
+  fn3: ChainableFunction<W, X>,
+  fn4: ChainableFunction<X, Y>,
+  fn5: ChainableFunction<Y, Z>,
+  fn6: ChainableFunction<Z, A>,
+  fn7: ChainableFunction<A, B>
+): ChainableFunction<U, B>
+export function pipe<U, V, W, X, Y, Z, A, B, C>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<V, W>,
+  fn3: ChainableFunction<W, X>,
+  fn4: ChainableFunction<X, Y>,
+  fn5: ChainableFunction<Y, Z>,
+  fn6: ChainableFunction<Z, A>,
+  fn7: ChainableFunction<A, B>,
+  fn8: ChainableFunction<B, C>
+): ChainableFunction<U, C>
+export function pipe<U, V, W, X, Y, Z, A, B, C, D>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<V, W>,
+  fn3: ChainableFunction<W, X>,
+  fn4: ChainableFunction<X, Y>,
+  fn5: ChainableFunction<Y, Z>,
+  fn6: ChainableFunction<Z, A>,
+  fn7: ChainableFunction<A, B>,
+  fn8: ChainableFunction<B, C>,
+  fn9: ChainableFunction<C, D>
+): ChainableFunction<U, D>
+export function pipe<U, V, W, X, Y, Z, A, B, C, D, E>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<V, W>,
+  fn3: ChainableFunction<W, X>,
+  fn4: ChainableFunction<X, Y>,
+  fn5: ChainableFunction<Y, Z>,
+  fn6: ChainableFunction<Z, A>,
+  fn7: ChainableFunction<A, B>,
+  fn8: ChainableFunction<B, C>,
+  fn9: ChainableFunction<C, D>,
+  fn10: ChainableFunction<D, E>
+): ChainableFunction<U, E>
+export function pipe(
+  ...fns: Array<ChainableFunction<unknown, unknown>>
+): ChainableFunction<unknown, unknown> {
+  return (value) => fns.reduce((prev, curr) => curr(prev), value)
+}
+
+export function map<U, V>(mapper: (el: U) => V) {
+  return (input: U) => mapper(input)
+}
+
+export function mapArray<U, V>(mapper: (el: U) => V) {
+  return (input: Array<U>) => input.map(mapper)
+}
+
+export function filterArray<U>(filter: (el: U) => boolean) {
+  return (input: Array<U>) => input.filter(filter)
+}
+
+export function flattenArray<U>() {
+  return (input: Array<U>) => input.flat()
+}
+
+export function getAtIndex<U>(index: number) {
+  return (input: Array<U>) => (input.length > index ? input[index] : null)
+}
+
+export function fallback<U, V>(
+  ...fns: Array<ChainableFunction<U, V>>
+): ChainableFunction<U, V> {
+  return (value: U) => {
+    for (let i = 0; i < fns.length; i++) {
+      const result = fns[i](value)
+      if (result !== null) {
+        return result
+      }
+    }
+    return null
+  }
+}
+
+export function combine<U, V, W>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<U, W>
+): ChainableFunction<U, [V, W]>
+export function combine<U, V, W, X>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<U, W>,
+  fn3: ChainableFunction<U, X>
+): ChainableFunction<U, [V, W, X]>
+export function combine<U, V, W, X, Y>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<U, W>,
+  fn3: ChainableFunction<U, X>,
+  fn4: ChainableFunction<U, Y>
+): ChainableFunction<U, [V, W, X, Y]>
+export function combine<U, V, W, X, Y, Z>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<U, W>,
+  fn3: ChainableFunction<U, X>,
+  fn4: ChainableFunction<U, Y>,
+  fn5: ChainableFunction<U, Z>
+): ChainableFunction<U, [V, W, X, Y, Z]>
+export function combine<U, V, W, X, Y, Z, A>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<U, W>,
+  fn3: ChainableFunction<U, X>,
+  fn4: ChainableFunction<U, Y>,
+  fn5: ChainableFunction<U, Z>,
+  fn6: ChainableFunction<U, A>
+): ChainableFunction<U, [V, W, X, Y, Z, A]>
+export function combine<U, V, W, X, Y, Z, A, B>(
+  fn1: ChainableFunction<U, V>,
+  fn2: ChainableFunction<U, W>,
+  fn3: ChainableFunction<U, X>,
+  fn4: ChainableFunction<U, Y>,
+  fn5: ChainableFunction<U, Z>,
+  fn6: ChainableFunction<U, A>,
+  fn7: ChainableFunction<U, B>
+): ChainableFunction<U, [V, W, X, Y, Z, A, B]>
+export function combine(
+  ...fns: Array<ChainableFunction<unknown, unknown>>
+): ChainableFunction<unknown, Array<unknown>> {
+  return (value) => fns.map((fn) => fn(value))
+}
+
+export function tap<U>(fn: (value: U) => void) {
+  return (value: U) => {
+    fn(value)
+    return value
+  }
+}
+
+export const noop = (value) => value

package/src/libs/api/metadata-converter/src/lib/gn4/atomic-operations.ts

@@ -0,0 +1,94 @@
+import { Individual, Organization } from '../../../../../../libs/common/domain/src/lib/record'
+import { getRoleFromRoleCode } from '../iso19139/codelists/role.mapper'
+
+export type SourceWithUnknownProps = { [key: string]: unknown }
+
+export const selectField = <T>(
+  source: SourceWithUnknownProps,
+  fieldName: string
+): T | null =>
+  source !== null && fieldName in source ? (source[fieldName] as T) : null
+
+export const selectFallbackFields = <T>(
+  source: SourceWithUnknownProps,
+  ...fieldNames: string[]
+): T | null =>
+  fieldNames.reduce<T>(
+    (prev, curr) => (prev === null ? selectField(source, curr) : prev),
+    null
+  )
+
+export const selectFallback = <T, U>(field: T, fallback: U): T | U =>
+  field === null ? fallback : field
+
+export const selectTranslatedValue = <T>(
+  source: SourceWithUnknownProps,
+  lang3: string
+): T | null =>
+  selectFallback(selectField(source, lang3), selectField(source, 'default'))
+
+export const selectTranslatedField = <T>(
+  source: SourceWithUnknownProps,
+  fieldName: string,
+  lang3: string
+): T | null => selectTranslatedValue(selectField(source, fieldName), lang3)
+
+export const toDate = (field) => new Date(field)
+
+export const getFirstValue = (field) =>
+  Array.isArray(field) ? field[0] : field
+
+export const getAsArray = (field) =>
+  Array.isArray(field) ? field : field !== null ? [field] : []
+
+export const getAsUrl = (
+  field,
+  location: string = window.location.toString()
+) => {
+  // an empty string is not a valid url, even though it could be considered an empty path to the root
+  if (field === '' || field === null) return null
+  let url = field
+  if (field.match(/^www\./)) url = `https://${field}`
+  try {
+    return new URL(url, location)
+  } catch {
+    return null
+  }
+}
+
+export const mapLogo = (source: SourceWithUnknownProps) => {
+  const logo = selectFallbackFields(source, 'logoUrl', 'logo')
+  return logo ? getAsUrl(`/geonetwork${logo}`) : null
+}
+
+export const mapOrganization = (
+  sourceContact: SourceWithUnknownProps,
+  lang3: string
+): Organization => {
+  const website = getAsUrl(selectField<string>(sourceContact, 'website'))
+  const logoUrl = getAsUrl(selectField<string>(sourceContact, 'logo'))
+  return {
+    name: selectFallback(
+      selectTranslatedField<string>(sourceContact, 'organisationObject', lang3),
+      selectField<string>(sourceContact, 'organisation')
+    ),
+    ...(logoUrl && { logoUrl }),
+    ...(website && { website }),
+  }
+}
+
+export const mapContact = (
+  sourceContact: SourceWithUnknownProps,
+  lang3: string
+): Individual => {
+  const address = selectField<string>(sourceContact, 'address')
+  const phone = selectField<string>(sourceContact, 'phone')
+  return {
+    lastName: selectField<string>(sourceContact, 'individual'),
+    organization: mapOrganization(sourceContact, lang3),
+    email: selectField<string>(sourceContact, 'email'),
+    role: getRoleFromRoleCode(selectField<string>(sourceContact, 'role')),
+    ...(address && { address }),
+    ...(phone && { phone }),
+  }
+}

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

@@ -0,0 +1,403 @@
+import {
+  getAsArray,
+  getAsUrl,
+  getFirstValue,
+  mapContact,
+  selectFallback,
+  selectFallbackFields,
+  selectField,
+  selectTranslatedField,
+  selectTranslatedValue,
+  SourceWithUnknownProps,
+  toDate,
+} 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 {
+  AccessConstraintType,
+  CatalogRecord,
+  DatasetDistribution,
+  DatasetDistributionType,
+  DatasetDownloadDistribution,
+  DatasetServiceDistribution,
+  OnlineLinkResource,
+} from '../../../../../../libs/common/domain/src/lib/record'
+import { matchProtocol } from '../common/distribution.mapper'
+import { LangService } from '../../../../../../libs/util/i18n/src'
+
+type ESResponseSource = SourceWithUnknownProps
+
+type EsFieldMapperFn = (
+  output: Partial<CatalogRecord>,
+  source: ESResponseSource
+) => Partial<CatalogRecord>
+
+@Injectable({
+  providedIn: 'root',
+})
+export class Gn4FieldMapper {
+  constructor(
+    private metadataUrlService: MetadataUrlService,
+    private langService: LangService
+  ) {}
+
+  private lang3 = this.langService.gnLang
+
+  protected fields: Record<string, EsFieldMapperFn> = {
+    id: (output, source) =>
+      this.addExtra({ id: selectField(source, 'id') }, output),
+    uuid: (output, source) => {
+      const uuid = selectField<string>(source, 'uuid')
+      const landingPage = getAsUrl(this.metadataUrlService.getUrl(uuid))
+      return { ...output, uniqueIdentifier: uuid, landingPage }
+    },
+    qualityScore: (output, source) =>
+      this.addExtra(
+        { qualityScore: selectField(source, 'qualityScore') },
+        output
+      ),
+    resourceTitleObject: (output, source) => ({
+      ...output,
+      title: selectFallback(
+        selectTranslatedField(source, 'resourceTitleObject', this.lang3),
+        'no title'
+      ),
+    }),
+    resourceAbstractObject: (output, source) => ({
+      ...output,
+      abstract: selectFallback(
+        selectTranslatedField(source, 'resourceAbstractObject', this.lang3),
+        'no title'
+      ),
+    }),
+    overview: (output, source) => {
+      const firstOverview = getFirstValue(selectField(source, 'overview'))
+      const description = selectTranslatedValue<string>(
+        selectField(firstOverview, 'text'),
+        this.lang3
+      )
+      return {
+        ...output,
+        overviews: [
+          {
+            url: getAsUrl(selectFallbackFields(firstOverview, 'url', 'data')),
+            ...(description ? { description } : {}),
+          },
+        ],
+      }
+    },
+    cl_topic: (output, source) => ({
+      ...output,
+      themes: [
+        ...(output.themes || []),
+        ...getAsArray(
+          selectField<SourceWithUnknownProps[]>(source, 'cl_topic')
+        ).map((topic) => selectTranslatedValue<string>(topic, this.lang3)),
+      ],
+    }),
+    cl_status: (output, source) => ({
+      ...output,
+      status: getStatusFromStatusCode(
+        selectField(getFirstValue(selectField(source, 'cl_status')), 'key')
+      ),
+    }),
+    cl_maintenanceAndUpdateFrequency: (output, source) => ({
+      ...output,
+      updateFrequency: getUpdateFrequencyFromFrequencyCode(
+        selectField(
+          getFirstValue(
+            selectField(source, 'cl_maintenanceAndUpdateFrequency')
+          ),
+          'key'
+        )
+      ),
+    }),
+    creationDateForResource: (output, source) => ({
+      ...output,
+      datasetCreated: toDate(
+        getFirstValue(selectField<string>(source, 'creationDateForResource'))
+      ),
+    }),
+    createDate: (output, source) => ({
+      ...output,
+      recordCreated: toDate(selectField<string>(source, 'createDate')),
+    }),
+    changeDate: (output, source) => ({
+      ...output,
+      recordUpdated: toDate(selectField<string>(source, 'changeDate')),
+    }),
+    link: (output, source) => {
+      const rawLinks = getAsArray(
+        selectField<SourceWithUnknownProps[]>(source, 'link')
+      )
+      const distributions = rawLinks
+        .map((link) => this.mapLink(link))
+        .filter((v) => v !== null)
+      return {
+        ...output,
+        distributions,
+      }
+    },
+    contact: (output, source) => ({
+      ...output,
+      contacts: [
+        mapContact(getFirstValue(selectField(source, 'contact')), this.lang3),
+      ],
+    }),
+    contactForResource: (output, source) => ({
+      ...output,
+      contactsForResource: [
+        ...('contactsForResource' in output &&
+        Array.isArray(output.contactsForResource)
+          ? output.contactsForResource
+          : []),
+        ...getAsArray(selectField(source, 'contactForResource')).map(
+          (contact) => mapContact(contact, this.lang3)
+        ),
+      ],
+    }),
+    sourceCatalogue: (output, source) => {
+      return this.addExtra(
+        {
+          catalogUuid: selectFallback(
+            selectField(source, 'sourceCatalogue'),
+            'no title'
+          ),
+        },
+        output
+      )
+    },
+    tag: (output, source) => ({
+      ...output,
+      keywords: getAsArray(
+        selectField<SourceWithUnknownProps[]>(source, 'tag')
+      ).map((tag) => selectTranslatedValue<string>(tag, this.lang3)),
+    }),
+    inspireTheme: (output, source) => ({
+      ...output,
+      themes: [
+        ...(output.themes || []),
+        ...getAsArray(selectField(source, 'inspireTheme_syn')),
+      ],
+    }),
+    MD_ConstraintsUseLimitationObject: (output, source) =>
+      this.constraintField('MD_ConstraintsUseLimitationObject', output, source),
+    MD_LegalConstraintsUseLimitationObject: (output, source) =>
+      this.constraintField(
+        'MD_LegalConstraintsUseLimitationObject',
+        output,
+        source
+      ),
+    MD_LegalConstraintsOtherConstraintsObject: (output, source) =>
+      this.constraintField(
+        'MD_LegalConstraintsOtherConstraintsObject',
+        output,
+        source
+      ),
+    MD_SecurityConstraintsUseLimitationObject: (output, source) =>
+      this.constraintField(
+        'MD_SecurityConstraintsUseLimitationObject',
+        output,
+        source
+      ),
+    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),
+    }),
+    mainLanguage: (output) => output,
+    userSavedCount: (output, source) =>
+      this.addExtra(
+        {
+          favoriteCount: parseInt(selectField(source, 'userSavedCount')),
+        },
+        output
+      ),
+    isOpenData: (output, source) =>
+      this.addExtra(
+        {
+          isOpenData: selectField(source, 'isOpenData') !== 'false',
+        },
+        output
+      ),
+    isPublishedToAll: (output, source) =>
+      this.addExtra(
+        {
+          isPublishedToAll: selectField(source, 'isPublishedToAll') !== 'false',
+        },
+        output
+      ),
+    userinfo: (output, source) =>
+      this.addExtra(
+        {
+          ownerInfo: selectField(source, 'userinfo'),
+        },
+        output
+      ),
+    cl_hierarchyLevel: (output, source) => {
+      const hierarchyLevel = selectField(
+        getFirstValue(selectField(source, 'cl_hierarchyLevel')),
+        'key'
+      )
+      const kind = hierarchyLevel === 'service' ? 'service' : 'dataset'
+      return {
+        ...output,
+        kind,
+      }
+    },
+  }
+
+  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)
+            ),
+          ],
+        }
+      : {
+          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'
+    }
+  }
+
+  getMappingFn(fieldName: string) {
+    return fieldName in this.fields ? this.fields[fieldName] : this.genericField
+  }
+
+  getLinkType(url: string, protocol?: string): DatasetDistributionType {
+    if (!protocol) {
+      return 'link'
+    }
+    if (
+      (/^ESRI:REST/.test(protocol) && /FeatureServer/.test(url)) ||
+      /^OGC:WMS/.test(protocol) ||
+      /^OGC:WFS/.test(protocol) ||
+      /^OGC:WMTS/.test(protocol)
+    ) {
+      return 'service'
+    }
+    if (/^WWW:DOWNLOAD/.test(protocol)) {
+      return 'download'
+    }
+    return 'link'
+  }
+
+  mapLink = (
+    sourceLink: SourceWithUnknownProps
+  ): DatasetDistribution | null => {
+    const url = getAsUrl(
+      selectFallback(
+        selectTranslatedField<string>(sourceLink, 'urlObject', this.lang3),
+        selectField<string>(sourceLink, 'url')
+      )
+    )
+    const name = selectFallback(
+      selectTranslatedField<string>(sourceLink, 'nameObject', this.lang3),
+      selectField<string>(sourceLink, 'name')
+    )
+    const description = selectFallback(
+      selectTranslatedField<string>(
+        sourceLink,
+        'descriptionObject',
+        this.lang3
+      ),
+      selectField<string>(sourceLink, 'description')
+    )
+    // no url: fail early
+    if (url === null) {
+      // TODO: collect errors at the record level?
+      console.warn('A link without valid URL was found', sourceLink)
+      return null
+    }
+
+    const protocol = selectField<string>(sourceLink, 'protocol')
+    const type = this.getLinkType(url.toString(), protocol)
+    const accessServiceProtocol = matchProtocol(protocol)
+    const mimeTypeMatches =
+      protocol && protocol.match(/^WWW:DOWNLOAD:(.+\/.+)$/)
+    const mimeType = mimeTypeMatches && mimeTypeMatches[1]
+
+    const distribution = {
+      ...(name && { name }),
+      ...(description && { description }),
+    }
+    switch (type) {
+      case 'service':
+        return {
+          ...distribution,
+          type,
+          url: url,
+          accessServiceProtocol,
+        } as DatasetServiceDistribution
+      case 'link':
+        return {
+          ...distribution,
+          type,
+          url: url,
+        } as OnlineLinkResource
+      case 'download':
+        return {
+          ...distribution,
+          type,
+          url: url,
+          ...(mimeType && { mimeType }),
+        } as DatasetDownloadDistribution
+    }
+  }
+
+  private addExtra = (value: object, output: Partial<CatalogRecord>) => ({
+    ...output,
+    extras: { ...(output.extras || {}), ...value },
+  })
+}