geonetwork-ui 2.3.0-dev.376e0e90 → 2.3.0-dev.3efe236f

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

@@ -22,9 +22,9 @@ import { LayerConfig, MapConfig } from '../../../../../../libs/util/app-config/s
 import { FeatureCollection } from 'geojson'
 import { fromLonLat } from 'ol/proj'
 import WMTS from 'ol/source/WMTS'
-import { removeSearchParams } from '../../../../../../libs/util/shared/src'
 import { Geometry } from 'ol/geom'
 import Feature from 'ol/Feature'
+import { WfsEndpoint, WmtsEndpoint } from '@camptocamp/ogc-client'
 
 export const DEFAULT_BASELAYER_CONTEXT: MapContextLayerXyzModel = {
   type: MapContextLayerTypeEnum.XYZ,
@@ -77,6 +77,15 @@ export class MapContextService {
     const { type } = layerModel
     const style = this.styleService.styles.default
     switch (type) {
+      case MapContextLayerTypeEnum.OGCAPI:
+        return new VectorLayer({
+          source: new VectorSource({
+            format: new GeoJSON(),
+            url: layerModel.url,
+          }),
+          style,
+        })
+
       case MapContextLayerTypeEnum.XYZ:
         return new TileLayer({
           source: new XYZ({
@@ -87,44 +96,63 @@ export class MapContextService {
       case MapContextLayerTypeEnum.WMS:
         return new TileLayer({
           source: new TileWMS({
-            url: removeSearchParams(layerModel.url, ['request', 'service']),
+            url: layerModel.url,
             params: { LAYERS: layerModel.name },
             gutter: 20,
           }),
         })
-      case MapContextLayerTypeEnum.WMTS:
-        return new TileLayer({
-          source: new WMTS(layerModel.options),
+      case MapContextLayerTypeEnum.WMTS: {
+        // TODO: isolate this in utils service
+        const olLayer = new TileLayer({})
+        const endpoint = new WmtsEndpoint(layerModel.url)
+        endpoint.isReady().then(async (endpoint) => {
+          const layerName = endpoint.getSingleLayerName() ?? layerModel.name
+          const layer = endpoint.getLayerByName(layerName)
+          const matrixSet = layer.matrixSets[0]
+          const tileGrid = await endpoint.getOpenLayersTileGrid(layer.name)
+          const resourceUrl = layer.resourceLinks[0]
+          const dimensions = endpoint.getDefaultDimensions(layer.name)
+          olLayer.setSource(
+            new WMTS({
+              layer: layer.name,
+              style: layer.defaultStyle,
+              matrixSet: matrixSet.identifier,
+              format: resourceUrl.format,
+              url: resourceUrl.url,
+              requestEncoding: resourceUrl.encoding,
+              tileGrid,
+              projection: matrixSet.crs,
+              dimensions,
+            })
+          )
         })
-      case MapContextLayerTypeEnum.WFS:
-        return new VectorLayer({
-          source: new VectorSource({
-            format: new GeoJSON(),
-            url: function (extent) {
-              const urlObj = new URL(
-                removeSearchParams(layerModel.url, [
-                  'service',
-                  'version',
-                  'request',
-                ])
-              )
-              urlObj.searchParams.set('service', 'WFS')
-              urlObj.searchParams.set('version', '1.1.0')
-              urlObj.searchParams.set('request', 'GetFeature')
-              urlObj.searchParams.set('outputFormat', 'application/json')
-              urlObj.searchParams.set('typename', layerModel.name)
-              urlObj.searchParams.set('srsname', 'EPSG:3857')
-              urlObj.searchParams.set('bbox', `${extent.join(',')},EPSG:3857`)
-              urlObj.searchParams.set(
-                'maxFeatures',
-                WFS_MAX_FEATURES.toString()
-              )
-              return urlObj.toString()
-            },
-            strategy: bboxStrategy,
-          }),
+        return olLayer
+      }
+      case MapContextLayerTypeEnum.WFS: {
+        const olLayer = new VectorLayer({
           style,
         })
+        new WfsEndpoint(layerModel.url).isReady().then((endpoint) => {
+          const featureType =
+            endpoint.getSingleFeatureTypeName() ?? layerModel.name
+          olLayer.setSource(
+            new VectorSource({
+              format: new GeoJSON(),
+              url: function (extent: [number, number, number, number]) {
+                return endpoint.getFeatureUrl(featureType, {
+                  maxFeatures: WFS_MAX_FEATURES,
+                  asJson: true,
+                  outputCrs: 'EPSG:3857',
+                  extent,
+                  extentCrs: 'EPSG:3857',
+                })
+              },
+              strategy: bboxStrategy,
+            })
+          )
+        })
+        return olLayer
+      }
       case MapContextLayerTypeEnum.GEOJSON: {
         if ('url' in layerModel) {
           return new VectorLayer({

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

@@ -12,7 +12,6 @@ import Source from 'ol/source/Source'
 import ImageWMS from 'ol/source/ImageWMS'
 import TileWMS from 'ol/source/TileWMS'
 import VectorSource from 'ol/source/Vector'
-import { optionsFromCapabilities } from 'ol/source/WMTS'
 import { defaults, DragPan, Interaction, MouseWheelZoom } from 'ol/interaction'
 import {
   mouseOnly,
@@ -20,23 +19,17 @@ import {
   platformModifierKeyOnly,
   primaryAction,
 } from 'ol/events/condition'
-import WMTSCapabilities from 'ol/format/WMTSCapabilities'
-import { from, Observable } from 'rxjs'
+import { Observable } from 'rxjs'
 import { map } from 'rxjs/operators'
 import {
   MapContextLayerModel,
-  MapContextLayerTypeEnum,
   MapContextLayerWmsModel,
-  MapContextLayerWmtsModel,
 } from '../map-context/map-context.model'
 import Collection from 'ol/Collection'
 import MapBrowserEvent from 'ol/MapBrowserEvent'
-import {
-  CatalogRecord,
-  DatasetDistribution,
-} from '../../../../../../libs/common/domain/src/lib/model/record'
+import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
 import { ProxyService } from '../../../../../../libs/util/shared/src'
-import { WmsEndpoint } from '@camptocamp/ogc-client'
+import { WmsEndpoint, WmtsEndpoint } from '@camptocamp/ogc-client'
 import { LONLAT_CRS_CODES } from '../constant/projections'
 import { fromEPSGCode, register } from 'ol/proj/proj4'
 import proj4 from 'proj4/dist/proj4'
@@ -152,11 +145,14 @@ export class MapUtilsService {
     } else if (layer && layer.type === 'wms') {
       latLonExtent = await this.getWmsLayerExtent(layer)
     } else if (layer && layer.type === 'wmts') {
-      if (layer.extent) {
-        latLonExtent = layer.extent
-      } else {
-        return layer.options.tileGrid.getExtent()
-      }
+      // TODO: isolate this in utils service
+      latLonExtent = await new WmtsEndpoint(layer.url)
+        .isReady()
+        .then((endpoint) => {
+          const layerName = endpoint.getSingleLayerName() ?? layer.name
+          const wmtsLayer = endpoint.getLayerByName(layerName)
+          return wmtsLayer.latLonBoundingBox
+        })
     } else {
       return null
     }
@@ -180,59 +176,19 @@ export class MapUtilsService {
       LONLAT_CRS_CODES.includes(crs)
     )
     if (lonLatCRS) {
-      return boundingBoxes[lonLatCRS].map(parseFloat)
+      return boundingBoxes[lonLatCRS]
     } else {
       const availableEPSGCode = Object.keys(boundingBoxes)[0]
       register(proj4)
       const proj = await fromEPSGCode(availableEPSGCode)
-      const bboxWithFiniteNumbers =
-        boundingBoxes[availableEPSGCode].map(parseFloat)
-      return transformExtent(bboxWithFiniteNumbers, proj, 'EPSG:4326')
+      return transformExtent(
+        boundingBoxes[availableEPSGCode],
+        proj,
+        'EPSG:4326'
+      )
     }
   }
 
-  getWmtsLayerFromCapabilities(
-    link: DatasetDistribution
-  ): Observable<MapContextLayerWmtsModel> {
-    const getCapabilitiesUrl = new URL(link.url, window.location.toString())
-    getCapabilitiesUrl.searchParams.set('SERVICE', 'WMTS')
-    getCapabilitiesUrl.searchParams.set('REQUEST', 'GetCapabilities')
-    return from(
-      fetch(getCapabilitiesUrl.toString())
-        .then(async function (response) {
-          if (!response.ok) {
-            throw new Error(`WMTS GetCapabilities HTTP request failed with code ${
-              response.status
-            } and body:
-${await response.text()}`)
-          }
-          return response.text()
-        })
-        .then(function (text) {
-          try {
-            const result = new WMTSCapabilities().read(text)
-            const options = optionsFromCapabilities(result, {
-              layer: link.name,
-              matrixSet: 'EPSG:3857',
-            })
-            const layerCap = result?.Contents?.Layer.find(
-              (layer) => layer.Identifier === link.name
-            )
-            return {
-              options,
-              type: MapContextLayerTypeEnum.WMTS as 'wmts',
-              ...(layerCap?.WGS84BoundingBox
-                ? { extent: layerCap.WGS84BoundingBox }
-                : {}),
-            }
-          } catch (e: any) {
-            throw new Error(`WMTS GetCapabilities parsing failed:
-${e.stack || e.message || e}`)
-          }
-        })
-    )
-  }
-
   prioritizePageScroll(interactions: Collection<Interaction>) {
     interactions.clear()
     interactions.extend(

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

@@ -0,0 +1,3 @@
+export * from './lib/feature-notifications.module'
+export * from './lib/notifications.service'
+export * from './lib/notifications-container/notifications-container.component'

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

@@ -0,0 +1,10 @@
+import { NotificationsService } from './notifications.service'
+import { NgModule } from '@angular/core'
+
+@NgModule({
+  declarations: [],
+  exports: [],
+  imports: [],
+  providers: [NotificationsService],
+})
+export class FeatureNotificationsModule {}

package/src/libs/feature/notifications/src/lib/notification.model.ts

@@ -0,0 +1,6 @@
+export interface NotificationContent {
+  type: 'info' | 'warning' | 'error' | 'success'
+  title: string
+  text: string
+  closeMessage?: string
+}

package/src/libs/feature/notifications/src/lib/notifications-container/notifications-container.component.html

@@ -0,0 +1,17 @@
+<div class="flex flex-col gap-6 p-6 items-start pointer-events-none">
+  <gn-ui-notification
+    *ngFor="
+      let notification of notificationsService.notifications$ | async;
+      trackBy: trackById
+    "
+    class="max-w-full pointer-events-auto"
+    [text]="notification.text"
+    [type]="notification.type"
+    [title]="notification.title"
+    [closeMessage]="notification.closeMessage"
+    (notificationClose)="
+      notificationsService.removeNotificationById(notification.id)
+    "
+    [@enterExit]
+  ></gn-ui-notification>
+</div>

package/src/libs/feature/notifications/src/lib/notifications-container/notifications-container.component.ts

@@ -0,0 +1,44 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core'
+import { CommonModule } from '@angular/common'
+import { NotificationsService } from '../notifications.service'
+import { NotificationComponent } from '../../../../../../libs/ui/elements/src'
+import {
+  animate,
+  keyframes,
+  style,
+  transition,
+  trigger,
+} from '@angular/animations'
+
+@Component({
+  selector: 'gn-ui-notifications-container',
+  standalone: true,
+  imports: [CommonModule, NotificationComponent],
+  templateUrl: './notifications-container.component.html',
+  styleUrls: ['./notifications-container.component.css'],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  animations: [
+    trigger('enterExit', [
+      transition(':enter', [
+        animate(
+          '150ms',
+          keyframes([
+            style({ transform: 'scale(1)', opacity: 0 }),
+            style({ transform: 'scale(1.03)', opacity: 0.5 }),
+            style({ transform: 'scale(1)', opacity: 1 }),
+          ])
+        ),
+      ]),
+      transition(':leave', [
+        animate('200ms', style({ transform: 'translateX(50px)', opacity: 0 })),
+      ]),
+    ]),
+  ],
+})
+export class NotificationsContainerComponent {
+  constructor(protected notificationsService: NotificationsService) {}
+
+  trackById(index: number, notification: { id: number }) {
+    return notification.id
+  }
+}

package/src/libs/feature/notifications/src/lib/notifications.service.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core'
+import { NotificationContent } from './notification.model'
+import { BehaviorSubject } from 'rxjs'
+
+type NotificationWithIdentity = NotificationContent & { id: number }
+
+@Injectable({
+  providedIn: 'root',
+})
+export class NotificationsService {
+  notifications$ = new BehaviorSubject<NotificationWithIdentity[]>([])
+
+  showNotification(content: NotificationContent, timeoutMs?: number) {
+    const id = Math.floor(Math.random() * 1000000)
+    this.notifications$.next([...this.notifications$.value, { ...content, id }])
+    if (typeof timeoutMs === 'undefined') return
+    setTimeout(() => {
+      this.removeNotificationById(id)
+    }, timeoutMs)
+  }
+
+  removeNotificationById(id: number) {
+    this.notifications$.next(
+      this.notifications$.value.filter((n) => n.id !== id)
+    )
+  }
+}

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

@@ -11,7 +11,10 @@ import { MdViewFacade } from './state'
 import { MdViewEffects } from './state/mdview.effects'
 import { MapViewComponent } from './map-view/map-view.component'
 import { DataViewComponent } from './data-view/data-view.component'
-import { MD_VIEW_FEATURE_STATE_KEY, reducer } from './state/mdview.reducer'
+import {
+  METADATA_VIEW_FEATURE_STATE_KEY,
+  reducer,
+} from './state/mdview.reducer'
 import { MatTabsModule } from '@angular/material/tabs'
 import { MatIconModule } from '@angular/material/icon'
 import { UiWidgetsModule } from '../../../../../libs/ui/widgets/src'
@@ -35,7 +38,7 @@ import { DataViewShareComponent } from './data-view-share/data-view-share.compon
   ],
   imports: [
     CommonModule,
-    StoreModule.forFeature(MD_VIEW_FEATURE_STATE_KEY, reducer),
+    StoreModule.forFeature(METADATA_VIEW_FEATURE_STATE_KEY, reducer),
     EffectsModule.forFeature([MdViewEffects]),
     UiLayoutModule,
     FeatureMapModule,

package/src/libs/feature/record/src/lib/map-view/map-view.component.ts

@@ -188,7 +188,11 @@ export class MapViewComponent implements OnInit, OnDestroy {
       link.type === 'service' &&
       link.accessServiceProtocol === 'wmts'
     ) {
-      return this.mapUtils.getWmtsLayerFromCapabilities(link)
+      return of({
+        url: link.url.toString(),
+        type: MapContextLayerTypeEnum.WMTS,
+        name: link.name,
+      })
     } else if (
       (link.type === 'service' &&
         (link.accessServiceProtocol === 'wfs' ||

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

@@ -1,7 +1,13 @@
 import { DatavizConfigurationModel } from '../../../../../../libs/common/domain/src/lib/model/dataviz/dataviz-configuration.model'
 import { createAction, props } from '@ngrx/store'
-import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
+import {
+  CatalogRecord,
+  UserFeedback,
+} from '../../../../../../libs/common/domain/src/lib/model/record'
 
+/*
+  Metadata actions
+ */
 export const loadFullMetadata = createAction(
   '[Metadata view] Load full metadata',
   props<{ uuid: string }>()
@@ -12,24 +18,63 @@ export const setIncompleteMetadata = createAction(
   props<{ incomplete: Partial<CatalogRecord> }>()
 )
 
-export const loadFullSuccess = createAction(
-  '[Metadata view] Load full success',
+export const loadFullMetadataSuccess = createAction(
+  '[Metadata view] Load full metadata success',
   props<{ full: CatalogRecord }>()
 )
 
-export const loadFullFailure = createAction(
-  '[Metadata view] Load full failure',
+export const loadFullMetadataFailure = createAction(
+  '[Metadata view] Load full metadata failure',
   props<{ otherError?: string; notFound?: boolean }>()
 )
 
+export const closeMetadata = createAction('[Metadata view] close')
+
+/*
+  Related actions
+ */
 export const setRelated = createAction(
   '[Metadata view] Set related records',
   props<{ related: CatalogRecord[] }>()
 )
 
+/*
+  ChartConfig actions
+ */
 export const setChartConfig = createAction(
   '[Metadata view] Set chart config',
   props<{ chartConfig: DatavizConfigurationModel }>()
 )
 
-export const close = createAction('[Metadata view] close')
+/*
+  User Feedbacks actions
+ */
+export const addUserFeedback = createAction(
+  '[Metadata view] Add UserFeedback',
+  props<{ userFeedback: UserFeedback }>()
+)
+
+export const addUserFeedbackSuccess = createAction(
+  '[Metadata view] Add UserFeedback Success',
+  props<{ datasetUuid: string }>()
+)
+
+export const addUserFeedbackFailure = createAction(
+  '[Metadata view] Add UserFeedback Failure',
+  props<{ otherError?: string; notFound?: boolean }>()
+)
+
+export const loadUserFeedbacks = createAction(
+  '[Metadata view] Load UserFeedbacks',
+  props<{ datasetUuid: string }>()
+)
+
+export const loadUserFeedbacksSuccess = createAction(
+  '[Metadata view] Load UserFeedbacks Success',
+  props<{ userFeedbacks: UserFeedback[] }>()
+)
+
+export const loadUserFeedbacksFailure = createAction(
+  '[Metadata view] Load UserFeedbacks Failure',
+  props<{ otherError?: string; notFound?: boolean }>()
+)

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

@@ -1,18 +1,23 @@
 import { Injectable } from '@angular/core'
 import { Actions, createEffect, ofType } from '@ngrx/effects'
-import { of } from 'rxjs'
+import { exhaustMap, mergeMap, of } from 'rxjs'
 import { catchError, map, switchMap } from 'rxjs/operators'
 import * as MdViewActions from './mdview.actions'
 import { RecordsRepositoryInterface } from '../../../../../../libs/common/domain/src/lib/repository/records-repository.interface'
+import { PlatformServiceInterface } from '../../../../../../libs/common/domain/src/lib/platform.service.interface'
 
 @Injectable()
 export class MdViewEffects {
   constructor(
     private actions$: Actions,
-    private recordsRepository: RecordsRepositoryInterface
+    private recordsRepository: RecordsRepositoryInterface,
+    private platformServiceInterface: PlatformServiceInterface
   ) {}
 
-  loadFull$ = createEffect(() =>
+  /*
+    Metadata effects
+  */
+  loadFullMetadata$ = createEffect(() =>
     this.actions$.pipe(
       ofType(MdViewActions.loadFullMetadata),
       switchMap(({ uuid }) =>
@@ -20,19 +25,22 @@ export class MdViewEffects {
       ),
       map((record) => {
         if (record === null) {
-          return MdViewActions.loadFullFailure({ notFound: true })
+          return MdViewActions.loadFullMetadataFailure({ notFound: true })
         }
-        return MdViewActions.loadFullSuccess({ full: record })
+        return MdViewActions.loadFullMetadataSuccess({ full: record })
       }),
       catchError((error) =>
-        of(MdViewActions.loadFullFailure({ otherError: error.message }))
+        of(MdViewActions.loadFullMetadataFailure({ otherError: error.message }))
       )
     )
   )
 
+  /*
+    Related effects
+  */
   loadRelatedRecords$ = createEffect(() =>
     this.actions$.pipe(
-      ofType(MdViewActions.loadFullSuccess),
+      ofType(MdViewActions.loadFullMetadataSuccess),
       switchMap(({ full }) => this.recordsRepository.getSimilarRecords(full)),
       map((related) => {
         return MdViewActions.setRelated({ related })
@@ -40,4 +48,71 @@ export class MdViewEffects {
       catchError((error) => of(MdViewActions.setRelated({ related: null })))
     )
   )
+
+  /*
+    UserFeedback effects
+  */
+  loadUserFeedbacks$ = createEffect(() =>
+    this.actions$.pipe(
+      ofType(MdViewActions.loadUserFeedbacks),
+      exhaustMap(({ datasetUuid }) =>
+        this.platformServiceInterface.getUserFeedbacks(datasetUuid).pipe(
+          map((userFeedbacks) =>
+            MdViewActions.loadUserFeedbacksSuccess({ userFeedbacks })
+          ),
+          catchError((error) =>
+            of(
+              MdViewActions.loadUserFeedbacksFailure({
+                otherError: error.message,
+              })
+            )
+          )
+        )
+      )
+    )
+  )
+
+  reloadUserFeedbacks$ = createEffect(() =>
+    this.actions$.pipe(
+      ofType(MdViewActions.addUserFeedbackSuccess),
+      exhaustMap(({ datasetUuid }) =>
+        this.platformServiceInterface.getUserFeedbacks(datasetUuid).pipe(
+          map((userFeedbacks) =>
+            MdViewActions.loadUserFeedbacksSuccess({ userFeedbacks })
+          ),
+          catchError((error) =>
+            of(
+              MdViewActions.loadUserFeedbacksFailure({
+                otherError: error.message,
+              })
+            )
+          )
+        )
+      )
+    )
+  )
+
+  addUserFeedback$ = createEffect(() =>
+    this.actions$.pipe(
+      ofType(MdViewActions.addUserFeedback),
+      mergeMap((action) =>
+        this.platformServiceInterface
+          .postUserFeedbacks(action.userFeedback)
+          .pipe(
+            map(() =>
+              MdViewActions.addUserFeedbackSuccess({
+                datasetUuid: action.userFeedback.metadataUUID,
+              })
+            ),
+            catchError((error) => {
+              return of(
+                MdViewActions.addUserFeedbackFailure({
+                  otherError: error.message,
+                })
+              )
+            })
+          )
+      )
+    )
+  )
 }