geonetwork-ui 2.1.0-initial

package/src/libs/feature/router/src/lib/default/router.service.ts

@@ -0,0 +1,39 @@
+import { Inject, Injectable } from '@angular/core'
+import { ROUTER_ROUTE_DATASET, ROUTER_ROUTE_SEARCH } from '.'
+import { Router, Routes } from '@angular/router'
+import { ROUTER_CONFIG, RouterConfigModel } from './router.config'
+
+@Injectable({
+  providedIn: 'root',
+})
+export class RouterService {
+  constructor(
+    @Inject(ROUTER_CONFIG) private routerConfig: RouterConfigModel,
+    private router: Router
+  ) {}
+
+  initRoutes() {
+    this.router.resetConfig(this.buildRoutes())
+  }
+
+  buildRoutes(): Routes {
+    return [
+      { path: '', redirectTo: `/${ROUTER_ROUTE_SEARCH}`, pathMatch: 'full' },
+      {
+        path: ROUTER_ROUTE_SEARCH,
+        data: {
+          shouldDetach: true,
+        },
+        component: this.routerConfig.searchRouteComponent,
+      },
+      {
+        path: `${ROUTER_ROUTE_DATASET}/:metadataUuid`,
+        component: this.routerConfig.recordRouteComponent,
+      },
+    ]
+  }
+
+  getSearchRoute(): string {
+    return ROUTER_ROUTE_SEARCH
+  }
+}

package/src/libs/feature/router/src/lib/default/services/router-search.service.ts

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core'
+import {
+  FieldsService,
+  SearchFacade,
+  SearchServiceI,
+} from '../../../../../../../libs/feature/search/src'
+import { FieldFilters, SortByField } from '../../../../../../../libs/common/domain/src/lib/search'
+import { ROUTE_PARAMS, SearchRouteParams } from '../constants'
+import { RouterFacade } from '../state/router.facade'
+import { firstValueFrom } from 'rxjs'
+import { sortByToString } from '../../../../../../../libs/util/shared/src'
+
+@Injectable()
+export class RouterSearchService implements SearchServiceI {
+  constructor(
+    private searchFacade: SearchFacade,
+    private facade: RouterFacade,
+    private fieldsService: FieldsService
+  ) {}
+
+  setSortAndFilters(filters: FieldFilters, sortBy: SortByField) {
+    this.fieldsService
+      .readFieldValuesFromFilters(filters)
+      .subscribe((values) => {
+        this.facade.setSearch({
+          ...values,
+          [ROUTE_PARAMS.SORT]: sortByToString(sortBy),
+        })
+      })
+  }
+
+  async setFilters(newFilters: FieldFilters) {
+    const sortBy = await firstValueFrom(this.searchFacade.sortBy$)
+    const fieldSearchParams = await firstValueFrom(
+      this.fieldsService.readFieldValuesFromFilters(newFilters)
+    )
+    this.facade.setSearch({
+      ...fieldSearchParams,
+      [ROUTE_PARAMS.SORT]: sortBy ? sortByToString(sortBy) : undefined,
+    })
+  }
+
+  async updateFilters(newFilters: FieldFilters) {
+    const currentFilters = await firstValueFrom(
+      this.searchFacade.searchFilters$
+    )
+    const updatedFilters = { ...currentFilters, ...newFilters }
+    const newParams = await firstValueFrom(
+      this.fieldsService.readFieldValuesFromFilters(updatedFilters)
+    )
+    this.facade.updateSearch(newParams as SearchRouteParams)
+  }
+
+  setSortBy(sortBy: SortByField) {
+    this.facade.updateSearch({
+      [ROUTE_PARAMS.SORT]: sortByToString(sortBy),
+    })
+  }
+
+  setPage(page: number): void {
+    this.facade.updateSearch({
+      [ROUTE_PARAMS.PAGE]: page,
+    })
+  }
+}

package/src/libs/feature/router/src/lib/default/state/router.actions.ts

@@ -0,0 +1,15 @@
+import { QueryParamsHandling } from '@angular/router'
+import { createAction, props } from '@ngrx/store'
+
+export interface RouterGoActionPayload {
+  path: string
+  query?: Record<string, unknown>
+  queryParamsHandling?: QueryParamsHandling
+}
+
+export const goAction = createAction(
+  '[Router] Go',
+  props<RouterGoActionPayload>()
+)
+export const backAction = createAction('[Router] Back')
+export const forwardAction = createAction('[Router] Forward')

package/src/libs/feature/router/src/lib/default/state/router.effects.ts

@@ -0,0 +1,163 @@
+import { Location } from '@angular/common'
+import { Inject, Injectable } from '@angular/core'
+import { ActivatedRouteSnapshot, Router } from '@angular/router'
+import { MdViewActions } from '../../../../../../../libs/feature/record/src'
+import {
+  FieldsService,
+  Paginate,
+  SearchActions,
+  SetFilters,
+  SetSortBy,
+} from '../../../../../../../libs/feature/search/src'
+import { FieldFilters, SortByEnum } from '../../../../../../../libs/common/domain/src/lib/search'
+import { Actions, createEffect, ofType } from '@ngrx/effects'
+import { navigation } from '@ngrx/router-store/data-persistence'
+import { of, pairwise, startWith, withLatestFrom } from 'rxjs'
+import { map, mergeMap, tap } from 'rxjs/operators'
+import * as RouterActions from './router.actions'
+import { RouterFacade } from './router.facade'
+import { ROUTE_PARAMS } from '../constants'
+import { sortByFromString } from '../../../../../../../libs/util/shared/src'
+import { ROUTER_CONFIG, RouterConfigModel } from '../router.config'
+
+@Injectable()
+export class RouterEffects {
+  constructor(
+    private _actions$: Actions,
+    private _router: Router,
+    private _location: Location,
+    private facade: RouterFacade,
+    @Inject(ROUTER_CONFIG) private routerConfig: RouterConfigModel,
+    private fieldsService: FieldsService
+  ) {}
+
+  navigate$ = createEffect(
+    () =>
+      this._actions$.pipe(
+        ofType(RouterActions.goAction),
+        tap(({ path, query: queryParams, queryParamsHandling }) => {
+          this._router.navigate([path], {
+            queryParams,
+            queryParamsHandling,
+          })
+        })
+      ),
+    { dispatch: false }
+  )
+
+  syncSearchState$ = createEffect(() =>
+    this.facade.searchParams$.pipe(
+      mergeMap((searchParams: Record<string, string>) =>
+        this.fieldsService
+          .buildFiltersFromFieldValues(searchParams)
+          .pipe(map((filters) => [searchParams, filters] as const))
+      ),
+      startWith([null, {}] as [Record<string, string>, FieldFilters]),
+      pairwise(),
+      map(([[oldParams, oldFilters], [newParams, newFilters]]) => {
+        let sortBy =
+          ROUTE_PARAMS.SORT in newParams
+            ? sortByFromString(newParams[ROUTE_PARAMS.SORT])
+            : SortByEnum.RELEVANCY
+        let pageNumber =
+          ROUTE_PARAMS.PAGE in newParams
+            ? parseInt(newParams[ROUTE_PARAMS.PAGE])
+            : 1
+        if (oldParams !== null) {
+          const oldSort =
+            ROUTE_PARAMS.SORT in oldParams
+              ? sortByFromString(oldParams[ROUTE_PARAMS.SORT])
+              : SortByEnum.RELEVANCY
+          if (JSON.stringify(sortBy) === JSON.stringify(oldSort)) {
+            sortBy = null
+          }
+          const oldPage =
+            ROUTE_PARAMS.PAGE in oldParams
+              ? parseInt(oldParams[ROUTE_PARAMS.PAGE])
+              : 1
+          if (pageNumber === oldPage) {
+            pageNumber = null
+          }
+        }
+        const filters =
+          JSON.stringify(oldFilters) === JSON.stringify(newFilters)
+            ? null
+            : newFilters
+        return [sortBy, pageNumber, filters] as const
+      }),
+      mergeMap(([sortBy, pageNumber, filters]) => {
+        const actions: SearchActions[] = []
+        if (filters !== null) {
+          actions.push(new SetFilters(filters, this.routerConfig.searchStateId))
+        }
+        if (sortBy !== null) {
+          actions.push(new SetSortBy(sortBy, this.routerConfig.searchStateId))
+        }
+        if (pageNumber !== null) {
+          actions.push(
+            new Paginate(pageNumber, this.routerConfig.searchStateId)
+          )
+        }
+        return of(...actions)
+      })
+    )
+  )
+
+  /**
+   * This effect will load the metadata when a navigation to
+   * a metadata record happens
+   */
+  navigateToMetadata$ = createEffect(() =>
+    this._actions$.pipe(
+      navigation(this.routerConfig.recordRouteComponent, {
+        run: (activatedRouteSnapshot: ActivatedRouteSnapshot) => {
+          return of(
+            MdViewActions.setIncompleteMetadata({
+              incomplete: {
+                uniqueIdentifier: activatedRouteSnapshot.params.metadataUuid,
+                title: '',
+              },
+            }),
+            MdViewActions.loadFullMetadata({
+              uuid: activatedRouteSnapshot.params.metadataUuid,
+            })
+          )
+        },
+
+        onError(a: ActivatedRouteSnapshot, e) {
+          console.error('Navigation failed', e)
+        },
+      })
+    )
+  )
+
+  /**
+   * This effect will close the metadata when a navigation to
+   * the search results happens
+   */
+  navigateToSearch$ = createEffect(() =>
+    this._actions$.pipe(
+      navigation(this.routerConfig.searchRouteComponent, {
+        run: () => MdViewActions.close(),
+      })
+    )
+  )
+
+  navigateBack$ = createEffect(
+    () =>
+      this._actions$.pipe(
+        ofType(RouterActions.backAction),
+        tap(() => this._location.back())
+      ),
+    { dispatch: false }
+  )
+
+  navigateForward$ = createEffect(
+    () =>
+      this._actions$.pipe(
+        ofType(RouterActions.forwardAction),
+        tap(() => this._location.forward())
+      ),
+    { dispatch: false }
+  )
+}

package/src/libs/feature/router/src/lib/default/state/router.facade.ts

@@ -0,0 +1,80 @@
+import { Injectable } from '@angular/core'
+import { MdViewActions } from '../../../../../../../libs/feature/record/src'
+import { RouterService } from '../router.service'
+import { RouterReducerState } from '@ngrx/router-store'
+import { select, Store } from '@ngrx/store'
+import { distinctUntilChanged, filter, map, take } from 'rxjs/operators'
+import {
+  ROUTER_ROUTE_DATASET,
+  ROUTER_ROUTE_SEARCH,
+  SearchRouteParams,
+} from '../constants'
+import {
+  backAction,
+  forwardAction,
+  goAction,
+  RouterGoActionPayload,
+} from './router.actions'
+import { selectCurrentRoute, selectRouteParams } from './router.selectors'
+import { CatalogRecord } from '../../../../../../../libs/common/domain/src/lib/record'
+
+@Injectable()
+export class RouterFacade {
+  currentRoute$ = this.store.pipe(select(selectCurrentRoute))
+  pathParams$ = this.store.pipe(select(selectRouteParams))
+
+  searchParams$ = this.currentRoute$.pipe(
+    filter((route) => !!route),
+    filter((route) => route.url[0]?.path.startsWith(ROUTER_ROUTE_SEARCH)),
+    map((route) => route.queryParams),
+    distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b))
+  )
+
+  constructor(
+    private store: Store<RouterReducerState>,
+    private routerService: RouterService
+  ) {}
+
+  goToMetadata(metadata: CatalogRecord) {
+    this.pathParams$
+      .pipe(
+        take(1),
+        filter((params) => params.metadataUuid !== metadata.uniqueIdentifier)
+      )
+      .subscribe(() => {
+        this.go({
+          path: `${ROUTER_ROUTE_DATASET}/${metadata.uniqueIdentifier}`,
+        })
+        this.store.dispatch(
+          MdViewActions.setIncompleteMetadata({ incomplete: metadata })
+        )
+      })
+  }
+
+  updateSearch(query?: SearchRouteParams) {
+    this.go({
+      path: this.routerService.getSearchRoute(),
+      ...(query && { query }),
+      queryParamsHandling: 'merge',
+    })
+  }
+
+  setSearch(query?: SearchRouteParams) {
+    this.go({
+      path: this.routerService.getSearchRoute(),
+      ...(query && { query }),
+    })
+  }
+
+  go(payload: RouterGoActionPayload) {
+    this.store.dispatch(goAction(payload))
+  }
+
+  back() {
+    this.store.dispatch(backAction())
+  }
+
+  forward() {
+    this.store.dispatch(forwardAction())
+  }
+}

package/src/libs/feature/router/src/lib/default/state/router.selectors.ts

@@ -0,0 +1,17 @@
+import { getRouterSelectors, RouterReducerState } from '@ngrx/router-store'
+import { createFeatureSelector } from '@ngrx/store'
+import { ROUTER_STATE_KEY } from '../constants'
+
+export const getRouterState =
+  createFeatureSelector<RouterReducerState>(ROUTER_STATE_KEY)
+
+export const {
+  selectCurrentRoute, // select the current route
+  selectFragment, // select the current route fragment
+  selectQueryParams, // select the current route query params
+  selectQueryParam, // factory function to select a query param
+  selectRouteParams, // select the current route params
+  selectRouteParam, // factory function to select a route param
+  selectRouteData, // select the current route data
+  selectUrl, // select the current url
+} = getRouterSelectors(getRouterState)

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

@@ -0,0 +1,20 @@
+export * from './lib/feature-search.module'
+export * from './lib/state/actions'
+export * from './lib/state/selectors'
+export * from './lib/state/search.facade'
+export * from './lib/state/effects'
+export * from './lib/state/reducer'
+export * from './lib/utils/service/search.service'
+export * from './lib/utils/service/fields.service'
+export * from './lib/results-list/results-list.container.component'
+export * from './lib/filter-dropdown/filter-dropdown.component'
+export * from './lib/constants'
+export * from './lib/fuzzy-search/fuzzy-search.component'
+export * from './lib/facets/facets.module'
+export * from './lib/facets/facets-container/facets-container.component'
+export * from './lib/records-metrics/records-metrics.component'
+export * from './lib/favorites/favorite-star/favorite-star.component'
+export * from './lib/results-hits-number/results-hits.container.component'
+export * from './lib/results-layout/results-layout.component'
+export * from './lib/sort-by/sort-by.component'
+export * from './lib/state/container/search-state.container.directive'

package/src/libs/feature/search/src/lib/constants.ts

@@ -0,0 +1,40 @@
+import { FieldName } from '../../../../../libs/common/domain/src/lib/search'
+
+export const DEFAULT_PAGE_SIZE = 10
+
+export const FIELDS_SUMMARY: FieldName[] = [
+  'uuid',
+  'id',
+  'title',
+  'resource*',
+  'resourceTitleObject',
+  'resourceAbstractObject',
+  'overview',
+  'logo',
+  'codelist_status_text',
+  'linkProtocol',
+  'contactForResource*.organisation*',
+  'contact*.organisation*',
+  'contact*.email',
+  'userSavedCount',
+  'cl_topic',
+  'cl_maintenanceAndUpdateFrequency',
+  'tag',
+  'MD_LegalConstraintsUseLimitationObject',
+  'qualityScore',
+]
+
+export const FIELDS_BRIEF: FieldName[] = [
+  ...FIELDS_SUMMARY,
+  'resourceTypeObject',
+  'Org*',
+]
+
+export const QUERY_FIELDS: FieldName[] = [
+  'resourceTitleObject.${searchLang}^5',
+  'tag.${searchLang}^4',
+  'resourceAbstractObject.${searchLang}^3',
+  'lineageObject.${searchLang}^2',
+  'any.${searchLang}',
+  'uuid',
+]

package/src/libs/feature/search/src/lib/facets/facets-container/facets-container.component.html

@@ -0,0 +1,7 @@
+<gn-ui-facet-list
+  [models]="models$ | async"
+  [selectedPaths]="selectedPaths$ | async"
+  (itemChange)="onItemChange($event)"
+  (more)="onMore($event)"
+  (filterChange)="onFilterChange($event)"
+></gn-ui-facet-list>

package/src/libs/feature/search/src/lib/facets/facets-container/facets-container.component.ts

@@ -0,0 +1,83 @@
+import { Component, OnInit } from '@angular/core'
+import { FacetSelectEvent, ModelBlock } from '../../../../../../../libs/ui/search/src'
+import { combineLatest, Observable } from 'rxjs'
+import { map, take } from 'rxjs/operators'
+import { SearchFacade } from '../../state/search.facade'
+import { FacetsService } from '../facets.service'
+import { marker } from '@biesbjerg/ngx-translate-extract-marker'
+import { FieldFilters } from '../../../../../../../libs/common/domain/src/lib/search'
+import { EsRequestAggTerm } from '../../../../../../../libs/api/metadata-converter/src'
+
+marker('facets.block.title.OrgForResource')
+marker('facets.block.title.availableInServices')
+marker('facets.block.title.cl_hierarchyLevel.key')
+marker('facets.block.title.cl_maintenanceAndUpdateFrequency.key')
+marker('facets.block.title.cl_spatialRepresentationType.key')
+marker('facets.block.title.cl_status.key')
+marker('facets.block.title.creationYearForResource')
+marker('facets.block.title.resolutionScaleDenominator')
+marker('facets.block.title.tag')
+marker('facets.block.title.tag.default')
+marker('facets.block.title.th_regions_tree.default')
+
+@Component({
+  selector: 'gn-ui-facets-container',
+  templateUrl: './facets-container.component.html',
+  styleUrls: ['./facets-container.component.css'],
+})
+export class FacetsContainerComponent implements OnInit {
+  selectedPaths$: Observable<string[][]>
+  models$: Observable<ModelBlock[]>
+
+  constructor(
+    private facets: FacetsService,
+    private searchFacade: SearchFacade
+  ) {}
+
+  ngOnInit(): void {
+    this.selectedPaths$ = this.searchFacade.searchFilters$.pipe(
+      map((filters) => this.facets.findSelectedPaths(filters))
+    )
+
+    this.models$ = combineLatest([
+      this.searchFacade.configAggregations$,
+      this.searchFacade.resultsAggregations$,
+    ]).pipe(
+      map(([configAggregations, resultsAggregations]) => {
+        const model = this.facets.createFacetModel(
+          configAggregations,
+          resultsAggregations,
+          false
+        )
+        return model
+      })
+    )
+  }
+
+  onItemChange(facetEvent: FacetSelectEvent) {
+    this.searchFacade.searchFilters$.pipe(take(1)).subscribe((filters) => {
+      this.updateFilters(filters, facetEvent)
+    })
+  }
+
+  private updateFilters(filters: FieldFilters, facetEvent: FacetSelectEvent) {
+    const { item, block } = facetEvent
+    const { path } = item
+    const pathValue = this.facets.computeItemPathValue(block, item)
+    const newFilters = this.facets.computeNewFiltersFromState(
+      filters,
+      path,
+      pathValue
+    )
+    this.searchFacade.setFilters(newFilters)
+  }
+
+  onMore(key: string): void {
+    this.searchFacade.requestMoreOnAggregation(key, 20)
+  }
+
+  onFilterChange(term: EsRequestAggTerm): void {
+    const include = `.*${term.include}.*`
+    this.searchFacade.setIncludeOnAggregation(term.field, include)
+  }
+}

package/src/libs/feature/search/src/lib/facets/facets.module.ts

@@ -0,0 +1,12 @@
+import { CommonModule } from '@angular/common'
+import { NgModule } from '@angular/core'
+import { UiFacetsModule } from '../../../../../../libs/ui/search/src'
+import { TranslateModule } from '@ngx-translate/core'
+import { FacetsContainerComponent } from './facets-container/facets-container.component'
+
+@NgModule({
+  declarations: [FacetsContainerComponent],
+  imports: [CommonModule, TranslateModule.forChild(), UiFacetsModule],
+  exports: [FacetsContainerComponent],
+})
+export class FacetsModule {}