geonetwork-ui 2.1.0-initial

package/esm2022/libs/feature/search/src/lib/state/search.facade.mjs

@@ -0,0 +1,126 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { select, Store } from '@ngrx/store';
+import { from, 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 { 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 { catchError, map, shareReplay } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+export class SearchFacade {
+    constructor(store, filterGeometry) {
+        this.store = store;
+        this.filterGeometry = filterGeometry;
+        this.hasSpatialFilter$ = from(this.filterGeometry ?? of(null)).pipe(map((geom) => !!geom), catchError(() => of(false)), shareReplay(1));
+    }
+    init(searchId = DEFAULT_SEARCH_KEY) {
+        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() {
+        this.store.dispatch(new ClearResults(this.searchId));
+        return this;
+    }
+    setConfigAggregations(config) {
+        this.store.dispatch(new SetConfigAggregations(config, this.searchId));
+        return this;
+    }
+    updateConfigAggregations(config) {
+        this.store.dispatch(new UpdateConfigAggregations(config, this.searchId));
+        return this;
+    }
+    setConfigRequestFields(fields) {
+        this.store.dispatch(new SetConfigRequestFields(fields, this.searchId));
+        return this;
+    }
+    setConfigFilters(filters) {
+        this.store.dispatch(new SetConfigFilters(filters, this.searchId));
+        return this;
+    }
+    requestMoreResults() {
+        this.store.dispatch(new RequestMoreResults(this.searchId));
+        return this;
+    }
+    requestMoreOnAggregation(key, increment) {
+        this.store.dispatch(new RequestMoreOnAggregation(key, increment, this.searchId));
+        return this;
+    }
+    setResultsLayout(layout) {
+        this.store.dispatch(new SetResultsLayout(layout, this.searchId));
+        return this;
+    }
+    setFilters(filters) {
+        this.store.dispatch(new SetFilters(filters, this.searchId));
+        return this;
+    }
+    updateFilters(filters) {
+        this.store.dispatch(new UpdateFilters(filters, this.searchId));
+        return this;
+    }
+    setSearch(params) {
+        this.store.dispatch(new SetSearch(params, this.searchId));
+        return this;
+    }
+    setFavoritesOnly(favoritesOnly) {
+        this.store.dispatch(new SetFavoritesOnly(favoritesOnly, this.searchId));
+        return this;
+    }
+    setIncludeOnAggregation(key, include) {
+        this.store.dispatch(new SetIncludeOnAggregation(key, include, this.searchId));
+        return this;
+    }
+    setPageSize(size) {
+        this.store.dispatch(new SetPageSize(size, this.searchId));
+        return this;
+    }
+    paginate(pageNumber) {
+        this.store.dispatch(new Paginate(pageNumber, this.searchId));
+        return this;
+    }
+    scroll() {
+        this.store.dispatch(new RequestMoreResults(this.searchId));
+        return this;
+    }
+    setSortBy(sortBy) {
+        this.store.dispatch(new SetSortBy(sortBy, this.searchId));
+        return this;
+    }
+    setSpatialFilterEnabled(enabled) {
+        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));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SearchFacade, deps: [{ token: i1.Store }, { token: FILTER_GEOMETRY, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SearchFacade }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SearchFacade, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: Promise, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FILTER_GEOMETRY]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.facade.js","sourceRoot":"","sources":["../../../../../../../../libs/feature/search/src/lib/state/search.facade.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core'\nimport { select, Store } from '@ngrx/store'\nimport { from, Observable, of } from 'rxjs'\nimport {\n  AddSearch,\n  ClearResults,\n  DEFAULT_SEARCH_KEY,\n  Paginate,\n  RequestMoreOnAggregation,\n  RequestMoreResults,\n  SetConfigAggregations,\n  SetConfigFilters,\n  SetConfigRequestFields,\n  SetFavoritesOnly,\n  SetFilters,\n  SetIncludeOnAggregation,\n  SetPageSize,\n  SetResultsLayout,\n  SetSearch,\n  SetSortBy,\n  SetSpatialFilterEnabled,\n  UpdateConfigAggregations,\n  UpdateFilters,\n} from './actions'\nimport { SearchError, SearchState, SearchStateParams } from './reducer'\nimport {\n  currentPage,\n  getError,\n  getFavoritesOnly,\n  getSearchConfigAggregations,\n  getSearchFilters,\n  getSearchResults,\n  getSearchResultsAggregations,\n  getSearchResultsHits,\n  getSearchResultsLayout,\n  getSearchResultsLoading,\n  getSearchSortBy,\n  getPageSize,\n  getSpatialFilterEnabled,\n  isEndOfResults,\n  totalPages,\n} from './selectors'\nimport { FILTER_GEOMETRY } from '../feature-search.module'\nimport { Geometry } from 'geojson'\nimport { catchError, map, shareReplay } from 'rxjs/operators'\nimport {\n  Aggregations,\n  AggregationsParams,\n  FieldFilters,\n  FieldName,\n  SortByField,\n} from '../../../../../../libs/common/domain/src/lib/search'\nimport { CatalogRecord } from '../../../../../../libs/common/domain/src/lib/record'\n\n@Injectable()\nexport class SearchFacade {\n  results$: Observable<CatalogRecord[]>\n  layout$: Observable<string>\n  sortBy$: Observable<SortByField>\n  isLoading$: Observable<boolean>\n  isEndOfResults$: Observable<boolean>\n  totalPages$: Observable<number>\n  currentPage$: Observable<number>\n  pageSize$: Observable<number>\n  searchFilters$: Observable<FieldFilters>\n  configAggregations$: Observable<AggregationsParams>\n  resultsAggregations$: Observable<Aggregations>\n  resultsHits$: Observable<number>\n  favoritesOnly$: Observable<boolean>\n  error$: Observable<SearchError>\n  spatialFilterEnabled$: Observable<boolean>\n  hasSpatialFilter$ = from(this.filterGeometry ?? of(null)).pipe(\n    map((geom) => !!geom),\n    catchError(() => of(false)),\n    shareReplay(1)\n  )\n\n  searchId: string\n\n  constructor(\n    private store: Store<SearchState>,\n    @Optional()\n    @Inject(FILTER_GEOMETRY)\n    private filterGeometry: Promise<Geometry>\n  ) {}\n\n  init(searchId: string = DEFAULT_SEARCH_KEY): void {\n    if (this.searchId)\n      throw new Error(\n        `This SearchFacade instance was already initialized with the following searchId: ${this.searchId}`\n      )\n\n    this.searchId = searchId\n    this.store.dispatch(new AddSearch(searchId))\n\n    this.results$ = this.store.pipe(select(getSearchResults, searchId))\n    this.layout$ = this.store.pipe(select(getSearchResultsLayout, searchId))\n    this.isLoading$ = this.store.pipe(select(getSearchResultsLoading, searchId))\n    this.searchFilters$ = this.store.pipe(select(getSearchFilters, searchId))\n    this.resultsHits$ = this.store.pipe(select(getSearchResultsHits, searchId))\n    this.isEndOfResults$ = this.store.pipe(select(isEndOfResults, searchId))\n    this.totalPages$ = this.store.pipe(select(totalPages, searchId))\n    this.currentPage$ = this.store.pipe(select(currentPage, searchId))\n    this.pageSize$ = this.store.pipe(select(getPageSize, searchId))\n    this.configAggregations$ = this.store.pipe(\n      select(getSearchConfigAggregations, searchId)\n    )\n    this.resultsAggregations$ = this.store.pipe(\n      select(getSearchResultsAggregations, searchId)\n    )\n    this.sortBy$ = this.store.pipe(select(getSearchSortBy, searchId))\n    this.favoritesOnly$ = this.store.pipe(select(getFavoritesOnly, searchId))\n    this.error$ = this.store.pipe(select(getError, searchId))\n    this.spatialFilterEnabled$ = this.store.pipe(\n      select(getSpatialFilterEnabled, searchId)\n    )\n  }\n\n  clearResults(): SearchFacade {\n    this.store.dispatch(new ClearResults(this.searchId))\n    return this\n  }\n\n  setConfigAggregations(config: any): SearchFacade {\n    this.store.dispatch(new SetConfigAggregations(config, this.searchId))\n    return this\n  }\n\n  updateConfigAggregations(config: any): SearchFacade {\n    this.store.dispatch(new UpdateConfigAggregations(config, this.searchId))\n    return this\n  }\n\n  setConfigRequestFields(fields: FieldName[]): SearchFacade {\n    this.store.dispatch(new SetConfigRequestFields(fields, this.searchId))\n    return this\n  }\n\n  setConfigFilters(filters: FieldFilters): SearchFacade {\n    this.store.dispatch(new SetConfigFilters(filters, this.searchId))\n    return this\n  }\n\n  requestMoreResults(): SearchFacade {\n    this.store.dispatch(new RequestMoreResults(this.searchId))\n    return this\n  }\n\n  requestMoreOnAggregation(key: string, increment: number): SearchFacade {\n    this.store.dispatch(\n      new RequestMoreOnAggregation(key, increment, this.searchId)\n    )\n    return this\n  }\n\n  setResultsLayout(layout: string): SearchFacade {\n    this.store.dispatch(new SetResultsLayout(layout, this.searchId))\n    return this\n  }\n\n  setFilters(filters: FieldFilters): SearchFacade {\n    this.store.dispatch(new SetFilters(filters, this.searchId))\n    return this\n  }\n\n  updateFilters(filters: FieldFilters): SearchFacade {\n    this.store.dispatch(new UpdateFilters(filters, this.searchId))\n    return this\n  }\n\n  setSearch(params: SearchStateParams): SearchFacade {\n    this.store.dispatch(new SetSearch(params, this.searchId))\n    return this\n  }\n\n  setFavoritesOnly(favoritesOnly: boolean): SearchFacade {\n    this.store.dispatch(new SetFavoritesOnly(favoritesOnly, this.searchId))\n    return this\n  }\n\n  setIncludeOnAggregation(key: string, include: string): SearchFacade {\n    this.store.dispatch(\n      new SetIncludeOnAggregation(key, include, this.searchId)\n    )\n    return this\n  }\n\n  setPageSize(size: number): SearchFacade {\n    this.store.dispatch(new SetPageSize(size, this.searchId))\n    return this\n  }\n\n  paginate(pageNumber: number): SearchFacade {\n    this.store.dispatch(new Paginate(pageNumber, this.searchId))\n    return this\n  }\n\n  scroll(): SearchFacade {\n    this.store.dispatch(new RequestMoreResults(this.searchId))\n    return this\n  }\n\n  setSortBy(sortBy: SortByField) {\n    this.store.dispatch(new SetSortBy(sortBy, this.searchId))\n    return this\n  }\n\n  setSpatialFilterEnabled(enabled: boolean) {\n    this.store.dispatch(new SetSpatialFilterEnabled(enabled, this.searchId))\n    return this\n  }\n\n  resetSearch() {\n    this.store.dispatch(new Paginate(1, this.searchId))\n    this.store.dispatch(new SetFilters({}, this.searchId))\n    this.store.dispatch(new SetSortBy([], this.searchId))\n    this.store.dispatch(new SetFavoritesOnly(false, this.searchId))\n  }\n}\n"]}

package/esm2022/libs/feature/search/src/lib/state/selectors.mjs

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

package/esm2022/libs/feature/search/src/lib/utils/operators/search.operator.mjs

@@ -0,0 +1,31 @@
+import { Observable } from 'rxjs';
+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(project) {
+    const subscriptionsBySearchId = {};
+    return (source) => source.pipe(mergeMap((action) => new Observable((observer) => {
+        const { id: searchId } = action;
+        const observable = project(action);
+        if (subscriptionsBySearchId[searchId]) {
+            subscriptionsBySearchId[searchId].unsubscribe();
+        }
+        subscriptionsBySearchId[searchId] = observable.subscribe({
+            next(value) {
+                observer.next(value);
+            },
+            complete() {
+                observer.complete();
+            },
+            error(err) {
+                observer.error(err);
+            },
+        });
+    })));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/feature/search/src/lib/utils/service/fields.mjs

@@ -0,0 +1,230 @@
+import { firstValueFrom, of, switchMap } from 'rxjs';
+import { ToolsApiService } from '../../../../../../../libs/data-access/gn4/src';
+import { catchError, map, shareReplay } from 'rxjs/operators';
+import { TranslateService } from '@ngx-translate/core';
+import { marker } from '@biesbjerg/ngx-translate-extract-marker';
+import { OrganizationsServiceInterface } from '../../../../../../../libs/common/domain/src/lib/organizations.service.interface';
+import { RecordsRepositoryInterface } from '../../../../../../../libs/common/domain/src/lib/records-repository.interface';
+import { ElasticsearchService } from '../../../../../../../libs/api/repository/src/lib/gn4';
+export class AbstractSearchField {
+}
+export class SimpleSearchField {
+    constructor(esFieldName, order = 'asc', injector) {
+        this.esFieldName = esFieldName;
+        this.order = order;
+        this.injector = injector;
+        this.repository = this.injector.get(RecordsRepositoryInterface);
+        // FIXME: this is required to register runtime fields; abstract this as well
+        this.esService = this.injector.get(ElasticsearchService);
+    }
+    getAggregations() {
+        return {
+            [this.esFieldName]: {
+                type: 'terms',
+                field: this.esFieldName,
+                limit: 1000,
+                sort: [this.order, 'key'],
+            },
+        };
+    }
+    async getBucketLabel(bucket) {
+        return bucket.term;
+    }
+    getAvailableValues() {
+        return this.repository.aggregate(this.getAggregations()).pipe(map((response) => response[this.esFieldName].buckets || []), switchMap((buckets) => {
+            const bucketPromises = buckets.map(async (bucket) => ({
+                label: `${await this.getBucketLabel(bucket)} (${bucket.count})`,
+                value: bucket.term.toString(),
+            }));
+            return Promise.all(bucketPromises);
+        }));
+    }
+    getFiltersForValues(values) {
+        return of({
+            [this.esFieldName]: values.reduce((acc, val) => {
+                return { ...acc, [val.toString()]: true };
+            }, {}),
+        });
+    }
+    getValuesForFilter(filters) {
+        const filter = filters[this.esFieldName];
+        if (!filter)
+            return of([]);
+        const values = typeof filter === 'string'
+            ? [filter]
+            : Object.keys(filter).filter((v) => filter[v]);
+        return of(values);
+    }
+}
+export class GnUiTranslationSearchField extends SimpleSearchField {
+    constructor(esFieldName, order = 'asc', injector) {
+        super(esFieldName, order, injector);
+        this.toolsApiService = this.injector.get(ToolsApiService);
+        this.allTranslations = this.toolsApiService.getTranslationsPackage1('gnui').pipe(catchError(() => {
+            console.warn('Error while loading gnui language package');
+            return of({});
+        }), shareReplay(1));
+    }
+    async getTranslation(topicKey) {
+        return firstValueFrom(this.allTranslations.pipe(map((translations) => translations[topicKey])));
+    }
+    async getBucketLabel(bucket) {
+        return (await this.getTranslation(bucket.term)) || bucket.term;
+    }
+    getAvailableValues() {
+        // sort values by alphabetical order
+        return super
+            .getAvailableValues()
+            .pipe(map((values) => values.sort((a, b) => new Intl.Collator().compare(a.label, b.label))));
+    }
+}
+export class FullTextSearchField {
+    getAvailableValues() {
+        return of([]);
+    }
+    getFiltersForValues(values) {
+        return of({
+            any: values[0],
+        });
+    }
+    getValuesForFilter(filters) {
+        return of(filters.any ? [filters.any] : []);
+    }
+}
+marker('search.filters.isSpatial.yes');
+marker('search.filters.isSpatial.no');
+export class IsSpatialSearchField extends SimpleSearchField {
+    constructor(injector) {
+        super('isSpatial', 'asc', injector);
+        this.translateService = this.injector.get(TranslateService);
+        this.esService.registerRuntimeField('isSpatial', `String result = 'no';
+String formats = doc.format.join('|').toLowerCase();
+if (formats.contains('geojson') || formats.contains('arcgis') || formats.contains('ogc') || formats.contains('shp')) result = 'yes';
+String protocols = doc.linkProtocol.join('|').toLowerCase();
+if (protocols.contains('esri') || protocols.contains('ogc')) result = 'yes';
+emit(result);`);
+    }
+    getAggregations() {
+        return {
+            isSpatial: {
+                type: 'terms',
+                limit: 2,
+                field: 'isSpatial',
+                sort: ['asc', 'key'],
+            },
+        };
+    }
+    async getBucketLabel(bucket) {
+        return firstValueFrom(this.translateService.get(`search.filters.isSpatial.${bucket.term}`));
+    }
+    getFiltersForValues(values) {
+        const isSpatial = {};
+        if (values.length > 0)
+            isSpatial[values[values.length - 1]] = true;
+        return of({
+            isSpatial,
+        });
+    }
+    getValuesForFilter(filters) {
+        const filter = filters.isSpatial;
+        if (!filter)
+            return of([]);
+        const keys = Object.keys(filter);
+        return of(keys.length ? [keys[0]] : []);
+    }
+}
+marker('search.filters.license.pddl');
+marker('search.filters.license.odbl');
+marker('search.filters.license.odc-by');
+marker('search.filters.license.cc-by-sa');
+marker('search.filters.license.cc-by');
+marker('search.filters.license.cc-zero');
+marker('search.filters.license.etalab-v2');
+marker('search.filters.license.etalab');
+marker('search.filters.license.unknown');
+// Note: values are inspired from https://doc.data.gouv.fr/moissonnage/licences/
+export class LicenseSearchField extends SimpleSearchField {
+    constructor(injector) {
+        super('license', 'asc', injector);
+        this.translateService = this.injector.get(TranslateService);
+        this.esService.registerRuntimeField('license', `String raw = '';
+if (doc.containsKey('licenseObject.default.keyword') && doc['licenseObject.default.keyword'].length > 0)
+  raw += doc['licenseObject.default.keyword'].join('|').toLowerCase();
+if (doc.containsKey('MD_LegalConstraintsUseLimitationObject.default.keyword') && doc['MD_LegalConstraintsUseLimitationObject.default.keyword'].length > 0)
+  raw += doc['MD_LegalConstraintsUseLimitationObject.default.keyword'].join('|').toLowerCase();
+
+boolean unknown = true;
+if (raw.contains('pddl') || raw.contains('public domain dedication and licence')) {
+  unknown = false;
+  emit('pddl');
+}
+if (raw.contains('odbl') || raw.contains('open database license')) {
+  unknown = false;
+  emit('odbl');
+}
+if (raw.contains('odc-by') || raw.contains('opendatacommons.org/licenses/by/summary/"')) {
+  unknown = false;
+  emit('odc-by');
+}
+
+if (raw.contains('cc-by-sa') || raw.contains('creative commons attribution share-alike')) {
+  unknown = false;
+  emit('cc-by-sa');
+} else if (raw.contains('cc-by') || raw.contains('cc by') || raw.contains('creative commons attribution')) {
+  unknown = false;
+  emit('cc-by');
+} else if (raw.contains('cc0') || raw.contains('cc-0') || raw.contains('cczero') || raw.contains('cc-zero')) {
+  unknown = false;
+  emit('cc-zero');
+}
+
+if (raw.contains('etalab') && (raw.contains('v2') || raw.contains('2.0'))) {
+  unknown = false;
+  emit('etalab-v2');
+} else if (raw.contains('open licence') || raw.contains('licence ouverte') || raw.contains('licence_ouverte')) {
+  unknown = false;
+  emit('etalab');
+}
+
+if(unknown) emit('unknown');`);
+    }
+    getAggregations() {
+        return {
+            license: {
+                type: 'terms',
+                limit: 10,
+                field: 'license',
+                sort: ['desc', 'count'],
+            },
+        };
+    }
+    async getBucketLabel(bucket) {
+        return firstValueFrom(this.translateService.get(`search.filters.license.${bucket.term}`));
+    }
+}
+// This will use the OrganizationsServiceInterface
+// Field values are the organization names
+export class OrganizationSearchField {
+    constructor(injector) {
+        this.injector = injector;
+        this.orgsService = this.injector.get(OrganizationsServiceInterface);
+    }
+    getFiltersForValues(values) {
+        return this.orgsService.organisations$.pipe(map((orgs) => values
+            .map((name) => orgs.find((org) => org.name === name))
+            .filter((org) => org !== undefined)), switchMap((selectedOrgs) => this.orgsService.getFiltersForOrgs(selectedOrgs)));
+    }
+    getValuesForFilter(filters) {
+        return this.orgsService
+            .getOrgsFromFilters(filters)
+            .pipe(map((orgs) => orgs.map((org) => org.name)));
+    }
+    getAvailableValues() {
+        // sort values by alphabetical order
+        return this.orgsService.organisations$.pipe(map((organisations) => organisations.map((org) => ({
+            label: `${org.name} (${org.recordCount})`,
+            value: org.name,
+        }))), map((values) => values.sort((a, b) => new Intl.Collator().compare(a.label, b.label))));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fields.js","sourceRoot":"","sources":["../../../../../../../../../libs/feature/search/src/lib/utils/service/fields.ts"],"names":[],"mappings":"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","sourcesContent":["import { firstValueFrom, Observable, of, switchMap } from 'rxjs'\nimport { ToolsApiService } from '../../../../../../../libs/data-access/gn4/src'\nimport { catchError, map, shareReplay } from 'rxjs/operators'\nimport { Injector } from '@angular/core'\nimport { TranslateService } from '@ngx-translate/core'\nimport { marker } from '@biesbjerg/ngx-translate-extract-marker'\nimport { OrganizationsServiceInterface } from '../../../../../../../libs/common/domain/src/lib/organizations.service.interface'\nimport {\n  AggregationBuckets,\n  AggregationsParams,\n  FieldFilterByExpression,\n  FieldFilters,\n  TermBucket,\n} from '../../../../../../../libs/common/domain/src/lib/search'\nimport { RecordsRepositoryInterface } from '../../../../../../../libs/common/domain/src/lib/records-repository.interface'\nimport { ElasticsearchService } from '../../../../../../../libs/api/repository/src/lib/gn4'\n\nexport type FieldValue = string | number\nexport interface FieldAvailableValue {\n  value: FieldValue\n  label: string\n}\n\nexport abstract class AbstractSearchField {\n  abstract getAvailableValues(): Observable<FieldAvailableValue[]>\n  abstract getFiltersForValues(values: FieldValue[]): Observable<FieldFilters>\n  abstract getValuesForFilter(filters: FieldFilters): Observable<FieldValue[]>\n}\n\nexport class SimpleSearchField implements AbstractSearchField {\n  protected repository = this.injector.get(RecordsRepositoryInterface)\n\n  // FIXME: this is required to register runtime fields; abstract this as well\n  protected esService = this.injector.get(ElasticsearchService)\n\n  constructor(\n    protected esFieldName: string,\n    protected order: 'asc' | 'desc' = 'asc',\n    protected injector: Injector\n  ) {}\n\n  protected getAggregations(): AggregationsParams {\n    return {\n      [this.esFieldName]: {\n        type: 'terms',\n        field: this.esFieldName,\n        limit: 1000,\n        sort: [this.order, 'key'],\n      },\n    }\n  }\n\n  protected async getBucketLabel(bucket: TermBucket): Promise<string> {\n    return bucket.term as string\n  }\n\n  getAvailableValues(): Observable<FieldAvailableValue[]> {\n    return this.repository.aggregate(this.getAggregations()).pipe(\n      map(\n        (response) =>\n          (response[this.esFieldName] as AggregationBuckets).buckets || []\n      ),\n      switchMap((buckets: TermBucket[]) => {\n        const bucketPromises = buckets.map(async (bucket) => ({\n          label: `${await this.getBucketLabel(bucket)} (${bucket.count})`,\n          value: bucket.term.toString(),\n        }))\n        return Promise.all(bucketPromises)\n      })\n    )\n  }\n  getFiltersForValues(values: FieldValue[]): Observable<FieldFilters> {\n    return of({\n      [this.esFieldName]: values.reduce((acc, val) => {\n        return { ...acc, [val.toString()]: true }\n      }, {}),\n    })\n  }\n  getValuesForFilter(filters: FieldFilters): Observable<FieldValue[]> {\n    const filter = filters[this.esFieldName]\n    if (!filter) return of([])\n    const values =\n      typeof filter === 'string'\n        ? [filter]\n        : Object.keys(filter).filter((v) => filter[v])\n    return of(values)\n  }\n}\n\nexport class GnUiTranslationSearchField extends SimpleSearchField {\n  private toolsApiService = this.injector.get(ToolsApiService)\n  allTranslations = this.toolsApiService.getTranslationsPackage1('gnui').pipe(\n    catchError(() => {\n      console.warn('Error while loading gnui language package')\n      return of({})\n    }),\n    shareReplay(1)\n  )\n\n  constructor(\n    esFieldName: string,\n    order: 'asc' | 'desc' = 'asc',\n    injector: Injector\n  ) {\n    super(esFieldName, order, injector)\n  }\n\n  private async getTranslation(topicKey: string) {\n    return firstValueFrom(\n      this.allTranslations.pipe(map((translations) => translations[topicKey]))\n    )\n  }\n\n  protected async getBucketLabel(bucket: TermBucket) {\n    return (await this.getTranslation(bucket.term)) || bucket.term\n  }\n\n  getAvailableValues(): Observable<FieldAvailableValue[]> {\n    // sort values by alphabetical order\n    return super\n      .getAvailableValues()\n      .pipe(\n        map((values) =>\n          values.sort((a, b) => new Intl.Collator().compare(a.label, b.label))\n        )\n      )\n  }\n}\n\nexport class FullTextSearchField implements AbstractSearchField {\n  getAvailableValues(): Observable<FieldAvailableValue[]> {\n    return of([])\n  }\n  getFiltersForValues(values: FieldValue[]): Observable<FieldFilters> {\n    return of({\n      any: values[0] as string,\n    })\n  }\n  getValuesForFilter(filters: FieldFilters): Observable<FieldValue[]> {\n    return of(filters.any ? [filters.any as FieldFilterByExpression] : [])\n  }\n}\n\nmarker('search.filters.isSpatial.yes')\nmarker('search.filters.isSpatial.no')\n\nexport class IsSpatialSearchField extends SimpleSearchField {\n  private translateService = this.injector.get(TranslateService)\n\n  constructor(injector: Injector) {\n    super('isSpatial', 'asc', injector)\n    this.esService.registerRuntimeField(\n      'isSpatial',\n      `String result = 'no';\nString formats = doc.format.join('|').toLowerCase();\nif (formats.contains('geojson') || formats.contains('arcgis') || formats.contains('ogc') || formats.contains('shp')) result = 'yes';\nString protocols = doc.linkProtocol.join('|').toLowerCase();\nif (protocols.contains('esri') || protocols.contains('ogc')) result = 'yes';\nemit(result);`\n    )\n  }\n\n  protected getAggregations(): AggregationsParams {\n    return {\n      isSpatial: {\n        type: 'terms',\n        limit: 2,\n        field: 'isSpatial',\n        sort: ['asc', 'key'],\n      },\n    }\n  }\n\n  protected async getBucketLabel(bucket: TermBucket) {\n    return firstValueFrom(\n      this.translateService.get(`search.filters.isSpatial.${bucket.term}`)\n    )\n  }\n\n  getFiltersForValues(values: FieldValue[]): Observable<FieldFilters> {\n    const isSpatial = {}\n    if (values.length > 0) isSpatial[values[values.length - 1]] = true\n    return of({\n      isSpatial,\n    })\n  }\n\n  getValuesForFilter(filters: FieldFilters): Observable<FieldValue[]> {\n    const filter = filters.isSpatial\n    if (!filter) return of([])\n    const keys = Object.keys(filter)\n    return of(keys.length ? [keys[0]] : [])\n  }\n}\n\nmarker('search.filters.license.pddl')\nmarker('search.filters.license.odbl')\nmarker('search.filters.license.odc-by')\nmarker('search.filters.license.cc-by-sa')\nmarker('search.filters.license.cc-by')\nmarker('search.filters.license.cc-zero')\nmarker('search.filters.license.etalab-v2')\nmarker('search.filters.license.etalab')\nmarker('search.filters.license.unknown')\n\n// Note: values are inspired from https://doc.data.gouv.fr/moissonnage/licences/\nexport class LicenseSearchField extends SimpleSearchField {\n  private translateService = this.injector.get(TranslateService)\n\n  constructor(injector: Injector) {\n    super('license', 'asc', injector)\n    this.esService.registerRuntimeField(\n      'license',\n      `String raw = '';\nif (doc.containsKey('licenseObject.default.keyword') && doc['licenseObject.default.keyword'].length > 0)\n  raw += doc['licenseObject.default.keyword'].join('|').toLowerCase();\nif (doc.containsKey('MD_LegalConstraintsUseLimitationObject.default.keyword') && doc['MD_LegalConstraintsUseLimitationObject.default.keyword'].length > 0)\n  raw += doc['MD_LegalConstraintsUseLimitationObject.default.keyword'].join('|').toLowerCase();\n\nboolean unknown = true;\nif (raw.contains('pddl') || raw.contains('public domain dedication and licence')) {\n  unknown = false;\n  emit('pddl');\n}\nif (raw.contains('odbl') || raw.contains('open database license')) {\n  unknown = false;\n  emit('odbl');\n}\nif (raw.contains('odc-by') || raw.contains('opendatacommons.org/licenses/by/summary/\"')) {\n  unknown = false;\n  emit('odc-by');\n}\n\nif (raw.contains('cc-by-sa') || raw.contains('creative commons attribution share-alike')) {\n  unknown = false;\n  emit('cc-by-sa');\n} else if (raw.contains('cc-by') || raw.contains('cc by') || raw.contains('creative commons attribution')) {\n  unknown = false;\n  emit('cc-by');\n} else if (raw.contains('cc0') || raw.contains('cc-0') || raw.contains('cczero') || raw.contains('cc-zero')) {\n  unknown = false;\n  emit('cc-zero');\n}\n\nif (raw.contains('etalab') && (raw.contains('v2') || raw.contains('2.0'))) {\n  unknown = false;\n  emit('etalab-v2');\n} else if (raw.contains('open licence') || raw.contains('licence ouverte') || raw.contains('licence_ouverte')) {\n  unknown = false;\n  emit('etalab');\n}\n\nif(unknown) emit('unknown');`\n    )\n  }\n\n  protected getAggregations(): AggregationsParams {\n    return {\n      license: {\n        type: 'terms',\n        limit: 10,\n        field: 'license',\n        sort: ['desc', 'count'],\n      },\n    }\n  }\n\n  protected async getBucketLabel(bucket: TermBucket) {\n    return firstValueFrom(\n      this.translateService.get(`search.filters.license.${bucket.term}`)\n    )\n  }\n}\n\n// This will use the OrganizationsServiceInterface\n// Field values are the organization names\nexport class OrganizationSearchField implements AbstractSearchField {\n  private orgsService = this.injector.get(OrganizationsServiceInterface)\n\n  constructor(private injector: Injector) {}\n\n  getFiltersForValues(values: FieldValue[]): Observable<FieldFilters> {\n    return this.orgsService.organisations$.pipe(\n      map((orgs) =>\n        values\n          .map((name) => orgs.find((org) => org.name === name))\n          .filter((org) => org !== undefined)\n      ),\n      switchMap((selectedOrgs) =>\n        this.orgsService.getFiltersForOrgs(selectedOrgs)\n      )\n    )\n  }\n\n  getValuesForFilter(filters: FieldFilters): Observable<FieldValue[]> {\n    return this.orgsService\n      .getOrgsFromFilters(filters)\n      .pipe(map((orgs) => orgs.map((org) => org.name)))\n  }\n\n  getAvailableValues(): Observable<FieldAvailableValue[]> {\n    // sort values by alphabetical order\n    return this.orgsService.organisations$.pipe(\n      map((organisations) =>\n        organisations.map((org) => ({\n          label: `${org.name} (${org.recordCount})`,\n          value: org.name,\n        }))\n      ),\n      map((values) =>\n        values.sort((a, b) => new Intl.Collator().compare(a.label, b.label))\n      )\n    )\n  }\n}\n"]}

package/esm2022/libs/feature/search/src/lib/utils/service/fields.service.mjs

@@ -0,0 +1,73 @@
+import { Injectable, Injector } from '@angular/core';
+import { GnUiTranslationSearchField, FullTextSearchField, IsSpatialSearchField, LicenseSearchField, OrganizationSearchField, SimpleSearchField, } from './fields';
+import { forkJoin, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { marker } from '@biesbjerg/ngx-translate-extract-marker';
+import * as i0 from "@angular/core";
+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');
+export class FieldsService {
+    get supportedFields() {
+        return Object.keys(this.fields);
+    }
+    constructor(injector) {
+        this.injector = injector;
+        this.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),
+        };
+    }
+    getAvailableValues(fieldName) {
+        if (this.supportedFields.indexOf(fieldName) === -1)
+            throw new Error(`Unsupported search field: ${fieldName}`);
+        return this.fields[fieldName].getAvailableValues();
+    }
+    getFiltersForValues(fieldName, values) {
+        return this.fields[fieldName].getFiltersForValues(values);
+    }
+    getValuesForFilters(fieldName, filters) {
+        return this.fields[fieldName].getValuesForFilter(filters);
+    }
+    buildFiltersFromFieldValues(fieldValues) {
+        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);
+        });
+        return forkJoin(filtersByField$).pipe(map((filters) => filters.reduce((prev, curr) => ({ ...prev, ...curr }), {})));
+    }
+    readFieldValuesFromFilters(filters) {
+        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 }), {})));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FieldsService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FieldsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FieldsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fields.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/feature/search/src/lib/utils/service/fields.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector } from '@angular/core'\nimport {\n  AbstractSearchField,\n  GnUiTranslationSearchField,\n  FieldValue,\n  FullTextSearchField,\n  IsSpatialSearchField,\n  LicenseSearchField,\n  OrganizationSearchField,\n  SimpleSearchField,\n} from './fields'\nimport { forkJoin, Observable, of } from 'rxjs'\nimport { map } from 'rxjs/operators'\nimport { FieldFilters } from '../../../../../../../libs/common/domain/src/lib/search'\nimport { marker } from '@biesbjerg/ngx-translate-extract-marker'\n\n// key is the field name\nexport type FieldValues = Record<string, FieldValue[] | FieldValue>\n\nmarker('search.filters.format')\nmarker('search.filters.inspireKeyword')\nmarker('search.filters.isSpatial')\nmarker('search.filters.license')\nmarker('search.filters.publicationYear')\nmarker('search.filters.publisher')\nmarker('search.filters.representationType')\nmarker('search.filters.resourceType')\nmarker('search.filters.standard')\nmarker('search.filters.topic')\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class FieldsService {\n  private fields = {\n    publisher: new OrganizationSearchField(this.injector),\n    format: new SimpleSearchField('format', 'asc', this.injector),\n    resourceType: new GnUiTranslationSearchField(\n      'resourceType',\n      'asc',\n      this.injector\n    ),\n    representationType: new GnUiTranslationSearchField(\n      'cl_spatialRepresentationType.key',\n      'asc',\n      this.injector\n    ),\n    publicationYear: new SimpleSearchField(\n      'publicationYearForResource',\n      'desc',\n      this.injector\n    ),\n    topic: new GnUiTranslationSearchField('cl_topic.key', 'asc', this.injector),\n    inspireKeyword: new SimpleSearchField(\n      'th_httpinspireeceuropaeutheme-theme_tree.default',\n      'asc',\n      this.injector\n    ),\n    documentStandard: new SimpleSearchField(\n      'documentStandard',\n      'asc',\n      this.injector\n    ),\n    isSpatial: new IsSpatialSearchField(this.injector),\n    q: new FullTextSearchField(),\n    license: new LicenseSearchField(this.injector),\n  } as Record<string, AbstractSearchField>\n\n  get supportedFields() {\n    return Object.keys(this.fields)\n  }\n\n  constructor(private injector: Injector) {}\n\n  getAvailableValues(fieldName: string) {\n    if (this.supportedFields.indexOf(fieldName) === -1)\n      throw new Error(`Unsupported search field: ${fieldName}`)\n    return this.fields[fieldName].getAvailableValues()\n  }\n\n  private getFiltersForValues(fieldName: string, values: FieldValue[]) {\n    return this.fields[fieldName].getFiltersForValues(values)\n  }\n  private getValuesForFilters(fieldName: string, filters: FieldFilters) {\n    return this.fields[fieldName].getValuesForFilter(filters)\n  }\n\n  buildFiltersFromFieldValues(\n    fieldValues: FieldValues\n  ): Observable<FieldFilters> {\n    const fieldNames = Object.keys(fieldValues).filter((fieldName) =>\n      this.supportedFields.includes(fieldName)\n    )\n    if (!fieldNames.length) return of({})\n    const filtersByField$ = fieldNames.map((fieldName) => {\n      const values = Array.isArray(fieldValues[fieldName])\n        ? fieldValues[fieldName]\n        : [fieldValues[fieldName]]\n      return this.getFiltersForValues(fieldName, values as FieldValue[])\n    })\n    return forkJoin(filtersByField$).pipe(\n      map((filters) =>\n        filters.reduce((prev, curr) => ({ ...prev, ...curr }), {})\n      )\n    )\n  }\n\n  readFieldValuesFromFilters(filters: FieldFilters): Observable<FieldValues> {\n    const fieldValues$ = this.supportedFields.map((fieldName) =>\n      this.getValuesForFilters(fieldName, filters).pipe(\n        map((values) => ({ [fieldName]: values }))\n      )\n    )\n    return forkJoin(fieldValues$).pipe(\n      map((fieldValues) =>\n        fieldValues.reduce((prev, curr) => ({ ...prev, ...curr }), {})\n      )\n    )\n  }\n}\n"]}