@netgrif/components-core
Version:
Netgrif Application engine frontend core Angular library
335 lines • 45.9 kB
JavaScript
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 { LoadingEmitter } from '../../utility/loading-emitter';
import * as i0 from "@angular/core";
import * as i1 from "../../logger/services/logger.service";
import * as i2 from "../category-factory/category-factory";
/**
* Holds information about the filter that is currently applied to the view component, that provides this services.
*/
export class SearchService {
_log;
_categoryFactory;
/**
* {@link Filter} that is applied to the view, even if the user doesn't search anything.
*/
_baseFilter;
/**
* Holds the {@link Predicate} tree root for user search queries.
*/
_rootPredicate;
/**
* Holds the {@link Filter} that is currently being applied to the view.
*/
_activeFilter;
/**
* Holds the full text {@link Filter} if set, `undefined` otherwise.
*/
_fullTextFilter;
/**
* The index of a removed {@link Predicate} is emmited into this stream
*/
_predicateRemoved$;
_loadingFromMetadata$;
/**
* The `rootPredicate` uses this stream to notify the search service about changes to the held query
*/
_predicateQueryChanged$;
subFilter;
/**
* 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.
*/
constructor(_log, _categoryFactory, baseFilter) {
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((filter) => {
this._baseFilter = filter.clone();
this.updateActiveFilter();
});
}
this.predicateQueryChanged$.subscribe(() => {
this.updateActiveFilter();
});
}
ngOnDestroy() {
this._predicateRemoved$.complete();
this._activeFilter.complete();
this._predicateQueryChanged$.complete();
if (this.subFilter) {
this.subFilter.unsubscribe();
}
this._loadingFromMetadata$.complete();
this._rootPredicate.destroy();
}
/**
* @returns the Filter that is currently applied to the view
*/
get activeFilter() {
return this._activeFilter.getValue();
}
/**
* @returns an `Observable` that updates every time the active Filter changes.
*/
get activeFilter$() {
return this._activeFilter.asObservable();
}
/**
* @returns `true` if a filter other than the base filter is currently applied.
* Returns `false` if only the base filter is currently applied.
*/
get additionalFiltersApplied() {
return !this._rootPredicate.query.isEmpty || !!this._fullTextFilter;
}
/**
* @returns `true` if any visible predicates are applied.
* Returns `false` if there are no predicates, or if there are only hidden predicates applied
*/
get hasVisiblePredicates() {
for (const predicate of this._rootPredicate.getPredicateMap().values()) {
if (predicate.isVisible) {
return true;
}
}
return false;
}
/**
* @returns a copy of the base filter
*/
get baseFilter() {
return this._baseFilter.clone();
}
/**
* @returns an Observable that emits the index of the removed predicate whenever a predicate is removed
*/
get predicateRemoved$() {
return this._predicateRemoved$.asObservable();
}
/**
* @returns the root predicate of the search service, that can be used to generate search requests with custom queries
*/
get rootPredicate() {
return this._rootPredicate;
}
/**
* @returns the type of the filter held in this search service instance
*/
get filterType() {
return this.baseFilter.type;
}
/**
* @returns whether the search service is currently loading its state from metadata or not.
*
* See [loadFromMetadata()]{@link SearchService#loadFromMetadata}
*/
get loadingFromMetadata() {
return this._loadingFromMetadata$.value;
}
/**
* @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 loadingFromMetadata$() {
return this._loadingFromMetadata$.asObservable();
}
/**
* @returns an Observable that emits whenever the root predicates query changes
*/
get predicateQueryChanged$() {
return this._predicateQueryChanged$.asObservable().pipe(map(() => this._rootPredicate.query), distinctUntilChanged((prev, curr) => prev && prev.equals(curr)));
}
/**
* 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
*/
addPredicate(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.
*/
addGeneratedLeafPredicate(generator) {
const branchId = this._rootPredicate.addNewClausePredicate(BooleanOperator.OR, false);
const 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
*/
removePredicate(index, clearInput = true) {
if (this._rootPredicate.removePredicate(index)) {
this._predicateRemoved$.next({ index, 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
*/
clearPredicates(clearHidden = false) {
if (this._rootPredicate.getPredicateMap().size > 0) {
for (const [id, predicate] of this._rootPredicate.getPredicateMap().entries()) {
if (clearHidden || predicate.isVisible) {
this.removePredicate(id);
}
}
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
*/
setFullTextFilter(searchedSubstring) {
const whiteSpacedSubstring = searchedSubstring?.replace(/ /g, '\\ ');
this._fullTextFilter = new SimpleFilter('', this._baseFilter.type, { fullText: whiteSpacedSubstring });
this.updateActiveFilter();
}
/**
* Clears the full text filter (if set). If the full text filter is not set, does nothing.
*/
clearFullTextFilter() {
const 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.
*/
show(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.
*/
updateActiveFilter() {
let 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.
*/
createPredicateMetadata() {
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
*/
loadFromMetadata(metadata) {
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();
const generatorObservables = [];
if (Array.isArray(metadata.predicateMetadata)) {
for (const clause of metadata.predicateMetadata) {
const branchId = this._rootPredicate.addNewClausePredicate(BooleanOperator.OR);
const branchPredicate = this._rootPredicate.getPredicateMap().get(branchId)
.getWrappedPredicate();
for (const predicate of clause) {
const localBranchReference = branchPredicate;
generatorObservables.push(this._categoryFactory.getFromMetadata(predicate).pipe(tap(generator => {
localBranchReference.addNewPredicateFromGenerator(generator);
})));
}
}
}
forkJoin(generatorObservables).subscribe(() => {
this._loadingFromMetadata$.off();
this.updateActiveFilter();
});
}
/**
* @returns an Array of filter text segments that correspond to the currently displayed completed predicates
*/
createFilterTextSegments() {
return this._rootPredicate.createFilterTextSegments();
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SearchService, deps: [{ token: i1.LoggerService }, { token: i2.CategoryFactory, optional: true }, { token: NAE_BASE_FILTER }], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SearchService });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SearchService, decorators: [{
type: Injectable
}], ctorParameters: () => [{ type: i1.LoggerService }, { type: i2.CategoryFactory, decorators: [{
type: Optional
}] }, { type: undefined, decorators: [{
type: Inject,
args: [NAE_BASE_FILTER]
}] }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"","sources":["../../../../../../projects/netgrif-components-core/src/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        const whiteSpacedSubstring = searchedSubstring?.replace(/ /g, '\\\\ ');\n        this._fullTextFilter = new SimpleFilter('', this._baseFilter.type, {fullText: whiteSpacedSubstring});\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        if (Array.isArray(metadata.predicateMetadata)) {\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\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"]}