@netgrif/components-core 6.0.1

package/esm5/lib/search/search-service/search.service.js

@@ -0,0 +1,405 @@
+import { __read, __values } from "tslib";
+import { Inject, Injectable, Optional } from '@angular/core';
+import { BooleanOperator } from '../models/boolean-operator';
+import { Filter } from '../../filter/models/filter';
+import { BehaviorSubject, forkJoin, Observable, Subject } from 'rxjs';
+import { SimpleFilter } from '../../filter/models/simple-filter';
+import { MergeOperator } from '../../filter/models/merge-operator';
+import { distinctUntilChanged, map, tap } from 'rxjs/operators';
+import { EditableClausePredicateWithGenerators } from '../models/predicate/editable-clause-predicate-with-generators';
+import { NAE_BASE_FILTER } from '../models/base-filter-injection-token';
+import { LoggerService } from '../../logger/services/logger.service';
+import { CategoryFactory } from '../category-factory/category-factory';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+/**
+ * Holds information about the filter that is currently applied to the view component, that provides this services.
+ */
+var SearchService = /** @class */ (function () {
+    /**
+     * The {@link Predicate} tree root uses an [AND]{@link BooleanOperator#AND} operator to combine the Predicates.
+     * @param _log {@link LoggerService}
+     * @param _categoryFactory a {@link CategoryFactory} instance. This dependency is optional.
+     * It is required if we want to load predicate filter from saved metadata
+     * @param baseFilter Filter that should be applied to the view when no searching is being performed.
+     * Injected trough the {@link NAE_BASE_FILTER} injection token.
+     */
+    function SearchService(_log, _categoryFactory, baseFilter) {
+        var _this = this;
+        this._log = _log;
+        this._categoryFactory = _categoryFactory;
+        if (baseFilter.filter instanceof Filter) {
+            this._baseFilter = baseFilter.filter.clone();
+        }
+        else if (baseFilter.filter instanceof Observable) {
+            this._baseFilter = new SimpleFilter('', baseFilter.filterType, { process: { identifier: '__EMPTY__' } });
+        }
+        else {
+            throw new Error('Unsupported BaseFilter input! You must provide the NAE_BASE_FILTER injection token with proper values!');
+        }
+        this._predicateQueryChanged$ = new Subject();
+        this._rootPredicate = new EditableClausePredicateWithGenerators(BooleanOperator.AND, this._predicateQueryChanged$, undefined, true);
+        this._activeFilter = new BehaviorSubject(this._baseFilter);
+        this._predicateRemoved$ = new Subject();
+        this._loadingFromMetadata$ = new LoadingEmitter();
+        if (baseFilter.filter instanceof Observable) {
+            this.subFilter = baseFilter.filter.subscribe(function (filter) {
+                _this._baseFilter = filter.clone();
+                _this.updateActiveFilter();
+            });
+        }
+        this.predicateQueryChanged$.subscribe(function () {
+            _this.updateActiveFilter();
+        });
+    }
+    SearchService.prototype.ngOnDestroy = function () {
+        this._predicateRemoved$.complete();
+        this._activeFilter.complete();
+        this._predicateQueryChanged$.complete();
+        if (this.subFilter) {
+            this.subFilter.unsubscribe();
+        }
+        this._loadingFromMetadata$.complete();
+        this._rootPredicate.destroy();
+    };
+    Object.defineProperty(SearchService.prototype, "activeFilter", {
+        /**
+         * @returns the Filter that is currently applied to the view
+         */
+        get: function () {
+            return this._activeFilter.getValue();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SearchService.prototype, "activeFilter$", {
+        /**
+         * @returns an `Observable` that updates every time the active Filter changes.
+         */
+        get: function () {
+            return this._activeFilter.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SearchService.prototype, "additionalFiltersApplied", {
+        /**
+         * @returns `true` if a filter other than the base filter is currently applied.
+         * Returns `false` if only the base filter is currently applied.
+         */
+        get: function () {
+            return !this._rootPredicate.query.isEmpty || !!this._fullTextFilter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SearchService.prototype, "hasVisiblePredicates", {
+        /**
+         * @returns `true` if any visible predicates are applied.
+         * Returns `false` if there are no predicates, or if there are only hidden predicates applied
+         */
+        get: function () {
+            var e_1, _a;
+            try {
+                for (var _b = __values(this._rootPredicate.getPredicateMap().values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var predicate = _c.value;
+                    if (predicate.isVisible) {
+                        return true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SearchService.prototype, "baseFilter", {
+        /**
+         * @returns a copy of the base filter
+         */
+        get: function () {
+            return this._baseFilter.clone();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SearchService.prototype, "predicateRemoved$", {
+        /**
+         * @returns an Observable that emits the index of the removed predicate whenever a predicate is removed
+         */
+        get: function () {
+            return this._predicateRemoved$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SearchService.prototype, "rootPredicate", {
+        /**
+         * @returns the root predicate of the search service, that can be used to generate search requests with custom queries
+         */
+        get: function () {
+            return this._rootPredicate;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SearchService.prototype, "filterType", {
+        /**
+         * @returns the type of the filter held in this search service instance
+         */
+        get: function () {
+            return this.baseFilter.type;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SearchService.prototype, "loadingFromMetadata", {
+        /**
+         * @returns whether the search service is currently loading its state from metadata or not.
+         *
+         * See [loadFromMetadata()]{@link SearchService#loadFromMetadata}
+         */
+        get: function () {
+            return this._loadingFromMetadata$.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SearchService.prototype, "loadingFromMetadata$", {
+        /**
+         * @returns an `Observable` that emits `true` if the search service is currently loading its state from metadata,
+         * emits `false` otherwise.
+         *
+         * See [loadFromMetadata()]{@link SearchService#loadFromMetadata}
+         */
+        get: function () {
+            return this._loadingFromMetadata$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SearchService.prototype, "predicateQueryChanged$", {
+        /**
+         * @returns an Observable that emits whenever the root predicates query changes
+         */
+        get: function () {
+            var _this = this;
+            return this._predicateQueryChanged$.asObservable().pipe(map(function () { return _this._rootPredicate.query; }), distinctUntilChanged(function (prev, curr) { return prev && prev.equals(curr); }));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Adds a {@link Predicate} to the Predicate root and updates the active Filter.
+     *
+     * Predicates added this way will not be visible in the search GUI.
+     * If you want to make sure your predicates are visible (and editable)
+     * use the [addGeneratedLeafPredicate()]{@link SearchService#addGeneratedLeafPredicate} method instead.
+     * @param newPredicate Predicate that should be added to the search queries.
+     * @returns the index of the added Predicate
+     */
+    SearchService.prototype.addPredicate = function (newPredicate) {
+        return this._rootPredicate.addPredicate(newPredicate, false);
+    };
+    /**
+     * Adds a new hidden branch of the predicate tree with a singular leaf node containing the provided Query.
+     *
+     * This can be used to add predicates to the search tree (think header search),
+     * which can be made visible and editable in the search GUI later.
+     * @param generator the generator that is in such state, that it generates the Query, that should be added as branch/leaf.
+     * If the generator doesn't currently generate a query a node with an empty query will be added.
+     */
+    SearchService.prototype.addGeneratedLeafPredicate = function (generator) {
+        var branchId = this._rootPredicate.addNewClausePredicate(BooleanOperator.OR, false);
+        var branch = this._rootPredicate.getPredicateMap().get(branchId).getWrappedPredicate();
+        branch.addNewPredicateFromGenerator(generator);
+        return branchId;
+    };
+    /**
+     * Removes the {@link Predicate} object from the provided index. If the index is invalid does nothing.
+     * Updates the the active Filter if the Predicate tree was affected.
+     * @param index index of the Predicate that should be removed
+     * @param clearInput whether the input, that corresponds to the predicate should be cleared
+     */
+    SearchService.prototype.removePredicate = function (index, clearInput) {
+        if (clearInput === void 0) { clearInput = true; }
+        if (this._rootPredicate.removePredicate(index)) {
+            this._predicateRemoved$.next({ index: index, clearInput: clearInput });
+        }
+    };
+    /**
+     * Removes all {@link Predicate} objects that contribute to the search. Updates the active Filter if it was affected.
+     *
+     * @param clearHidden whether the hidden predicates should be cleared as well
+     */
+    SearchService.prototype.clearPredicates = function (clearHidden) {
+        var e_2, _a;
+        if (clearHidden === void 0) { clearHidden = false; }
+        if (this._rootPredicate.getPredicateMap().size > 0) {
+            try {
+                for (var _b = __values(this._rootPredicate.getPredicateMap().entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), id = _d[0], predicate = _d[1];
+                    if (clearHidden || predicate.isVisible) {
+                        this.removePredicate(id);
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            this.updateActiveFilter();
+        }
+    };
+    /**
+     * Adds a {@link Filter} with the [fullText]{@link CaseSearchRequestBody#fullText} attribute set to the provided value.
+     * If full text filter is already set, it will be replaced.
+     * @param searchedSubstring value that should be searched on all full text fields
+     */
+    SearchService.prototype.setFullTextFilter = function (searchedSubstring) {
+        this._fullTextFilter = new SimpleFilter('', this._baseFilter.type, { fullText: searchedSubstring });
+        this.updateActiveFilter();
+    };
+    /**
+     * Clears the full text filter (if set). If the full text filter is not set, does nothing.
+     */
+    SearchService.prototype.clearFullTextFilter = function () {
+        var wasFulltextSet = this._fullTextFilter !== undefined;
+        this._fullTextFilter = undefined;
+        if (wasFulltextSet) {
+            this.updateActiveFilter();
+        }
+    };
+    /**
+     * Shows the predicates with the given ids. Skips ids that don't exist.
+     * @param predicateIds the ids of the predicates that should be shown.
+     */
+    SearchService.prototype.show = function (predicateIds) {
+        this._rootPredicate.showPredicates(predicateIds);
+    };
+    /**
+     * Reads the current query from the predicate tree, combines it with the base Filter and full text Filter (if set)
+     * and updates the active Filter.
+     */
+    SearchService.prototype.updateActiveFilter = function () {
+        var additionalFilter;
+        if (!this._rootPredicate.query.isEmpty) {
+            additionalFilter = new SimpleFilter('', this._baseFilter.type, { query: this._rootPredicate.query.value });
+        }
+        if (this._fullTextFilter) {
+            if (additionalFilter) {
+                additionalFilter = additionalFilter.merge(this._fullTextFilter, MergeOperator.AND);
+            }
+            else {
+                additionalFilter = this._fullTextFilter;
+            }
+        }
+        if (additionalFilter) {
+            this._activeFilter.next(this._baseFilter.merge(additionalFilter, MergeOperator.AND));
+        }
+        else {
+            this._activeFilter.next(this._baseFilter.clone());
+        }
+    };
+    /**
+     * @returns `undefined` if the predicate tree contains no complete query.
+     * Otherwise returns the serialized form of the completed queries in the predicate tree.
+     */
+    SearchService.prototype.createPredicateMetadata = function () {
+        return this._rootPredicate.createGeneratorMetadata();
+    };
+    /**
+     * Replaces the current predicate filter by the one corresponding to the provided generator metadata.
+     *
+     * The {@link CategoryFactory} instance must be provided for this service if we want to use this method. Logs an error and does nothing.
+     *
+     * The `filterType` of this search service must match the `filterType` of the provided metadata. Otherwise an error is thrown.
+     *
+     * @param metadata the serialized state of the predicate tree that should be restored to this search service
+     */
+    SearchService.prototype.loadFromMetadata = function (metadata) {
+        var e_3, _a, e_4, _b;
+        var _this = this;
+        if (this._categoryFactory === null) {
+            this._log.error('A CategoryFactory instance must be provided for the SearchService'
+                + ' if you want to reconstruct a predicate filter from saved metadata');
+            return;
+        }
+        if (metadata.filterType !== this.filterType) {
+            throw Error("The filter type of the provided metadata (" + metadata.filterType + ") does not match the filter type of the search service (" + this.filterType + ")!");
+        }
+        this.clearPredicates(true);
+        this._loadingFromMetadata$.on();
+        var generatorObservables = [];
+        try {
+            for (var _c = __values(metadata.predicateMetadata), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var clause = _d.value;
+                var branchId = this._rootPredicate.addNewClausePredicate(BooleanOperator.OR);
+                var branchPredicate = this._rootPredicate.getPredicateMap().get(branchId)
+                    .getWrappedPredicate();
+                var _loop_1 = function (predicate) {
+                    var localBranchReference = branchPredicate;
+                    generatorObservables.push(this_1._categoryFactory.getFromMetadata(predicate).pipe(tap(function (generator) {
+                        localBranchReference.addNewPredicateFromGenerator(generator);
+                    })));
+                };
+                var this_1 = this;
+                try {
+                    for (var clause_1 = (e_4 = void 0, __values(clause)), clause_1_1 = clause_1.next(); !clause_1_1.done; clause_1_1 = clause_1.next()) {
+                        var predicate = clause_1_1.value;
+                        _loop_1(predicate);
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (clause_1_1 && !clause_1_1.done && (_b = clause_1.return)) _b.call(clause_1);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        forkJoin(generatorObservables).subscribe(function () {
+            _this._loadingFromMetadata$.off();
+            _this.updateActiveFilter();
+        });
+    };
+    /**
+     * @returns an Array of filter text segments that correspond to the currently displayed completed predicates
+     */
+    SearchService.prototype.createFilterTextSegments = function () {
+        return this._rootPredicate.createFilterTextSegments();
+    };
+    SearchService.ctorParameters = function () { return [
+        { type: LoggerService },
+        { type: CategoryFactory, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_BASE_FILTER,] }] }
+    ]; };
+    SearchService.decorators = [
+        { type: Injectable }
+    ];
+    SearchService.ctorParameters = function () { return [
+        { type: LoggerService },
+        { type: CategoryFactory, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_BASE_FILTER,] }] }
+    ]; };
+    return SearchService;
+}());
+export { SearchService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/search-service/search.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy, Optional} from '@angular/core';\nimport {BooleanOperator} from '../models/boolean-operator';\nimport {Filter} from '../../filter/models/filter';\nimport {BehaviorSubject, forkJoin, Observable, Subject, Subscription} from 'rxjs';\nimport {Predicate} from '../models/predicate/predicate';\nimport {SimpleFilter} from '../../filter/models/simple-filter';\nimport {MergeOperator} from '../../filter/models/merge-operator';\nimport {PredicateRemovalEvent} from '../models/predicate-removal-event';\nimport {Query} from '../models/query/query';\nimport {distinctUntilChanged, map, tap} from 'rxjs/operators';\nimport {EditableClausePredicateWithGenerators} from '../models/predicate/editable-clause-predicate-with-generators';\nimport {Category} from '../models/category/category';\nimport {PredicateTreeMetadata} from '../models/persistance/generator-metadata';\nimport {NAE_BASE_FILTER} from '../models/base-filter-injection-token';\nimport {BaseFilter} from '../models/base-filter';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {CategoryFactory} from '../category-factory/category-factory';\nimport {FilterType} from '../../filter/models/filter-type';\nimport {LoadingEmitter} from '../../utility/loading-emitter';\nimport {FilterMetadata} from '../models/persistance/filter-metadata';\nimport {FilterTextSegment} from '../models/persistance/filter-text-segment';\n\n/**\n * Holds information about the filter that is currently applied to the view component, that provides this services.\n */\n@Injectable()\nexport class SearchService implements OnDestroy {\n\n    /**\n     * {@link Filter} that is applied to the view, even if the user doesn't search anything.\n     */\n    protected _baseFilter: Filter;\n    /**\n     * Holds the {@link Predicate} tree root for user search queries.\n     */\n    protected _rootPredicate: EditableClausePredicateWithGenerators;\n    /**\n     * Holds the {@link Filter} that is currently being applied to the view.\n     */\n    protected _activeFilter: BehaviorSubject<Filter>;\n    /**\n     * Holds the full text {@link Filter} if set, `undefined` otherwise.\n     */\n    protected _fullTextFilter: SimpleFilter | undefined;\n    /**\n     * The index of a removed {@link Predicate} is emmited into this stream\n     */\n    protected _predicateRemoved$: Subject<PredicateRemovalEvent>;\n    protected _loadingFromMetadata$: LoadingEmitter;\n    /**\n     * The `rootPredicate` uses this stream to notify the search service about changes to the held query\n     */\n    private readonly _predicateQueryChanged$: Subject<void>;\n    private readonly subFilter: Subscription;\n\n    /**\n     * The {@link Predicate} tree root uses an [AND]{@link BooleanOperator#AND} operator to combine the Predicates.\n     * @param _log {@link LoggerService}\n     * @param _categoryFactory a {@link CategoryFactory} instance. This dependency is optional.\n     * It is required if we want to load predicate filter from saved metadata\n     * @param baseFilter Filter that should be applied to the view when no searching is being performed.\n     * Injected trough the {@link NAE_BASE_FILTER} injection token.\n     */\n    constructor(protected _log: LoggerService,\n                @Optional() protected _categoryFactory: CategoryFactory,\n                @Inject(NAE_BASE_FILTER) baseFilter: BaseFilter) {\n        if (baseFilter.filter instanceof Filter) {\n            this._baseFilter = baseFilter.filter.clone();\n        } else if (baseFilter.filter instanceof Observable) {\n            this._baseFilter = new SimpleFilter('', baseFilter.filterType, {process: {identifier: '__EMPTY__'}});\n        } else {\n            throw new Error('Unsupported BaseFilter input! You must provide the NAE_BASE_FILTER injection token with proper values!');\n        }\n\n        this._predicateQueryChanged$ = new Subject<void>();\n        this._rootPredicate = new EditableClausePredicateWithGenerators(BooleanOperator.AND, this._predicateQueryChanged$, undefined, true);\n        this._activeFilter = new BehaviorSubject<Filter>(this._baseFilter);\n        this._predicateRemoved$ = new Subject<PredicateRemovalEvent>();\n        this._loadingFromMetadata$ = new LoadingEmitter();\n\n        if (baseFilter.filter instanceof Observable) {\n            this.subFilter = baseFilter.filter.subscribe((filter) => {\n                this._baseFilter = filter.clone();\n                this.updateActiveFilter();\n            });\n        }\n\n        this.predicateQueryChanged$.subscribe(() => {\n            this.updateActiveFilter();\n        });\n    }\n\n    ngOnDestroy(): void {\n        this._predicateRemoved$.complete();\n        this._activeFilter.complete();\n        this._predicateQueryChanged$.complete();\n        if (this.subFilter) {\n            this.subFilter.unsubscribe();\n        }\n        this._loadingFromMetadata$.complete();\n        this._rootPredicate.destroy();\n    }\n\n    /**\n     * @returns the Filter that is currently applied to the view\n     */\n    public get activeFilter(): Filter {\n        return this._activeFilter.getValue();\n    }\n\n    /**\n     * @returns an `Observable` that updates every time the active Filter changes.\n     */\n    public get activeFilter$(): Observable<Filter> {\n        return this._activeFilter.asObservable();\n    }\n\n    /**\n     * @returns `true` if a filter other than the base filter is currently applied.\n     * Returns `false` if only the base filter is currently applied.\n     */\n    public get additionalFiltersApplied(): boolean {\n        return !this._rootPredicate.query.isEmpty || !!this._fullTextFilter;\n    }\n\n    /**\n     * @returns `true` if any visible predicates are applied.\n     * Returns `false` if there are no predicates, or if there are only hidden predicates applied\n     */\n    public get hasVisiblePredicates(): boolean {\n        for (const predicate of this._rootPredicate.getPredicateMap().values()) {\n            if (predicate.isVisible) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * @returns a copy of the base filter\n     */\n    public get baseFilter(): Filter {\n        return this._baseFilter.clone();\n    }\n\n    /**\n     * @returns an Observable that emits the index of the removed predicate whenever a predicate is removed\n     */\n    public get predicateRemoved$(): Observable<PredicateRemovalEvent> {\n        return this._predicateRemoved$.asObservable();\n    }\n\n    /**\n     * @returns the root predicate of the search service, that can be used to generate search requests with custom queries\n     */\n    public get rootPredicate(): EditableClausePredicateWithGenerators {\n        return this._rootPredicate;\n    }\n\n    /**\n     * @returns the type of the filter held in this search service instance\n     */\n    public get filterType(): FilterType {\n        return this.baseFilter.type;\n    }\n\n    /**\n     * @returns whether the search service is currently loading its state from metadata or not.\n     *\n     * See [loadFromMetadata()]{@link SearchService#loadFromMetadata}\n     */\n    public get loadingFromMetadata(): boolean {\n        return this._loadingFromMetadata$.value;\n    }\n\n    /**\n     * @returns an `Observable` that emits `true` if the search service is currently loading its state from metadata,\n     * emits `false` otherwise.\n     *\n     * See [loadFromMetadata()]{@link SearchService#loadFromMetadata}\n     */\n    public get loadingFromMetadata$(): Observable<boolean> {\n        return this._loadingFromMetadata$.asObservable();\n    }\n\n    /**\n     * @returns an Observable that emits whenever the root predicates query changes\n     */\n    protected get predicateQueryChanged$(): Observable<Query> {\n        return this._predicateQueryChanged$.asObservable().pipe(\n            map(() => this._rootPredicate.query),\n            distinctUntilChanged((prev, curr) => prev && prev.equals(curr))\n        );\n    }\n\n    /**\n     * Adds a {@link Predicate} to the Predicate root and updates the active Filter.\n     *\n     * Predicates added this way will not be visible in the search GUI.\n     * If you want to make sure your predicates are visible (and editable)\n     * use the [addGeneratedLeafPredicate()]{@link SearchService#addGeneratedLeafPredicate} method instead.\n     * @param newPredicate Predicate that should be added to the search queries.\n     * @returns the index of the added Predicate\n     */\n    public addPredicate(newPredicate: Predicate): number {\n        return this._rootPredicate.addPredicate(newPredicate, false);\n    }\n\n    /**\n     * Adds a new hidden branch of the predicate tree with a singular leaf node containing the provided Query.\n     *\n     * This can be used to add predicates to the search tree (think header search),\n     * which can be made visible and editable in the search GUI later.\n     * @param generator the generator that is in such state, that it generates the Query, that should be added as branch/leaf.\n     * If the generator doesn't currently generate a query a node with an empty query will be added.\n     */\n    public addGeneratedLeafPredicate(generator: Category<any>): number {\n        const branchId = this._rootPredicate.addNewClausePredicate(BooleanOperator.OR, false);\n        const branch = (\n            this._rootPredicate.getPredicateMap().get(branchId).getWrappedPredicate() as unknown as EditableClausePredicateWithGenerators\n        );\n        branch.addNewPredicateFromGenerator(generator);\n        return branchId;\n    }\n\n    /**\n     * Removes the {@link Predicate} object from the provided index. If the index is invalid does nothing.\n     * Updates the the active Filter if the Predicate tree was affected.\n     * @param index index of the Predicate that should be removed\n     * @param clearInput whether the input, that corresponds to the predicate should be cleared\n     */\n    public removePredicate(index: number, clearInput = true): void {\n        if (this._rootPredicate.removePredicate(index)) {\n            this._predicateRemoved$.next({index, clearInput});\n        }\n    }\n\n    /**\n     * Removes all {@link Predicate} objects that contribute to the search. Updates the active Filter if it was affected.\n     *\n     * @param clearHidden whether the hidden predicates should be cleared as well\n     */\n    public clearPredicates(clearHidden = false): void {\n        if (this._rootPredicate.getPredicateMap().size > 0) {\n            for (const [id, predicate] of this._rootPredicate.getPredicateMap().entries()) {\n                if (clearHidden || predicate.isVisible) {\n                    this.removePredicate(id);\n                }\n            }\n            this.updateActiveFilter();\n        }\n    }\n\n    /**\n     * Adds a {@link Filter} with the [fullText]{@link CaseSearchRequestBody#fullText} attribute set to the provided value.\n     * If full text filter is already set, it will be replaced.\n     * @param searchedSubstring value that should be searched on all full text fields\n     */\n    public setFullTextFilter(searchedSubstring: string): void {\n        this._fullTextFilter = new SimpleFilter('', this._baseFilter.type, {fullText: searchedSubstring});\n        this.updateActiveFilter();\n    }\n\n    /**\n     * Clears the full text filter (if set). If the full text filter is not set, does nothing.\n     */\n    public clearFullTextFilter(): void {\n        const wasFulltextSet = this._fullTextFilter !== undefined;\n        this._fullTextFilter = undefined;\n        if (wasFulltextSet) {\n            this.updateActiveFilter();\n        }\n    }\n\n    /**\n     * Shows the predicates with the given ids. Skips ids that don't exist.\n     * @param predicateIds the ids of the predicates that should be shown.\n     */\n    public show(predicateIds: Array<number>): void {\n        this._rootPredicate.showPredicates(predicateIds);\n    }\n\n    /**\n     * Reads the current query from the predicate tree, combines it with the base Filter and full text Filter (if set)\n     * and updates the active Filter.\n     */\n    protected updateActiveFilter(): void {\n        let additionalFilter: Filter;\n        if (!this._rootPredicate.query.isEmpty) {\n            additionalFilter = new SimpleFilter('', this._baseFilter.type, {query: this._rootPredicate.query.value});\n        }\n        if (this._fullTextFilter) {\n            if (additionalFilter) {\n                additionalFilter = additionalFilter.merge(this._fullTextFilter, MergeOperator.AND);\n            } else {\n                additionalFilter = this._fullTextFilter;\n            }\n        }\n        if (additionalFilter) {\n            this._activeFilter.next(this._baseFilter.merge(additionalFilter, MergeOperator.AND));\n        } else {\n            this._activeFilter.next(this._baseFilter.clone());\n        }\n    }\n\n    /**\n     * @returns `undefined` if the predicate tree contains no complete query.\n     * Otherwise returns the serialized form of the completed queries in the predicate tree.\n     */\n    public createPredicateMetadata(): PredicateTreeMetadata | undefined {\n        return this._rootPredicate.createGeneratorMetadata() as PredicateTreeMetadata;\n    }\n\n    /**\n     * Replaces the current predicate filter by the one corresponding to the provided generator metadata.\n     *\n     * The {@link CategoryFactory} instance must be provided for this service if we want to use this method. Logs an error and does nothing.\n     *\n     * The `filterType` of this search service must match the `filterType` of the provided metadata. Otherwise an error is thrown.\n     *\n     * @param metadata the serialized state of the predicate tree that should be restored to this search service\n     */\n    public loadFromMetadata(metadata: FilterMetadata) {\n        if (this._categoryFactory === null) {\n            this._log.error('A CategoryFactory instance must be provided for the SearchService'\n                + ' if you want to reconstruct a predicate filter from saved metadata');\n            return;\n        }\n\n        if (metadata.filterType !== this.filterType) {\n            throw Error(`The filter type of the provided metadata (${metadata.filterType\n            }) does not match the filter type of the search service (${this.filterType})!`);\n        }\n\n        this.clearPredicates(true);\n        this._loadingFromMetadata$.on();\n\n        const generatorObservables = [];\n\n        for (const clause of metadata.predicateMetadata) {\n            const branchId = this._rootPredicate.addNewClausePredicate(BooleanOperator.OR);\n            const branchPredicate = (\n                this._rootPredicate.getPredicateMap().get(branchId)\n                    .getWrappedPredicate() as unknown as EditableClausePredicateWithGenerators\n            );\n            for (const predicate of clause) {\n                const localBranchReference = branchPredicate;\n                generatorObservables.push(\n                    this._categoryFactory.getFromMetadata(predicate).pipe(tap(generator => {\n                        localBranchReference.addNewPredicateFromGenerator(generator);\n                    }))\n                );\n            }\n        }\n\n        forkJoin(generatorObservables).subscribe(() => {\n            this._loadingFromMetadata$.off();\n            this.updateActiveFilter();\n        });\n    }\n\n    /**\n     * @returns an Array of filter text segments that correspond to the currently displayed completed predicates\n     */\n    public createFilterTextSegments(): Array<FilterTextSegment> {\n        return this._rootPredicate.createFilterTextSegments();\n    }\n}\n"]}