@netgrif/components-core 6.0.1

package/esm2015/lib/navigation/navigation-tree/abstract-navigation-tree.component.js

@@ -0,0 +1,371 @@
+import { Input } from '@angular/core';
+import { NestedTreeControl } from '@angular/cdk/tree';
+import { NavigationEnd } from '@angular/router';
+import { MatTreeNestedDataSource } from '@angular/material/tree';
+import { forkJoin, of, ReplaySubject } from 'rxjs';
+import { AbstractNavigationResizableDrawerComponent } from '../navigation-drawer/abstract-navigation-resizable-drawer.component';
+import { concatMap, debounceTime, filter, map, take } from 'rxjs/operators';
+import { SimpleFilter } from '../../filter/models/simple-filter';
+import { hasContent } from '../../utility/pagination/page-has-content';
+import { GroupNavigationConstants } from '../model/group-navigation-constants';
+import { refreshTree } from '../../utility/refresh-tree';
+import { getField } from '../../utility/get-field';
+import { extractIconAndTitle, extractRoles } from '../utility/navigation-item-task-utility-methods';
+export class AbstractNavigationTreeComponent extends AbstractNavigationResizableDrawerComponent {
+    constructor(_config, _router, _log, _userService, _roleGuard, _authorityGuard, _groupGuard, _activeGroupService, _taskResourceService, _languageService, _navigationRouteProvider) {
+        super();
+        this._config = _config;
+        this._router = _router;
+        this._log = _log;
+        this._userService = _userService;
+        this._roleGuard = _roleGuard;
+        this._authorityGuard = _authorityGuard;
+        this._groupGuard = _groupGuard;
+        this._activeGroupService = _activeGroupService;
+        this._taskResourceService = _taskResourceService;
+        this._languageService = _languageService;
+        this._navigationRouteProvider = _navigationRouteProvider;
+        this._groupNavNodesCount = 0;
+        this.treeControl = new NestedTreeControl(node => node.children);
+        this.dataSource = new MatTreeNestedDataSource();
+        this._groupNavigationConfig = this._config.getConfigurationSubtree(['services', 'groupNavigation']);
+        this.dataSource.data = this.resolveNavigationNodes(_config.getConfigurationSubtree(['views']), '');
+        this.resolveLevels(this.dataSource.data);
+        this._reloadNavigation = new ReplaySubject(1);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        if (this.viewPath && this.parentUrl !== undefined && this.routerChange) {
+            this.resolveNavigationNodesWithOffsetRoot();
+        }
+        this._subscriptions = [
+            this._router.events.pipe(filter(event => event instanceof NavigationEnd && this.routerChange))
+                .subscribe(() => this._reloadNavigation.next()),
+            this._userService.user$.subscribe(() => this._reloadNavigation.next()),
+            this._activeGroupService.activeGroups$.subscribe(() => this._reloadNavigation.next())
+        ];
+        this._subscriptions.push(this._reloadNavigation.pipe(debounceTime(100)).subscribe(() => {
+            this.resolveNavigation();
+        }));
+    }
+    ngOnDestroy() {
+        for (const sub of this._subscriptions) {
+            if (!sub.closed) {
+                sub.unsubscribe();
+            }
+        }
+        this._reloadNavigation.complete();
+        if (this._subGroupResolution !== undefined) {
+            this._subGroupResolution.unsubscribe();
+        }
+        if (this._subLangChange !== undefined) {
+            this._subLangChange.unsubscribe();
+        }
+    }
+    hasChild(_, node) {
+        return !!node.children && node.children.length > 0;
+    }
+    resolveNavigation() {
+        let nodes;
+        if (this.viewPath && this.parentUrl !== undefined && this.routerChange) {
+            nodes = this.resolveNavigationNodesWithOffsetRoot();
+        }
+        else {
+            nodes = this.resolveNavigationNodes(this._config.getConfigurationSubtree(['views']), '');
+        }
+        this.dataSource.data = nodes;
+        this.resolveLevels(this.dataSource.data);
+    }
+    resolveNavigationNodesWithOffsetRoot() {
+        const view = this._config.getViewByPath(this.viewPath);
+        if (view && view.children) {
+            return this.resolveNavigationNodes(view.children, this.parentUrl);
+        }
+        return this.dataSource.data;
+    }
+    /**
+     * Converts the provided {@link Views} object into the corresponding navigation tree
+     * @param views navigation configuration
+     * @param parentUrl URL of the parent navigation tree node
+     * @param ancestorNodeContainer if the parent node has no navigation this attribute contains the
+     * closest ancestor that has navigation
+     * @protected
+     */
+    resolveNavigationNodes(views, parentUrl, ancestorNodeContainer) {
+        if (!views || Object.keys(views).length === 0) {
+            return null;
+        }
+        let groupNavigationGenerated = false;
+        const nodes = [];
+        Object.keys(views).forEach((viewKey) => {
+            const view = views[viewKey];
+            if (!groupNavigationGenerated && this.isGroupNavigationNode(view)) {
+                groupNavigationGenerated = true;
+                const insertPosition = (ancestorNodeContainer !== null && ancestorNodeContainer !== void 0 ? ancestorNodeContainer : nodes).length;
+                this._subLangChange = this._languageService.getLangChange$().subscribe(() => {
+                    this.loadGroupNavigationNodes(insertPosition, ancestorNodeContainer !== null && ancestorNodeContainer !== void 0 ? ancestorNodeContainer : nodes);
+                });
+                this.loadGroupNavigationNodes(insertPosition, ancestorNodeContainer !== null && ancestorNodeContainer !== void 0 ? ancestorNodeContainer : nodes);
+                return; // continue
+            }
+            if (!this.hasNavigation(view) && !this.hasSubRoutes(view)) {
+                return; // continue
+            }
+            const routeSegment = this.getNodeRouteSegment(view);
+            if (routeSegment === undefined) {
+                throw new Error('Route segment doesnt exist in view ' + parentUrl + '/' + viewKey + ' !');
+            }
+            if (!this.canAccessView(view, this.appendRouteSegment(parentUrl, routeSegment))) {
+                return; // continue
+            }
+            if (this.hasNavigation(view)) {
+                const node = this.buildNode(view, routeSegment, parentUrl);
+                if (this.hasSubRoutes(view)) {
+                    node.children = this.resolveNavigationNodes(view.children, node.url);
+                }
+                nodes.push(node);
+            }
+            else {
+                if (this.hasSubRoutes(view)) {
+                    nodes.push(...this.resolveNavigationNodes(view.children, this.appendRouteSegment(parentUrl, routeSegment), ancestorNodeContainer !== null && ancestorNodeContainer !== void 0 ? ancestorNodeContainer : nodes));
+                }
+            }
+        });
+        return nodes;
+    }
+    hasNavigation(route) {
+        if (!route.navigation) {
+            return false;
+        }
+        if (typeof route.navigation === 'boolean') {
+            return route.navigation;
+        }
+        if (typeof route.navigation === 'object') {
+            return Object.keys(route.navigation).length !== 0;
+        }
+    }
+    hasSubRoutes(route) {
+        if (!route.children) {
+            return false;
+        }
+        if (typeof route.children === 'object') {
+            return Object.keys(route.children).length !== 0;
+        }
+    }
+    buildNode(view, routeSegment, parentUrl) {
+        const node = {
+            name: null,
+            url: null
+        };
+        node.name = this.getNodeName(view, routeSegment);
+        node.icon = this.getNodeIcon(view);
+        node.url = this.appendRouteSegment(parentUrl, routeSegment);
+        node.translate = this.getNodeTranslateFlag(view);
+        return node;
+    }
+    getNodeName(view, routeSegment) {
+        if (view.navigation['title']) {
+            return view.navigation['title'];
+        }
+        const str = routeSegment.replace('_', ' ');
+        return str.charAt(0).toUpperCase() + str.substring(1);
+    }
+    getNodeIcon(view) {
+        return !view.navigation['icon'] ? undefined : view.navigation['icon'];
+    }
+    /**
+     * @param view configuration of some view, whose routeSegment we want to determine
+     * @returns the routeSegment for the provided view, or undefined if none is specified
+     */
+    getNodeRouteSegment(view) {
+        return !!view.routing && (typeof view.routing.path === 'string') ? view.routing.path : undefined;
+    }
+    getNodeTranslateFlag(view) {
+        var _a;
+        return (_a = view.navigation['translate']) !== null && _a !== void 0 ? _a : false;
+    }
+    /**
+     * Appends the route segment to the parent URL.
+     * @param parentUrl URL of the parent. Should not end with '/'
+     * @param routeSegment URL segment of the child
+     * @returns `parentUrl/routeSegment` if the `routeSegment` is truthy (not an empty string).
+     * Returns `parentUrl` if `routeSegment` is falsy (empty string).
+     */
+    appendRouteSegment(parentUrl, routeSegment) {
+        return routeSegment ? parentUrl + '/' + routeSegment : parentUrl;
+    }
+    resolveLevels(nodes, parentLevel) {
+        if (!nodes) {
+            return;
+        }
+        const currentLevel = parentLevel === null || parentLevel === undefined ? 0 : parentLevel + 1;
+        nodes.forEach(node => {
+            node.level = currentLevel;
+            if (node.children) {
+                this.resolveLevels(node.children, currentLevel);
+            }
+        });
+    }
+    /**
+     * @param view the view whose access permissions we want to check
+     * @param url URL to which the view maps. Is used only for error message generation
+     * @returns whether the user can access the provided view
+     */
+    canAccessView(view, url) {
+        if (!view.hasOwnProperty('access')) {
+            return true;
+        }
+        if (typeof view.access === 'string') {
+            if (view.access === 'public') {
+                return true;
+            }
+            if (view.access !== 'private') {
+                throw new Error(`Unknown access option '${view.access}'. Only 'public' or 'private' is allowed.`);
+            }
+            return !this._userService.user.isEmpty();
+        }
+        return !this._userService.user.isEmpty() // AuthGuard
+            && this.passesRoleGuard(view, url)
+            && this.passesAuthorityGuard(view)
+            && this.passesGroupGuard(view, url);
+    }
+    /**
+     * @param view the view whose access permissions we want to check
+     * @param url URL to which the view maps. Is used only for error message generation
+     * @returns whether the user passes the role guard condition for accessing the specified view
+     */
+    passesRoleGuard(view, url) {
+        return !view.access.hasOwnProperty('role') || this._roleGuard.canAccessView(view, url);
+    }
+    /**
+     * @param view the view whose access permissions we want to check
+     * @returns whether the user passes the authority guard condition for accessing the specified view
+     */
+    passesAuthorityGuard(view) {
+        return !view.access.hasOwnProperty('authority') || this._authorityGuard.canAccessView(view);
+    }
+    /**
+     * @param view the view whose access permissions we want to check
+     * @param url URL to which the view maps. Is used only for error message generation
+     * @returns whether the user passes the role guard condition for accessing the specified view
+     */
+    passesGroupGuard(view, url) {
+        return !view.access.hasOwnProperty('group') || this._groupGuard.canAccessView(view, url);
+    }
+    resolveChange() {
+        const view = this._config.getViewByPath(this.viewPath);
+        if (view && view.children) {
+            this.dataSource.data = this.resolveNavigationNodes(view.children, this.parentUrl);
+        }
+        this.resolveLevels(this.dataSource.data);
+    }
+    /**
+     * @returns `true` if the layout of the provided {@link View} node's name indicates it is a
+     * [group navigation outlet]{@link GroupNavigationConstants#GROUP_NAVIGATION_OUTLET}. Returns `false` otherwise.
+     */
+    isGroupNavigationNode(view) {
+        var _a;
+        return ((_a = view === null || view === void 0 ? void 0 : view.layout) === null || _a === void 0 ? void 0 : _a.name) === GroupNavigationConstants.GROUP_NAVIGATION_OUTLET;
+    }
+    /**
+     * Forces a reload of the group navigation nodes.
+     * @param insertPosition the position in the container where group navigation nodes reside
+     * @param nodeContainer the node container that contains the group navigation nodes
+     * (can be an inner node of the navigation tree or its root)
+     */
+    loadGroupNavigationNodes(insertPosition, nodeContainer) {
+        if (this._subGroupResolution !== undefined && !this._subGroupResolution.closed) {
+            this._subGroupResolution.unsubscribe();
+        }
+        this._subGroupResolution = this.generateGroupNavigationNodes().pipe(take(1)).subscribe(groupNavNodes => {
+            nodeContainer.splice(insertPosition, this._groupNavNodesCount, ...groupNavNodes);
+            this._groupNavNodesCount = groupNavNodes.length;
+            refreshTree(this.dataSource);
+        });
+    }
+    generateGroupNavigationNodes() {
+        return forkJoin(this._activeGroupService.activeGroups.map(groupCase => {
+            return this._taskResourceService.searchTask(SimpleFilter.fromTaskQuery({ case: { id: groupCase.stringId }, transitionId: GroupNavigationConstants.NAVIGATION_CONFIG_TRANSITION_ID })).pipe(map(taskPage => {
+                if (hasContent(taskPage)) {
+                    return this._taskResourceService.getData(taskPage.content[0].stringId);
+                }
+                else {
+                    this._log.error('Group navigation configuration task was not found.'
+                        + ' Navigation for this group cannot be constructed.');
+                    return of([]);
+                }
+            }), concatMap(o => o));
+        })).pipe(map((navigationConfigurations) => {
+            const result = [];
+            for (const navConfig of navigationConfigurations) {
+                result.push(...this.convertDatagroupsToNavEntries(navConfig));
+            }
+            return result;
+        }));
+    }
+    convertDatagroupsToNavEntries(navConfigDatagroups) {
+        const result = [];
+        const entryDataGroupIndices = [];
+        navConfigDatagroups.forEach((group, index) => {
+            if (group.fields.some(field => field.stringId === GroupNavigationConstants.NAVIGATION_ENTRY_MARKER_FIELD_ID_SUFFIX)) {
+                entryDataGroupIndices.push(index);
+            }
+        });
+        let navEntriesTaskRef;
+        navConfigDatagroups.some(group => {
+            const taskRef = getField(group.fields, GroupNavigationConstants.NAVIGATION_ENTRIES_TASK_REF_FIELD_ID);
+            if (taskRef !== undefined) {
+                navEntriesTaskRef = taskRef;
+            }
+            return !!taskRef;
+        });
+        if (!navEntriesTaskRef) {
+            throw new Error('The navigation configuration task contains no task ref with entries. Navigation cannot be constructed');
+        }
+        for (let order = 0; order < navEntriesTaskRef.value.length; order++) {
+            const index = entryDataGroupIndices[order];
+            const label = extractIconAndTitle(navConfigDatagroups.slice(index, index + GroupNavigationConstants.DATAGROUPS_PER_NAVIGATION_ENTRY));
+            const newNode = Object.assign({ url: '' }, label);
+            const url = this._navigationRouteProvider.route;
+            if (url === undefined) {
+                this._log.error(`No URL is configured in nae.json for configurable group navigation. Dynamic navigation entry was ignored`);
+                continue;
+            }
+            newNode.url = `/${url}/${navEntriesTaskRef.value[order]}`;
+            const allowedRoles = extractRoles(navConfigDatagroups.slice(index, index + GroupNavigationConstants.DATAGROUPS_PER_NAVIGATION_ENTRY), GroupNavigationConstants.NAVIGATION_ENTRY_ALLOWED_ROLES_FIELD_ID_SUFFIX);
+            const bannedRoles = extractRoles(navConfigDatagroups.slice(index, index + GroupNavigationConstants.DATAGROUPS_PER_NAVIGATION_ENTRY), GroupNavigationConstants.NAVIGATION_ENTRY_BANNED_ROLES_FIELD_ID_SUFFIX);
+            const splitAllowedRoles = this.extractRoleAndNetId(allowedRoles);
+            const splitBannedRoles = this.extractRoleAndNetId(bannedRoles);
+            if ((splitAllowedRoles.length === 0
+                || splitAllowedRoles.some(idPair => this._userService.hasRoleByIdentifier(idPair[0], idPair[1])))
+                && !splitBannedRoles.some(idPair => this._userService.hasRoleByIdentifier(idPair[0], idPair[1]))) {
+                result.push(newNode);
+            }
+        }
+        return result;
+    }
+    /**
+     * Splits the provided strings on the ':' character and returns an array of the resulting splits.
+     *
+     * If any of the input strings split into fewer or more than 2 strings an error is thrown.
+     *
+     * @param joined a list of strings in the form `<role identifier>:<net identifier>`
+     */
+    extractRoleAndNetId(joined) {
+        const split = [];
+        for (const pair of joined) {
+            const splitPair = pair.split(':');
+            if (splitPair.length !== 2) {
+                throw new Error(`The role-net pair '${pair}' has invalid format! Cannot extract role and net identifiers.`);
+            }
+            split.push(splitPair);
+        }
+        return split;
+    }
+}
+AbstractNavigationTreeComponent.propDecorators = {
+    viewPath: [{ type: Input }],
+    parentUrl: [{ type: Input }],
+    routerChange: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-navigation-tree.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/navigation/navigation-tree/abstract-navigation-tree.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Input, OnDestroy, OnInit} from '@angular/core';\nimport {NestedTreeControl} from '@angular/cdk/tree';\nimport {ConfigurationService} from '../../configuration/configuration.service';\nimport {Services, View, Views} from '../../../commons/schema';\nimport {NavigationEnd, Router} from '@angular/router';\nimport {MatTreeNestedDataSource} from '@angular/material/tree';\nimport {forkJoin, Observable, of, ReplaySubject, Subscription} from 'rxjs';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {UserService} from '../../user/services/user.service';\nimport {RoleGuardService} from '../../authorization/role/role-guard.service';\nimport {AuthorityGuardService} from '../../authorization/authority/authority-guard.service';\nimport {GroupGuardService} from '../../authorization/group/group-guard.service';\nimport {AbstractNavigationResizableDrawerComponent} from '../navigation-drawer/abstract-navigation-resizable-drawer.component';\nimport {ActiveGroupService} from '../../groups/services/active-group.service';\nimport {concatMap, debounceTime, filter, map, take} from 'rxjs/operators';\nimport {TaskResourceService} from '../../resources/engine-endpoint/task-resource.service';\nimport {SimpleFilter} from '../../filter/models/simple-filter';\nimport {hasContent} from '../../utility/pagination/page-has-content';\nimport {DataGroup} from '../../resources/interface/data-groups';\nimport {GroupNavigationConstants} from '../model/group-navigation-constants';\nimport {refreshTree} from '../../utility/refresh-tree';\nimport {getField} from '../../utility/get-field';\nimport {extractIconAndTitle, extractRoles} from '../utility/navigation-item-task-utility-methods';\nimport {LanguageService} from '../../translate/language.service';\nimport {\n    DynamicNavigationRouteProviderService\n} from '../../routing/dynamic-navigation-route-provider/dynamic-navigation-route-provider.service';\n\nexport interface NavigationNode {\n    name: string;\n    icon?: string;\n    url: string;\n    children?: Array<NavigationNode>;\n    level?: number;\n    translate?: boolean;\n}\n\nexport abstract class AbstractNavigationTreeComponent extends AbstractNavigationResizableDrawerComponent implements OnInit, OnDestroy {\n\n    @Input() public viewPath: string;\n    @Input() public parentUrl: string;\n    @Input() public routerChange: boolean;\n\n    protected _reloadNavigation: ReplaySubject<void>;\n    protected _groupNavigationConfig: Services['groupNavigation'];\n\n    private _subscriptions: Array<Subscription>;\n    private _subGroupResolution: Subscription;\n    private _subLangChange: Subscription;\n    private _groupNavNodesCount = 0;\n\n    treeControl: NestedTreeControl<NavigationNode>;\n    dataSource: MatTreeNestedDataSource<NavigationNode>;\n\n    protected constructor(protected _config: ConfigurationService,\n                          protected _router: Router,\n                          protected _log: LoggerService,\n                          protected _userService: UserService,\n                          protected _roleGuard: RoleGuardService,\n                          protected _authorityGuard: AuthorityGuardService,\n                          protected _groupGuard: GroupGuardService,\n                          protected _activeGroupService: ActiveGroupService,\n                          protected _taskResourceService: TaskResourceService,\n                          protected _languageService: LanguageService,\n                          protected _navigationRouteProvider: DynamicNavigationRouteProviderService) {\n        super();\n        this.treeControl = new NestedTreeControl<NavigationNode>(node => node.children);\n        this.dataSource = new MatTreeNestedDataSource<NavigationNode>();\n        this._groupNavigationConfig = this._config.getConfigurationSubtree(['services', 'groupNavigation']);\n        this.dataSource.data = this.resolveNavigationNodes(_config.getConfigurationSubtree(['views']), '');\n        this.resolveLevels(this.dataSource.data);\n        this._reloadNavigation = new ReplaySubject<void>(1);\n    }\n\n    ngOnInit(): void {\n        super.ngOnInit();\n        if (this.viewPath && this.parentUrl !== undefined && this.routerChange) {\n            this.resolveNavigationNodesWithOffsetRoot();\n        }\n\n        this._subscriptions = [\n            this._router.events.pipe(filter(event => event instanceof NavigationEnd && this.routerChange))\n                .subscribe(() => this._reloadNavigation.next()),\n            this._userService.user$.subscribe(() => this._reloadNavigation.next()),\n            this._activeGroupService.activeGroups$.subscribe(() => this._reloadNavigation.next())\n        ];\n\n        this._subscriptions.push(\n            this._reloadNavigation.pipe(debounceTime(100)).subscribe(() => {\n                this.resolveNavigation();\n            })\n        );\n    }\n\n    ngOnDestroy(): void {\n        for (const sub of this._subscriptions) {\n            if (!sub.closed) {\n                sub.unsubscribe();\n            }\n        }\n        this._reloadNavigation.complete();\n        if (this._subGroupResolution !== undefined) {\n            this._subGroupResolution.unsubscribe();\n        }\n        if (this._subLangChange !== undefined) {\n            this._subLangChange.unsubscribe();\n        }\n    }\n\n    public hasChild(_: number, node: NavigationNode): boolean {\n        return !!node.children && node.children.length > 0;\n    }\n\n    protected resolveNavigation(): void {\n        let nodes;\n        if (this.viewPath && this.parentUrl !== undefined && this.routerChange) {\n            nodes = this.resolveNavigationNodesWithOffsetRoot();\n        } else {\n            nodes = this.resolveNavigationNodes(this._config.getConfigurationSubtree(['views']), '');\n        }\n        this.dataSource.data = nodes;\n        this.resolveLevels(this.dataSource.data);\n    }\n\n    protected resolveNavigationNodesWithOffsetRoot(): Array<NavigationNode> {\n        const view = this._config.getViewByPath(this.viewPath);\n        if (view && view.children) {\n            return this.resolveNavigationNodes(view.children, this.parentUrl);\n        }\n        return this.dataSource.data;\n    }\n\n    /**\n     * Converts the provided {@link Views} object into the corresponding navigation tree\n     * @param views navigation configuration\n     * @param parentUrl URL of the parent navigation tree node\n     * @param ancestorNodeContainer if the parent node has no navigation this attribute contains the\n     * closest ancestor that has navigation\n     * @protected\n     */\n    protected resolveNavigationNodes(\n        views: Views,\n        parentUrl: string,\n        ancestorNodeContainer?: Array<NavigationNode>\n    ): Array<NavigationNode> {\n        if (!views || Object.keys(views).length === 0) {\n            return null;\n        }\n\n        let groupNavigationGenerated = false;\n        const nodes: Array<NavigationNode> = [];\n        Object.keys(views).forEach((viewKey: string) => {\n            const view = views[viewKey];\n\n            if (!groupNavigationGenerated && this.isGroupNavigationNode(view)) {\n                groupNavigationGenerated = true;\n                const insertPosition = (ancestorNodeContainer ?? nodes).length;\n\n                this._subLangChange = this._languageService.getLangChange$().subscribe(() => {\n                    this.loadGroupNavigationNodes(insertPosition, ancestorNodeContainer ?? nodes);\n                });\n                this.loadGroupNavigationNodes(insertPosition, ancestorNodeContainer ?? nodes);\n\n                return; // continue\n            }\n\n            if (!this.hasNavigation(view) && !this.hasSubRoutes(view)) {\n                return; // continue\n            }\n            const routeSegment = this.getNodeRouteSegment(view);\n\n            if (routeSegment === undefined) {\n                throw new Error('Route segment doesnt exist in view ' + parentUrl + '/' + viewKey + ' !');\n            }\n\n            if (!this.canAccessView(view, this.appendRouteSegment(parentUrl, routeSegment))) {\n                return; // continue\n            }\n\n            if (this.hasNavigation(view)) {\n                const node: NavigationNode = this.buildNode(view, routeSegment, parentUrl);\n                if (this.hasSubRoutes(view)) {\n                    node.children = this.resolveNavigationNodes(view.children, node.url);\n                }\n                nodes.push(node);\n            } else {\n                if (this.hasSubRoutes(view)) {\n                    nodes.push(...this.resolveNavigationNodes(\n                        view.children,\n                        this.appendRouteSegment(parentUrl, routeSegment), ancestorNodeContainer ?? nodes)\n                    );\n                }\n            }\n        });\n        return nodes;\n    }\n\n    protected hasNavigation(route: View): boolean {\n        if (!route.navigation) {\n            return false;\n        }\n        if (typeof route.navigation === 'boolean') {\n            return route.navigation;\n        }\n        if (typeof route.navigation === 'object') {\n            return Object.keys(route.navigation).length !== 0;\n        }\n    }\n\n    protected hasSubRoutes(route: View): boolean {\n        if (!route.children) {\n            return false;\n        }\n        if (typeof route.children === 'object') {\n            return Object.keys(route.children).length !== 0;\n        }\n    }\n\n    protected buildNode(view: View, routeSegment: string, parentUrl: string): NavigationNode {\n        const node: NavigationNode = {\n            name: null,\n            url: null\n        };\n        node.name = this.getNodeName(view, routeSegment);\n        node.icon = this.getNodeIcon(view);\n        node.url = this.appendRouteSegment(parentUrl, routeSegment);\n        node.translate = this.getNodeTranslateFlag(view);\n        return node;\n    }\n\n    protected getNodeName(view: View, routeSegment: string): string {\n        if (view.navigation['title']) {\n            return view.navigation['title'];\n        }\n        const str = routeSegment.replace('_', ' ');\n        return str.charAt(0).toUpperCase() + str.substring(1);\n    }\n\n    protected getNodeIcon(view: View): string {\n        return !view.navigation['icon'] ? undefined : view.navigation['icon'];\n    }\n\n    /**\n     * @param view configuration of some view, whose routeSegment we want to determine\n     * @returns the routeSegment for the provided view, or undefined if none is specified\n     */\n    protected getNodeRouteSegment(view: View): string {\n        return !!view.routing && (typeof view.routing.path === 'string') ? view.routing.path : undefined;\n    }\n\n    protected getNodeTranslateFlag(view: View): boolean {\n        return view.navigation['translate'] ?? false;\n    }\n\n    /**\n     * Appends the route segment to the parent URL.\n     * @param parentUrl URL of the parent. Should not end with '/'\n     * @param routeSegment URL segment of the child\n     * @returns `parentUrl/routeSegment` if the `routeSegment` is truthy (not an empty string).\n     * Returns `parentUrl` if `routeSegment` is falsy (empty string).\n     */\n    protected appendRouteSegment(parentUrl: string, routeSegment: string): string {\n        return routeSegment ? parentUrl + '/' + routeSegment : parentUrl;\n    }\n\n    protected resolveLevels(nodes: Array<NavigationNode>, parentLevel?: number): void {\n        if (!nodes) {\n            return;\n        }\n        const currentLevel = parentLevel === null || parentLevel === undefined ? 0 : parentLevel + 1;\n        nodes.forEach(node => {\n            node.level = currentLevel;\n            if (node.children) {\n                this.resolveLevels(node.children, currentLevel);\n            }\n        });\n    }\n\n    /**\n     * @param view the view whose access permissions we want to check\n     * @param url URL to which the view maps. Is used only for error message generation\n     * @returns whether the user can access the provided view\n     */\n    protected canAccessView(view: View, url: string): boolean {\n        if (!view.hasOwnProperty('access')) {\n            return true;\n        }\n\n        if (typeof view.access === 'string') {\n            if (view.access === 'public') {\n                return true;\n            }\n            if (view.access !== 'private') {\n                throw new Error(`Unknown access option '${view.access}'. Only 'public' or 'private' is allowed.`);\n            }\n            return !this._userService.user.isEmpty();\n        }\n\n        return !this._userService.user.isEmpty() // AuthGuard\n                && this.passesRoleGuard(view, url)\n                && this.passesAuthorityGuard(view)\n                && this.passesGroupGuard(view, url);\n    }\n\n    /**\n     * @param view the view whose access permissions we want to check\n     * @param url URL to which the view maps. Is used only for error message generation\n     * @returns whether the user passes the role guard condition for accessing the specified view\n     */\n    protected passesRoleGuard(view: View, url: string): boolean {\n        return !view.access.hasOwnProperty('role') || this._roleGuard.canAccessView(view, url);\n    }\n\n    /**\n     * @param view the view whose access permissions we want to check\n     * @returns whether the user passes the authority guard condition for accessing the specified view\n     */\n    protected passesAuthorityGuard(view: View): boolean {\n        return !view.access.hasOwnProperty('authority') || this._authorityGuard.canAccessView(view);\n    }\n\n    /**\n     * @param view the view whose access permissions we want to check\n     * @param url URL to which the view maps. Is used only for error message generation\n     * @returns whether the user passes the role guard condition for accessing the specified view\n     */\n    protected passesGroupGuard(view: View, url: string): boolean {\n        return !view.access.hasOwnProperty('group') || this._groupGuard.canAccessView(view, url);\n    }\n\n    protected resolveChange() {\n        const view = this._config.getViewByPath(this.viewPath);\n        if (view && view.children) {\n            this.dataSource.data = this.resolveNavigationNodes(view.children, this.parentUrl);\n        }\n        this.resolveLevels(this.dataSource.data);\n    }\n\n    /**\n     * @returns `true` if the layout of the provided {@link View} node's name indicates it is a\n     * [group navigation outlet]{@link GroupNavigationConstants#GROUP_NAVIGATION_OUTLET}. Returns `false` otherwise.\n     */\n    protected isGroupNavigationNode(view: View): boolean {\n        return view?.layout?.name === GroupNavigationConstants.GROUP_NAVIGATION_OUTLET;\n    }\n\n    /**\n     * Forces a reload of the group navigation nodes.\n     * @param insertPosition the position in the container where group navigation nodes reside\n     * @param nodeContainer the node container that contains the group navigation nodes\n     * (can be an inner node of the navigation tree or its root)\n     */\n    protected loadGroupNavigationNodes(insertPosition: number, nodeContainer: Array<NavigationNode>): void {\n        if (this._subGroupResolution !== undefined && !this._subGroupResolution.closed) {\n            this._subGroupResolution.unsubscribe();\n        }\n\n        this._subGroupResolution = this.generateGroupNavigationNodes().pipe(take(1)).subscribe(groupNavNodes => {\n            nodeContainer.splice(insertPosition, this._groupNavNodesCount, ...groupNavNodes);\n            this._groupNavNodesCount = groupNavNodes.length;\n            refreshTree(this.dataSource);\n        });\n    }\n\n    protected generateGroupNavigationNodes(): Observable<Array<NavigationNode>> {\n        return forkJoin(this._activeGroupService.activeGroups.map(groupCase => {\n            return this._taskResourceService.searchTask(SimpleFilter.fromTaskQuery(\n                {case: {id: groupCase.stringId}, transitionId: GroupNavigationConstants.NAVIGATION_CONFIG_TRANSITION_ID as string}\n            )).pipe(\n                map(taskPage => {\n                    if (hasContent(taskPage)) {\n                        return this._taskResourceService.getData(taskPage.content[0].stringId);\n                    } else {\n                        this._log.error('Group navigation configuration task was not found.'\n                            + ' Navigation for this group cannot be constructed.');\n                        return of([]);\n                    }\n                }),\n                concatMap(o => o)\n            );\n        })).pipe(\n            map((navigationConfigurations: Array<Array<DataGroup>>) => {\n                const result = [];\n                for (const navConfig of navigationConfigurations) {\n                    result.push(...this.convertDatagroupsToNavEntries(navConfig));\n                }\n                return result;\n            })\n        );\n    }\n\n    protected convertDatagroupsToNavEntries(navConfigDatagroups: Array<DataGroup>): Array<NavigationNode> {\n        const result = [];\n        const entryDataGroupIndices = [];\n        navConfigDatagroups.forEach(\n            (group, index) => {\n                if (group.fields.some(\n                    field => field.stringId === GroupNavigationConstants.NAVIGATION_ENTRY_MARKER_FIELD_ID_SUFFIX\n                )) {\n                    entryDataGroupIndices.push(index);\n                }\n            }\n        );\n\n        let navEntriesTaskRef;\n        navConfigDatagroups.some(group => {\n            const taskRef = getField(group.fields, GroupNavigationConstants.NAVIGATION_ENTRIES_TASK_REF_FIELD_ID);\n            if (taskRef !== undefined) {\n                navEntriesTaskRef = taskRef;\n            }\n            return !!taskRef;\n        });\n\n        if (!navEntriesTaskRef) {\n            throw new Error('The navigation configuration task contains no task ref with entries. Navigation cannot be constructed');\n        }\n\n        for (let order = 0; order < navEntriesTaskRef.value.length; order ++) {\n            const index = entryDataGroupIndices[order];\n            const label = extractIconAndTitle(navConfigDatagroups.slice(index,\n                index + GroupNavigationConstants.DATAGROUPS_PER_NAVIGATION_ENTRY));\n            const newNode: NavigationNode = {url: '', ...label};\n\n            const url = this._navigationRouteProvider.route;\n            if (url === undefined) {\n                this._log.error(`No URL is configured in nae.json for configurable group navigation. Dynamic navigation entry was ignored`);\n                continue;\n            }\n            newNode.url = `/${url}/${navEntriesTaskRef.value[order]}`;\n            const allowedRoles = extractRoles(navConfigDatagroups.slice(index,\n                index + GroupNavigationConstants.DATAGROUPS_PER_NAVIGATION_ENTRY),\n                GroupNavigationConstants.NAVIGATION_ENTRY_ALLOWED_ROLES_FIELD_ID_SUFFIX);\n\n            const bannedRoles = extractRoles(navConfigDatagroups.slice(index,\n                index + GroupNavigationConstants.DATAGROUPS_PER_NAVIGATION_ENTRY),\n                GroupNavigationConstants.NAVIGATION_ENTRY_BANNED_ROLES_FIELD_ID_SUFFIX);\n\n            const splitAllowedRoles = this.extractRoleAndNetId(allowedRoles);\n            const splitBannedRoles = this.extractRoleAndNetId(bannedRoles);\n\n            if ((splitAllowedRoles.length === 0\n                    || splitAllowedRoles.some(idPair => this._userService.hasRoleByIdentifier(idPair[0], idPair[1])))\n                && !splitBannedRoles.some(idPair => this._userService.hasRoleByIdentifier(idPair[0], idPair[1]))) {\n                result.push(newNode);\n            }\n        }\n        return result;\n    }\n\n    /**\n     * Splits the provided strings on the ':' character and returns an array of the resulting splits.\n     *\n     * If any of the input strings split into fewer or more than 2 strings an error is thrown.\n     *\n     * @param joined a list of strings in the form `<role identifier>:<net identifier>`\n     */\n    protected extractRoleAndNetId(joined: Array<string>): Array<Array<string>> {\n        const split = [];\n        for (const pair of joined) {\n            const splitPair = pair.split(':');\n            if (splitPair.length !== 2) {\n                throw new Error(`The role-net pair '${pair}' has invalid format! Cannot extract role and net identifiers.`);\n            }\n            split.push(splitPair);\n        }\n        return split;\n    }\n}\n"]}

package/esm2015/lib/navigation/public-api.js

@@ -0,0 +1,19 @@
+/* APIS */
+export * from './quick-panel/public-api';
+/* COMPONENTS */
+export * from './navigation-tree/abstract-navigation-tree.component';
+export * from './navigation-drawer/abstract-navigation-drawer.component';
+export * from './navigation-rail/abstract-navigation-rail.component';
+export * from './group-navigation-component-resolver/abstract-group-navigation-component-resolver.component';
+/* SERVICES */
+export * from './group-navigation-component-resolver/group-navigation-component-resolver.service';
+export * from './utility/filter-extraction.service';
+/* MODELS */
+export * from './model/group-navigation-constants';
+export * from './model/group-navigation-component-resolver-component-injection-token';
+export * from './model/filter-case-injection-token';
+export * from './model/group-navigation-item-label';
+/* UTILITY METHODS */
+export * from './utility/navigation-item-task-utility-methods';
+export * from './group-navigation-component-resolver/group-navigation-view-id-segment-factory';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/navigation/quick-panel/components/abstract-quick-panel.component.js

@@ -0,0 +1,25 @@
+import { Input } from '@angular/core';
+import { AbstractNavigationResizableDrawerComponent } from '../../navigation-drawer/abstract-navigation-resizable-drawer.component';
+export class AbstractQuickPanelComponent extends AbstractNavigationResizableDrawerComponent {
+    constructor(_select, _paperView) {
+        super();
+        this._select = _select;
+        this._paperView = _paperView;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+    }
+    getLang() {
+        return this._select.getLanguage();
+    }
+    setPaperView() {
+        this._paperView.paperView = !this._paperView.paperView;
+    }
+    isPaperView() {
+        return this._paperView.paperView;
+    }
+}
+AbstractQuickPanelComponent.propDecorators = {
+    items: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtcXVpY2stcGFuZWwuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL25hdmlnYXRpb24vcXVpY2stcGFuZWwvY29tcG9uZW50cy9hYnN0cmFjdC1xdWljay1wYW5lbC5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLEtBQUssRUFBUyxNQUFNLGVBQWUsQ0FBQztBQUc1QyxPQUFPLEVBQUMsMENBQTBDLEVBQUMsTUFBTSx3RUFBd0UsQ0FBQztBQUlsSSxNQUFNLE9BQWdCLDJCQUE0QixTQUFRLDBDQUEwQztJQUloRyxZQUFzQixPQUF3QixFQUFZLFVBQTRCO1FBQ2xGLEtBQUssRUFBRSxDQUFDO1FBRFUsWUFBTyxHQUFQLE9BQU8sQ0FBaUI7UUFBWSxlQUFVLEdBQVYsVUFBVSxDQUFrQjtJQUV0RixDQUFDO0lBRUQsUUFBUTtRQUNKLEtBQUssQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUNyQixDQUFDO0lBRUQsT0FBTztRQUNILE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUN0QyxDQUFDO0lBRUQsWUFBWTtRQUNSLElBQUksQ0FBQyxVQUFVLENBQUMsU0FBUyxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUM7SUFDM0QsQ0FBQztJQUVELFdBQVc7UUFDUCxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDO0lBQ3JDLENBQUM7OztvQkFwQkEsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5wdXQsIE9uSW5pdH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0xhbmd1YWdlU2VydmljZX0gZnJvbSAnLi4vLi4vLi4vdHJhbnNsYXRlL2xhbmd1YWdlLnNlcnZpY2UnO1xuaW1wb3J0IHtQYXBlclZpZXdTZXJ2aWNlfSBmcm9tICcuL3BhcGVyLXZpZXcuc2VydmljZSc7XG5pbXBvcnQge0Fic3RyYWN0TmF2aWdhdGlvblJlc2l6YWJsZURyYXdlckNvbXBvbmVudH0gZnJvbSAnLi4vLi4vbmF2aWdhdGlvbi1kcmF3ZXIvYWJzdHJhY3QtbmF2aWdhdGlvbi1yZXNpemFibGUtZHJhd2VyLmNvbXBvbmVudCc7XG5cbmV4cG9ydCB0eXBlIFF1aWNrUGFuZWxJdGVtID0gJ2xhbmd1YWdlJyB8ICdzZXR0aW5ncycgfCAnbG9nb3V0JztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFic3RyYWN0UXVpY2tQYW5lbENvbXBvbmVudCBleHRlbmRzIEFic3RyYWN0TmF2aWdhdGlvblJlc2l6YWJsZURyYXdlckNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG5cbiAgICBASW5wdXQoKSBwdWJsaWMgaXRlbXM6IEFycmF5PFF1aWNrUGFuZWxJdGVtPjtcblxuICAgIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBfc2VsZWN0OiBMYW5ndWFnZVNlcnZpY2UsIHByb3RlY3RlZCBfcGFwZXJWaWV3OiBQYXBlclZpZXdTZXJ2aWNlKSB7XG4gICAgICAgIHN1cGVyKCk7XG4gICAgfVxuXG4gICAgbmdPbkluaXQoKTogdm9pZCB7XG4gICAgICAgIHN1cGVyLm5nT25Jbml0KCk7XG4gICAgfVxuXG4gICAgZ2V0TGFuZygpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gdGhpcy5fc2VsZWN0LmdldExhbmd1YWdlKCk7XG4gICAgfVxuXG4gICAgc2V0UGFwZXJWaWV3KCkge1xuICAgICAgICB0aGlzLl9wYXBlclZpZXcucGFwZXJWaWV3ID0gIXRoaXMuX3BhcGVyVmlldy5wYXBlclZpZXc7XG4gICAgfVxuXG4gICAgaXNQYXBlclZpZXcoKSB7XG4gICAgICAgIHJldHVybiB0aGlzLl9wYXBlclZpZXcucGFwZXJWaWV3O1xuICAgIH1cbn1cbiJdfQ==

package/esm2015/lib/navigation/quick-panel/components/internal-link/abstract-internal-link.component.js

@@ -0,0 +1,12 @@
+import { Input } from '@angular/core';
+export class AbstractInternalLinkComponent {
+    constructor() {
+    }
+    ngOnInit() {
+    }
+}
+AbstractInternalLinkComponent.propDecorators = {
+    link: [{ type: Input }],
+    icon: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtaW50ZXJuYWwtbGluay5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvbmF2aWdhdGlvbi9xdWljay1wYW5lbC9jb21wb25lbnRzL2ludGVybmFsLWxpbmsvYWJzdHJhY3QtaW50ZXJuYWwtbGluay5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLEtBQUssRUFBUyxNQUFNLGVBQWUsQ0FBQztBQUU1QyxNQUFNLE9BQWdCLDZCQUE2QjtJQUsvQztJQUNBLENBQUM7SUFFRCxRQUFRO0lBQ1IsQ0FBQzs7O21CQVBBLEtBQUs7bUJBQ0wsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5wdXQsIE9uSW5pdH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdEludGVybmFsTGlua0NvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG5cbiAgICBASW5wdXQoKSBwdWJsaWMgbGluazogc3RyaW5nO1xuICAgIEBJbnB1dCgpIHB1YmxpYyBpY29uOiBzdHJpbmc7XG5cbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICB9XG5cbiAgICBuZ09uSW5pdCgpOiB2b2lkIHtcbiAgICB9XG5cbn1cbiJdfQ==

package/esm2015/lib/navigation/quick-panel/components/language-selector/abstract-language-selector.component.js

@@ -0,0 +1,52 @@
+import { Input } from '@angular/core';
+export class AbstractLanguageSelectorComponent {
+    constructor(_select) {
+        this._select = _select;
+        /**
+         * ISO 639-1
+         */
+        this.langMenuItems = [
+            {
+                key: 'sk-SK',
+                value: 'sk'
+            },
+            {
+                key: 'de-DE',
+                value: 'de'
+            },
+            {
+                key: 'en-US',
+                value: 'en',
+                flag: 'gb'
+            }
+        ];
+        this._flagOverrides = new Map();
+        this.langMenuItems.forEach(option => {
+            if (option.flag !== undefined) {
+                this._flagOverrides.set(option.key, option.flag);
+            }
+        });
+    }
+    ngOnInit() {
+    }
+    get flagCountryCode() {
+        return this.flagCode(this.language);
+    }
+    flagCode(languageCode) {
+        if (this._flagOverrides.has(languageCode)) {
+            return this._flagOverrides.get(languageCode);
+        }
+        if (languageCode.includes('-')) {
+            return languageCode.split('-')[1].toLowerCase();
+        }
+        return languageCode.toLowerCase();
+    }
+    setLang(lang) {
+        this.language = lang;
+        this._select.setLanguage(lang, true);
+    }
+}
+AbstractLanguageSelectorComponent.propDecorators = {
+    language: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/navigation/quick-panel/components/logout-shortcut/abstract-logout-shortcut.component.js

@@ -0,0 +1,21 @@
+export class AbstractLogoutShortcutComponent {
+    constructor(_user, _log, _config, _router) {
+        this._user = _user;
+        this._log = _log;
+        this._config = _config;
+        this._router = _router;
+    }
+    ngOnInit() {
+    }
+    logout() {
+        this._user.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]);
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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