@netgrif/components-core 6.0.1

package/esm5/lib/view/tree-case-view/tree-component/model/case-tree-node.js

@@ -0,0 +1,106 @@
+import { LoadingEmitter } from '../../../../utility/loading-emitter';
+import { TreePetriflowIdentifiers } from '../../model/tree-petriflow-identifiers';
+var CaseTreeNode = /** @class */ (function () {
+    function CaseTreeNode(nodeCase, parentNode) {
+        this.case = nodeCase;
+        this.children = [];
+        this.dirtyChildren = true;
+        this.loadingChildren = new LoadingEmitter();
+        this.removingNode = new LoadingEmitter();
+        this.addingNode = new LoadingEmitter();
+        this.parent = parentNode;
+    }
+    /**
+     * @returns whether this node has the value `true` in it's [immediate data field]{@link TreePetriflowIdentifiers#CAN_ADD_CHILDREN}
+     * that controls this behavior.
+     */
+    CaseTreeNode.prototype.canAddChildren = function () {
+        var immediate = this.searchImmediateData(TreePetriflowIdentifiers.CAN_ADD_CHILDREN);
+        return !!immediate && immediate.value;
+    };
+    /**
+     * @returns whether this node has the value `true` in it's [immediate data field]{@link TreePetriflowIdentifiers#CAN_REMOVE_NODE}
+     * that controls this behavior.
+     */
+    CaseTreeNode.prototype.canBeRemoved = function () {
+        var immediate = this.searchImmediateData(TreePetriflowIdentifiers.CAN_REMOVE_NODE);
+        return this.parent && !!immediate && immediate.value;
+    };
+    /**
+     * @returns whether this node's children are currently being loaded
+     */
+    CaseTreeNode.prototype.isLoadingChildren = function () {
+        return this.loadingChildren.isActive;
+    };
+    /**
+     * @returns whether this node is being removed from the tree
+     */
+    CaseTreeNode.prototype.isBeingRemoved = function () {
+        return this.removingNode.isActive;
+    };
+    /**
+     * @returns whether children are being added to this node
+     */
+    CaseTreeNode.prototype.isAddingNode = function () {
+        return this.addingNode.isActive;
+    };
+    /**
+     * @returns return node value, if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#BEFORE_TEXT_ICON} type exists
+     */
+    CaseTreeNode.prototype.beforeTextIcon = function () {
+        var immediate = this.searchImmediateData(TreePetriflowIdentifiers.BEFORE_TEXT_ICON);
+        if (immediate === undefined) {
+            return undefined;
+        }
+        return immediate.value;
+    };
+    /**
+     * @returns return node value, if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#TREE_ADD_ICON} type exists
+     */
+    CaseTreeNode.prototype.treeAddTextIcon = function () {
+        var immediate = this.searchImmediateData(TreePetriflowIdentifiers.TREE_ADD_ICON);
+        if (immediate === undefined) {
+            return undefined;
+        }
+        return immediate.value;
+    };
+    /**
+     * @returns return node title, if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#BEFORE_TEXT_ICON} type exists
+     */
+    CaseTreeNode.prototype.beforeTextIconTitle = function () {
+        var immediate = this.searchImmediateData(TreePetriflowIdentifiers.BEFORE_TEXT_ICON);
+        if (immediate === undefined || !(immediate.name && immediate.name.defaultValue)) {
+            return undefined;
+        }
+        return immediate.name.defaultValue;
+    };
+    /**
+     * @returns return node title if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#TREE_ADD_ICON} type exists
+     */
+    CaseTreeNode.prototype.treeAddTextIconTitle = function () {
+        var immediate = this.searchImmediateData(TreePetriflowIdentifiers.TREE_ADD_ICON);
+        if (immediate === undefined || !(immediate.name && immediate.name.defaultValue)) {
+            return undefined;
+        }
+        return immediate.name.defaultValue;
+    };
+    CaseTreeNode.prototype.searchImmediateData = function (dataId) {
+        return this.case.immediateData.find(function (data) { return data.stringId === dataId; });
+    };
+    /**
+     * @returns an object representing the same CaseTreeNode, but with circular references removed, so that it can be serialized and logged.
+     * The [parent]{@link CaseTreeNode#parent} reference is replaced by the parents case stringId (if defined).
+     * The [children]{@link CaseTreeNode#children} references are replaced by the child's case stringId (if defined).
+     */
+    CaseTreeNode.prototype.toLoggableForm = function () {
+        return {
+            case: this.case,
+            dirtyChildren: this.dirtyChildren,
+            parent: this.parent ? this.parent.case.stringId : this.parent,
+            children: this.children.map(function (c) { return c.case.stringId; }),
+        };
+    };
+    return CaseTreeNode;
+}());
+export { CaseTreeNode };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-tree-node.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/view/tree-case-view/tree-component/model/case-tree-node.ts"],"names":[],"mappings":"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","sourcesContent":["import {Case} from '../../../../resources/interface/case';\nimport {LoadingEmitter} from '../../../../utility/loading-emitter';\nimport {TreePetriflowIdentifiers} from '../../model/tree-petriflow-identifiers';\nimport {ImmediateData} from '../../../../resources/interface/immediate-data';\n\nexport class CaseTreeNode {\n    public case: Case;\n    public children: Array<CaseTreeNode>;\n    public dirtyChildren: boolean;\n    public loadingChildren: LoadingEmitter;\n    public removingNode: LoadingEmitter;\n    public addingNode: LoadingEmitter;\n    public parent: CaseTreeNode;\n\n    constructor(nodeCase: Case, parentNode: CaseTreeNode) {\n        this.case = nodeCase;\n        this.children = [];\n        this.dirtyChildren = true;\n        this.loadingChildren = new LoadingEmitter();\n        this.removingNode = new LoadingEmitter();\n        this.addingNode = new LoadingEmitter();\n        this.parent = parentNode;\n    }\n\n    /**\n     * @returns whether this node has the value `true` in it's [immediate data field]{@link TreePetriflowIdentifiers#CAN_ADD_CHILDREN}\n     * that controls this behavior.\n     */\n    public canAddChildren(): boolean {\n        const immediate = this.searchImmediateData(TreePetriflowIdentifiers.CAN_ADD_CHILDREN);\n        return !!immediate && immediate.value;\n    }\n\n    /**\n     * @returns whether this node has the value `true` in it's [immediate data field]{@link TreePetriflowIdentifiers#CAN_REMOVE_NODE}\n     * that controls this behavior.\n     */\n    public canBeRemoved(): boolean {\n        const immediate = this.searchImmediateData(TreePetriflowIdentifiers.CAN_REMOVE_NODE);\n        return this.parent && !!immediate && immediate.value;\n    }\n\n    /**\n     * @returns whether this node's children are currently being loaded\n     */\n    public isLoadingChildren(): boolean {\n        return this.loadingChildren.isActive;\n    }\n\n    /**\n     * @returns whether this node is being removed from the tree\n     */\n    public isBeingRemoved(): boolean {\n        return this.removingNode.isActive;\n    }\n\n    /**\n     * @returns whether children are being added to this node\n     */\n    public isAddingNode(): boolean {\n        return this.addingNode.isActive;\n    }\n\n    /**\n     * @returns return node value, if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#BEFORE_TEXT_ICON} type exists\n     */\n    public beforeTextIcon(): string {\n        const immediate = this.searchImmediateData(TreePetriflowIdentifiers.BEFORE_TEXT_ICON);\n        if (immediate === undefined) {\n            return undefined;\n        }\n        return immediate.value;\n    }\n\n    /**\n     * @returns return node value, if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#TREE_ADD_ICON} type exists\n     */\n    public treeAddTextIcon(): string {\n        const immediate = this.searchImmediateData(TreePetriflowIdentifiers.TREE_ADD_ICON);\n        if (immediate === undefined) {\n            return undefined;\n        }\n        return immediate.value;\n    }\n\n    /**\n     * @returns return node title, if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#BEFORE_TEXT_ICON} type exists\n     */\n    public beforeTextIconTitle(): string {\n        const immediate = this.searchImmediateData(TreePetriflowIdentifiers.BEFORE_TEXT_ICON);\n        if (immediate === undefined || !(immediate.name && immediate.name.defaultValue)) {\n            return undefined;\n        }\n        return immediate.name.defaultValue;\n    }\n\n    /**\n     * @returns return node title if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#TREE_ADD_ICON} type exists\n     */\n    public treeAddTextIconTitle(): string {\n        const immediate = this.searchImmediateData(TreePetriflowIdentifiers.TREE_ADD_ICON);\n        if (immediate === undefined || !(immediate.name && immediate.name.defaultValue)) {\n            return undefined;\n        }\n        return immediate.name.defaultValue;\n    }\n\n    private searchImmediateData(dataId: string): ImmediateData | undefined {\n        return this.case.immediateData.find(data => data.stringId === dataId);\n    }\n\n    /**\n     * @returns an object representing the same CaseTreeNode, but with circular references removed, so that it can be serialized and logged.\n     * The [parent]{@link CaseTreeNode#parent} reference is replaced by the parents case stringId (if defined).\n     * The [children]{@link CaseTreeNode#children} references are replaced by the child's case stringId (if defined).\n     */\n    public toLoggableForm(): object {\n        return {\n            case: this.case,\n            dirtyChildren: this.dirtyChildren,\n            parent: this.parent ? this.parent.case.stringId : this.parent,\n            children: this.children.map(c => c.case.stringId),\n        };\n    }\n}\n"]}

package/esm5/lib/view/tree-case-view/tree-component/model/case-tree-path.js

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

package/esm5/lib/view/tree-case-view/tree-component/model/expansion-tree.js

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

package/esm5/lib/view/tree-case-view/tree-component/remove-node/abstract-remove-node.component.js

@@ -0,0 +1,16 @@
+import { Input } from '@angular/core';
+var AbstractRemoveNodeComponent = /** @class */ (function () {
+    function AbstractRemoveNodeComponent(_treeService) {
+        this._treeService = _treeService;
+    }
+    AbstractRemoveNodeComponent.prototype.removeNode = function (event) {
+        event.stopPropagation();
+        this._treeService.removeNode(this.node);
+    };
+    AbstractRemoveNodeComponent.propDecorators = {
+        node: [{ type: Input }]
+    };
+    return AbstractRemoveNodeComponent;
+}());
+export { AbstractRemoveNodeComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtcmVtb3ZlLW5vZGUuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3ZpZXcvdHJlZS1jYXNlLXZpZXcvdHJlZS1jb21wb25lbnQvcmVtb3ZlLW5vZGUvYWJzdHJhY3QtcmVtb3ZlLW5vZGUuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxLQUFLLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFJcEM7SUFJSSxxQ0FBc0IsWUFBNkI7UUFBN0IsaUJBQVksR0FBWixZQUFZLENBQWlCO0lBQ25ELENBQUM7SUFFTSxnREFBVSxHQUFqQixVQUFrQixLQUFZO1FBQzFCLEtBQUssQ0FBQyxlQUFlLEVBQUUsQ0FBQztRQUN4QixJQUFJLENBQUMsWUFBWSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDNUMsQ0FBQzs7dUJBUkEsS0FBSzs7SUFVVixrQ0FBQztDQUFBLEFBWkQsSUFZQztTQVpxQiwyQkFBMkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0lucHV0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7Q2FzZVRyZWVOb2RlfSBmcm9tICcuLi9tb2RlbC9jYXNlLXRyZWUtbm9kZSc7XG5pbXBvcnQge0Nhc2VUcmVlU2VydmljZX0gZnJvbSAnLi4vY2FzZS10cmVlLnNlcnZpY2UnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RSZW1vdmVOb2RlQ29tcG9uZW50IHtcblxuICAgIEBJbnB1dCgpIG5vZGU6IENhc2VUcmVlTm9kZTtcblxuICAgIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBfdHJlZVNlcnZpY2U6IENhc2VUcmVlU2VydmljZSkge1xuICAgIH1cblxuICAgIHB1YmxpYyByZW1vdmVOb2RlKGV2ZW50OiBFdmVudCk6IHZvaWQge1xuICAgICAgICBldmVudC5zdG9wUHJvcGFnYXRpb24oKTtcbiAgICAgICAgdGhpcy5fdHJlZVNlcnZpY2UucmVtb3ZlTm9kZSh0aGlzLm5vZGUpO1xuICAgIH1cblxufVxuIl19

package/esm5/lib/view/tree-case-view/tree-task-content/abstract-tree-task-content.component.js

@@ -0,0 +1,66 @@
+import { Input } from '@angular/core';
+var AbstractTreeTaskContentComponent = /** @class */ (function () {
+    function AbstractTreeTaskContentComponent(_treeTaskContentService, _taskEventService, _assign, _cancel, _finish, _taskContentService, _permissionService) {
+        this._treeTaskContentService = _treeTaskContentService;
+        this._taskEventService = _taskEventService;
+        this._assign = _assign;
+        this._cancel = _cancel;
+        this._finish = _finish;
+        this._taskContentService = _taskContentService;
+        this._permissionService = _permissionService;
+        this.displayTaskControlButtons = true;
+    }
+    AbstractTreeTaskContentComponent.prototype.ngAfterViewInit = function () {
+        var _this = this;
+        setTimeout(function () {
+            _this._treeTaskContentService.displayEmptyTaskContent();
+        });
+    };
+    AbstractTreeTaskContentComponent.prototype.canAssign = function () {
+        return this._permissionService.canAssign(this._taskContentService.task);
+    };
+    AbstractTreeTaskContentComponent.prototype.canCancel = function () {
+        return this._permissionService.canCancel(this._taskContentService.task);
+    };
+    AbstractTreeTaskContentComponent.prototype.canFinish = function () {
+        return this._permissionService.canFinish(this._taskContentService.task);
+    };
+    AbstractTreeTaskContentComponent.prototype.assign = function () {
+        this._assign.assign();
+    };
+    AbstractTreeTaskContentComponent.prototype.cancel = function () {
+        this._cancel.cancel();
+    };
+    AbstractTreeTaskContentComponent.prototype.finish = function () {
+        this._finish.validateDataAndFinish();
+    };
+    AbstractTreeTaskContentComponent.prototype.getAssignTitle = function () {
+        return this._taskContentService.task.assignTitle ? this._taskContentService.task.assignTitle : 'tasks.view.assign';
+    };
+    AbstractTreeTaskContentComponent.prototype.getCancelTitle = function () {
+        return this._taskContentService.task.cancelTitle ? this._taskContentService.task.cancelTitle : 'tasks.view.cancel';
+    };
+    AbstractTreeTaskContentComponent.prototype.getFinishTitle = function () {
+        return this._taskContentService.task.finishTitle ? this._taskContentService.task.finishTitle : 'tasks.view.finish';
+    };
+    Object.defineProperty(AbstractTreeTaskContentComponent.prototype, "processingTaskChange", {
+        get: function () {
+            return this._treeTaskContentService.processingTaskChange;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractTreeTaskContentComponent.prototype, "taskContentText$", {
+        get: function () {
+            return this._treeTaskContentService.taskContentText$;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractTreeTaskContentComponent.propDecorators = {
+        displayTaskControlButtons: [{ type: Input }]
+    };
+    return AbstractTreeTaskContentComponent;
+}());
+export { AbstractTreeTaskContentComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/view/tree-case-view/tree-task-content/tree-task-content.service.js

@@ -0,0 +1,308 @@
+import { __read, __spread } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { TaskContentService } from '../../../task-content/services/task-content.service';
+import { TaskDataService } from '../../../task/services/task-data.service';
+import { CancelTaskService } from '../../../task/services/cancel-task.service';
+import { TaskEventService } from '../../../task-content/services/task-event.service';
+import { TaskResourceService } from '../../../resources/engine-endpoint/task-resource.service';
+import { TreeCaseViewService } from '../tree-case-view.service';
+import { AssignPolicyService } from '../../../task/services/assign-policy.service';
+import { AssignPolicy } from '../../../task-content/model/policy';
+import { NAE_TASK_OPERATIONS } from '../../../task/models/task-operations-injection-token';
+import { SubjectTaskOperations } from '../../../task/models/subject-task-operations';
+import { UserComparatorService } from '../../../user/services/user-comparator.service';
+import { TreePetriflowIdentifiers } from '../model/tree-petriflow-identifiers';
+import { CallChainService } from '../../../utility/call-chain/call-chain.service';
+import { LoadingEmitter } from '../../../utility/loading-emitter';
+import { ReplaySubject } from 'rxjs';
+import { hasContent } from '../../../utility/pagination/page-has-content';
+import { getImmediateData } from '../../../utility/get-immediate-data';
+import { filter } from 'rxjs/operators';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { SelectedCaseService } from '../../../task/services/selected-case.service';
+import { SimpleFilter } from '../../../filter/models/simple-filter';
+import { PermissionService } from '../../../authorization/permission/permission.service';
+import { ChangedFieldsService } from '../../../changed-fields/services/changed-fields.service';
+var TreeTaskContentService = /** @class */ (function () {
+    function TreeTaskContentService(_treeCaseService, _taskDataService, _taskContentService, _taskResourceService, _taskEventService, _assignPolicy, _cancel, _userComparator, _callchain, _logger, _selectedCaseService, _changedFieldsService, _permissionService, _taskOperations) {
+        var _this = this;
+        this._treeCaseService = _treeCaseService;
+        this._taskDataService = _taskDataService;
+        this._taskContentService = _taskContentService;
+        this._taskResourceService = _taskResourceService;
+        this._taskEventService = _taskEventService;
+        this._assignPolicy = _assignPolicy;
+        this._cancel = _cancel;
+        this._userComparator = _userComparator;
+        this._callchain = _callchain;
+        this._logger = _logger;
+        this._selectedCaseService = _selectedCaseService;
+        this._changedFieldsService = _changedFieldsService;
+        this._permissionService = _permissionService;
+        this._taskOperations = _taskOperations;
+        this._processingTaskChange = new LoadingEmitter();
+        this._displayedTaskText$ = new ReplaySubject();
+        this._changedFieldsService.changedFields$.subscribe(function (changedFieldsMap) {
+            var filteredCaseIds = Object.keys(changedFieldsMap).filter(function (caseId) { return Object.keys(_this._taskContentService.referencedTaskAndCaseIds).includes(caseId); });
+            var changedFields = [];
+            filteredCaseIds.forEach(function (caseId) {
+                var taskIds = _this._taskContentService.referencedTaskAndCaseIds[caseId];
+                changedFields.push.apply(changedFields, __spread(_this._changedFieldsService.parseChangedFieldsByCaseAndTaskIds(caseId, taskIds, changedFieldsMap)));
+            });
+            changedFields.filter(function (fields) { return fields !== undefined; }).forEach(function (fields) {
+                _this._taskContentService.updateFromChangedFields(fields);
+            });
+        });
+        _taskDataService.updateSuccess$.subscribe(function (result) {
+            if (result) {
+                _this._treeCaseService.reloadCase$.next();
+                _this.resolveTaskBlockState();
+            }
+        });
+        _treeCaseService.loadTask$.asObservable().pipe(filter(function (selectedCase) { return _this.taskChanged(selectedCase); })).subscribe(function (selectedCase) {
+            _this.cancelAndLoadFeaturedTask(selectedCase);
+        });
+        _taskOperations.reload$.subscribe(function () {
+            _this.updateTaskState();
+            _this._treeCaseService.reloadCase$.next();
+        });
+        _taskOperations.open$.subscribe(function () {
+            _this._taskContentService.blockFields(false);
+        });
+        _taskOperations.close$.subscribe(function () {
+            _this._taskContentService.blockFields(true);
+        });
+    }
+    Object.defineProperty(TreeTaskContentService.prototype, "taskContentText$", {
+        get: function () {
+            return this._displayedTaskText$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TreeTaskContentService.prototype, "processingTaskChange", {
+        get: function () {
+            return this._processingTaskChange.isActive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TreeTaskContentService.prototype.displayEmptyTaskContent = function () {
+        this._taskContentService.$shouldCreate.next([]);
+        this._displayedTaskText$.next('caseTree.noTaskSelected');
+    };
+    /**
+     * Cancels the currently selected {@link Task} if any. And then loads and assigns the new Task.
+     * @param selectedCase the Case who's task should be now displayed
+     */
+    TreeTaskContentService.prototype.cancelAndLoadFeaturedTask = function (selectedCase) {
+        var _this = this;
+        this._processingTaskChange.on();
+        this._taskContentService.blockFields(true);
+        if (this.shouldCancelTask) {
+            this._cancel.cancel(this._callchain.create(function (success) {
+                if (success) {
+                    _this._logger.debug('Old tree task successfully canceled');
+                }
+                else {
+                    _this._logger.warn('Old tree task could not be canceled');
+                }
+            }));
+        }
+        this.loadFeaturedTask(selectedCase);
+    };
+    /**
+     * Changes the currently displayed {@link Task} based on the selected {@link Case} from the Tree.
+     * @param selectedCase the Case who's task should be now displayed
+     */
+    TreeTaskContentService.prototype.loadFeaturedTask = function (selectedCase) {
+        var _this = this;
+        this._selectedCaseService.selectedCase = selectedCase;
+        var requestBody = this.getTaskFilter();
+        if (requestBody === undefined) {
+            this.clearCurrentTask();
+            return;
+        }
+        this._taskResourceService.getTasks(requestBody).subscribe(function (page) {
+            if (hasContent(page)) {
+                _this.setStandardTaskText();
+                _this.switchToTask(page.content[0]);
+            }
+            else {
+                _this.clearCurrentTask();
+            }
+        });
+    };
+    /**
+     * Checks whether the currently displayed task differs from the new one
+     * @param newCase [Case]{@link Case} object that holds the newly selected {@link Task}
+     * @returns `true` if the currently selected Case has a different ID from the newly selected Case.
+     * If the IDs are the same returns `true` if the transition IDs are different.
+     * Returns `false` otherwise.
+     */
+    TreeTaskContentService.prototype.taskChanged = function (newCase) {
+        var currentCaseId = this._selectedCaseService.selectedCase ? this._selectedCaseService.selectedCase.stringId : undefined;
+        var newCaseId = newCase ? newCase.stringId : undefined;
+        if (currentCaseId !== newCaseId) {
+            return true;
+        }
+        var currentTransitionId = this.getTransitionId(this._selectedCaseService.selectedCase);
+        var newTransitionId = this.getTransitionId(newCase);
+        return currentTransitionId !== newTransitionId;
+    };
+    Object.defineProperty(TreeTaskContentService.prototype, "shouldCancelTask", {
+        /**
+         * Checks whether a Task object is currently selected and if it can be cancelled by the user
+         */
+        get: function () {
+            return this._taskContentService.task && this._permissionService.canCancel(this._taskContentService.task);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Creates a {@link Filter} object that finds the specified Task for the currently selected Case in a Tree Case View
+     * @returns a request body that finds tasks of the given case with task id that corresponds to the value in the `treeTaskTransitionId`
+     * immediate data field. Returns `undefined` if the request body cannot be created.
+     */
+    TreeTaskContentService.prototype.getTaskFilter = function () {
+        var transitionId = this.getTransitionId(this._selectedCaseService.selectedCase);
+        if (transitionId) {
+            return SimpleFilter.fromTaskQuery({
+                case: { id: this._selectedCaseService.selectedCase.stringId },
+                transitionId: transitionId
+            });
+        }
+        return undefined;
+    };
+    /**
+     * @param examinedCase the {@link Case} object from which we want to extract the transition ID
+     * @returns the ID of the transition that should be displayed in the {@link AbstractTaskContentComponent},
+     * or `undefined` if the currently selected case doesn't define it
+     */
+    TreeTaskContentService.prototype.getTransitionId = function (examinedCase) {
+        if (examinedCase && examinedCase.immediateData) {
+            var transitionId = getImmediateData(examinedCase, TreePetriflowIdentifiers.FEATURED_TRANSITION);
+            return transitionId ? transitionId.value : undefined;
+        }
+        return undefined;
+    };
+    /**
+     * Changes the currently selected {@link Task}.
+     * @param task the Task that should now be selected
+     */
+    TreeTaskContentService.prototype.switchToTask = function (task) {
+        var _this = this;
+        if (task.caseId !== this._selectedCaseService.selectedCase.stringId) {
+            this._logger.debug('Tree featured task has been loaded, but the selected case has changed since. Discarding...');
+            return;
+        }
+        task.assignPolicy = AssignPolicy.auto;
+        this._taskContentService.task = task;
+        this._taskContentService.blockFields(true);
+        this._assignPolicy.performAssignPolicy(true, this._callchain.create(function () {
+            _this._processingTaskChange.off();
+        }));
+    };
+    /**
+     * Notifies all connected Services that no Task is currently selected
+     */
+    TreeTaskContentService.prototype.clearCurrentTask = function () {
+        this._taskContentService.task = undefined;
+        this.displayEmptyTaskContent();
+        this._processingTaskChange.off();
+    };
+    /**
+     * Updates the state of the current Task from backend
+     */
+    TreeTaskContentService.prototype.updateTaskState = function () {
+        var _this = this;
+        var uniqueTaskIdentifier = this.getUniqueTaskIdentifier();
+        if (uniqueTaskIdentifier === this._reloadedTaskUniqueIdentifier) {
+            this._logger.debug('The currently selected task is already being reloaded. Ignoring reload request.');
+            return;
+        }
+        this._reloadedTaskUniqueIdentifier = uniqueTaskIdentifier;
+        this._taskResourceService.getTasks(this.getTaskFilter()).subscribe(function (page) {
+            if (hasContent(page)) {
+                if (_this._taskContentService.task && _this._taskContentService.task.stringId === page.content[0].stringId) {
+                    _this._reloadedTaskUniqueIdentifier = undefined;
+                    Object.assign(_this._taskContentService.task, page.content[0]);
+                }
+                _this.resolveTaskBlockState();
+            }
+        });
+    };
+    /**
+     * If the current {@link Task} is assigned to the current user it is unblocked. Otherwise it is blocked.
+     */
+    TreeTaskContentService.prototype.resolveTaskBlockState = function () {
+        var taskShouldBeBlocked = !this._taskContentService.task
+            || this._taskContentService.task.user === undefined
+            || !this._userComparator.compareUsers(this._taskContentService.task.user);
+        this._taskContentService.blockFields(taskShouldBeBlocked);
+    };
+    /**
+     * Sets the noData text in the task content to it's default value
+     */
+    TreeTaskContentService.prototype.setStandardTaskText = function () {
+        this._displayedTaskText$.next();
+    };
+    /**
+     * Attempts to cancel the currently opened Task if the Task is in such state that allows cancellation.
+     */
+    TreeTaskContentService.prototype.ngOnDestroy = function () {
+        if (this.shouldCancelTask) {
+            this._cancel.cancel();
+        }
+    };
+    /**
+     * @returns a unique identifier for the currently selected task, that consists of it's case's id and it's transition id.
+     *
+     * Returns `undefined`, if no task is currently selected.
+     */
+    TreeTaskContentService.prototype.getUniqueTaskIdentifier = function () {
+        if (!this._selectedCaseService.selectedCase) {
+            return undefined;
+        }
+        return this._selectedCaseService.selectedCase.stringId + "#" + this.getTransitionId(this._selectedCaseService.selectedCase);
+    };
+    TreeTaskContentService.ctorParameters = function () { return [
+        { type: TreeCaseViewService },
+        { type: TaskDataService },
+        { type: TaskContentService },
+        { type: TaskResourceService },
+        { type: TaskEventService },
+        { type: AssignPolicyService },
+        { type: CancelTaskService },
+        { type: UserComparatorService },
+        { type: CallChainService },
+        { type: LoggerService },
+        { type: SelectedCaseService },
+        { type: ChangedFieldsService },
+        { type: PermissionService },
+        { type: SubjectTaskOperations, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] }
+    ]; };
+    TreeTaskContentService.decorators = [
+        { type: Injectable }
+    ];
+    TreeTaskContentService.ctorParameters = function () { return [
+        { type: TreeCaseViewService },
+        { type: TaskDataService },
+        { type: TaskContentService },
+        { type: TaskResourceService },
+        { type: TaskEventService },
+        { type: AssignPolicyService },
+        { type: CancelTaskService },
+        { type: UserComparatorService },
+        { type: CallChainService },
+        { type: LoggerService },
+        { type: SelectedCaseService },
+        { type: ChangedFieldsService },
+        { type: PermissionService },
+        { type: SubjectTaskOperations, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] }
+    ]; };
+    return TreeTaskContentService;
+}());
+export { TreeTaskContentService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-task-content.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/view/tree-case-view/tree-task-content/tree-task-content.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy} from '@angular/core';\nimport {TaskContentService} from '../../../task-content/services/task-content.service';\nimport {TaskDataService} from '../../../task/services/task-data.service';\nimport {CancelTaskService} from '../../../task/services/cancel-task.service';\nimport {TaskEventService} from '../../../task-content/services/task-event.service';\nimport {TaskResourceService} from '../../../resources/engine-endpoint/task-resource.service';\nimport {TreeCaseViewService} from '../tree-case-view.service';\nimport {Case} from '../../../resources/interface/case';\nimport {Task} from '../../../resources/interface/task';\nimport {AssignPolicyService} from '../../../task/services/assign-policy.service';\nimport {AssignPolicy} from '../../../task-content/model/policy';\nimport {NAE_TASK_OPERATIONS} from '../../../task/models/task-operations-injection-token';\nimport {SubjectTaskOperations} from '../../../task/models/subject-task-operations';\nimport {UserComparatorService} from '../../../user/services/user-comparator.service';\nimport {TreePetriflowIdentifiers} from '../model/tree-petriflow-identifiers';\nimport {CallChainService} from '../../../utility/call-chain/call-chain.service';\nimport {LoadingEmitter} from '../../../utility/loading-emitter';\nimport {Observable, ReplaySubject, Subject} from 'rxjs';\nimport {hasContent} from '../../../utility/pagination/page-has-content';\nimport {getImmediateData} from '../../../utility/get-immediate-data';\nimport {filter} from 'rxjs/operators';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {SelectedCaseService} from '../../../task/services/selected-case.service';\nimport {Filter} from '../../../filter/models/filter';\nimport {SimpleFilter} from '../../../filter/models/simple-filter';\nimport {PermissionService} from '../../../authorization/permission/permission.service';\nimport {ChangedFieldsService} from '../../../changed-fields/services/changed-fields.service';\nimport {ChangedFields} from '../../../data-fields/models/changed-fields';\nimport {ChangedFieldsMap} from '../../../event/services/interfaces/changed-fields-map';\n\n@Injectable()\nexport class TreeTaskContentService implements OnDestroy {\n\n    private _processingTaskChange: LoadingEmitter;\n    private _displayedTaskText$: Subject<string>;\n    /**\n     * a unique identifier consisting of caseId and transition ID\n     *\n     * Is set if a reload of the given task is currently taking place, `undefined` otherwise.\n     */\n    private _reloadedTaskUniqueIdentifier: string;\n\n    constructor(protected _treeCaseService: TreeCaseViewService,\n                protected _taskDataService: TaskDataService,\n                protected _taskContentService: TaskContentService,\n                protected _taskResourceService: TaskResourceService,\n                protected _taskEventService: TaskEventService,\n                protected _assignPolicy: AssignPolicyService,\n                protected _cancel: CancelTaskService,\n                protected _userComparator: UserComparatorService,\n                protected _callchain: CallChainService,\n                protected _logger: LoggerService,\n                protected _selectedCaseService: SelectedCaseService,\n                protected _changedFieldsService: ChangedFieldsService,\n                protected _permissionService: PermissionService,\n                @Inject(NAE_TASK_OPERATIONS) protected _taskOperations: SubjectTaskOperations) {\n        this._processingTaskChange = new LoadingEmitter();\n        this._displayedTaskText$ = new ReplaySubject<string>();\n\n        this._changedFieldsService.changedFields$.subscribe((changedFieldsMap: ChangedFieldsMap) => {\n            const filteredCaseIds: Array<string> = Object.keys(changedFieldsMap).filter(\n                caseId => Object.keys(this._taskContentService.referencedTaskAndCaseIds).includes(caseId)\n            );\n            const changedFields: Array<ChangedFields> = [];\n            filteredCaseIds.forEach(caseId => {\n                const taskIds: Array<string> = this._taskContentService.referencedTaskAndCaseIds[caseId];\n                changedFields.push(...this._changedFieldsService.parseChangedFieldsByCaseAndTaskIds(caseId, taskIds, changedFieldsMap));\n            });\n            changedFields.filter(fields => fields !== undefined).forEach(fields => {\n                this._taskContentService.updateFromChangedFields(fields);\n            });\n        });\n        _taskDataService.updateSuccess$.subscribe(result => {\n            if (result) {\n                this._treeCaseService.reloadCase$.next();\n                this.resolveTaskBlockState();\n            }\n        });\n\n        _treeCaseService.loadTask$.asObservable().pipe(filter(selectedCase => this.taskChanged(selectedCase))).subscribe(selectedCase => {\n            this.cancelAndLoadFeaturedTask(selectedCase);\n        });\n\n        _taskOperations.reload$.subscribe(() => {\n            this.updateTaskState();\n            this._treeCaseService.reloadCase$.next();\n        });\n        _taskOperations.open$.subscribe(() => {\n            this._taskContentService.blockFields(false);\n        });\n        _taskOperations.close$.subscribe(() => {\n            this._taskContentService.blockFields(true);\n        });\n    }\n\n    public get taskContentText$(): Observable<string> {\n        return this._displayedTaskText$.asObservable();\n    }\n\n    public get processingTaskChange(): boolean {\n        return this._processingTaskChange.isActive;\n    }\n\n    public displayEmptyTaskContent(): void {\n        this._taskContentService.$shouldCreate.next([]);\n        this._displayedTaskText$.next('caseTree.noTaskSelected');\n    }\n\n    /**\n     * Cancels the currently selected {@link Task} if any. And then loads and assigns the new Task.\n     * @param selectedCase the Case who's task should be now displayed\n     */\n    protected cancelAndLoadFeaturedTask(selectedCase: Case | undefined) {\n        this._processingTaskChange.on();\n        this._taskContentService.blockFields(true);\n        if (this.shouldCancelTask) {\n            this._cancel.cancel(this._callchain.create(success => {\n                if (success) {\n                    this._logger.debug('Old tree task successfully canceled');\n                } else {\n                    this._logger.warn('Old tree task could not be canceled');\n                }\n            }));\n        }\n        this.loadFeaturedTask(selectedCase);\n    }\n\n    /**\n     * Changes the currently displayed {@link Task} based on the selected {@link Case} from the Tree.\n     * @param selectedCase the Case who's task should be now displayed\n     */\n    protected loadFeaturedTask(selectedCase: Case | undefined): void {\n        this._selectedCaseService.selectedCase = selectedCase;\n\n        const requestBody = this.getTaskFilter();\n        if (requestBody === undefined) {\n            this.clearCurrentTask();\n            return;\n        }\n\n        this._taskResourceService.getTasks(requestBody).subscribe(page => {\n            if (hasContent(page)) {\n                this.setStandardTaskText();\n                this.switchToTask(page.content[0]);\n            } else {\n                this.clearCurrentTask();\n            }\n        });\n    }\n\n    /**\n     * Checks whether the currently displayed task differs from the new one\n     * @param newCase [Case]{@link Case} object that holds the newly selected {@link Task}\n     * @returns `true` if the currently selected Case has a different ID from the newly selected Case.\n     * If the IDs are the same returns `true` if the transition IDs are different.\n     * Returns `false` otherwise.\n     */\n    private taskChanged(newCase: Case | undefined): boolean {\n        const currentCaseId = this._selectedCaseService.selectedCase ? this._selectedCaseService.selectedCase.stringId : undefined;\n        const newCaseId = newCase ? newCase.stringId : undefined;\n        if (currentCaseId !== newCaseId) {\n            return true;\n        }\n\n        const currentTransitionId = this.getTransitionId(this._selectedCaseService.selectedCase);\n        const newTransitionId = this.getTransitionId(newCase);\n        return currentTransitionId !== newTransitionId;\n    }\n\n    /**\n     * Checks whether a Task object is currently selected and if it can be cancelled by the user\n     */\n    private get shouldCancelTask(): boolean {\n        return this._taskContentService.task && this._permissionService.canCancel(this._taskContentService.task);\n    }\n\n    /**\n     * Creates a {@link Filter} object that finds the specified Task for the currently selected Case in a Tree Case View\n     * @returns a request body that finds tasks of the given case with task id that corresponds to the value in the `treeTaskTransitionId`\n     * immediate data field. Returns `undefined` if the request body cannot be created.\n     */\n    protected getTaskFilter(): Filter | undefined {\n        const transitionId = this.getTransitionId(this._selectedCaseService.selectedCase);\n        if (transitionId) {\n            return SimpleFilter.fromTaskQuery({\n                case: {id: this._selectedCaseService.selectedCase.stringId},\n                transitionId\n            });\n        }\n        return undefined;\n    }\n\n    /**\n     * @param examinedCase the {@link Case} object from which we want to extract the transition ID\n     * @returns the ID of the transition that should be displayed in the {@link AbstractTaskContentComponent},\n     * or `undefined` if the currently selected case doesn't define it\n     */\n    protected getTransitionId(examinedCase: Case): string | undefined {\n        if (examinedCase && examinedCase.immediateData) {\n            const transitionId = getImmediateData(examinedCase, TreePetriflowIdentifiers.FEATURED_TRANSITION);\n            return transitionId ? transitionId.value : undefined;\n        }\n        return undefined;\n    }\n\n    /**\n     * Changes the currently selected {@link Task}.\n     * @param task the Task that should now be selected\n     */\n    protected switchToTask(task: Task): void {\n        if (task.caseId !== this._selectedCaseService.selectedCase.stringId) {\n            this._logger.debug('Tree featured task has been loaded, but the selected case has changed since. Discarding...');\n            return;\n        }\n\n        task.assignPolicy = AssignPolicy.auto;\n        this._taskContentService.task = task;\n        this._taskContentService.blockFields(true);\n        this._assignPolicy.performAssignPolicy(true, this._callchain.create(() => {\n            this._processingTaskChange.off();\n        }));\n    }\n\n    /**\n     * Notifies all connected Services that no Task is currently selected\n     */\n    protected clearCurrentTask(): void {\n        this._taskContentService.task = undefined;\n        this.displayEmptyTaskContent();\n        this._processingTaskChange.off();\n    }\n\n    /**\n     * Updates the state of the current Task from backend\n     */\n    protected updateTaskState(): void {\n        const uniqueTaskIdentifier = this.getUniqueTaskIdentifier();\n        if (uniqueTaskIdentifier === this._reloadedTaskUniqueIdentifier) {\n            this._logger.debug('The currently selected task is already being reloaded. Ignoring reload request.');\n            return;\n        }\n        this._reloadedTaskUniqueIdentifier = uniqueTaskIdentifier;\n        this._taskResourceService.getTasks(this.getTaskFilter()).subscribe(page => {\n            if (hasContent(page)) {\n                if (this._taskContentService.task && this._taskContentService.task.stringId === page.content[0].stringId) {\n                    this._reloadedTaskUniqueIdentifier = undefined;\n                    Object.assign(this._taskContentService.task, page.content[0]);\n                }\n                this.resolveTaskBlockState();\n            }\n        });\n    }\n\n    /**\n     * If the current {@link Task} is assigned to the current user it is unblocked. Otherwise it is blocked.\n     */\n    protected resolveTaskBlockState(): void {\n        const taskShouldBeBlocked = !this._taskContentService.task\n                                    || this._taskContentService.task.user === undefined\n                                    || !this._userComparator.compareUsers(this._taskContentService.task.user);\n        this._taskContentService.blockFields(taskShouldBeBlocked);\n    }\n\n    /**\n     * Sets the noData text in the task content to it's default value\n     */\n    protected setStandardTaskText(): void {\n        this._displayedTaskText$.next();\n    }\n\n    /**\n     * Attempts to cancel the currently opened Task if the Task is in such state that allows cancellation.\n     */\n    ngOnDestroy(): void {\n        if (this.shouldCancelTask) {\n            this._cancel.cancel();\n        }\n    }\n\n    /**\n     * @returns a unique identifier for the currently selected task, that consists of it's case's id and it's transition id.\n     *\n     * Returns `undefined`, if no task is currently selected.\n     */\n    protected getUniqueTaskIdentifier(): string {\n        if (!this._selectedCaseService.selectedCase) {\n            return undefined;\n        }\n        return `${this._selectedCaseService.selectedCase.stringId}#${this.getTransitionId(this._selectedCaseService.selectedCase)}`;\n    }\n}\n"]}