@netgrif/components-core 6.4.0 → 6.5.0-rc.1

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

@@ -0,0 +1,458 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import { BehaviorSubject, of } from 'rxjs';
+import { LoadingEmitter } from "../../../utility/loading-emitter";
+import { filter, map, take } from "rxjs/operators";
+import { DoubleDrawerUtils } from "../util/double-drawer-utils";
+import { HttpParams } from "@angular/common/http";
+import { PaginationParams } from "../../../utility/pagination/pagination-params";
+import { SimpleFilter } from "../../../filter/models/simple-filter";
+import { MENU_IDENTIFIERS, MenuOrder, RIGHT_SIDE_INIT_PAGE_SIZE, RIGHT_SIDE_NEW_PAGE_SIZE, SETTINGS_TRANSITION_ID } from '../../model/navigation-configs';
+import { GroupNavigationConstants } from "../../model/group-navigation-constants";
+import * as i0 from "@angular/core";
+import * as i1 from "../../service/uri.service";
+import * as i2 from "../../../logger/services/logger.service";
+import * as i3 from "../../../configuration/configuration.service";
+import * as i4 from "@angular/router";
+import * as i5 from "../../../resources/engine-endpoint/case-resource.service";
+import * as i6 from "../../../authorization/permission/access.service";
+import * as i7 from "@ngx-translate/core";
+import * as i8 from "../../../routing/dynamic-navigation-route-provider/dynamic-navigation-route-provider.service";
+import * as i9 from "../../../routing/redirect-service/redirect.service";
+/**
+ * Service for managing navigation in double-drawer
+ * */
+export class DoubleDrawerNavigationService {
+    constructor(_uriService, _log, _config, _activatedRoute, _caseResourceService, _accessService, _translateService, _dynamicRoutingService, _redirectService) {
+        this._uriService = _uriService;
+        this._log = _log;
+        this._config = _config;
+        this._activatedRoute = _activatedRoute;
+        this._caseResourceService = _caseResourceService;
+        this._accessService = _accessService;
+        this._translateService = _translateService;
+        this._dynamicRoutingService = _dynamicRoutingService;
+        this._redirectService = _redirectService;
+        this.defaultViewIcon = 'filter_alt';
+        this._leftItems$ = new BehaviorSubject([]);
+        this._rightItems$ = new BehaviorSubject([]);
+        this._moreItems$ = new BehaviorSubject([]);
+        this._hiddenCustomItems$ = new BehaviorSubject([]);
+        this._childCustomViews = {};
+        this._leftLoading$ = new LoadingEmitter();
+        this._rightLoading$ = new LoadingEmitter();
+        this._nodeLoading$ = new LoadingEmitter();
+        this._currentNavigationItem = null;
+        this.itemsOrder = MenuOrder.Ascending;
+        this.customItemsInitialized = false;
+        this.hiddenCustomItemsInitialized = false;
+        this.itemClicked = new EventEmitter();
+        this.itemLoaded = new EventEmitter();
+        this._currentNodeSubscription = this._uriService.activeNode$.subscribe(node => {
+            this.currentNode = node;
+        });
+    }
+    ngOnDestroy() {
+        this._currentNodeSubscription?.unsubscribe();
+        this._leftLoading$.complete();
+        this._rightLoading$.complete();
+        this._nodeLoading$.complete();
+        this.itemClicked.complete();
+        this.itemLoaded.complete();
+    }
+    get canGoBackLoading$() {
+        return this._nodeLoading$;
+    }
+    get currentNode() {
+        return this._currentNode;
+    }
+    set currentNode(node) {
+        if (node === this._currentNode || this._leftLoading$.isActive || this._rightLoading$.isActive) {
+            return;
+        }
+        this._currentNode = node;
+        if (!node) {
+            return;
+        }
+        if (node.parentId && !node.parent) {
+            if (node.parentId === this._uriService.root.id) {
+                node.parent = this._uriService.root;
+            }
+            else {
+                this._nodeLoading$.on();
+                this._uriService.getNodeByPath(this._uriService.resolveParentPath(node)).subscribe(n => {
+                    node.parent = !n ? this._uriService.root : n;
+                    this._nodeLoading$.off();
+                }, error => {
+                    this._log.error(error);
+                    this._nodeLoading$.off();
+                });
+            }
+        }
+        if (this._nodeLoading$.isActive) {
+            this._nodeLoading$.subscribe(() => {
+                this.loadNavigationItems(node);
+            });
+        }
+        else {
+            this.loadNavigationItems(node);
+        }
+    }
+    get itemClicked$() {
+        return this.itemClicked;
+    }
+    get itemLoaded$() {
+        return this.itemLoaded;
+    }
+    get rightItems$() {
+        return this._rightItems$;
+    }
+    get leftItems$() {
+        return this._leftItems$;
+    }
+    get moreItems$() {
+        return this._moreItems$;
+    }
+    get hiddenCustomItems$() {
+        return this._hiddenCustomItems$;
+    }
+    get rightItems() {
+        return this._rightItems$.getValue();
+    }
+    get leftItems() {
+        return this._leftItems$.getValue();
+    }
+    get moreItems() {
+        return this._moreItems$.getValue();
+    }
+    get hiddenCustomItems() {
+        return this._hiddenCustomItems$.getValue();
+    }
+    get leftLoading$() {
+        return this._leftLoading$;
+    }
+    get rightLoading$() {
+        return this._rightLoading$;
+    }
+    get nodeLoading$() {
+        return this._nodeLoading$;
+    }
+    loadNavigationItems(node) {
+        if (this._uriService.isRoot(node)) {
+            this._leftItems$.next([]);
+            this.loadRightSide();
+        }
+        else {
+            if (!this._leftItems$.getValue().find(item => DoubleDrawerUtils.isNodeCorrespondingToItem(node, item))) {
+                this.loadLeftSide();
+            }
+            this.loadRightSide();
+        }
+    }
+    /**
+     * On home click, the current level is set to 0, and current parent is
+     * set to root node.
+     * */
+    onHomeClick() {
+        if (this._leftLoading$.isActive || this._rightLoading$.isActive) {
+            return;
+        }
+        this._uriService.activeNode = this._uriService.root;
+        this.itemClicked.emit({ uriNode: this._uriService.activeNode, isHome: true });
+    }
+    /**
+     * On back click, the parent is set to parent of left nodes, that will solve
+     * the right side menu (elements that were in left side, after backward
+     * navigation will be on the right side).
+     * Current level is set to a lower number in order to set the left side menu.
+     * */
+    onBackClick() {
+        if (this._leftLoading$.isActive || this._rightLoading$.isActive || this._uriService.isRoot(this._currentNode)) {
+            return;
+        }
+        this._uriService.activeNode = this._currentNode.parent;
+        this.itemClicked.emit({ uriNode: this._uriService.activeNode, isHome: false });
+    }
+    /**
+     * On item click, the selected item's view is rendered (by routerLink). If the selected item has children items, the menu is updated
+     * and view, that is rendered is selected by the defined rule. The rule is: On first check for default view in children.
+     * On second check if the clicked item has a view. On third, pick any other children's view, else show nothing.
+     * */
+    onItemClick(item) {
+        this._currentNavigationItem = item;
+        if (item.resource === undefined) {
+            // custom view represented only in nae.json
+            if (item.processUri === this.currentNode.uriPath) {
+                this._uriService.activeNode = this._currentNode;
+            }
+            else {
+                this._uriService.activeNode = this._currentNode.parent;
+            }
+            this.itemClicked.emit({ uriNode: this._uriService.activeNode, isHome: false });
+        }
+        else {
+            const path = item.resource.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_NODE_PATH)?.value;
+            if (DoubleDrawerUtils.hasItemChildren(item) && !this._leftLoading$.isActive && !this._rightLoading$.isActive) {
+                this._uriService.getNodeByPath(path).subscribe(node => {
+                    this._uriService.activeNode = node;
+                    this.itemClicked.emit({ uriNode: this._uriService.activeNode, isHome: false });
+                    this._rightLoading$.pipe(filter(isRightLoading => isRightLoading === false), take(1)).subscribe(() => {
+                        this.openAvailableView();
+                    });
+                }, error => {
+                    this._log.error(error);
+                });
+            }
+            else if (!path.includes(this.currentNode.uriPath)) {
+                this._uriService.activeNode = this._currentNode.parent;
+                this.itemClicked.emit({ uriNode: this._uriService.activeNode, isHome: false });
+            }
+            else {
+                this._uriService.activeNode = this._currentNode;
+                this.itemClicked.emit({ uriNode: this._uriService.activeNode, isHome: false });
+            }
+        }
+    }
+    /**
+     * Opens a view of the current right items in the menu by defined rule. The rule is: On first check for default
+     * view in children. On second check if the clicked item has a view. On third, pick any other children's view, else
+     * show nothing.
+     * */
+    openAvailableView() {
+        let allItems = this.rightItems.concat(this.moreItems);
+        let autoOpenItems = allItems.filter(item => DoubleDrawerUtils.hasItemAutoOpenView(item));
+        if (autoOpenItems.length > 0) {
+            this._redirectService.redirect(autoOpenItems[0].routing.path);
+            return;
+        }
+        if (DoubleDrawerUtils.hasItemView(this._currentNavigationItem)) {
+            // is routed by routerLink on item click
+            return;
+        }
+        let itemsWithView = allItems.filter(item => DoubleDrawerUtils.hasItemView(item));
+        if (itemsWithView.length > 0) {
+            this._redirectService.redirect(autoOpenItems[0].routing.path);
+        }
+    }
+    loadMoreItems() {
+        if (this.moreItems.length > RIGHT_SIDE_NEW_PAGE_SIZE) {
+            let currentRightItems = this.rightItems;
+            let currentMoreItems = this.moreItems;
+            currentRightItems.push(...currentMoreItems.splice(0, RIGHT_SIDE_NEW_PAGE_SIZE));
+            this.rightItems$.next(currentRightItems);
+            this.moreItems$.next(currentMoreItems);
+        }
+        else {
+            let currentRightItems = this.rightItems;
+            currentRightItems.push(...this.moreItems);
+            this.rightItems$.next(currentRightItems);
+            this.moreItems$.next([]);
+        }
+    }
+    initializeCustomViewsOfView(view, viewConfigPath) {
+        if (!view || this.customItemsInitialized || this.hiddenCustomItemsInitialized)
+            return;
+        Object.entries(view.children).forEach(([key, childView]) => {
+            const childViewConfigPath = viewConfigPath + '/' + key;
+            this.resolveUriForChildViews(childViewConfigPath, childView);
+            this.resolveHiddenMenuItemFromChildViews(childViewConfigPath, childView);
+        });
+        this.resolveCustomViewsInRightSide();
+        this.resolveCustomViewsInLeftSide();
+        this.customItemsInitialized = true;
+        this.hiddenCustomItemsInitialized = true;
+    }
+    switchOrder() {
+        this.itemsOrder = (this.itemsOrder + 1) % 2;
+        let multiplier = 1;
+        if (this.itemsOrder === MenuOrder.Descending) {
+            multiplier = -1;
+        }
+        let currentRightItems = this.rightItems;
+        let currentLeftItems = this.leftItems;
+        currentRightItems.sort((a, b) => multiplier * a?.navigation?.title.localeCompare(b?.navigation?.title));
+        currentLeftItems.sort((a, b) => multiplier * a?.navigation?.title.localeCompare(b?.navigation?.title));
+        this.rightItems$.next(currentRightItems);
+        this.leftItems$.next(currentLeftItems);
+    }
+    isAscending() {
+        return this.itemsOrder === MenuOrder.Ascending;
+    }
+    loadLeftSide() {
+        if (this._uriService.isRoot(this._currentNode)) {
+            this._leftItems$.next([]);
+            return;
+        }
+        this._leftLoading$.on();
+        this._uriService.getItemCaseByNodePath(this.currentNode.parent).subscribe(page => {
+            let childCases$;
+            let targetItem;
+            let orderedChildCaseIds;
+            if (page?.pagination?.totalElements === 0) {
+                childCases$ = of([]);
+            }
+            else {
+                targetItem = page.content[0];
+                orderedChildCaseIds = DoubleDrawerUtils.extractChildCaseIds(targetItem);
+                childCases$ = this.getItemCasesByIdsInOnePage(orderedChildCaseIds).pipe(map(p => p.content));
+            }
+            childCases$.subscribe(result => {
+                result = result.map(folder => this.resolveItemCaseToNavigationItem(folder)).filter(i => !!i);
+                this._leftItems$.next(result.sort((a, b) => orderedChildCaseIds.indexOf(a.resource.stringId) - orderedChildCaseIds.indexOf(b.resource.stringId)));
+                this.resolveCustomViewsInLeftSide();
+                this._leftLoading$.off();
+                this.itemLoaded.emit({ menu: 'left', items: this.leftItems });
+            }, error => {
+                this._log.error(error);
+                this._leftItems$.next([]);
+                this.resolveCustomViewsInLeftSide();
+                this._leftLoading$.off();
+            });
+        }, error => {
+            this._log.error(error);
+            this._leftItems$.next([]);
+            this.resolveCustomViewsInLeftSide();
+            this._leftLoading$.off();
+        });
+    }
+    loadRightSide() {
+        this._rightLoading$.on();
+        this._moreItems$.next([]);
+        this._uriService.getItemCaseByNodePath(this.currentNode).subscribe(page => {
+            let childCases$;
+            let targetItem;
+            let orderedChildCaseIds;
+            if (page?.pagination?.totalElements === 0) {
+                childCases$ = of([]);
+            }
+            else {
+                targetItem = page.content[0];
+                orderedChildCaseIds = DoubleDrawerUtils.extractChildCaseIds(targetItem);
+                childCases$ = this.getItemCasesByIdsInOnePage(orderedChildCaseIds).pipe(map(p => p.content));
+            }
+            childCases$.subscribe(result => {
+                result = result.sort((a, b) => orderedChildCaseIds.indexOf(a.stringId) - orderedChildCaseIds.indexOf(b.stringId));
+                if (result.length > RIGHT_SIDE_INIT_PAGE_SIZE) {
+                    const rawRightItems = result.splice(0, RIGHT_SIDE_INIT_PAGE_SIZE);
+                    this._rightItems$.next(rawRightItems.map(folder => this.resolveItemCaseToNavigationItem(folder)).filter(i => !!i));
+                    this._moreItems$.next(result.map(folder => this.resolveItemCaseToNavigationItem(folder)).filter(i => !!i));
+                }
+                else {
+                    this._rightItems$.next(result.map(folder => this.resolveItemCaseToNavigationItem(folder)).filter(i => !!i));
+                }
+                this.resolveCustomViewsInRightSide();
+                this._rightLoading$.off();
+                this.itemLoaded.emit({ menu: 'right', items: this.rightItems });
+            }, error => {
+                this._log.error(error);
+                this._rightItems$.next([]);
+                this._moreItems$.next([]);
+                this.resolveCustomViewsInRightSide();
+                this._rightLoading$.off();
+            });
+        }, error => {
+            this._log.error(error);
+            this._rightItems$.next([]);
+            this._moreItems$.next([]);
+            this.resolveCustomViewsInRightSide();
+            this._rightLoading$.off();
+        });
+    }
+    getItemCasesByIdsInOnePage(caseIds) {
+        return this.getItemCasesByIds(caseIds, 0, caseIds.length);
+    }
+    getItemCasesByIds(caseIds, pageNumber, pageSize) {
+        const searchBody = {
+            stringId: caseIds,
+            process: MENU_IDENTIFIERS.map(id => ({ identifier: id })),
+        };
+        let httpParams = new HttpParams()
+            .set(PaginationParams.PAGE_SIZE, pageSize)
+            .set(PaginationParams.PAGE_NUMBER, pageNumber);
+        return this._caseResourceService.searchCases(SimpleFilter.fromCaseQuery(searchBody), httpParams);
+    }
+    resolveItemCaseToNavigationItem(itemCase) {
+        if (DoubleDrawerUtils.representsRootNode(itemCase)) {
+            return;
+        }
+        const item = {
+            access: {},
+            navigation: {
+                icon: itemCase.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_MENU_ICON)?.value || this.defaultViewIcon,
+                title: this.getTranslation(itemCase.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_MENU_NAME)?.value) || itemCase.title,
+            },
+            routing: {
+                path: this.getItemRoutingPath(itemCase),
+            },
+            id: itemCase.stringId,
+            resource: itemCase,
+        };
+        const resolvedRoles = DoubleDrawerUtils.resolveAccessRoles(itemCase, GroupNavigationConstants.ITEM_FIELD_ID_ALLOWED_ROLES);
+        const resolvedBannedRoles = DoubleDrawerUtils.resolveAccessRoles(itemCase, GroupNavigationConstants.ITEM_FIELD_ID_BANNED_ROLES);
+        if (!!resolvedRoles)
+            item.access['role'] = resolvedRoles;
+        if (!!resolvedBannedRoles)
+            item.access['bannedRole'] = resolvedBannedRoles;
+        if (!this._accessService.canAccessView(item, item.routingPath))
+            return;
+        return item;
+    }
+    resolveCustomViewsInLeftSide() {
+        if (!!this._currentNode?.parent && !!this._childCustomViews[this._currentNode.parent.uriPath]) {
+            let currentLeftItems = this._leftItems$.getValue();
+            currentLeftItems.push(...Object.values(this._childCustomViews[this._currentNode.parent.uriPath]));
+            this._leftItems$.next(currentLeftItems);
+        }
+    }
+    resolveCustomViewsInRightSide() {
+        if (!!this._currentNode && !!this._childCustomViews[this._currentNode.uriPath]) {
+            let currentRightItems = this._rightItems$.getValue();
+            currentRightItems.push(...Object.values(this._childCustomViews[this._currentNode.uriPath]));
+            this._rightItems$.next(currentRightItems);
+        }
+    }
+    resolveUriForChildViews(configPath, childView) {
+        if (!childView.processUri)
+            return;
+        if (!this._accessService.canAccessView(childView, configPath))
+            return;
+        if (!this._childCustomViews[childView.processUri]) {
+            this._childCustomViews[childView.processUri] = {};
+        }
+        this._childCustomViews[childView.processUri][configPath] = {
+            id: configPath,
+            ...childView,
+        };
+    }
+    resolveHiddenMenuItemFromChildViews(configPath, childView) {
+        if (!childView.navigation)
+            return;
+        if (!this._accessService.canAccessView(childView, configPath))
+            return;
+        if (!!(childView?.navigation?.hidden)) {
+            let currentHiddenCustomItems = this._hiddenCustomItems$.getValue();
+            currentHiddenCustomItems.push({
+                id: configPath,
+                ...childView,
+            });
+            this._hiddenCustomItems$.next(currentHiddenCustomItems);
+        }
+    }
+    getTranslation(value) {
+        const locale = this._translateService.currentLang.split('-')[0];
+        return locale in value.translations ? value.translations[locale] : value.defaultValue;
+    }
+    getItemRoutingPath(itemCase) {
+        const taskId = DoubleDrawerUtils.findTaskIdInCase(itemCase, SETTINGS_TRANSITION_ID);
+        const url = this._dynamicRoutingService.route;
+        return `/${url}/${taskId}`;
+    }
+}
+DoubleDrawerNavigationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: DoubleDrawerNavigationService, deps: [{ token: i1.UriService }, { token: i2.LoggerService }, { token: i3.ConfigurationService }, { token: i4.ActivatedRoute }, { token: i5.CaseResourceService }, { token: i6.AccessService }, { token: i7.TranslateService }, { token: i8.DynamicNavigationRouteProviderService }, { token: i9.RedirectService }], target: i0.ɵɵFactoryTarget.Injectable });
+DoubleDrawerNavigationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: DoubleDrawerNavigationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: DoubleDrawerNavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.UriService }, { type: i2.LoggerService }, { type: i3.ConfigurationService }, { type: i4.ActivatedRoute }, { type: i5.CaseResourceService }, { type: i6.AccessService }, { type: i7.TranslateService }, { type: i8.DynamicNavigationRouteProviderService }, { type: i9.RedirectService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"double-drawer-navigation.service.js","sourceRoot":"","sources":["../../../../../../../projects/netgrif-components-core/src/lib/navigation/navigation-double-drawer/service/double-drawer-navigation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {EventEmitter, Injectable, OnDestroy} from '@angular/core';\nimport {BehaviorSubject, Observable, of, Subscription} from 'rxjs';\nimport {UriService} from \"../../service/uri.service\";\nimport {LoadingEmitter} from \"../../../utility/loading-emitter\";\nimport {filter, map, take} from \"rxjs/operators\";\nimport {Case} from \"../../../resources/interface/case\";\nimport {LoggerService} from \"../../../logger/services/logger.service\";\nimport {DoubleDrawerUtils} from \"../util/double-drawer-utils\";\nimport {Page} from \"../../../resources/interface/page\";\nimport {CaseSearchRequestBody, PetriNetSearchRequest} from \"../../../filter/models/case-search-request-body\";\nimport {HttpParams} from \"@angular/common/http\";\nimport {PaginationParams} from \"../../../utility/pagination/pagination-params\";\nimport {SimpleFilter} from \"../../../filter/models/simple-filter\";\nimport {CaseResourceService} from \"../../../resources/engine-endpoint/case-resource.service\";\nimport {I18nFieldValue} from \"../../../data-fields/i18n-field/models/i18n-field-value\";\nimport {TranslateService} from \"@ngx-translate/core\";\nimport {\n    DynamicNavigationRouteProviderService\n} from \"../../../routing/dynamic-navigation-route-provider/dynamic-navigation-route-provider.service\";\nimport {RedirectService} from \"../../../routing/redirect-service/redirect.service\";\nimport {AccessService} from \"../../../authorization/permission/access.service\";\nimport {ActivatedRoute} from \"@angular/router\";\nimport {ConfigurationService} from \"../../../configuration/configuration.service\";\nimport {View} from \"../../../../commons/schema\";\nimport {\n    MENU_IDENTIFIERS,\n    MenuOrder,\n    NavigationItem, RIGHT_SIDE_INIT_PAGE_SIZE,\n    RIGHT_SIDE_NEW_PAGE_SIZE,\n    SETTINGS_TRANSITION_ID\n} from '../../model/navigation-configs';\nimport { UriNodeResource } from '../../model/uri-resource';\nimport {MenuItemClickEvent, MenuItemLoadedEvent} from '../../model/navigation-menu-events';\nimport {GroupNavigationConstants} from \"../../model/group-navigation-constants\";\n\n/**\n * Service for managing navigation in double-drawer\n * */\n@Injectable({\n    providedIn: 'root',\n})\nexport class DoubleDrawerNavigationService implements OnDestroy {\n\n    /**\n     * List of displayed items on the left side\n     * */\n    protected _leftItems$: BehaviorSubject<Array<NavigationItem>>;\n    /**\n     * List of displayed items on the right side\n     * */\n    protected _rightItems$: BehaviorSubject<Array<NavigationItem>>;\n    /**\n     * List of hidden items\n     * */\n    protected _moreItems$: BehaviorSubject<Array<NavigationItem>>;\n    /**\n     * List of custom items in more menu\n     * */\n    protected _hiddenCustomItems$: BehaviorSubject<Array<NavigationItem>>;\n    /**\n     * List of custom items\n     * */\n    protected _childCustomViews: { [uri: string]: { [key: string]: NavigationItem } };\n    protected itemsOrder: MenuOrder;\n    protected _leftLoading$: LoadingEmitter;\n    protected _rightLoading$: LoadingEmitter;\n    protected _nodeLoading$: LoadingEmitter;\n    protected _currentNodeSubscription: Subscription;\n    /**\n     * Currently display uri\n     * Siblings of the node are on the left, children are on the right\n     */\n    protected _currentNode: UriNodeResource;\n    /**\n     * Currently selected navigation item\n     */\n    protected _currentNavigationItem: NavigationItem;\n    protected defaultViewIcon: string = 'filter_alt';\n    protected customItemsInitialized: boolean;\n    protected hiddenCustomItemsInitialized: boolean;\n    protected itemClicked: EventEmitter<MenuItemClickEvent>;\n    protected itemLoaded: EventEmitter<MenuItemLoadedEvent>;\n\n    constructor(protected _uriService: UriService,\n                protected _log: LoggerService,\n                protected _config: ConfigurationService,\n                protected _activatedRoute: ActivatedRoute,\n                protected _caseResourceService: CaseResourceService,\n                protected _accessService: AccessService,\n                protected _translateService: TranslateService,\n                protected _dynamicRoutingService: DynamicNavigationRouteProviderService,\n                protected _redirectService: RedirectService) {\n        this._leftItems$ = new BehaviorSubject([]);\n        this._rightItems$ = new BehaviorSubject([]);\n        this._moreItems$ = new BehaviorSubject([]);\n        this._hiddenCustomItems$ = new BehaviorSubject([]);\n        this._childCustomViews = {};\n        this._leftLoading$ = new LoadingEmitter();\n        this._rightLoading$ = new LoadingEmitter();\n        this._nodeLoading$ = new LoadingEmitter();\n        this._currentNavigationItem = null;\n        this.itemsOrder = MenuOrder.Ascending;\n        this.customItemsInitialized = false;\n        this.hiddenCustomItemsInitialized = false;\n        this.itemClicked = new EventEmitter<MenuItemClickEvent>();\n        this.itemLoaded = new EventEmitter<MenuItemLoadedEvent>();\n\n        this._currentNodeSubscription = this._uriService.activeNode$.subscribe(node => {\n            this.currentNode = node;\n        });\n    }\n\n    public ngOnDestroy(): void {\n        this._currentNodeSubscription?.unsubscribe();\n        this._leftLoading$.complete();\n        this._rightLoading$.complete();\n        this._nodeLoading$.complete();\n        this.itemClicked.complete();\n        this.itemLoaded.complete();\n    }\n\n    public get canGoBackLoading$(): Observable<boolean> {\n        return this._nodeLoading$;\n    }\n\n    public get currentNode(): UriNodeResource {\n        return this._currentNode;\n    }\n\n    public set currentNode(node: UriNodeResource) {\n        if (node === this._currentNode || this._leftLoading$.isActive || this._rightLoading$.isActive) {\n            return;\n        }\n        this._currentNode = node;\n        if (!node) {\n            return;\n        }\n        if (node.parentId && !node.parent) {\n            if (node.parentId === this._uriService.root.id) {\n                node.parent = this._uriService.root;\n            } else {\n                this._nodeLoading$.on();\n                this._uriService.getNodeByPath(this._uriService.resolveParentPath(node)).subscribe(n => {\n                    node.parent = !n ? this._uriService.root : n;\n                    this._nodeLoading$.off();\n                }, error => {\n                    this._log.error(error);\n                    this._nodeLoading$.off();\n                });\n            }\n        }\n        if (this._nodeLoading$.isActive) {\n            this._nodeLoading$.subscribe(() => {\n                this.loadNavigationItems(node);\n            });\n        } else {\n            this.loadNavigationItems(node);\n        }\n    }\n\n    public get itemClicked$(): EventEmitter<MenuItemClickEvent> {\n        return this.itemClicked;\n    }\n\n    public get itemLoaded$(): EventEmitter<MenuItemLoadedEvent> {\n        return this.itemLoaded;\n    }\n\n    public get rightItems$(): BehaviorSubject<Array<NavigationItem>> {\n        return this._rightItems$;\n    }\n\n    public get leftItems$(): BehaviorSubject<Array<NavigationItem>> {\n        return this._leftItems$;\n    }\n\n    public get moreItems$(): BehaviorSubject<Array<NavigationItem>> {\n        return this._moreItems$;\n    }\n\n    public get hiddenCustomItems$(): BehaviorSubject<Array<NavigationItem>> {\n        return this._hiddenCustomItems$;\n    }\n\n    public get rightItems(): Array<NavigationItem> {\n        return this._rightItems$.getValue();\n    }\n\n    public get leftItems(): Array<NavigationItem> {\n        return this._leftItems$.getValue();\n    }\n\n    public get moreItems(): Array<NavigationItem> {\n        return this._moreItems$.getValue();\n    }\n\n    public get hiddenCustomItems(): Array<NavigationItem> {\n        return this._hiddenCustomItems$.getValue();\n    }\n\n    public get leftLoading$(): LoadingEmitter {\n        return this._leftLoading$;\n    }\n\n    public get rightLoading$(): LoadingEmitter {\n        return this._rightLoading$;\n    }\n\n    public get nodeLoading$(): LoadingEmitter {\n        return this._nodeLoading$;\n    }\n\n    public loadNavigationItems(node: UriNodeResource) {\n        if (this._uriService.isRoot(node)) {\n            this._leftItems$.next([]);\n            this.loadRightSide();\n        } else {\n            if (!this._leftItems$.getValue().find(item => DoubleDrawerUtils.isNodeCorrespondingToItem(node, item))) {\n                this.loadLeftSide();\n            }\n            this.loadRightSide();\n        }\n    }\n\n    /**\n     * On home click, the current level is set to 0, and current parent is\n     * set to root node.\n     * */\n    public onHomeClick(): void {\n        if (this._leftLoading$.isActive || this._rightLoading$.isActive) {\n            return;\n        }\n        this._uriService.activeNode = this._uriService.root;\n        this.itemClicked.emit({uriNode: this._uriService.activeNode, isHome: true});\n    }\n\n    /**\n     * On back click, the parent is set to parent of left nodes, that will solve\n     * the right side menu (elements that were in left side, after backward\n     * navigation will be on the right side).\n     * Current level is set to a lower number in order to set the left side menu.\n     * */\n    public onBackClick(): void {\n        if (this._leftLoading$.isActive || this._rightLoading$.isActive || this._uriService.isRoot(this._currentNode)) {\n            return;\n        }\n        this._uriService.activeNode = this._currentNode.parent;\n        this.itemClicked.emit({uriNode: this._uriService.activeNode, isHome: false});\n    }\n\n    /**\n     * On item click, the selected item's view is rendered (by routerLink). If the selected item has children items, the menu is updated\n     * and view, that is rendered is selected by the defined rule. The rule is: On first check for default view in children.\n     * On second check if the clicked item has a view. On third, pick any other children's view, else show nothing.\n     * */\n    public onItemClick(item: NavigationItem): void {\n        this._currentNavigationItem = item;\n        if (item.resource === undefined) {\n            // custom view represented only in nae.json\n            if (item.processUri === this.currentNode.uriPath) {\n                this._uriService.activeNode = this._currentNode;\n            } else {\n                this._uriService.activeNode = this._currentNode.parent;\n            }\n            this.itemClicked.emit({uriNode: this._uriService.activeNode, isHome: false});\n        } else {\n            const path = item.resource.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_NODE_PATH)?.value;\n            if (DoubleDrawerUtils.hasItemChildren(item) && !this._leftLoading$.isActive && !this._rightLoading$.isActive) {\n                this._uriService.getNodeByPath(path).subscribe(node => {\n                    this._uriService.activeNode = node;\n                    this.itemClicked.emit({uriNode: this._uriService.activeNode, isHome: false});\n                    this._rightLoading$.pipe(\n                        filter(isRightLoading => isRightLoading === false),\n                        take(1)\n                    ).subscribe(()=> {\n                        this.openAvailableView();\n                    })\n                }, error => {\n                    this._log.error(error);\n                });\n            } else if (!path.includes(this.currentNode.uriPath)) {\n                this._uriService.activeNode = this._currentNode.parent;\n                this.itemClicked.emit({uriNode: this._uriService.activeNode, isHome: false});\n            } else {\n                this._uriService.activeNode = this._currentNode;\n                this.itemClicked.emit({uriNode: this._uriService.activeNode, isHome: false});\n            }\n        }\n    }\n\n    /**\n     * Opens a view of the current right items in the menu by defined rule. The rule is: On first check for default\n     * view in children. On second check if the clicked item has a view. On third, pick any other children's view, else\n     * show nothing.\n     * */\n    public openAvailableView() {\n        let allItems: Array<NavigationItem> = this.rightItems.concat(this.moreItems);\n\n        let autoOpenItems: Array<NavigationItem> = allItems.filter(item => DoubleDrawerUtils.hasItemAutoOpenView(item));\n        if (autoOpenItems.length > 0) {\n            this._redirectService.redirect(autoOpenItems[0].routing.path);\n            return;\n        }\n\n        if (DoubleDrawerUtils.hasItemView(this._currentNavigationItem)) {\n            // is routed by routerLink on item click\n            return;\n        }\n\n        let itemsWithView: Array<NavigationItem> = allItems.filter(item => DoubleDrawerUtils.hasItemView(item));\n        if (itemsWithView.length > 0) {\n            this._redirectService.redirect(autoOpenItems[0].routing.path);\n        }\n    }\n\n    public loadMoreItems() {\n        if (this.moreItems.length > RIGHT_SIDE_NEW_PAGE_SIZE) {\n            let currentRightItems = this.rightItems;\n            let currentMoreItems = this.moreItems;\n            currentRightItems.push(...currentMoreItems.splice(0, RIGHT_SIDE_NEW_PAGE_SIZE));\n            this.rightItems$.next(currentRightItems);\n            this.moreItems$.next(currentMoreItems);\n        } else {\n            let currentRightItems = this.rightItems;\n            currentRightItems.push(...this.moreItems);\n            this.rightItems$.next(currentRightItems);\n            this.moreItems$.next([]);\n        }\n    }\n\n    public initializeCustomViewsOfView(view: View, viewConfigPath: string): void {\n        if (!view || this.customItemsInitialized || this.hiddenCustomItemsInitialized) return;\n\n        Object.entries(view.children).forEach(([key, childView]) => {\n            const childViewConfigPath: string = viewConfigPath + '/' + key;\n            this.resolveUriForChildViews(childViewConfigPath, childView);\n            this.resolveHiddenMenuItemFromChildViews(childViewConfigPath, childView);\n        });\n\n        this.resolveCustomViewsInRightSide();\n        this.resolveCustomViewsInLeftSide();\n\n        this.customItemsInitialized = true;\n        this.hiddenCustomItemsInitialized = true;\n    }\n\n    public switchOrder(): void {\n        this.itemsOrder = (this.itemsOrder + 1) % 2;\n        let multiplier = 1;\n        if (this.itemsOrder === MenuOrder.Descending) {\n            multiplier = -1;\n        }\n        let currentRightItems = this.rightItems;\n        let currentLeftItems = this.leftItems;\n        currentRightItems.sort((a, b) => multiplier * (a?.navigation as NavigationItem)?.title.localeCompare((b?.navigation as NavigationItem)?.title));\n        currentLeftItems.sort((a, b) => multiplier * (a?.navigation as NavigationItem)?.title.localeCompare((b?.navigation as NavigationItem)?.title));\n        this.rightItems$.next(currentRightItems);\n        this.leftItems$.next(currentLeftItems);\n    }\n\n    public isAscending(): boolean {\n        return this.itemsOrder === MenuOrder.Ascending;\n    }\n\n    protected loadLeftSide() {\n        if (this._uriService.isRoot(this._currentNode)) {\n            this._leftItems$.next([])\n            return;\n        }\n        this._leftLoading$.on();\n        this._uriService.getItemCaseByNodePath(this.currentNode.parent).subscribe(page => {\n            let childCases$;\n            let targetItem;\n            let orderedChildCaseIds;\n\n            if (page?.pagination?.totalElements === 0) {\n                childCases$ = of([]);\n            } else {\n                targetItem = page.content[0];\n                orderedChildCaseIds = DoubleDrawerUtils.extractChildCaseIds(targetItem);\n                childCases$ = this.getItemCasesByIdsInOnePage(orderedChildCaseIds).pipe(\n                    map(p => p.content),\n                );\n            }\n\n            childCases$.subscribe(result => {\n                result = result.map(folder => this.resolveItemCaseToNavigationItem(folder)).filter(i => !!i);\n                this._leftItems$.next(result.sort((a, b) => orderedChildCaseIds.indexOf(a.resource.stringId) - orderedChildCaseIds.indexOf(b.resource.stringId)));\n                this.resolveCustomViewsInLeftSide();\n                this._leftLoading$.off();\n                this.itemLoaded.emit({menu: 'left', items: this.leftItems});\n            }, error => {\n                this._log.error(error);\n                this._leftItems$.next([])\n                this.resolveCustomViewsInLeftSide();\n                this._leftLoading$.off();\n            });\n        }, error => {\n            this._log.error(error);\n            this._leftItems$.next([])\n            this.resolveCustomViewsInLeftSide();\n            this._leftLoading$.off();\n        });\n    }\n\n    protected loadRightSide() {\n        this._rightLoading$.on();\n        this._moreItems$.next([])\n        this._uriService.getItemCaseByNodePath(this.currentNode).subscribe(page => {\n            let childCases$;\n            let targetItem;\n            let orderedChildCaseIds;\n\n            if (page?.pagination?.totalElements === 0) {\n                childCases$ = of([]);\n            } else {\n                targetItem = page.content[0];\n                orderedChildCaseIds = DoubleDrawerUtils.extractChildCaseIds(targetItem);\n                childCases$ = this.getItemCasesByIdsInOnePage(orderedChildCaseIds).pipe(\n                    map(p => p.content),\n                );\n            }\n\n            childCases$.subscribe(result => {\n                result = (result as Case[]).sort((a, b) => orderedChildCaseIds.indexOf(a.stringId) - orderedChildCaseIds.indexOf(b.stringId));\n                if (result.length > RIGHT_SIDE_INIT_PAGE_SIZE) {\n                    const rawRightItems: Case[] = result.splice(0, RIGHT_SIDE_INIT_PAGE_SIZE);\n                    this._rightItems$.next(rawRightItems.map(folder => this.resolveItemCaseToNavigationItem(folder)).filter(i => !!i));\n                    this._moreItems$.next(result.map(folder => this.resolveItemCaseToNavigationItem(folder)).filter(i => !!i));\n                } else {\n                    this._rightItems$.next(result.map(folder => this.resolveItemCaseToNavigationItem(folder)).filter(i => !!i));\n                }\n                this.resolveCustomViewsInRightSide();\n                this._rightLoading$.off();\n                this.itemLoaded.emit({menu: 'right', items: this.rightItems});\n            }, error => {\n                this._log.error(error);\n                this._rightItems$.next([]);\n                this._moreItems$.next([]);\n                this.resolveCustomViewsInRightSide();\n                this._rightLoading$.off();\n            });\n        }, error => {\n            this._log.error(error);\n            this._rightItems$.next([]);\n            this._moreItems$.next([]);\n            this.resolveCustomViewsInRightSide();\n            this._rightLoading$.off();\n        });\n    }\n\n    protected getItemCasesByIdsInOnePage(caseIds: string[]): Observable<Page<Case>> {\n        return this.getItemCasesByIds(caseIds, 0, caseIds.length);\n    }\n\n    protected getItemCasesByIds(caseIds: string[], pageNumber: number, pageSize: string | number): Observable<Page<Case>> {\n        const searchBody: CaseSearchRequestBody = {\n            stringId: caseIds,\n            process: MENU_IDENTIFIERS.map(id => ({identifier: id} as PetriNetSearchRequest)),\n        };\n\n        let httpParams = new HttpParams()\n            .set(PaginationParams.PAGE_SIZE, pageSize)\n            .set(PaginationParams.PAGE_NUMBER, pageNumber);\n        return this._caseResourceService.searchCases(SimpleFilter.fromCaseQuery(searchBody), httpParams);\n    }\n\n    public resolveItemCaseToNavigationItem(itemCase: Case): NavigationItem | undefined {\n        if (DoubleDrawerUtils.representsRootNode(itemCase)) {\n            return;\n        }\n        const item: NavigationItem = {\n            access: {},\n            navigation: {\n                icon: itemCase.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_MENU_ICON)?.value || this.defaultViewIcon,\n                title: this.getTranslation(itemCase.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_MENU_NAME)?.value) || itemCase.title,\n            },\n            routing: {\n                path: this.getItemRoutingPath(itemCase),\n            },\n            id: itemCase.stringId,\n            resource: itemCase,\n        };\n        const resolvedRoles = DoubleDrawerUtils.resolveAccessRoles(itemCase, GroupNavigationConstants.ITEM_FIELD_ID_ALLOWED_ROLES);\n        const resolvedBannedRoles = DoubleDrawerUtils.resolveAccessRoles(itemCase, GroupNavigationConstants.ITEM_FIELD_ID_BANNED_ROLES);\n        if (!!resolvedRoles) item.access['role'] = resolvedRoles;\n        if (!!resolvedBannedRoles) item.access['bannedRole'] = resolvedBannedRoles;\n        if (!this._accessService.canAccessView(item, item.routingPath)) return;\n        return item;\n    }\n\n    protected resolveCustomViewsInLeftSide() {\n        if (!!this._currentNode?.parent && !!this._childCustomViews[this._currentNode.parent.uriPath]) {\n            let currentLeftItems = this._leftItems$.getValue();\n            currentLeftItems.push(...Object.values(this._childCustomViews[this._currentNode.parent.uriPath]));\n            this._leftItems$.next(currentLeftItems);\n        }\n    }\n\n    protected resolveCustomViewsInRightSide() {\n        if (!!this._currentNode && !!this._childCustomViews[this._currentNode.uriPath]) {\n            let currentRightItems = this._rightItems$.getValue();\n            currentRightItems.push(...Object.values(this._childCustomViews[this._currentNode.uriPath]));\n            this._rightItems$.next(currentRightItems);\n        }\n    }\n\n    protected resolveUriForChildViews(configPath: string, childView: View): void {\n        if (!childView.processUri) return;\n        if (!this._accessService.canAccessView(childView, configPath)) return;\n        if (!this._childCustomViews[childView.processUri]) {\n            this._childCustomViews[childView.processUri] = {};\n        }\n        this._childCustomViews[childView.processUri][configPath] = {\n            id: configPath,\n            ...childView,\n        };\n    }\n\n    protected resolveHiddenMenuItemFromChildViews(configPath: string, childView: View): void {\n        if (!childView.navigation) return;\n        if (!this._accessService.canAccessView(childView, configPath)) return;\n        if (!!((childView?.navigation as any)?.hidden)) {\n            let currentHiddenCustomItems = this._hiddenCustomItems$.getValue();\n            currentHiddenCustomItems.push({\n                id: configPath,\n                ...childView,\n            });\n            this._hiddenCustomItems$.next(currentHiddenCustomItems);\n        }\n    }\n\n    protected getTranslation(value: I18nFieldValue): string {\n        const locale = this._translateService.currentLang.split('-')[0];\n        return locale in value.translations ? value.translations[locale] : value.defaultValue;\n    }\n\n    public getItemRoutingPath(itemCase: Case) {\n        const taskId = DoubleDrawerUtils.findTaskIdInCase(itemCase, SETTINGS_TRANSITION_ID);\n        const url = this._dynamicRoutingService.route;\n        return `/${url}/${taskId}`;\n    }\n}\n"]}

package/esm2020/lib/navigation/navigation-double-drawer/util/double-drawer-utils.mjs

@@ -0,0 +1,43 @@
+import { GroupNavigationConstants } from "../../model/group-navigation-constants";
+export class DoubleDrawerUtils {
+    constructor() { }
+    static hasItemChildren(item) {
+        return item.resource?.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_HAS_CHILDREN)?.value;
+    }
+    static hasItemAutoOpenView(item) {
+        return item.resource?.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_IS_AUTO_SELECT)?.value;
+    }
+    static hasItemView(item) {
+        return item?.resource?.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_CONTAINS_FILTER)?.value;
+    }
+    static isItemAndNodeEqual(item, node) {
+        return item.resource?.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_NODE_PATH)?.value === node.uriPath;
+    }
+    static extractChildCaseIds(item) {
+        return item.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_CHILD_ITEM_IDS)?.value;
+    }
+    static representsRootNode(item) {
+        return item.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_NODE_PATH).value === '/';
+    }
+    static resolveAccessRoles(filter, roleType) {
+        const allowedRoles = filter.immediateData.find(f => f.stringId === roleType)?.options;
+        if (!allowedRoles || Object.keys(allowedRoles).length === 0)
+            return undefined;
+        const roles = [];
+        Object.keys(allowedRoles).forEach(combined => {
+            const parts = combined.split(':');
+            roles.push({
+                processId: parts[1],
+                roleId: parts[0],
+            });
+        });
+        return roles;
+    }
+    static isNodeCorrespondingToItem(node, item) {
+        return item.resource?.immediateData.find(f => f.stringId === GroupNavigationConstants.ITEM_FIELD_ID_NODE_PATH)?.value === node.uriPath;
+    }
+    static findTaskIdInCase(useCase, transId) {
+        return useCase.tasks.find(taskPair => taskPair.transition === transId).task;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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