@netgrif/components-core 6.0.1

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

@@ -0,0 +1,415 @@
+import { __assign, __extends, __read, __spread, __values } from "tslib";
+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';
+var AbstractNavigationTreeComponent = /** @class */ (function (_super) {
+    __extends(AbstractNavigationTreeComponent, _super);
+    function AbstractNavigationTreeComponent(_config, _router, _log, _userService, _roleGuard, _authorityGuard, _groupGuard, _activeGroupService, _taskResourceService, _languageService, _navigationRouteProvider) {
+        var _this = _super.call(this) || this;
+        _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(function (node) { return 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);
+        return _this;
+    }
+    AbstractNavigationTreeComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        _super.prototype.ngOnInit.call(this);
+        if (this.viewPath && this.parentUrl !== undefined && this.routerChange) {
+            this.resolveNavigationNodesWithOffsetRoot();
+        }
+        this._subscriptions = [
+            this._router.events.pipe(filter(function (event) { return event instanceof NavigationEnd && _this.routerChange; }))
+                .subscribe(function () { return _this._reloadNavigation.next(); }),
+            this._userService.user$.subscribe(function () { return _this._reloadNavigation.next(); }),
+            this._activeGroupService.activeGroups$.subscribe(function () { return _this._reloadNavigation.next(); })
+        ];
+        this._subscriptions.push(this._reloadNavigation.pipe(debounceTime(100)).subscribe(function () {
+            _this.resolveNavigation();
+        }));
+    };
+    AbstractNavigationTreeComponent.prototype.ngOnDestroy = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this._subscriptions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var sub = _c.value;
+                if (!sub.closed) {
+                    sub.unsubscribe();
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this._reloadNavigation.complete();
+        if (this._subGroupResolution !== undefined) {
+            this._subGroupResolution.unsubscribe();
+        }
+        if (this._subLangChange !== undefined) {
+            this._subLangChange.unsubscribe();
+        }
+    };
+    AbstractNavigationTreeComponent.prototype.hasChild = function (_, node) {
+        return !!node.children && node.children.length > 0;
+    };
+    AbstractNavigationTreeComponent.prototype.resolveNavigation = function () {
+        var 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);
+    };
+    AbstractNavigationTreeComponent.prototype.resolveNavigationNodesWithOffsetRoot = function () {
+        var 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
+     */
+    AbstractNavigationTreeComponent.prototype.resolveNavigationNodes = function (views, parentUrl, ancestorNodeContainer) {
+        var _this = this;
+        if (!views || Object.keys(views).length === 0) {
+            return null;
+        }
+        var groupNavigationGenerated = false;
+        var nodes = [];
+        Object.keys(views).forEach(function (viewKey) {
+            var view = views[viewKey];
+            if (!groupNavigationGenerated && _this.isGroupNavigationNode(view)) {
+                groupNavigationGenerated = true;
+                var insertPosition_1 = (ancestorNodeContainer !== null && ancestorNodeContainer !== void 0 ? ancestorNodeContainer : nodes).length;
+                _this._subLangChange = _this._languageService.getLangChange$().subscribe(function () {
+                    _this.loadGroupNavigationNodes(insertPosition_1, ancestorNodeContainer !== null && ancestorNodeContainer !== void 0 ? ancestorNodeContainer : nodes);
+                });
+                _this.loadGroupNavigationNodes(insertPosition_1, ancestorNodeContainer !== null && ancestorNodeContainer !== void 0 ? ancestorNodeContainer : nodes);
+                return; // continue
+            }
+            if (!_this.hasNavigation(view) && !_this.hasSubRoutes(view)) {
+                return; // continue
+            }
+            var 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)) {
+                var 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.apply(nodes, __spread(_this.resolveNavigationNodes(view.children, _this.appendRouteSegment(parentUrl, routeSegment), ancestorNodeContainer !== null && ancestorNodeContainer !== void 0 ? ancestorNodeContainer : nodes)));
+                }
+            }
+        });
+        return nodes;
+    };
+    AbstractNavigationTreeComponent.prototype.hasNavigation = function (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;
+        }
+    };
+    AbstractNavigationTreeComponent.prototype.hasSubRoutes = function (route) {
+        if (!route.children) {
+            return false;
+        }
+        if (typeof route.children === 'object') {
+            return Object.keys(route.children).length !== 0;
+        }
+    };
+    AbstractNavigationTreeComponent.prototype.buildNode = function (view, routeSegment, parentUrl) {
+        var 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;
+    };
+    AbstractNavigationTreeComponent.prototype.getNodeName = function (view, routeSegment) {
+        if (view.navigation['title']) {
+            return view.navigation['title'];
+        }
+        var str = routeSegment.replace('_', ' ');
+        return str.charAt(0).toUpperCase() + str.substring(1);
+    };
+    AbstractNavigationTreeComponent.prototype.getNodeIcon = function (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
+     */
+    AbstractNavigationTreeComponent.prototype.getNodeRouteSegment = function (view) {
+        return !!view.routing && (typeof view.routing.path === 'string') ? view.routing.path : undefined;
+    };
+    AbstractNavigationTreeComponent.prototype.getNodeTranslateFlag = function (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).
+     */
+    AbstractNavigationTreeComponent.prototype.appendRouteSegment = function (parentUrl, routeSegment) {
+        return routeSegment ? parentUrl + '/' + routeSegment : parentUrl;
+    };
+    AbstractNavigationTreeComponent.prototype.resolveLevels = function (nodes, parentLevel) {
+        var _this = this;
+        if (!nodes) {
+            return;
+        }
+        var currentLevel = parentLevel === null || parentLevel === undefined ? 0 : parentLevel + 1;
+        nodes.forEach(function (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
+     */
+    AbstractNavigationTreeComponent.prototype.canAccessView = function (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
+     */
+    AbstractNavigationTreeComponent.prototype.passesRoleGuard = function (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
+     */
+    AbstractNavigationTreeComponent.prototype.passesAuthorityGuard = function (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
+     */
+    AbstractNavigationTreeComponent.prototype.passesGroupGuard = function (view, url) {
+        return !view.access.hasOwnProperty('group') || this._groupGuard.canAccessView(view, url);
+    };
+    AbstractNavigationTreeComponent.prototype.resolveChange = function () {
+        var 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.
+     */
+    AbstractNavigationTreeComponent.prototype.isGroupNavigationNode = function (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)
+     */
+    AbstractNavigationTreeComponent.prototype.loadGroupNavigationNodes = function (insertPosition, nodeContainer) {
+        var _this = this;
+        if (this._subGroupResolution !== undefined && !this._subGroupResolution.closed) {
+            this._subGroupResolution.unsubscribe();
+        }
+        this._subGroupResolution = this.generateGroupNavigationNodes().pipe(take(1)).subscribe(function (groupNavNodes) {
+            nodeContainer.splice.apply(nodeContainer, __spread([insertPosition, _this._groupNavNodesCount], groupNavNodes));
+            _this._groupNavNodesCount = groupNavNodes.length;
+            refreshTree(_this.dataSource);
+        });
+    };
+    AbstractNavigationTreeComponent.prototype.generateGroupNavigationNodes = function () {
+        var _this = this;
+        return forkJoin(this._activeGroupService.activeGroups.map(function (groupCase) {
+            return _this._taskResourceService.searchTask(SimpleFilter.fromTaskQuery({ case: { id: groupCase.stringId }, transitionId: GroupNavigationConstants.NAVIGATION_CONFIG_TRANSITION_ID })).pipe(map(function (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(function (o) { return o; }));
+        })).pipe(map(function (navigationConfigurations) {
+            var e_2, _a;
+            var result = [];
+            try {
+                for (var navigationConfigurations_1 = __values(navigationConfigurations), navigationConfigurations_1_1 = navigationConfigurations_1.next(); !navigationConfigurations_1_1.done; navigationConfigurations_1_1 = navigationConfigurations_1.next()) {
+                    var navConfig = navigationConfigurations_1_1.value;
+                    result.push.apply(result, __spread(_this.convertDatagroupsToNavEntries(navConfig)));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (navigationConfigurations_1_1 && !navigationConfigurations_1_1.done && (_a = navigationConfigurations_1.return)) _a.call(navigationConfigurations_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return result;
+        }));
+    };
+    AbstractNavigationTreeComponent.prototype.convertDatagroupsToNavEntries = function (navConfigDatagroups) {
+        var _this = this;
+        var result = [];
+        var entryDataGroupIndices = [];
+        navConfigDatagroups.forEach(function (group, index) {
+            if (group.fields.some(function (field) { return field.stringId === GroupNavigationConstants.NAVIGATION_ENTRY_MARKER_FIELD_ID_SUFFIX; })) {
+                entryDataGroupIndices.push(index);
+            }
+        });
+        var navEntriesTaskRef;
+        navConfigDatagroups.some(function (group) {
+            var 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 (var order = 0; order < navEntriesTaskRef.value.length; order++) {
+            var index = entryDataGroupIndices[order];
+            var label = extractIconAndTitle(navConfigDatagroups.slice(index, index + GroupNavigationConstants.DATAGROUPS_PER_NAVIGATION_ENTRY));
+            var newNode = __assign({ url: '' }, label);
+            var 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];
+            var allowedRoles = extractRoles(navConfigDatagroups.slice(index, index + GroupNavigationConstants.DATAGROUPS_PER_NAVIGATION_ENTRY), GroupNavigationConstants.NAVIGATION_ENTRY_ALLOWED_ROLES_FIELD_ID_SUFFIX);
+            var bannedRoles = extractRoles(navConfigDatagroups.slice(index, index + GroupNavigationConstants.DATAGROUPS_PER_NAVIGATION_ENTRY), GroupNavigationConstants.NAVIGATION_ENTRY_BANNED_ROLES_FIELD_ID_SUFFIX);
+            var splitAllowedRoles = this.extractRoleAndNetId(allowedRoles);
+            var splitBannedRoles = this.extractRoleAndNetId(bannedRoles);
+            if ((splitAllowedRoles.length === 0
+                || splitAllowedRoles.some(function (idPair) { return _this._userService.hasRoleByIdentifier(idPair[0], idPair[1]); }))
+                && !splitBannedRoles.some(function (idPair) { return _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>`
+     */
+    AbstractNavigationTreeComponent.prototype.extractRoleAndNetId = function (joined) {
+        var e_3, _a;
+        var split = [];
+        try {
+            for (var joined_1 = __values(joined), joined_1_1 = joined_1.next(); !joined_1_1.done; joined_1_1 = joined_1.next()) {
+                var pair = joined_1_1.value;
+                var 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);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (joined_1_1 && !joined_1_1.done && (_a = joined_1.return)) _a.call(joined_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return split;
+    };
+    AbstractNavigationTreeComponent.propDecorators = {
+        viewPath: [{ type: Input }],
+        parentUrl: [{ type: Input }],
+        routerChange: [{ type: Input }]
+    };
+    return AbstractNavigationTreeComponent;
+}(AbstractNavigationResizableDrawerComponent));
+export { AbstractNavigationTreeComponent };
+//# 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/esm5/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/esm5/lib/navigation/quick-panel/components/abstract-quick-panel.component.js

@@ -0,0 +1,30 @@
+import { __extends } from "tslib";
+import { Input } from '@angular/core';
+import { AbstractNavigationResizableDrawerComponent } from '../../navigation-drawer/abstract-navigation-resizable-drawer.component';
+var AbstractQuickPanelComponent = /** @class */ (function (_super) {
+    __extends(AbstractQuickPanelComponent, _super);
+    function AbstractQuickPanelComponent(_select, _paperView) {
+        var _this = _super.call(this) || this;
+        _this._select = _select;
+        _this._paperView = _paperView;
+        return _this;
+    }
+    AbstractQuickPanelComponent.prototype.ngOnInit = function () {
+        _super.prototype.ngOnInit.call(this);
+    };
+    AbstractQuickPanelComponent.prototype.getLang = function () {
+        return this._select.getLanguage();
+    };
+    AbstractQuickPanelComponent.prototype.setPaperView = function () {
+        this._paperView.paperView = !this._paperView.paperView;
+    };
+    AbstractQuickPanelComponent.prototype.isPaperView = function () {
+        return this._paperView.paperView;
+    };
+    AbstractQuickPanelComponent.propDecorators = {
+        items: [{ type: Input }]
+    };
+    return AbstractQuickPanelComponent;
+}(AbstractNavigationResizableDrawerComponent));
+export { AbstractQuickPanelComponent };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,14 @@
+import { Input } from '@angular/core';
+var AbstractInternalLinkComponent = /** @class */ (function () {
+    function AbstractInternalLinkComponent() {
+    }
+    AbstractInternalLinkComponent.prototype.ngOnInit = function () {
+    };
+    AbstractInternalLinkComponent.propDecorators = {
+        link: [{ type: Input }],
+        icon: [{ type: Input }]
+    };
+    return AbstractInternalLinkComponent;
+}());
+export { AbstractInternalLinkComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtaW50ZXJuYWwtbGluay5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvbmF2aWdhdGlvbi9xdWljay1wYW5lbC9jb21wb25lbnRzL2ludGVybmFsLWxpbmsvYWJzdHJhY3QtaW50ZXJuYWwtbGluay5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLEtBQUssRUFBUyxNQUFNLGVBQWUsQ0FBQztBQUU1QztJQUtJO0lBQ0EsQ0FBQztJQUVELGdEQUFRLEdBQVI7SUFDQSxDQUFDOzt1QkFQQSxLQUFLO3VCQUNMLEtBQUs7O0lBUVYsb0NBQUM7Q0FBQSxBQVhELElBV0M7U0FYcUIsNkJBQTZCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbnB1dCwgT25Jbml0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFic3RyYWN0SW50ZXJuYWxMaW5rQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcblxuICAgIEBJbnB1dCgpIHB1YmxpYyBsaW5rOiBzdHJpbmc7XG4gICAgQElucHV0KCkgcHVibGljIGljb246IHN0cmluZztcblxuICAgIGNvbnN0cnVjdG9yKCkge1xuICAgIH1cblxuICAgIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIH1cblxufVxuIl19