geonetwork-ui 2.3.0-dev.3d65a13b → 2.3.0-dev.3e7f46f3

package/src/libs/feature/map/src/lib/add-layer-from-ogc-api/add-layer-from-ogc-api.component.ts

@@ -14,7 +14,7 @@ import {
   MapContextLayerTypeEnum,
 } from '../map-context/map-context.model'
 import { TranslateModule } from '@ngx-translate/core'
-import { UiInputsModule } from '../../../../../../libs/ui/inputs/src'
+import { DropdownChoice, UiInputsModule } from '../../../../../../libs/ui/inputs/src'
 import { CommonModule } from '@angular/common'
 import { MapLayer } from '../+state/map.models'
 
@@ -30,18 +30,16 @@ export class AddLayerFromOgcApiComponent implements OnInit {
   @Output() layerAdded = new EventEmitter<MapLayer>()
 
   urlChange = new Subject<string>()
-  layerUrl = ''
   loading = false
-  layers: string[] = []
-  ogcEndpoint: OgcApiEndpoint = null
+  layers: any[] = []
   errorMessage: string | null = null
+  selectedLayerTypes: { [key: string]: DropdownChoice['value'] } = {}
 
   constructor(private changeDetectorRef: ChangeDetectorRef) {}
 
   ngOnInit() {
     this.urlChange.pipe(debounceTime(700)).subscribe(() => {
       this.loadLayers()
-      this.changeDetectorRef.detectChanges() // manually trigger change detection
     })
   }
 
@@ -49,14 +47,13 @@ export class AddLayerFromOgcApiComponent implements OnInit {
     this.errorMessage = null
     try {
       this.loading = true
-      if (this.ogcUrl.trim() === '') {
+      if (!this.ogcUrl.trim()) {
         this.layers = []
         return
       }
-      this.ogcEndpoint = await new OgcApiEndpoint(this.ogcUrl)
-
-      // Currently only supports feature collections
-      this.layers = await this.ogcEndpoint.featureCollections
+      const ogcEndpoint = await new OgcApiEndpoint(this.ogcUrl)
+      this.layers = await ogcEndpoint.allCollections
+      this.setDefaultLayerTypes()
     } catch (error) {
       const err = error as Error
       this.layers = []
@@ -67,14 +64,72 @@ export class AddLayerFromOgcApiComponent implements OnInit {
     }
   }
 
-  async addLayer(layer: string) {
-    this.layerUrl = await this.ogcEndpoint.getCollectionItemsUrl(layer)
+  setDefaultLayerTypes() {
+    this.layers.forEach((layer) => {
+      const choices = this.getLayerChoices(layer)
+      if (choices.length > 0) {
+        this.selectedLayerTypes[layer.name] = choices[0].value
+      }
+    })
+  }
 
-    const layerToAdd: MapContextLayerModel = {
-      name: layer,
-      url: this.layerUrl,
-      type: MapContextLayerTypeEnum.OGCAPI,
+  getLayerChoices(layer: any) {
+    const choices = []
+    if (layer.hasRecords) {
+      choices.push({ label: 'Records', value: 'record' })
+    }
+    if (layer.hasFeatures) {
+      choices.push({ label: 'Features', value: 'features' })
+    }
+    if (layer.hasVectorTiles) {
+      choices.push({ label: 'Vector Tiles', value: 'vectorTiles' })
+    }
+    if (layer.hasMapTiles) {
+      choices.push({ label: 'Map Tiles', value: 'mapTiles' })
+    }
+    return choices
+  }
+
+  shouldDisplayLayer(layer: any) {
+    return (
+      layer.hasRecords ||
+      layer.hasFeatures ||
+      layer.hasVectorTiles ||
+      layer.hasMapTiles
+    )
+  }
+
+  onLayerTypeSelect(layerName: string, selectedType: any) {
+    this.selectedLayerTypes[layerName] = selectedType
+      ? selectedType
+      : this.getLayerChoices(layerName)[0]?.value
+  }
+
+  async addLayer(layer: string, layerType: any) {
+    try {
+      const ogcEndpoint = await new OgcApiEndpoint(this.ogcUrl)
+      let layerUrl: string
+
+      if (layerType === 'vectorTiles') {
+        layerUrl = await ogcEndpoint.getVectorTilesetUrl(layer)
+      } else if (layerType === 'mapTiles') {
+        layerUrl = await ogcEndpoint.getMapTilesetUrl(layer)
+      } else {
+        layerUrl = await ogcEndpoint.getCollectionItemsUrl(layer, {
+          outputFormat: 'json',
+        })
+      }
+
+      const layerToAdd: MapContextLayerModel = {
+        name: layer,
+        url: layerUrl,
+        type: MapContextLayerTypeEnum.OGCAPI,
+        layerType: layerType,
+      }
+      this.layerAdded.emit({ ...layerToAdd, title: layer })
+    } catch (error) {
+      const err = error as Error
+      console.error('Error adding layer:', err.message)
     }
-    this.layerAdded.emit({ ...layerToAdd, title: layer })
   }
 }

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

@@ -20,29 +20,35 @@ export interface MapContextLayerWmsModel {
   type: 'wms'
   url: string
   name: string
+  attributions?: string
 }
 
 export interface MapContextLayerWmtsModel {
   type: 'wmts'
   url: string
   name: string
+  attributions?: string
 }
 
 interface MapContextLayerWfsModel {
   type: 'wfs'
   url: string
   name: string
+  attributions?: string
 }
 
 export interface MapContextLayerOgcapiModel {
   type: 'ogcapi'
   url: string
   name: string
+  layerType: 'feature' | 'vectorTiles' | 'mapTiles' | 'record'
+  attributions?: string
 }
 
 interface LayerXyzModel {
   type: 'xyz'
   name?: string
+  attributions?: string
 }
 interface LayerXyzModelWithUrl extends LayerXyzModel {
   url: string
@@ -58,6 +64,7 @@ export type MapContextLayerXyzModel =
 
 interface LayerGeojson {
   type: 'geojson'
+  attributions?: string
 }
 interface LayerGeojsonWithUrl extends LayerGeojson {
   url: string

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

@@ -25,6 +25,12 @@ import WMTS from 'ol/source/WMTS'
 import { Geometry } from 'ol/geom'
 import Feature from 'ol/Feature'
 import { WfsEndpoint, WmtsEndpoint } from '@camptocamp/ogc-client'
+import OGCVectorTile from 'ol/source/OGCVectorTile.js'
+import { MVT } from 'ol/format'
+import VectorTileLayer from 'ol/layer/VectorTile'
+import OGCMapTile from 'ol/source/OGCMapTile.js'
+import ImageLayer from 'ol/layer/Image'
+import ImageWMS from 'ol/source/ImageWMS'
 
 export const DEFAULT_BASELAYER_CONTEXT: MapContextLayerXyzModel = {
   type: MapContextLayerTypeEnum.XYZ,
@@ -33,6 +39,7 @@ export const DEFAULT_BASELAYER_CONTEXT: MapContextLayerXyzModel = {
     `https://b.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}.png`,
     `https://c.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}.png`,
   ],
+  attributions: `<span>© <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, © <a href="https://carto.com/">Carto</a></span>`,
 }
 
 export const DEFAULT_VIEW: MapContextViewModel = {
@@ -69,38 +76,69 @@ export class MapContextService {
     }
     map.setView(this.createView(mapContext.view, map))
     map.getLayers().clear()
-    mapContext.layers.forEach((layer) => map.addLayer(this.createLayer(layer)))
+    mapContext.layers.forEach((layer) =>
+      map.addLayer(this.createLayer(layer, mapConfig))
+    )
     return map
   }
 
-  createLayer(layerModel: MapContextLayerModel): Layer {
+  createLayer(layerModel: MapContextLayerModel, mapConfig?: MapConfig): Layer {
     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,
-        })
-
+        if (layerModel.layerType === 'vectorTiles') {
+          return new VectorTileLayer({
+            source: new OGCVectorTile({
+              url: layerModel.url,
+              format: new MVT(),
+              attributions: layerModel.attributions,
+            }),
+          })
+        } else if (layerModel.layerType === 'mapTiles') {
+          return new TileLayer({
+            source: new OGCMapTile({
+              url: layerModel.url,
+              attributions: layerModel.attributions,
+            }),
+          })
+        } else {
+          return new VectorLayer({
+            source: new VectorSource({
+              format: new GeoJSON(),
+              url: layerModel.url,
+              attributions: layerModel.attributions,
+            }),
+            style,
+          })
+        }
       case MapContextLayerTypeEnum.XYZ:
         return new TileLayer({
           source: new XYZ({
             url: 'url' in layerModel ? layerModel.url : undefined,
             urls: 'urls' in layerModel ? layerModel.urls : undefined,
+            attributions: layerModel.attributions,
           }),
         })
       case MapContextLayerTypeEnum.WMS:
-        return new TileLayer({
-          source: new TileWMS({
-            url: layerModel.url,
-            params: { LAYERS: layerModel.name },
-            gutter: 20,
-          }),
-        })
+        if (mapConfig?.DO_NOT_TILE_WMS) {
+          return new ImageLayer({
+            source: new ImageWMS({
+              url: layerModel.url,
+              params: { LAYERS: layerModel.name },
+              attributions: layerModel.attributions,
+            }),
+          })
+        } else {
+          return new TileLayer({
+            source: new TileWMS({
+              url: layerModel.url,
+              params: { LAYERS: layerModel.name, TILED: true },
+              attributions: layerModel.attributions,
+            }),
+          })
+        }
+
       case MapContextLayerTypeEnum.WMTS: {
         // TODO: isolate this in utils service
         const olLayer = new TileLayer({})
@@ -123,6 +161,7 @@ export class MapContextService {
               tileGrid,
               projection: matrixSet.crs,
               dimensions,
+              attributions: layerModel.attributions,
             })
           )
         })
@@ -148,6 +187,7 @@ export class MapContextService {
                 })
               },
               strategy: bboxStrategy,
+              attributions: layerModel.attributions,
             })
           )
         })

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

@@ -26,6 +26,7 @@ import {
   MapContextLayerWmsModel,
 } from '../map-context/map-context.model'
 import Collection from 'ol/Collection'
+import { defaults as defaultControls } from 'ol/control.js'
 import MapBrowserEvent from 'ol/MapBrowserEvent'
 import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
 import { ProxyService } from '../../../../../../libs/util/shared/src'
@@ -47,7 +48,10 @@ export class MapUtilsService {
 
   createEmptyMap(): Map {
     return new Map({
-      controls: [],
+      controls: defaultControls({
+        attribution: true,
+        attributionOptions: { collapsible: false },
+      }),
       pixelRatio: 1,
     })
   }
@@ -213,7 +217,7 @@ export class MapUtilsService {
   }
 
   getRecordExtent(record: Partial<CatalogRecord>): Extent {
-    if (!('spatialExtents' in record)) {
+    if (!('spatialExtents' in record) || record.spatialExtents.length === 0) {
       return null
     }
     // transform an array of geojson geometries into a bbox

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

@@ -15,7 +15,7 @@ import {
   MapUtilsService,
 } from '../../../../../../libs/feature/map/src'
 import { getOptionalMapConfig, MapConfig } from '../../../../../../libs/util/app-config/src'
-import { getLinkLabel, ProxyService } from '../../../../../../libs/util/shared/src'
+import { getLinkLabel } from '../../../../../../libs/util/shared/src'
 import Feature from 'ol/Feature'
 import { Geometry } from 'ol/geom'
 import { StyleLike } from 'ol/style/Style'
@@ -23,10 +23,8 @@ import {
   BehaviorSubject,
   combineLatest,
   from,
-  lastValueFrom,
   Observable,
   of,
-  startWith,
   Subscription,
   throwError,
   withLatestFrom,
@@ -57,9 +55,11 @@ export class MapViewComponent implements OnInit, OnDestroy {
 
   compatibleMapLinks$ = combineLatest([
     this.mdViewFacade.mapApiLinks$,
-    this.mdViewFacade.geoDataLinks$,
+    this.mdViewFacade.geoDataLinksWithGeometry$,
   ]).pipe(
-    map(([mapApiLinks, geoDataLinks]) => [...mapApiLinks, ...geoDataLinks])
+    map(([mapApiLinks, geoDataLinksWithGeometry]) => {
+      return [...mapApiLinks, ...geoDataLinksWithGeometry]
+    })
   )
 
   dropdownChoices$ = this.compatibleMapLinks$.pipe(
@@ -104,8 +104,8 @@ export class MapViewComponent implements OnInit, OnDestroy {
   mapContext$ = this.currentLayers$.pipe(
     switchMap((layers) =>
       from(this.mapUtils.getLayerExtent(layers[0])).pipe(
-        catchError((error) => {
-          console.warn(error) // FIXME: report this to the user somehow
+        catchError(() => {
+          this.error = 'The layer has no extent'
           return of(undefined)
         }),
         map(
@@ -117,7 +117,9 @@ export class MapViewComponent implements OnInit, OnDestroy {
               },
             } as MapContextModel)
         ),
-        tap(() => this.resetSelection())
+        tap((res) => {
+          this.resetSelection()
+        })
       )
     ),
     withLatestFrom(this.mdViewFacade.metadata$),
@@ -196,7 +198,8 @@ export class MapViewComponent implements OnInit, OnDestroy {
     } else if (
       (link.type === 'service' &&
         (link.accessServiceProtocol === 'wfs' ||
-          link.accessServiceProtocol === 'esriRest')) ||
+          link.accessServiceProtocol === 'esriRest' ||
+          link.accessServiceProtocol === 'ogcFeatures')) ||
       link.type === 'download'
     ) {
       return this.dataService.readAsGeoJson(link).pipe(

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 }>()
+)