@netgrif/components-core 6.0.1

package/esm2015/lib/view/tree-case-view/tree-component/case-tree.service.js

@@ -0,0 +1,843 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { CaseResourceService } from '../../../resources/engine-endpoint/case-resource.service';
+import { CaseTreeNode } from './model/case-tree-node';
+import { TreeCaseViewService } from '../tree-case-view.service';
+import { TaskResourceService } from '../../../resources/engine-endpoint/task-resource.service';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { ProcessService } from '../../../process/process.service';
+import { SideMenuService } from '../../../side-menu/services/side-menu.service';
+import { SideMenuSize } from '../../../side-menu/models/side-menu-size';
+import { forkJoin, of, ReplaySubject, throwError } from 'rxjs';
+import { TreePetriflowIdentifiers } from '../model/tree-petriflow-identifiers';
+import { tap } from 'rxjs/operators';
+import { TranslateService } from '@ngx-translate/core';
+import { hasContent } from '../../../utility/pagination/page-has-content';
+import { NestedTreeControl } from '@angular/cdk/tree';
+import { MatTreeNestedDataSource } from '@angular/material/tree';
+import { ofVoid } from '../../../utility/of-void';
+import { getImmediateData } from '../../../utility/get-immediate-data';
+import { NAE_OPTION_SELECTOR_COMPONENT } from '../../../side-menu/content-components/injection-tokens';
+import { SimpleFilter } from '../../../filter/models/simple-filter';
+import { ResultWithAfterActions } from '../../../utility/result-with-after-actions';
+import { refreshTree } from '../../../utility/refresh-tree';
+export class CaseTreeService {
+    constructor(_caseResourceService, _treeCaseViewService, _taskResourceService, _logger, _processService, _sideMenuService, _translateService, _optionSelectorComponent) {
+        this._caseResourceService = _caseResourceService;
+        this._treeCaseViewService = _treeCaseViewService;
+        this._taskResourceService = _taskResourceService;
+        this._logger = _logger;
+        this._processService = _processService;
+        this._sideMenuService = _sideMenuService;
+        this._translateService = _translateService;
+        this._optionSelectorComponent = _optionSelectorComponent;
+        /**
+         * Weather the tree is eager loaded or not.
+         *
+         * Defaults to `false`.
+         *
+         * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.
+         */
+        this._isEagerLoaded = false;
+        this._treeDataSource = new MatTreeNestedDataSource();
+        this._treeControl = new NestedTreeControl(node => node.children);
+        _treeCaseViewService.reloadCase$.asObservable().subscribe(() => {
+            this.reloadCurrentCase();
+        });
+        this._treeRootLoaded$ = new ReplaySubject(1);
+    }
+    ngOnDestroy() {
+        this._treeRootLoaded$.complete();
+    }
+    set rootFilter(filter) {
+        this._rootNodesFilter = filter;
+        this.dataSource.data = [];
+        this.loadTreeRoot();
+    }
+    get dataSource() {
+        return this._treeDataSource;
+    }
+    get treeControl() {
+        return this._treeControl;
+    }
+    get currentNode() {
+        return this._currentNode;
+    }
+    /**
+     * Emits a value whenever a new root node Filter is set.
+     *
+     * `true` is emitted if the root node was successfully loaded. `false` otherwise.
+     *
+     * On subscription emits the last emitted value (if any) to the subscriber.
+     */
+    get treeRootLoaded$() {
+        return this._treeRootLoaded$.asObservable();
+    }
+    get _currentCase() {
+        return this._currentNode ? this._currentNode.case : undefined;
+    }
+    /**
+     * @returns an `Observable` of the {@link LoadingEmitter} representing the loading state of the root node.
+     * Returns `undefined` if the tree has not yet been initialized.
+     *
+     * Wait for an emission on the [treeRootLoaded$]{@link CaseTreeService#treeRootLoaded$} stream before getting this Observable.
+     *
+     * The first value emitted by the Observable is `false`, when the tree finishes initializing.
+     */
+    get rootNodeLoading$() {
+        return !!this._rootNode ? this._rootNode.loadingChildren.asObservable() : undefined;
+    }
+    /**
+     * @returns an `Observable` of the {@link LoadingEmitter} representing whether the root node is currently
+     * in the process of adding a new child node or not.
+     * Returns `undefined` if the tree has not yet been initialized.
+     *
+     * Wait for an emission on the [treeRootLoaded$]{@link CaseTreeService#treeRootLoaded$} stream before getting this Observable.
+     *
+     * The first value emitted by the Observable is `false`, when the tree finishes initializing.
+     */
+    get rootNodeAddingChild$() {
+        return !!this._rootNode ? this._rootNode.addingNode.asObservable() : undefined;
+    }
+    /**
+     * Weather the tree is eager loaded or not.
+     *
+     * Defaults to `false`.
+     *
+     * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.
+     */
+    get isEagerLoaded() {
+        return this._isEagerLoaded;
+    }
+    /**
+     * Weather the tree is eager loaded or not.
+     *
+     * Defaults to `false`.
+     *
+     * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.
+     *
+     * @param eager the new setting for eager loading
+     */
+    set isEagerLoaded(eager) {
+        this._isEagerLoaded = eager;
+    }
+    /**
+     * Loads and populates the topmost level of the tree.
+     *
+     * The displayed cases are determined by this object's [rootFilter]{@link CaseTreeService#rootFilter}.
+     *
+     * Cases are loaded one page at a time and the tree is refreshed after each page.
+     * [finishedLoadingFirstLevel$]{@link CaseTreeService#treeRootLoaded$}
+     * will emit `true` once the last page loads successfully.
+     * `false` will be emitted if any of the requests fail.
+     */
+    loadTreeRoot() {
+        if (this._rootNodesFilter) {
+            this._caseResourceService.searchCases(this._rootNodesFilter).subscribe(page => {
+                if (hasContent(page)) {
+                    this._rootNode = new CaseTreeNode(page.content[0], undefined);
+                    if (page.content.length !== 1) {
+                        this._logger.warn('Filter for tree root returned more than one case. Using the first value as tree root...');
+                    }
+                    this._treeRootLoaded$.next(true);
+                }
+                else {
+                    this._logger.error('Tree root cannot be generated from the provided filter', page);
+                }
+            }, error => {
+                this._logger.error('Root node of the case tree could not be loaded', error);
+                this._treeRootLoaded$.next(false);
+            });
+        }
+    }
+    /**
+     * Adds the loaded tree root to the display based on the setting.
+     * @param showRoot whether the root of the tree should be displayed in the tree or not.
+     * If the root is not displayed it's children will be displayed on the first level.
+     * @returns an Observable that emits when the tree finishes initialization.
+     */
+    initializeTree(showRoot) {
+        if (!this._rootNode) {
+            this._logger.error('Set a Filter before initializing the case tree');
+            return throwError(new Error('Set a Filter before initializing the case tree'));
+        }
+        this._showRoot = showRoot;
+        if (showRoot) {
+            this.dataSource.data = [this._rootNode];
+        }
+        else {
+            this.dataSource.data = this._rootNode.children;
+        }
+        let ret;
+        if (!showRoot || this._isEagerLoaded) {
+            const result = new ReplaySubject(1);
+            ret = result.asObservable();
+            this.expandNode(this._rootNode).subscribe(() => {
+                this.refreshTree();
+                result.next();
+                result.complete();
+            });
+        }
+        else {
+            this.refreshTree();
+            ret = ofVoid();
+        }
+        return ret;
+    }
+    /**
+     * Notifies the parent TreeCaseView that a case was clicked in the tree and it's Task should be displayed
+     */
+    changeActiveNode(node) {
+        this._currentNode = node;
+        this._treeCaseViewService.loadTask$.next(node ? node.case : undefined);
+    }
+    /**
+     * Toggles the expansion state of a node
+     * @param node the {@link CaseTreeNode} who's content should be toggled
+     */
+    toggleNode(node) {
+        if (this._treeControl.isExpanded(node)) {
+            this._treeControl.collapse(node);
+        }
+        else {
+            this.expandNode(node);
+        }
+    }
+    /**
+     * Expands the target node in the tree and reloads it's children if they are marked as dirty
+     * @param node the {@link CaseTreeNode} that should be expanded
+     * @returns emits `true` if the node is expanded and `false` if not. If the expansion causes more node expansions
+     * (e.g. eager loaded tree) then, the Observable emits after all the subtree expansions complete.
+     */
+    expandNode(node) {
+        this._logger.debug('Requesting expansion of tree node', node.toLoggableForm());
+        if (node.loadingChildren.isActive) {
+            this._logger.debug('Node requested for expansion is loading. Expansion canceled.');
+            return of(false);
+        }
+        if (!node.dirtyChildren) {
+            this._logger.debug('Node requested for expansion has clean children. Simple expansion.');
+            this.treeControl.expand(node);
+            return of(true);
+        }
+        const ret = new ReplaySubject(1);
+        this.updateNodeChildren(node).subscribe(() => {
+            this._logger.debug('Node requested for expansion with dirty children had its children reloaded.');
+            if (node.children.length > 0) {
+                this._logger.debug('Node expanded.', node.toLoggableForm());
+                this.treeControl.expand(node);
+                if (this._isEagerLoaded) {
+                    this._logger.debug(`Eager loading children of tree node with case id '${node.case.stringId}'`);
+                    const innerObservables = node.children.map(childNode => this.expandNode(childNode));
+                    // forkJoin doesn't emit with 0 input observables
+                    innerObservables.push(of(true));
+                    forkJoin(innerObservables).subscribe(() => {
+                        ret.next(true);
+                        ret.complete();
+                    });
+                }
+                else {
+                    ret.next(true);
+                    ret.complete();
+                }
+            }
+            else {
+                ret.next(false);
+                ret.complete();
+            }
+        });
+        return ret.asObservable();
+    }
+    /**
+     * Checks whether dirty children need to be reloaded and reloads them if needed.
+     * @param node the {@link CaseTreeNode} who's children are updated
+     * @returns emits when loading finishes
+     */
+    updateNodeChildren(node) {
+        node.loadingChildren.on();
+        const childrenCaseRef = getImmediateData(node.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);
+        if (!childrenCaseRef || childrenCaseRef.value.length === 0) {
+            node.children = [];
+            this.refreshTree();
+            node.dirtyChildren = false;
+            node.loadingChildren.off();
+            return ofVoid();
+        }
+        if (node.children.length === childrenCaseRef.value.length) {
+            const existingChildren = new Set();
+            node.children.forEach(childNode => existingChildren.add(childNode.case.stringId));
+            if (childrenCaseRef.value.every(caseId => existingChildren.has(caseId))) {
+                node.dirtyChildren = false;
+                node.loadingChildren.off();
+                return ofVoid();
+            }
+        }
+        return this.updatePageOfChildren(node, 0).pipe(tap(() => {
+            this.refreshTree();
+            node.dirtyChildren = false;
+            node.loadingChildren.off();
+        }));
+    }
+    /**
+     * Loads every page of children from the given number and updates the existing children.
+     *
+     * Missing nodes are removed. Existing nodes are marked as dirty. New nodes are added.
+     *
+     * Nodes are returned in their insertion order.
+     * @param node the {@link CaseTreeNode} who's children are updated
+     * @param pageNumber the number of the first page that should be loaded. All following pages are loaded as well
+     * @returns next is emitted when loading of all pages completes (regardless of the outcome)
+     */
+    updatePageOfChildren(node, pageNumber) {
+        const requestBody = this.createChildRequestBody(node);
+        if (!requestBody) {
+            this._logger.error('Cannot create filter to find children of the given node', node.case);
+            return throwError(new Error('Cannot create filter to find children of the given node'));
+        }
+        const done = new ReplaySubject(1);
+        let params = new HttpParams();
+        params = params.set('page', `${pageNumber}`).set('sort', 'creationDate,asc');
+        this._caseResourceService.getCases(requestBody, params).subscribe(page => {
+            if (!hasContent(page)) {
+                this._logger.error('Child cases invalid page content', page);
+                done.next();
+                done.complete();
+                return;
+            }
+            this.updateCurrentChildrenWithNewPage(node, page);
+            if (pageNumber + 1 < page.pagination.totalPages) {
+                this.updatePageOfChildren(node, pageNumber + 1).subscribe(() => {
+                    done.next();
+                    done.complete();
+                });
+            }
+            else {
+                done.next();
+                done.complete();
+            }
+        }, error => {
+            this._logger.error('Child cases could not be loaded', error);
+            done.next();
+            done.complete();
+        });
+        return done.asObservable();
+    }
+    /**
+     * Updates the children of the given {@link CaseTreeNode} with [Cases]{@link Case} from the provided {@link Page}.
+     * @param node the {@link CaseTreeNode} who's children are updated
+     * @param page the {@link Page} that contains the updated children
+     */
+    updateCurrentChildrenWithNewPage(node, page) {
+        page.content.forEach((newCase, index) => {
+            const position = page.pagination.size * page.pagination.number + index;
+            while (position < node.children.length && node.children[position].case.stringId !== newCase.stringId) {
+                node.children.splice(position, 1);
+            }
+            if (node.children.length === position) {
+                node.children.push(new CaseTreeNode(newCase, node));
+            }
+            else {
+                node.children[position].case = newCase;
+                node.dirtyChildren = true;
+                this.treeControl.collapseDescendants(node.children[position]);
+            }
+        });
+    }
+    /**
+     * @param node the {@link CaseTreeNode} who's children the {@link Filter} should return
+     * @returns a request body that finds all child cases of the given `node`.
+     * Returns `undefined` if the provided `node` doesn't contain enough information to create the request body.
+     */
+    createChildRequestBody(node) {
+        const childCaseRef = getImmediateData(node.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);
+        if (!childCaseRef) {
+            return undefined;
+        }
+        return { stringId: childCaseRef.value };
+    }
+    /**
+     * Adds a child to the root node.
+     *
+     * Useful if you are using the layout where the root node is hidden.
+     * @returns emits `true` if the child was successfully added, `false` if not
+     */
+    addRootChildNode() {
+        const ret = new ReplaySubject(1);
+        this.addChildNode(this._rootNode).subscribe(added => {
+            if (added) {
+                if (!this._showRoot && this._treeDataSource.data.length === 0) {
+                    this._treeDataSource.data = this._rootNode.children;
+                    this.refreshTree();
+                }
+            }
+            ret.next(added);
+            ret.complete();
+        });
+        return ret;
+    }
+    /**
+     * Adds a new child node to the given node based on the properties of the node's case
+     * @returns emits `true` if the child was successfully added, `false` if not
+     */
+    addChildNode(clickedNode) {
+        clickedNode.addingNode.on();
+        const caseRefField = getImmediateData(clickedNode.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);
+        if (caseRefField.allowedNets.length === 0) {
+            this._logger.error(`Case ${clickedNode.case.stringId} can add new tree nodes but has no allowed nets`);
+            clickedNode.addingNode.off();
+            return of(false);
+        }
+        const ret = new ReplaySubject(1);
+        if (caseRefField.allowedNets.length === 1) {
+            this.createAndAddChildCase(caseRefField.allowedNets[0], clickedNode, ret);
+        }
+        else {
+            this._processService.getNets(caseRefField.allowedNets).subscribe(nets => {
+                const sideMeuRef = this._sideMenuService.open(this._optionSelectorComponent, SideMenuSize.MEDIUM, {
+                    title: clickedNode.case.title,
+                    options: nets.map(net => ({ text: net.title, value: net.identifier }))
+                });
+                let sideMenuSubscription;
+                sideMenuSubscription = sideMeuRef.onClose.subscribe(event => {
+                    if (!!event.data) {
+                        this.createAndAddChildCase(event.data.value, clickedNode, ret);
+                        sideMenuSubscription.unsubscribe();
+                    }
+                    else {
+                        clickedNode.addingNode.off();
+                        ret.next(false);
+                        ret.complete();
+                    }
+                });
+            });
+        }
+        return ret.asObservable();
+    }
+    /**
+     * Creates a new case and adds it to the children of the specified node
+     * @param processIdentifier identifier of the process that should be created
+     * @param clickedNode the node that is the parent of the new case
+     * @param operationResult the result of the operation will be emitted into this stream when the operation completes
+     */
+    createAndAddChildCase(processIdentifier, clickedNode, operationResult) {
+        this._processService.getNet(processIdentifier).subscribe(net => {
+            const childTitleImmediate = getImmediateData(clickedNode.case, TreePetriflowIdentifiers.CHILD_NODE_TITLE);
+            let childTitle = this._translateService.instant('caseTree.newNodeDefaultName');
+            if (!!childTitleImmediate) {
+                childTitle = childTitleImmediate.value;
+            }
+            else if (!!net.defaultCaseName) {
+                childTitle = net.defaultCaseName;
+            }
+            this._caseResourceService.createCase({
+                title: childTitle,
+                netId: net.stringId
+            }).subscribe((outcomeResource) => {
+                const caseRefField = getImmediateData(clickedNode.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);
+                const setCaseRefValue = [...caseRefField.value, outcomeResource.outcome.aCase.stringId];
+                this.performCaseRefCall(clickedNode.case.stringId, setCaseRefValue).subscribe(valueChange => this.updateTreeAfterChildAdd(clickedNode, valueChange ? valueChange : setCaseRefValue, operationResult));
+            });
+        });
+    }
+    /**
+     * Updates the tree after adding a new child
+     * @param clickedNode the parent node
+     * @param newCaseRefValue the new value of the parent node's case ref
+     * @param operationResult the result of the operation will be emitted into this stream when the operation completes
+     */
+    updateTreeAfterChildAdd(clickedNode, newCaseRefValue, operationResult) {
+        this.updateNodeChildrenFromChangedFields(clickedNode, newCaseRefValue).subscribe(result => {
+            clickedNode.addingNode.off();
+            this.expandNode(clickedNode).subscribe(expandSuccess => {
+                if (expandSuccess) {
+                    this.changeActiveNode(clickedNode.children[clickedNode.children.length - 1]);
+                    result.executeAfterActions();
+                }
+                operationResult.next(true);
+                operationResult.complete();
+            });
+        });
+    }
+    /**
+     * removes the provided non-root node if the underlying case allows it.
+     *
+     * The underlying case is removed from the case ref of it's parent element with the help from the `remove`
+     * operation provided by case ref itself.
+     * @param node the node that should be removed from the tree
+     */
+    removeNode(node) {
+        if (!node.parent) {
+            this._logger.error('Case tree doesn\'t support removal of the root node, as it has no parent case ref.');
+            return;
+        }
+        node.removingNode.on();
+        const caseRefImmediate = getImmediateData(node.parent.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);
+        const setCaseRefValue = caseRefImmediate.value.filter(id => id !== node.case.stringId);
+        this.performCaseRefCall(node.parent.case.stringId, setCaseRefValue).subscribe(caseRefChange => {
+            const newCaseRefValue = caseRefChange ? caseRefChange : setCaseRefValue;
+            this.deleteRemovedNodes(node.parent, newCaseRefValue);
+            this.updateNodeChildrenFromChangedFields(node.parent, newCaseRefValue);
+            node.removingNode.off();
+        });
+        this.deselectNodeIfDescendantOf(node);
+    }
+    /**
+     * Expands all nodes in the tree dictated by the argument.
+     *
+     * @param path nodes that should be expanded along with their path from the root node
+     */
+    expandPath(path) {
+        if (this.dataSource.data.length === 0) {
+            return;
+        }
+        let rootNode = this.dataSource.data[0];
+        while (rootNode.parent !== undefined) {
+            rootNode = rootNode.parent;
+        }
+        this.expandLevel([rootNode], this.convertPathToExpansionTree(path));
+    }
+    /**
+     * Transforms a {@Link CaseTreePath} object into an {@link ExpansionTree} object.
+     * The result has all the common paths merged into single branches of the resulting tree structure.
+     *
+     * @param paths nodes that should be expanded along with their path from the root node
+     * @returns an {@link ExpansionTree} equivalent to the provided {@link CaseTreePath}
+     */
+    convertPathToExpansionTree(paths) {
+        const result = {};
+        Object.values(paths).forEach(path => {
+            let currentNode = result;
+            path.forEach(nodeId => {
+                if (currentNode[nodeId] === undefined) {
+                    currentNode[nodeId] = {};
+                }
+                currentNode = currentNode[nodeId];
+            });
+        });
+        return result;
+    }
+    /**
+     * Recursively expands all nodes from the provided array of nodes, that appear in the top level of the {@link ExpansionTree} object.
+     *
+     * @param levelNodes nodes from which the expansion should start
+     * @param targets a tree structure representing the nodes that are to be expanded recursively.
+     * The top level nodes are expanded first, from the provided `levelNodes`.
+     */
+    expandLevel(levelNodes, targets) {
+        const desiredIds = new Set(Object.keys(targets));
+        if (desiredIds.size === 0) {
+            return;
+        }
+        levelNodes.forEach(n => {
+            const node = n;
+            if (!desiredIds.has(node.case.stringId)) {
+                return; // continue
+            }
+            this.expandNode(node).subscribe(success => {
+                if (!success) {
+                    this._logger.debug('Could not expand tree node with ID: ' + node.case.stringId);
+                    return;
+                }
+                this.expandLevel(node.children, targets[node.case.stringId]);
+            });
+        });
+    }
+    /**
+     * Deletes the subtrees rooted at the nodes that are present in the parent node's child case ref values,
+     * but are no longer present in the new value
+     * @param parentNode an inner node of the tree that had some of it's children removed
+     * @param newCaseRefValue the new value of the parent node's case ref
+     */
+    deleteRemovedNodes(parentNode, newCaseRefValue) {
+        const removedChildren = new Set();
+        getImmediateData(parentNode.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF).value.forEach(id => removedChildren.add(id));
+        newCaseRefValue.forEach(id => removedChildren.delete(id));
+        removedChildren.forEach(removedId => this._caseResourceService.deleteCase(removedId, true)
+            .subscribe(responseMessage => {
+            if (responseMessage.error) {
+                this._logger.error('Removal of child case unsuccessful', responseMessage.error);
+            }
+        }));
+    }
+    /**
+     * Deselects the currently selected node if it is a descendant of the provided node
+     * @param node the node who's descendants should be deselected
+     */
+    deselectNodeIfDescendantOf(node) {
+        let bubblingNode = this.currentNode;
+        while (bubblingNode && bubblingNode !== this._rootNode) {
+            if (bubblingNode === node) {
+                this.changeActiveNode(undefined);
+                break;
+            }
+            bubblingNode = bubblingNode.parent;
+        }
+    }
+    /**
+     * Performs a backend call on the given case, and sets the value of the case ref field in the transition defined by
+     * [CASE_REF_TRANSITION]{@link TreePetriflowIdentifiers#CASE_REF_TRANSITION}.
+     * @param caseId string ID of the case that should have it's tree case ref set
+     * @param newCaseRefValue the new value of the case ref field
+     */
+    performCaseRefCall(caseId, newCaseRefValue) {
+        const result$ = new ReplaySubject(1);
+        this._taskResourceService.getTasks(SimpleFilter.fromTaskQuery({
+            case: { id: caseId },
+            transitionId: TreePetriflowIdentifiers.CASE_REF_TRANSITION
+        })).subscribe(page => {
+            if (!hasContent(page)) {
+                this._logger.error('Case ref accessor task doesn\'t exist!');
+                result$.complete();
+                return;
+            }
+            const task = page.content[0];
+            this._taskResourceService.assignTask(task.stringId).subscribe(assignResponse => {
+                if (!assignResponse.success) {
+                    this._logger.error('Case ref accessor task could not be assigned', assignResponse.error);
+                }
+                const body = {};
+                body[TreePetriflowIdentifiers.CHILDREN_CASE_REF] = {
+                    type: 'caseRef',
+                    value: newCaseRefValue
+                };
+                this._taskResourceService.setData(task.stringId, body).subscribe((outcomeResource) => {
+                    const changedFields = outcomeResource.outcome.changedFields.changedFields;
+                    const caseRefChanges = changedFields[TreePetriflowIdentifiers.CHILDREN_CASE_REF];
+                    result$.next(caseRefChanges ? caseRefChanges.value : undefined);
+                    result$.complete();
+                    this._taskResourceService.finishTask(task.stringId).subscribe(finishResponse => {
+                        if (finishResponse.success) {
+                            this._logger.debug('Case ref accessor task finished', finishResponse.success);
+                        }
+                        else {
+                            this._logger.error('Case ref accessor task finish failed', finishResponse.error);
+                        }
+                    });
+                }, error => {
+                    this._logger.error('Could not set data to tree case ref', error);
+                    result$.complete();
+                });
+            }, error => {
+                this._logger.error('Case ref accessor task could not be assigned', error);
+                result$.complete();
+            });
+        }, error => {
+            this._logger.error('Case ref accessor task could not be found', error);
+            result$.complete();
+        });
+        return result$.asObservable();
+    }
+    /**
+     * Performs an update after adding or removing a node from the tree.
+     *
+     * If only one node was added adds it into the tree
+     *
+     * If only one node was removed removes it from the tree
+     *
+     * Otherwise collapses the affected node and marks it's children as dirty
+     *
+     * @param affectedNode node that had it's children changed
+     * @param newCaseRefValue new value of the caseRef field returned by backend
+     * @returns an `Observable` that emits an object with the [result]{@link ResultWithAfterActions#result} attribute set to `true` if
+     * the update completes successfully and `false` otherwise.
+     */
+    updateNodeChildrenFromChangedFields(affectedNode, newCaseRefValue) {
+        const caseRefField = getImmediateData(affectedNode.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);
+        const newChildren = new Set();
+        newCaseRefValue.forEach(id => newChildren.add(id));
+        let numberOfMissingChildren = 0;
+        for (let i = 0; i < caseRefField.value.length && numberOfMissingChildren < 2; i++) {
+            if (!newChildren.has(caseRefField.value[i])) {
+                numberOfMissingChildren++;
+            }
+        }
+        const exactlyOneChildAdded = caseRefField.value.length + 1 === newCaseRefValue.length
+            && caseRefField.value.every(it => newChildren.has(it));
+        const exactlyOneChildRemoved = caseRefField.value.length - 1 === newCaseRefValue.length
+            && numberOfMissingChildren === 1;
+        if (!exactlyOneChildAdded && !exactlyOneChildRemoved) {
+            caseRefField.value = newCaseRefValue;
+            this._treeControl.collapseDescendants(affectedNode);
+            affectedNode.dirtyChildren = true;
+            return of(new ResultWithAfterActions(true));
+        }
+        if (exactlyOneChildAdded) {
+            return this.processChildNodeAdd(affectedNode, caseRefField, newCaseRefValue);
+        }
+        else {
+            return this.processChildNodeRemove(affectedNode, caseRefField, newChildren);
+        }
+    }
+    /**
+     * Adds a new child node to the `affectedNode` by adding the last Case from the `newCaseRefValue`
+     * @param affectedNode the node in the tree that had a child added - the parent node
+     * @param caseRefField the case ref field of the affected node
+     * @param newCaseRefValue the new value of the case ref field in the node
+     * @returns an `Observable` that emits `true` if a node was successfully added, `false` otherwise.
+     */
+    processChildNodeAdd(affectedNode, caseRefField, newCaseRefValue) {
+        const result$ = new ReplaySubject(1);
+        caseRefField.value = newCaseRefValue;
+        this._caseResourceService.getOneCase(newCaseRefValue[newCaseRefValue.length - 1]).subscribe(childCase => {
+            if (childCase) {
+                this._logger.debug('Pushing child node to tree', { childCase, affectedNode: affectedNode.toLoggableForm() });
+                const childNode = this.pushChildToTree(affectedNode, childCase);
+                result$.next(new ResultWithAfterActions(true, [() => {
+                        if (this._isEagerLoaded) {
+                            this._logger.debug('Eagerly expanding a newly added node.', childNode.toLoggableForm());
+                            this.expandNode(childNode);
+                        }
+                    }]));
+            }
+            else {
+                this._logger.error('New child case was not found, illegal state', childCase);
+                result$.next(new ResultWithAfterActions(false));
+            }
+            result$.complete();
+        }, error => {
+            this._logger.error('New child node case could not be found', error);
+            result$.next(new ResultWithAfterActions(false));
+            result$.complete();
+        });
+        return result$.asObservable();
+    }
+    /**
+     * Adds a new child node to the target parent node.
+     * @param parentNode the nodes whose child should be added
+     * @param childCase the child case
+     * @returns the newly added node
+     */
+    pushChildToTree(parentNode, childCase) {
+        const childNode = new CaseTreeNode(childCase, parentNode);
+        parentNode.children.push(childNode);
+        this.refreshTree();
+        return childNode;
+    }
+    /**
+     * Removes the deleted node from the children of the `affectedNode`
+     * @param affectedNode the node in the tree that had it's child removed
+     * @param caseRefField the case ref field of the affected node
+     * @param newCaseRefValues the new value of the case ref field in the node
+     * @returns an `Observable` that emits `true` when the remove operation completes.
+     */
+    processChildNodeRemove(affectedNode, caseRefField, newCaseRefValues) {
+        const index = caseRefField.value.findIndex(it => !newCaseRefValues.has(it));
+        caseRefField.value.splice(index, 1);
+        affectedNode.children.splice(index, 1);
+        this.refreshTree();
+        return of(new ResultWithAfterActions(true));
+    }
+    /**
+     * @ignore
+     * Forces a rerender of the tree content
+     */
+    refreshTree() {
+        refreshTree(this._treeDataSource);
+    }
+    /**
+     * Reloads the currently selected case node. The {@link Case} object held in the {@link CaseTreeNode} instance is not replaced,
+     * but the new Case is `Object.assign`-ed into it. This means that the reference to the Case instance is unchanged but references
+     * to all it's non-primitive attributes are changed.
+     *
+     * If a reload of the current node is initiated before the previous one completed, the new one is ignored.
+     *
+     * If the currently selected case changed before a response from backend was received the response is ignored.
+     *
+     * Note that the parent node, nor the child nodes are reloaded.
+     */
+    reloadCurrentCase() {
+        if (!this._currentNode) {
+            this._logger.debug('No Tree Case Node selected, nothing to reload');
+            return;
+        }
+        if (this._reloadedCaseId && this._currentNode.case.stringId !== this._reloadedCaseId) {
+            this._logger.debug('Reload of the current case already in progress');
+            return;
+        }
+        this._reloadedCaseId = this._currentNode.case.stringId;
+        this._caseResourceService.getOneCase(this._currentCase.stringId).subscribe(reloadedCurrentCase => {
+            if (!reloadedCurrentCase) {
+                this._logger.error('Current Case Tree Node could not be reloaded. Invalid server response', reloadedCurrentCase);
+                return;
+            }
+            if (this._currentNode && reloadedCurrentCase.stringId === this._currentNode.case.stringId) {
+                this._reloadedCaseId = undefined;
+                const change = this.determineCaseUpdate(this._currentCase, reloadedCurrentCase);
+                Object.assign(this._currentCase, reloadedCurrentCase);
+                this._treeCaseViewService.loadTask$.next(this._currentCase);
+                if (change.visibleTreePropertiesChanged) {
+                    this.refreshTree();
+                }
+                if (change.childrenChanged) {
+                    this._currentNode.dirtyChildren = true;
+                    this.expandNode(this._currentNode);
+                }
+                this._logger.debug('Current Case Tree Node reloaded');
+            }
+            else {
+                this._logger.debug('Discarding case reload response, since the current node has changed before its case was received');
+            }
+        }, error => {
+            this._logger.error('Current Case Tree Node reload request failed', error);
+        });
+    }
+    /**
+     * Determines if anny of the case attributes that are visible on the tree changed.
+     * @param oldCase the previous version of the Case object, that is currently displayed on the tree
+     * @param newCase the new version of the Case object, that should replace the old one
+     */
+    determineCaseUpdate(oldCase, newCase) {
+        const visibleAttributes = [
+            TreePetriflowIdentifiers.CAN_ADD_CHILDREN,
+            TreePetriflowIdentifiers.CAN_REMOVE_NODE,
+            TreePetriflowIdentifiers.BEFORE_TEXT_ICON,
+            TreePetriflowIdentifiers.TREE_ADD_ICON
+        ];
+        const result = {
+            visibleTreePropertiesChanged: true,
+            childrenChanged: false
+        };
+        const oldChildCaseRef = getImmediateData(oldCase, TreePetriflowIdentifiers.CHILDREN_CASE_REF);
+        if (oldChildCaseRef !== undefined) {
+            const oldChildren = new Set(oldChildCaseRef.value);
+            const newChildren = new Set(getImmediateData(newCase, TreePetriflowIdentifiers.CHILDREN_CASE_REF).value);
+            result.childrenChanged = oldChildren.size !== newChildren.size;
+            if (!result.childrenChanged) {
+                result.childrenChanged = Array.from(oldChildren).some(childId => !newChildren.has(childId));
+            }
+            // short-circuit
+            if (result.childrenChanged) {
+                return result;
+            }
+        }
+        result.visibleTreePropertiesChanged = visibleAttributes.some(attribute => {
+            return getImmediateData(oldCase, attribute)
+                && getImmediateData(oldCase, attribute).value !== getImmediateData(newCase, attribute).value;
+        });
+        return result;
+    }
+}
+CaseTreeService.ctorParameters = () => [
+    { type: CaseResourceService },
+    { type: TreeCaseViewService },
+    { type: TaskResourceService },
+    { type: LoggerService },
+    { type: ProcessService },
+    { type: SideMenuService },
+    { type: TranslateService },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_OPTION_SELECTOR_COMPONENT,] }] }
+];
+CaseTreeService.decorators = [
+    { type: Injectable }
+];
+CaseTreeService.ctorParameters = () => [
+    { type: CaseResourceService },
+    { type: TreeCaseViewService },
+    { type: TaskResourceService },
+    { type: LoggerService },
+    { type: ProcessService },
+    { type: SideMenuService },
+    { type: TranslateService },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_OPTION_SELECTOR_COMPONENT,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-tree.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/view/tree-case-view/tree-component/case-tree.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy, Optional} from '@angular/core';\nimport {Filter} from '../../../filter/models/filter';\nimport {HttpParams} from '@angular/common/http';\nimport {CaseResourceService} from '../../../resources/engine-endpoint/case-resource.service';\nimport {CaseTreeNode} from './model/case-tree-node';\nimport {TreeCaseViewService} from '../tree-case-view.service';\nimport {TaskResourceService} from '../../../resources/engine-endpoint/task-resource.service';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {ImmediateData} from '../../../resources/interface/immediate-data';\nimport {Case} from '../../../resources/interface/case';\nimport {ProcessService} from '../../../process/process.service';\nimport {SideMenuService} from '../../../side-menu/services/side-menu.service';\nimport {SideMenuSize} from '../../../side-menu/models/side-menu-size';\nimport {forkJoin, Observable, of, ReplaySubject, Subject, Subscription, throwError} from 'rxjs';\nimport {Page} from '../../../resources/interface/page';\nimport {TreePetriflowIdentifiers} from '../model/tree-petriflow-identifiers';\nimport {tap} from 'rxjs/operators';\nimport {TranslateService} from '@ngx-translate/core';\nimport {hasContent} from '../../../utility/pagination/page-has-content';\nimport {NestedTreeControl} from '@angular/cdk/tree';\nimport {MatTreeNestedDataSource} from '@angular/material/tree';\nimport {ofVoid} from '../../../utility/of-void';\nimport {CaseGetRequestBody} from '../../../resources/interface/case-get-request-body';\nimport {getImmediateData} from '../../../utility/get-immediate-data';\nimport {NAE_OPTION_SELECTOR_COMPONENT} from '../../../side-menu/content-components/injection-tokens';\nimport {SimpleFilter} from '../../../filter/models/simple-filter';\nimport {CaseTreePath} from './model/case-tree-path';\nimport {ExpansionTree} from './model/expansion-tree';\nimport {ResultWithAfterActions} from '../../../utility/result-with-after-actions';\nimport {EventOutcomeMessageResource} from '../../../resources/interface/message-resource';\nimport {SetDataEventOutcome} from '../../../event/model/event-outcomes/data-outcomes/set-data-event-outcome';\nimport {CreateCaseEventOutcome} from '../../../event/model/event-outcomes/case-outcomes/create-case-event-outcome';\nimport {refreshTree} from '../../../utility/refresh-tree';\n\n/**\n * An internal helper object, that is used to return two values from a function.\n */\ninterface CaseUpdateResult {\n    /**\n     * Whether the attributes that are visible on the tree changed\n     */\n    visibleTreePropertiesChanged: boolean;\n    /**\n     * Whether the nodes children changed\n     */\n    childrenChanged: boolean;\n}\n\n@Injectable()\nexport class CaseTreeService implements OnDestroy {\n\n    protected _currentNode: CaseTreeNode;\n    private _rootNodesFilter: Filter;\n    private readonly _treeDataSource: MatTreeNestedDataSource<CaseTreeNode>;\n    private readonly _treeControl: NestedTreeControl<CaseTreeNode>;\n    private _treeRootLoaded$: ReplaySubject<boolean>;\n    private _rootNode: CaseTreeNode;\n    private _showRoot: boolean;\n    /**\n     * Weather the tree is eager loaded or not.\n     *\n     * Defaults to `false`.\n     *\n     * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.\n     */\n    private _isEagerLoaded = false;\n    /**\n     * string id of the case, that is currently being reloaded, `undefined` if no case is currently being reloaded\n     */\n    private _reloadedCaseId: string;\n\n    constructor(protected _caseResourceService: CaseResourceService,\n                protected _treeCaseViewService: TreeCaseViewService,\n                protected _taskResourceService: TaskResourceService,\n                protected _logger: LoggerService,\n                protected _processService: ProcessService,\n                protected _sideMenuService: SideMenuService,\n                protected _translateService: TranslateService,\n                @Optional() @Inject(NAE_OPTION_SELECTOR_COMPONENT) protected _optionSelectorComponent: any) {\n        this._treeDataSource = new MatTreeNestedDataSource<CaseTreeNode>();\n        this._treeControl = new NestedTreeControl<CaseTreeNode>(node => node.children);\n        _treeCaseViewService.reloadCase$.asObservable().subscribe(() => {\n            this.reloadCurrentCase();\n        });\n        this._treeRootLoaded$ = new ReplaySubject<boolean>(1);\n    }\n\n    ngOnDestroy(): void {\n        this._treeRootLoaded$.complete();\n    }\n\n    public set rootFilter(filter: Filter) {\n        this._rootNodesFilter = filter;\n        this.dataSource.data = [];\n        this.loadTreeRoot();\n    }\n\n    public get dataSource(): MatTreeNestedDataSource<CaseTreeNode> {\n        return this._treeDataSource;\n    }\n\n    public get treeControl(): NestedTreeControl<CaseTreeNode> {\n        return this._treeControl;\n    }\n\n    public get currentNode(): CaseTreeNode {\n        return this._currentNode;\n    }\n\n    /**\n     * Emits a value whenever a new root node Filter is set.\n     *\n     * `true` is emitted if the root node was successfully loaded. `false` otherwise.\n     *\n     * On subscription emits the last emitted value (if any) to the subscriber.\n     */\n    public get treeRootLoaded$(): Observable<boolean> {\n        return this._treeRootLoaded$.asObservable();\n    }\n\n    protected get _currentCase(): Case | undefined {\n        return this._currentNode ? this._currentNode.case : undefined;\n    }\n\n    /**\n     * @returns an `Observable` of the {@link LoadingEmitter} representing the loading state of the root node.\n     * Returns `undefined` if the tree has not yet been initialized.\n     *\n     * Wait for an emission on the [treeRootLoaded$]{@link CaseTreeService#treeRootLoaded$} stream before getting this Observable.\n     *\n     * The first value emitted by the Observable is `false`, when the tree finishes initializing.\n     */\n    public get rootNodeLoading$(): Observable<boolean> | undefined {\n        return !!this._rootNode ? this._rootNode.loadingChildren.asObservable() : undefined;\n    }\n\n    /**\n     * @returns an `Observable` of the {@link LoadingEmitter} representing whether the root node is currently\n     * in the process of adding a new child node or not.\n     * Returns `undefined` if the tree has not yet been initialized.\n     *\n     * Wait for an emission on the [treeRootLoaded$]{@link CaseTreeService#treeRootLoaded$} stream before getting this Observable.\n     *\n     * The first value emitted by the Observable is `false`, when the tree finishes initializing.\n     */\n    public get rootNodeAddingChild$(): Observable<boolean> | undefined {\n        return !!this._rootNode ? this._rootNode.addingNode.asObservable() : undefined;\n    }\n\n    /**\n     * Weather the tree is eager loaded or not.\n     *\n     * Defaults to `false`.\n     *\n     * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.\n     */\n    public get isEagerLoaded(): boolean {\n        return this._isEagerLoaded;\n    }\n\n    /**\n     * Weather the tree is eager loaded or not.\n     *\n     * Defaults to `false`.\n     *\n     * It is not recommended to eager load large trees as each node sends a separate backend request to load its data.\n     *\n     * @param eager the new setting for eager loading\n     */\n    public set isEagerLoaded(eager: boolean) {\n        this._isEagerLoaded = eager;\n    }\n\n    /**\n     * Loads and populates the topmost level of the tree.\n     *\n     * The displayed cases are determined by this object's [rootFilter]{@link CaseTreeService#rootFilter}.\n     *\n     * Cases are loaded one page at a time and the tree is refreshed after each page.\n     * [finishedLoadingFirstLevel$]{@link CaseTreeService#treeRootLoaded$}\n     * will emit `true` once the last page loads successfully.\n     * `false` will be emitted if any of the requests fail.\n     */\n    protected loadTreeRoot() {\n        if (this._rootNodesFilter) {\n            this._caseResourceService.searchCases(this._rootNodesFilter).subscribe(page => {\n                if (hasContent(page)) {\n                    this._rootNode = new CaseTreeNode(page.content[0], undefined);\n                    if (page.content.length !== 1) {\n                        this._logger.warn('Filter for tree root returned more than one case. Using the first value as tree root...');\n                    }\n                    this._treeRootLoaded$.next(true);\n                } else {\n                    this._logger.error('Tree root cannot be generated from the provided filter', page);\n                }\n            }, error => {\n                this._logger.error('Root node of the case tree could not be loaded', error);\n                this._treeRootLoaded$.next(false);\n            });\n        }\n    }\n\n    /**\n     * Adds the loaded tree root to the display based on the setting.\n     * @param showRoot whether the root of the tree should be displayed in the tree or not.\n     * If the root is not displayed it's children will be displayed on the first level.\n     * @returns an Observable that emits when the tree finishes initialization.\n     */\n    public initializeTree(showRoot: boolean): Observable<void> {\n        if (!this._rootNode) {\n            this._logger.error('Set a Filter before initializing the case tree');\n            return throwError(new Error('Set a Filter before initializing the case tree'));\n        }\n\n        this._showRoot = showRoot;\n\n        if (showRoot) {\n            this.dataSource.data = [this._rootNode];\n        } else {\n            this.dataSource.data = this._rootNode.children;\n        }\n\n        let ret: Observable<void>;\n        if (!showRoot || this._isEagerLoaded) {\n            const result = new ReplaySubject<void>(1);\n            ret = result.asObservable();\n            this.expandNode(this._rootNode).subscribe(() => {\n                this.refreshTree();\n                result.next();\n                result.complete();\n            });\n        } else {\n            this.refreshTree();\n            ret = ofVoid();\n        }\n        return ret;\n    }\n\n    /**\n     * Notifies the parent TreeCaseView that a case was clicked in the tree and it's Task should be displayed\n     */\n    public changeActiveNode(node: CaseTreeNode | undefined): void {\n        this._currentNode = node;\n        this._treeCaseViewService.loadTask$.next(node ? node.case : undefined);\n    }\n\n    /**\n     * Toggles the expansion state of a node\n     * @param node the {@link CaseTreeNode} who's content should be toggled\n     */\n    public toggleNode(node: CaseTreeNode): void {\n        if (this._treeControl.isExpanded(node)) {\n            this._treeControl.collapse(node);\n        } else {\n            this.expandNode(node);\n        }\n    }\n\n    /**\n     * Expands the target node in the tree and reloads it's children if they are marked as dirty\n     * @param node the {@link CaseTreeNode} that should be expanded\n     * @returns emits `true` if the node is expanded and `false` if not. If the expansion causes more node expansions\n     * (e.g. eager loaded tree) then, the Observable emits after all the subtree expansions complete.\n     */\n    protected expandNode(node: CaseTreeNode): Observable<boolean> {\n        this._logger.debug('Requesting expansion of tree node', node.toLoggableForm());\n\n        if (node.loadingChildren.isActive) {\n            this._logger.debug('Node requested for expansion is loading. Expansion canceled.');\n            return of(false);\n        }\n\n        if (!node.dirtyChildren) {\n            this._logger.debug('Node requested for expansion has clean children. Simple expansion.');\n            this.treeControl.expand(node);\n            return of(true);\n        }\n\n        const ret = new ReplaySubject<boolean>(1);\n        this.updateNodeChildren(node).subscribe(() => {\n            this._logger.debug('Node requested for expansion with dirty children had its children reloaded.');\n            if (node.children.length > 0) {\n                this._logger.debug('Node expanded.', node.toLoggableForm());\n                this.treeControl.expand(node);\n                if (this._isEagerLoaded) {\n                    this._logger.debug(`Eager loading children of tree node with case id '${node.case.stringId}'`);\n                    const innerObservables = node.children.map(childNode => this.expandNode(childNode));\n                    // forkJoin doesn't emit with 0 input observables\n                    innerObservables.push(of(true));\n                    forkJoin(innerObservables).subscribe(() => {\n                        ret.next(true);\n                        ret.complete();\n                    });\n                } else {\n                    ret.next(true);\n                    ret.complete();\n                }\n            } else {\n                ret.next(false);\n                ret.complete();\n            }\n        });\n        return ret.asObservable();\n    }\n\n    /**\n     * Checks whether dirty children need to be reloaded and reloads them if needed.\n     * @param node the {@link CaseTreeNode} who's children are updated\n     * @returns emits when loading finishes\n     */\n    protected updateNodeChildren(node: CaseTreeNode): Observable<void> {\n        node.loadingChildren.on();\n\n        const childrenCaseRef = getImmediateData(node.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);\n        if (!childrenCaseRef || childrenCaseRef.value.length === 0) {\n            node.children = [];\n            this.refreshTree();\n            node.dirtyChildren = false;\n            node.loadingChildren.off();\n            return ofVoid();\n        }\n\n        if (node.children.length === childrenCaseRef.value.length) {\n            const existingChildren = new Set<string>();\n            node.children.forEach(childNode => existingChildren.add(childNode.case.stringId));\n            if (childrenCaseRef.value.every(caseId => existingChildren.has(caseId))) {\n                node.dirtyChildren = false;\n                node.loadingChildren.off();\n                return ofVoid();\n            }\n        }\n\n        return this.updatePageOfChildren(node, 0).pipe(\n            tap(() => {\n                    this.refreshTree();\n                    node.dirtyChildren = false;\n                    node.loadingChildren.off();\n                }\n            )\n        );\n    }\n\n    /**\n     * Loads every page of children from the given number and updates the existing children.\n     *\n     * Missing nodes are removed. Existing nodes are marked as dirty. New nodes are added.\n     *\n     * Nodes are returned in their insertion order.\n     * @param node the {@link CaseTreeNode} who's children are updated\n     * @param pageNumber the number of the first page that should be loaded. All following pages are loaded as well\n     * @returns next is emitted when loading of all pages completes (regardless of the outcome)\n     */\n    protected updatePageOfChildren(node: CaseTreeNode, pageNumber: number): Observable<void> {\n        const requestBody = this.createChildRequestBody(node);\n        if (!requestBody) {\n            this._logger.error('Cannot create filter to find children of the given node', node.case);\n            return throwError(new Error('Cannot create filter to find children of the given node'));\n        }\n\n        const done = new ReplaySubject<void>(1);\n\n        let params: HttpParams = new HttpParams();\n        params = params.set('page', `${pageNumber}`).set('sort', 'creationDate,asc');\n        this._caseResourceService.getCases(requestBody, params).subscribe(page => {\n            if (!hasContent(page)) {\n                this._logger.error('Child cases invalid page content', page);\n                done.next();\n                done.complete();\n                return;\n            }\n\n            this.updateCurrentChildrenWithNewPage(node, page);\n\n            if (pageNumber + 1 < page.pagination.totalPages) {\n                this.updatePageOfChildren(node, pageNumber + 1).subscribe(() => {\n                    done.next();\n                    done.complete();\n                });\n            } else {\n                done.next();\n                done.complete();\n            }\n\n        }, error => {\n            this._logger.error('Child cases could not be loaded', error);\n            done.next();\n            done.complete();\n        });\n\n        return done.asObservable();\n    }\n\n    /**\n     * Updates the children of the given {@link CaseTreeNode} with [Cases]{@link Case} from the provided {@link Page}.\n     * @param node the {@link CaseTreeNode} who's children are updated\n     * @param page the {@link Page} that contains the updated children\n     */\n    protected updateCurrentChildrenWithNewPage(node: CaseTreeNode, page: Page<Case>): void {\n        page.content.forEach((newCase, index) => {\n            const position = page.pagination.size * page.pagination.number + index;\n            while (position < node.children.length && node.children[position].case.stringId !== newCase.stringId) {\n                node.children.splice(position, 1);\n            }\n            if (node.children.length === position) {\n                node.children.push(new CaseTreeNode(newCase, node));\n            } else {\n                node.children[position].case = newCase;\n                node.dirtyChildren = true;\n                this.treeControl.collapseDescendants(node.children[position]);\n            }\n        });\n    }\n\n    /**\n     * @param node the {@link CaseTreeNode} who's children the {@link Filter} should return\n     * @returns a request body that finds all child cases of the given `node`.\n     * Returns `undefined` if the provided `node` doesn't contain enough information to create the request body.\n     */\n    protected createChildRequestBody(node: CaseTreeNode): CaseGetRequestBody {\n        const childCaseRef = getImmediateData(node.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);\n        if (!childCaseRef) {\n            return undefined;\n        }\n\n        return {stringId: (childCaseRef.value as Array<string>)};\n    }\n\n    /**\n     * Adds a child to the root node.\n     *\n     * Useful if you are using the layout where the root node is hidden.\n     * @returns emits `true` if the child was successfully added, `false` if not\n     */\n    public addRootChildNode(): Observable<boolean> {\n        const ret = new ReplaySubject<boolean>(1);\n        this.addChildNode(this._rootNode).subscribe(added => {\n            if (added) {\n                if (!this._showRoot && this._treeDataSource.data.length === 0) {\n                    this._treeDataSource.data = this._rootNode.children;\n                    this.refreshTree();\n                }\n            }\n            ret.next(added);\n            ret.complete();\n        });\n        return ret;\n    }\n\n    /**\n     * Adds a new child node to the given node based on the properties of the node's case\n     * @returns emits `true` if the child was successfully added, `false` if not\n     */\n    public addChildNode(clickedNode: CaseTreeNode): Observable<boolean> {\n        clickedNode.addingNode.on();\n        const caseRefField = getImmediateData(clickedNode.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);\n\n        if (caseRefField.allowedNets.length === 0) {\n            this._logger.error(`Case ${clickedNode.case.stringId} can add new tree nodes but has no allowed nets`);\n            clickedNode.addingNode.off();\n            return of(false);\n        }\n\n        const ret = new ReplaySubject<boolean>(1);\n\n        if (caseRefField.allowedNets.length === 1) {\n            this.createAndAddChildCase(caseRefField.allowedNets[0], clickedNode, ret);\n        } else {\n            this._processService.getNets(caseRefField.allowedNets).subscribe(nets => {\n                const sideMeuRef = this._sideMenuService.open(this._optionSelectorComponent, SideMenuSize.MEDIUM, {\n                    title: clickedNode.case.title,\n                    options: nets.map(net => ({text: net.title, value: net.identifier}))\n                });\n                let sideMenuSubscription: Subscription;\n                sideMenuSubscription = sideMeuRef.onClose.subscribe(event => {\n                    if (!!event.data) {\n                        this.createAndAddChildCase(event.data.value, clickedNode, ret);\n                        sideMenuSubscription.unsubscribe();\n                    } else {\n                        clickedNode.addingNode.off();\n                        ret.next(false);\n                        ret.complete();\n                    }\n                });\n            });\n        }\n        return ret.asObservable();\n    }\n\n    /**\n     * Creates a new case and adds it to the children of the specified node\n     * @param processIdentifier identifier of the process that should be created\n     * @param clickedNode the node that is the parent of the new case\n     * @param operationResult the result of the operation will be emitted into this stream when the operation completes\n     */\n    protected createAndAddChildCase(processIdentifier: string,\n                                    clickedNode: CaseTreeNode,\n                                    operationResult: Subject<boolean>) {\n        this._processService.getNet(processIdentifier).subscribe(net => {\n            const childTitleImmediate = getImmediateData(clickedNode.case, TreePetriflowIdentifiers.CHILD_NODE_TITLE);\n            let childTitle = this._translateService.instant('caseTree.newNodeDefaultName');\n            if (!!childTitleImmediate) {\n                childTitle = childTitleImmediate.value;\n            } else if (!!net.defaultCaseName) {\n                childTitle = net.defaultCaseName;\n            }\n            this._caseResourceService.createCase({\n                title: childTitle,\n                netId: net.stringId\n            }).subscribe((outcomeResource: EventOutcomeMessageResource) => {\n                const caseRefField = getImmediateData(clickedNode.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);\n                const setCaseRefValue = [...caseRefField.value, (outcomeResource.outcome as CreateCaseEventOutcome).aCase.stringId];\n                this.performCaseRefCall(clickedNode.case.stringId, setCaseRefValue).subscribe(\n                    valueChange => this.updateTreeAfterChildAdd(clickedNode, valueChange ? valueChange : setCaseRefValue, operationResult)\n                );\n            });\n        });\n    }\n\n    /**\n     * Updates the tree after adding a new child\n     * @param clickedNode the parent node\n     * @param newCaseRefValue the new value of the parent node's case ref\n     * @param operationResult the result of the operation will be emitted into this stream when the operation completes\n     */\n    protected updateTreeAfterChildAdd(clickedNode: CaseTreeNode, newCaseRefValue: Array<string>, operationResult: Subject<boolean>): void {\n        this.updateNodeChildrenFromChangedFields(clickedNode, newCaseRefValue).subscribe(result => {\n            clickedNode.addingNode.off();\n            this.expandNode(clickedNode).subscribe(expandSuccess => {\n                if (expandSuccess) {\n                    this.changeActiveNode(clickedNode.children[clickedNode.children.length - 1]);\n                    result.executeAfterActions();\n                }\n                operationResult.next(true);\n                operationResult.complete();\n            });\n        });\n    }\n\n    /**\n     * removes the provided non-root node if the underlying case allows it.\n     *\n     * The underlying case is removed from the case ref of it's parent element with the help from the `remove`\n     * operation provided by case ref itself.\n     * @param node the node that should be removed from the tree\n     */\n    public removeNode(node: CaseTreeNode): void {\n        if (!node.parent) {\n            this._logger.error('Case tree doesn\\'t support removal of the root node, as it has no parent case ref.');\n            return;\n        }\n\n        node.removingNode.on();\n        const caseRefImmediate = getImmediateData(node.parent.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);\n        const setCaseRefValue = (caseRefImmediate.value as Array<string>).filter(id => id !== node.case.stringId);\n        this.performCaseRefCall(node.parent.case.stringId, setCaseRefValue).subscribe(caseRefChange => {\n            const newCaseRefValue = caseRefChange ? caseRefChange : setCaseRefValue;\n            this.deleteRemovedNodes(node.parent, newCaseRefValue);\n            this.updateNodeChildrenFromChangedFields(node.parent, newCaseRefValue);\n\n            node.removingNode.off();\n        });\n\n        this.deselectNodeIfDescendantOf(node);\n    }\n\n    /**\n     * Expands all nodes in the tree dictated by the argument.\n     *\n     * @param path nodes that should be expanded along with their path from the root node\n     */\n    public expandPath(path: CaseTreePath): void {\n        if (this.dataSource.data.length === 0) {\n            return;\n        }\n        let rootNode = this.dataSource.data[0];\n        while (rootNode.parent !== undefined) {\n            rootNode = rootNode.parent;\n        }\n        this.expandLevel([rootNode], this.convertPathToExpansionTree(path));\n    }\n\n    /**\n     * Transforms a {@Link CaseTreePath} object into an {@link ExpansionTree} object.\n     * The result has all the common paths merged into single branches of the resulting tree structure.\n     *\n     * @param paths nodes that should be expanded along with their path from the root node\n     * @returns an {@link ExpansionTree} equivalent to the provided {@link CaseTreePath}\n     */\n    protected convertPathToExpansionTree(paths: CaseTreePath): ExpansionTree {\n        const result = {};\n        Object.values(paths).forEach(path => {\n            let currentNode = result;\n            path.forEach(nodeId => {\n                if (currentNode[nodeId] === undefined) {\n                    currentNode[nodeId] = {};\n                }\n                currentNode = currentNode[nodeId];\n            });\n        });\n        return result;\n    }\n\n    /**\n     * Recursively expands all nodes from the provided array of nodes, that appear in the top level of the {@link ExpansionTree} object.\n     *\n     * @param levelNodes nodes from which the expansion should start\n     * @param targets a tree structure representing the nodes that are to be expanded recursively.\n     * The top level nodes are expanded first, from the provided `levelNodes`.\n     */\n    protected expandLevel(levelNodes: Array<CaseTreeNode>, targets: ExpansionTree): void {\n        const desiredIds = new Set(Object.keys(targets));\n        if (desiredIds.size === 0) {\n            return;\n        }\n\n        levelNodes.forEach(n => {\n            const node = n;\n            if (!desiredIds.has(node.case.stringId)) {\n                return; // continue\n            }\n            this.expandNode(node).subscribe(success => {\n                if (!success) {\n                    this._logger.debug('Could not expand tree node with ID: ' + node.case.stringId);\n                    return;\n                }\n                this.expandLevel(node.children, targets[node.case.stringId]);\n            });\n        });\n    }\n\n    /**\n     * Deletes the subtrees rooted at the nodes that are present in the parent node's child case ref values,\n     * but are no longer present in the new value\n     * @param parentNode an inner node of the tree that had some of it's children removed\n     * @param newCaseRefValue the new value of the parent node's case ref\n     */\n    protected deleteRemovedNodes(parentNode: CaseTreeNode, newCaseRefValue: Array<string>): void {\n        const removedChildren = new Set<string>();\n        getImmediateData(parentNode.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF).value.forEach(id => removedChildren.add(id));\n        newCaseRefValue.forEach(id => removedChildren.delete(id));\n        removedChildren.forEach(removedId => this._caseResourceService.deleteCase(removedId, true)\n            .subscribe(responseMessage => {\n                if (responseMessage.error) {\n                    this._logger.error('Removal of child case unsuccessful', responseMessage.error);\n                }\n            }));\n    }\n\n    /**\n     * Deselects the currently selected node if it is a descendant of the provided node\n     * @param node the node who's descendants should be deselected\n     */\n    protected deselectNodeIfDescendantOf(node: CaseTreeNode): void {\n        let bubblingNode = this.currentNode;\n        while (bubblingNode && bubblingNode !== this._rootNode) {\n            if (bubblingNode === node) {\n                this.changeActiveNode(undefined);\n                break;\n            }\n            bubblingNode = bubblingNode.parent;\n        }\n    }\n\n    /**\n     * Performs a backend call on the given case, and sets the value of the case ref field in the transition defined by\n     * [CASE_REF_TRANSITION]{@link TreePetriflowIdentifiers#CASE_REF_TRANSITION}.\n     * @param caseId string ID of the case that should have it's tree case ref set\n     * @param newCaseRefValue the new value of the case ref field\n     */\n    private performCaseRefCall(caseId: string, newCaseRefValue: Array<string>): Observable<Array<string> | undefined> {\n        const result$ = new ReplaySubject<Array<string>>(1);\n\n        this._taskResourceService.getTasks(SimpleFilter.fromTaskQuery({\n            case: {id: caseId},\n            transitionId: TreePetriflowIdentifiers.CASE_REF_TRANSITION\n        })).subscribe(page => {\n            if (!hasContent(page)) {\n                this._logger.error('Case ref accessor task doesn\\'t exist!');\n                result$.complete();\n                return;\n            }\n\n            const task = page.content[0];\n\n            this._taskResourceService.assignTask(task.stringId).subscribe(assignResponse => {\n                if (!assignResponse.success) {\n                    this._logger.error('Case ref accessor task could not be assigned', assignResponse.error);\n                }\n\n                const body = {};\n                body[TreePetriflowIdentifiers.CHILDREN_CASE_REF] = {\n                    type: 'caseRef',\n                    value: newCaseRefValue\n                };\n                this._taskResourceService.setData(task.stringId, body).subscribe((outcomeResource: EventOutcomeMessageResource) => {\n                    const changedFields = (outcomeResource.outcome as SetDataEventOutcome).changedFields.changedFields;\n                    const caseRefChanges = changedFields[TreePetriflowIdentifiers.CHILDREN_CASE_REF];\n                    result$.next(caseRefChanges ? caseRefChanges.value : undefined);\n                    result$.complete();\n                    this._taskResourceService.finishTask(task.stringId).subscribe(finishResponse => {\n                        if (finishResponse.success) {\n                            this._logger.debug('Case ref accessor task finished', finishResponse.success);\n                        } else {\n                            this._logger.error('Case ref accessor task finish failed', finishResponse.error);\n                        }\n                    });\n                }, error => {\n                    this._logger.error('Could not set data to tree case ref', error);\n                    result$.complete();\n                });\n            }, error => {\n                this._logger.error('Case ref accessor task could not be assigned', error);\n                result$.complete();\n            });\n        }, error => {\n            this._logger.error('Case ref accessor task could not be found', error);\n            result$.complete();\n        });\n        return result$.asObservable();\n    }\n\n    /**\n     * Performs an update after adding or removing a node from the tree.\n     *\n     * If only one node was added adds it into the tree\n     *\n     * If only one node was removed removes it from the tree\n     *\n     * Otherwise collapses the affected node and marks it's children as dirty\n     *\n     * @param affectedNode node that had it's children changed\n     * @param newCaseRefValue new value of the caseRef field returned by backend\n     * @returns an `Observable` that emits an object with the [result]{@link ResultWithAfterActions#result} attribute set to `true` if\n     * the update completes successfully and `false` otherwise.\n     */\n    private updateNodeChildrenFromChangedFields(affectedNode: CaseTreeNode,\n                                                newCaseRefValue: Array<string>): Observable<ResultWithAfterActions<boolean>> {\n        const caseRefField = getImmediateData(affectedNode.case, TreePetriflowIdentifiers.CHILDREN_CASE_REF);\n        const newChildren = new Set<string>();\n        newCaseRefValue.forEach(id => newChildren.add(id));\n\n        let numberOfMissingChildren = 0;\n        for (let i = 0; i < caseRefField.value.length && numberOfMissingChildren < 2; i++) {\n            if (!newChildren.has(caseRefField.value[i])) {\n                numberOfMissingChildren++;\n            }\n        }\n\n        const exactlyOneChildAdded = caseRefField.value.length + 1 === newCaseRefValue.length\n            && caseRefField.value.every(it => newChildren.has(it));\n\n        const exactlyOneChildRemoved = caseRefField.value.length - 1 === newCaseRefValue.length\n            && numberOfMissingChildren === 1;\n\n        if (!exactlyOneChildAdded && !exactlyOneChildRemoved) {\n            caseRefField.value = newCaseRefValue;\n            this._treeControl.collapseDescendants(affectedNode);\n            affectedNode.dirtyChildren = true;\n            return of(new ResultWithAfterActions(true));\n        }\n\n        if (exactlyOneChildAdded) {\n            return this.processChildNodeAdd(affectedNode, caseRefField, newCaseRefValue);\n        } else {\n            return this.processChildNodeRemove(affectedNode, caseRefField, newChildren);\n        }\n    }\n\n    /**\n     * Adds a new child node to the `affectedNode` by adding the last Case from the `newCaseRefValue`\n     * @param affectedNode the node in the tree that had a child added - the parent node\n     * @param caseRefField the case ref field of the affected node\n     * @param newCaseRefValue the new value of the case ref field in the node\n     * @returns an `Observable` that emits `true` if a node was successfully added, `false` otherwise.\n     */\n    protected processChildNodeAdd(affectedNode: CaseTreeNode,\n                                  caseRefField: ImmediateData,\n                                  newCaseRefValue: Array<string>): Observable<ResultWithAfterActions<boolean>> {\n        const result$ = new ReplaySubject<ResultWithAfterActions<boolean>>(1);\n\n        caseRefField.value = newCaseRefValue;\n        this._caseResourceService.getOneCase(newCaseRefValue[newCaseRefValue.length - 1]).subscribe(childCase => {\n            if (childCase) {\n                this._logger.debug('Pushing child node to tree', {childCase, affectedNode: affectedNode.toLoggableForm()});\n                const childNode = this.pushChildToTree(affectedNode, childCase);\n                result$.next(new ResultWithAfterActions(true, [() => {\n                    if (this._isEagerLoaded) {\n                        this._logger.debug('Eagerly expanding a newly added node.', childNode.toLoggableForm());\n                        this.expandNode(childNode);\n                    }\n                }]));\n            } else {\n                this._logger.error('New child case was not found, illegal state', childCase);\n                result$.next(new ResultWithAfterActions(false));\n            }\n            result$.complete();\n        }, error => {\n            this._logger.error('New child node case could not be found', error);\n            result$.next(new ResultWithAfterActions(false));\n            result$.complete();\n        });\n\n        return result$.asObservable();\n    }\n\n    /**\n     * Adds a new child node to the target parent node.\n     * @param parentNode the nodes whose child should be added\n     * @param childCase the child case\n     * @returns the newly added node\n     */\n    protected pushChildToTree(parentNode: CaseTreeNode, childCase: Case): CaseTreeNode {\n        const childNode = new CaseTreeNode(childCase, parentNode);\n        parentNode.children.push(childNode);\n        this.refreshTree();\n        return childNode;\n    }\n\n    /**\n     * Removes the deleted node from the children of the `affectedNode`\n     * @param affectedNode the node in the tree that had it's child removed\n     * @param caseRefField the case ref field of the affected node\n     * @param newCaseRefValues the new value of the case ref field in the node\n     * @returns an `Observable` that emits `true` when the remove operation completes.\n     */\n    protected processChildNodeRemove(affectedNode: CaseTreeNode,\n                                     caseRefField: ImmediateData,\n                                     newCaseRefValues: Set<string>): Observable<ResultWithAfterActions<boolean>> {\n        const index = caseRefField.value.findIndex(it => !newCaseRefValues.has(it));\n        caseRefField.value.splice(index, 1);\n        affectedNode.children.splice(index, 1);\n        this.refreshTree();\n        return of(new ResultWithAfterActions(true));\n    }\n\n    /**\n     * @ignore\n     * Forces a rerender of the tree content\n     */\n    private refreshTree(): void {\n        refreshTree(this._treeDataSource);\n    }\n\n    /**\n     * Reloads the currently selected case node. The {@link Case} object held in the {@link CaseTreeNode} instance is not replaced,\n     * but the new Case is `Object.assign`-ed into it. This means that the reference to the Case instance is unchanged but references\n     * to all it's non-primitive attributes are changed.\n     *\n     * If a reload of the current node is initiated before the previous one completed, the new one is ignored.\n     *\n     * If the currently selected case changed before a response from backend was received the response is ignored.\n     *\n     * Note that the parent node, nor the child nodes are reloaded.\n     */\n    protected reloadCurrentCase(): void {\n        if (!this._currentNode) {\n            this._logger.debug('No Tree Case Node selected, nothing to reload');\n            return;\n        }\n        if (this._reloadedCaseId && this._currentNode.case.stringId !== this._reloadedCaseId) {\n            this._logger.debug('Reload of the current case already in progress');\n            return;\n        }\n        this._reloadedCaseId = this._currentNode.case.stringId;\n        this._caseResourceService.getOneCase(this._currentCase.stringId).subscribe(reloadedCurrentCase => {\n            if (!reloadedCurrentCase) {\n                this._logger.error('Current Case Tree Node could not be reloaded. Invalid server response', reloadedCurrentCase);\n                return;\n            }\n            if (this._currentNode && reloadedCurrentCase.stringId === this._currentNode.case.stringId) {\n                this._reloadedCaseId = undefined;\n                const change = this.determineCaseUpdate(this._currentCase, reloadedCurrentCase);\n                Object.assign(this._currentCase, reloadedCurrentCase);\n                this._treeCaseViewService.loadTask$.next(this._currentCase);\n                if (change.visibleTreePropertiesChanged) {\n                    this.refreshTree();\n                }\n                if (change.childrenChanged) {\n                    this._currentNode.dirtyChildren = true;\n                    this.expandNode(this._currentNode);\n                }\n                this._logger.debug('Current Case Tree Node reloaded');\n            } else {\n                this._logger.debug('Discarding case reload response, since the current node has changed before its case was received');\n            }\n        }, error => {\n            this._logger.error('Current Case Tree Node reload request failed', error);\n        });\n    }\n\n    /**\n     * Determines if anny of the case attributes that are visible on the tree changed.\n     * @param oldCase the previous version of the Case object, that is currently displayed on the tree\n     * @param newCase the new version of the Case object, that should replace the old one\n     */\n    private determineCaseUpdate(oldCase: Case, newCase: Case): CaseUpdateResult {\n        const visibleAttributes = [\n            TreePetriflowIdentifiers.CAN_ADD_CHILDREN,\n            TreePetriflowIdentifiers.CAN_REMOVE_NODE,\n            TreePetriflowIdentifiers.BEFORE_TEXT_ICON,\n            TreePetriflowIdentifiers.TREE_ADD_ICON\n        ];\n\n        const result: CaseUpdateResult = {\n            visibleTreePropertiesChanged: true, // for short-circuiting the evaluation, if nodes children changed\n            childrenChanged: false\n        };\n\n        const oldChildCaseRef = getImmediateData(oldCase, TreePetriflowIdentifiers.CHILDREN_CASE_REF);\n        if (oldChildCaseRef !== undefined) {\n            const oldChildren = new Set(oldChildCaseRef.value);\n            const newChildren = new Set(getImmediateData(newCase, TreePetriflowIdentifiers.CHILDREN_CASE_REF).value);\n\n            result.childrenChanged = oldChildren.size !== newChildren.size;\n            if (!result.childrenChanged) {\n                result.childrenChanged = Array.from(oldChildren).some(childId => !newChildren.has(childId));\n            }\n\n            // short-circuit\n            if (result.childrenChanged) {\n                return result;\n            }\n        }\n\n        result.visibleTreePropertiesChanged = visibleAttributes.some(attribute => {\n            return getImmediateData(oldCase, attribute)\n                && getImmediateData(oldCase, attribute).value !== getImmediateData(newCase, attribute).value;\n        });\n\n        return result;\n    }\n}\n"]}