@netgrif/components-core 6.0.1

package/esm2015/lib/filter/models/simple-filter.js

@@ -0,0 +1,91 @@
+import { Filter } from './filter';
+import { MergedFilter } from './merged-filter';
+import { FilterType } from './filter-type';
+/**
+ * Holds backend search request data and allows limited manipulation with it.
+ */
+export class SimpleFilter extends Filter {
+    /**
+     * @param id identifier of the filter
+     * @param type type of resources that the filter can query
+     * @param filterBody search request matching this filter's `type`
+     * @param title human readable filter name
+     */
+    constructor(id, type, filterBody, title) {
+        super(id, type, title);
+        this._filter = this.deepCopy(filterBody);
+    }
+    /**
+     * Create an empty filter of provided type
+     * @param type type of resources that the filter can query
+     * @returns a filter with empty body of the provided type. `id` of the new filter is set to an empty string.
+     */
+    static empty(type) {
+        return new SimpleFilter('', type, {});
+    }
+    /**
+     * Equivalent to calling `SimpleFilter.empty(FilterType.CASE)`.
+     * @returns a filter with empty body that can be used to search cases
+     */
+    static emptyCaseFilter() {
+        return SimpleFilter.empty(FilterType.CASE);
+    }
+    /**
+     * Equivalent to calling `SimpleFilter.empty(FilterType.TASK)`.
+     * @returns a filter with empty body that can be used to search tasks
+     */
+    static emptyTaskFilter() {
+        return SimpleFilter.empty(FilterType.TASK);
+    }
+    /**
+     * Creates a filter with the provided body and the provided type
+     * @param filterBody the body of the new filter
+     * @param type the type of the new filter. Type must match the type of the body.
+     * @returns a filter with the given body and type. `id` of the new filter is set to an empty string.
+     */
+    static fromQuery(filterBody, type) {
+        return new SimpleFilter('', type, filterBody);
+    }
+    /**
+     * Creates a case filter with the provided body
+     * @param filterBody the body of the new filter
+     * @returns a case filter with the given body. `id` of the new filter is set to an empty string.
+     */
+    static fromCaseQuery(filterBody) {
+        return SimpleFilter.fromQuery(filterBody, FilterType.CASE);
+    }
+    /**
+     * Creates a task filter with the provided body
+     * @param filterBody the body of the new filter
+     * @returns a task filter with the given body. `id` of the new filter is set to an empty string.
+     */
+    static fromTaskQuery(filterBody) {
+        return SimpleFilter.fromQuery(filterBody, FilterType.TASK);
+    }
+    /**
+     * See [Filter.clone()]{@link Filter#clone}
+     */
+    clone() {
+        return new SimpleFilter(this.id, this.type, this._filter, this.title);
+    }
+    /**
+     * See [Filter.merge()]{@link Filter#merge}
+     */
+    merge(filter, operator) {
+        const temp = new MergedFilter(this.id, this.type, [this._filter], operator, this.title);
+        return temp.merge(filter, operator);
+    }
+    /**
+     * See [Filter.bodyContainsQuery()]{@link Filter#bodyContainsQuery}
+     */
+    bodyContainsQuery() {
+        return this._filter.query !== undefined && this._filter.query !== null;
+    }
+    /**
+     * See [Filter.getRequestBody()]{@link Filter#getRequestBody}
+     */
+    getRequestBody() {
+        return this.deepCopy(this._filter);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-filter.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/filter/models/simple-filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAG7C,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAEzC;;GAEG;AACH,MAAM,OAAO,YAAa,SAAQ,MAAM;IA6DpC;;;;;OAKG;IACH,YAAY,EAAU,EAAE,IAAgB,EAAE,UAAyD,EAAE,KAAc;QAC/G,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACvB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC7C,CAAC;IA9DD;;;;OAIG;IACI,MAAM,CAAC,KAAK,CAAC,IAAgB;QAChC,OAAO,IAAI,YAAY,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,eAAe;QACzB,OAAO,YAAY,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,eAAe;QACzB,OAAO,YAAY,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,SAAS,CAAC,UAAyD,EAAE,IAAgB;QAC/F,OAAO,IAAI,YAAY,CAAC,EAAE,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,aAAa,CAAC,UAAiC;QACzD,OAAO,YAAY,CAAC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/D,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,aAAa,CAAC,UAAiC;QACzD,OAAO,YAAY,CAAC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/D,CAAC;IAaD;;OAEG;IACH,KAAK;QACD,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1E,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAc,EAAE,QAAuB;QACzC,MAAM,IAAI,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACxF,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,iBAAiB;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC;IAC3E,CAAC;IAED;;OAEG;IACH,cAAc;QACV,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAkD,CAAC;IACxF,CAAC;CACJ","sourcesContent":["import {Filter} from './filter';\nimport {MergeOperator} from './merge-operator';\nimport {MergedFilter} from './merged-filter';\nimport {TaskSearchRequestBody} from './task-search-request-body';\nimport {CaseSearchRequestBody} from './case-search-request-body';\nimport {FilterType} from './filter-type';\n\n/**\n * Holds backend search request data and allows limited manipulation with it.\n */\nexport class SimpleFilter extends Filter {\n\n    /**\n     * @ignore\n     * Stores the underlying filter data\n     */\n    private readonly _filter: CaseSearchRequestBody | TaskSearchRequestBody;\n\n    /**\n     * Create an empty filter of provided type\n     * @param type type of resources that the filter can query\n     * @returns a filter with empty body of the provided type. `id` of the new filter is set to an empty string.\n     */\n    public static empty(type: FilterType): Filter {\n        return new SimpleFilter('', type, {});\n    }\n\n    /**\n     * Equivalent to calling `SimpleFilter.empty(FilterType.CASE)`.\n     * @returns a filter with empty body that can be used to search cases\n     */\n    public static emptyCaseFilter(): Filter {\n        return SimpleFilter.empty(FilterType.CASE);\n    }\n\n    /**\n     * Equivalent to calling `SimpleFilter.empty(FilterType.TASK)`.\n     * @returns a filter with empty body that can be used to search tasks\n     */\n    public static emptyTaskFilter(): Filter {\n        return SimpleFilter.empty(FilterType.TASK);\n    }\n\n    /**\n     * Creates a filter with the provided body and the provided type\n     * @param filterBody the body of the new filter\n     * @param type the type of the new filter. Type must match the type of the body.\n     * @returns a filter with the given body and type. `id` of the new filter is set to an empty string.\n     */\n    public static fromQuery(filterBody: CaseSearchRequestBody | TaskSearchRequestBody, type: FilterType): Filter {\n        return new SimpleFilter('', type, filterBody);\n    }\n\n    /**\n     * Creates a case filter with the provided body\n     * @param filterBody the body of the new filter\n     * @returns a case filter with the given body. `id` of the new filter is set to an empty string.\n     */\n    public static fromCaseQuery(filterBody: CaseSearchRequestBody): Filter {\n        return SimpleFilter.fromQuery(filterBody, FilterType.CASE);\n    }\n\n    /**\n     * Creates a task filter with the provided body\n     * @param filterBody the body of the new filter\n     * @returns a task filter with the given body. `id` of the new filter is set to an empty string.\n     */\n    public static fromTaskQuery(filterBody: TaskSearchRequestBody): Filter {\n        return SimpleFilter.fromQuery(filterBody, FilterType.TASK);\n    }\n\n    /**\n     * @param id identifier of the filter\n     * @param type type of resources that the filter can query\n     * @param filterBody search request matching this filter's `type`\n     * @param title human readable filter name\n     */\n    constructor(id: string, type: FilterType, filterBody: CaseSearchRequestBody | TaskSearchRequestBody, title?: string) {\n        super(id, type, title);\n        this._filter = this.deepCopy(filterBody);\n    }\n\n    /**\n     * See [Filter.clone()]{@link Filter#clone}\n     */\n    clone(): Filter {\n        return new SimpleFilter(this.id, this.type, this._filter, this.title);\n    }\n\n    /**\n     * See [Filter.merge()]{@link Filter#merge}\n     */\n    merge(filter: Filter, operator: MergeOperator): MergedFilter {\n        const temp = new MergedFilter(this.id, this.type, [this._filter], operator, this.title);\n        return temp.merge(filter, operator);\n    }\n\n    /**\n     * See [Filter.bodyContainsQuery()]{@link Filter#bodyContainsQuery}\n     */\n    bodyContainsQuery(): boolean {\n        return this._filter.query !== undefined && this._filter.query !== null;\n    }\n\n    /**\n     * See [Filter.getRequestBody()]{@link Filter#getRequestBody}\n     */\n    getRequestBody(): TaskSearchRequestBody | CaseSearchRequestBody {\n        return this.deepCopy(this._filter) as CaseSearchRequestBody | TaskSearchRequestBody;\n    }\n}\n"]}

package/esm2015/lib/filter/models/task-search-request-body.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/filter/models/user-filter-constants.js

@@ -0,0 +1,39 @@
+/**
+ * Holds all identifiers of the Filter process in an accessible manner
+ */
+export var UserFilterConstants;
+(function (UserFilterConstants) {
+    /**
+     * Identifier of the filter process
+     */
+    UserFilterConstants["FILTER_NET_IDENTIFIER"] = "filter";
+    /**
+     * Transition ID of the "Set filter metadata" transition used for setting filter metadata to new filter cases
+     */
+    UserFilterConstants["SET_FILTER_METADATA_TRANSITION_ID"] = "frontend_create";
+    /**
+     * Transition ID of the "New Filter" transition displayed in the side menu
+     */
+    UserFilterConstants["NEW_FILTER_TRANSITION_ID"] = "newFilter";
+    /**
+     * ID of the field containing the saved filter
+     */
+    UserFilterConstants["FILTER_FIELD_ID"] = "filter";
+    /**
+     * ID of the field containing the saved filter type
+     */
+    UserFilterConstants["FILTER_TYPE_FIELD_ID"] = "filter_type";
+    /**
+     * ID of the field containing the viewId of the filters origin (if the filter originates from an app view)
+     */
+    UserFilterConstants["ORIGIN_VIEW_ID_FIELD_ID"] = "origin_view_id";
+    /**
+     * ID of the field containing the filter case ID
+     */
+    UserFilterConstants["FILTER_CASE_ID_FIELD_ID"] = "filter_case_id";
+    /**
+     * ID of the field containing the filter case ID of the parent filter (if the filter has a filter parent)
+     */
+    UserFilterConstants["PARENT_FILTER_CASE_ID_FIELD_ID"] = "parent_filter_id";
+})(UserFilterConstants || (UserFilterConstants = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/filter/public-api.js

@@ -0,0 +1,18 @@
+/* SERVICES */
+export * from './filter.repository';
+export * from './user-filters.service';
+/* CLASSES */
+export * from './models/filter';
+export * from './models/simple-filter';
+export * from './models/merged-filter';
+/* ENUMS */
+export * from './models/merge-operator';
+export * from './models/filter-type';
+export * from './models/user-filter-constants';
+/* INTERFACES */
+export * from './models/case-search-request-body';
+export * from './models/task-search-request-body';
+export * from './models/merged-filter-params';
+/* TOKENS */
+export * from './models/filters-filter-injection-token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9maWx0ZXIvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHdCQUF3QixDQUFDO0FBRXZDLGFBQWE7QUFDYixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxXQUFXO0FBQ1gsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsZ0NBQWdDLENBQUM7QUFFL0MsZ0JBQWdCO0FBQ2hCLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLCtCQUErQixDQUFDO0FBRTlDLFlBQVk7QUFDWixjQUFjLHlDQUF5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyogU0VSVklDRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vZmlsdGVyLnJlcG9zaXRvcnknO1xuZXhwb3J0ICogZnJvbSAnLi91c2VyLWZpbHRlcnMuc2VydmljZSc7XG5cbi8qIENMQVNTRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL2ZpbHRlcic7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9zaW1wbGUtZmlsdGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL21lcmdlZC1maWx0ZXInO1xuXG4vKiBFTlVNUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvbWVyZ2Utb3BlcmF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvZmlsdGVyLXR5cGUnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvdXNlci1maWx0ZXItY29uc3RhbnRzJztcblxuLyogSU5URVJGQUNFUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvY2FzZS1zZWFyY2gtcmVxdWVzdC1ib2R5JztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3Rhc2stc2VhcmNoLXJlcXVlc3QtYm9keSc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9tZXJnZWQtZmlsdGVyLXBhcmFtcyc7XG5cbi8qIFRPS0VOUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvZmlsdGVycy1maWx0ZXItaW5qZWN0aW9uLXRva2VuJztcbiJdfQ==

package/esm2015/lib/filter/user-filters.service.js

@@ -0,0 +1,337 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { of, ReplaySubject } from 'rxjs';
+import { CaseResourceService } from '../resources/engine-endpoint/case-resource.service';
+import { TaskResourceService } from '../resources/engine-endpoint/task-resource.service';
+import { ProcessService } from '../process/process.service';
+import { LoggerService } from '../logger/services/logger.service';
+import { filter, take } from 'rxjs/operators';
+import { SimpleFilter } from './models/simple-filter';
+import { hasContent } from '../utility/pagination/page-has-content';
+import { CallChainService } from '../utility/call-chain/call-chain.service';
+import { FieldTypeResource } from '../task-content/model/field-type-resource';
+import { UserFilterConstants } from './models/user-filter-constants';
+import { SideMenuSize } from '../side-menu/models/side-menu-size';
+import { SideMenuService } from '../side-menu/services/side-menu.service';
+import { NAE_LOAD_FILTER_COMPONENT, NAE_SAVE_FILTER_COMPONENT } from '../side-menu/content-components/injection-tokens';
+import { FilterType } from './models/filter-type';
+import { MergeOperator } from './models/merge-operator';
+import { CategoryResolverService } from '../search/category-factory/category-resolver.service';
+import { getFieldFromDataGroups } from '../utility/get-field';
+import * as i0 from "@angular/core";
+import * as i1 from "../resources/engine-endpoint/case-resource.service";
+import * as i2 from "../resources/engine-endpoint/task-resource.service";
+import * as i3 from "../process/process.service";
+import * as i4 from "../utility/call-chain/call-chain.service";
+import * as i5 from "../side-menu/services/side-menu.service";
+import * as i6 from "../logger/services/logger.service";
+import * as i7 from "../search/category-factory/category-resolver.service";
+import * as i8 from "../side-menu/content-components/injection-tokens";
+/**
+ * Service that manages filters created by users of the application.
+ */
+export class UserFiltersService {
+    constructor(_caseService, _taskService, _processService, _callChainService, _sideMenuService, _log, _categoryResolverService, _saveFilterComponent, _loadFilterComponent) {
+        this._caseService = _caseService;
+        this._taskService = _taskService;
+        this._processService = _processService;
+        this._callChainService = _callChainService;
+        this._sideMenuService = _sideMenuService;
+        this._log = _log;
+        this._categoryResolverService = _categoryResolverService;
+        this._saveFilterComponent = _saveFilterComponent;
+        this._loadFilterComponent = _loadFilterComponent;
+        this._initialized$ = new ReplaySubject(1);
+        this._processService.getNet(UserFilterConstants.FILTER_NET_IDENTIFIER).subscribe(net => {
+            this._filterNet = net;
+            this._initialized$.next(true);
+        }, error => {
+            this._log.error(`Filter net could not be loaded with error`, error);
+            this._initialized$.next(false);
+        });
+    }
+    ngOnDestroy() {
+        this._initialized$.complete();
+    }
+    /**
+     * Deletes the specified filter case by its case id.
+     * @param filterCaseId StringId of the filter case that should be deleted
+     * @returns an Observable that emits `true` if the case was successfully deleted and `false` otherwise
+     */
+    delete(filterCaseId) {
+        const result$ = new ReplaySubject(1);
+        this._caseService.deleteCase(filterCaseId).subscribe((response) => {
+            if (response.success) {
+                this._log.debug('Filter case delete success', response);
+                result$.next(true);
+                result$.complete();
+            }
+            else {
+                this._log.error('Filter case delete failure', response);
+                result$.next(false);
+                result$.complete();
+            }
+        }, e => {
+            this._log.error('Filter case delete error', e);
+            result$.next(false);
+            result$.complete();
+        });
+        return result$.asObservable();
+    }
+    /**
+     * Opens a side menu with filter cases and allows the user to select one of them.
+     *
+     * The default filter constrains the cases to be instances of the filter process and to be filters of the specified type
+     * (`Case` or `Task`).
+     *
+     * @param filterType whether `Case` or `Task` user filters should be loaded
+     * @param additionalFilter additional constrains on the displayed user filter cases. Must be of type `Case`
+     * otherwise the method throws an error. If it is a {@link MergedFilter} must use the `AND` {@link MergeOperator} otherwise an error
+     * will be thrown
+     * @returns an Observable that emits the data necessary to reconstruct the selected filter, or `undefined` if no filter was selected
+     */
+    load(filterType, additionalFilter) {
+        if ((additionalFilter === null || additionalFilter === void 0 ? void 0 : additionalFilter.type) === FilterType.TASK) {
+            this._log.error('The additional filter applied to UserFiltersService.load() must be of type Case', additionalFilter);
+            throw Error('The additional filter applied to UserFiltersService.load() must be of type Case');
+        }
+        let filterCasesFilter = SimpleFilter.fromCaseQuery({
+            process: {
+                identifier: UserFilterConstants.FILTER_NET_IDENTIFIER
+            },
+            query: `dataSet.${UserFilterConstants.FILTER_TYPE_FIELD_ID}.keyValue:${filterType}`
+        });
+        if (!!additionalFilter) {
+            filterCasesFilter = filterCasesFilter.merge(additionalFilter, MergeOperator.AND);
+        }
+        const result = new ReplaySubject(1);
+        const ref = this._sideMenuService.open(this._loadFilterComponent, SideMenuSize.LARGE, {
+            filter: filterCasesFilter
+        });
+        ref.onClose.pipe(filter(e => !e.opened), take(1)).subscribe(event => {
+            if (event.message === 'Side menu closed unexpectedly') {
+                result.next();
+            }
+            else {
+                result.next(event.data);
+            }
+            result.complete();
+        });
+        return result.asObservable();
+    }
+    /**
+     * Saves the predicate filter contained in the provided {@link SearchService} instance.
+     *
+     * The base filter of the search service is not saved.
+     *
+     * A new filter case is created and the necessary filter information is set into it.
+     *
+     * Then a side menu with the filter is opened for the user to enter the name and other properties.
+     * The user can confirm or cancel the save by finishing the task in the side menu, or by canceling/closing.
+     *
+     * @param searchService search service containing a predicate filter, we want to save
+     * @param allowedNets allowed nets of the view, that contains the search service
+     * @param searchCategories search categories available in the saved advanced search component
+     * @param viewId the viewId of the view which contained the filter.
+     * If neither the `viewId` nor the `navigationItemTaskData` attribute is set the filter will be created as a new root filter
+     * without any parent filter link. This will most likely result in the filter being less restrictive than what
+     * the user sees in the current view, since the base filter of the view will NOT be saved alongside the saved filter.
+     * @param additionalData set data request body, that is sent to the filter in addition to the default body.
+     * The default body is applied first and can be overridden by this argument.
+     * @param withDefaultCategories Whether the saved filter should be saved with
+     * the [defaultSearchCategories]{@link FilterMetadata#defaultSearchCategories} flag set to `true`, or `false`.
+     * @param inheritAllowedNets Whether the saved filter should merge its allowed nets with the allowed nets provided by
+     * the {@link BaseAllowedNetsService}.
+     * @param navigationItemTaskData if provided then it implies the filter has a parent filter that created its host dynamic view.
+     * If this is the case the case ID of the parent filter will be set into the newly created filter case.
+     * If not set it implies this is a filter originating in an in-app view and its view id will be set into the created filter.
+     * @returns an observable that emits the id of the created Filter case instance or `undefined` if the user canceled the save process,
+     * or the filter could not be saved
+     */
+    save(searchService, allowedNets, searchCategories, viewId, additionalData = {}, withDefaultCategories = true, inheritAllowedNets = true, navigationItemTaskData = null) {
+        if (!searchService.additionalFiltersApplied) {
+            this._log.warn('The provided SearchService contains no filter besides the base filter. Nothing to save.');
+            return of(undefined);
+        }
+        const result = new ReplaySubject(1);
+        this.createFilterCaseAndSetData(searchService, allowedNets, searchCategories, viewId, additionalData, withDefaultCategories, inheritAllowedNets, navigationItemTaskData).subscribe(filterCaseId => {
+            const ref = this._sideMenuService.open(this._saveFilterComponent, SideMenuSize.LARGE, {
+                newFilterCaseId: filterCaseId
+            });
+            ref.onClose.pipe(filter(e => !e.opened), take(1)).subscribe(event => {
+                if (event.message === 'Side menu closed unexpectedly') {
+                    this.delete(filterCaseId);
+                    result.next();
+                }
+                else {
+                    result.next({
+                        filterCaseId,
+                        allowedNets: [...allowedNets],
+                        originViewId: viewId,
+                        filterMetadata: this.filterMetadataFromSearchService(searchService, searchCategories, withDefaultCategories, inheritAllowedNets),
+                        filter: SimpleFilter.fromQuery({ query: searchService.rootPredicate.query.value }, searchService.filterType)
+                    });
+                }
+                result.complete();
+            });
+        });
+        return result.asObservable();
+    }
+    /**
+     * Saves the predicate filter contained in the provided {@link SearchService} instance.
+     *
+     * The base filter of the search service is not saved.
+     *
+     * A new filter case is created and the necessary filter information is set into it.
+     *
+     * @param searchService search service containing a predicate filter, we want to save
+     * @param allowedNets allowed nets of the view, that contains the search service
+     * @param searchCategories search categories available in the saved advanced search component
+     * @param viewId the viewId of the view which contained the filter.
+     * If neither the `viewId` nor the `navigationItemTaskData` attribute is set the filter will be created as a new root filter
+     * without any parent filter link. This will most likely result in the filter being less restrictive than what
+     * the user sees in the current view, since the base filter of the view will NOT be saved alongside the saved filter.
+     * @param additionalData set data request body, that is sent to the filter in addition to the default body.
+     * The default body is applied first and can be overridden by this argument.
+     * @param withDefaultCategories Whether the saved filter should be saved with
+     * the [defaultSearchCategories]{@link FilterMetadata#defaultSearchCategories} flag set to `true`, or `false`.
+     * @param inheritAllowedNets Whether the saved filter should merge its allowed nets with the allowed nets provided by
+     * the {@link BaseAllowedNetsService}.
+     * @param navigationItemTaskData if provided then it implies the filter has a parent filter that created its host dynamic view.
+     * If this is the case the case ID of the parent filter will be set into the newly created filter case.
+     * If not set it implies this is a filter originating in an in-app view and its view id will be set into the created filter.
+     * @returns an observable that emits the id of the created Filter case instance
+     */
+    createFilterCaseAndSetData(searchService, allowedNets, searchCategories, viewId, additionalData = {}, withDefaultCategories = true, inheritAllowedNets = true, navigationItemTaskData = null) {
+        const result = new ReplaySubject(1);
+        this.whenInitialized(() => {
+            this._caseService.createCase({
+                title: this._filterNet.defaultCaseName,
+                netId: this._filterNet.stringId
+            }).subscribe(filterCase => {
+                this._taskService.getTasks(SimpleFilter.fromTaskQuery({
+                    case: {
+                        id: filterCase.outcome.aCase.stringId
+                    }
+                })).subscribe(page => {
+                    if (!hasContent(page)) {
+                        throw new Error('Expected filter process to contain tasks, but none were found!');
+                    }
+                    const initTask = page.content.find(task => task.transitionId === UserFilterConstants.SET_FILTER_METADATA_TRANSITION_ID);
+                    if (initTask === undefined) {
+                        throw new Error(`Expected filter process to contain task '${UserFilterConstants.SET_FILTER_METADATA_TRANSITION_ID}', but none was found!`);
+                    }
+                    const requestBody = {
+                        [UserFilterConstants.FILTER_TYPE_FIELD_ID]: {
+                            type: FieldTypeResource.ENUMERATION_MAP,
+                            value: searchService.filterType
+                        },
+                        [UserFilterConstants.FILTER_FIELD_ID]: {
+                            type: FieldTypeResource.FILTER,
+                            value: searchService.rootPredicate.query.value,
+                            allowedNets,
+                            filterMetadata: this.filterMetadataFromSearchService(searchService, searchCategories, withDefaultCategories, inheritAllowedNets)
+                        },
+                    };
+                    let parentFilterCaseIdField;
+                    if (navigationItemTaskData !== null && navigationItemTaskData !== undefined) {
+                        parentFilterCaseIdField = getFieldFromDataGroups(navigationItemTaskData, UserFilterConstants.FILTER_CASE_ID_FIELD_ID);
+                    }
+                    if (parentFilterCaseIdField !== undefined) {
+                        requestBody[UserFilterConstants.PARENT_FILTER_CASE_ID_FIELD_ID] = {
+                            type: FieldTypeResource.TEXT,
+                            value: parentFilterCaseIdField.value
+                        };
+                    }
+                    else if (viewId !== undefined || viewId !== '') {
+                        requestBody[UserFilterConstants.ORIGIN_VIEW_ID_FIELD_ID] = {
+                            type: FieldTypeResource.TEXT,
+                            value: viewId
+                        };
+                    }
+                    this.assignSetDataFinish(initTask, {
+                        [initTask.stringId]: Object.assign(Object.assign({}, requestBody), additionalData)
+                    }, this._callChainService.create(success => {
+                        if (!success) {
+                            throw new Error('Filter instance could not be initialized');
+                        }
+                        result.next(filterCase.outcome.aCase.stringId);
+                        result.complete();
+                    }));
+                });
+            });
+        }, 'saveWithSideMenu');
+        return result.asObservable();
+    }
+    whenInitialized(onSuccess, method, onFailure = () => {
+        this._log.error(`UserFilterService failed to initialize and the called method${method ? ' (' + method + ')' : ''} cannot be performed`);
+    }) {
+        this._initialized$.asObservable().pipe(take(1)).subscribe(initialized => {
+            initialized ? onSuccess() : onFailure();
+        });
+    }
+    // TODO 6.4.2021 IMPROVEMENT - extract similar method into some utility service
+    assignSetDataFinish(task, data, callChain) {
+        this._taskService.assignTask(task.stringId).subscribe(assignOutcome => {
+            if (assignOutcome.error) {
+                this._log.error(`Could not assign task '${task.title}'`, task, assignOutcome.error);
+                callChain.next(false);
+            }
+            this._taskService.setData(task.stringId, data).subscribe(() => {
+                this._taskService.finishTask(task.stringId).subscribe(finishOutcome => {
+                    if (finishOutcome.error) {
+                        this._log.error(`Could not finish task '${task.title}'`, task, finishOutcome.error);
+                        callChain.next(false);
+                    }
+                    callChain.next(true);
+                }, error => {
+                    this._log.error(`Could not finish task '${task.title}'`, task, error);
+                    callChain.next(false);
+                });
+            }, error => {
+                this._log.error(`Could not set data of task '${task.title}'`, task, data, error);
+                callChain.next(false);
+            });
+        }, error => {
+            this._log.error(`Could not assign task '${task.title}'`, task, error);
+            callChain.next(false);
+        });
+    }
+    filterMetadataFromSearchService(searchService, searchCategories, withDefaultCategories, inheritAllowedNets) {
+        return {
+            filterType: searchService.filterType,
+            predicateMetadata: searchService.createPredicateMetadata(),
+            searchCategories: searchCategories.map(c => this._categoryResolverService.serialize(c)),
+            defaultSearchCategories: withDefaultCategories,
+            inheritAllowedNets
+        };
+    }
+}
+UserFiltersService.ctorParameters = () => [
+    { type: CaseResourceService },
+    { type: TaskResourceService },
+    { type: ProcessService },
+    { type: CallChainService },
+    { type: SideMenuService },
+    { type: LoggerService },
+    { type: CategoryResolverService },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_SAVE_FILTER_COMPONENT,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_LOAD_FILTER_COMPONENT,] }] }
+];
+UserFiltersService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserFiltersService_Factory() { return new UserFiltersService(i0.ɵɵinject(i1.CaseResourceService), i0.ɵɵinject(i2.TaskResourceService), i0.ɵɵinject(i3.ProcessService), i0.ɵɵinject(i4.CallChainService), i0.ɵɵinject(i5.SideMenuService), i0.ɵɵinject(i6.LoggerService), i0.ɵɵinject(i7.CategoryResolverService), i0.ɵɵinject(i8.NAE_SAVE_FILTER_COMPONENT, 8), i0.ɵɵinject(i8.NAE_LOAD_FILTER_COMPONENT, 8)); }, token: UserFiltersService, providedIn: "root" });
+UserFiltersService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+UserFiltersService.ctorParameters = () => [
+    { type: CaseResourceService },
+    { type: TaskResourceService },
+    { type: ProcessService },
+    { type: CallChainService },
+    { type: SideMenuService },
+    { type: LoggerService },
+    { type: CategoryResolverService },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_SAVE_FILTER_COMPONENT,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_LOAD_FILTER_COMPONENT,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-filters.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/filter/user-filters.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy, Optional, Type} from '@angular/core';\nimport {Observable, of, ReplaySubject, Subject} from 'rxjs';\nimport {CaseResourceService} from '../resources/engine-endpoint/case-resource.service';\nimport {TaskResourceService} from '../resources/engine-endpoint/task-resource.service';\nimport {SearchService} from '../search/search-service/search.service';\nimport {ProcessService} from '../process/process.service';\nimport {LoggerService} from '../logger/services/logger.service';\nimport {filter, take} from 'rxjs/operators';\nimport {SimpleFilter} from './models/simple-filter';\nimport {hasContent} from '../utility/pagination/page-has-content';\nimport {Task} from '../resources/interface/task';\nimport {CallChainService} from '../utility/call-chain/call-chain.service';\nimport {TaskSetDataRequestBody, TaskSetDataRequestFields} from '../resources/interface/task-set-data-request-body';\nimport {FieldTypeResource} from '../task-content/model/field-type-resource';\nimport {Category} from '../search/models/category/category';\nimport {Net} from '../process/net';\nimport {UserFilterConstants} from './models/user-filter-constants';\nimport {SideMenuSize} from '../side-menu/models/side-menu-size';\nimport {SaveFilterInjectionData} from '../side-menu/content-components/save-filter/model/save-filter-injection-data';\nimport {SideMenuService} from '../side-menu/services/side-menu.service';\nimport {NAE_LOAD_FILTER_COMPONENT, NAE_SAVE_FILTER_COMPONENT} from '../side-menu/content-components/injection-tokens';\nimport {ComponentType} from '@angular/cdk/portal';\nimport {LoadFilterInjectionData} from '../side-menu/content-components/load-filter/model/load-filter-injection-data';\nimport {FilterType} from './models/filter-type';\nimport {Filter} from './models/filter';\nimport {MergeOperator} from './models/merge-operator';\nimport {SavedFilterMetadata} from '../search/models/persistance/saved-filter-metadata';\nimport {FilterMetadata} from '../search/models/persistance/filter-metadata';\nimport {CreateCaseEventOutcome} from '../event/model/event-outcomes/case-outcomes/create-case-event-outcome';\nimport {CategoryResolverService} from '../search/category-factory/category-resolver.service';\nimport {DataGroup} from '../resources/interface/data-groups';\nimport {getFieldFromDataGroups} from '../utility/get-field';\nimport {EventOutcomeMessageResource} from '../resources/interface/message-resource';\n\n/**\n * Service that manages filters created by users of the application.\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class UserFiltersService implements OnDestroy {\n\n    protected _initialized$: ReplaySubject<boolean>;\n    protected _filterNet: Net;\n\n    constructor(protected _caseService: CaseResourceService,\n                protected _taskService: TaskResourceService,\n                protected _processService: ProcessService,\n                protected _callChainService: CallChainService,\n                protected _sideMenuService: SideMenuService,\n                protected _log: LoggerService,\n                protected _categoryResolverService: CategoryResolverService,\n                @Optional() @Inject(NAE_SAVE_FILTER_COMPONENT) protected _saveFilterComponent: ComponentType<unknown>,\n                @Optional() @Inject(NAE_LOAD_FILTER_COMPONENT) protected _loadFilterComponent: ComponentType<unknown>) {\n        this._initialized$ = new ReplaySubject<boolean>(1);\n        this._processService.getNet(UserFilterConstants.FILTER_NET_IDENTIFIER).subscribe(net => {\n            this._filterNet = net;\n            this._initialized$.next(true);\n        }, error => {\n            this._log.error(`Filter net could not be loaded with error`, error);\n            this._initialized$.next(false);\n        });\n    }\n\n    ngOnDestroy(): void {\n        this._initialized$.complete();\n    }\n\n    /**\n     * Deletes the specified filter case by its case id.\n     * @param filterCaseId StringId of the filter case that should be deleted\n     * @returns an Observable that emits `true` if the case was successfully deleted and `false` otherwise\n     */\n    public delete(filterCaseId: string): Observable<boolean> {\n        const result$ = new ReplaySubject<boolean>(1);\n        this._caseService.deleteCase(filterCaseId).subscribe((response: EventOutcomeMessageResource) => {\n            if (response.success) {\n                this._log.debug('Filter case delete success', response);\n                result$.next(true);\n                result$.complete();\n            } else {\n                this._log.error('Filter case delete failure', response);\n                result$.next(false);\n                result$.complete();\n            }\n        }, e => {\n            this._log.error('Filter case delete error', e);\n            result$.next(false);\n            result$.complete();\n        });\n        return result$.asObservable();\n    }\n\n    /**\n     * Opens a side menu with filter cases and allows the user to select one of them.\n     *\n     * The default filter constrains the cases to be instances of the filter process and to be filters of the specified type\n     * (`Case` or `Task`).\n     *\n     * @param filterType whether `Case` or `Task` user filters should be loaded\n     * @param additionalFilter additional constrains on the displayed user filter cases. Must be of type `Case`\n     * otherwise the method throws an error. If it is a {@link MergedFilter} must use the `AND` {@link MergeOperator} otherwise an error\n     * will be thrown\n     * @returns an Observable that emits the data necessary to reconstruct the selected filter, or `undefined` if no filter was selected\n     */\n    public load(filterType: FilterType, additionalFilter?: Filter): Observable<any> {\n        if (additionalFilter?.type === FilterType.TASK) {\n            this._log.error('The additional filter applied to UserFiltersService.load() must be of type Case', additionalFilter);\n            throw Error('The additional filter applied to UserFiltersService.load() must be of type Case');\n        }\n\n        let filterCasesFilter = SimpleFilter.fromCaseQuery({\n            process: {\n                identifier: UserFilterConstants.FILTER_NET_IDENTIFIER\n            },\n            query: `dataSet.${UserFilterConstants.FILTER_TYPE_FIELD_ID}.keyValue:${filterType}`\n        });\n        if (!!additionalFilter) {\n            filterCasesFilter = filterCasesFilter.merge(additionalFilter, MergeOperator.AND);\n        }\n\n        const result = new ReplaySubject<any>(1);\n        const ref = this._sideMenuService.open(this._loadFilterComponent, SideMenuSize.LARGE, {\n            filter: filterCasesFilter\n        } as LoadFilterInjectionData);\n        ref.onClose.pipe(filter(e => !e.opened), take(1)).subscribe(event => {\n            if (event.message === 'Side menu closed unexpectedly') {\n                result.next();\n            } else {\n                result.next(event.data);\n            }\n            result.complete();\n        });\n        return result.asObservable();\n    }\n\n    /**\n     * Saves the predicate filter contained in the provided {@link SearchService} instance.\n     *\n     * The base filter of the search service is not saved.\n     *\n     * A new filter case is created and the necessary filter information is set into it.\n     *\n     * Then a side menu with the filter is opened for the user to enter the name and other properties.\n     * The user can confirm or cancel the save by finishing the task in the side menu, or by canceling/closing.\n     *\n     * @param searchService search service containing a predicate filter, we want to save\n     * @param allowedNets allowed nets of the view, that contains the search service\n     * @param searchCategories search categories available in the saved advanced search component\n     * @param viewId the viewId of the view which contained the filter.\n     * If neither the `viewId` nor the `navigationItemTaskData` attribute is set the filter will be created as a new root filter\n     * without any parent filter link. This will most likely result in the filter being less restrictive than what\n     * the user sees in the current view, since the base filter of the view will NOT be saved alongside the saved filter.\n     * @param additionalData set data request body, that is sent to the filter in addition to the default body.\n     * The default body is applied first and can be overridden by this argument.\n     * @param withDefaultCategories Whether the saved filter should be saved with\n     * the [defaultSearchCategories]{@link FilterMetadata#defaultSearchCategories} flag set to `true`, or `false`.\n     * @param inheritAllowedNets Whether the saved filter should merge its allowed nets with the allowed nets provided by\n     * the {@link BaseAllowedNetsService}.\n     * @param navigationItemTaskData if provided then it implies the filter has a parent filter that created its host dynamic view.\n     * If this is the case the case ID of the parent filter will be set into the newly created filter case.\n     * If not set it implies this is a filter originating in an in-app view and its view id will be set into the created filter.\n     * @returns an observable that emits the id of the created Filter case instance or `undefined` if the user canceled the save process,\n     * or the filter could not be saved\n     */\n    public save(searchService: SearchService,\n                allowedNets: ReadonlyArray<string>,\n                searchCategories: ReadonlyArray<Type<Category<any>>>,\n                viewId?: string,\n                additionalData: TaskSetDataRequestFields = {},\n                withDefaultCategories = true,\n                inheritAllowedNets = true,\n                navigationItemTaskData: Array<DataGroup> = null): Observable<SavedFilterMetadata> {\n        if (!searchService.additionalFiltersApplied) {\n            this._log.warn('The provided SearchService contains no filter besides the base filter. Nothing to save.');\n            return of(undefined);\n        }\n\n        const result = new ReplaySubject<SavedFilterMetadata>(1);\n        this.createFilterCaseAndSetData(\n            searchService,\n            allowedNets,\n            searchCategories,\n            viewId,\n            additionalData,\n            withDefaultCategories,\n            inheritAllowedNets,\n            navigationItemTaskData\n        ).subscribe(filterCaseId => {\n            const ref = this._sideMenuService.open(this._saveFilterComponent, SideMenuSize.LARGE, {\n                newFilterCaseId: filterCaseId\n            } as SaveFilterInjectionData);\n            ref.onClose.pipe(filter(e => !e.opened), take(1)).subscribe(event => {\n                if (event.message === 'Side menu closed unexpectedly') {\n                    this.delete(filterCaseId);\n                    result.next();\n                } else {\n                    result.next({\n                        filterCaseId,\n                        allowedNets: [...allowedNets],\n                        originViewId: viewId,\n                        filterMetadata: this.filterMetadataFromSearchService(\n                            searchService,\n                            searchCategories,\n                            withDefaultCategories,\n                            inheritAllowedNets\n                        ),\n                        filter: SimpleFilter.fromQuery({query: searchService.rootPredicate.query.value}, searchService.filterType)\n                    });\n                }\n                result.complete();\n            });\n        });\n        return result.asObservable();\n    }\n\n    /**\n     * Saves the predicate filter contained in the provided {@link SearchService} instance.\n     *\n     * The base filter of the search service is not saved.\n     *\n     * A new filter case is created and the necessary filter information is set into it.\n     *\n     * @param searchService search service containing a predicate filter, we want to save\n     * @param allowedNets allowed nets of the view, that contains the search service\n     * @param searchCategories search categories available in the saved advanced search component\n     * @param viewId the viewId of the view which contained the filter.\n     * If neither the `viewId` nor the `navigationItemTaskData` attribute is set the filter will be created as a new root filter\n     * without any parent filter link. This will most likely result in the filter being less restrictive than what\n     * the user sees in the current view, since the base filter of the view will NOT be saved alongside the saved filter.\n     * @param additionalData set data request body, that is sent to the filter in addition to the default body.\n     * The default body is applied first and can be overridden by this argument.\n     * @param withDefaultCategories Whether the saved filter should be saved with\n     * the [defaultSearchCategories]{@link FilterMetadata#defaultSearchCategories} flag set to `true`, or `false`.\n     * @param inheritAllowedNets Whether the saved filter should merge its allowed nets with the allowed nets provided by\n     * the {@link BaseAllowedNetsService}.\n     * @param navigationItemTaskData if provided then it implies the filter has a parent filter that created its host dynamic view.\n     * If this is the case the case ID of the parent filter will be set into the newly created filter case.\n     * If not set it implies this is a filter originating in an in-app view and its view id will be set into the created filter.\n     * @returns an observable that emits the id of the created Filter case instance\n     */\n    public createFilterCaseAndSetData(searchService: SearchService,\n                                      allowedNets: ReadonlyArray<string>,\n                                      searchCategories: ReadonlyArray<Type<Category<any>>>,\n                                      viewId?: string,\n                                      additionalData: TaskSetDataRequestFields = {},\n                                      withDefaultCategories = true,\n                                      inheritAllowedNets = true,\n                                      navigationItemTaskData: Array<DataGroup> = null): Observable<string> {\n        const result = new ReplaySubject<string>(1);\n        this.whenInitialized(() => {\n            this._caseService.createCase({\n                title: this._filterNet.defaultCaseName,\n                netId: this._filterNet.stringId\n            }).subscribe(filterCase => {\n                this._taskService.getTasks(SimpleFilter.fromTaskQuery({\n                    case: {\n                        id: (filterCase.outcome as CreateCaseEventOutcome).aCase.stringId\n                    }\n                })).subscribe(page => {\n                    if (!hasContent(page)) {\n                        throw new Error('Expected filter process to contain tasks, but none were found!');\n                    }\n\n                    const initTask = page.content.find(task => task.transitionId === UserFilterConstants.SET_FILTER_METADATA_TRANSITION_ID);\n                    if (initTask === undefined) {\n                        throw new Error(`Expected filter process to contain task '${UserFilterConstants.SET_FILTER_METADATA_TRANSITION_ID\n                        }', but none was found!`);\n                    }\n\n                    const requestBody = {\n                        [UserFilterConstants.FILTER_TYPE_FIELD_ID]: {\n                            type: FieldTypeResource.ENUMERATION_MAP,\n                            value: searchService.filterType\n                        },\n                        [UserFilterConstants.FILTER_FIELD_ID]: {\n                            type: FieldTypeResource.FILTER,\n                            value: searchService.rootPredicate.query.value,\n                            allowedNets,\n                            filterMetadata: this.filterMetadataFromSearchService(\n                                searchService,\n                                searchCategories,\n                                withDefaultCategories,\n                                inheritAllowedNets\n                            )\n                        },\n                    };\n\n                    let parentFilterCaseIdField;\n                    if (navigationItemTaskData !== null && navigationItemTaskData !== undefined) {\n                        parentFilterCaseIdField = getFieldFromDataGroups(navigationItemTaskData,\n                            UserFilterConstants.FILTER_CASE_ID_FIELD_ID);\n                    }\n\n                    if (parentFilterCaseIdField !== undefined) {\n                        requestBody[UserFilterConstants.PARENT_FILTER_CASE_ID_FIELD_ID] = {\n                            type: FieldTypeResource.TEXT,\n                            value: parentFilterCaseIdField.value\n                        };\n                    } else if (viewId !== undefined || viewId !== '') {\n                        requestBody[UserFilterConstants.ORIGIN_VIEW_ID_FIELD_ID] = {\n                            type: FieldTypeResource.TEXT,\n                            value: viewId\n                        };\n                    }\n\n                    this.assignSetDataFinish(initTask, {\n                        [initTask.stringId]: {\n                            ...requestBody,\n                            ...additionalData\n                        }\n                    }, this._callChainService.create(success => {\n                        if (!success) {\n                            throw new Error('Filter instance could not be initialized');\n                        }\n\n                        result.next((filterCase.outcome as CreateCaseEventOutcome).aCase.stringId);\n                        result.complete();\n                    }));\n                });\n            });\n        }, 'saveWithSideMenu');\n        return result.asObservable();\n    }\n\n    protected whenInitialized(onSuccess: () => void,\n                              method?: string,\n                              onFailure: () => void = () => {\n                                  this._log.error(`UserFilterService failed to initialize and the called method${\n                                      method ? ' (' + method + ')' : ''\n                                  } cannot be performed`);\n                              }) {\n        this._initialized$.asObservable().pipe(take(1)).subscribe(initialized => {\n            initialized ? onSuccess() : onFailure();\n        });\n    }\n\n    // TODO 6.4.2021 IMPROVEMENT - extract similar method into some utility service\n    protected assignSetDataFinish(task: Task, data: TaskSetDataRequestBody, callChain: Subject<boolean>): void {\n        this._taskService.assignTask(task.stringId).subscribe(assignOutcome => {\n            if (assignOutcome.error) {\n                this._log.error(`Could not assign task '${task.title}'`, task, assignOutcome.error);\n                callChain.next(false);\n            }\n\n            this._taskService.setData(task.stringId, data).subscribe(() => {\n                this._taskService.finishTask(task.stringId).subscribe(finishOutcome => {\n                    if (finishOutcome.error) {\n                        this._log.error(`Could not finish task '${task.title}'`, task, finishOutcome.error);\n                        callChain.next(false);\n                    }\n\n                    callChain.next(true);\n                }, error => {\n                    this._log.error(`Could not finish task '${task.title}'`, task, error);\n                    callChain.next(false);\n                });\n            }, error => {\n                this._log.error(`Could not set data of task '${task.title}'`, task, data, error);\n                callChain.next(false);\n            });\n        }, error => {\n            this._log.error(`Could not assign task '${task.title}'`, task, error);\n            callChain.next(false);\n        });\n    }\n\n    protected filterMetadataFromSearchService(searchService: SearchService,\n                                              searchCategories: ReadonlyArray<Type<Category<any>>>,\n                                              withDefaultCategories: boolean,\n                                              inheritAllowedNets: boolean): FilterMetadata {\n        return {\n            filterType: searchService.filterType,\n            predicateMetadata: searchService.createPredicateMetadata(),\n            searchCategories: searchCategories.map(c => this._categoryResolverService.serialize(c)),\n            defaultSearchCategories: withDefaultCategories,\n            inheritAllowedNets\n        };\n    }\n}\n"]}