@netgrif/components-core 6.1.1 → 6.2.0-rc.11

package/esm2020/lib/navigation/navigation-double-drawer/abstract-navigation-double-drawer.mjs

@@ -0,0 +1,386 @@
+import { Component, Input } from '@angular/core';
+import { forkJoin } from 'rxjs';
+import { Breakpoints } from '@angular/cdk/layout';
+import { LoadingEmitter } from "../../utility/loading-emitter";
+import { NAE_ROUTING_CONFIGURATION_PATH } from "../../routing/routing-builder/routing-builder.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/cdk/layout";
+import * as i3 from "../../translate/language.service";
+import * as i4 from "../../user/services/user.service";
+import * as i5 from "../../authorization/permission/access.service";
+import * as i6 from "../../logger/services/logger.service";
+import * as i7 from "../../configuration/configuration.service";
+import * as i8 from "../service/uri.service";
+import * as i9 from "../../routing/dynamic-navigation-route-provider/dynamic-navigation-route-provider.service";
+export const FILTER_IDENTIFIERS = [
+    "preference_filter_item"
+];
+export const FILTER_VIEW_TASK_TRANSITION_ID = 'view';
+const LEFT_DRAWER_DEFAULT_WIDTH = 60;
+const RIGHT_DRAWER_DEFAULT_WIDTH = 240;
+const RIGHT_DRAWER_DEFAULT_MIN_WIDTH = 180;
+const RIGHT_DRAWER_MAX_WIDTH = 460;
+export class AbstractNavigationDoubleDrawerComponent {
+    constructor(_router, _activatedRoute, _breakpoint, _languageService, _userService, _accessService, _log, _config, _uriService, _dynamicRoutingService) {
+        this._router = _router;
+        this._activatedRoute = _activatedRoute;
+        this._breakpoint = _breakpoint;
+        this._languageService = _languageService;
+        this._userService = _userService;
+        this._accessService = _accessService;
+        this._log = _log;
+        this._config = _config;
+        this._uriService = _uriService;
+        this._dynamicRoutingService = _dynamicRoutingService;
+        this.imageRouterLink = "/";
+        this.imageAlt = "Logo";
+        this.profileRouterLink = "/profile";
+        this.includeUser = true;
+        this.includeLanguage = true;
+        this.includeMoreMenu = true;
+        this.allClosable = true;
+        this.folderIcon = "folder";
+        this.openedFolderIcon = "folder_open";
+        this.filterIcon = "filter_alt";
+        this.foldersCategoryName = 'toolbar.menu.folders';
+        this.viewsCategoryName = 'toolbar.menu.views';
+        this._configLeftMenu = {
+            mode: 'side',
+            opened: true,
+            disableClose: false,
+            width: LEFT_DRAWER_DEFAULT_WIDTH
+        };
+        this._configRightMenu = {
+            mode: 'side',
+            opened: true,
+            disableClose: false,
+            width: RIGHT_DRAWER_DEFAULT_WIDTH
+        };
+        this.leftNodes = new Array();
+        this.rightNodes = new Array();
+        this.views = new Array();
+        this.leftLoading$ = new LoadingEmitter();
+        this.rightLoading$ = new LoadingEmitter();
+        this._childCustomViews = {};
+        this.moreMenuItems = new Array();
+    }
+    ngOnInit() {
+        this._breakpointSubscription = this._breakpoint.observe([Breakpoints.HandsetLandscape]).subscribe(() => {
+            if (this._breakpoint.isMatched('(max-width: 959.99px)')) {
+                this.resolveLayout(false);
+            }
+            else {
+                this.resolveLayout(true);
+            }
+        });
+        if (!this.currentNode) {
+            this.leftLoading$.on();
+            this.rightLoading$.on();
+        }
+        this._currentNodeSubscription = this._uriService.activeNode$.subscribe(node => {
+            this.currentNode = node;
+            if (!node)
+                return;
+            if (this.leftLoading$.isActive || this.rightLoading$.isActive) {
+                this.leftLoading$.off();
+                this.rightLoading$.off();
+            }
+            if (this._uriService.isRoot(node)) {
+                this.leftNodes = [];
+                this.loadRightSide();
+                return;
+            }
+            if (!this.leftNodes.find(n => n.id === node.id)) {
+                this.loadLeftSide();
+            }
+            this.loadRightSide();
+        });
+        const viewConfigurationPath = this._activatedRoute.snapshot.data[NAE_ROUTING_CONFIGURATION_PATH];
+        if (!!viewConfigurationPath) {
+            const viewConfiguration = this._config.getViewByPath(viewConfigurationPath);
+            Object.entries(viewConfiguration.children).forEach(([key, childView]) => {
+                this.resolveUriForChildViews(viewConfigurationPath + '/' + key, childView);
+                this.resolveHiddenMenuItemFromChildViews(viewConfigurationPath + '/' + key, childView);
+            });
+        }
+    }
+    resolveUriForChildViews(configPath, childView) {
+        if (!childView.processUri)
+            return;
+        if (!this._accessService.canAccessView(childView, configPath))
+            return;
+        if (!this._childCustomViews[childView.processUri]) {
+            this._childCustomViews[childView.processUri] = {};
+        }
+        this._childCustomViews[childView.processUri][configPath] = {
+            id: configPath,
+            ...childView
+        };
+    }
+    resolveHiddenMenuItemFromChildViews(configPath, childView) {
+        if (!childView.navigation)
+            return;
+        if (!this._accessService.canAccessView(childView, configPath))
+            return;
+        // @ts-ignore
+        if (!!(childView?.navigation?.hidden)) {
+            this.moreMenuItems.push({
+                id: configPath,
+                ...childView
+            });
+        }
+    }
+    ngOnDestroy() {
+        this._breakpointSubscription?.unsubscribe();
+        this._leftNodesSubscription?.unsubscribe();
+        this._rightNodesSubscription?.unsubscribe();
+        this._filtersSubscription?.unsubscribe();
+        this._rootSubscription?.unsubscribe();
+        this._currentNodeSubscription?.unsubscribe();
+        this.leftLoading$.complete();
+        this.rightLoading$.complete();
+    }
+    get configLeftMenu() {
+        return this._configLeftMenu;
+    }
+    get configRightMenu() {
+        return this._configRightMenu;
+    }
+    toggleMenu() {
+        this.toggleRightMenu();
+        if (this.allClosable) {
+            this.toggleLeftMenu();
+        }
+    }
+    toggleLeftMenu() {
+        this._configLeftMenu.opened = !this._configLeftMenu.opened;
+    }
+    toggleRightMenu() {
+        this._configRightMenu.opened = !this._configRightMenu.opened;
+    }
+    resolveLayout(isLargeScreen) {
+        this._configLeftMenu = isLargeScreen ? {
+            mode: 'side',
+            opened: true,
+            disableClose: true,
+            width: this._configLeftMenu.width
+        } : {
+            mode: 'over',
+            opened: false,
+            disableClose: false,
+            width: this._configLeftMenu.width
+        };
+        this._configRightMenu = isLargeScreen ? {
+            mode: 'side',
+            opened: true,
+            disableClose: true,
+            width: this._configRightMenu.width
+        } : {
+            mode: 'over',
+            opened: false,
+            disableClose: false,
+            width: this._configRightMenu.width
+        };
+    }
+    getLang() {
+        return this._languageService.getLanguage();
+    }
+    logout() {
+        this._userService.logout().subscribe(() => {
+            this._log.debug('User is logged out');
+            if (this._config.get().services && this._config.get().services.auth && this._config.get().services.auth.logoutRedirect) {
+                const redirectPath = this._config.get().services.auth.logoutRedirect;
+                this._log.info('Redirecting to ' + redirectPath);
+                this._router.navigate([redirectPath]);
+            }
+        });
+    }
+    get user() {
+        return this._userService.user;
+    }
+    get canGoBackLoading$() {
+        return this._uriService.parentNodeLoading$;
+    }
+    /**
+     * On home click, the current level is set to 0, and current parent is
+     * set to root node.
+     * */
+    onHomeClick() {
+        this._uriService.reset();
+    }
+    /**
+     * On back click, the parent is set to parent of left nodes, that will solve
+     * the right side menu (elements that were in left side, after backward
+     * navigation will be on the right side).
+     * Current level is set to a lower number in order to set the left side menu.
+     * */
+    onBackClick() {
+        if (this._uriService.isRoot(this.currentNode))
+            return;
+        this._uriService.activeNode = this.currentNode.parent;
+    }
+    onNodeClick(node) {
+        this._uriService.activeNode = node;
+    }
+    loadLeftSide() {
+        if (this._uriService.isRoot(this.currentNode)) {
+            this.leftNodes = [];
+            return;
+        }
+        this.leftLoading$.on();
+        this._leftNodesSubscription = this._uriService.getSiblingsOfNode(this.currentNode).subscribe(nodes => {
+            this.leftNodes = nodes instanceof Array ? nodes : [];
+            this.leftNodes.sort((a, b) => this.compareStrings(a.name, b.name));
+            this.leftLoading$.off();
+        }, error => {
+            this._log.error(error);
+            this.leftNodes = [];
+            this.leftLoading$.off();
+        });
+    }
+    loadRightSide() {
+        this.rightLoading$.on();
+        forkJoin({
+            folders: this._uriService.getChildNodes(this.currentNode),
+            filters: this._uriService.getCasesOfNode(this.currentNode, FILTER_IDENTIFIERS)
+        }).subscribe(result => {
+            this.rightNodes = result.folders instanceof Array ? result.folders : [];
+            this.rightNodes.sort((a, b) => this.compareStrings(a.name, b.name));
+            this.views = (result.filters instanceof Array ? result.filters : []).map(f => this.resolveFilterCaseToViewNavigationItem(f)).filter(i => !!i);
+            if (!!this._childCustomViews[this.currentNode.uriPath]) {
+                this.views.push(...Object.values(this._childCustomViews[this.currentNode.uriPath]));
+            }
+            // @ts-ignore
+            this.views.sort((a, b) => this.compareStrings(a?.navigation?.title, b?.navigation?.title));
+            this.rightLoading$.off();
+        }, error => {
+            this._log.error(error);
+            this.rightNodes = [];
+            this.views = [];
+            this.rightLoading$.off();
+        });
+    }
+    resolveFilterCaseToViewNavigationItem(filter) {
+        const item = {
+            access: {},
+            navigation: {
+                icon: filter.immediateData.find(f => f.stringId === 'icon_name')?.value || this.filterIcon,
+                title: filter.immediateData.find(f => f.stringId === 'entry_name')?.value?.defaultValue || filter.title
+            },
+            routing: {
+                path: this.getFilterRoutingPath(filter)
+            },
+            id: filter.stringId,
+            resource: filter
+        };
+        const resolvedRoles = this.resolveAccessRoles(filter);
+        if (!!resolvedRoles)
+            item.access['role'] = resolvedRoles;
+        if (!this._accessService.canAccessView(item, item.routingPath))
+            return;
+        return item;
+    }
+    resolveAccessRoles(filter) {
+        const allowedRoles = filter.immediateData.find(f => f.stringId === 'allowed_roles')?.options;
+        if (!allowedRoles || Object.keys(allowedRoles).length === 0)
+            return undefined;
+        const roles = [];
+        Object.keys(allowedRoles).forEach(combined => {
+            const parts = combined.split(':');
+            roles.push({
+                processId: parts[1],
+                roleId: parts[0]
+            });
+        });
+        return roles;
+    }
+    getFilterRoutingPath(filterCase) {
+        const viewTaskId = filterCase.tasks.find(taskPair => taskPair.transition === FILTER_VIEW_TASK_TRANSITION_ID).task;
+        const url = this._dynamicRoutingService.route;
+        return `/${url}/${viewTaskId}`;
+    }
+    compareStrings(a, b) {
+        if (!a && !b)
+            return 0;
+        if (a < b)
+            return -1;
+        return a > b ? 1 : 0;
+    }
+    /**
+     * Function to check whether the back button should be displayed
+     * @returns boolean if the back button should be displayed
+     * */
+    isOnZeroLevel() {
+        return !!this.currentNode?.level ? this.currentNode.level == 0 : true;
+    }
+    isLeftNodesEmpty() {
+        return this.leftNodes === undefined || this.leftNodes.length === 0;
+    }
+    isRightNodesEmpty() {
+        return this.rightNodes === undefined || this.rightNodes.length === 0;
+    }
+    isViewsEmpty() {
+        return this.views === undefined || this.views.length === 0;
+    }
+    uriNodeTrackBy(index, node) {
+        return node.id;
+    }
+    viewsTrackBy(index, view) {
+        return view.id;
+    }
+    onResizeEvent(event) {
+        if (event.rectangle.width > RIGHT_DRAWER_MAX_WIDTH) {
+            this._configRightMenu.width = RIGHT_DRAWER_MAX_WIDTH;
+        }
+        else if (event.rectangle.width < RIGHT_DRAWER_DEFAULT_MIN_WIDTH) {
+            this._configRightMenu.width = RIGHT_DRAWER_DEFAULT_MIN_WIDTH;
+        }
+        else {
+            this._configRightMenu.width = event.rectangle.width;
+        }
+        // TODO implement saving drawer width to user preferences
+        // this.userPreferenceService._drawerWidthChanged$.next(this.width);
+        // this.contentWidth.next(this.width);
+    }
+}
+AbstractNavigationDoubleDrawerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractNavigationDoubleDrawerComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.BreakpointObserver }, { token: i3.LanguageService }, { token: i4.UserService }, { token: i5.AccessService }, { token: i6.LoggerService }, { token: i7.ConfigurationService }, { token: i8.UriService }, { token: i9.DynamicNavigationRouteProviderService }], target: i0.ɵɵFactoryTarget.Component });
+AbstractNavigationDoubleDrawerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AbstractNavigationDoubleDrawerComponent, selector: "ncc-abstract-navigation-double-drawer", inputs: { portalLeftMenu: "portalLeftMenu", portalRightMenu: "portalRightMenu", imageRouterLink: "imageRouterLink", imageAlt: "imageAlt", image: "image", profileRouterLink: "profileRouterLink", includeUser: "includeUser", includeLanguage: "includeLanguage", includeMoreMenu: "includeMoreMenu", allClosable: "allClosable", folderIcon: "folderIcon", openedFolderIcon: "openedFolderIcon", filterIcon: "filterIcon", foldersCategoryName: "foldersCategoryName", viewsCategoryName: "viewsCategoryName" }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractNavigationDoubleDrawerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ncc-abstract-navigation-double-drawer',
+                    template: '',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.BreakpointObserver }, { type: i3.LanguageService }, { type: i4.UserService }, { type: i5.AccessService }, { type: i6.LoggerService }, { type: i7.ConfigurationService }, { type: i8.UriService }, { type: i9.DynamicNavigationRouteProviderService }]; }, propDecorators: { portalLeftMenu: [{
+                type: Input
+            }], portalRightMenu: [{
+                type: Input
+            }], imageRouterLink: [{
+                type: Input
+            }], imageAlt: [{
+                type: Input
+            }], image: [{
+                type: Input
+            }], profileRouterLink: [{
+                type: Input
+            }], includeUser: [{
+                type: Input
+            }], includeLanguage: [{
+                type: Input
+            }], includeMoreMenu: [{
+                type: Input
+            }], allClosable: [{
+                type: Input
+            }], folderIcon: [{
+                type: Input
+            }], openedFolderIcon: [{
+                type: Input
+            }], filterIcon: [{
+                type: Input
+            }], foldersCategoryName: [{
+                type: Input
+            }], viewsCategoryName: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-navigation-double-drawer.js","sourceRoot":"","sources":["../../../../../../projects/netgrif-components-core/src/lib/navigation/navigation-double-drawer/abstract-navigation-double-drawer.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, Input, OnDestroy, OnInit, TemplateRef} from '@angular/core';\nimport {forkJoin, Observable, Subscription} from 'rxjs';\nimport {ActivatedRoute, Router} from '@angular/router';\nimport {BreakpointObserver, Breakpoints} from '@angular/cdk/layout';\nimport {LanguageService} from '../../translate/language.service';\nimport {UserService} from '../../user/services/user.service';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {ConfigurationService} from '../../configuration/configuration.service';\nimport {UriService} from '../service/uri.service';\nimport {UriNodeResource} from '../model/uri-resource';\nimport {Case} from '../../resources/interface/case';\nimport {\n    DynamicNavigationRouteProviderService\n} from '../../routing/dynamic-navigation-route-provider/dynamic-navigation-route-provider.service';\nimport {LoadingEmitter} from \"../../utility/loading-emitter\";\nimport {MatDrawerMode} from \"@angular/material/sidenav\";\nimport {ResizeEvent} from \"angular-resizable-element\";\nimport {User} from \"../../user/models/user\";\nimport {RoleAccess, View} from \"../../../commons/schema\";\nimport {NAE_ROUTING_CONFIGURATION_PATH} from \"../../routing/routing-builder/routing-builder.service\";\nimport {AccessService} from \"../../authorization/permission/access.service\";\n\nexport interface ConfigDoubleMenu {\n    mode: MatDrawerMode;\n    opened: boolean;\n    disableClose: boolean;\n    width: number;\n}\n\nexport interface ViewNavigationItem extends View {\n    id: string;\n    resource?: Case\n}\n\nexport const FILTER_IDENTIFIERS = [\n    \"preference_filter_item\"\n];\nexport const FILTER_VIEW_TASK_TRANSITION_ID = 'view';\n\nconst LEFT_DRAWER_DEFAULT_WIDTH = 60;\nconst RIGHT_DRAWER_DEFAULT_WIDTH = 240;\nconst RIGHT_DRAWER_DEFAULT_MIN_WIDTH = 180;\nconst RIGHT_DRAWER_MAX_WIDTH = 460;\n\n@Component({\n    selector: 'ncc-abstract-navigation-double-drawer',\n    template: '',\n})\nexport abstract class AbstractNavigationDoubleDrawerComponent implements OnInit, OnDestroy {\n\n    @Input() portalLeftMenu: TemplateRef<any>;\n    @Input() portalRightMenu: TemplateRef<any>;\n    @Input() imageRouterLink: string = \"/\";\n    @Input() imageAlt: string = \"Logo\";\n    @Input() image: string;\n    @Input() profileRouterLink: string = \"/profile\";\n    @Input() includeUser: boolean = true;\n    @Input() includeLanguage: boolean = true;\n    @Input() includeMoreMenu: boolean = true;\n    @Input() allClosable: boolean = true;\n    @Input() folderIcon: string = \"folder\";\n    @Input() openedFolderIcon: string = \"folder_open\";\n    @Input() filterIcon: string = \"filter_alt\";\n    @Input() foldersCategoryName: string = 'toolbar.menu.folders';\n    @Input() viewsCategoryName: string = 'toolbar.menu.views';\n\n    /**\n     * Array of folder nodes on left side\n     * */\n    leftNodes: Array<UriNodeResource>;\n\n    /**\n     * Array of folder nodes on right side\n     * */\n    rightNodes: Array<UriNodeResource>;\n\n    /**\n     * Processes that can be displayed under folders on right side menu\n     * */\n    views: Array<ViewNavigationItem>;\n\n    moreMenuItems: Array<ViewNavigationItem>;\n\n    protected _leftNodesSubscription: Subscription;\n    protected _rightNodesSubscription: Subscription;\n    protected _filtersSubscription: Subscription;\n    protected _breakpointSubscription: Subscription;\n    protected _rootSubscription: Subscription;\n    protected _currentNodeSubscription: Subscription;\n\n    /**\n     * Currently display uri\n     * Siblings of the node are on the left, children are on the right\n     */\n    currentNode: UriNodeResource\n\n    leftLoading$: LoadingEmitter;\n    rightLoading$: LoadingEmitter;\n\n    protected _configLeftMenu: ConfigDoubleMenu = {\n        mode: 'side',\n        opened: true,\n        disableClose: false,\n        width: LEFT_DRAWER_DEFAULT_WIDTH\n    };\n    protected _configRightMenu: ConfigDoubleMenu = {\n        mode: 'side',\n        opened: true,\n        disableClose: false,\n        width: RIGHT_DRAWER_DEFAULT_WIDTH\n    };\n\n    protected _childCustomViews: { [uri: string]: { [key: string]: ViewNavigationItem } }\n\n    protected constructor(protected _router: Router,\n                          protected _activatedRoute: ActivatedRoute,\n                          protected _breakpoint: BreakpointObserver,\n                          protected _languageService: LanguageService,\n                          protected _userService: UserService,\n                          protected _accessService: AccessService,\n                          protected _log: LoggerService,\n                          protected _config: ConfigurationService,\n                          protected _uriService: UriService,\n                          protected _dynamicRoutingService: DynamicNavigationRouteProviderService) {\n        this.leftNodes = new Array<UriNodeResource>();\n        this.rightNodes = new Array<UriNodeResource>();\n        this.views = new Array<ViewNavigationItem>();\n        this.leftLoading$ = new LoadingEmitter();\n        this.rightLoading$ = new LoadingEmitter();\n        this._childCustomViews = {};\n        this.moreMenuItems = new Array<ViewNavigationItem>();\n    }\n\n    ngOnInit(): void {\n        this._breakpointSubscription = this._breakpoint.observe([Breakpoints.HandsetLandscape]).subscribe(() => {\n            if (this._breakpoint.isMatched('(max-width: 959.99px)')) {\n                this.resolveLayout(false);\n            } else {\n                this.resolveLayout(true);\n            }\n        });\n        if (!this.currentNode) {\n            this.leftLoading$.on();\n            this.rightLoading$.on();\n        }\n        this._currentNodeSubscription = this._uriService.activeNode$.subscribe(node => {\n            this.currentNode = node;\n            if (!node) return;\n            if (this.leftLoading$.isActive || this.rightLoading$.isActive) {\n                this.leftLoading$.off();\n                this.rightLoading$.off();\n            }\n            if (this._uriService.isRoot(node)) {\n                this.leftNodes = [];\n                this.loadRightSide();\n                return;\n            }\n            if (!this.leftNodes.find(n => n.id === node.id)) {\n                this.loadLeftSide();\n            }\n            this.loadRightSide();\n        });\n\n        const viewConfigurationPath = this._activatedRoute.snapshot.data[NAE_ROUTING_CONFIGURATION_PATH];\n        if (!!viewConfigurationPath) {\n            const viewConfiguration = this._config.getViewByPath(viewConfigurationPath);\n            Object.entries(viewConfiguration.children).forEach(([key, childView]) => {\n                this.resolveUriForChildViews(viewConfigurationPath + '/' + key, childView);\n                this.resolveHiddenMenuItemFromChildViews(viewConfigurationPath + '/' + key, childView);\n            });\n        }\n    }\n\n    protected resolveUriForChildViews(configPath: string, childView: View): void {\n        if (!childView.processUri) return;\n        if (!this._accessService.canAccessView(childView, configPath)) return;\n        if (!this._childCustomViews[childView.processUri]) {\n            this._childCustomViews[childView.processUri] = {};\n        }\n        this._childCustomViews[childView.processUri][configPath] = {\n            id: configPath,\n            ...childView\n        }\n    }\n\n    protected resolveHiddenMenuItemFromChildViews(configPath: string, childView: View): void {\n        if (!childView.navigation) return;\n        if (!this._accessService.canAccessView(childView, configPath)) return;\n        // @ts-ignore\n        if (!!(childView?.navigation?.hidden)) {\n            this.moreMenuItems.push({\n                id: configPath,\n                ...childView\n            });\n        }\n    }\n\n    ngOnDestroy(): void {\n        this._breakpointSubscription?.unsubscribe();\n        this._leftNodesSubscription?.unsubscribe();\n        this._rightNodesSubscription?.unsubscribe();\n        this._filtersSubscription?.unsubscribe();\n        this._rootSubscription?.unsubscribe();\n        this._currentNodeSubscription?.unsubscribe();\n        this.leftLoading$.complete();\n        this.rightLoading$.complete();\n    }\n\n    get configLeftMenu() {\n        return this._configLeftMenu;\n    }\n\n    get configRightMenu() {\n        return this._configRightMenu;\n    }\n\n    toggleMenu() {\n        this.toggleRightMenu();\n        if (this.allClosable) {\n            this.toggleLeftMenu();\n        }\n    }\n\n    toggleLeftMenu() {\n        this._configLeftMenu.opened = !this._configLeftMenu.opened;\n    }\n\n    toggleRightMenu() {\n        this._configRightMenu.opened = !this._configRightMenu.opened;\n    }\n\n    protected resolveLayout(isLargeScreen: boolean): void {\n        this._configLeftMenu = isLargeScreen ? {\n            mode: 'side',\n            opened: true,\n            disableClose: true,\n            width: this._configLeftMenu.width\n        } : {\n            mode: 'over',\n            opened: false,\n            disableClose: false,\n            width: this._configLeftMenu.width\n        };\n        this._configRightMenu = isLargeScreen ? {\n            mode: 'side',\n            opened: true,\n            disableClose: true,\n            width: this._configRightMenu.width\n        } : {\n            mode: 'over',\n            opened: false,\n            disableClose: false,\n            width: this._configRightMenu.width\n        };\n    }\n\n    getLang() {\n        return this._languageService.getLanguage();\n    }\n\n    logout(): void {\n        this._userService.logout().subscribe(() => {\n            this._log.debug('User is logged out');\n            if (this._config.get().services && this._config.get().services.auth && this._config.get().services.auth.logoutRedirect) {\n                const redirectPath = this._config.get().services.auth.logoutRedirect;\n                this._log.info('Redirecting to ' + redirectPath);\n                this._router.navigate([redirectPath]);\n            }\n        });\n    }\n\n    get user(): User {\n        return this._userService.user;\n    }\n\n    get canGoBackLoading$(): Observable<boolean> {\n        return this._uriService.parentNodeLoading$;\n    }\n\n    /**\n     * On home click, the current level is set to 0, and current parent is\n     * set to root node.\n     * */\n    onHomeClick(): void {\n        this._uriService.reset();\n    }\n\n    /**\n     * On back click, the parent is set to parent of left nodes, that will solve\n     * the right side menu (elements that were in left side, after backward\n     * navigation will be on the right side).\n     * Current level is set to a lower number in order to set the left side menu.\n     * */\n    onBackClick(): void {\n        if (this._uriService.isRoot(this.currentNode)) return;\n        this._uriService.activeNode = this.currentNode.parent;\n    }\n\n    onNodeClick(node: UriNodeResource): void {\n        this._uriService.activeNode = node;\n    }\n\n    protected loadLeftSide() {\n        if (this._uriService.isRoot(this.currentNode)) {\n            this.leftNodes = [];\n            return;\n        }\n        this.leftLoading$.on();\n        this._leftNodesSubscription = this._uriService.getSiblingsOfNode(this.currentNode).subscribe(nodes => {\n            this.leftNodes = nodes instanceof Array ? nodes : [];\n            this.leftNodes.sort((a, b) => this.compareStrings(a.name, b.name));\n            this.leftLoading$.off();\n        }, error => {\n            this._log.error(error);\n            this.leftNodes = [];\n            this.leftLoading$.off();\n        });\n    }\n\n    protected loadRightSide() {\n        this.rightLoading$.on()\n        forkJoin({\n            folders: this._uriService.getChildNodes(this.currentNode),\n            filters: this._uriService.getCasesOfNode(this.currentNode, FILTER_IDENTIFIERS)\n        }).subscribe(result => {\n            this.rightNodes = result.folders instanceof Array ? result.folders : [];\n            this.rightNodes.sort((a, b) => this.compareStrings(a.name, b.name));\n            this.views = (result.filters instanceof Array ? result.filters : []).map(f => this.resolveFilterCaseToViewNavigationItem(f)).filter(i => !!i);\n            if (!!this._childCustomViews[this.currentNode.uriPath]) {\n                this.views.push(...Object.values(this._childCustomViews[this.currentNode.uriPath]))\n            }\n            // @ts-ignore\n            this.views.sort((a, b) => this.compareStrings(a?.navigation?.title, b?.navigation?.title));\n            this.rightLoading$.off();\n        }, error => {\n            this._log.error(error);\n            this.rightNodes = [];\n            this.views = [];\n            this.rightLoading$.off();\n        });\n    }\n\n    protected resolveFilterCaseToViewNavigationItem(filter: Case): ViewNavigationItem | undefined {\n        const item: ViewNavigationItem = {\n            access: {},\n            navigation: {\n                icon: filter.immediateData.find(f => f.stringId === 'icon_name')?.value || this.filterIcon,\n                title: filter.immediateData.find(f => f.stringId === 'entry_name')?.value?.defaultValue || filter.title\n            },\n            routing: {\n                path: this.getFilterRoutingPath(filter)\n            },\n            id: filter.stringId,\n            resource: filter\n        };\n        const resolvedRoles = this.resolveAccessRoles(filter);\n        if(!!resolvedRoles) item.access['role'] = resolvedRoles;\n        if (!this._accessService.canAccessView(item, item.routingPath)) return;\n        return item;\n    }\n\n    protected resolveAccessRoles(filter: Case): Array<RoleAccess> | undefined {\n        const allowedRoles = filter.immediateData.find(f => f.stringId === 'allowed_roles')?.options;\n        if (!allowedRoles || Object.keys(allowedRoles).length === 0) return undefined;\n        const roles = [];\n        Object.keys(allowedRoles).forEach(combined => {\n            const parts = combined.split(':');\n            roles.push({\n                processId: parts[1],\n                roleId: parts[0]\n            });\n        });\n        return roles;\n    }\n\n    protected getFilterRoutingPath(filterCase: Case) {\n        const viewTaskId = filterCase.tasks.find(taskPair => taskPair.transition === FILTER_VIEW_TASK_TRANSITION_ID).task;\n        const url = this._dynamicRoutingService.route;\n        return `/${url}/${viewTaskId}`;\n    }\n\n    protected compareStrings(a: string, b: string): number {\n        if (!a && !b) return 0;\n        if (a < b) return -1;\n        return a > b ? 1 : 0;\n    }\n\n    /**\n     * Function to check whether the back button should be displayed\n     * @returns boolean if the back button should be displayed\n     * */\n    isOnZeroLevel(): boolean {\n        return !!this.currentNode?.level ? this.currentNode.level == 0 : true;\n    }\n\n    isLeftNodesEmpty(): boolean {\n        return this.leftNodes === undefined || this.leftNodes.length === 0;\n    }\n\n    isRightNodesEmpty(): boolean {\n        return this.rightNodes === undefined || this.rightNodes.length === 0;\n    }\n\n    isViewsEmpty(): boolean {\n        return this.views === undefined || this.views.length === 0;\n    }\n\n    uriNodeTrackBy(index: number, node: UriNodeResource) {\n        return node.id;\n    }\n\n    viewsTrackBy(index: number, view: ViewNavigationItem) {\n        return view.id;\n    }\n\n    onResizeEvent(event: ResizeEvent): void {\n        if (event.rectangle.width > RIGHT_DRAWER_MAX_WIDTH) {\n            this._configRightMenu.width = RIGHT_DRAWER_MAX_WIDTH;\n        } else if (event.rectangle.width < RIGHT_DRAWER_DEFAULT_MIN_WIDTH) {\n            this._configRightMenu.width = RIGHT_DRAWER_DEFAULT_MIN_WIDTH;\n        } else {\n            this._configRightMenu.width = event.rectangle.width;\n        }\n        // TODO implement saving drawer width to user preferences\n        // this.userPreferenceService._drawerWidthChanged$.next(this.width);\n        // this.contentWidth.next(this.width);\n    }\n\n}\n"]}