@netgrif/components-core 6.0.1

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

@@ -0,0 +1,357 @@
+import { __assign, __read, __spread } from "tslib";
+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.
+ */
+var UserFiltersService = /** @class */ (function () {
+    function UserFiltersService(_caseService, _taskService, _processService, _callChainService, _sideMenuService, _log, _categoryResolverService, _saveFilterComponent, _loadFilterComponent) {
+        var _this = this;
+        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(function (net) {
+            _this._filterNet = net;
+            _this._initialized$.next(true);
+        }, function (error) {
+            _this._log.error("Filter net could not be loaded with error", error);
+            _this._initialized$.next(false);
+        });
+    }
+    UserFiltersService.prototype.ngOnDestroy = function () {
+        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
+     */
+    UserFiltersService.prototype.delete = function (filterCaseId) {
+        var _this = this;
+        var result$ = new ReplaySubject(1);
+        this._caseService.deleteCase(filterCaseId).subscribe(function (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();
+            }
+        }, function (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
+     */
+    UserFiltersService.prototype.load = function (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');
+        }
+        var 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);
+        }
+        var result = new ReplaySubject(1);
+        var ref = this._sideMenuService.open(this._loadFilterComponent, SideMenuSize.LARGE, {
+            filter: filterCasesFilter
+        });
+        ref.onClose.pipe(filter(function (e) { return !e.opened; }), take(1)).subscribe(function (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
+     */
+    UserFiltersService.prototype.save = function (searchService, allowedNets, searchCategories, viewId, additionalData, withDefaultCategories, inheritAllowedNets, navigationItemTaskData) {
+        var _this = this;
+        if (additionalData === void 0) { additionalData = {}; }
+        if (withDefaultCategories === void 0) { withDefaultCategories = true; }
+        if (inheritAllowedNets === void 0) { inheritAllowedNets = true; }
+        if (navigationItemTaskData === void 0) { navigationItemTaskData = null; }
+        if (!searchService.additionalFiltersApplied) {
+            this._log.warn('The provided SearchService contains no filter besides the base filter. Nothing to save.');
+            return of(undefined);
+        }
+        var result = new ReplaySubject(1);
+        this.createFilterCaseAndSetData(searchService, allowedNets, searchCategories, viewId, additionalData, withDefaultCategories, inheritAllowedNets, navigationItemTaskData).subscribe(function (filterCaseId) {
+            var ref = _this._sideMenuService.open(_this._saveFilterComponent, SideMenuSize.LARGE, {
+                newFilterCaseId: filterCaseId
+            });
+            ref.onClose.pipe(filter(function (e) { return !e.opened; }), take(1)).subscribe(function (event) {
+                if (event.message === 'Side menu closed unexpectedly') {
+                    _this.delete(filterCaseId);
+                    result.next();
+                }
+                else {
+                    result.next({
+                        filterCaseId: filterCaseId,
+                        allowedNets: __spread(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
+     */
+    UserFiltersService.prototype.createFilterCaseAndSetData = function (searchService, allowedNets, searchCategories, viewId, additionalData, withDefaultCategories, inheritAllowedNets, navigationItemTaskData) {
+        var _this = this;
+        if (additionalData === void 0) { additionalData = {}; }
+        if (withDefaultCategories === void 0) { withDefaultCategories = true; }
+        if (inheritAllowedNets === void 0) { inheritAllowedNets = true; }
+        if (navigationItemTaskData === void 0) { navigationItemTaskData = null; }
+        var result = new ReplaySubject(1);
+        this.whenInitialized(function () {
+            _this._caseService.createCase({
+                title: _this._filterNet.defaultCaseName,
+                netId: _this._filterNet.stringId
+            }).subscribe(function (filterCase) {
+                _this._taskService.getTasks(SimpleFilter.fromTaskQuery({
+                    case: {
+                        id: filterCase.outcome.aCase.stringId
+                    }
+                })).subscribe(function (page) {
+                    var _a, _b;
+                    if (!hasContent(page)) {
+                        throw new Error('Expected filter process to contain tasks, but none were found!');
+                    }
+                    var initTask = page.content.find(function (task) { return 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!");
+                    }
+                    var requestBody = (_a = {},
+                        _a[UserFilterConstants.FILTER_TYPE_FIELD_ID] = {
+                            type: FieldTypeResource.ENUMERATION_MAP,
+                            value: searchService.filterType
+                        },
+                        _a[UserFilterConstants.FILTER_FIELD_ID] = {
+                            type: FieldTypeResource.FILTER,
+                            value: searchService.rootPredicate.query.value,
+                            allowedNets: allowedNets,
+                            filterMetadata: _this.filterMetadataFromSearchService(searchService, searchCategories, withDefaultCategories, inheritAllowedNets)
+                        },
+                        _a);
+                    var 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, (_b = {},
+                        _b[initTask.stringId] = __assign(__assign({}, requestBody), additionalData),
+                        _b), _this._callChainService.create(function (success) {
+                        if (!success) {
+                            throw new Error('Filter instance could not be initialized');
+                        }
+                        result.next(filterCase.outcome.aCase.stringId);
+                        result.complete();
+                    }));
+                });
+            });
+        }, 'saveWithSideMenu');
+        return result.asObservable();
+    };
+    UserFiltersService.prototype.whenInitialized = function (onSuccess, method, onFailure) {
+        var _this = this;
+        if (onFailure === void 0) { onFailure = function () {
+            _this._log.error("UserFilterService failed to initialize and the called method" + (method ? ' (' + method + ')' : '') + " cannot be performed");
+        }; }
+        this._initialized$.asObservable().pipe(take(1)).subscribe(function (initialized) {
+            initialized ? onSuccess() : onFailure();
+        });
+    };
+    // TODO 6.4.2021 IMPROVEMENT - extract similar method into some utility service
+    UserFiltersService.prototype.assignSetDataFinish = function (task, data, callChain) {
+        var _this = this;
+        this._taskService.assignTask(task.stringId).subscribe(function (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(function () {
+                _this._taskService.finishTask(task.stringId).subscribe(function (finishOutcome) {
+                    if (finishOutcome.error) {
+                        _this._log.error("Could not finish task '" + task.title + "'", task, finishOutcome.error);
+                        callChain.next(false);
+                    }
+                    callChain.next(true);
+                }, function (error) {
+                    _this._log.error("Could not finish task '" + task.title + "'", task, error);
+                    callChain.next(false);
+                });
+            }, function (error) {
+                _this._log.error("Could not set data of task '" + task.title + "'", task, data, error);
+                callChain.next(false);
+            });
+        }, function (error) {
+            _this._log.error("Could not assign task '" + task.title + "'", task, error);
+            callChain.next(false);
+        });
+    };
+    UserFiltersService.prototype.filterMetadataFromSearchService = function (searchService, searchCategories, withDefaultCategories, inheritAllowedNets) {
+        var _this = this;
+        return {
+            filterType: searchService.filterType,
+            predicateMetadata: searchService.createPredicateMetadata(),
+            searchCategories: searchCategories.map(function (c) { return _this._categoryResolverService.serialize(c); }),
+            defaultSearchCategories: withDefaultCategories,
+            inheritAllowedNets: inheritAllowedNets
+        };
+    };
+    UserFiltersService.ctorParameters = function () { return [
+        { 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 = function () { return [
+        { 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,] }] }
+    ]; };
+    return UserFiltersService;
+}());
+export { UserFiltersService };
+//# 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"]}

package/esm5/lib/forms/email-submission/abstract-email-submission-form.component.js

@@ -0,0 +1,33 @@
+import { EventEmitter, Input, Output } from '@angular/core';
+import { Validators } from '@angular/forms';
+var AbstractEmailSubmissionFormComponent = /** @class */ (function () {
+    function AbstractEmailSubmissionFormComponent(formBuilder) {
+        this.displayLegalNotice = true;
+        this.rootFormGroup = formBuilder.group({
+            email: ['', Validators.email]
+        });
+        this.formSubmit = new EventEmitter();
+        this.goBackButton = new EventEmitter();
+    }
+    AbstractEmailSubmissionFormComponent.prototype.ngOnDestroy = function () {
+        this.formSubmit.complete();
+        this.goBackButton.complete();
+    };
+    AbstractEmailSubmissionFormComponent.prototype.emitGoBack = function () {
+        this.goBackButton.emit();
+    };
+    AbstractEmailSubmissionFormComponent.prototype.onSubmit = function () {
+        if (!this.rootFormGroup.valid) {
+            return;
+        }
+        this.formSubmit.emit({ email: this.rootFormGroup.controls['email'].value });
+    };
+    AbstractEmailSubmissionFormComponent.propDecorators = {
+        displayLegalNotice: [{ type: Input }],
+        formSubmit: [{ type: Output }],
+        goBackButton: [{ type: Output }]
+    };
+    return AbstractEmailSubmissionFormComponent;
+}());
+export { AbstractEmailSubmissionFormComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/forms/forgotten-password/abstract-forgotten-password.component.js

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { AbstractRegistrationComponent } from '../models/abstract-registration.component';
+import { passwordValidator } from '../models/password.validator';
+import { Validators } from '@angular/forms';
+import { Input } from '@angular/core';
+var AbstractForgottenPasswordComponent = /** @class */ (function (_super) {
+    __extends(AbstractForgottenPasswordComponent, _super);
+    function AbstractForgottenPasswordComponent(formBuilder, signupService, log, translate) {
+        var _this = _super.call(this, signupService, log, translate) || this;
+        _this.displayLegalNotice = false;
+        _this.rootFormGroup = formBuilder.group({
+            password: ['', [Validators.required, Validators.minLength(_this.MIN_PASSWORD_LENGTH)]],
+            confirmPassword: ['', [Validators.required, Validators.minLength(_this.MIN_PASSWORD_LENGTH)]]
+        }, { validator: passwordValidator });
+        return _this;
+    }
+    AbstractForgottenPasswordComponent.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+    };
+    AbstractForgottenPasswordComponent.prototype.createRequestBody = function () {
+        return {
+            token: undefined,
+            name: undefined,
+            surname: undefined,
+            password: this.rootFormGroup.controls['password'].value
+        };
+    };
+    AbstractForgottenPasswordComponent.prototype.callRegistration = function (requestBody) {
+        return this._signupService.recoverPassword(requestBody.token, requestBody.password);
+    };
+    AbstractForgottenPasswordComponent.propDecorators = {
+        displayLegalNotice: [{ type: Input }]
+    };
+    return AbstractForgottenPasswordComponent;
+}(AbstractRegistrationComponent));
+export { AbstractForgottenPasswordComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/forms/has-form.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzLWZvcm0uanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvZm9ybXMvaGFzLWZvcm0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Rm9ybUdyb3VwfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQge0V2ZW50RW1pdHRlcn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgSGFzRm9ybSB7XG4gICAgcm9vdEZvcm1Hcm91cDogRm9ybUdyb3VwO1xuICAgIGZvcm1TdWJtaXQ6IEV2ZW50RW1pdHRlcjxGb3JtU3VibWl0RXZlbnQ+O1xuXG4gICAgb25TdWJtaXQoKTogdm9pZDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGb3JtU3VibWl0RXZlbnQge1xuICAgIFtrOiBzdHJpbmddOiBhbnk7XG59XG4iXX0=

package/esm5/lib/forms/login/abstract-login-form.component.js

@@ -0,0 +1,61 @@
+import { EventEmitter, Input, Output } from '@angular/core';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { take } from 'rxjs/operators';
+var AbstractLoginFormComponent = /** @class */ (function () {
+    function AbstractLoginFormComponent(formBuilder, _userService) {
+        this._userService = _userService;
+        this.hidePassword = true;
+        this.rootFormGroup = formBuilder.group({
+            login: [''],
+            password: ['']
+        });
+        this.login = new EventEmitter();
+        this.resetPassword = new EventEmitter();
+        this.signUp = new EventEmitter();
+        this.formSubmit = new EventEmitter();
+        this.loading = new LoadingEmitter();
+    }
+    AbstractLoginFormComponent.prototype.ngOnDestroy = function () {
+        this.loading.complete();
+        this.login.complete();
+        this.resetPassword.complete();
+        this.signUp.complete();
+        this.formSubmit.complete();
+    };
+    AbstractLoginFormComponent.prototype.onSubmit = function () {
+        var _this = this;
+        if (!this.rootFormGroup.valid || this.loading.isActive) {
+            return;
+        }
+        var credential = { username: this.rootFormGroup.controls['login'].value, password: this.rootFormGroup.controls['password'].value };
+        this.loading.on();
+        this.formSubmit.emit(credential);
+        this._userService.login(credential).pipe(take(1)).subscribe(function (user) {
+            _this.login.emit(user);
+            _this.loading.off();
+        });
+    };
+    AbstractLoginFormComponent.prototype.resetEmit = function () {
+        this.resetPassword.emit();
+    };
+    AbstractLoginFormComponent.prototype.signUpEmit = function () {
+        this.signUp.emit();
+    };
+    AbstractLoginFormComponent.prototype.getButtonsFxLayoutAlign = function () {
+        if (this.showSignUpButton || this.showForgottenPasswordButton) {
+            return 'space-between';
+        }
+        return 'end';
+    };
+    AbstractLoginFormComponent.propDecorators = {
+        showSignUpButton: [{ type: Input }],
+        showForgottenPasswordButton: [{ type: Input }],
+        login: [{ type: Output }],
+        resetPassword: [{ type: Output }],
+        signUp: [{ type: Output }],
+        formSubmit: [{ type: Output }]
+    };
+    return AbstractLoginFormComponent;
+}());
+export { AbstractLoginFormComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtbG9naW4tZm9ybS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvZm9ybXMvbG9naW4vYWJzdHJhY3QtbG9naW4tZm9ybS5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFlBQVksRUFBRSxLQUFLLEVBQWEsTUFBTSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBS3JFLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSwrQkFBK0IsQ0FBQztBQUM3RCxPQUFPLEVBQUMsSUFBSSxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFFcEM7SUFhSSxvQ0FBc0IsV0FBd0IsRUFBWSxZQUF5QjtRQUF6QixpQkFBWSxHQUFaLFlBQVksQ0FBYTtRQVY1RSxpQkFBWSxHQUFHLElBQUksQ0FBQztRQVd2QixJQUFJLENBQUMsYUFBYSxHQUFHLFdBQVcsQ0FBQyxLQUFLLENBQUM7WUFDbkMsS0FBSyxFQUFFLENBQUMsRUFBRSxDQUFDO1lBQ1gsUUFBUSxFQUFFLENBQUMsRUFBRSxDQUFDO1NBQ2pCLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxZQUFZLEVBQVEsQ0FBQztRQUN0QyxJQUFJLENBQUMsYUFBYSxHQUFHLElBQUksWUFBWSxFQUFRLENBQUM7UUFDOUMsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLFlBQVksRUFBUSxDQUFDO1FBQ3ZDLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxZQUFZLEVBQW1CLENBQUM7UUFDdEQsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLGNBQWMsRUFBRSxDQUFDO0lBQ3hDLENBQUM7SUFFRCxnREFBVyxHQUFYO1FBQ0ksSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN4QixJQUFJLENBQUMsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ3RCLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDOUIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN2QixJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQy9CLENBQUM7SUFFRCw2Q0FBUSxHQUFSO1FBQUEsaUJBWUM7UUFYRyxJQUFJLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxLQUFLLElBQUksSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUU7WUFDcEQsT0FBTztTQUNWO1FBQ0QsSUFBTSxVQUFVLEdBQUcsRUFBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUMsS0FBSyxFQUFFLFFBQVEsRUFBRSxJQUFJLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQyxLQUFLLEVBQUMsQ0FBQztRQUVuSSxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQ2xCLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ2pDLElBQUksQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsVUFBQyxJQUFVO1lBQ25FLEtBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3RCLEtBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDdkIsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQsOENBQVMsR0FBVDtRQUNJLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDOUIsQ0FBQztJQUVELCtDQUFVLEdBQVY7UUFDSSxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3ZCLENBQUM7SUFFRCw0REFBdUIsR0FBdkI7UUFDSSxJQUFJLElBQUksQ0FBQyxnQkFBZ0IsSUFBSSxJQUFJLENBQUMsMkJBQTJCLEVBQUU7WUFDM0QsT0FBTyxlQUFlLENBQUM7U0FDMUI7UUFDRCxPQUFPLEtBQUssQ0FBQztJQUNqQixDQUFDOzttQ0F0REEsS0FBSzs4Q0FDTCxLQUFLO3dCQUNMLE1BQU07Z0NBQ04sTUFBTTt5QkFDTixNQUFNOzZCQUNOLE1BQU07O0lBa0RYLGlDQUFDO0NBQUEsQUE3REQsSUE2REM7U0E3RHFCLDBCQUEwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RXZlbnRFbWl0dGVyLCBJbnB1dCwgT25EZXN0cm95LCBPdXRwdXR9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtGb3JtQnVpbGRlciwgRm9ybUdyb3VwfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQge0Zvcm1TdWJtaXRFdmVudCwgSGFzRm9ybX0gZnJvbSAnLi4vaGFzLWZvcm0nO1xuaW1wb3J0IHtVc2VyU2VydmljZX0gZnJvbSAnLi4vLi4vdXNlci9zZXJ2aWNlcy91c2VyLnNlcnZpY2UnO1xuaW1wb3J0IHtVc2VyfSBmcm9tICcuLi8uLi91c2VyL21vZGVscy91c2VyJztcbmltcG9ydCB7TG9hZGluZ0VtaXR0ZXJ9IGZyb20gJy4uLy4uL3V0aWxpdHkvbG9hZGluZy1lbWl0dGVyJztcbmltcG9ydCB7dGFrZX0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RMb2dpbkZvcm1Db21wb25lbnQgaW1wbGVtZW50cyBIYXNGb3JtLCBPbkRlc3Ryb3kge1xuXG4gICAgcHVibGljIHJvb3RGb3JtR3JvdXA6IEZvcm1Hcm91cDtcbiAgICBwdWJsaWMgaGlkZVBhc3N3b3JkID0gdHJ1ZTtcbiAgICBwdWJsaWMgbG9hZGluZzogTG9hZGluZ0VtaXR0ZXI7XG5cbiAgICBASW5wdXQoKSBwdWJsaWMgc2hvd1NpZ25VcEJ1dHRvbjogYm9vbGVhbjtcbiAgICBASW5wdXQoKSBwdWJsaWMgc2hvd0ZvcmdvdHRlblBhc3N3b3JkQnV0dG9uOiBib29sZWFuO1xuICAgIEBPdXRwdXQoKSBwdWJsaWMgbG9naW46IEV2ZW50RW1pdHRlcjxVc2VyPjtcbiAgICBAT3V0cHV0KCkgcHVibGljIHJlc2V0UGFzc3dvcmQ6IEV2ZW50RW1pdHRlcjx2b2lkPjtcbiAgICBAT3V0cHV0KCkgcHVibGljIHNpZ25VcDogRXZlbnRFbWl0dGVyPHZvaWQ+O1xuICAgIEBPdXRwdXQoKSBwdWJsaWMgZm9ybVN1Ym1pdDogRXZlbnRFbWl0dGVyPEZvcm1TdWJtaXRFdmVudD47XG5cbiAgICBwcm90ZWN0ZWQgY29uc3RydWN0b3IoZm9ybUJ1aWxkZXI6IEZvcm1CdWlsZGVyLCBwcm90ZWN0ZWQgX3VzZXJTZXJ2aWNlOiBVc2VyU2VydmljZSkge1xuICAgICAgICB0aGlzLnJvb3RGb3JtR3JvdXAgPSBmb3JtQnVpbGRlci5ncm91cCh7XG4gICAgICAgICAgICBsb2dpbjogWycnXSxcbiAgICAgICAgICAgIHBhc3N3b3JkOiBbJyddXG4gICAgICAgIH0pO1xuICAgICAgICB0aGlzLmxvZ2luID0gbmV3IEV2ZW50RW1pdHRlcjxVc2VyPigpO1xuICAgICAgICB0aGlzLnJlc2V0UGFzc3dvcmQgPSBuZXcgRXZlbnRFbWl0dGVyPHZvaWQ+KCk7XG4gICAgICAgIHRoaXMuc2lnblVwID0gbmV3IEV2ZW50RW1pdHRlcjx2b2lkPigpO1xuICAgICAgICB0aGlzLmZvcm1TdWJtaXQgPSBuZXcgRXZlbnRFbWl0dGVyPEZvcm1TdWJtaXRFdmVudD4oKTtcbiAgICAgICAgdGhpcy5sb2FkaW5nID0gbmV3IExvYWRpbmdFbWl0dGVyKCk7XG4gICAgfVxuXG4gICAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgICAgIHRoaXMubG9hZGluZy5jb21wbGV0ZSgpO1xuICAgICAgICB0aGlzLmxvZ2luLmNvbXBsZXRlKCk7XG4gICAgICAgIHRoaXMucmVzZXRQYXNzd29yZC5jb21wbGV0ZSgpO1xuICAgICAgICB0aGlzLnNpZ25VcC5jb21wbGV0ZSgpO1xuICAgICAgICB0aGlzLmZvcm1TdWJtaXQuY29tcGxldGUoKTtcbiAgICB9XG5cbiAgICBvblN1Ym1pdCgpIHtcbiAgICAgICAgaWYgKCF0aGlzLnJvb3RGb3JtR3JvdXAudmFsaWQgfHwgdGhpcy5sb2FkaW5nLmlzQWN0aXZlKSB7XG4gICAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cbiAgICAgICAgY29uc3QgY3JlZGVudGlhbCA9IHt1c2VybmFtZTogdGhpcy5yb290Rm9ybUdyb3VwLmNvbnRyb2xzWydsb2dpbiddLnZhbHVlLCBwYXNzd29yZDogdGhpcy5yb290Rm9ybUdyb3VwLmNvbnRyb2xzWydwYXNzd29yZCddLnZhbHVlfTtcblxuICAgICAgICB0aGlzLmxvYWRpbmcub24oKTtcbiAgICAgICAgdGhpcy5mb3JtU3VibWl0LmVtaXQoY3JlZGVudGlhbCk7XG4gICAgICAgIHRoaXMuX3VzZXJTZXJ2aWNlLmxvZ2luKGNyZWRlbnRpYWwpLnBpcGUodGFrZSgxKSkuc3Vic2NyaWJlKCh1c2VyOiBVc2VyKSA9PiB7XG4gICAgICAgICAgICB0aGlzLmxvZ2luLmVtaXQodXNlcik7XG4gICAgICAgICAgICB0aGlzLmxvYWRpbmcub2ZmKCk7XG4gICAgICAgIH0pO1xuICAgIH1cblxuICAgIHJlc2V0RW1pdCgpIHtcbiAgICAgICAgdGhpcy5yZXNldFBhc3N3b3JkLmVtaXQoKTtcbiAgICB9XG5cbiAgICBzaWduVXBFbWl0KCkge1xuICAgICAgICB0aGlzLnNpZ25VcC5lbWl0KCk7XG4gICAgfVxuXG4gICAgZ2V0QnV0dG9uc0Z4TGF5b3V0QWxpZ24oKTogc3RyaW5nIHtcbiAgICAgICAgaWYgKHRoaXMuc2hvd1NpZ25VcEJ1dHRvbiB8fCB0aGlzLnNob3dGb3Jnb3R0ZW5QYXNzd29yZEJ1dHRvbikge1xuICAgICAgICAgICAgcmV0dXJuICdzcGFjZS1iZXR3ZWVuJztcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gJ2VuZCc7XG4gICAgfVxufVxuIl19