geonetwork-ui 2.11.0-dev.c42282af5 → 2.11.0-dev.c830efcd7

package/src/libs/api/metadata-converter/src/lib/fixtures/mel.records.dataset+featurecatalog.ts

@@ -0,0 +1,317 @@
+import { DatasetRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
+
+export const MEL_FEATURECATALOG_DATASET_RECORD: DatasetRecord = {
+  uniqueIdentifier: '1f7c8d9f-3363-4512-ad3a-064fb6b851bc',
+  kind: 'dataset',
+  otherLanguages: [],
+  defaultLanguage: 'fr',
+  recordCreated: new Date('2025-11-04T15:47:22Z'),
+  recordUpdated: new Date('2026-10-05T08:40:46.464848Z'),
+  resourceCreated: new Date('2023-10-27T00:00:00'),
+  resourcePublished: new Date('2025-11-04'),
+  title: 'Schéma cyclable 2035 - liaisons - Plan de mobilité',
+  abstract:
+    'L\'action n°35 du Plan de Mobilité de la Métropole Européenne de Lille présente le schéma cyclable métropolitain à horizon 2035. \n\nLa donnée proposée ici décrit la déclinaison en trois niveaux hiérarchiques des axes du schéma cyclable : \n- **le réseau Vélo+** pour la desserte des grandes destinations métropolitaines, \n- **le réseau intercommunal métropolitain** pour la desserte des pôles générateurs principaux, \n- **le réseau cyclable de proximité** qui assure la diffusion fine et permet de faire le lien avec les générateurs de trafic et les cœurs de quartiers.  \n  \n### Détail\nLes entités disposant du code INSEE "0000" sont situées en-dehors du périmètre MEL.\n  \n### Donnée associée à consulter : \n*Schéma cyclable 2035 - points durs - Plan de mobilité - MEL - 2023-2035*\n  \n### Contexte\nLe schéma directeur cyclable métropolitain 2035 s’ancre sur le schéma Métropole Cyclable 2020. Il en propose une vision renforcée. Il est le fruit d’une réflexion territorialisée dont l’objectif est de proposer un réseau intercommunal adapté à la géographie des territoires et aux pratiques cyclables qui ne sont pas les même en ville et à la campagne. \n\n- En milieu rural, les liaisons proposées permettront de relier les bourgs et les villages tout en organisant le rabattement vers les stations de transport collectif majeures : gares et terminus métro. Elles permettront d’accéder aux grands ensembles scolaires et zones d’emploi. Elles porteront également les déplacements longues distances vers les zones urbaines denses. \n- En zone urbaine, les liaisons inscrites au réseau intercommunal porteront les déplacements intercommunaux et inter-quartiers. Ce réseau s’articule avec le réseau de transport collectif urbain et s’appuie sur la hiérarchisation des voies. \n\n     - Il permettra de desservir la totalité des communes de la Métropole Européenne de Lille. \n     - Il assurera aussi une desserte directe de 90 % de la population, 94 % des emplois et 93 % des effectifs scolaires projetés à horizon 2035.\n\n### Le Schéma Directeur Cyclable Métropolitain\nLe schéma directeur cyclable métropolitain 2035 s’appuie en premier lieu sur un diagnostic complet ayant permis de mettre en lumière de nouveaux enjeux sur le territoire, notamment en regard des développements projetés et des évolutions comportementales à l’œuvre. \n  \nCe nouveau schéma directeur est aussi et surtout le fruit d’une concertation avec les communes de la Métropole Européenne de Lille et d’une collaboration technique active de l’association droit au vélo. Il a été construit en interface avec les territoires limitrophes.   \n  \nSa compatibilité avec les nouvelles lignes de transports en site propre et le schéma cible des véloroutes et voies vertes a été considérée.',
+  ownerOrganization: {
+    name: 'Métropole Européenne de Lille',
+    translations: {},
+  },
+  contacts: [
+    {
+      email: 'opendata@lillemetropole.fr',
+      address: '2, boulevard des Cités Unies, Lille, 59040',
+      organization: {
+        name: 'Métropole Européenne de Lille',
+        translations: {},
+      },
+      role: 'point_of_contact',
+    },
+  ],
+  contactsForResource: [
+    {
+      email: 'opendata@lillemetropole.fr',
+      address: '2, boulevard des Cités Unies, Lille, 59040',
+      organization: {
+        name: 'Métropole Européenne de Lille',
+        translations: {},
+      },
+      role: 'originator',
+    },
+    {
+      email: 'opendata@lillemetropole.fr',
+      address: '2, boulevard des Cités Unies, Lille, 59040',
+      organization: {
+        name: 'Métropole Européenne de Lille',
+        translations: {},
+      },
+      role: 'distributor',
+    },
+    {
+      email: 'datamobilite@lillemetropole.fr, mfontaine@lillemetropole.fr',
+      address: '2, boulevard des Cités Unies, Lille, 59040',
+      organization: {
+        name: 'Métropole Européenne de Lille',
+        translations: {},
+      },
+      role: 'point_of_contact',
+    },
+  ],
+  keywords: [
+    {
+      thesaurus: {
+        id: 'geonetwork.thesaurus.local.place.mel',
+        name: 'Territoires MEL',
+        url: new URL(
+          'https://data.lillemetropole.fr/geonetwork/srv/api/registries/vocabularies/local.place.mel'
+        ),
+      },
+      label: 'Métropole Européenne de Lille',
+      type: 'place',
+      translations: {},
+    },
+    {
+      thesaurus: {
+        id: 'geonetwork.thesaurus.external.theme.httpinspireeceuropaeutheme-theme',
+        name: 'GEMET - INSPIRE themes, version 1.0',
+        url: new URL(
+          'http://localhost:8080/geonetwork/srv/api/registries/vocabularies/external.theme.httpinspireeceuropaeutheme-theme'
+        ),
+      },
+      label: '',
+      type: 'theme',
+      translations: {},
+    },
+    {
+      thesaurus: {
+        id: 'geonetwork.thesaurus.external.theme.gemet',
+        name: 'GEMET',
+        url: new URL(
+          'https://data.lillemetropole.fr/geonetwork/srv/api/registries/vocabularies/external.theme.gemet'
+        ),
+      },
+      label: '',
+      type: 'theme',
+      translations: {},
+    },
+    {
+      thesaurus: {
+        id: 'geonetwork.thesaurus.external.theme.thesaurus_mot_cle_thematique_categories',
+        name: 'Catégories',
+        url: new URL(
+          'https://data.lillemetropole.fr/geonetwork/srv/api/registries/vocabularies/external.theme.thesaurus_mot_cle_thematique_categories'
+        ),
+      },
+      label: 'Mobilité, transports, déplacement',
+      type: 'theme',
+      translations: {},
+    },
+    {
+      thesaurus: {
+        id: 'geonetwork.thesaurus.external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement',
+        name: 'Mobilité, Transports, Déplacement',
+        url: new URL(
+          'https://data.lillemetropole.fr/geonetwork/srv/api/registries/vocabularies/external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement'
+        ),
+      },
+      label: 'Pistes cyclables',
+      type: 'theme',
+      translations: {},
+    },
+    {
+      thesaurus: {
+        id: 'geonetwork.thesaurus.external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement',
+        name: 'Mobilité, Transports, Déplacement',
+        url: new URL(
+          'https://data.lillemetropole.fr/geonetwork/srv/api/registries/vocabularies/external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement'
+        ),
+      },
+      label: 'Schéma cyclable',
+      type: 'theme',
+      translations: {},
+    },
+    {
+      thesaurus: {
+        id: 'geonetwork.thesaurus.external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement',
+        name: 'Mobilité, Transports, Déplacement',
+        url: new URL(
+          'https://data.lillemetropole.fr/geonetwork/srv/api/registries/vocabularies/external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement'
+        ),
+      },
+      label: 'Vélos',
+      type: 'theme',
+      translations: {},
+    },
+    {
+      thesaurus: {
+        id: 'geonetwork.thesaurus.external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement',
+        name: 'Mobilité, Transports, Déplacement',
+        url: new URL(
+          'https://data.lillemetropole.fr/geonetwork/srv/api/registries/vocabularies/external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement'
+        ),
+      },
+      label: 'Plan de mobilité',
+      type: 'theme',
+      translations: {},
+    },
+    {
+      thesaurus: {
+        id: 'geonetwork.thesaurus.external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement',
+        name: 'Mobilité, Transports, Déplacement',
+        url: new URL(
+          'https://data.lillemetropole.fr/geonetwork/srv/api/registries/vocabularies/external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement'
+        ),
+      },
+      label: 'Cyclisme',
+      type: 'theme',
+      translations: {},
+    },
+    {
+      thesaurus: {
+        id: 'geonetwork.thesaurus.external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement',
+        name: 'Mobilité, Transports, Déplacement',
+        url: new URL(
+          'https://data.lillemetropole.fr/geonetwork/srv/api/registries/vocabularies/external.theme.thesaurus_mot_cle_thematique_mobilite_transports_deplacement'
+        ),
+      },
+      label: 'Cyclable',
+      type: 'theme',
+      translations: {},
+    },
+  ],
+  topics: ['transportation'],
+  licenses: [],
+  legalConstraints: [
+    {
+      text: 'Licence Ouverte v2.0 (Etalab)',
+      translations: {},
+    },
+    {
+      text: 'Utilisation libre sous réserve de mentionner la source (a minima le nom du producteur) et la date de sa dernière mise à jour',
+      translations: {},
+    },
+  ],
+  securityConstraints: [],
+  otherConstraints: [],
+  overviews: [],
+  spatialExtents: [
+    {
+      bbox: [
+        2.78913293567365, 50.4997300394295, 3.272498092970729, 50.7945765614518,
+      ],
+      translations: {},
+    },
+  ],
+  onlineResources: [
+    {
+      type: 'service',
+      url: new URL(
+        'https://data.lillemetropole.fr/geoserver/ogc/features/v1/collections/mel_mobilite_et_transport:sc_schema_cyclable_pm35_2023/items'
+      ),
+      accessServiceProtocol: 'ogcFeatures',
+      identifierInService: 'Schéma cyclable 2035 - liaisons - Plan de mobilité',
+      name: 'Schéma cyclable 2035 - liaisons - Plan de mobilité',
+      description: 'Schéma cyclable 2035 - liaisons - Plan de mobilité',
+      translations: {},
+    },
+    {
+      type: 'service',
+      url: new URL('https://data.lillemetropole.fr/geoserver/ows'),
+      accessServiceProtocol: 'wfs',
+      identifierInService:
+        'mel_mobilite_et_transport:sc_schema_cyclable_pm35_2023',
+      name: 'mel_mobilite_et_transport:sc_schema_cyclable_pm35_2023',
+      description: 'Schéma cyclable 2035 - liaisons - Plan de mobilité',
+      translations: {},
+    },
+    {
+      type: 'service',
+      url: new URL('https://data.lillemetropole.fr/geoserver/ows'),
+      accessServiceProtocol: 'wms',
+      identifierInService:
+        'mel_mobilite_et_transport:sc_schema_cyclable_pm35_2023',
+      name: 'mel_mobilite_et_transport:sc_schema_cyclable_pm35_2023',
+      description: 'Schéma cyclable 2035 - liaisons - Plan de mobilité',
+      translations: {},
+    },
+    {
+      type: 'link',
+      url: new URL(
+        'https://plandemobilite2035.lillemetropole.fr/schema-cyclable/'
+      ),
+      name: 'Documentation',
+      description: 'Lien vers la carte dynamique « schéma cyclable »',
+      translations: {},
+    },
+  ],
+  translations: {},
+  landingPage: new URL(
+    'https://data.lillemetropole.fr/catalogue/dataset/1f7c8d9f-3363-4512-ad3a-064fb6b851bc'
+  ),
+  status: 'completed',
+  lineage: null,
+  sourceRecords: [],
+  associatedRecords: [],
+  temporalExtents: [
+    {
+      start: new Date('2023-10-27'),
+      end: new Date('2035-12-31'),
+    },
+  ],
+  updateFrequency: 'notPlanned',
+  featureTypeDescriptions: [
+    {
+      name: 'schéma cyclable - liaisons',
+      description: 'Liaisons du schéma directeur cyclable de la MEL',
+      attributes: [
+        {
+          name: 'objectid',
+          description: "Identifiant de l'objet (clé primaire)",
+          type: 'numeric(38)',
+          code: 'OBJECTID',
+        },
+        {
+          name: 'code_insee',
+          description: 'Code INSEE de la commune',
+          type: 'varchar(8)',
+          code: 'CODE_INSEE',
+        },
+        {
+          name: 'velo_plus',
+          description:
+            "Permet de savoir si l'objet décrit un tronçon faisant parti du réseau vélo + : Oui - le tronçon fait partie intégrante du réseau vélo+ /Non - le tronçon ne fait pas partie du réseau vélo+ /Option - le tronçon pourrait éventuellement faire partie du réseau réseau vélo+ / Variante - le tronçon pourrait être utilisé en lieu et place d'un autre pour répondre à un trajet équivalent",
+          type: 'varchar(256)',
+        },
+        {
+          name: 'r_ppal',
+          description:
+            "Permet de savoir si l'objet décrit un tronçon faisant parti du réseau Intercommunal : Oui - le tronçon fait partie intégrante du réseau intercommunal / Non - le tronçon ne fait pas partie du réseau intercommunal / Option : le tronçon pourrait éventuellement faire partie du réseau intercommunal / Variante : le tronçon pourrait être utilisé en lieu et place d'un autre pour répondre à un trajet équivalent",
+          type: 'varchar(256)',
+        },
+        {
+          name: 'r_scdr',
+          description:
+            "Permet de savoir si l'objet décrit un tronçon faisant parti du réseau de proximité : Oui - le tronçon fait partie intégrante du réseau cyclable de proximité / Non - le tronçon ne fait pas partie du réseau cyclable de proximité",
+          type: 'varchar(256)',
+        },
+        {
+          name: 'test_niveau_difficulte',
+          description:
+            '[Données pour tester valeurs de liste]: Donne une note de difficulté (1-5) du tronçon.',
+          type: 'varchar(256)',
+          values: [
+            { code: '1', label: 'Très facile' },
+            { code: '2', label: 'Facile' },
+            { code: '3', label: 'Moyen' },
+            { code: '4', label: 'Difficile' },
+            { code: '5', label: 'Très difficile' },
+          ],
+        },
+        {
+          name: 'geom',
+          description: 'Géométrie de type ligne simple',
+          type: 'geometry',
+        },
+      ],
+    },
+  ],
+}

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

@@ -22,12 +22,13 @@ import {
   AssociatedRecord,
   CatalogRecord,
   Constraint,
+  DatasetFeatureCatalog,
   DatasetSpatialExtent,
   OnlineResource,
   OnlineResourceType,
 } from '../../../../../../libs/common/domain/src/lib/model/record'
 import { matchProtocol } from '../common/distribution.mapper'
-import { Thesaurus } from './types'
+import { FeatureType, Thesaurus } from './types'
 import {
   getResourceType,
   getReusePresentationForm,
@@ -312,13 +313,14 @@ export class Gn4FieldMapper {
         },
         output
       ),
-    featureTypes: (output, source) =>
-      this.addExtra(
-        {
-          featureTypes: selectField(source, 'featureTypes'),
-        },
-        output
-      ),
+    featureTypes: (output, source) => {
+      const featureTypes = getAsArray(selectField(source, 'featureTypes'))
+      if (!featureTypes.length) return output
+      return {
+        ...output,
+        featureTypeDescriptions: this.featureTypesField(featureTypes),
+      }
+    },
     related: (output, source) => {
       const related = <SourceWithUnknownProps>selectField(source, 'related')
       const fcatSource = selectField(
@@ -518,6 +520,31 @@ export class Gn4FieldMapper {
 
   private genericField = (output) => output
 
+  private featureTypesField = (
+    featureTypes: FeatureType[]
+  ): DatasetFeatureCatalog['featureTypes'] =>
+    featureTypes.map((featureType) => ({
+      name: featureType.typeName ?? '',
+      ...(featureType.definition && {
+        description: featureType.definition,
+      }),
+      attributes: getAsArray(featureType.attributeTable ?? []).map((attr) => {
+        const values = (attr.values ?? [])
+          .filter((value) => value.code || value.label)
+          .map((value) => ({
+            ...(value.code && { code: value.code }),
+            ...(value.label && { label: value.label }),
+          }))
+        return {
+          name: attr.name ?? '',
+          ...(attr.definition && { description: attr.definition }),
+          ...(attr.code && { code: attr.code }),
+          ...(attr.type && { type: attr.type }),
+          ...(values.length > 0 && { values }),
+        }
+      }),
+    }))
+
   private constraintField = (
     type: 'license' | 'legal' | 'security' | 'other',
     output: Partial<CatalogRecord>,

package/src/libs/api/metadata-converter/src/lib/gn4/types/metadata.model.ts

@@ -79,6 +79,24 @@ export interface Link {
   group?: number
 }
 
+interface FeatureTypeAttribute {
+  name: string
+  code: string
+  link: string
+  definition: string
+  type: string
+  values?: Array<{ code?: string; label?: string; description?: string }>
+}
+
+export interface FeatureType {
+  typeName: string
+  definition: string
+  code: string
+  aliases: string
+  isAbstract: string
+  attributeTable: FeatureTypeAttribute[]
+}
+
 export type MetadataObject = Partial<{
   MD_ConstraintsUseLimitationObject: MultilingualField[]
   MD_LegalConstraintsOtherConstraintsObject: MultilingualField[]
@@ -109,6 +127,7 @@ export type MetadataObject = Partial<{
   extentDescriptionObject: MultilingualField[]
   extra: string
   featureOfRecord: string
+  featureTypes: FeatureType[]
   feedbackCount: string
   geom: Geometry | Geometry[]
   groupOwner: string

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

@@ -4,6 +4,7 @@ import { Iso19139Converter } from '../iso19139'
 import { renameElements } from '../xml-utils'
 import {
   readAssociatedRecords,
+  readFeatureTypeDescriptions,
   readContacts,
   readContactsForResource,
   readDefaultLanguage,
@@ -59,6 +60,7 @@ export class Iso191153Converter extends Iso19139Converter {
     this.readers['lineage'] = readLineage
     this.readers['sourceRecords'] = readSourceRecords
     this.readers['associatedRecords'] = readAssociatedRecords
+    this.readers['featureTypeDescriptions'] = readFeatureTypeDescriptions
     this.readers['onlineResources'] = readOnlineResources
     this.readers['defaultLanguage'] = readDefaultLanguage
     this.readers['otherLanguages'] = readOtherLanguages

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

@@ -5,11 +5,13 @@ import {
   findNestedElements,
   findParent,
   readAttribute,
+  readText,
   XmlElement,
 } from '../xml-utils'
 import {
   ChainableFunction,
   combine,
+  fallback,
   filterArray,
   flattenArray,
   getAtIndex,
@@ -32,6 +34,9 @@ import {
 } from '../iso19139/read-parts'
 import {
   AssociatedRecord,
+  DatasetFeatureAttribute,
+  DatasetFeatureAttributeValue,
+  DatasetFeatureCatalog,
   Individual,
   LanguageCode,
   SourceRecord,
@@ -411,3 +416,96 @@ export function readOtherLanguages(rootEl: XmlElement): LanguageCode[] {
     )
   )(rootEl)
 }
+
+function extractCharacterStringOrText(): ChainableFunction<XmlElement, string> {
+  return fallback(extractCharacterString(), readText())
+}
+
+function extractListedValue(): ChainableFunction<
+  XmlElement,
+  DatasetFeatureAttributeValue
+> {
+  return pipe(
+    combine(
+      pipe(findChildElement('gfc:code', false), extractCharacterString()),
+      pipe(findChildElement('gfc:label', false), extractCharacterString())
+    ),
+    map(([code, label]) => ({
+      ...(code && { code }),
+      ...(label && { label }),
+    }))
+  )
+}
+
+function extractFeatureAttribute(): ChainableFunction<
+  XmlElement,
+  DatasetFeatureAttribute
+> {
+  return pipe(
+    combine(
+      pipe(
+        findChildElement('gfc:memberName', false),
+        extractCharacterStringOrText()
+      ),
+      pipe(findChildElement('gfc:definition', false), extractCharacterString()),
+      pipe(findChildElement('gfc:code', false), extractCharacterString()),
+      pipe(
+        findNestedElement('gfc:valueType', 'gco:TypeName', 'gco:aName'),
+        extractCharacterString()
+      ),
+      pipe(
+        findNestedElements('gfc:listedValue', 'gfc:FC_ListedValue'),
+        mapArray(extractListedValue()),
+        filterArray((value) => !!(value.code || value.label))
+      )
+    ),
+    map(([name, description, code, type, values]) => ({
+      name: name ?? '',
+      ...(description && { description }),
+      ...(code && { code }),
+      ...(type && { type }),
+      ...(values.length > 0 && { values }),
+    }))
+  )
+}
+
+export function readFeatureTypeDescriptions(
+  rootEl: XmlElement
+): DatasetFeatureCatalog['featureTypes'] {
+  return pipe(
+    findNestedElements(
+      'mdb:contentInfo',
+      'mrc:MD_FeatureCatalogue',
+      'mrc:featureCatalogue',
+      'gfc:FC_FeatureCatalogue',
+      'gfc:featureType',
+      'gfc:FC_FeatureType'
+    ),
+    mapArray(
+      pipe(
+        combine(
+          pipe(
+            findChildElement('gfc:typeName', false),
+            extractCharacterStringOrText()
+          ),
+          pipe(
+            findChildElement('gfc:definition', false),
+            extractCharacterString()
+          ),
+          pipe(
+            findNestedElements(
+              'gfc:carrierOfCharacteristics',
+              'gfc:FC_FeatureAttribute'
+            ),
+            mapArray(extractFeatureAttribute())
+          )
+        ),
+        map(([name, description, attributes]) => ({
+          name: name ?? '',
+          ...(description && { description }),
+          attributes,
+        }))
+      )
+    )
+  )(rootEl)
+}

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

@@ -118,6 +118,7 @@ export class Iso19139Converter extends BaseConverter<string> {
     lineage: readLineage,
     sourceRecords: readSourceRecords,
     associatedRecords: readAssociatedRecords,
+    featureTypeDescriptions: () => undefined,
     onlineResources: readOnlineResources,
     temporalExtents: readTemporalExtents,
     spatialExtents: readSpatialExtents,
@@ -161,6 +162,7 @@ export class Iso19139Converter extends BaseConverter<string> {
     lineage: writeLineage,
     sourceRecords: writeSourceRecords,
     associatedRecords: writeAssociatedRecords,
+    featureTypeDescriptions: () => undefined,
     onlineResources: writeOnlineResources,
     temporalExtents: writeTemporalExtents,
     spatialExtents: writeSpatialExtents,
@@ -306,6 +308,10 @@ export class Iso19139Converter extends BaseConverter<string> {
       const sourceRecords = this.readers['sourceRecords'](rootEl, tr)
       const associatedRecords = this.readers['associatedRecords'](rootEl, tr)
       const updateFrequency = this.readers['updateFrequency'](rootEl, tr)
+      const featureTypeDescriptions = this.readers['featureTypeDescriptions'](
+        rootEl,
+        tr
+      ) as DatasetRecord['featureTypeDescriptions']
 
       return this.afterRecordRead({
         ...this.readBaseRecord(rootEl, tr),
@@ -317,6 +323,7 @@ export class Iso19139Converter extends BaseConverter<string> {
         ...(spatialRepresentation && { spatialRepresentation }),
         temporalExtents,
         updateFrequency,
+        ...(featureTypeDescriptions?.length && { featureTypeDescriptions }),
         translations: tr,
       } as DatasetRecord)
     } else if (kind === 'reuse') {

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

@@ -69,7 +69,8 @@ export function extractCharacterString(): ChainableFunction<
     fallback(
       findChildElement('gco:CharacterString', false),
       findChildElement('gmx:Anchor', false),
-      findChildElement('gmx:MimeFileType', false)
+      findChildElement('gmx:MimeFileType', false),
+      findChildElement('gco:LocalName', false)
     ),
     readText()
   )

package/src/libs/api/repository/src/lib/gn4/elasticsearch/elasticsearch.service.ts

@@ -59,6 +59,8 @@ export class ElasticsearchService {
     { script: string; type: 'keyword' | 'date' }
   > = {}
 
+  private fieldAliases: Record<string, string> = {}
+
   // we're using getters in case the defined languages change over time
   private get metadataLang(): LanguageCode {
     const mdLangValue = this.injector.get(METADATA_LANGUAGE, null)
@@ -155,6 +157,10 @@ export class ElasticsearchService {
     this.runtimeFields[fieldName] = { script: expression, type }
   }
 
+  registerFieldAlias(fieldIdentifier: string, esFieldName: string) {
+    this.fieldAliases[fieldIdentifier] = esFieldName
+  }
+
   getMetadataByIdsPayload(uuids: string[]): EsSearchParams {
     return {
       query: {
@@ -293,12 +299,25 @@ export class ElasticsearchService {
     return Object.values(filters).find(isBoundingBox)
   }
 
-  // if a field registered min/max runtime fields, its dates form an interval
-  // the record matches if that interval intersects the filter range
+  // builds a query matching records whose dates intersect the filter range
   private buildDateRangeQuery(searchField: string, dateRange: DateRange) {
+    // fields ending with 'DateRange' maps as ES range type
+    if (searchField.endsWith('DateRange')) {
+      return {
+        range: {
+          [searchField]: {
+            ...(dateRange.start && { gte: formatDate(dateRange.start) }),
+            ...(dateRange.end && { lte: formatDate(dateRange.end) }),
+            format: 'yyyy-MM-dd',
+            relation: 'intersects',
+          },
+        },
+      }
+    }
     const minField = `${searchField}Min`
     const maxField = `${searchField}Max`
     if (minField in this.runtimeFields && maxField in this.runtimeFields) {
+      // min/max runtime fields form an interval per record; match if it intersects the filter range
       const filter = [
         dateRange.start && {
           range: {
@@ -362,7 +381,8 @@ export class ElasticsearchService {
                 JSON.stringify(filters[fieldname]) !== '{}'
             )
             .map(
-              (fieldname) => `${fieldname}:(${makeQuery(filters[fieldname])})`
+              (fieldname) =>
+                `${this.fieldAliases[fieldname] ?? fieldname}:(${makeQuery(filters[fieldname])})`
             )
             .join(' AND ')
     if (filters['gn-ui-crossFieldFilter']) {
@@ -708,6 +728,12 @@ export class ElasticsearchService {
               order: {
                 [`_${aggregation.sort[1]}`]: aggregation.sort[0],
               },
+              ...(aggregation.includeValues && {
+                include: aggregation.includeValues,
+              }),
+              ...(aggregation.excludeValues && {
+                exclude: aggregation.excludeValues,
+              }),
             },
           }
         case 'histogram':