geonetwork-ui 2.11.0-dev.fb3fea50c → 2.11.0-dev.fb48cfeee

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

@@ -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,6 +299,56 @@ export class ElasticsearchService {
     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)
@@ -325,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']) {
@@ -340,15 +397,9 @@ export class ElasticsearchService {
           query: queryString,
         },
       },
-      ...queryRanges.map(([searchField, dateRange]) => ({
-        range: {
-          [searchField]: {
-            ...(dateRange.start && { gte: formatDate(dateRange.start) }),
-            ...(dateRange.end && { lte: formatDate(dateRange.end) }),
-            format: 'yyyy-MM-dd',
-          },
-        },
-      })),
+      ...queryRanges.map(([searchField, dateRange]) =>
+        this.buildDateRangeQuery(searchField, dateRange)
+      ),
       spatialFilterExtent && {
         geo_shape: {
           geom: {
@@ -677,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'

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

@@ -316,6 +316,7 @@ export interface DatasetRecord extends BaseRecord {
   spatialExtents: Array<DatasetSpatialExtent>
   temporalExtents: Array<DatasetTemporalExtent>
   spatialRepresentation?: SpatialRepresentationType
+  featureTypeDescriptions?: Array<DatasetFeatureType>
 }
 
 export interface ServiceEndpoint {
@@ -347,33 +348,28 @@ export interface ReuseRecord extends BaseRecord {
   temporalExtents: Array<DatasetTemporalExtent>
 }
 
+export interface DatasetFeatureType {
+  name: string
+  label?: string
+  description?: string
+  attributes: DatasetFeatureAttribute[]
+}
 export type DatasetFeatureCatalog = {
-  featureTypes: Array<{
-    name: string
-    definition: string
-    attributes: DatasetFeatureAttribute[]
-  }>
+  featureTypes: Array<DatasetFeatureType>
 }
 export interface DatasetFeatureAttributeValue {
-  code?: string
-  definition?: string
+  value: string // empty string when the value has no code
   label?: string
+  description?: string
 }
 export interface DatasetFeatureAttribute {
   name: string
-  definition: string
-  type: string
-  code: string
+  label?: string
+  description?: string
+  type?: string
+  code?: string
   values?: Array<DatasetFeatureAttributeValue>
 }
-export interface DatasetFeatureType {
-  aliases: string
-  code: string
-  isAbstract: string
-  typeName: string
-  definition: string
-  attributeTable: Array<DatasetFeatureAttribute>
-}
 
 export type ReuseType = 'application' | 'map' | 'other'
 

package/src/libs/common/domain/src/lib/model/search/aggregation.model.ts

@@ -7,6 +7,8 @@ export interface TermsAggregationParams {
   limit: number
   sort: AggregationSort
   filter?: string
+  includeValues?: string[]
+  excludeValues?: string[]
 }
 export interface HistogramAggregationParams {
   type: 'histogram'

package/src/libs/common/domain/src/lib/model/search/filter.model.ts

@@ -21,7 +21,10 @@ export type QueryString = {
   query_string: string
 }
 export type QueryRange = {
-  range: Record<string, { format: string; gte: string; lte: string }>
+  range: Record<
+    string,
+    { format: string; gte?: string; lte?: string; relation?: string }
+  >
 }
 export type QueryGeoShape = {
   geo_shape: {
@@ -31,4 +34,11 @@ export type QueryGeoShape = {
     }
   }
 }
-export type FilterQuery = Array<QueryString | QueryRange | QueryGeoShape>
+export type QueryBool = {
+  bool: {
+    filter: QueryRange[]
+  }
+}
+export type FilterQuery = Array<
+  QueryString | QueryRange | QueryGeoShape | QueryBool
+>

package/src/libs/common/domain/src/lib/platform.service.interface.ts

@@ -28,6 +28,7 @@ export abstract class PlatformServiceInterface {
   abstract supportsAuthentication(): boolean
   abstract getMe(): Observable<UserModel>
   abstract isAnonymous(): Observable<boolean>
+  abstract isAdministrator(): Observable<boolean>
   abstract getUsers(): Observable<UserModel[]>
   abstract getUserPermissionsByGroup(): Observable<GroupModel[]>
   abstract getUsersByOrganization(

package/src/libs/common/domain/src/lib/repository/records-repository.interface.ts

@@ -11,13 +11,14 @@ import {
   DatasetFeatureCatalog,
   LanguageCode,
   LinkedRecord,
+  RecordFlag,
 } from '../model/record'
 
 export abstract class RecordsRepositoryInterface {
   abstract search(params: SearchParams): Observable<SearchResults>
   abstract getMatchesCount(filters: FieldFilters): Observable<number>
   abstract getRecord(uniqueIdentifier: string): Observable<CatalogRecord | null>
-  abstract getFeatureCatalog(
+  abstract queryLinkedFeatureCatalog(
     record: CatalogRecord
   ): Observable<DatasetFeatureCatalog | null>
   abstract aggregate(params: AggregationsParams): Observable<Aggregations>
@@ -106,4 +107,22 @@ export abstract class RecordsRepositoryInterface {
   ): Observable<{ user: string; date: Date }>
   abstract getRecordPublicationStatus(uuid: string): Observable<boolean>
   abstract getApplicationLanguages(): Observable<LanguageCode[]>
+
+  /**
+   * Sets a given flag on a record. Flags are not part of the metadata document, which is why they are
+   * not part of the Record model.
+   */
+  abstract setRecordFlag(
+    uniqueIdentifier: string,
+    flagName: RecordFlag,
+    value: boolean
+  ): Observable<void>
+
+  /**
+   * Checks whether a given flag is enabled for a record.
+   */
+  abstract getRecordFlag(
+    uniqueIdentifier: string,
+    flagName: RecordFlag
+  ): Observable<boolean>
 }