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

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,7 +17,6 @@ import {
   AssociatedRecord,
   CatalogRecord,
   DatasetFeatureCatalog,
-  DatasetFeatureType,
   LanguageCode,
   LinkedRecord,
   RecordRelation,
@@ -182,43 +181,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 +199,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)
         )
       )
     }

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?: DatasetFeatureCatalog['featureTypes']
 }
 
 export interface ServiceEndpoint {
@@ -350,30 +351,22 @@ export interface ReuseRecord extends BaseRecord {
 export type DatasetFeatureCatalog = {
   featureTypes: Array<{
     name: string
-    definition: string
+    description?: string
     attributes: DatasetFeatureAttribute[]
   }>
 }
 export interface DatasetFeatureAttributeValue {
   code?: string
-  definition?: string
+  description?: string
   label?: string
 }
 export interface DatasetFeatureAttribute {
   name: string
-  definition: string
-  type: string
-  code: 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

@@ -6,17 +6,39 @@ export type FieldFilterByRange = {
   start?: Date
   end?: Date
 }
+// matches util/shared's BoundingBox; duplicated here to avoid a circular
+// dependency (util/shared already depends on common/domain)
+export type FieldFilterByBoundingBox = [number, number, number, number]
 
 export type FieldFilter =
   | FieldFilterByExpression
   | FieldFilterByValues
   | FieldFilterByRange
+  | FieldFilterByBoundingBox
 export type FieldFilters = Record<FieldName, FieldFilter>
 
 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 FilterQuery = Array<QueryString | QueryRange>
+export type QueryGeoShape = {
+  geo_shape: {
+    geom: {
+      shape: { type: string; coordinates: number[][] }
+      relation: string
+    }
+  }
+}
+export type QueryBool = {
+  bool: {
+    filter: QueryRange[]
+  }
+}
+export type FilterQuery = Array<
+  QueryString | QueryRange | QueryGeoShape | QueryBool
+>

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

@@ -17,7 +17,7 @@ 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>

package/src/libs/common/fixtures/src/lib/records.fixtures.ts

@@ -164,69 +164,49 @@ As such, **it is not very interesting at all.**`,
     extras: {
       isPublishedToAll: true,
       edit: true,
-      featureTypes: [
-        {
-          attributeTable: [
-            {
-              code: 'OBJECTID',
-              name: 'OBJECTID',
-              link: '',
-              definition: 'Object identifier',
-              type: 'OID',
-            },
-            {
-              code: 'NOM',
-              name: 'Nom',
-              link: '',
-              definition: 'Nom de la rue',
-              type: 'String (48)',
-              values: [
-                {
-                  code: 'Pomme',
-                  label: 'Les Pommiers',
-                  description: 'Sous les pommiers',
-                },
-                {
-                  code: 'Cotton',
-                  label: 'Rue Cotton',
-                  description: 'Rue Cotton',
-                },
-                { code: "Passage de l'échiquier" },
-                { description: 'Rue du Charlieu' },
-              ],
-            },
-            {
-              code: 'RUE',
-              name: 'Rue',
-              link: '',
-              definition: '',
-              type: 'String (50)',
-            },
-          ],
-          code: '',
-          aliases: '',
-          typeName: "Catalogue d'attributs N°1",
-          definition: 'Définition du catalogue d attributs N°1',
-          isAbstract: 'false',
-        },
-        {
-          attributeTable: [
-            {
-              code: 'UniqueObject',
-              name: 'unique object ',
-              link: '',
-              definition: 'this is the only object of this catalog',
-              type: 'String (50)',
-            },
-          ],
-          code: '',
-          aliases: '',
-          typeName: "Catalogue d'attributs N°2",
-          definition: 'Définition du catalogue d attributs N°2',
-          isAbstract: 'false',
-        },
-      ],
     },
+    featureTypeDescriptions: [
+      {
+        name: "Catalogue d'attributs N°1",
+        description: 'Définition du catalogue d attributs N°1',
+        attributes: [
+          {
+            name: 'OBJECTID',
+            description: 'Object identifier',
+            code: 'OBJECTID',
+            type: 'OID',
+          },
+          {
+            name: 'Nom',
+            description: 'Nom de la rue',
+            code: 'NOM',
+            type: 'String (48)',
+            values: [
+              { code: 'Pomme', label: 'Les Pommiers' },
+              { code: 'Cotton', label: 'Rue Cotton' },
+              { code: "Passage de l'échiquier" },
+            ],
+          },
+          {
+            name: 'Rue',
+            code: 'RUE',
+            type: 'String (50)',
+          },
+        ],
+      },
+      {
+        name: "Catalogue d'attributs N°2",
+        description: 'Définition du catalogue d attributs N°2',
+        attributes: [
+          {
+            name: 'unique object ',
+            description: 'this is the only object of this catalog',
+            code: 'UniqueObject',
+            type: 'String (50)',
+          },
+        ],
+      },
+    ],
   },
   {
     uniqueIdentifier: '7d002c4c-92ef-4b9f-a568-d732f740b99e',

package/src/libs/feature/dataviz/src/lib/service/data.service.ts

@@ -209,7 +209,8 @@ export class DataService {
     ogcApiLink: DatasetServiceDistribution
   ): Promise<DatasetOnlineResource[]> {
     const collectionInfo = await this.getDownloadUrlsFromOgcApi(
-      ogcApiLink.url.href
+      ogcApiLink.url.href,
+      ogcApiLink.name
     )
 
     return Object.keys(collectionInfo.bulkDownloadLinks).map((mimeType) => {
@@ -229,31 +230,41 @@ export class DataService {
     })
   }
 
-  async getDownloadUrlsFromOgcApi(url: string): Promise<OgcApiCollectionInfo> {
+  private async getTargetCollectionId(
+    endpoint: OgcApiEndpoint,
+    collectionId?: string
+  ): Promise<string | undefined> {
+    const collections = await endpoint.featureCollections
+    return collections.length === 1 && !collectionId
+      ? collections[0]
+      : collectionId
+  }
+
+  async getDownloadUrlsFromOgcApi(
+    url: string,
+    collectionId?: string
+  ): Promise<OgcApiCollectionInfo> {
     const endpoint = new OgcApiEndpoint(url)
-    return await endpoint.featureCollections
-      .then((collections) => {
-        return endpoint.getCollectionInfo(collections[0])
-      })
-      .catch((error) => {
-        throw new Error(`ogc.unreachable.unknown`)
-      })
+    try {
+      const id = await this.getTargetCollectionId(endpoint, collectionId)
+      return await endpoint.getCollectionInfo(id)
+    } catch {
+      throw new Error('ogc.unreachable.unknown')
+    }
   }
 
   async getItemsFromOgcApi(
     url: string,
+    collectionId?: string,
     limit?: number
   ): Promise<OgcApiRecord[]> {
     const endpoint = new OgcApiEndpoint(url)
-    return await endpoint.featureCollections
-      .then((collections) => {
-        return collections.length
-          ? endpoint.getCollectionItems(collections[0], limit)
-          : null
-      })
-      .catch(() => {
-        throw new Error(`ogc.unreachable.unknown`)
-      })
+    try {
+      const id = await this.getTargetCollectionId(endpoint, collectionId)
+      return await endpoint.getCollectionItems(id, limit)
+    } catch {
+      throw new Error('ogc.unreachable.unknown')
+    }
   }
 
   async getItemsFromStacApi(
@@ -381,7 +392,9 @@ export class DataService {
       link.type === 'service' &&
       link.accessServiceProtocol === 'ogcFeatures'
     ) {
-      return from(this.getDownloadUrlsFromOgcApi(link.url.href)).pipe(
+      return from(
+        this.getDownloadUrlsFromOgcApi(link.url.href, link.name)
+      ).pipe(
         switchMap((collectionInfo) => {
           const isMimeTypeJson = (mimeType: string): boolean => {
             return mimeType.toLowerCase().indexOf('json') > -1

package/src/libs/feature/map/src/index.ts

@@ -6,8 +6,6 @@ export * from './lib/feature-map.module'
 export * from './lib/map-state-container/map-state-container.component'
 export * from './lib/constant'
 export * from './lib/utils'
-export * from './lib/style'
 export * from './lib/layers-panel/layers-panel.component'
 export * from './lib/add-layer-from-catalog/add-layer-from-catalog.component'
 export * from './lib/add-layer-from-catalog/add-layer-record-preview/add-layer-record-preview.component'
-export * from './lib/geocoding/geocoding.component'

package/src/libs/feature/map/src/lib/add-layer-from-file/add-layer-from-file.component.html

@@ -5,6 +5,7 @@
         (fileChange)="handleFileChange($event)"
         [accept]="acceptedMimeType.join(',')"
         [placeholder]="'map.addFromFile.placeholder' | translate"
+        textClass="text-gray-900 pl-2 py-2"
         class="placeholder-grey"
       ></gn-ui-drag-and-drop-file-input>
     </div>

package/src/libs/feature/map/src/lib/feature-map.module.ts

@@ -2,18 +2,11 @@ import { NgModule } from '@angular/core'
 import { StoreModule } from '@ngrx/store'
 import * as fromMap from './+state/map.reducer'
 import { MapFacade } from './+state/map.facade'
-import { GEOCODING_PROVIDER, GeocodingProvider } from './geocoding.service'
 
 @NgModule({
   imports: [
     StoreModule.forFeature(fromMap.MAP_FEATURE_KEY, fromMap.mapReducer),
   ],
-  providers: [
-    MapFacade,
-    {
-      provide: GEOCODING_PROVIDER,
-      useValue: ['geonames', { maxRows: 5 }] as GeocodingProvider,
-    },
-  ],
+  providers: [MapFacade],
 })
 export class FeatureMapModule {}