geonetwork-ui 2.11.0-dev.80a8b0bfa → 2.11.0-dev.840dcc932

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

@@ -1,5 +1,8 @@
 import {
   CatalogRecord,
+  DatasetFeatureAttribute,
+  DatasetFeatureAttributeValue,
+  DatasetFeatureType,
   DatasetRecord,
   Individual,
   LanguageCode,
@@ -616,3 +619,131 @@ export function writeAssociatedRecords(
     )
   )(rootEl)
 }
+
+function createNilElement(name: string, nilReason: string) {
+  return pipe(createElement(name), writeAttribute('gco:nilReason', nilReason))
+}
+
+function createFeatureCatalogueShell() {
+  return pipe(
+    createNestedElement(
+      'mdb:contentInfo',
+      'mrc:MD_FeatureCatalogue',
+      'mrc:featureCatalogue',
+      'gfc:FC_FeatureCatalogue'
+    ),
+    // create mandatory elements which are not part of the model yet
+    appendChildren(
+      createNilElement('cat:name', 'missing'),
+      createNilElement('cat:scope', 'missing'),
+      createNilElement('cat:versionNumber', 'missing'),
+      createNilElement('cat:versionDate', 'missing'),
+      createNilElement('gfc:producer', 'missing')
+    )
+  )
+}
+
+function createListedValue(value: DatasetFeatureAttributeValue) {
+  return pipe(
+    createNestedElement('gfc:listedValue', 'gfc:FC_ListedValue'),
+    appendChildren(
+      value.label
+        ? pipe(createElement('gfc:label'), writeCharacterString(value.label))
+        : createNilElement('gfc:label', 'missing'),
+      value.value
+        ? pipe(createElement('gfc:code'), writeCharacterString(value.value))
+        : null,
+      value.description
+        ? pipe(
+            createElement('gfc:definition'),
+            writeCharacterString(value.description)
+          )
+        : null
+    )
+  )
+}
+
+function createFeatureAttribute(attribute: DatasetFeatureAttribute) {
+  return pipe(
+    createNestedElement(
+      'gfc:carrierOfCharacteristics',
+      'gfc:FC_FeatureAttribute'
+    ),
+    appendChildren(
+      pipe(createElement('gfc:memberName'), setTextContent(attribute.name)),
+      attribute.description
+        ? pipe(
+            createElement('gfc:definition'),
+            writeCharacterString(attribute.description)
+          )
+        : null,
+      createNilElement('gfc:cardinality', 'missing'),
+      attribute.label
+        ? pipe(
+            createElement('gfc:designation'),
+            writeCharacterString(attribute.label)
+          )
+        : null,
+      attribute.code
+        ? pipe(createElement('gfc:code'), writeCharacterString(attribute.code))
+        : null,
+      attribute.type
+        ? pipe(
+            createNestedElement('gfc:valueType', 'gco:TypeName', 'gco:aName'),
+            writeCharacterString(attribute.type)
+          )
+        : null,
+      ...(attribute.values ?? [])
+        .filter((value) => value.value || value.label)
+        .map(createListedValue)
+    )
+  )
+}
+
+function createFeatureType(featureType: DatasetFeatureType) {
+  return pipe(
+    createNestedElement('gfc:featureType', 'gfc:FC_FeatureType'),
+    appendChildren(
+      pipe(createElement('gfc:typeName'), setTextContent(featureType.name)),
+      featureType.description
+        ? pipe(
+            createElement('gfc:definition'),
+            writeCharacterString(featureType.description)
+          )
+        : null,
+      pipe(
+        createNestedElement('gfc:isAbstract', 'gco:Boolean'),
+        setTextContent('false')
+      ),
+      featureType.label
+        ? pipe(
+            createElement('gfc:designation'),
+            writeCharacterString(featureType.label)
+          )
+        : null,
+      ...featureType.attributes.map(createFeatureAttribute),
+      createNilElement('gfc:featureCatalogue', 'missing')
+    )
+  )
+}
+
+export function writeFeatureTypeDescriptions(
+  record: DatasetRecord,
+  rootEl: XmlElement
+) {
+  const featureTypes = record.featureTypeDescriptions ?? []
+  const catalogues = findNestedElements(
+    'mdb:contentInfo',
+    'mrc:MD_FeatureCatalogue',
+    'mrc:featureCatalogue',
+    'gfc:FC_FeatureCatalogue'
+  )(rootEl)
+  catalogues.forEach((catalogue) =>
+    removeChildrenByName('gfc:featureType')(catalogue)
+  )
+  if (!featureTypes.length) return
+
+  const catalogue =
+    catalogues[0] ?? appendChildTree(createFeatureCatalogueShell())(rootEl)
+  appendChildren(...featureTypes.map(createFeatureType))(catalogue)
+}

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') {
@@ -416,6 +423,8 @@ export class Iso19139Converter extends BaseConverter<string> {
 
     if (record.kind === 'dataset') {
       fieldChanged('status') && this.writers['status'](record, rootEl)
+      fieldChanged('featureTypeDescriptions') &&
+        this.writers['featureTypeDescriptions'](record, rootEl)
     }
     if (record.kind === 'dataset' || record.kind === 'reuse') {
       fieldChanged('updateFrequency') &&

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

@@ -34,7 +34,12 @@ import {
   LanguageCode,
 } from '../../../../../../../libs/common/domain/src/lib/model/record'
 import { TranslateService } from '@ngx-translate/core'
-import { getGeometryBoundingBox } from '../../../../../../../libs/util/shared/src'
+import {
+  bboxToPolygon,
+  BoundingBox,
+  getGeometryBoundingBox,
+  isBoundingBox,
+} from '../../../../../../../libs/util/shared/src'
 import { getLength as getGeodesicLength } from 'ol/sphere.js'
 import { LineString } from 'ol/geom.js'
 
@@ -49,7 +54,12 @@ export class ElasticsearchService {
 
   // runtime fields are computed using a Painless script
   // see: https://www.elastic.co/guide/en/elasticsearch/reference/current/runtime-mapping-fields.html
-  private runtimeFields: Record<string, string> = {}
+  private runtimeFields: Record<
+    string,
+    { 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 {
@@ -91,8 +101,8 @@ export class ElasticsearchService {
     const addMapping = (fieldName: string) => {
       if (!payload.runtime_mappings) payload.runtime_mappings = {}
       payload.runtime_mappings[fieldName] = {
-        type: 'keyword',
-        script: this.runtimeFields[fieldName],
+        type: this.runtimeFields[fieldName].type,
+        script: this.runtimeFields[fieldName].script,
       }
     }
     const lookForField = (node: unknown) => {
@@ -113,6 +123,14 @@ export class ElasticsearchService {
         ) {
           addMapping(runtimeField)
         }
+        if (
+          runtimeField in node &&
+          typeof node[runtimeField] === 'object' &&
+          node[runtimeField] !== null &&
+          ('gte' in node[runtimeField] || 'lte' in node[runtimeField])
+        ) {
+          addMapping(runtimeField)
+        }
         if (
           'query' in node &&
           typeof node.query === 'string' &&
@@ -131,8 +149,16 @@ export class ElasticsearchService {
     return payload
   }
 
-  registerRuntimeField(fieldName: string, expression: string) {
-    this.runtimeFields[fieldName] = expression
+  registerRuntimeField(
+    fieldName: string,
+    expression: string,
+    type: 'keyword' | 'date' = 'keyword'
+  ) {
+    this.runtimeFields[fieldName] = { script: expression, type }
+  }
+
+  registerFieldAlias(fieldIdentifier: string, esFieldName: string) {
+    this.fieldAliases[fieldIdentifier] = esFieldName
   }
 
   getMetadataByIdsPayload(uuids: string[]): EsSearchParams {
@@ -264,8 +290,68 @@ export class ElasticsearchService {
     return this.metadataLang === 'current'
   }
 
-  private filtersToQuery(
+  private findSpatialFilterExtent(
     filters: FieldFilters | FiltersAggregationParams | string
+  ): BoundingBox | undefined {
+    if (typeof filters === 'string') {
+      return undefined
+    }
+    return Object.values(filters).find(isBoundingBox)
+  }
+
+  // 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: {
+            [maxField]: {
+              gte: formatDate(dateRange.start),
+              format: 'yyyy-MM-dd',
+            },
+          },
+        },
+        dateRange.end && {
+          range: {
+            [minField]: {
+              lte: formatDate(dateRange.end),
+              format: 'yyyy-MM-dd',
+            },
+          },
+        },
+      ].filter(Boolean)
+      return { bool: { filter } }
+    }
+    return {
+      range: {
+        [searchField]: {
+          ...(dateRange.start && { gte: formatDate(dateRange.start) }),
+          ...(dateRange.end && { lte: formatDate(dateRange.end) }),
+          format: 'yyyy-MM-dd',
+        },
+      },
+    }
+  }
+
+  private filtersToQuery(
+    filters: FieldFilters | FiltersAggregationParams | string,
+    spatialFilterExtent = this.findSpatialFilterExtent(filters)
   ): FilterQuery {
     const addQuote = (key: string) => (/^\/.+\/$/.test(key) ? key : `"${key}"`)
     const makeQuery = (filter: FieldFilter): string => {
@@ -286,50 +372,49 @@ export class ElasticsearchService {
         ? filters
         : Object.keys(filters)
             .filter((fieldname) => fieldname !== 'gn-ui-crossFieldFilter')
+            .filter((fieldname) => !isBoundingBox(filters[fieldname]))
             .filter((fieldname) => !isDateRange(filters[fieldname]))
+            .filter((fieldname) => !Array.isArray(filters[fieldname]))
             .filter(
               (fieldname) =>
                 filters[fieldname] &&
                 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']) {
       queryString = `${queryString} AND (${filters['gn-ui-crossFieldFilter']})`
     }
-    const queryRange = Object.entries(filters)
-      .filter(([, value]) => isDateRange(value))
-      .map(([searchField, dateRange]) => {
-        return {
-          searchField,
-          dateRange,
-        } as {
-          searchField: string
-          dateRange: DateRange
-        }
-      })[0]
+    const queryRanges = Object.entries(filters).filter(([, value]) =>
+      isDateRange(value)
+    ) as [string, DateRange][]
     const queryParts = [
       queryString && {
         query_string: {
           query: queryString,
         },
       },
-      queryRange &&
-        queryRange.dateRange && {
-          range: {
-            [queryRange.searchField]: {
-              ...(queryRange.dateRange.start && {
-                gte: formatDate(queryRange.dateRange.start),
-              }),
-              ...(queryRange.dateRange.end && {
-                lte: formatDate(queryRange.dateRange.end),
-              }),
-              format: 'yyyy-MM-dd',
+      ...queryRanges.map(([searchField, dateRange]) =>
+        this.buildDateRangeQuery(searchField, dateRange)
+      ),
+      spatialFilterExtent && {
+        geo_shape: {
+          geom: {
+            shape: {
+              type: 'envelope',
+              // spatialFilterExtent is [minX, minY, maxX, maxY]; envelope coordinates are [top-left, bottom-right]
+              coordinates: [
+                [spatialFilterExtent[0], spatialFilterExtent[3]],
+                [spatialFilterExtent[2], spatialFilterExtent[1]],
+              ],
             },
+            relation: 'intersects',
           },
         },
+      },
     ].filter(Boolean)
     return queryParts.length > 0 ? (queryParts as FilterQuery) : undefined
   }
@@ -368,7 +453,12 @@ export class ElasticsearchService {
         },
       })
     }
-    const queryFilters = this.filtersToQuery(fieldSearchFilters)
+    // a spatial extent filter takes precedence over the preference geometry for boosting
+    const spatialFilterExtent = this.findSpatialFilterExtent(fieldSearchFilters)
+    const queryFilters = this.filtersToQuery(
+      fieldSearchFilters,
+      spatialFilterExtent
+    )
     if (queryFilters) {
       filter.push(...queryFilters)
     }
@@ -379,7 +469,10 @@ export class ElasticsearchService {
         },
       })
     }
-    if (geometry) {
+    const boostGeometry = spatialFilterExtent
+      ? bboxToPolygon(spatialFilterExtent)
+      : geometry
+    if (boostGeometry) {
       // boosts applied using the filter geometry:
       // * records completely within the geometry receive a boost of 5
       // * records intersecting the geometry receive a boost of 2
@@ -389,7 +482,7 @@ export class ElasticsearchService {
         {
           geo_shape: {
             geom: {
-              shape: geometry,
+              shape: boostGeometry,
               relation: 'within',
             },
             boost: 5.0,
@@ -398,7 +491,7 @@ export class ElasticsearchService {
         {
           geo_shape: {
             geom: {
-              shape: geometry,
+              shape: boostGeometry,
               relation: 'intersects',
             },
             boost: 2.0,
@@ -409,7 +502,7 @@ export class ElasticsearchService {
       // this will boost the results variably depending on their distance from the given geometry
       // note: this takes into account the `location` field of a record; this is generally the center of all spatial extents
       // combined, and thus the actual size/coverage of the record spatial extent isn't relevant here
-      const bbox = getGeometryBoundingBox(geometry)
+      const bbox = getGeometryBoundingBox(boostGeometry)
       const center = [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2]
       const northToCenter = new LineString([
         [center[0], bbox[3]],
@@ -635,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':

package/src/libs/api/repository/src/lib/gn4/gn4-repository.ts

@@ -17,9 +17,9 @@ import {
   AssociatedRecord,
   CatalogRecord,
   DatasetFeatureCatalog,
-  DatasetFeatureType,
   LanguageCode,
   LinkedRecord,
+  RecordFlag,
   RecordRelation,
 } from '../../../../../../libs/common/domain/src/lib/model/record'
 import {
@@ -37,6 +37,7 @@ import {
   LanguagesApiService,
   RecordsApiService,
   SearchApiService,
+  TagsApiService,
 } from '../../../../../../libs/data-access/gn4/src'
 import {
   combineLatest,
@@ -49,7 +50,13 @@ import {
   switchMap,
   throwError,
 } from 'rxjs'
-import { catchError, map, tap } from 'rxjs/operators'
+import {
+  catchError,
+  map,
+  shareReplay,
+  tap,
+  withLatestFrom,
+} from 'rxjs/operators'
 import { lt } from 'semver'
 import { ElasticsearchService } from './elasticsearch'
 import { toLang2 } from '../../../../../../libs/util/i18n/src'
@@ -81,6 +88,7 @@ export class Gn4Repository implements RecordsRepositoryInterface {
   private platformService = inject(PlatformServiceInterface)
   private gn4LanguagesApi = inject(LanguagesApiService)
   private settingsService = inject(Gn4SettingsService)
+  private gn4TagsApi = inject(TagsApiService)
   private disableDraft = inject(DISABLE_DRAFT, { optional: true }) ?? false
   private defaultConverter = inject(DEFAULT_RECORD_CONVERTER)
 
@@ -182,43 +190,15 @@ export class Gn4Repository implements RecordsRepositoryInterface {
       )
   }
 
-  private mapEmbeddedFeatureCatalog(
-    featureTypes: Array<DatasetFeatureType>
-  ): DatasetFeatureCatalog {
-    return {
-      featureTypes: featureTypes.map((featureType) => ({
-        name: featureType.typeName || '',
-        definition: featureType.definition || '',
-        attributes: Array.isArray(featureType.attributeTable)
-          ? featureType.attributeTable.map((attr) => {
-              const values = attr.values
-                ?.filter((v) => v.code || v.label)
-                .map((v) => ({
-                  code: v.code,
-                  label: v.label,
-                }))
-              return {
-                name: attr.name,
-                code: attr.code,
-                definition: attr.definition,
-                type: attr.type,
-                ...(values?.length > 0 ? { values } : {}),
-              }
-            })
-          : [],
-      })),
-    }
-  }
-  getFeatureCatalog(
+  queryLinkedFeatureCatalog(
     record: CatalogRecord,
     visited: Set<string> = new Set() // prevent looping
   ): Observable<DatasetFeatureCatalog | null> {
     if (
-      record.extras?.['featureTypes'] &&
-      Array.isArray(record.extras['featureTypes']) &&
-      record.extras['featureTypes'].length > 0
+      'featureTypeDescriptions' in record &&
+      record.featureTypeDescriptions?.length > 0
     ) {
-      return of(this.mapEmbeddedFeatureCatalog(record.extras['featureTypes']))
+      return of({ featureTypes: record.featureTypeDescriptions })
     }
 
     const featureCatalogIdentifier = record.extras[
@@ -228,7 +208,7 @@ export class Gn4Repository implements RecordsRepositoryInterface {
       visited.add(featureCatalogIdentifier)
       return this.getRecord(featureCatalogIdentifier).pipe(
         switchMap((record) =>
-          record ? this.getFeatureCatalog(record, visited) : of(null)
+          record ? this.queryLinkedFeatureCatalog(record, visited) : of(null)
         )
       )
     }
@@ -704,4 +684,72 @@ export class Gn4Repository implements RecordsRepositoryInterface {
   private removeRecordFromLocalStorage(recordId: string): void {
     window.localStorage.removeItem(this.getLocalStorageKeyForRecord(recordId))
   }
+
+  /*
+   * FLAGS
+   * Note: in GN4 API, categories are named "tags"
+   */
+
+  categoriesIdentifierForFlags: Observable<Record<RecordFlag, number>> =
+    this.gn4TagsApi.getTags().pipe(
+      map((categories) =>
+        categories.reduce(
+          (acc, category) => {
+            if (category.name.startsWith('geonetwork-ui-flag:')) {
+              acc[
+                category.name.replace(/^geonetwork-ui-flag:/, '') as RecordFlag
+              ] = category.id
+            }
+            return acc
+          },
+          {} as Record<RecordFlag, number>
+        )
+      ),
+      shareReplay(1)
+    )
+
+  private getCategoryIdForFlag(
+    flagName: RecordFlag
+  ): Observable<number | null> {
+    return this.categoriesIdentifierForFlags.pipe(
+      map((categories) => {
+        const categoryId = categories[flagName]
+        if (categoryId === undefined) {
+          console.warn(
+            `The record flag ${flagName} is not created on GeoNetwork backend; please create a category with the name geonetwork-ui-flag:${flagName} for this to work.`
+          )
+          return null
+        }
+        return categoryId
+      })
+    )
+  }
+
+  setRecordFlag(
+    uniqueIdentifier: string,
+    flagName: RecordFlag,
+    value: boolean
+  ): Observable<void> {
+    return this.getCategoryIdForFlag(flagName).pipe(
+      switchMap((categoryId) => {
+        if (categoryId === null) return of()
+        return value
+          ? this.gn4RecordsApi.tagRecord(uniqueIdentifier, [categoryId], false)
+          : this.gn4RecordsApi.deleteTags(uniqueIdentifier, [categoryId])
+      })
+    )
+  }
+
+  getRecordFlag(
+    uniqueIdentifier: string,
+    flagName: RecordFlag
+  ): Observable<boolean> {
+    return this.gn4RecordsApi.getRecordTags(uniqueIdentifier).pipe(
+      withLatestFrom(this.getCategoryIdForFlag(flagName)),
+      map(([tags, categoryId]) => {
+        if (categoryId === null) return false
+        return Array.from(tags).some((tag) => tag.id === categoryId)
+      })
+    )
+  }
 }

package/src/libs/api/repository/src/lib/gn4/platform/gn4-platform.service.ts

@@ -92,6 +92,13 @@ export class Gn4PlatformService implements PlatformServiceInterface {
         switchMap((apiUser) => this.mapper.userFromMeApi(apiUser)),
         shareReplay({ bufferSize: 1, refCount: true })
       )
+  private isAdmin$ = this.disableAuth
+    ? of(false)
+    : of(true).pipe(
+        switchMap(() => this.meApi.getMe()),
+        map((apiUser) => !!apiUser?.admin),
+        shareReplay({ bufferSize: 1, refCount: true })
+      )
 
   /**
    * A map of already loaded thesauri (groups of keywords); the key is a URI
@@ -146,6 +153,10 @@ export class Gn4PlatformService implements PlatformServiceInterface {
     return this.isUserAnonymous$
   }
 
+  isAdministrator(): Observable<boolean> {
+    return this.isAdmin$
+  }
+
   getOrganizations(): Observable<Organization[]> {
     return undefined
   }

package/src/libs/common/domain/src/lib/model/record/flags.model.ts

@@ -0,0 +1 @@
+export type RecordFlag = 'IS_REFERENCE_DATASET'

package/src/libs/common/domain/src/lib/model/record/index.ts

@@ -3,3 +3,4 @@ export * from './metadata.model'
 export * from './organization.model'
 export * from './translation.model'
 export * from './user-feedbacks.model'
+export * from './flags.model'