geonetwork-ui 2.2.0-dev.e0d0f7a1 → 2.2.0-dev.e441b922

package/src/libs/feature/editor/src/lib/fields.config.ts

@@ -0,0 +1,35 @@
+import { EditorFieldsConfig } from './models/fields.model'
+
+export const DEFAULT_FIELDS: EditorFieldsConfig = [
+  {
+    model: 'title',
+    formFieldConfig: {
+      labelKey: 'Metadata title',
+      type: 'text',
+    },
+  },
+  {
+    model: 'abstract',
+    formFieldConfig: {
+      labelKey: 'Abstract',
+      type: 'rich',
+    },
+  },
+  {
+    model: 'uniqueIdentifier',
+    formFieldConfig: {
+      labelKey: 'Unique identifier',
+      type: 'text',
+      locked: true,
+    },
+  },
+  {
+    model: 'recordUpdated',
+    formFieldConfig: {
+      labelKey: 'Record Updated',
+      type: 'text',
+      locked: true,
+    },
+    onSaveProcess: '${dateNow()}',
+  },
+]

package/src/libs/feature/editor/src/lib/models/fields.model.ts

@@ -0,0 +1,29 @@
+import { FormFieldConfig } from '../../../../../../libs/ui/inputs/src'
+
+// Expressions should be enclosed in `${}` to be recognized as such
+// eg. ${dateNow()}
+export type EditorFieldExpression = `$\{${string}}`
+
+export interface EditorFieldConfig {
+  // configuration of the form field used as presentation; optional, nothing shown if not defined
+  formFieldConfig?: FormFieldConfig
+
+  // name of the target field in the record; will not change the record directly if not defined
+  model?: string
+
+  // a hidden field won't show but can still be used to modify the record
+  // FIXME: currently this is redundant with an absence of formFieldConfig but necessary for clarity
+  hidden?: boolean
+
+  // the result of this expression will replace the field value on save
+  onSaveProcess?: EditorFieldExpression
+}
+
+export type EditorFieldsConfig = EditorFieldConfig[]
+
+export type EditorFieldValue = string | number | boolean | unknown
+
+export interface EditorFieldState {
+  config: EditorFieldConfig
+  value: string | number | boolean | unknown
+}

package/src/libs/feature/editor/src/lib/record-form/record-form.component.html

@@ -1,8 +1,10 @@
-<div class="flex flex-col gap-6">
-  <gn-ui-form-field
-    *ngFor="let field of editorService.fields$ | async; trackBy: fieldTracker"
-    [config]="field.config"
-    [value]="field.value"
-    (valueChange)="handleFieldValueChange(field.config.model, $event)"
-  ></gn-ui-form-field>
+<div class="flex flex-col gap-6 p-6">
+  <ng-container *ngFor="let field of fields$ | async; trackBy: fieldTracker">
+    <gn-ui-form-field
+      *ngIf="field.config.formFieldConfig && !field.config.hidden"
+      [config]="field.config.formFieldConfig"
+      [value]="field.value"
+      (valueChange)="handleFieldValueChange(field, $event)"
+    ></gn-ui-form-field>
+  </ng-container>
 </div>

package/src/libs/feature/editor/src/lib/record-form/record-form.component.ts

@@ -1,6 +1,8 @@
 import { CommonModule } from '@angular/common'
 import { ChangeDetectionStrategy, Component } from '@angular/core'
-import { EditorService, FormField } from '../services/editor.service'
+import { UiInputsModule } from '../../../../../../libs/ui/inputs/src'
+import { EditorFacade } from '../+state/editor.facade'
+import { EditorFieldState, EditorFieldValue } from '../models/fields.model'
 
 @Component({
   selector: 'gn-ui-record-form',
@@ -8,16 +10,21 @@ import { EditorService, FormField } from '../services/editor.service'
   styleUrls: ['./record-form.component.css'],
   changeDetection: ChangeDetectionStrategy.OnPush,
   standalone: true,
-  imports: [CommonModule],
+  imports: [CommonModule, UiInputsModule],
 })
 export class RecordFormComponent {
-  constructor(public editorService: EditorService) {}
+  fields$ = this.facade.recordFields$
 
-  handleFieldValueChange(fieldName: string, value: unknown) {
-    this.editorService.updateRecordField(fieldName, value)
+  constructor(public facade: EditorFacade) {}
+
+  handleFieldValueChange(field: EditorFieldState, newValue: EditorFieldValue) {
+    if (!field.config.model) {
+      return
+    }
+    this.facade.updateRecordField(field.config.model, newValue)
   }
 
-  fieldTracker(index: number, field: FormField) {
+  fieldTracker(index: number, field: EditorFieldState) {
     return field.config.model
   }
 }

package/src/libs/feature/editor/src/lib/services/editor.service.ts

@@ -1,59 +1,27 @@
 import { Inject, Injectable, Optional } from '@angular/core'
 import { toModel, toXml } from '../../../../../../libs/api/metadata-converter/src'
 import { Configuration } from '../../../../../../libs/data-access/gn4/src'
-import { BehaviorSubject, Observable } from 'rxjs'
-import { finalize, map, switchMap, take, tap } from 'rxjs/operators'
+import { Observable } from 'rxjs'
+import { map } from 'rxjs/operators'
 import { HttpClient } from '@angular/common/http'
-import { FormFieldConfig } from '../../../../../../libs/ui/inputs/src'
 import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
-
-export interface FormField {
-  config: FormFieldConfig
-  value: string | number | boolean | unknown
-}
+import { EditorFieldsConfig } from '../models/fields.model'
+import { evaluate } from '../expressions'
 
 @Injectable({
   providedIn: 'root',
 })
 export class EditorService {
-  private record$ = new BehaviorSubject<CatalogRecord | null>(null)
-  private fieldsConfig: FormFieldConfig[] = [
-    {
-      model: 'title',
-      labelKey: 'Metadata title',
-      type: 'text',
-    },
-    {
-      model: 'abstract',
-      labelKey: 'Abstract',
-      type: 'rich',
-    },
-    {
-      model: 'uniqueIdentifier',
-      labelKey: 'Unique identifier',
-      type: 'text',
-      locked: true,
-    },
-  ]
-
   private apiUrl = `${this.apiConfiguration?.basePath || '/geonetwork/srv/api'}`
 
-  fields$: Observable<FormField[]> = this.record$.pipe(
-    map((record) =>
-      this.fieldsConfig.map((fieldConfig) => ({
-        config: fieldConfig,
-        value: record?.[fieldConfig.model] || null,
-      }))
-    )
-  )
-  saving$ = new BehaviorSubject(false)
-
   constructor(
     private http: HttpClient,
     @Optional()
     @Inject(Configuration)
     private apiConfiguration: Configuration
   ) {}
+
+  // TODO: use the catalog repository instead
   loadRecordByUuid(uuid: string): Observable<CatalogRecord> {
     return this.http
       .get(`${this.apiUrl}/records/${uuid}/formatters/xml`, {
@@ -65,43 +33,36 @@ export class EditorService {
       .pipe(map((response) => toModel(response.toString())))
   }
 
-  saveCurrentRecord(): Observable<void> {
-    return this.record$.pipe(
-      take(1),
-      tap((record) => {
-        if (!record)
-          throw new Error('Save record failed: no record currently open')
-        this.saving$.next(true)
-      }),
-      switchMap((record) =>
-        this.http.put(
-          `${this.apiUrl}/records?metadataType=METADATA&uuidProcessing=OVERWRITE&transformWith=_none_&publishToAll=on`,
-          toXml(record),
-          {
-            headers: {
-              'Content-Type': 'application/xml',
-            },
-            withCredentials: true,
-          }
-        )
-      ),
-      map(() => undefined),
-      finalize(() => {
-        this.saving$.next(false)
-      })
-    )
-  }
+  // returns the record as it was when saved
+  saveRecord(
+    record: CatalogRecord,
+    fieldsConfig: EditorFieldsConfig
+  ): Observable<CatalogRecord> {
+    const savedRecord = { ...record }
 
-  setCurrentRecord(record: CatalogRecord) {
-    this.record$.next(record)
-  }
+    // run onSave processes
+    for (const field of fieldsConfig) {
+      if (field.onSaveProcess && field.model) {
+        const evaluator = evaluate(field.onSaveProcess)
+        savedRecord[field.model] = evaluator({
+          config: field,
+          value: record[field.model],
+        })
+      }
+    }
 
-  updateRecordField(fieldName: string, value: unknown) {
-    this.record$
-      .pipe(
-        take(1),
-        map((record) => ({ ...record, [fieldName]: value }))
+    // TODO: use the catalog repository instead
+    return this.http
+      .put(
+        `${this.apiUrl}/records?metadataType=METADATA&uuidProcessing=OVERWRITE&transformWith=_none_&publishToAll=on`,
+        toXml(savedRecord),
+        {
+          headers: {
+            'Content-Type': 'application/xml',
+          },
+          withCredentials: true,
+        }
       )
-      .subscribe((record) => this.record$.next(record))
+      .pipe(map(() => savedRecord))
   }
 }

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

@@ -17,3 +17,4 @@ 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/map-container/map-container.component'
+export * from './lib/geocoding/geocoding.component'

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

@@ -1 +1,2 @@
 export * from './map-options'
+export * from './projections'

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

@@ -23,6 +23,8 @@ import { UiInputsModule } from '../../../../../libs/ui/inputs/src'
 import { AddLayerFromWmsComponent } from './add-layer-from-wms/add-layer-from-wms.component'
 import { AddLayerFromFileComponent } from './add-layer-from-file/add-layer-from-file.component'
 import { AddLayerFromWfsComponent } from './add-layer-from-wfs/add-layer-from-wfs.component'
+import { GeocodingComponent } from './geocoding/geocoding.component'
+import { GEOCODING_PROVIDER, GeocodingProvider } from './geocoding.service'
 
 @NgModule({
   declarations: [
@@ -35,6 +37,7 @@ import { AddLayerFromWfsComponent } from './add-layer-from-wfs/add-layer-from-wf
     AddLayerFromWmsComponent,
     AddLayerFromFileComponent,
     AddLayerFromWfsComponent,
+    GeocodingComponent,
   ],
   exports: [
     MapContextComponent,
@@ -42,6 +45,7 @@ import { AddLayerFromWfsComponent } from './add-layer-from-wfs/add-layer-from-wf
     LayersPanelComponent,
     AddLayerFromCatalogComponent,
     MapContainerComponent,
+    GeocodingComponent,
   ],
   imports: [
     CommonModule,
@@ -62,6 +66,10 @@ import { AddLayerFromWfsComponent } from './add-layer-from-wfs/add-layer-from-wf
       useValue: defaultMapOptions,
     },
     MapFacade,
+    {
+      provide: GEOCODING_PROVIDER,
+      useValue: ['geonames', { maxRows: 5 }] as GeocodingProvider,
+    },
   ],
 })
 export class FeatureMapModule {}

package/src/libs/feature/map/src/lib/geocoding/geocoding.component.html

@@ -0,0 +1,39 @@
+<gn-ui-search-input
+  [(value)]="searchText"
+  (valueChange)="onSearchChange($event)"
+  (keyup.enter)="onEnterPress()"
+  [placeholder]="'map.geocoding.placeholder' | translate"
+>
+</gn-ui-search-input>
+<ul
+  class="bg-gray-50 border border-gray-200 w-full mt-2 shadow-sm rounded-lg"
+  *ngIf="results && results.length"
+>
+  <li
+    *ngFor="let result of results"
+    (click)="zoomToLocation(result)"
+    class="flex items-center pl-8 pr-4 py-2 border-b border-gray-200 relative cursor-pointer hover:bg-blue-100 hover:text-gray-800 transition duration-300 ease-in-out"
+  >
+    <svg
+      class="stroke-current text-blue-500 absolute w-5 h-5 left-3 top-3"
+      xmlns="http://www.w3.org/2000/svg"
+      fill="none"
+      viewBox="0 0 24 24"
+      stroke="currentColor"
+    >
+      <path
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        stroke-width="2"
+        d="M17.657 16.657L13.414 20.9a1.998 1.998 0 01-2.827 0l-4.244-4.243a8 8 0 1111.314 0z"
+      />
+      <path
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        stroke-width="2"
+        d="M15 11a3 3 0 11-6 0 3 3 0 016 0z"
+      />
+    </svg>
+    <span class="font-sans font-semibold ml-4">{{ result.label }}</span>
+  </li>
+</ul>

package/src/libs/feature/map/src/lib/geocoding/geocoding.component.ts

@@ -0,0 +1,99 @@
+import { Component, OnDestroy } from '@angular/core'
+import { catchError, from, Subject, takeUntil } from 'rxjs'
+import { debounceTime, switchMap } from 'rxjs/operators'
+import { MapManagerService } from '../manager/map-manager.service'
+import { fromLonLat } from 'ol/proj'
+import { Polygon } from 'ol/geom'
+import { GeocodingService } from '../geocoding.service'
+
+@Component({
+  selector: 'gn-ui-geocoding',
+  templateUrl: './geocoding.component.html',
+  styleUrls: ['./geocoding.component.css'],
+})
+export class GeocodingComponent implements OnDestroy {
+  searchText = ''
+  results: any[] = []
+  searchTextChanged = new Subject<string>()
+  destroy$ = new Subject<void>()
+  errorMessage: string | null = null
+
+  constructor(
+    private mapManager: MapManagerService,
+    private geocodingService: GeocodingService
+  ) {
+    this.searchTextChanged
+      .pipe(
+        debounceTime(300),
+        switchMap((searchText) => {
+          return from(this.geocodingService.query(searchText)).pipe(
+            catchError((error) => {
+              this.errorMessage =
+                'An error occurred while searching. Please try again.'
+              console.error(error)
+              return []
+            })
+          )
+        }),
+        takeUntil(this.destroy$)
+      )
+      .subscribe((results) => {
+        this.results = results
+      })
+  }
+
+  ngOnDestroy() {
+    this.destroy$.next()
+    this.destroy$.complete()
+  }
+
+  onSearchChange(searchText: string) {
+    if (!searchText) {
+      this.clearSearch()
+      return
+    } else {
+      this.searchTextChanged.next(searchText)
+    }
+  }
+
+  clearSearch() {
+    this.searchText = ''
+    this.results = []
+    this.errorMessage = null
+  }
+
+  zoomToLocation(result: any) {
+    const map = this.mapManager.map
+    const view = map.getView()
+    const geometry = result.geom
+
+    if (geometry.type === 'Point') {
+      this.zoomToPoint(geometry.coordinates, view)
+    } else if (geometry.type === 'Polygon') {
+      this.zoomToPolygon(geometry.coordinates, view)
+    } else {
+      console.error(`Unsupported geometry type: ${geometry.type}`)
+    }
+  }
+
+  zoomToPoint(pointCoords: [number, number], view: any) {
+    const transformedCoords = fromLonLat(pointCoords)
+    view.setCenter(transformedCoords)
+    view.setZoom(12)
+  }
+
+  zoomToPolygon(polygonCoords: [[number, number][]], view: any) {
+    const transformedCoords = polygonCoords[0].map((coord) => fromLonLat(coord))
+    const polygon = new Polygon([transformedCoords])
+    view.fit(polygon, {
+      duration: 100,
+      maxZoom: 12,
+    })
+  }
+
+  onEnterPress() {
+    if (this.results && this.results.length > 0) {
+      this.zoomToLocation(this.results[0])
+    }
+  }
+}

package/src/libs/feature/map/src/lib/geocoding.service.ts

@@ -0,0 +1,59 @@
+import { Injectable, Inject, InjectionToken } from '@angular/core'
+import {
+  queryGeoadmin,
+  GeoadminOptions,
+  GeocodingResult,
+  queryGeonames,
+  GeonamesOptions,
+  DataGouvFrOptions,
+  queryDataGouvFr,
+} from '@geospatial-sdk/geocoding'
+import { from, Observable, throwError } from 'rxjs'
+import { catchError } from 'rxjs/operators'
+
+type GeoadminGeocodingProvider = ['geoadmin', GeoadminOptions]
+type GeonamesGeocodingProvider = ['geonames', GeonamesOptions]
+type DataGouvFrGeocodingProvider = ['data-gouv-fr', DataGouvFrOptions]
+export type GeocodingProvider =
+  | GeoadminGeocodingProvider
+  | GeonamesGeocodingProvider
+  | DataGouvFrGeocodingProvider
+
+export const GEOCODING_PROVIDER = new InjectionToken<GeocodingProvider>(
+  'geocoding-provider'
+)
+
+@Injectable({
+  providedIn: 'root',
+})
+export class GeocodingService {
+  constructor(
+    @Inject(GEOCODING_PROVIDER) private provider: GeocodingProvider
+  ) {}
+
+  query(text: string): Observable<GeocodingResult[]> {
+    let queryObservable: Observable<GeocodingResult[]>
+    switch (this.provider[0]) {
+      case 'geoadmin':
+        queryObservable = from(
+          queryGeoadmin(text, this.provider[1] as GeoadminOptions)
+        )
+        break
+      case 'geonames':
+        queryObservable = from(
+          queryGeonames(text, this.provider[1] as GeonamesOptions)
+        )
+        break
+      case 'data-gouv-fr':
+        queryObservable = from(
+          queryDataGouvFr(text, this.provider[1] as DataGouvFrOptions)
+        )
+        break
+      default:
+        return throwError(
+          () => new Error(`Unsupported geocoding provider: ${this.provider[0]}`)
+        )
+    }
+    return queryObservable.pipe(catchError((error) => throwError(error)))
+  }
+}

package/src/libs/feature/map/src/lib/map-context/map-context.service.ts

@@ -58,6 +58,8 @@ export class MapContextService {
   ): Map {
     if (mapConfig) {
       mapContext = this.mergeMapConfigWithContext(mapContext, mapConfig)
+    } else {
+      mapContext.layers = this.addDefaultBaselayerContext(mapContext.layers)
     }
     if (
       !mapContext.view?.extent &&
@@ -179,6 +181,14 @@ export class MapContextService {
     return view
   }
 
+  addDefaultBaselayerContext(
+    layers: MapContextLayerModel[]
+  ): MapContextLayerModel[] {
+    return layers.includes(DEFAULT_BASELAYER_CONTEXT)
+      ? layers
+      : [DEFAULT_BASELAYER_CONTEXT, ...layers]
+  }
+
   mergeMapConfigWithContext(
     mapContext: MapContextModel,
     mapConfig: MapConfig

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

@@ -1,3 +1 @@
 export * from './map-utils.service'
-export * from './map-utils-wms.service'
-export * from './projections'