geonetwork-ui 2.1.0-initial

package/esm2022/libs/api/repository/src/lib/gn4/elasticsearch/elasticsearch.service.mjs

@@ -0,0 +1,444 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { ES_QUERY_FIELDS_PRIORITY, ES_SOURCE_SUMMARY, } from './constant';
+import { METADATA_LANGUAGE } from '../../metadata-language';
+import { LangService } from '../../../../../../../libs/util/i18n/src';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../../../libs/util/i18n/src";
+export class ElasticsearchService {
+    constructor(langService, metadataLang) {
+        this.langService = langService;
+        this.metadataLang = metadataLang;
+        // runtime fields are computed using a Painless script
+        // see: https://www.elastic.co/guide/en/elasticsearch/reference/current/runtime-mapping-fields.html
+        this.runtimeFields = {};
+        this.lang3 = this.langService.iso3;
+    }
+    getSearchRequestBody(aggregations = {}, size = 0, from = 0, sortBy = null, requestFields = [], searchFilters = {}, configFilters = {}, uuids, geometry) {
+        const payload = {
+            aggregations,
+            from,
+            size,
+            sort: this.buildPayloadSort(sortBy),
+            query: this.buildPayloadQuery(searchFilters, configFilters, uuids, geometry),
+            ...(size > 0 ? { track_total_hits: true } : {}),
+            _source: requestFields,
+        };
+        this.processRuntimeFields(payload);
+        return payload;
+    }
+    // payload object will be mutated
+    processRuntimeFields(payload) {
+        const addMapping = (fieldName) => {
+            if (!payload.runtime_mappings)
+                payload.runtime_mappings = {};
+            payload.runtime_mappings[fieldName] = {
+                type: 'keyword',
+                script: this.runtimeFields[fieldName],
+            };
+        };
+        const lookForField = (node) => {
+            if (Array.isArray(node)) {
+                node.forEach(lookForField);
+                return;
+            }
+            if (typeof node !== 'object')
+                return;
+            if ('field' in node && typeof node.field === 'string') {
+                if (node.field in this.runtimeFields) {
+                    addMapping(node.field);
+                }
+            }
+            for (const runtimeField in this.runtimeFields) {
+                if (runtimeField in node &&
+                    (node[runtimeField] === 'asc' || node[runtimeField] === 'desc')) {
+                    addMapping(runtimeField);
+                }
+                if ('query' in node &&
+                    typeof node.query === 'string' &&
+                    node.query.indexOf(runtimeField + ':') > -1) {
+                    addMapping(runtimeField);
+                }
+            }
+            for (const key in node) {
+                if (typeof node[key] === 'object')
+                    lookForField(node[key]);
+            }
+        };
+        lookForField(payload.aggregations);
+        lookForField(payload.sort);
+        lookForField(payload.query);
+        return payload;
+    }
+    registerRuntimeField(fieldName, expression) {
+        this.runtimeFields[fieldName] = expression;
+    }
+    getMetadataByIdPayload(uuid) {
+        return {
+            query: {
+                ids: {
+                    values: [uuid],
+                },
+            },
+        };
+    }
+    getRelatedRecordPayload(title, uuid, size = 6, _source = ES_SOURCE_SUMMARY) {
+        return {
+            query: {
+                bool: {
+                    must: [
+                        {
+                            more_like_this: {
+                                fields: [
+                                    'resourceTitleObject.default',
+                                    'resourceAbstractObject.default',
+                                    'tag.raw',
+                                ],
+                                like: title,
+                                min_term_freq: 1,
+                                max_query_terms: 12,
+                            },
+                        },
+                        {
+                            terms: {
+                                isTemplate: ['n'],
+                            },
+                        },
+                        {
+                            terms: {
+                                draft: ['n', 'e'],
+                            },
+                        },
+                    ],
+                    must_not: [{ wildcard: { uuid: uuid } }],
+                },
+            },
+            size,
+            _source,
+        };
+    }
+    buildPayloadSort(sortBy) {
+        if (sortBy === null)
+            return undefined;
+        const fields = Array.isArray(sortBy[0]) ? sortBy : [sortBy];
+        return fields.map((field) => ({ [field[1]]: field[0] }));
+    }
+    injectLangInQueryStringFields(queryFieldsPriority) {
+        const queryLang = this.getQueryLang();
+        return Object.keys(queryFieldsPriority).reduce((query, field) => {
+            const multiLangRegExp = /\$\{searchLang\}/g;
+            const isMultilangField = multiLangRegExp.test(field);
+            const fieldPriority = queryFieldsPriority[field];
+            return [
+                ...query,
+                ...(this.isCurrentSearchLang() && isMultilangField
+                    ? [
+                        `${field.replace(multiLangRegExp, queryLang)}^${fieldPriority + 10}`,
+                        field.replace(multiLangRegExp, '*') +
+                            (fieldPriority > 1 ? `^${fieldPriority}` : ''),
+                    ]
+                    : [
+                        field.replace(multiLangRegExp, queryLang) +
+                            (fieldPriority > 1 ? `^${fieldPriority}` : ''),
+                    ]),
+            ];
+        }, []);
+    }
+    getQueryLang() {
+        if (this.metadataLang) {
+            return this.isCurrentSearchLang()
+                ? `lang${this.lang3}`
+                : `lang${this.metadataLang}`;
+        }
+        else
+            return '*';
+    }
+    isCurrentSearchLang() {
+        return this.metadataLang === 'current';
+    }
+    buildPayloadQuery({ any, ...fieldSearchFilters }, configFilters, uuids, geometry) {
+        const queryFilters = this.stateFiltersToQueryString(fieldSearchFilters);
+        const must = [this.queryFilterOnValues('isTemplate', 'n')];
+        const must_not = {
+            ...this.queryFilterOnValues('resourceType', [
+                'service',
+                'map',
+                'map/static',
+                'mapDigital',
+            ]),
+        };
+        const should = [];
+        if (any) {
+            must.push({
+                query_string: {
+                    query: this.escapeSpecialCharacters(any),
+                    default_operator: 'AND',
+                    fields: this.injectLangInQueryStringFields(ES_QUERY_FIELDS_PRIORITY),
+                },
+            });
+        }
+        if (queryFilters) {
+            must.push({
+                query_string: {
+                    query: queryFilters,
+                },
+            });
+        }
+        if (uuids) {
+            must.push({
+                ids: {
+                    values: uuids,
+                },
+            });
+        }
+        if (geometry) {
+            should.push({
+                geo_shape: {
+                    geom: {
+                        shape: geometry,
+                        relation: 'within',
+                    },
+                    boost: 10.0,
+                },
+            }, {
+                geo_shape: {
+                    geom: {
+                        shape: geometry,
+                        relation: 'intersects',
+                    },
+                    boost: 7.0,
+                },
+            });
+        }
+        return {
+            bool: {
+                must,
+                must_not,
+                should,
+                filter: [],
+            },
+        };
+    }
+    buildMoreOnAggregationPayload(aggregations, key, searchFilters, configFilters) {
+        return {
+            aggregations: { [key]: aggregations[key] },
+            size: 0,
+            query: this.buildPayloadQuery(searchFilters, configFilters),
+        };
+    }
+    queryFilterOnValues(key, values) {
+        return !values || values.length <= 0
+            ? {}
+            : {
+                terms: {
+                    [key]: [...values],
+                },
+            };
+    }
+    buildAutocompletePayload(query) {
+        return {
+            query: {
+                bool: {
+                    must: [
+                        this.queryFilterOnValues('isTemplate', 'n'),
+                        {
+                            multi_match: {
+                                query,
+                                type: 'bool_prefix',
+                                fields: this.injectLangInQueryStringFields({
+                                    'resourceTitleObject.${searchLang}': 4,
+                                    'resourceAbstractObject.${searchLang}': 3,
+                                    tag: 2,
+                                    resourceIdentifier: 1,
+                                }),
+                            },
+                        },
+                    ],
+                    must_not: {
+                        ...this.queryFilterOnValues('resourceType', [
+                            'service',
+                            'map',
+                            'map/static',
+                            'mapDigital',
+                        ]),
+                    },
+                },
+            },
+            _source: ['resourceTitleObject', 'uuid'],
+            from: 0,
+            size: 20,
+        };
+    }
+    combineQueryGroups(queryGroups) {
+        return queryGroups ? queryGroups.join(' AND ').trim() : '';
+    }
+    /**
+     * Facets state is an object like this:
+     *
+     * {
+     *   'tag': {
+     *     'world': true,
+     *     'vector': true
+     *   },
+     *   'availableInService' : {
+     *     'availableInViewService': '+linkProtocol:\/OGC:WMS.*\/'
+     *   },
+     *   'resourceType': {
+     *     'service': {
+     *       'serviceType': {
+     *         'OGC:WMS': true
+     *         'OGC:WFS': false
+     *       }
+     *     },
+     *     'download': {
+     *       'serviceType': {
+     *       }
+     *     },
+     *     'dataset': true
+     *   }
+     * }
+     */
+    stateFiltersToQueryString(facetsState) {
+        const query = [];
+        for (const indexKey in facetsState) {
+            if (indexKey in facetsState) {
+                const queryChunk = this.parseStateNode(indexKey, facetsState[indexKey], undefined);
+                if (queryChunk) {
+                    query.push(queryChunk);
+                }
+            }
+        }
+        return this.combineQueryGroups(query);
+    }
+    parseStateNode(nodeName, node, indexKey) {
+        let queryString = '';
+        if (node && typeof node === 'object') {
+            const chunks = [];
+            for (const p in node) {
+                // nesting
+                if (node[p] && typeof node[p] === 'object') {
+                    const nextLvlKey = Object.keys(node[p])[0];
+                    const nextLvlState = node[p][nextLvlKey];
+                    if (Object.keys(nextLvlState).length) {
+                        const nestedChunks = [nodeName + ':' + '"' + p + '"'];
+                        const chunk = this.parseStateNode(nextLvlKey, nextLvlState, nextLvlKey).trim();
+                        if (chunk) {
+                            nestedChunks.push(chunk);
+                        }
+                        chunks.push('(' + nestedChunks.join(' AND ') + ')');
+                    }
+                }
+                else {
+                    const chunk = this.parseStateNode(p, node[p], nodeName).trim();
+                    if (chunk) {
+                        chunks.push(chunk);
+                    }
+                }
+            }
+            if (chunks && chunks.length) {
+                queryString += '(';
+                queryString += chunks.join(' ');
+                queryString += ')';
+            }
+        }
+        else if (typeof node === 'string') {
+            queryString += node;
+        }
+        else if (node === true) {
+            queryString += indexKey + ':"' + nodeName + '"';
+        }
+        else if (node === false) {
+            queryString += '-' + indexKey + ':"' + nodeName + '"';
+        }
+        return queryString;
+    }
+    escapeSpecialCharacters(querystring) {
+        return querystring.replace(/(\+|-|\/|&&|\|\||!|\{|\}|\[|\]\^|~|\?|:|\\{1}|\(|\))/g, '\\$1');
+    }
+    buildAggregationsPayload(aggregations) {
+        const mapFilterAggregation = (filterAgg) => ({
+            match: filterAgg,
+        });
+        const mapToESAggregation = (aggregation) => {
+            switch (aggregation.type) {
+                case 'filters':
+                    return {
+                        filters: Object.keys(aggregation.filters).reduce((prev, curr) => ({
+                            ...prev,
+                            [curr]: mapFilterAggregation(aggregation.filters[curr]),
+                        }), {}),
+                    };
+                case 'terms':
+                    return {
+                        terms: {
+                            size: aggregation.limit,
+                            field: aggregation.field,
+                            order: {
+                                [`_${aggregation.sort[1]}`]: aggregation.sort[0],
+                            },
+                        },
+                    };
+                case 'histogram':
+                    return {
+                        histogram: {
+                            field: aggregation.field,
+                            interval: aggregation.interval,
+                        },
+                    };
+            }
+        };
+        return Object.keys(aggregations).reduce((prev, curr) => ({
+            ...prev,
+            [curr]: mapToESAggregation(aggregations[curr]),
+        }), {});
+    }
+    parseAggregationResult(result, requestParam) {
+        switch (requestParam.type) {
+            case 'filters':
+                return {
+                    buckets: Object.keys(result.buckets).map((key) => {
+                        const bucket = result.buckets[key];
+                        return {
+                            term: key,
+                            count: bucket.doc_count,
+                        };
+                    }),
+                };
+            case 'terms':
+                return {
+                    buckets: result.buckets.map((bucket) => ({
+                        term: bucket.key,
+                        count: bucket.doc_count,
+                    })),
+                };
+            case 'histogram': {
+                const histogramResult = result;
+                let buckets = Array.isArray(histogramResult.buckets)
+                    ? histogramResult.buckets
+                    : Object.keys(histogramResult.buckets).map((key) => histogramResult.buckets[key]);
+                buckets = buckets.map((bucket, index) => ({
+                    lowValue: bucket.key,
+                    highValue: buckets[index + 1]?.key,
+                    count: bucket.doc_count,
+                }));
+                buckets.pop(); // see above
+                return {
+                    buckets,
+                };
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: ElasticsearchService, deps: [{ token: i1.LangService }, { token: METADATA_LANGUAGE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: ElasticsearchService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: ElasticsearchService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LangService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [METADATA_LANGUAGE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"elasticsearch.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/api/repository/src/lib/gn4/elasticsearch/elasticsearch.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core'\nimport { Geometry } from 'geojson'\nimport {\n  ES_QUERY_FIELDS_PRIORITY,\n  ES_SOURCE_SUMMARY,\n  EsQueryFieldsPriorityType,\n} from './constant'\nimport {\n  Aggregation,\n  AggregationParams,\n  AggregationsParams,\n  FilterAggregationParams,\n  SortByField,\n} from '../../../../../../../libs/common/domain/src/lib/search'\nimport { METADATA_LANGUAGE } from '../../metadata-language'\nimport {\n  AggregationResult,\n  EsSearchParams,\n  FiltersAggregationResult,\n  HistogramAggregationResult,\n  RequestFields,\n  SearchFilters,\n  SortParams,\n  TermsAggregationResult,\n} from '../../../../../../../libs/api/metadata-converter/src'\nimport { LangService } from '../../../../../../../libs/util/i18n/src'\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ElasticsearchService {\n  // runtime fields are computed using a Painless script\n  // see: https://www.elastic.co/guide/en/elasticsearch/reference/current/runtime-mapping-fields.html\n  private runtimeFields: Record<string, string> = {}\n  private lang3 = this.langService.iso3\n\n  constructor(\n    private langService: LangService,\n    @Optional() @Inject(METADATA_LANGUAGE) private metadataLang: string\n  ) {}\n\n  getSearchRequestBody(\n    aggregations: any = {},\n    size = 0,\n    from = 0,\n    sortBy: SortByField = null,\n    requestFields: RequestFields = [],\n    searchFilters: SearchFilters = {},\n    configFilters: SearchFilters = {},\n    uuids?: string[],\n    geometry?: Geometry\n  ): EsSearchParams {\n    const payload = {\n      aggregations,\n      from,\n      size,\n      sort: this.buildPayloadSort(sortBy),\n      query: this.buildPayloadQuery(\n        searchFilters,\n        configFilters,\n        uuids,\n        geometry\n      ),\n      ...(size > 0 ? { track_total_hits: true } : {}),\n      _source: requestFields,\n    }\n    this.processRuntimeFields(payload)\n    return payload\n  }\n\n  // payload object will be mutated\n  private processRuntimeFields(payload: EsSearchParams): EsSearchParams {\n    const addMapping = (fieldName: string) => {\n      if (!payload.runtime_mappings) payload.runtime_mappings = {}\n      payload.runtime_mappings[fieldName] = {\n        type: 'keyword',\n        script: this.runtimeFields[fieldName],\n      }\n    }\n    const lookForField = (node: unknown) => {\n      if (Array.isArray(node)) {\n        node.forEach(lookForField)\n        return\n      }\n      if (typeof node !== 'object') return\n      if ('field' in node && typeof node.field === 'string') {\n        if (node.field in this.runtimeFields) {\n          addMapping(node.field)\n        }\n      }\n      for (const runtimeField in this.runtimeFields) {\n        if (\n          runtimeField in node &&\n          (node[runtimeField] === 'asc' || node[runtimeField] === 'desc')\n        ) {\n          addMapping(runtimeField)\n        }\n        if (\n          'query' in node &&\n          typeof node.query === 'string' &&\n          node.query.indexOf(runtimeField + ':') > -1\n        ) {\n          addMapping(runtimeField)\n        }\n      }\n      for (const key in node) {\n        if (typeof node[key] === 'object') lookForField(node[key])\n      }\n    }\n    lookForField(payload.aggregations)\n    lookForField(payload.sort)\n    lookForField(payload.query)\n    return payload\n  }\n\n  registerRuntimeField(fieldName: string, expression: string) {\n    this.runtimeFields[fieldName] = expression\n  }\n\n  getMetadataByIdPayload(uuid: string): EsSearchParams {\n    return {\n      query: {\n        ids: {\n          values: [uuid],\n        },\n      },\n    }\n  }\n\n  getRelatedRecordPayload(\n    title: string,\n    uuid: string,\n    size = 6,\n    _source = ES_SOURCE_SUMMARY\n  ): EsSearchParams {\n    return {\n      query: {\n        bool: {\n          must: [\n            {\n              more_like_this: {\n                fields: [\n                  'resourceTitleObject.default',\n                  'resourceAbstractObject.default',\n                  'tag.raw',\n                ],\n                like: title,\n                min_term_freq: 1,\n                max_query_terms: 12,\n              },\n            },\n            {\n              terms: {\n                isTemplate: ['n'],\n              },\n            },\n            {\n              terms: {\n                draft: ['n', 'e'],\n              },\n            },\n          ],\n          must_not: [{ wildcard: { uuid: uuid } }],\n        },\n      },\n      size,\n      _source,\n    }\n  }\n\n  private buildPayloadSort(sortBy: SortByField): SortParams {\n    if (sortBy === null) return undefined\n    const fields = Array.isArray(sortBy[0]) ? sortBy : [sortBy]\n    return fields.map((field) => ({ [field[1]]: field[0] }))\n  }\n\n  private injectLangInQueryStringFields(\n    queryFieldsPriority: EsQueryFieldsPriorityType\n  ) {\n    const queryLang = this.getQueryLang()\n    return Object.keys(queryFieldsPriority).reduce((query, field) => {\n      const multiLangRegExp = /\\$\\{searchLang\\}/g\n      const isMultilangField = multiLangRegExp.test(field)\n      const fieldPriority = queryFieldsPriority[field]\n      return [\n        ...query,\n        ...(this.isCurrentSearchLang() && isMultilangField\n          ? [\n              `${field.replace(multiLangRegExp, queryLang)}^${\n                fieldPriority + 10\n              }`,\n              field.replace(multiLangRegExp, '*') +\n                (fieldPriority > 1 ? `^${fieldPriority}` : ''),\n            ]\n          : [\n              field.replace(multiLangRegExp, queryLang) +\n                (fieldPriority > 1 ? `^${fieldPriority}` : ''),\n            ]),\n      ]\n    }, [])\n  }\n\n  private getQueryLang(): string {\n    if (this.metadataLang) {\n      return this.isCurrentSearchLang()\n        ? `lang${this.lang3}`\n        : `lang${this.metadataLang}`\n    } else return '*'\n  }\n  private isCurrentSearchLang() {\n    return this.metadataLang === 'current'\n  }\n\n  private buildPayloadQuery(\n    { any, ...fieldSearchFilters }: SearchFilters,\n    configFilters: SearchFilters,\n    uuids?: string[],\n    geometry?: Geometry\n  ) {\n    const queryFilters = this.stateFiltersToQueryString(fieldSearchFilters)\n    const must = [this.queryFilterOnValues('isTemplate', 'n')] as Record<\n      string,\n      unknown\n    >[]\n    const must_not = {\n      ...this.queryFilterOnValues('resourceType', [\n        'service',\n        'map',\n        'map/static',\n        'mapDigital',\n      ]),\n    }\n    const should = [] as Record<string, unknown>[]\n\n    if (any) {\n      must.push({\n        query_string: {\n          query: this.escapeSpecialCharacters(any),\n          default_operator: 'AND',\n          fields: this.injectLangInQueryStringFields(ES_QUERY_FIELDS_PRIORITY),\n        },\n      })\n    }\n    if (queryFilters) {\n      must.push({\n        query_string: {\n          query: queryFilters,\n        },\n      })\n    }\n    if (uuids) {\n      must.push({\n        ids: {\n          values: uuids,\n        },\n      })\n    }\n    if (geometry) {\n      should.push(\n        {\n          geo_shape: {\n            geom: {\n              shape: geometry,\n              relation: 'within',\n            },\n            boost: 10.0,\n          },\n        },\n        {\n          geo_shape: {\n            geom: {\n              shape: geometry,\n              relation: 'intersects',\n            },\n            boost: 7.0,\n          },\n        }\n      )\n    }\n\n    return {\n      bool: {\n        must,\n        must_not,\n        should,\n        filter: [],\n      },\n    }\n  }\n\n  buildMoreOnAggregationPayload(\n    aggregations: any,\n    key: string,\n    searchFilters: SearchFilters,\n    configFilters: SearchFilters\n  ): EsSearchParams {\n    return {\n      aggregations: { [key]: aggregations[key] },\n      size: 0,\n      query: this.buildPayloadQuery(searchFilters, configFilters),\n    }\n  }\n\n  queryFilterOnValues(key, values) {\n    return !values || values.length <= 0\n      ? {}\n      : {\n          terms: {\n            [key]: [...values],\n          },\n        }\n  }\n\n  buildAutocompletePayload(query: string): EsSearchParams {\n    return {\n      query: {\n        bool: {\n          must: [\n            this.queryFilterOnValues('isTemplate', 'n'),\n            {\n              multi_match: {\n                query,\n                type: 'bool_prefix',\n                fields: this.injectLangInQueryStringFields({\n                  'resourceTitleObject.${searchLang}': 4,\n                  'resourceAbstractObject.${searchLang}': 3,\n                  tag: 2,\n                  resourceIdentifier: 1,\n                }),\n              },\n            },\n          ],\n          must_not: {\n            ...this.queryFilterOnValues('resourceType', [\n              'service',\n              'map',\n              'map/static',\n              'mapDigital',\n            ]),\n          },\n        },\n      },\n      _source: ['resourceTitleObject', 'uuid'],\n      from: 0,\n      size: 20,\n    }\n  }\n\n  combineQueryGroups(queryGroups) {\n    return queryGroups ? queryGroups.join(' AND ').trim() : ''\n  }\n\n  /**\n   * Facets state is an object like this:\n   *\n   * {\n   *   'tag': {\n   *     'world': true,\n   *     'vector': true\n   *   },\n   *   'availableInService' : {\n   *     'availableInViewService': '+linkProtocol:\\/OGC:WMS.*\\/'\n   *   },\n   *   'resourceType': {\n   *     'service': {\n   *       'serviceType': {\n   *         'OGC:WMS': true\n   *         'OGC:WFS': false\n   *       }\n   *     },\n   *     'download': {\n   *       'serviceType': {\n   *       }\n   *     },\n   *     'dataset': true\n   *   }\n   * }\n   */\n  stateFiltersToQueryString(facetsState) {\n    const query = []\n    for (const indexKey in facetsState) {\n      if (indexKey in facetsState) {\n        const queryChunk = this.parseStateNode(\n          indexKey,\n          facetsState[indexKey],\n          undefined\n        )\n        if (queryChunk) {\n          query.push(queryChunk)\n        }\n      }\n    }\n    return this.combineQueryGroups(query)\n  }\n\n  private parseStateNode(nodeName, node, indexKey) {\n    let queryString = ''\n    if (node && typeof node === 'object') {\n      const chunks = []\n      for (const p in node) {\n        // nesting\n        if (node[p] && typeof node[p] === 'object') {\n          const nextLvlKey = Object.keys(node[p])[0]\n          const nextLvlState = node[p][nextLvlKey]\n          if (Object.keys(nextLvlState).length) {\n            const nestedChunks = [nodeName + ':' + '\"' + p + '\"']\n            const chunk = this.parseStateNode(\n              nextLvlKey,\n              nextLvlState,\n              nextLvlKey\n            ).trim()\n            if (chunk) {\n              nestedChunks.push(chunk)\n            }\n            chunks.push('(' + nestedChunks.join(' AND ') + ')')\n          }\n        } else {\n          const chunk = this.parseStateNode(p, node[p], nodeName).trim()\n          if (chunk) {\n            chunks.push(chunk)\n          }\n        }\n      }\n      if (chunks && chunks.length) {\n        queryString += '('\n        queryString += chunks.join(' ')\n        queryString += ')'\n      }\n    } else if (typeof node === 'string') {\n      queryString += node\n    } else if (node === true) {\n      queryString += indexKey + ':\"' + nodeName + '\"'\n    } else if (node === false) {\n      queryString += '-' + indexKey + ':\"' + nodeName + '\"'\n    }\n    return queryString\n  }\n\n  private escapeSpecialCharacters(querystring) {\n    return querystring.replace(\n      /(\\+|-|\\/|&&|\\|\\||!|\\{|\\}|\\[|\\]\\^|~|\\?|:|\\\\{1}|\\(|\\))/g,\n      '\\\\$1'\n    )\n  }\n\n  buildAggregationsPayload(aggregations: AggregationsParams): any {\n    const mapFilterAggregation = (filterAgg: FilterAggregationParams) => ({\n      match: filterAgg,\n    })\n    const mapToESAggregation = (aggregation: AggregationParams) => {\n      switch (aggregation.type) {\n        case 'filters':\n          return {\n            filters: Object.keys(aggregation.filters).reduce(\n              (prev, curr) => ({\n                ...prev,\n                [curr]: mapFilterAggregation(aggregation.filters[curr]),\n              }),\n              {}\n            ),\n          }\n        case 'terms':\n          return {\n            terms: {\n              size: aggregation.limit,\n              field: aggregation.field,\n              order: {\n                [`_${aggregation.sort[1]}`]: aggregation.sort[0],\n              },\n            },\n          }\n        case 'histogram':\n          return {\n            histogram: {\n              field: aggregation.field,\n              interval: aggregation.interval,\n            },\n          }\n      }\n    }\n    return Object.keys(aggregations).reduce(\n      (prev, curr) => ({\n        ...prev,\n        [curr]: mapToESAggregation(aggregations[curr]),\n      }),\n      {}\n    )\n  }\n\n  parseAggregationResult(\n    result: AggregationResult,\n    requestParam: AggregationParams\n  ): Aggregation {\n    switch (requestParam.type) {\n      case 'filters':\n        return {\n          buckets: Object.keys(\n            (result as FiltersAggregationResult).buckets\n          ).map((key) => {\n            const bucket = (result as FiltersAggregationResult).buckets[key]\n            return {\n              term: key,\n              count: bucket.doc_count,\n            }\n          }),\n        }\n      case 'terms':\n        return {\n          buckets: (result as TermsAggregationResult).buckets.map((bucket) => ({\n            term: bucket.key,\n            count: bucket.doc_count,\n          })),\n        }\n      case 'histogram': {\n        const histogramResult = result as HistogramAggregationResult\n        let buckets = Array.isArray(histogramResult.buckets)\n          ? histogramResult.buckets\n          : Object.keys(histogramResult.buckets).map(\n              (key) => histogramResult.buckets[key]\n            )\n        buckets = buckets.map((bucket, index) => ({\n          lowValue: bucket.key,\n          highValue: buckets[index + 1]?.key, // this will return undefined on the last element (which we remove later)\n          count: bucket.doc_count,\n        }))\n        buckets.pop() // see above\n        return {\n          buckets,\n        }\n      }\n    }\n  }\n}\n"]}

package/esm2022/libs/api/repository/src/lib/gn4/elasticsearch/index.mjs

@@ -0,0 +1,3 @@
+export * from './elasticsearch.service';
+export * from './constant';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FwaS9yZXBvc2l0b3J5L3NyYy9saWIvZ240L2VsYXN0aWNzZWFyY2gvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQTtBQUN2QyxjQUFjLFlBQVksQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZWxhc3RpY3NlYXJjaC5zZXJ2aWNlJ1xuZXhwb3J0ICogZnJvbSAnLi9jb25zdGFudCdcbiJdfQ==

package/esm2022/libs/api/repository/src/lib/gn4/favorites/favorites.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { merge, of, Subject, throwError } from 'rxjs';
+import { UserselectionsApiService } from '../../../../../../../libs/data-access/gn4/src';
+import { AuthService } from '../auth/auth.service';
+import { catchError, map, shareReplay, switchMap, take, tap, withLatestFrom, } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../../../libs/data-access/gn4/src";
+import * as i2 from "../auth/auth.service";
+const SELECTION_ID = 0; // hardcoded to always point on the first selection
+export class FavoritesService {
+    constructor(userSelectionsService, authService) {
+        this.userSelectionsService = userSelectionsService;
+        this.authService = authService;
+        this.myUserId$ = this.authService
+            .authReady()
+            .pipe(map((userInfo) => (userInfo ? parseInt(userInfo.id) : null)));
+        // this observable loads the current list of favorites from the API
+        this.myFavoritesUuidFromApi$ = this.myUserId$.pipe(switchMap((userId) => userId !== null
+            ? this.userSelectionsService.getSelectionRecords(SELECTION_ID, userId)
+            : of([]) // emit an empty array if the user is not authentified
+        ), catchError((e) => {
+            console.error(`An error occurred while fetching favorite records: ${e.message}`);
+            return of([]);
+        }));
+        this.modifiedFavorites$ = new Subject();
+        // favorites are loaded once from the API (from myFavoritesUuidFromApi$);
+        // subsequent emissions are caused by modifications of the favorite list
+        // on the client side (coming from modifiedFavorites$)
+        this.myFavoritesUuid$ = merge(this.myFavoritesUuidFromApi$, this.modifiedFavorites$).pipe(shareReplay(1) // new subscriptions should not trigger a new API request!
+        );
+    }
+    addToFavorites(uuids) {
+        return this.myFavoritesUuid$.pipe(take(1), withLatestFrom(this.myUserId$), tap(([, userId]) => {
+            if (userId === null)
+                throw new Error('not authenticated');
+        }), switchMap(([favorites, userId]) => this.userSelectionsService
+            .addToUserSelection(SELECTION_ID, userId, uuids)
+            .pipe(tap(() => this.emitAddedFavorites(favorites, uuids)))), map(() => undefined), catchError((e) => throwError(new Error(`An error occurred while adding records to favorites: ${e.message}`))));
+    }
+    removeFromFavorites(uuids) {
+        return this.myFavoritesUuid$.pipe(take(1), withLatestFrom(this.myUserId$), tap(([, userId]) => {
+            if (userId === null)
+                throw new Error('not authenticated');
+        }), switchMap(([favorites, userId]) => this.userSelectionsService
+            .deleteFromUserSelection(SELECTION_ID, userId, uuids)
+            .pipe(tap(() => this.emitRemovedFavorites(favorites, uuids)))), map(() => undefined), catchError((e) => throwError(new Error(`An error occurred while removing records from favorites: ${e.message}`))));
+    }
+    emitAddedFavorites(favorites, addedUuids) {
+        this.modifiedFavorites$.next([
+            ...favorites.filter((uuid) => addedUuids.indexOf(uuid) === -1),
+            ...addedUuids,
+        ]);
+    }
+    emitRemovedFavorites(favorites, removedUuids) {
+        this.modifiedFavorites$.next(favorites.filter((uuid) => removedUuids.indexOf(uuid) === -1));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FavoritesService, deps: [{ token: i1.UserselectionsApiService }, { token: i2.AuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FavoritesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: FavoritesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.UserselectionsApiService }, { type: i2.AuthService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"favorites.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/api/repository/src/lib/gn4/favorites/favorites.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport { merge, Observable, of, Subject, throwError } from 'rxjs'\nimport { UserselectionsApiService } from '../../../../../../../libs/data-access/gn4/src'\nimport { AuthService } from '../auth/auth.service'\nimport {\n  catchError,\n  map,\n  shareReplay,\n  switchMap,\n  take,\n  tap,\n  withLatestFrom,\n} from 'rxjs/operators'\n\nconst SELECTION_ID = 0 // hardcoded to always point on the first selection\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class FavoritesService {\n  private myUserId$ = this.authService\n    .authReady()\n    .pipe(map((userInfo) => (userInfo ? parseInt(userInfo.id) : null)))\n\n  // this observable loads the current list of favorites from the API\n  private myFavoritesUuidFromApi$: Observable<string[]> = this.myUserId$.pipe(\n    switchMap(\n      (userId) =>\n        userId !== null\n          ? this.userSelectionsService.getSelectionRecords(SELECTION_ID, userId)\n          : of([] as string[]) // emit an empty array if the user is not authentified\n    ),\n    catchError((e) => {\n      console.error(\n        `An error occurred while fetching favorite records: ${e.message}`\n      )\n      return of([])\n    })\n  )\n\n  private modifiedFavorites$ = new Subject<string[]>()\n\n  // favorites are loaded once from the API (from myFavoritesUuidFromApi$);\n  // subsequent emissions are caused by modifications of the favorite list\n  // on the client side (coming from modifiedFavorites$)\n  myFavoritesUuid$ = merge(\n    this.myFavoritesUuidFromApi$,\n    this.modifiedFavorites$\n  ).pipe(\n    shareReplay(1) // new subscriptions should not trigger a new API request!\n  )\n\n  constructor(\n    private userSelectionsService: UserselectionsApiService,\n    private authService: AuthService\n  ) {}\n\n  addToFavorites(uuids: string[]): Observable<void> {\n    return this.myFavoritesUuid$.pipe(\n      take(1),\n      withLatestFrom(this.myUserId$),\n      tap(([, userId]) => {\n        if (userId === null) throw new Error('not authenticated')\n      }),\n      switchMap(([favorites, userId]) =>\n        this.userSelectionsService\n          .addToUserSelection(SELECTION_ID, userId, uuids)\n          .pipe(tap(() => this.emitAddedFavorites(favorites, uuids)))\n      ),\n      map(() => undefined),\n      catchError((e) =>\n        throwError(\n          new Error(\n            `An error occurred while adding records to favorites: ${e.message}`\n          )\n        )\n      )\n    )\n  }\n\n  removeFromFavorites(uuids: string[]): Observable<void> {\n    return this.myFavoritesUuid$.pipe(\n      take(1),\n      withLatestFrom(this.myUserId$),\n      tap(([, userId]) => {\n        if (userId === null) throw new Error('not authenticated')\n      }),\n      switchMap(([favorites, userId]) =>\n        this.userSelectionsService\n          .deleteFromUserSelection(SELECTION_ID, userId, uuids)\n          .pipe(tap(() => this.emitRemovedFavorites(favorites, uuids)))\n      ),\n      map(() => undefined),\n      catchError((e) =>\n        throwError(\n          new Error(\n            `An error occurred while removing records from favorites: ${e.message}`\n          )\n        )\n      )\n    )\n  }\n\n  private emitAddedFavorites(favorites: string[], addedUuids: string[]) {\n    this.modifiedFavorites$.next([\n      ...favorites.filter((uuid) => addedUuids.indexOf(uuid) === -1),\n      ...addedUuids,\n    ])\n  }\n\n  private emitRemovedFavorites(favorites: string[], removedUuids: string[]) {\n    this.modifiedFavorites$.next(\n      favorites.filter((uuid) => removedUuids.indexOf(uuid) === -1)\n    )\n  }\n}\n"]}