import { Inject, Injectable, Optional } from '@angular/core';
import { HttpParams } from '@angular/common/http';
import { CaseTreeNode } from './model/case-tree-node';
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 { 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';
import { NAE_TREE_CASE_VIEW_CONFIGURATION } from './model/tree-configuration-injection-token';
import { PaginationParams } from '../../../utility/pagination/pagination-params';
import { createSortParam, PaginationSort } from '../../../utility/pagination/pagination-sort';
import * as i0 from "@angular/core";
import * as i1 from "../../../resources/engine-endpoint/case-resource.service";
import * as i2 from "../tree-case-view.service";
import * as i3 from "../../../resources/engine-endpoint/task-resource.service";
import * as i4 from "../../../logger/services/logger.service";
import * as i5 from "../../../process/process.service";
import * as i6 from "../../../side-menu/services/side-menu.service";
import * as i7 from "@ngx-translate/core";
export class CaseTreeService {
    _caseResourceService;
    _treeCaseViewService;
    _taskResourceService;
    _logger;
    _processService;
    _sideMenuService;
    _translateService;
    _optionSelectorComponent;
    _treeConfiguration;
    static DEFAULT_PAGE_SIZE = 50;
    _currentNode;
    _rootNodesFilter;
    _treeDataSource;
    _treeControl;
    _treeRootLoaded$;
    _rootNode;
    _showRoot;
    /**
     * 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.
     */
    _isEagerLoaded = false;
    /**
     * string id of the case, that is currently being reloaded, `undefined` if no case is currently being reloaded
     */
    _reloadedCaseId;
    constructor(_caseResourceService, _treeCaseViewService, _taskResourceService, _logger, _processService, _sideMenuService, _translateService, _optionSelectorComponent, _treeConfiguration) {
        this._caseResourceService = _caseResourceService;
        this._treeCaseViewService = _treeCaseViewService;
        this._taskResourceService = _taskResourceService;
        this._logger = _logger;
        this._processService = _processService;
        this._sideMenuService = _sideMenuService;
        this._translateService = _translateService;
        this._optionSelectorComponent = _optionSelectorComponent;
        this._treeConfiguration = _treeConfiguration;
        if (!this._treeConfiguration) {
            this._treeConfiguration = {
                pageSize: CaseTreeService.DEFAULT_PAGE_SIZE
            };
        }
        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(PaginationParams.PAGE_SIZE, `${this._treeConfiguration.pageSize}`)
            .set(PaginationParams.PAGE_NUMBER, `${pageNumber}`)
            .set(PaginationParams.PAGE_SORT, createSortParam('creationDate', PaginationSort.ASCENDING));
        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[task.stringId] = {
                    [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;
    }
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CaseTreeService, deps: [{ token: i1.CaseResourceService }, { token: i2.TreeCaseViewService }, { token: i3.TaskResourceService }, { token: i4.LoggerService }, { token: i5.ProcessService }, { token: i6.SideMenuService }, { token: i7.TranslateService }, { token: NAE_OPTION_SELECTOR_COMPONENT, optional: true }, { token: NAE_TREE_CASE_VIEW_CONFIGURATION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CaseTreeService });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CaseTreeService, decorators: [{
            type: Injectable
        }], ctorParameters: () => [{ type: i1.CaseResourceService }, { type: i2.TreeCaseViewService }, { type: i3.TaskResourceService }, { type: i4.LoggerService }, { type: i5.ProcessService }, { type: i6.SideMenuService }, { type: i7.TranslateService }, { type: undefined, decorators: [{
                    type: Optional
                }, {
                    type: Inject,
                    args: [NAE_OPTION_SELECTOR_COMPONENT]
                }] }, { type: undefined, decorators: [{
                    type: Optional
                }, {
                    type: Inject,
                    args: [NAE_TREE_CASE_VIEW_CONFIGURATION]
                }] }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-tree.service.js","sourceRoot":"","sources":["../../../../../../../projects/netgrif-components-core/src/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';\nimport {NAE_TREE_CASE_VIEW_CONFIGURATION} from './model/tree-configuration-injection-token';\nimport {TreeCaseViewConfiguration} from './model/tree-case-view-configuration';\nimport {PaginationParams} from '../../../utility/pagination/pagination-params';\nimport {createSortParam, PaginationSort} from '../../../utility/pagination/pagination-sort';\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    public static readonly DEFAULT_PAGE_SIZE = 50;\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                @Optional() @Inject(NAE_TREE_CASE_VIEW_CONFIGURATION) protected _treeConfiguration: TreeCaseViewConfiguration) {\n        if (!this._treeConfiguration) {\n            this._treeConfiguration = {\n                pageSize: CaseTreeService.DEFAULT_PAGE_SIZE\n            };\n        }\n\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(PaginationParams.PAGE_SIZE, `${this._treeConfiguration.pageSize}`)\n                       .set(PaginationParams.PAGE_NUMBER, `${pageNumber}`)\n                       .set(PaginationParams.PAGE_SORT, createSortParam('creationDate', PaginationSort.ASCENDING));\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[task.stringId] = {\n                    [TreePetriflowIdentifiers.CHILDREN_CASE_REF]: {\n                        type: 'caseRef',\n                        value: newCaseRefValue\n                    }\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"]}