geonetwork-ui 2.1.0-initial

package/src/libs/feature/search/src/lib/state/search.facade.ts

@@ -0,0 +1,219 @@
+import { Inject, Injectable, Optional } from '@angular/core'
+import { select, Store } from '@ngrx/store'
+import { from, Observable, of } from 'rxjs'
+import {
+  AddSearch,
+  ClearResults,
+  DEFAULT_SEARCH_KEY,
+  Paginate,
+  RequestMoreOnAggregation,
+  RequestMoreResults,
+  SetConfigAggregations,
+  SetConfigFilters,
+  SetConfigRequestFields,
+  SetFavoritesOnly,
+  SetFilters,
+  SetIncludeOnAggregation,
+  SetPageSize,
+  SetResultsLayout,
+  SetSearch,
+  SetSortBy,
+  SetSpatialFilterEnabled,
+  UpdateConfigAggregations,
+  UpdateFilters,
+} from './actions'
+import { SearchError, SearchState, SearchStateParams } from './reducer'
+import {
+  currentPage,
+  getError,
+  getFavoritesOnly,
+  getSearchConfigAggregations,
+  getSearchFilters,
+  getSearchResults,
+  getSearchResultsAggregations,
+  getSearchResultsHits,
+  getSearchResultsLayout,
+  getSearchResultsLoading,
+  getSearchSortBy,
+  getPageSize,
+  getSpatialFilterEnabled,
+  isEndOfResults,
+  totalPages,
+} from './selectors'
+import { FILTER_GEOMETRY } from '../feature-search.module'
+import { Geometry } from 'geojson'
+import { catchError, map, shareReplay } from 'rxjs/operators'
+import {
+  Aggregations,
+  AggregationsParams,
+  FieldFilters,
+  FieldName,
+  SortByField,
+} from '../../../../../../libs/common/domain/src/lib/search'
+import { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/record'
+
+@Injectable()
+export class SearchFacade {
+  results$: Observable<CatalogRecord[]>
+  layout$: Observable<string>
+  sortBy$: Observable<SortByField>
+  isLoading$: Observable<boolean>
+  isEndOfResults$: Observable<boolean>
+  totalPages$: Observable<number>
+  currentPage$: Observable<number>
+  pageSize$: Observable<number>
+  searchFilters$: Observable<FieldFilters>
+  configAggregations$: Observable<AggregationsParams>
+  resultsAggregations$: Observable<Aggregations>
+  resultsHits$: Observable<number>
+  favoritesOnly$: Observable<boolean>
+  error$: Observable<SearchError>
+  spatialFilterEnabled$: Observable<boolean>
+  hasSpatialFilter$ = from(this.filterGeometry ?? of(null)).pipe(
+    map((geom) => !!geom),
+    catchError(() => of(false)),
+    shareReplay(1)
+  )
+
+  searchId: string
+
+  constructor(
+    private store: Store<SearchState>,
+    @Optional()
+    @Inject(FILTER_GEOMETRY)
+    private filterGeometry: Promise<Geometry>
+  ) {}
+
+  init(searchId: string = DEFAULT_SEARCH_KEY): void {
+    if (this.searchId)
+      throw new Error(
+        `This SearchFacade instance was already initialized with the following searchId: ${this.searchId}`
+      )
+
+    this.searchId = searchId
+    this.store.dispatch(new AddSearch(searchId))
+
+    this.results$ = this.store.pipe(select(getSearchResults, searchId))
+    this.layout$ = this.store.pipe(select(getSearchResultsLayout, searchId))
+    this.isLoading$ = this.store.pipe(select(getSearchResultsLoading, searchId))
+    this.searchFilters$ = this.store.pipe(select(getSearchFilters, searchId))
+    this.resultsHits$ = this.store.pipe(select(getSearchResultsHits, searchId))
+    this.isEndOfResults$ = this.store.pipe(select(isEndOfResults, searchId))
+    this.totalPages$ = this.store.pipe(select(totalPages, searchId))
+    this.currentPage$ = this.store.pipe(select(currentPage, searchId))
+    this.pageSize$ = this.store.pipe(select(getPageSize, searchId))
+    this.configAggregations$ = this.store.pipe(
+      select(getSearchConfigAggregations, searchId)
+    )
+    this.resultsAggregations$ = this.store.pipe(
+      select(getSearchResultsAggregations, searchId)
+    )
+    this.sortBy$ = this.store.pipe(select(getSearchSortBy, searchId))
+    this.favoritesOnly$ = this.store.pipe(select(getFavoritesOnly, searchId))
+    this.error$ = this.store.pipe(select(getError, searchId))
+    this.spatialFilterEnabled$ = this.store.pipe(
+      select(getSpatialFilterEnabled, searchId)
+    )
+  }
+
+  clearResults(): SearchFacade {
+    this.store.dispatch(new ClearResults(this.searchId))
+    return this
+  }
+
+  setConfigAggregations(config: any): SearchFacade {
+    this.store.dispatch(new SetConfigAggregations(config, this.searchId))
+    return this
+  }
+
+  updateConfigAggregations(config: any): SearchFacade {
+    this.store.dispatch(new UpdateConfigAggregations(config, this.searchId))
+    return this
+  }
+
+  setConfigRequestFields(fields: FieldName[]): SearchFacade {
+    this.store.dispatch(new SetConfigRequestFields(fields, this.searchId))
+    return this
+  }
+
+  setConfigFilters(filters: FieldFilters): SearchFacade {
+    this.store.dispatch(new SetConfigFilters(filters, this.searchId))
+    return this
+  }
+
+  requestMoreResults(): SearchFacade {
+    this.store.dispatch(new RequestMoreResults(this.searchId))
+    return this
+  }
+
+  requestMoreOnAggregation(key: string, increment: number): SearchFacade {
+    this.store.dispatch(
+      new RequestMoreOnAggregation(key, increment, this.searchId)
+    )
+    return this
+  }
+
+  setResultsLayout(layout: string): SearchFacade {
+    this.store.dispatch(new SetResultsLayout(layout, this.searchId))
+    return this
+  }
+
+  setFilters(filters: FieldFilters): SearchFacade {
+    this.store.dispatch(new SetFilters(filters, this.searchId))
+    return this
+  }
+
+  updateFilters(filters: FieldFilters): SearchFacade {
+    this.store.dispatch(new UpdateFilters(filters, this.searchId))
+    return this
+  }
+
+  setSearch(params: SearchStateParams): SearchFacade {
+    this.store.dispatch(new SetSearch(params, this.searchId))
+    return this
+  }
+
+  setFavoritesOnly(favoritesOnly: boolean): SearchFacade {
+    this.store.dispatch(new SetFavoritesOnly(favoritesOnly, this.searchId))
+    return this
+  }
+
+  setIncludeOnAggregation(key: string, include: string): SearchFacade {
+    this.store.dispatch(
+      new SetIncludeOnAggregation(key, include, this.searchId)
+    )
+    return this
+  }
+
+  setPageSize(size: number): SearchFacade {
+    this.store.dispatch(new SetPageSize(size, this.searchId))
+    return this
+  }
+
+  paginate(pageNumber: number): SearchFacade {
+    this.store.dispatch(new Paginate(pageNumber, this.searchId))
+    return this
+  }
+
+  scroll(): SearchFacade {
+    this.store.dispatch(new RequestMoreResults(this.searchId))
+    return this
+  }
+
+  setSortBy(sortBy: SortByField) {
+    this.store.dispatch(new SetSortBy(sortBy, this.searchId))
+    return this
+  }
+
+  setSpatialFilterEnabled(enabled: boolean) {
+    this.store.dispatch(new SetSpatialFilterEnabled(enabled, this.searchId))
+    return this
+  }
+
+  resetSearch() {
+    this.store.dispatch(new Paginate(1, this.searchId))
+    this.store.dispatch(new SetFilters({}, this.searchId))
+    this.store.dispatch(new SetSortBy([], this.searchId))
+    this.store.dispatch(new SetFavoritesOnly(false, this.searchId))
+  }
+}

package/src/libs/feature/search/src/lib/state/selectors.ts

@@ -0,0 +1,94 @@
+import { createFeatureSelector, createSelector } from '@ngrx/store'
+import { DEFAULT_SEARCH_KEY } from './actions'
+import { SEARCH_FEATURE_KEY, SearchState, SearchStateSearch } from './reducer'
+
+export const getSearchState =
+  createFeatureSelector<SearchState>(SEARCH_FEATURE_KEY)
+
+export const getSearchStateSearch = createSelector(
+  getSearchState,
+  (state: SearchState, id: string = DEFAULT_SEARCH_KEY) => state[id]
+)
+
+export const getSearchFilters = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.params.filters
+)
+
+export const getSearchSortBy = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.params.sort
+)
+
+export const getSearchResultsLayout = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.resultsLayout
+)
+
+export const getSearchConfigAggregations = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.config.aggregations
+)
+
+export const getSearchResults = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.results.records
+)
+
+export const getSearchResultsLoading = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.loadingResults
+)
+
+export const getSearchResultsAggregations = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.results.aggregations
+)
+
+export const getSearchResultsHits = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.results.count
+)
+
+export const isEndOfResults = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => {
+    return (
+      state.params.currentPage * state.params.pageSize +
+        state.params.pageSize >=
+      state.results.count
+    )
+  }
+)
+
+export const totalPages = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => {
+    return Math.ceil(state.results.count / state.params.pageSize)
+  }
+)
+
+export const currentPage = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.params.currentPage + 1
+)
+
+export const getPageSize = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.params.pageSize
+)
+
+export const getFavoritesOnly = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.params.favoritesOnly
+)
+
+export const getError = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.error
+)
+
+export const getSpatialFilterEnabled = createSelector(
+  getSearchStateSearch,
+  (state: SearchStateSearch) => state.params.useSpatialFilter
+)

package/src/libs/feature/search/src/lib/utils/operators/search.operator.ts

@@ -0,0 +1,40 @@
+import { Observable, Observer, Subscription } from 'rxjs'
+import { AbstractAction } from '../../state/actions'
+import { mergeMap } from 'rxjs/operators'
+
+/**
+ * This operator will only unsubscribe to previous observables if the new
+ * one applies to the same search id; this allows having parallel searches
+ * with different id while avoiding concurrent requests with the same
+ * search id
+ * @param project
+ */
+export function switchMapWithSearchId<A extends AbstractAction, T>(
+  project: (value: A) => Observable<T>
+) {
+  const subscriptionsBySearchId: { [id: string]: Subscription } = {}
+  return (source: Observable<A>) =>
+    source.pipe(
+      mergeMap(
+        (action) =>
+          new Observable((observer: Observer<T>) => {
+            const { id: searchId } = action
+            const observable = project(action)
+            if (subscriptionsBySearchId[searchId]) {
+              subscriptionsBySearchId[searchId].unsubscribe()
+            }
+            subscriptionsBySearchId[searchId] = observable.subscribe({
+              next(value: T) {
+                observer.next(value)
+              },
+              complete() {
+                observer.complete()
+              },
+              error(err: unknown) {
+                observer.error(err)
+              },
+            })
+          })
+      )
+    )
+}

package/src/libs/feature/search/src/lib/utils/service/fields.service.ts

@@ -0,0 +1,120 @@
+import { Injectable, Injector } from '@angular/core'
+import {
+  AbstractSearchField,
+  GnUiTranslationSearchField,
+  FieldValue,
+  FullTextSearchField,
+  IsSpatialSearchField,
+  LicenseSearchField,
+  OrganizationSearchField,
+  SimpleSearchField,
+} from './fields'
+import { forkJoin, Observable, of } from 'rxjs'
+import { map } from 'rxjs/operators'
+import { FieldFilters } from '../../../../../../../libs/common/domain/src/lib/search'
+import { marker } from '@biesbjerg/ngx-translate-extract-marker'
+
+// key is the field name
+export type FieldValues = Record<string, FieldValue[] | FieldValue>
+
+marker('search.filters.format')
+marker('search.filters.inspireKeyword')
+marker('search.filters.isSpatial')
+marker('search.filters.license')
+marker('search.filters.publicationYear')
+marker('search.filters.publisher')
+marker('search.filters.representationType')
+marker('search.filters.resourceType')
+marker('search.filters.standard')
+marker('search.filters.topic')
+
+@Injectable({
+  providedIn: 'root',
+})
+export class FieldsService {
+  private fields = {
+    publisher: new OrganizationSearchField(this.injector),
+    format: new SimpleSearchField('format', 'asc', this.injector),
+    resourceType: new GnUiTranslationSearchField(
+      'resourceType',
+      'asc',
+      this.injector
+    ),
+    representationType: new GnUiTranslationSearchField(
+      'cl_spatialRepresentationType.key',
+      'asc',
+      this.injector
+    ),
+    publicationYear: new SimpleSearchField(
+      'publicationYearForResource',
+      'desc',
+      this.injector
+    ),
+    topic: new GnUiTranslationSearchField('cl_topic.key', 'asc', this.injector),
+    inspireKeyword: new SimpleSearchField(
+      'th_httpinspireeceuropaeutheme-theme_tree.default',
+      'asc',
+      this.injector
+    ),
+    documentStandard: new SimpleSearchField(
+      'documentStandard',
+      'asc',
+      this.injector
+    ),
+    isSpatial: new IsSpatialSearchField(this.injector),
+    q: new FullTextSearchField(),
+    license: new LicenseSearchField(this.injector),
+  } as Record<string, AbstractSearchField>
+
+  get supportedFields() {
+    return Object.keys(this.fields)
+  }
+
+  constructor(private injector: Injector) {}
+
+  getAvailableValues(fieldName: string) {
+    if (this.supportedFields.indexOf(fieldName) === -1)
+      throw new Error(`Unsupported search field: ${fieldName}`)
+    return this.fields[fieldName].getAvailableValues()
+  }
+
+  private getFiltersForValues(fieldName: string, values: FieldValue[]) {
+    return this.fields[fieldName].getFiltersForValues(values)
+  }
+  private getValuesForFilters(fieldName: string, filters: FieldFilters) {
+    return this.fields[fieldName].getValuesForFilter(filters)
+  }
+
+  buildFiltersFromFieldValues(
+    fieldValues: FieldValues
+  ): Observable<FieldFilters> {
+    const fieldNames = Object.keys(fieldValues).filter((fieldName) =>
+      this.supportedFields.includes(fieldName)
+    )
+    if (!fieldNames.length) return of({})
+    const filtersByField$ = fieldNames.map((fieldName) => {
+      const values = Array.isArray(fieldValues[fieldName])
+        ? fieldValues[fieldName]
+        : [fieldValues[fieldName]]
+      return this.getFiltersForValues(fieldName, values as FieldValue[])
+    })
+    return forkJoin(filtersByField$).pipe(
+      map((filters) =>
+        filters.reduce((prev, curr) => ({ ...prev, ...curr }), {})
+      )
+    )
+  }
+
+  readFieldValuesFromFilters(filters: FieldFilters): Observable<FieldValues> {
+    const fieldValues$ = this.supportedFields.map((fieldName) =>
+      this.getValuesForFilters(fieldName, filters).pipe(
+        map((values) => ({ [fieldName]: values }))
+      )
+    )
+    return forkJoin(fieldValues$).pipe(
+      map((fieldValues) =>
+        fieldValues.reduce((prev, curr) => ({ ...prev, ...curr }), {})
+      )
+    )
+  }
+}