@netgrif/components-core 6.0.1

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

@@ -0,0 +1,104 @@
+import { LoadingEmitter } from '../../../../utility/loading-emitter';
+import { TreePetriflowIdentifiers } from '../../model/tree-petriflow-identifiers';
+export class CaseTreeNode {
+    constructor(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.
+     */
+    canAddChildren() {
+        const 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.
+     */
+    canBeRemoved() {
+        const immediate = this.searchImmediateData(TreePetriflowIdentifiers.CAN_REMOVE_NODE);
+        return this.parent && !!immediate && immediate.value;
+    }
+    /**
+     * @returns whether this node's children are currently being loaded
+     */
+    isLoadingChildren() {
+        return this.loadingChildren.isActive;
+    }
+    /**
+     * @returns whether this node is being removed from the tree
+     */
+    isBeingRemoved() {
+        return this.removingNode.isActive;
+    }
+    /**
+     * @returns whether children are being added to this node
+     */
+    isAddingNode() {
+        return this.addingNode.isActive;
+    }
+    /**
+     * @returns return node value, if immediate date of [immediate data field]{@link TreePetriflowIdentifiers#BEFORE_TEXT_ICON} type exists
+     */
+    beforeTextIcon() {
+        const 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
+     */
+    treeAddTextIcon() {
+        const 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
+     */
+    beforeTextIconTitle() {
+        const 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
+     */
+    treeAddTextIconTitle() {
+        const immediate = this.searchImmediateData(TreePetriflowIdentifiers.TREE_ADD_ICON);
+        if (immediate === undefined || !(immediate.name && immediate.name.defaultValue)) {
+            return undefined;
+        }
+        return immediate.name.defaultValue;
+    }
+    searchImmediateData(dataId) {
+        return this.case.immediateData.find(data => 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).
+     */
+    toLoggableForm() {
+        return {
+            case: this.case,
+            dirtyChildren: this.dirtyChildren,
+            parent: this.parent ? this.parent.case.stringId : this.parent,
+            children: this.children.map(c => c.case.stringId),
+        };
+    }
+}
+//# 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":"AACA,OAAO,EAAC,cAAc,EAAC,MAAM,qCAAqC,CAAC;AACnE,OAAO,EAAC,wBAAwB,EAAC,MAAM,wCAAwC,CAAC;AAGhF,MAAM,OAAO,YAAY;IASrB,YAAY,QAAc,EAAE,UAAwB;QAChD,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,eAAe,GAAG,IAAI,cAAc,EAAE,CAAC;QAC5C,IAAI,CAAC,YAAY,GAAG,IAAI,cAAc,EAAE,CAAC;QACzC,IAAI,CAAC,UAAU,GAAG,IAAI,cAAc,EAAE,CAAC;QACvC,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACI,cAAc;QACjB,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;QACtF,OAAO,CAAC,CAAC,SAAS,IAAI,SAAS,CAAC,KAAK,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACI,YAAY;QACf,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,eAAe,CAAC,CAAC;QACrF,OAAO,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,SAAS,IAAI,SAAS,CAAC,KAAK,CAAC;IACzD,CAAC;IAED;;OAEG;IACI,iBAAiB;QACpB,OAAO,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,cAAc;QACjB,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;IACtC,CAAC;IAED;;OAEG;IACI,YAAY;QACf,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;IACpC,CAAC;IAED;;OAEG;IACI,cAAc;QACjB,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;QACtF,IAAI,SAAS,KAAK,SAAS,EAAE;YACzB,OAAO,SAAS,CAAC;SACpB;QACD,OAAO,SAAS,CAAC,KAAK,CAAC;IAC3B,CAAC;IAED;;OAEG;IACI,eAAe;QAClB,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,aAAa,CAAC,CAAC;QACnF,IAAI,SAAS,KAAK,SAAS,EAAE;YACzB,OAAO,SAAS,CAAC;SACpB;QACD,OAAO,SAAS,CAAC,KAAK,CAAC;IAC3B,CAAC;IAED;;OAEG;IACI,mBAAmB;QACtB,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;QACtF,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE;YAC7E,OAAO,SAAS,CAAC;SACpB;QACD,OAAO,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC;IACvC,CAAC;IAED;;OAEG;IACI,oBAAoB;QACvB,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,aAAa,CAAC,CAAC;QACnF,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE;YAC7E,OAAO,SAAS,CAAC;SACpB;QACD,OAAO,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC;IACvC,CAAC;IAEO,mBAAmB,CAAC,MAAc;QACtC,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,KAAK,MAAM,CAAC,CAAC;IAC1E,CAAC;IAED;;;;OAIG;IACI,cAAc;QACjB,OAAO;YACH,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM;YAC7D,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;SACpD,CAAC;IACN,CAAC;CACJ","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/esm2015/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/esm2015/lib/view/tree-case-view/tree-component/model/expansion-tree.js

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

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

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

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

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

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

@@ -0,0 +1,288 @@
+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';
+export class TreeTaskContentService {
+    constructor(_treeCaseService, _taskDataService, _taskContentService, _taskResourceService, _taskEventService, _assignPolicy, _cancel, _userComparator, _callchain, _logger, _selectedCaseService, _changedFieldsService, _permissionService, _taskOperations) {
+        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((changedFieldsMap) => {
+            const filteredCaseIds = Object.keys(changedFieldsMap).filter(caseId => Object.keys(this._taskContentService.referencedTaskAndCaseIds).includes(caseId));
+            const changedFields = [];
+            filteredCaseIds.forEach(caseId => {
+                const taskIds = this._taskContentService.referencedTaskAndCaseIds[caseId];
+                changedFields.push(...this._changedFieldsService.parseChangedFieldsByCaseAndTaskIds(caseId, taskIds, changedFieldsMap));
+            });
+            changedFields.filter(fields => fields !== undefined).forEach(fields => {
+                this._taskContentService.updateFromChangedFields(fields);
+            });
+        });
+        _taskDataService.updateSuccess$.subscribe(result => {
+            if (result) {
+                this._treeCaseService.reloadCase$.next();
+                this.resolveTaskBlockState();
+            }
+        });
+        _treeCaseService.loadTask$.asObservable().pipe(filter(selectedCase => this.taskChanged(selectedCase))).subscribe(selectedCase => {
+            this.cancelAndLoadFeaturedTask(selectedCase);
+        });
+        _taskOperations.reload$.subscribe(() => {
+            this.updateTaskState();
+            this._treeCaseService.reloadCase$.next();
+        });
+        _taskOperations.open$.subscribe(() => {
+            this._taskContentService.blockFields(false);
+        });
+        _taskOperations.close$.subscribe(() => {
+            this._taskContentService.blockFields(true);
+        });
+    }
+    get taskContentText$() {
+        return this._displayedTaskText$.asObservable();
+    }
+    get processingTaskChange() {
+        return this._processingTaskChange.isActive;
+    }
+    displayEmptyTaskContent() {
+        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
+     */
+    cancelAndLoadFeaturedTask(selectedCase) {
+        this._processingTaskChange.on();
+        this._taskContentService.blockFields(true);
+        if (this.shouldCancelTask) {
+            this._cancel.cancel(this._callchain.create(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
+     */
+    loadFeaturedTask(selectedCase) {
+        this._selectedCaseService.selectedCase = selectedCase;
+        const requestBody = this.getTaskFilter();
+        if (requestBody === undefined) {
+            this.clearCurrentTask();
+            return;
+        }
+        this._taskResourceService.getTasks(requestBody).subscribe(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.
+     */
+    taskChanged(newCase) {
+        const currentCaseId = this._selectedCaseService.selectedCase ? this._selectedCaseService.selectedCase.stringId : undefined;
+        const newCaseId = newCase ? newCase.stringId : undefined;
+        if (currentCaseId !== newCaseId) {
+            return true;
+        }
+        const currentTransitionId = this.getTransitionId(this._selectedCaseService.selectedCase);
+        const newTransitionId = this.getTransitionId(newCase);
+        return currentTransitionId !== newTransitionId;
+    }
+    /**
+     * Checks whether a Task object is currently selected and if it can be cancelled by the user
+     */
+    get shouldCancelTask() {
+        return this._taskContentService.task && this._permissionService.canCancel(this._taskContentService.task);
+    }
+    /**
+     * 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.
+     */
+    getTaskFilter() {
+        const transitionId = this.getTransitionId(this._selectedCaseService.selectedCase);
+        if (transitionId) {
+            return SimpleFilter.fromTaskQuery({
+                case: { id: this._selectedCaseService.selectedCase.stringId },
+                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
+     */
+    getTransitionId(examinedCase) {
+        if (examinedCase && examinedCase.immediateData) {
+            const 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
+     */
+    switchToTask(task) {
+        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(() => {
+            this._processingTaskChange.off();
+        }));
+    }
+    /**
+     * Notifies all connected Services that no Task is currently selected
+     */
+    clearCurrentTask() {
+        this._taskContentService.task = undefined;
+        this.displayEmptyTaskContent();
+        this._processingTaskChange.off();
+    }
+    /**
+     * Updates the state of the current Task from backend
+     */
+    updateTaskState() {
+        const 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(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.
+     */
+    resolveTaskBlockState() {
+        const 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
+     */
+    setStandardTaskText() {
+        this._displayedTaskText$.next();
+    }
+    /**
+     * Attempts to cancel the currently opened Task if the Task is in such state that allows cancellation.
+     */
+    ngOnDestroy() {
+        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.
+     */
+    getUniqueTaskIdentifier() {
+        if (!this._selectedCaseService.selectedCase) {
+            return undefined;
+        }
+        return `${this._selectedCaseService.selectedCase.stringId}#${this.getTransitionId(this._selectedCaseService.selectedCase)}`;
+    }
+}
+TreeTaskContentService.ctorParameters = () => [
+    { 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 = () => [
+    { 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,] }] }
+];
+//# 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"]}

package/esm2015/lib/view/workflow-view/abstract-workflow-view.component.js

@@ -0,0 +1,68 @@
+import { Input, ViewChild } from '@angular/core';
+import { ViewWithHeaders } from '../abstract/view-with-headers';
+import { HeaderType } from '../../header/models/header-type';
+import { Net } from '../../process/net';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+export class AbstractWorkflowViewComponent extends ViewWithHeaders {
+    constructor(_sideMenuService, _workflowViewService, _log, _processService) {
+        super(_workflowViewService);
+        this._sideMenuService = _sideMenuService;
+        this._workflowViewService = _workflowViewService;
+        this._log = _log;
+        this._processService = _processService;
+        this.showDeleteMenu = false;
+        this.headerType = HeaderType.WORKFLOW;
+        this.workflows$ = this._workflowViewService.workflows$;
+        this.loading$ = this._workflowViewService.loading$;
+        this.footerSize = 0;
+    }
+    ngAfterViewInit() {
+        this.initializeHeader(this.workflowHeader);
+    }
+    importSidemenuNet(component) {
+        this._sideMenuService.open(component).onClose.subscribe(event => {
+            var _a, _b;
+            if (((_a = event.data) === null || _a === void 0 ? void 0 : _a.net) !== undefined) {
+                this._workflowViewService.reload();
+                if ((_b = event.data) === null || _b === void 0 ? void 0 : _b.net) {
+                    this._processService.updateNet(new Net(event.data.net));
+                }
+            }
+            else {
+                this._log.debug('');
+            }
+        });
+    }
+    trackBy(i) {
+        return i;
+    }
+    loadNextPage() {
+        if (!this.viewport) {
+            return;
+        }
+        this._workflowViewService.nextPage(this.viewport.getRenderedRange(), this.viewport.getDataLength());
+    }
+    calculateListHeight(preciseHeight) {
+        if (!this.viewport) {
+            return;
+        }
+        const element = this.viewport.getElementRef().nativeElement;
+        if (preciseHeight !== null && preciseHeight !== undefined) {
+            element.style.height = preciseHeight + 'px';
+        }
+        else {
+            const viewportHeight = window.innerHeight - element.offsetTop - this.footerSize;
+            if (element.style.height !== viewportHeight + 'px') {
+                this._log.info('Virtual scroll height change to: ' + viewportHeight);
+                element.style.height = viewportHeight + 'px';
+            }
+        }
+    }
+}
+AbstractWorkflowViewComponent.propDecorators = {
+    footerSize: [{ type: Input }],
+    showDeleteMenu: [{ type: Input }],
+    workflowHeader: [{ type: ViewChild, args: ['header',] }],
+    viewport: [{ type: ViewChild, args: [CdkVirtualScrollViewport,] }]
+};
+//# sourceMappingURL=data:application/json;base64,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