geonetwork-ui 2.11.0-dev.5c2e5295e → 2.11.0-dev.80a8b0bfa

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

@@ -14,10 +14,13 @@ import {
 } from '../../../../../../libs/api/metadata-converter/src'
 import { PublicationVersionError } from '../../../../../../libs/common/domain/src/lib/model/error'
 import {
+  AssociatedRecord,
   CatalogRecord,
   DatasetFeatureCatalog,
   DatasetFeatureType,
   LanguageCode,
+  LinkedRecord,
+  RecordRelation,
 } from '../../../../../../libs/common/domain/src/lib/model/record'
 import {
   Aggregations,
@@ -145,7 +148,7 @@ export class Gn4Repository implements RecordsRepositoryInterface {
     return this.gn4SearchApi
       .search(
         'bucket',
-        ['fcats', 'hassources'],
+        ['fcats', 'hassources', 'siblings', 'associated'],
         JSON.stringify(
           this.gn4SearchHelper.getMetadataByIdsPayload([uniqueIdentifier])
         )
@@ -249,22 +252,43 @@ export class Gn4Repository implements RecordsRepositoryInterface {
       )
   }
 
-  getSources(record: CatalogRecord): Observable<CatalogRecord[]> {
-    const sourcesIdentifiers = record.extras?.['sourcesIdentifiers'] as string[]
-    if (sourcesIdentifiers && sourcesIdentifiers.length > 0) {
-      return this.getMultipleRecords(sourcesIdentifiers)
-    }
-    return of(null)
-  }
-
-  getSourceOf(record: CatalogRecord): Observable<CatalogRecord[]> {
-    const sourceOfIdentifiers = record.extras?.[
-      'sourceOfIdentifiers'
-    ] as string[]
-    if (sourceOfIdentifiers && sourceOfIdentifiers.length > 0) {
-      return this.getMultipleRecords(sourceOfIdentifiers)
+  getLinkedRecords(record: CatalogRecord): Observable<LinkedRecord[]> {
+    const siblings = (record.extras?.['siblings'] ?? []) as AssociatedRecord[]
+    const relations: Array<[RecordRelation, string[]]> = [
+      ['source', (record.extras?.['sourcesIdentifiers'] ?? []) as string[]],
+      ['sourceOf', (record.extras?.['sourceOfIdentifiers'] ?? []) as string[]],
+      ['sibling', siblings.map(({ uniqueIdentifier }) => uniqueIdentifier)],
+      [
+        'associated',
+        (record.extras?.['associatedIdentifiers'] ?? []) as string[],
+      ],
+    ]
+    const requested = relations.filter(
+      ([, identifiers]) => identifiers.length > 0
+    )
+    if (requested.length === 0) {
+      return of([])
     }
-    return of(null)
+    return forkJoin(
+      requested.map(([relation, identifiers]) =>
+        this.getMultipleRecords(identifiers).pipe(
+          map((records) =>
+            (records ?? []).map((record) => ({
+              record,
+              relation,
+              associationType:
+                relation === 'sibling'
+                  ? siblings.find(
+                      ({ uniqueIdentifier }) =>
+                        uniqueIdentifier === record.uniqueIdentifier
+                    )?.associationType
+                  : undefined,
+            }))
+          ),
+          catchError(() => of([]))
+        )
+      )
+    ).pipe(map((groups) => groups.flat()))
   }
 
   aggregate(params: AggregationsParams): Observable<Aggregations> {

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

@@ -294,6 +294,18 @@ export interface AssociatedRecord {
   associationType: AssociationType
 }
 
+/**
+ * Nature of the link between a record and another one; the association type is
+ * only known for 'sibling' relations, as it is held by the declaring record.
+ */
+export type RecordRelation = 'source' | 'sourceOf' | 'sibling' | 'associated'
+
+export interface LinkedRecord {
+  record: CatalogRecord
+  relation: RecordRelation
+  associationType?: AssociationType
+}
+
 export interface DatasetRecord extends BaseRecord {
   kind: 'dataset'
   status: RecordStatus

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

@@ -10,6 +10,7 @@ import {
   CatalogRecord,
   DatasetFeatureCatalog,
   LanguageCode,
+  LinkedRecord,
 } from '../model/record'
 
 export abstract class RecordsRepositoryInterface {
@@ -23,8 +24,7 @@ export abstract class RecordsRepositoryInterface {
   abstract getSimilarRecords(
     similarTo: CatalogRecord
   ): Observable<CatalogRecord[]>
-  abstract getSources(record: CatalogRecord): Observable<CatalogRecord[]>
-  abstract getSourceOf(record: CatalogRecord): Observable<CatalogRecord[]>
+  abstract getLinkedRecords(record: CatalogRecord): Observable<LinkedRecord[]>
   abstract fuzzySearch(query: string): Observable<SearchResults>
   abstract canDuplicate(record: CatalogRecord): boolean
   abstract canDelete(record: CatalogRecord): Observable<boolean>

package/src/libs/feature/dataviz/src/lib/chart-view/chart-view.component.ts

@@ -2,9 +2,9 @@ import {
   ChangeDetectionStrategy,
   ChangeDetectorRef,
   Component,
+  inject,
   Input,
   Output,
-  inject,
 } from '@angular/core'
 import { marker } from '@biesbjerg/ngx-translate-extract-marker'
 import {
@@ -183,7 +183,7 @@ export class ChartViewComponent {
   yChoices$ = this.properties$.pipe(
     map((properties) =>
       properties
-        .filter((prop) => prop.type === 'number' || prop.type === 'date')
+        .filter((prop) => prop.type === 'number')
         .map((prop) => ({ value: prop.name, label: prop.label || prop.name }))
     ),
     tap((choices) => {
@@ -222,6 +222,7 @@ export class ChartViewComponent {
     switchMap(([dataset, xProp, yProp, aggregation]) => {
       const fieldAgg: FieldAggregation =
         aggregation === 'count' ? ['count'] : [aggregation, yProp]
+      this.loading = true
       return dataset
         .groupBy(['distinct', xProp])
         .aggregate(fieldAgg)

package/src/libs/feature/dataviz/src/lib/geo-table-view/geo-table-view.component.ts

@@ -2,11 +2,11 @@ import {
   ChangeDetectionStrategy,
   ChangeDetectorRef,
   Component,
+  inject,
   Input,
   OnDestroy,
   OnInit,
   ViewChild,
-  inject,
 } from '@angular/core'
 import {
   DataTableComponent,
@@ -75,6 +75,7 @@ export class GeoTableViewComponent implements OnInit, OnDestroy {
   }
 
   private async initMapContext(): Promise<MapContext> {
+    this.dataset.load()
     this.dataset.selectAll()
     return {
       layers: [

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

@@ -1,15 +1,15 @@
-import { Injectable, inject } from '@angular/core'
+import { inject, Injectable } from '@angular/core'
 import { marker } from '@biesbjerg/ngx-translate-extract-marker'
 import {
+  GetCollectionItemsOptions,
   OgcApiCollectionInfo,
   OgcApiEndpoint,
   OgcApiRecord,
-  WfsEndpoint,
-  WfsVersion,
-  TmsEndpoint,
   StacEndpoint,
-  GetCollectionItemsOptions,
   StacItemsDocument,
+  TmsEndpoint,
+  WfsEndpoint,
+  WfsVersion,
 } from '@camptocamp/ogc-client'
 import {
   BaseReader,
@@ -26,7 +26,7 @@ import {
 } from '../../../../../../libs/util/shared/src'
 import type { FeatureCollection } from 'geojson'
 import { from, Observable, throwError } from 'rxjs'
-import { catchError, map, switchMap, tap } from 'rxjs/operators'
+import { catchError, map, switchMap } from 'rxjs/operators'
 import {
   DatasetOnlineResource,
   DatasetServiceDistribution,
@@ -347,14 +347,11 @@ export class DataService {
     if (link.type === 'service' && link.accessServiceProtocol === 'wfs') {
       const wfsUrlEndpoint = this.proxy.getProxiedUrl(link.url.toString())
       return from(
-        openDataset(
-          wfsUrlEndpoint,
-          'wfs',
-          {
-            wfsFeatureType: link.name,
-          },
-          cacheActive
-        )
+        openDataset(wfsUrlEndpoint, {
+          typeHint: 'wfs',
+          wfsFeatureType: link.name,
+          enableCache: cacheActive,
+        })
       )
     } else if (link.type === 'download') {
       const linkProxifiedUrl = this.proxy.getProxiedUrl(link.url.toString())
@@ -364,7 +361,10 @@ export class DataService {
           ? (format as SupportedType)
           : undefined
       return from(
-        openDataset(linkProxifiedUrl, supportedType, undefined, cacheActive)
+        openDataset(linkProxifiedUrl, {
+          typeHint: supportedType,
+          enableCache: cacheActive,
+        })
       ).pipe()
     } else if (
       link.type === 'service' &&
@@ -374,7 +374,9 @@ export class DataService {
         link.url.toString(),
         'geojson'
       )
-      return from(openDataset(url, 'geojson', undefined, cacheActive)).pipe()
+      return from(
+        openDataset(url, { typeHint: 'geojson', enableCache: cacheActive })
+      ).pipe()
     } else if (
       link.type === 'service' &&
       link.accessServiceProtocol === 'ogcFeatures'
@@ -395,12 +397,10 @@ export class DataService {
           }
           const urlWithoutLimit = new URL(geojsonUrl)
           urlWithoutLimit.searchParams.delete('limit')
-          return openDataset(
-            urlWithoutLimit.toString(),
-            'geojson',
-            undefined,
-            cacheActive
-          )
+          return openDataset(urlWithoutLimit.toString(), {
+            typeHint: 'geojson',
+            enableCache: cacheActive,
+          })
         })
       )
     }

package/src/libs/feature/record/src/lib/state/mdview.actions.ts

@@ -3,6 +3,7 @@ import { createAction, props } from '@ngrx/store'
 import {
   CatalogRecord,
   DatasetFeatureCatalog,
+  LinkedRecord,
   UserFeedback,
 } from '../../../../../../libs/common/domain/src/lib/model/record'
 
@@ -54,14 +55,9 @@ export const setRelated = createAction(
   props<{ related: CatalogRecord[] }>()
 )
 
-export const setSources = createAction(
-  '[Metadata view] Set sources',
-  props<{ sources: CatalogRecord[] }>()
-)
-
-export const setSourceOf = createAction(
-  '[Metadata view] Set has sources',
-  props<{ sourceOf: CatalogRecord[] }>()
+export const setLinkedRecords = createAction(
+  '[Metadata view] Set associated records',
+  props<{ linkedRecords: LinkedRecord[] }>()
 )
 
 /*

package/src/libs/feature/record/src/lib/state/mdview.effects.ts

@@ -70,25 +70,16 @@ export class MdViewEffects {
     )
   )
 
-  loadSources$ = createEffect(() =>
+  loadLinkedRecords$ = createEffect(() =>
     this.actions$.pipe(
       ofType(MdViewActions.loadFullMetadataSuccess),
-      switchMap(({ full }) => this.recordsRepository.getSources(full)),
-      map((sources) => {
-        return MdViewActions.setSources({ sources })
+      switchMap(({ full }) => this.recordsRepository.getLinkedRecords(full)),
+      map((linkedRecords) => {
+        return MdViewActions.setLinkedRecords({ linkedRecords })
       }),
-      catchError(() => of(MdViewActions.setSources({ sources: null })))
-    )
-  )
-
-  loadSourceOf$ = createEffect(() =>
-    this.actions$.pipe(
-      ofType(MdViewActions.loadFullMetadataSuccess),
-      switchMap(({ full }) => this.recordsRepository.getSourceOf(full)),
-      map((sourceOf) => {
-        return MdViewActions.setSourceOf({ sourceOf })
-      }),
-      catchError(() => of(MdViewActions.setSourceOf({ sourceOf: null })))
+      catchError(() =>
+        of(MdViewActions.setLinkedRecords({ linkedRecords: null }))
+      )
     )
   )
 

package/src/libs/feature/record/src/lib/state/mdview.facade.ts

@@ -74,9 +74,7 @@ export class MdViewFacade {
 
   related$ = this.store.pipe(select(MdViewSelectors.getRelated))
 
-  sources$ = this.store.pipe(select(MdViewSelectors.getSources))
-
-  sourceOf$ = this.store.pipe(select(MdViewSelectors.getSourceOf))
+  linkedRecords$ = this.store.pipe(select(MdViewSelectors.getLinkedRecords))
 
   chartConfig$ = this.store.pipe(select(MdViewSelectors.getChartConfig))
 

package/src/libs/feature/record/src/lib/state/mdview.reducer.ts

@@ -4,6 +4,7 @@ import { DatavizChartConfigModel } from '../../../../../../libs/common/domain/sr
 import {
   CatalogRecord,
   DatasetFeatureCatalog,
+  LinkedRecord,
   UserFeedback,
 } from '../../../../../../libs/common/domain/src/lib/model/record'
 
@@ -14,8 +15,7 @@ export interface MetadataViewState {
   error: { notFound?: boolean; otherError?: string } | null
   metadata?: Partial<CatalogRecord>
   related?: CatalogRecord[]
-  sources?: CatalogRecord[]
-  sourceOf?: CatalogRecord[]
+  linkedRecords?: LinkedRecord[]
   userFeedbacks?: UserFeedback[]
   allUserFeedbacksLoading: boolean
   addUserFeedbackLoading: boolean
@@ -77,14 +77,9 @@ const metadataViewReducer = createReducer(
     related,
   })),
 
-  on(MetadataViewActions.setSources, (state, { sources }) => ({
+  on(MetadataViewActions.setLinkedRecords, (state, { linkedRecords }) => ({
     ...state,
-    sources,
-  })),
-
-  on(MetadataViewActions.setSourceOf, (state, { sourceOf }) => ({
-    ...state,
-    sourceOf,
+    linkedRecords,
   })),
 
   /*

package/src/libs/feature/record/src/lib/state/mdview.selectors.ts

@@ -41,14 +41,9 @@ export const getRelated = createSelector(
   (state: MetadataViewState) => state.related
 )
 
-export const getSources = createSelector(
+export const getLinkedRecords = createSelector(
   getMdViewState,
-  (state: MetadataViewState) => state.sources
-)
-
-export const getSourceOf = createSelector(
-  getMdViewState,
-  (state: MetadataViewState) => state.sourceOf
+  (state: MetadataViewState) => state.linkedRecords
 )
 /*
   Metadata selectors

package/src/libs/ui/dataviz/src/lib/data-table/data-table.component.html

@@ -6,33 +6,32 @@
       matSort
       (matSortChange)="setSort($event)"
       [matSortDisableClear]="true"
-      *ngrxLet="properties$ as properties"
     >
-      @for (attr of _featureAttributes; track attr) {
-        <ng-container [matColumnDef]="attr.value">
+      @for (column of columns; track column) {
+        <ng-container [matColumnDef]="column.name">
           <th
             mat-header-cell
             *matHeaderCellDef
             mat-sort-header
             class="text-sm text-black bg-white"
           >
-            {{ attr.label }}
+            {{ column.label }}
           </th>
           <td
             mat-cell
             *matCellDef="let element"
             class="whitespace-nowrap pr-1 truncate"
           >
-            {{ element[attr.value] }}
+            {{ element[column.name] }}
           </td>
         </ng-container>
       }
 
-      <tr mat-header-row *matHeaderRowDef="properties; sticky: true"></tr>
+      <tr mat-header-row *matHeaderRowDef="columnNames; sticky: true"></tr>
       <tr
         [id]="getRowEltId(row.id)"
         mat-row
-        *matRowDef="let row; columns: properties"
+        *matRowDef="let row; columns: columnNames"
         (click)="selected.emit(row)"
         [class.active]="
           activeId !== undefined && activeId !== null && row.id === activeId

package/src/libs/ui/dataviz/src/lib/data-table/data-table.component.ts

@@ -6,14 +6,14 @@ import {
   Component,
   ElementRef,
   EventEmitter,
+  inject,
   Input,
   OnChanges,
   OnInit,
   Output,
   ViewChild,
-  inject,
 } from '@angular/core'
-import { MatSort, MatSortModule } from '@angular/material/sort'
+import { MatSort, MatSortModule, Sort } from '@angular/material/sort'
 import { MatTableModule } from '@angular/material/table'
 import {
   TranslateDirective,
@@ -29,12 +29,11 @@ import {
 } from '@angular/material/paginator'
 import { CustomMatPaginatorIntl } from './custom.mat.paginator.intl'
 import { CommonModule } from '@angular/common'
-import { BehaviorSubject, filter, firstValueFrom } from 'rxjs'
+import { BehaviorSubject } from 'rxjs'
 import {
   LoadingMaskComponent,
   PopupAlertComponent,
 } from '../../../../../../libs/ui/widgets/src'
-import { LetDirective } from '@ngrx/component'
 
 const rowIdPrefix = 'table-item-'
 
@@ -46,6 +45,11 @@ export interface TableItemModel {
   [key: string]: TableItemType
 }
 
+interface TableColumn {
+  name: string
+  label: string
+}
+
 @Component({
   standalone: true,
   imports: [
@@ -56,7 +60,6 @@ export interface TableItemModel {
     CommonModule,
     LoadingMaskComponent,
     PopupAlertComponent,
-    LetDirective,
     TranslatePipe,
     TranslateDirective,
   ],
@@ -71,15 +74,21 @@ export class DataTableComponent implements OnInit, AfterViewInit, OnChanges {
   private cdr = inject(ChangeDetectorRef)
   private translateService = inject(TranslateService)
 
-  _featureAttributes = []
+  columnsFromFeatureCatalog: TableColumn[] = null
   @Input() set featureAttributes(value: { value: string; label: string }[]) {
-    this._featureAttributes = value
-    this.properties$.next(value.map((attr) => attr.value))
+    this.columnsFromFeatureCatalog = value.map((attrs) => ({
+      name: attrs.value,
+      label: attrs.label,
+    }))
   }
+  columnsFromDataset: TableColumn[] = []
   @Input() set dataset(value: BaseReader) {
     this.dataset_ = value
     this.dataset_.load()
-    this.dataset_.info.then((info) => (this.count = info.itemsCount))
+    this.dataset_.info.then((info) => {
+      this.count = info.itemsCount
+      this.cdr.detectChanges()
+    })
   }
   @Input() activeId: TableItemId
   @Output() selected = new EventEmitter<any>()
@@ -88,13 +97,19 @@ export class DataTableComponent implements OnInit, AfterViewInit, OnChanges {
   @ViewChild(MatPaginator) paginator: MatPaginator
 
   dataset_: BaseReader
-  properties$ = new BehaviorSubject<string[]>(null)
   dataSource: DataTableDataSource
   headerHeight: number
   count: number
   loading$ = new BehaviorSubject<boolean>(false)
   error = null
 
+  get columns() {
+    return this.columnsFromFeatureCatalog ?? this.columnsFromDataset
+  }
+  get columnNames() {
+    return this.columns.map((c) => c.name)
+  }
+
   ngOnInit() {
     this.dataSource = new DataTableDataSource()
   }
@@ -110,7 +125,7 @@ export class DataTableComponent implements OnInit, AfterViewInit, OnChanges {
     this.setPagination()
   }
 
-  setSort(sort: MatSort) {
+  setSort(sort: Sort) {
     if (!this.dataset_) return
     if (!sort.active) {
       this.dataset_.orderBy()
@@ -132,15 +147,12 @@ export class DataTableComponent implements OnInit, AfterViewInit, OnChanges {
 
   async readData() {
     this.loading$.next(true)
-    // wait for properties to be read
-    const properties = await firstValueFrom(
-      this.properties$.pipe(filter((p) => !!p))
-    )
-    const propsWithoutGeom = properties.filter(
-      (p) => !p.toLowerCase().startsWith('geom')
-    )
-    this.dataset_.select(...propsWithoutGeom)
     try {
+      // wait for properties to be read
+      if (!this.columnsFromFeatureCatalog) {
+        this.columnsFromDataset = await this.dataset_.properties
+      }
+      this.dataset_.select(...this.columnNames)
       await this.dataSource.showData(this.dataset_.read())
       this.error = null
     } catch (error) {

package/src/libs/ui/dataviz/src/lib/data-table/data-table.fixtures.ts

@@ -25,8 +25,8 @@ export const tableItemsFixture = {
       geometry: null,
       properties: {
         id: '0003',
-        firstName: 'Claude',
-        lastName: 'François',
+        firstName: 'Lady',
+        lastName: 'Gaga',
       },
     },
   ] as DataItem[],

package/src/libs/util/data-fetcher/src/lib/data-fetcher.ts

@@ -7,20 +7,19 @@ import { DataItem, DatasetHeaders, FetchError, SupportedType } from './model'
 import { inferDatasetType } from './utils'
 import { BaseReader } from './readers/base'
 import { GmlReader } from './readers/gml'
-import { WfsVersion } from '@camptocamp/ogc-client'
 import { WfsReader } from './readers/wfs'
 
+interface OpenDatasetOptions {
+  typeHint?: SupportedType
+  wfsFeatureType?: string
+  enableCache?: boolean // by default cache will be used if this is not set to false
+}
+
 export async function openDataset(
   url: string,
-  typeHint?: SupportedType,
-  options?: {
-    namespace?: string
-    wfsVersion?: WfsVersion
-    wfsFeatureType?: string
-  },
-  cacheActive?: boolean
+  options?: OpenDatasetOptions
 ): Promise<BaseReader> {
-  const fileType = await inferDatasetType(url, typeHint)
+  const fileType = await inferDatasetType(url, options?.typeHint)
   let reader:
     | CsvReader
     | JsonReader
@@ -43,19 +42,19 @@ export async function openDataset(
         reader = new ExcelReader(url)
         break
       case 'gml':
-        reader = new GmlReader(url, options.namespace, options.wfsVersion)
+        reader = new GmlReader(url)
         break
       case 'wfs':
-        reader = await WfsReader.createReader(url, options.wfsFeatureType)
+        reader = new WfsReader(url, options?.wfsFeatureType)
         break
     }
-    reader.setCacheActive(cacheActive)
+    reader.enableCache(options?.enableCache ?? true)
     reader.load()
     return reader
-  } catch (e: any) {
-    //WfsReader may already raise a FetchError
+  } catch (e: unknown) {
+    // WfsReader may already raise a FetchError
     if (e instanceof FetchError) throw e
-    else throw FetchError.parsingFailed(e.message)
+    else throw FetchError.parsingFailed((e as Error).message)
   }
 }
 
@@ -63,22 +62,20 @@ export async function openDataset(
  * This fetches the full dataset at the given URL and parses it according to its mime type.
  * All items in the dataset are converted to GeoJSON features, even if they do not bear any spatial geometry.
  * File type can be either inferred (from the HTTP headers or the URL), or hinted using the 2nd argument
- * File type is determined liked so:
+ * File type is determined like so:
  *  1. if a type hint is given, use it
  *  2. otherwise, look for a Content-Type header in the response with a supported mime type
  *  3. if no valid mime type was found, look for an explicit file extension in the url (.csv, .geojson etc.)
  */
 export async function readDataset(
   url: string,
-  typeHint?: SupportedType,
-  options?: any,
-  cacheActive = true
+  options?: OpenDatasetOptions
 ): Promise<DataItem[]> {
-  const reader = await openDataset(url, typeHint, options, cacheActive)
+  const reader = await openDataset(url, options)
   try {
     return await reader.read()
-  } catch (e: any) {
-    throw FetchError.parsingFailed(e.message)
+  } catch (e: unknown) {
+    throw FetchError.parsingFailed((e as Error).message)
   }
 }