geonetwork-ui 2.3.0-dev.f736344f → 2.3.0

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,
@@ -36,6 +34,7 @@ import {
   distinctUntilChanged,
   finalize,
   map,
+  startWith,
   switchMap,
   tap,
 } from 'rxjs/operators'
@@ -57,9 +56,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 +105,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,9 +118,15 @@ export class MapViewComponent implements OnInit, OnDestroy {
               },
             } as MapContextModel)
         ),
-        tap(() => this.resetSelection())
+        tap((res) => {
+          this.resetSelection()
+        })
       )
     ),
+    startWith({
+      layers: [],
+      view: {},
+    } as MapContextModel),
     withLatestFrom(this.mdViewFacade.metadata$),
     map(([context, metadata]) => {
       if (context.view.extent) return context
@@ -188,11 +195,16 @@ 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' ||
-          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 }>()
+)

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

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

@@ -1,11 +1,18 @@
 import { Injectable } from '@angular/core'
 import { select, Store } from '@ngrx/store'
-import { filter, map } from 'rxjs/operators'
+import { defaultIfEmpty, filter, map, mergeMap, scan } from 'rxjs/operators'
 import * as MdViewActions from './mdview.actions'
 import * as MdViewSelectors from './mdview.selectors'
 import { LinkClassifierService, LinkUsage } from '../../../../../../libs/util/shared/src'
 import { DatavizConfigurationModel } from '../../../../../../libs/common/domain/src/lib/model/dataviz/dataviz-configuration.model'
-import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
+import {
+  CatalogRecord,
+  UserFeedback,
+} from '../../../../../../libs/common/domain/src/lib/model/record'
+import { AvatarServiceInterface } from '../../../../../../libs/api/repository/src'
+import { OgcApiRecord } from '@camptocamp/ogc-client'
+import { from, of } from 'rxjs'
+import { DataService } from '../../../../../../libs/feature/dataviz/src'
 
 @Injectable()
 /**
@@ -15,19 +22,32 @@ import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/mode
  * To clear the current record use the `close()` method.
  */
 export class MdViewFacade {
+  constructor(
+    private store: Store,
+    public linkClassifier: LinkClassifierService,
+    private avatarService: AvatarServiceInterface,
+    public dataService: DataService
+  ) {}
+
   isPresent$ = this.store.pipe(
     select(MdViewSelectors.getMetadataUuid),
     map((uuid) => !!uuid)
   )
-  isLoading$ = this.store.pipe(select(MdViewSelectors.getMetadataIsLoading))
+
+  isMetadataLoading$ = this.store.pipe(
+    select(MdViewSelectors.getMetadataIsLoading)
+  )
+
   metadata$ = this.store.pipe(
     select(MdViewSelectors.getMetadata),
     filter((md) => !!md)
   )
+
   isIncomplete$ = this.store.pipe(
     select(MdViewSelectors.getMetadataIsIncomplete),
     filter((incomplete) => incomplete !== null)
   )
+
   error$ = this.store.pipe(select(MdViewSelectors.getMetadataError))
 
   related$ = this.store.pipe(select(MdViewSelectors.getRelated))
@@ -37,11 +57,13 @@ export class MdViewFacade {
   allLinks$ = this.metadata$.pipe(
     map((record) => ('distributions' in record ? record.distributions : []))
   )
+
   apiLinks$ = this.allLinks$.pipe(
     map((links) =>
       links.filter((link) => this.linkClassifier.hasUsage(link, LinkUsage.API))
     )
   )
+
   mapApiLinks$ = this.allLinks$.pipe(
     map((links) =>
       links.filter((link) =>
@@ -49,6 +71,7 @@ export class MdViewFacade {
       )
     )
   )
+
   downloadLinks$ = this.allLinks$.pipe(
     map((links) =>
       links.filter((link) =>
@@ -56,11 +79,13 @@ export class MdViewFacade {
       )
     )
   )
+
   dataLinks$ = this.allLinks$.pipe(
     map((links) =>
       links.filter((link) => this.linkClassifier.hasUsage(link, LinkUsage.DATA))
     )
   )
+
   geoDataLinks$ = this.allLinks$.pipe(
     map((links) =>
       links.filter((link) =>
@@ -68,9 +93,44 @@ export class MdViewFacade {
       )
     )
   )
+
+  geoDataLinksWithGeometry$ = this.allLinks$.pipe(
+    mergeMap((links) => {
+      return from(links)
+    }),
+    mergeMap((link) => {
+      if (this.linkClassifier.hasUsage(link, LinkUsage.GEODATA)) {
+        if (
+          link.type === 'service' &&
+          link.accessServiceProtocol === 'ogcFeatures'
+        ) {
+          return from(this.dataService.getItemsFromOgcApi(link.url.href)).pipe(
+            map((collectionRecords: OgcApiRecord) => {
+              return collectionRecords && collectionRecords.geometry
+                ? link
+                : null
+            }),
+            defaultIfEmpty(null)
+          )
+        } else {
+          return of(link)
+        }
+      } else {
+        return of(null)
+      }
+    }),
+    scan((acc, val) => {
+      if (val !== null && !acc.includes(val)) {
+        acc.push(val)
+      }
+      return acc
+    }, [])
+  )
+
   landingPageLinks$ = this.metadata$.pipe(
     map((record) => ('landingPage' in record ? [record.landingPage] : []))
   )
+
   otherLinks$ = this.allLinks$.pipe(
     map((links) =>
       links.filter((link) =>
@@ -79,10 +139,13 @@ export class MdViewFacade {
     )
   )
 
-  constructor(
-    private store: Store,
-    private linkClassifier: LinkClassifierService
-  ) {}
+  userFeedbacks$ = this.store.pipe(select(MdViewSelectors.getUserFeedbacks))
+  isAllUserFeedbackLoading$ = this.store.pipe(
+    select(MdViewSelectors.getAllUserFeedbacksLoading)
+  )
+  isAddUserFeedbackLoading$ = this.store.pipe(
+    select(MdViewSelectors.getAddUserFeedbacksLoading)
+  )
 
   /**
    * This will show an incomplete record (e.g. from a search result) as a preview
@@ -91,16 +154,30 @@ export class MdViewFacade {
   setIncompleteMetadata(incomplete: CatalogRecord) {
     this.store.dispatch(MdViewActions.setIncompleteMetadata({ incomplete }))
   }
+
   /**
    * This will trigger the load of a full metadata record
    */
   loadFull(uuid: string) {
     this.store.dispatch(MdViewActions.loadFullMetadata({ uuid }))
   }
-  close() {
-    this.store.dispatch(MdViewActions.close())
+
+  closeMetadata() {
+    this.store.dispatch(MdViewActions.closeMetadata())
   }
+
   setChartConfig(chartConfig: DatavizConfigurationModel) {
     this.store.dispatch(MdViewActions.setChartConfig({ chartConfig }))
   }
+
+  /**
+   * UserFeedbacks
+   */
+  addUserFeedback(userFeedback: UserFeedback) {
+    this.store.dispatch(MdViewActions.addUserFeedback({ userFeedback }))
+  }
+
+  loadUserFeedbacks(datasetUuid: string) {
+    this.store.dispatch(MdViewActions.loadUserFeedbacks({ datasetUuid }))
+  }
 }

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

@@ -1,61 +1,116 @@
 import { Action, createReducer, on } from '@ngrx/store'
-import * as MdViewActions from './mdview.actions'
+import * as MetadataViewActions from './mdview.actions'
 import { DatavizConfigurationModel } from '../../../../../../libs/common/domain/src/lib/model/dataviz/dataviz-configuration.model'
-import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/model/record'
+import {
+  CatalogRecord,
+  UserFeedback,
+} from '../../../../../../libs/common/domain/src/lib/model/record'
 
-export const MD_VIEW_FEATURE_STATE_KEY = 'mdView'
+export const METADATA_VIEW_FEATURE_STATE_KEY = 'metadataView'
 
-export interface MdViewState {
+export interface MetadataViewState {
   loadingFull: boolean
   error: { notFound?: boolean; otherError?: string } | null
   metadata?: Partial<CatalogRecord>
   related?: CatalogRecord[]
+  userFeedbacks?: UserFeedback[]
+  allUserFeedbacksLoading: boolean
+  addUserFeedbackLoading: boolean
   chartConfig?: DatavizConfigurationModel
 }
 
-export const initialMdviewState: MdViewState = {
+export const initialMetadataViewState: MetadataViewState = {
   error: null,
   loadingFull: false,
+  allUserFeedbacksLoading: false,
+  addUserFeedbackLoading: false,
 }
 
-const mdViewReducer = createReducer(
-  initialMdviewState,
-  on(MdViewActions.loadFullMetadata, (state) => ({
+const metadataViewReducer = createReducer(
+  initialMetadataViewState,
+
+  /*
+    Metadata reducers
+  */
+  on(MetadataViewActions.loadFullMetadata, (state) => ({
     ...state,
     error: null,
     loadingFull: true,
   })),
-  on(MdViewActions.setIncompleteMetadata, (state, { incomplete }) => ({
+  on(MetadataViewActions.setIncompleteMetadata, (state, { incomplete }) => ({
     ...state,
     error: null,
     metadata: incomplete,
   })),
-  on(MdViewActions.loadFullSuccess, (state, { full }) => ({
+  on(MetadataViewActions.loadFullMetadataSuccess, (state, { full }) => ({
     ...state,
     error: null,
     metadata: full,
     loadingFull: false,
   })),
-  on(MdViewActions.loadFullFailure, (state, { otherError, notFound }) => ({
-    ...state,
-    error: { otherError, notFound },
-    loadingFull: false,
-  })),
-  on(MdViewActions.setRelated, (state, { related }) => ({
+  on(
+    MetadataViewActions.loadFullMetadataFailure,
+    (state, { otherError, notFound }) => ({
+      ...state,
+      error: { otherError, notFound },
+      loadingFull: false,
+    })
+  ),
+  on(MetadataViewActions.closeMetadata, (state) => {
+    const { metadata, related, userFeedbacks, ...stateWithoutMetadata } = state
+    return stateWithoutMetadata
+  }),
+
+  /*
+    Related reducers
+  */
+  on(MetadataViewActions.setRelated, (state, { related }) => ({
     ...state,
     related,
   })),
-  on(MdViewActions.setChartConfig, (state, { chartConfig }) => ({
+
+  /*
+    ChartConfig reducers
+  */
+  on(MetadataViewActions.setChartConfig, (state, { chartConfig }) => ({
     ...state,
     chartConfig,
   })),
-  on(MdViewActions.close, (state) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { metadata, related, ...stateWithoutMd } = state
-    return stateWithoutMd
-  })
+
+  /*
+    UserFeedbacks reducers
+  */
+  on(MetadataViewActions.loadUserFeedbacks, (state) => ({
+    ...state,
+    allUserFeedbacksLoading: true,
+  })),
+  on(MetadataViewActions.addUserFeedback, (state) => ({
+    ...state,
+    addUserFeedbackLoading: true,
+  })),
+  on(
+    MetadataViewActions.loadUserFeedbacksSuccess,
+    (state, { userFeedbacks }) => ({
+      ...state,
+      userFeedbacks: userFeedbacks,
+      addUserFeedbackLoading: false,
+      allUserFeedbacksLoading: false,
+    })
+  ),
+  on(
+    MetadataViewActions.loadUserFeedbacksFailure,
+    (state, { otherError, notFound }) => ({
+      ...state,
+      error: { otherError, notFound },
+      addUserFeedbackLoading: false,
+      allUserFeedbacksLoading: false,
+    })
+  )
 )
 
-export function reducer(state: MdViewState | undefined, action: Action) {
-  return mdViewReducer(state, action)
+export function reducer(
+  metadataViewState: MetadataViewState | undefined,
+  action: Action
+) {
+  return metadataViewReducer(metadataViewState, action)
 }