@eo-sdk/client 10.7.0-rc.5 → 11.0.0-beta.1

package/esm2022/app/eo-framework-core/search/app-search.service.mjs

@@ -0,0 +1,387 @@
+import { from as observableFrom, BehaviorSubject, ReplaySubject } from 'rxjs';
+import { groupBy, reduce, mergeMap } from 'rxjs/operators';
+import { Injectable } from '@angular/core';
+import { SearchQuery, SearchState, EnaioEvent, Utils } from '@eo-sdk/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@eo-sdk/core";
+/**
+ * AppSearchService is the apps main entry point for searching (used by the appBarSearch component).
+ * It provides an `query$` observable components can subscribe to, to
+ * stay in touch with updates to the query.
+ */
+export class AppSearchService {
+    constructor(searchService, eventService, system) {
+        this.searchService = searchService;
+        this.eventService = eventService;
+        this.system = system;
+        this.query = new SearchQuery();
+        this.lastQuery = new SearchQuery();
+        this.queryState = new SearchState();
+        // Subject holding the current query (initial value is a new SearchQuery)
+        // @see: http://blog.angular-university.io/how-to-build-angular2-apps-using-rxjs-observable-data-services-pitfalls-to-avoid/#rxjssubjectandhowtouseit
+        // todo: maybe add support for holding a query history, so the user can reload older queries as well
+        this.querySource = new ReplaySubject(1);
+        this.queryStateSource = new BehaviorSubject(this.queryState);
+        // Expose an observable instead of the subject itself to prevent the service clients from
+        // themselves emitting store values directly instead of calling action methods, and therefore
+        // bypassing the store.
+        this.query$ = this.querySource.asObservable();
+        // Search service also exposes an observable that emits the state of the current query.
+        // We separate the state of the query from the query itself as otherwise changhing the queries
+        // state will trigger all subscribers of the query observale and lead to undesired behaviour
+        this.queryState$ = this.queryStateSource.asObservable();
+        this.objectTypeGroups = [];
+        this.typesAllowedUnderSysroot = [];
+        this.setDefaultAggs();
+        this.eventService.on(EnaioEvent.LOGOUT)
+            .subscribe(res => {
+            this.reset(true);
+        });
+        this.querySource.next(this.query);
+        // Fetch object types and groups that serve as search filter params.
+        // These groups are provided through the services `objectTypeGroups` property.
+        this.system.system$.subscribe((systemDefinition) => {
+            this.typesAllowedUnderSysroot = systemDefinition.types.filter(type => type.parenttypes.includes('sysroot'));
+            let groups = [];
+            observableFrom(systemDefinition.types)
+                .pipe(groupBy((type) => type.group || '0'), mergeMap(g => g.pipe(reduce((acc, curr) => [...acc, curr], []))))
+                .subscribe(otg => {
+                groups.push({
+                    label: otg[0].group || '0',
+                    types: this.sortObjectTypeGroup(otg)
+                });
+            });
+            this.objectTypeGroups = groups.sort(Utils.sortValues('label'));
+        });
+    }
+    resetAggs() {
+        this.setDefaultAggs();
+        this.lastAggCallComparator = null;
+    }
+    setDefaultAggs() {
+        this.aggs = {
+            type: {}
+        };
+    }
+    // helper method for sorting the entries of an object type group
+    sortObjectTypeGroup(types) {
+        return types.sort((a, b) => {
+            if (a.isContextFolder && !b.isContextFolder) {
+                return -1;
+            }
+            if (!a.isContextFolder && b.isContextFolder) {
+                return 1;
+            }
+            if (a.isFolder && !b.isFolder) {
+                return -1;
+            }
+            if (!a.isFolder && b.isFolder) {
+                return 1;
+            }
+            if (a.isFolder && b.isFolder) {
+                return Utils.sortValues('label').call(this, a, b);
+            }
+            return Utils.sortValues('label').call(this, a, b);
+        });
+    }
+    // Extends the objectTypesGroups by the elements for each object type
+    // Used in expert search mode
+    buildTypeGroupTree() {
+        let gTree = [];
+        let i = 0;
+        for (let group of this.objectTypeGroups) {
+            let g = {
+                id: i++,
+                label: group.label,
+                tree: []
+            };
+            let types = [];
+            for (let objectType of group.types) {
+                let t = {
+                    id: objectType.id,
+                    label: objectType.label,
+                    children: []
+                };
+                let children = [];
+                for (let el of objectType.elements) {
+                    children.push({
+                        label: el.label,
+                        type: el.type,
+                        data: el.qname
+                    });
+                }
+                // sort by label
+                t.children = children.sort(Utils.sortValues('label'));
+                types.push(t);
+            }
+            g.tree = types.sort(Utils.sortValues('label'));
+            gTree.push(g);
+        }
+        return gTree;
+    }
+    /**
+     * Override the current query by a different one.
+     * This could be done by for example loading a stored query.
+     *
+     * @param query - the query that should replace the current query, this may be either a SearchQuery instance,
+     * a JSON string of an object matching the search api
+     */
+    setQuery(query) {
+        if (this.isNewQuery(query)) {
+            this.setDefaultAggs();
+            this.query = query;
+            this.querySource.next(this.query);
+        }
+    }
+    /**
+     * Resets the current query.
+     */
+    clearQuery() {
+        this.setQuery(new SearchQuery());
+    }
+    isNewQuery(query) {
+        return JSON.stringify(query.getQueryJson()) !== JSON.stringify(this.query.getQueryJson());
+    }
+    /**
+     * toggles the searchmode from regular search to expert search and vice versa
+     */
+    toggleExpertMode() {
+        if (!this.query.expertMode) {
+            this.lastQuery = this.query;
+            this.setDefaultAggs();
+            this.query = new SearchQuery();
+            this.query.expertMode = true;
+        }
+        else {
+            this.query = this.lastQuery;
+        }
+        this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TOGGLED_EXPERTMODE;
+        this.querySource.next(this.query);
+        this.aggregate();
+    }
+    setTerm(term) {
+        this.query.term = term;
+        this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TERM_SET;
+        this.querySource.next(this.query);
+        this.aggregate();
+    }
+    setQueryScope(scope) {
+        this.query.scope = scope;
+        this.querySource.next(this.query);
+        this.aggregate();
+    }
+    // set aggregation properties to be applied to ONLY aggregate search queries
+    setAggs(aggs, extend = false) {
+        this.aggs = extend ? { ...this.aggs, ...aggs } : aggs;
+    }
+    /**
+     * Toggles a type filter.
+     * @param type - object type
+     */
+    toggleQueryType(type) {
+        this.query.toggleType(type);
+        this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TOGGLED_TYPE;
+        this.querySource.next(this.query);
+        this.aggregate(SearchQuery.BASE_PARAMS.TYPE);
+    }
+    /**
+     * Sets the queries target types.
+     *
+     * @param types - array of ObjectTypes
+     * @param silent If set to true aggregate won't be called
+     */
+    setQueryTypes(types, silent) {
+        this.query.types = types;
+        this.aggs = {
+            type: {
+                sub: {
+                    contextfoldertype: {}
+                }
+            }
+        };
+        this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TYPES_SET;
+        this.querySource.next(this.query);
+        if (!silent) {
+            this.aggregate();
+        }
+    }
+    /**
+     * Sets the queries target context type.
+     *
+     * @param type The context type to be set or null for resetting
+     * @param silent If set to true aggregate won't be called
+     */
+    setContextType(type, silent) {
+        if (this.query.contextFolderTypes.length && !type) {
+            // clear context folder
+            this.emitNewContextFolderType(null);
+        }
+        else if (this.query.contextFolderTypes.length && type.name !== this.query.contextFolderTypes[0].name) {
+            // got a type to be set up that differs from the current one
+            this.emitNewContextFolderType(type);
+        }
+        else if (!this.query.contextFolderTypes.length) {
+            // nothing set up so far
+            this.emitNewContextFolderType(type);
+        }
+        // trying to setup the same type as the current on should not emit a new value
+    }
+    emitNewContextFolderType(type, silent) {
+        if (!type && this.query.contextFolderTypes.length === 0) {
+            return;
+        }
+        this.aggs = {
+            type: {
+                sub: {
+                    contextfoldertype: {}
+                }
+            }
+        };
+        this.query.contextFolderTypes = type ? [type] : [];
+        this.query.__updateCause = SearchQuery.UPDATE_CAUSE.CONTEXT_FOLDER_SET;
+        this.querySource.next(this.query);
+        if (!silent) {
+            this.aggregate();
+        }
+    }
+    /**
+     * Toggles a created filter.
+     * @param filter - the filter to be toggled
+     */
+    toggleQueryFilter(filter, override) {
+        this.query.toggleFilter(filter, override);
+        this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TOGGLED_FILTER;
+        this.querySource.next(this.query);
+        this.aggregate(filter.property);
+    }
+    /**
+     * Toggles created filters and aggregates them together.
+     * @param filters - the filters to be toggled
+     */
+    toggleQueryFilters(filters, override) {
+        let baseParam = '';
+        filters.forEach(filter => {
+            this.query.toggleFilter(filter, override);
+            this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TOGGLED_FILTER;
+            baseParam += filter.property + ' ';
+        });
+        this.querySource.next(this.query);
+        this.aggregate(baseParam.trim());
+    }
+    /**
+     * Adds a filter to the query.
+     * @param filter - the filter to be added
+     */
+    addQueryFilter(filter) {
+        this.query.addFilter(filter);
+        this.query.__updateCause = SearchQuery.UPDATE_CAUSE.ADDED_FILTER;
+        this.querySource.next(this.query);
+        this.aggregate(filter.property);
+    }
+    /**
+     * Removes a filter to the query.
+     * @param filter - the filter to be removed
+     */
+    removeQueryFilter(filter) {
+        this.query.removeFilter(filter.property);
+        this.query.__updateCause = SearchQuery.UPDATE_CAUSE.REMOVED_FILTER;
+        this.querySource.next(this.query);
+        this.aggregate(filter.property);
+    }
+    /**
+     * Sets the filters for an indexdata search.
+     * Setting them will also remove all indexdata filters set before.
+     *
+     * @param filters - the filters to be set
+     * @param silent If set to true aggregate won't be called
+     */
+    setIndexSearchQueryFilters(filters, silent) {
+        // remove previous filters (all filters that are not baseparam filters)
+        this.query.filters = this.query.filters.filter((f) => this.isBaseParamFilter(f));
+        for (let f of filters) {
+            this.query.addFilter(f);
+        }
+        if (!silent) {
+            this.aggregate();
+        }
+    }
+    getIndexSearchQueryFilters(query) {
+        let q = query || this.query;
+        return q.filters.filter((f) => !this.isBaseParamFilter(f));
+    }
+    /**
+     * Determines whether or not the provided search filter belongs to a base param.
+     *
+     * @param filter - the filter to be checked
+     */
+    isBaseParamFilter(filter) {
+        //return Object.values(SearchQuery.BASE_PARAMS).some((bp) => filter.property === bp);
+        return Object.keys(SearchQuery.BASE_PARAMS).some((bpKey) => filter.property === SearchQuery.BASE_PARAMS[bpKey]);
+    }
+    /**
+     * Executes the current query as aggregate search
+     */
+    aggregate(baseParam = '') {
+        const aggQuery = { aggs: this.aggs, ...this.query.getQueryJson() };
+        // compare the call to be made with a former request
+        if (this.lastAggCallComparator !== JSON.stringify(aggQuery)) {
+            this.lastAggCallComparator = JSON.stringify(aggQuery);
+            this.getSearchState(aggQuery)
+                .subscribe((queryState) => {
+                queryState.lastChange = baseParam;
+                this.queryState = queryState;
+                this.queryStateSource.next(this.queryState);
+            });
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Reset the query
+     */
+    reset(silent) {
+        this.query = new SearchQuery();
+        this.setDefaultAggs();
+        this.querySource.next(this.query);
+        if (!silent) {
+            this.aggregate();
+        }
+    }
+    exitIndexdataSearch() {
+        this.setIndexSearchQueryFilters([], true);
+        this.setQueryTypes([], true);
+        this.setContextType(null, true);
+        this.aggregate();
+    }
+    /**
+     * Executes the current query as aggregate search
+     */
+    getSearchState(queryJson) {
+        return this.searchService.getSearchState(queryJson);
+    }
+    autocomplete(term) {
+        return this.searchService.autocomplete(term);
+    }
+    /**
+     * Finds the object type element inside of the queries target types
+     * for a form elements name. Used e.g. for the search summary panel.
+     *
+     * @param formElementName - the name of the form element
+     * @return the object type element matching the form elements name
+     */
+    getTargetTypeElementByName(formElementName) {
+        let i = 0;
+        let match;
+        while (!match && i < this.query.types.length) {
+            match = this.query.types[i].elements.find((element) => element.qname === formElementName);
+            i++;
+        }
+        return match;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AppSearchService, deps: [{ token: i1.SearchService }, { token: i1.EventService }, { token: i1.SystemService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AppSearchService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AppSearchService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.SearchService }, { type: i1.EventService }, { type: i1.SystemService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-search.service.js","sourceRoot":"","sources":["../../../../../../../src/app/eo-framework-core/search/app-search.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {from as observableFrom, BehaviorSubject, ReplaySubject, Observable} from 'rxjs';\nimport {groupBy, reduce, mergeMap} from 'rxjs/operators';\nimport {Injectable} from '@angular/core';\nimport {\n  SearchFilter, SearchQuery, SearchState, SystemService,\n  ObjectType, SearchService, EventService, EnaioEvent, Utils, QueryScope\n} from '@eo-sdk/core';\n\n/**\n * AppSearchService is the apps main entry point for searching (used by the appBarSearch component).\n * It provides an `query$` observable components can subscribe to, to\n * stay in touch with updates to the query.\n */\n@Injectable()\nexport class AppSearchService {\n\n  private query = new SearchQuery();\n  private aggs: any;\n  private lastQuery = new SearchQuery();\n  private queryState = new SearchState();\n  // Holds the last aggregation properties sent to the server\n  // Used for preventing redundant calls\n  private lastAggCallComparator: string;\n\n  // Subject holding the current query (initial value is a new SearchQuery)\n  // @see: http://blog.angular-university.io/how-to-build-angular2-apps-using-rxjs-observable-data-services-pitfalls-to-avoid/#rxjssubjectandhowtouseit\n  // todo: maybe add support for holding a query history, so the user can reload older queries as well\n  private querySource = new ReplaySubject<SearchQuery>(1);\n  private queryStateSource = new BehaviorSubject<SearchState>(this.queryState);\n\n  // Expose an observable instead of the subject itself to prevent the service clients from\n  // themselves emitting store values directly instead of calling action methods, and therefore\n  // bypassing the store.\n  public query$: Observable<SearchQuery> = this.querySource.asObservable();\n  // Search service also exposes an observable that emits the state of the current query.\n  // We separate the state of the query from the query itself as otherwise changhing the queries\n  // state will trigger all subscribers of the query observale and lead to undesired behaviour\n  public queryState$: Observable<SearchState> = this.queryStateSource.asObservable();\n  public objectTypeGroups = [];\n  public typesAllowedUnderSysroot = [];\n\n  constructor(private searchService: SearchService,\n    private eventService: EventService,\n    private system: SystemService) {\n\n    this.setDefaultAggs();\n    this.eventService.on(EnaioEvent.LOGOUT)\n      .subscribe(res => {\n        this.reset(true);\n      });\n\n    this.querySource.next(this.query);\n\n    // Fetch object types and groups that serve as search filter params.\n    // These groups are provided through the services `objectTypeGroups` property.\n    this.system.system$.subscribe((systemDefinition) => {\n\n      this.typesAllowedUnderSysroot = systemDefinition.types.filter(type => type.parenttypes.includes('sysroot'));\n\n      let groups = [];\n      observableFrom(systemDefinition.types)\n        .pipe(\n          groupBy((type: any) => type.group || '0'),\n          mergeMap(g => g.pipe(reduce((acc, curr) => [...acc, curr], [])))\n        )\n        .subscribe(otg => {\n          groups.push({\n            label: otg[0].group || '0',\n            types: this.sortObjectTypeGroup(otg)\n          });\n        });\n      this.objectTypeGroups = groups.sort(Utils.sortValues('label'));\n    });\n  }\n\n  resetAggs() {\n    this.setDefaultAggs();\n    this.lastAggCallComparator = null;\n  }\n\n  private setDefaultAggs() {\n    this.aggs = {\n      type: {}\n    };\n  }\n\n  // helper method for sorting the entries of an object type group\n  private sortObjectTypeGroup(types) {\n    return types.sort((a, b) => {\n\n      if (a.isContextFolder && !b.isContextFolder) {\n        return -1;\n      }\n      if (!a.isContextFolder && b.isContextFolder) {\n        return 1;\n      }\n      if (a.isFolder && !b.isFolder) {\n        return -1;\n      }\n      if (!a.isFolder && b.isFolder) {\n        return 1;\n      }\n      if (a.isFolder && b.isFolder) {\n        return Utils.sortValues('label').call(this, a, b);\n      }\n      return Utils.sortValues('label').call(this, a, b);\n    });\n  }\n\n  // Extends the objectTypesGroups by the elements for each object type\n  // Used in expert search mode\n  public buildTypeGroupTree() {\n\n    let gTree = [];\n    let i = 0;\n    for (let group of this.objectTypeGroups) {\n      let g = {\n        id: i++,\n        label: group.label,\n        tree: []\n      };\n      let types = [];\n      for (let objectType of group.types) {\n\n        let t = {\n          id: objectType.id,\n          label: objectType.label,\n          children: []\n        };\n        let children = [];\n        for (let el of objectType.elements) {\n          children.push({\n            label: el.label,\n            type: el.type,\n            data: el.qname\n          });\n        }\n        // sort by label\n        t.children = children.sort(Utils.sortValues('label'));\n        types.push(t);\n      }\n      g.tree = types.sort(Utils.sortValues('label'));\n\n\n      gTree.push(g);\n    }\n    return gTree;\n  }\n\n  /**\n   * Override the current query by a different one.\n   * This could be done by for example loading a stored query.\n   *\n   * @param query - the query that should replace the current query, this may be either a SearchQuery instance,\n   * a JSON string of an object matching the search api\n   */\n  public setQuery(query: SearchQuery) {\n    if (this.isNewQuery(query)) {\n      this.setDefaultAggs();\n      this.query = query;\n      this.querySource.next(this.query);\n    }\n  }\n\n  /**\n   * Resets the current query.\n   */\n  public clearQuery() {\n    this.setQuery(new SearchQuery());\n  }\n\n  private isNewQuery(query: SearchQuery): boolean {\n    return JSON.stringify(query.getQueryJson()) !== JSON.stringify(this.query.getQueryJson());\n  }\n\n  /**\n   * toggles the searchmode from regular search to expert search and vice versa\n   */\n  public toggleExpertMode() {\n    if (!this.query.expertMode) {\n      this.lastQuery = this.query;\n      this.setDefaultAggs();\n      this.query = new SearchQuery();\n      this.query.expertMode = true;\n    } else {\n      this.query = this.lastQuery;\n    }\n    this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TOGGLED_EXPERTMODE;\n    this.querySource.next(this.query);\n    this.aggregate();\n\n  }\n\n  public setTerm(term: string) {\n    this.query.term = term;\n    this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TERM_SET;\n    this.querySource.next(this.query);\n    this.aggregate();\n  }\n\n  public setQueryScope(scope: QueryScope) {\n    this.query.scope = scope;\n    this.querySource.next(this.query);\n    this.aggregate();\n  }\n\n  // set aggregation properties to be applied to ONLY aggregate search queries\n  public setAggs(aggs: any, extend = false) {\n    this.aggs = extend ? {...this.aggs, ...aggs} : aggs;\n  }\n\n  /**\n   * Toggles a type filter.\n   * @param type - object type\n   */\n  public toggleQueryType(type: ObjectType) {\n    this.query.toggleType(type);\n    this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TOGGLED_TYPE;\n    this.querySource.next(this.query);\n    this.aggregate(SearchQuery.BASE_PARAMS.TYPE);\n  }\n\n  /**\n   * Sets the queries target types.\n   *\n   * @param types - array of ObjectTypes\n   * @param silent If set to true aggregate won't be called\n   */\n  public setQueryTypes(types: ObjectType[], silent?: boolean) {\n    this.query.types = types;\n    this.aggs = {\n      type: {\n        sub: {\n          contextfoldertype: {}\n        }\n      }\n    };\n    this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TYPES_SET;\n    this.querySource.next(this.query);\n    if (!silent) {\n      this.aggregate();\n    }\n  }\n\n  /**\n   * Sets the queries target context type.\n   *\n   * @param type The context type to be set or null for resetting\n   * @param silent If set to true aggregate won't be called\n   */\n  public setContextType(type: ObjectType, silent?: boolean) {\n\n    if (this.query.contextFolderTypes.length && !type) {\n      // clear context folder\n      this.emitNewContextFolderType(null);\n    } else if (this.query.contextFolderTypes.length && type.name !== this.query.contextFolderTypes[0].name) {\n      // got a type to be set up that differs from the current one\n      this.emitNewContextFolderType(type);\n    } else if (!this.query.contextFolderTypes.length) {\n      // nothing set up so far\n      this.emitNewContextFolderType(type);\n    }\n    // trying to setup the same type as the current on should not emit a new value\n  }\n\n  private emitNewContextFolderType(type, silent?: boolean) {\n    if (!type && this.query.contextFolderTypes.length === 0) {\n      return;\n    }\n    this.aggs = {\n      type: {\n        sub: {\n          contextfoldertype: {}\n        }\n      }\n    };\n    this.query.contextFolderTypes = type ? [type] : [];\n    this.query.__updateCause = SearchQuery.UPDATE_CAUSE.CONTEXT_FOLDER_SET;\n    this.querySource.next(this.query);\n    if (!silent) {\n      this.aggregate();\n    }\n  }\n\n  /**\n   * Toggles a created filter.\n   * @param filter - the filter to be toggled\n   */\n  public toggleQueryFilter(filter: SearchFilter, override?: boolean) {\n    this.query.toggleFilter(filter, override);\n    this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TOGGLED_FILTER;\n    this.querySource.next(this.query);\n    this.aggregate(filter.property);\n  }\n\n  /**\n   * Toggles created filters and aggregates them together.\n   * @param filters - the filters to be toggled\n   */\n  public toggleQueryFilters(filters: SearchFilter[], override?: boolean) {\n    let baseParam = '';\n    filters.forEach(filter => {\n      this.query.toggleFilter(filter, override);\n      this.query.__updateCause = SearchQuery.UPDATE_CAUSE.TOGGLED_FILTER;\n      baseParam += filter.property + ' ';\n    });\n\n    this.querySource.next(this.query);\n    this.aggregate(baseParam.trim());\n  }\n\n  /**\n   * Adds a filter to the query.\n   * @param filter - the filter to be added\n   */\n  public addQueryFilter(filter: SearchFilter) {\n    this.query.addFilter(filter);\n    this.query.__updateCause = SearchQuery.UPDATE_CAUSE.ADDED_FILTER;\n    this.querySource.next(this.query);\n    this.aggregate(filter.property);\n  }\n\n  /**\n   * Removes a filter to the query.\n   * @param filter - the filter to be removed\n   */\n  public removeQueryFilter(filter: SearchFilter) {\n    this.query.removeFilter(filter.property);\n    this.query.__updateCause = SearchQuery.UPDATE_CAUSE.REMOVED_FILTER;\n    this.querySource.next(this.query);\n    this.aggregate(filter.property);\n  }\n\n  /**\n   * Sets the filters for an indexdata search.\n   * Setting them will also remove all indexdata filters set before.\n   *\n   * @param filters - the filters to be set\n   * @param silent If set to true aggregate won't be called\n   */\n  public setIndexSearchQueryFilters(filters: SearchFilter[], silent?: boolean) {\n\n    // remove previous filters (all filters that are not baseparam filters)\n    this.query.filters = this.query.filters.filter((f) => this.isBaseParamFilter(f));\n    for (let f of filters) {\n      this.query.addFilter(f);\n    }\n    if (!silent) {\n      this.aggregate();\n    }\n  }\n\n  public getIndexSearchQueryFilters(query?: SearchQuery): SearchFilter[] {\n    let q = query || this.query;\n    return q.filters.filter((f) => !this.isBaseParamFilter(f));\n  }\n\n  /**\n   * Determines whether or not the provided search filter belongs to a base param.\n   *\n   * @param filter - the filter to be checked\n   */\n  public isBaseParamFilter(filter: SearchFilter): boolean {\n    //return Object.values(SearchQuery.BASE_PARAMS).some((bp) => filter.property === bp);\n    return Object.keys(SearchQuery.BASE_PARAMS).some((bpKey) => filter.property === SearchQuery.BASE_PARAMS[bpKey]);\n  }\n\n  /**\n   * Executes the current query as aggregate search\n   */\n  public aggregate(baseParam = '') {\n\n    const aggQuery = {aggs: this.aggs, ...this.query.getQueryJson()};\n    // compare the call to be made with a former request\n    if (this.lastAggCallComparator !== JSON.stringify(aggQuery)) {\n      this.lastAggCallComparator = JSON.stringify(aggQuery);\n      this.getSearchState(aggQuery)\n        .subscribe((queryState: SearchState) => {\n          queryState.lastChange = baseParam;\n          this.queryState = queryState;\n          this.queryStateSource.next(this.queryState);\n        });\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Reset the query\n   */\n  public reset(silent?: boolean) {\n    this.query = new SearchQuery();\n    this.setDefaultAggs();\n    this.querySource.next(this.query);\n    if (!silent) {\n      this.aggregate();\n    }\n  }\n\n  exitIndexdataSearch() {\n    this.setIndexSearchQueryFilters([], true);\n    this.setQueryTypes([], true);\n    this.setContextType(null, true);\n    this.aggregate();\n  }\n\n  /**\n   * Executes the current query as aggregate search\n   */\n  public getSearchState(queryJson: any) {\n    return this.searchService.getSearchState(queryJson);\n  }\n\n  public autocomplete(term: string) {\n    return this.searchService.autocomplete(term);\n  }\n\n  /**\n   * Finds the object type element inside of the queries target types\n   * for a form elements name. Used e.g. for the search summary panel.\n   *\n   * @param formElementName - the name of the form element\n   * @return the object type element matching the form elements name\n   */\n  public getTargetTypeElementByName(formElementName: string): any {\n    let i = 0;\n    let match;\n    while (!match && i < this.query.types.length) {\n      match = this.query.types[i].elements.find((element) => element.qname === formElementName);\n      i++;\n    }\n    return match;\n  }\n}\n"]}

package/esm2022/app/eo-framework-core/selection/selection.service.mjs

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import { debounceTime } from 'rxjs/operators';
+import { ReplaySubject } from 'rxjs';
+import { EnaioEvent } from '@eo-sdk/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@eo-sdk/core";
+export class SelectionService {
+    constructor(eventService) {
+        this.eventService = eventService;
+        this.children = {};
+        this.selection = [];
+        this.selectionSource = new ReplaySubject(1);
+        this.selection$ = this.selectionSource.asObservable().pipe(debounceTime(200));
+        this._focus = {};
+        this.focusSource = new ReplaySubject(1);
+        this.focus$ = this.focusSource.asObservable().pipe(debounceTime(200));
+        this._disabled = false;
+        this.eventService
+            .on(EnaioEvent.LOGOUT)
+            .subscribe(() => {
+            this.clear();
+            Object.keys(this.children).forEach(k => this.children[k].clear());
+        });
+    }
+    focus(focus) {
+        if (!this._disabled) {
+            this._focus = focus;
+            this.focusSource.next(this._focus);
+        }
+    }
+    set(selection) {
+        if (!this._disabled) {
+            this.selection = selection;
+            this.selectionSource.next(this.selection);
+        }
+    }
+    disable(val = true) {
+        this._disabled = val;
+    }
+    get() {
+        return this.selection;
+    }
+    clear() {
+        this.set([]);
+        this.focus({});
+    }
+    getFocus() {
+        return this._focus;
+    }
+    find(id) {
+        return (this.children[id] || this);
+    }
+    createNew(id) {
+        this.children[id] = new SelectionService(this.eventService);
+        return this.find(id);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SelectionService, deps: [{ token: i1.EventService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SelectionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SelectionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.EventService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/eo-framework-core/title/page-title.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "../selection/selection.service";
+import * as i3 from "@eo-sdk/core";
+export class PageTitleService {
+    constructor(titleService, selection, config) {
+        this.titleService = titleService;
+        this.selection = selection;
+        this.config = config;
+        this.DEFAULT_TITLE = this.config.getRaw('dashboardTitle') || 'yuuvis® RAD client';
+        this.selection.focus$
+            .subscribe((item) => {
+            if (this.baseTitle) {
+                this.titleService.setTitle((item && item.title) ? `${this.baseTitle}: ${item.title}` : this.baseTitle);
+            }
+            else if (item && item.title) {
+                this.titleService.setTitle(item.title);
+            }
+            else {
+                this.setDefaultTitle();
+            }
+        });
+    }
+    setBaseTitle(base) {
+        this.baseTitle = base;
+        this.titleService.setTitle(this.baseTitle || this.DEFAULT_TITLE);
+    }
+    setDefaultTitle() {
+        this.baseTitle = null;
+        this.titleService.setTitle(this.DEFAULT_TITLE);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PageTitleService, deps: [{ token: i1.Title }, { token: i2.SelectionService }, { token: i3.Config }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PageTitleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PageTitleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Title }, { type: i2.SelectionService }, { type: i3.Config }] });
+//# sourceMappingURL=data:application/json;base64,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