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

package/lib/authorization/permission/access.service.d.ts

@@ -0,0 +1,40 @@
+import { RoleGuardService } from "../role/role-guard.service";
+import { AuthorityGuardService } from "../authority/authority-guard.service";
+import { GroupGuardService } from "../group/group-guard.service";
+import { ConfigurationService } from "../../configuration/configuration.service";
+import { View } from "../../../commons/schema";
+import { UserService } from '../../user/services/user.service';
+import * as i0 from "@angular/core";
+export declare class AccessService {
+    private _config;
+    private _userService;
+    private _roleGuard;
+    private _authorityGuard;
+    private _groupGuard;
+    constructor(_config: ConfigurationService, _userService: UserService, _roleGuard: RoleGuardService, _authorityGuard: AuthorityGuardService, _groupGuard: GroupGuardService);
+    /**
+     * @param view the view whose access permissions we want to check
+     * @param url URL to which the view maps. Is used only for error message generation
+     * @returns whether the user can access the provided view
+     */
+    canAccessView(view: View, url?: string): boolean;
+    /**
+     * @param view the view whose access permissions we want to check
+     * @param url URL to which the view maps. Is used only for error message generation
+     * @returns whether the user passes the role guard condition for accessing the specified view
+     */
+    passesRoleGuard(view: View, url: string): boolean;
+    /**
+     * @param view the view whose access permissions we want to check
+     * @returns whether the user passes the authority guard condition for accessing the specified view
+     */
+    passesAuthorityGuard(view: View): boolean;
+    /**
+     * @param view the view whose access permissions we want to check
+     * @param url URL to which the view maps. Is used only for error message generation
+     * @returns whether the user passes the role guard condition for accessing the specified view
+     */
+    passesGroupGuard(view: View, url: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccessService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccessService>;
+}

package/lib/authorization/public-api.d.ts

@@ -2,3 +2,4 @@ export * from './authority/authority-guard.service';
 export * from './role/role-guard.service';
 export * from './group/group-guard.service';
 export * from './permission/permission.service';
+export * from './permission/access.service';

package/lib/filter/models/case-search-request-body.d.ts

@@ -59,6 +59,7 @@ export interface CaseSearchRequestBody {
      * If more than one group ID is specified, the returned cases are instances of one of the groups.
      */
     group?: string | Array<string>;
+    uriNodeId?: string;
 }
 /**
  * Queries cases that are instances of a specific PetriNet

package/lib/header/abstract-header-service.d.ts

@@ -13,12 +13,14 @@ import { LoadingEmitter } from '../utility/loading-emitter';
 import { SortDirection } from '@angular/material/sort';
 import { ViewIdService } from '../user/services/view-id.service';
 import { Net } from '../process/net';
+import { OverflowService } from './services/overflow.service';
 import * as i0 from "@angular/core";
 export declare abstract class AbstractHeaderService implements OnDestroy {
     protected _headerType: HeaderType;
     protected _preferences: UserPreferenceService;
-    private _viewIdService;
     protected _logger: LoggerService;
+    private _viewIdService;
+    protected _overflowService: OverflowService;
     static readonly DEFAULT_HEADER_COUNT = 5;
     static readonly DEFAULT_HEADER_RESPONSIVITY = true;
     protected _headerColumnCount$: BehaviorSubject<number>;
@@ -31,7 +33,7 @@ export declare abstract class AbstractHeaderService implements OnDestroy {
     private _initializedCount;
     loading: LoadingEmitter;
     fieldsGroup: Array<FieldsGroup>;
-    protected constructor(_headerType: HeaderType, _preferences: UserPreferenceService, _viewIdService: ViewIdService, _logger: LoggerService);
+    protected constructor(_headerType: HeaderType, _preferences: UserPreferenceService, _logger: LoggerService, _viewIdService: ViewIdService, _overflowService: OverflowService);
     /**
      * Provides Observable for all changes in header
      */
@@ -39,6 +41,7 @@ export declare abstract class AbstractHeaderService implements OnDestroy {
     get selectedHeaders$(): Observable<Array<HeaderColumn>>;
     get headerState(): HeaderStateInterface;
     get headerType(): HeaderType;
+    get overflowMode(): boolean;
     get headerColumnCount(): number;
     set headerColumnCount(maxColumns: number);
     get headerColumnCount$(): Observable<number>;
@@ -131,6 +134,6 @@ export declare abstract class AbstractHeaderService implements OnDestroy {
     protected abstract saveState(): any;
     protected abstract saveNewState(): any;
     protected abstract restoreLastState(): any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractHeaderService, [null, null, { optional: true; }, null]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractHeaderService, [null, null, null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AbstractHeaderService>;
 }

package/lib/header/abstract-header.component.d.ts

@@ -13,7 +13,7 @@ export declare abstract class AbstractHeaderComponent implements OnInit, OnDestr
     protected _translate: TranslateService;
     protected _overflowService: OverflowService;
     protected readonly DEFAULT_COLUMN_COUNT = 6;
-    protected readonly DEFAULT_COLUMN_WIDTH = 190;
+    protected readonly DEFAULT_COLUMN_WIDTH = 220;
     type: HeaderType;
     hideEditMode: boolean;
     headerService: AbstractHeaderService;

package/lib/header/task-header/task-header.service.d.ts

@@ -6,16 +6,17 @@ import { LoggerService } from '../../logger/services/logger.service';
 import { Subscription } from 'rxjs';
 import { ViewIdService } from '../../user/services/view-id.service';
 import { AllowedNetsService } from '../../allowed-nets/services/allowed-nets.service';
+import { OverflowService } from '../services/overflow.service';
 import * as i0 from "@angular/core";
 export declare class TaskHeaderService extends AbstractHeaderService implements OnDestroy {
     protected _allowedNetsService: AllowedNetsService;
     protected subAllowedNets: Subscription;
-    constructor(_allowedNetsService: AllowedNetsService, preferences: UserPreferenceService, logger: LoggerService, viewIdService: ViewIdService, naeDefaultHeaders: Array<string>);
+    constructor(_allowedNetsService: AllowedNetsService, preferences: UserPreferenceService, logger: LoggerService, viewIdService: ViewIdService, overflowService: OverflowService, naeDefaultHeaders: Array<string>);
     protected createMetaHeaders(): Array<HeaderColumn>;
     protected saveState(): void;
     protected saveNewState(): void;
     protected restoreLastState(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TaskHeaderService, [null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskHeaderService, [null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TaskHeaderService>;
 }

package/lib/header/workflow-header/workflow-header.service.d.ts

@@ -4,14 +4,15 @@ import { HeaderColumn } from '../models/header-column';
 import { UserPreferenceService } from '../../user/services/user-preference.service';
 import { LoggerService } from '../../logger/services/logger.service';
 import { ViewIdService } from '../../user/services/view-id.service';
+import { OverflowService } from '../services/overflow.service';
 import * as i0 from "@angular/core";
 export declare class WorkflowHeaderService extends AbstractHeaderService implements OnDestroy {
-    constructor(preferences: UserPreferenceService, viewIdService: ViewIdService, logger: LoggerService);
+    constructor(preferences: UserPreferenceService, logger: LoggerService, viewIdService: ViewIdService, overflowService: OverflowService);
     protected createMetaHeaders(): Array<HeaderColumn>;
     ngOnDestroy(): void;
     protected saveState(): void;
     protected saveNewState(): void;
     protected restoreLastState(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowHeaderService, [null, { optional: true; }, null]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowHeaderService, [null, null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WorkflowHeaderService>;
 }

package/lib/navigation/model/uri-resource.d.ts

@@ -0,0 +1,15 @@
+export interface UriNodeResource {
+    id: string;
+    uriPath: string;
+    name: string;
+    parentId: string;
+    parent: UriNodeResource;
+    childrenId: Set<string>;
+    children: Set<UriNodeResource>;
+    level: number;
+    contentTypes: Set<UriContentType>;
+}
+export declare enum UriContentType {
+    PROCESS = 0,
+    CASE = 1
+}

package/lib/navigation/navigation-double-drawer/abstract-navigation-double-drawer.d.ts

@@ -0,0 +1,138 @@
+import { OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { Observable, Subscription } from 'rxjs';
+import { ActivatedRoute, Router } from '@angular/router';
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { LanguageService } from '../../translate/language.service';
+import { UserService } from '../../user/services/user.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { UriService } from '../service/uri.service';
+import { UriNodeResource } from '../model/uri-resource';
+import { Case } from '../../resources/interface/case';
+import { DynamicNavigationRouteProviderService } from '../../routing/dynamic-navigation-route-provider/dynamic-navigation-route-provider.service';
+import { LoadingEmitter } from "../../utility/loading-emitter";
+import { MatDrawerMode } from "@angular/material/sidenav";
+import { ResizeEvent } from "angular-resizable-element";
+import { User } from "../../user/models/user";
+import { RoleAccess, View } from "../../../commons/schema";
+import { AccessService } from "../../authorization/permission/access.service";
+import * as i0 from "@angular/core";
+export interface ConfigDoubleMenu {
+    mode: MatDrawerMode;
+    opened: boolean;
+    disableClose: boolean;
+    width: number;
+}
+export interface ViewNavigationItem extends View {
+    id: string;
+    resource?: Case;
+}
+export declare const FILTER_IDENTIFIERS: string[];
+export declare const FILTER_VIEW_TASK_TRANSITION_ID = "view";
+export declare abstract class AbstractNavigationDoubleDrawerComponent implements OnInit, OnDestroy {
+    protected _router: Router;
+    protected _activatedRoute: ActivatedRoute;
+    protected _breakpoint: BreakpointObserver;
+    protected _languageService: LanguageService;
+    protected _userService: UserService;
+    protected _accessService: AccessService;
+    protected _log: LoggerService;
+    protected _config: ConfigurationService;
+    protected _uriService: UriService;
+    protected _dynamicRoutingService: DynamicNavigationRouteProviderService;
+    portalLeftMenu: TemplateRef<any>;
+    portalRightMenu: TemplateRef<any>;
+    imageRouterLink: string;
+    imageAlt: string;
+    image: string;
+    profileRouterLink: string;
+    includeUser: boolean;
+    includeLanguage: boolean;
+    includeMoreMenu: boolean;
+    allClosable: boolean;
+    folderIcon: string;
+    openedFolderIcon: string;
+    filterIcon: string;
+    foldersCategoryName: string;
+    viewsCategoryName: string;
+    /**
+     * Array of folder nodes on left side
+     * */
+    leftNodes: Array<UriNodeResource>;
+    /**
+     * Array of folder nodes on right side
+     * */
+    rightNodes: Array<UriNodeResource>;
+    /**
+     * Processes that can be displayed under folders on right side menu
+     * */
+    views: Array<ViewNavigationItem>;
+    moreMenuItems: Array<ViewNavigationItem>;
+    protected _leftNodesSubscription: Subscription;
+    protected _rightNodesSubscription: Subscription;
+    protected _filtersSubscription: Subscription;
+    protected _breakpointSubscription: Subscription;
+    protected _rootSubscription: Subscription;
+    protected _currentNodeSubscription: Subscription;
+    /**
+     * Currently display uri
+     * Siblings of the node are on the left, children are on the right
+     */
+    currentNode: UriNodeResource;
+    leftLoading$: LoadingEmitter;
+    rightLoading$: LoadingEmitter;
+    protected _configLeftMenu: ConfigDoubleMenu;
+    protected _configRightMenu: ConfigDoubleMenu;
+    protected _childCustomViews: {
+        [uri: string]: {
+            [key: string]: ViewNavigationItem;
+        };
+    };
+    protected constructor(_router: Router, _activatedRoute: ActivatedRoute, _breakpoint: BreakpointObserver, _languageService: LanguageService, _userService: UserService, _accessService: AccessService, _log: LoggerService, _config: ConfigurationService, _uriService: UriService, _dynamicRoutingService: DynamicNavigationRouteProviderService);
+    ngOnInit(): void;
+    protected resolveUriForChildViews(configPath: string, childView: View): void;
+    protected resolveHiddenMenuItemFromChildViews(configPath: string, childView: View): void;
+    ngOnDestroy(): void;
+    get configLeftMenu(): ConfigDoubleMenu;
+    get configRightMenu(): ConfigDoubleMenu;
+    toggleMenu(): void;
+    toggleLeftMenu(): void;
+    toggleRightMenu(): void;
+    protected resolveLayout(isLargeScreen: boolean): void;
+    getLang(): string;
+    logout(): void;
+    get user(): User;
+    get canGoBackLoading$(): Observable<boolean>;
+    /**
+     * On home click, the current level is set to 0, and current parent is
+     * set to root node.
+     * */
+    onHomeClick(): void;
+    /**
+     * 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(): void;
+    onNodeClick(node: UriNodeResource): void;
+    protected loadLeftSide(): void;
+    protected loadRightSide(): void;
+    protected resolveFilterCaseToViewNavigationItem(filter: Case): ViewNavigationItem | undefined;
+    protected resolveAccessRoles(filter: Case): Array<RoleAccess> | undefined;
+    protected getFilterRoutingPath(filterCase: Case): string;
+    protected compareStrings(a: string, b: string): number;
+    /**
+     * Function to check whether the back button should be displayed
+     * @returns boolean if the back button should be displayed
+     * */
+    isOnZeroLevel(): boolean;
+    isLeftNodesEmpty(): boolean;
+    isRightNodesEmpty(): boolean;
+    isViewsEmpty(): boolean;
+    uriNodeTrackBy(index: number, node: UriNodeResource): string;
+    viewsTrackBy(index: number, view: ViewNavigationItem): string;
+    onResizeEvent(event: ResizeEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractNavigationDoubleDrawerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractNavigationDoubleDrawerComponent, "ncc-abstract-navigation-double-drawer", never, { "portalLeftMenu": "portalLeftMenu"; "portalRightMenu": "portalRightMenu"; "imageRouterLink": "imageRouterLink"; "imageAlt": "imageAlt"; "image": "image"; "profileRouterLink": "profileRouterLink"; "includeUser": "includeUser"; "includeLanguage": "includeLanguage"; "includeMoreMenu": "includeMoreMenu"; "allClosable": "allClosable"; "folderIcon": "folderIcon"; "openedFolderIcon": "openedFolderIcon"; "filterIcon": "filterIcon"; "foldersCategoryName": "foldersCategoryName"; "viewsCategoryName": "viewsCategoryName"; }, {}, never, never>;
+}

package/lib/navigation/navigation-tree/abstract-navigation-tree.component.d.ts

@@ -7,15 +7,13 @@ import { MatTreeNestedDataSource } from '@angular/material/tree';
 import { Observable, ReplaySubject } from 'rxjs';
 import { LoggerService } from '../../logger/services/logger.service';
 import { UserService } from '../../user/services/user.service';
-import { RoleGuardService } from '../../authorization/role/role-guard.service';
-import { AuthorityGuardService } from '../../authorization/authority/authority-guard.service';
-import { GroupGuardService } from '../../authorization/group/group-guard.service';
 import { AbstractNavigationResizableDrawerComponent } from '../navigation-drawer/abstract-navigation-resizable-drawer.component';
 import { ActiveGroupService } from '../../groups/services/active-group.service';
 import { TaskResourceService } from '../../resources/engine-endpoint/task-resource.service';
 import { DataGroup } from '../../resources/interface/data-groups';
 import { LanguageService } from '../../translate/language.service';
 import { DynamicNavigationRouteProviderService } from '../../routing/dynamic-navigation-route-provider/dynamic-navigation-route-provider.service';
+import { AccessService } from "../../authorization/permission/access.service";
 import * as i0 from "@angular/core";
 export interface NavigationNode {
     name: string;
@@ -30,9 +28,7 @@ export declare abstract class AbstractNavigationTreeComponent extends AbstractNa
     protected _router: Router;
     protected _log: LoggerService;
     protected _userService: UserService;
-    protected _roleGuard: RoleGuardService;
-    protected _authorityGuard: AuthorityGuardService;
-    protected _groupGuard: GroupGuardService;
+    protected _accessService: AccessService;
     protected _activeGroupService: ActiveGroupService;
     protected _taskResourceService: TaskResourceService;
     protected _languageService: LanguageService;
@@ -48,7 +44,7 @@ export declare abstract class AbstractNavigationTreeComponent extends AbstractNa
     private _groupNavNodesCount;
     treeControl: NestedTreeControl<NavigationNode>;
     dataSource: MatTreeNestedDataSource<NavigationNode>;
-    protected constructor(_config: ConfigurationService, _router: Router, _log: LoggerService, _userService: UserService, _roleGuard: RoleGuardService, _authorityGuard: AuthorityGuardService, _groupGuard: GroupGuardService, _activeGroupService: ActiveGroupService, _taskResourceService: TaskResourceService, _languageService: LanguageService, _navigationRouteProvider: DynamicNavigationRouteProviderService);
+    protected constructor(_config: ConfigurationService, _router: Router, _log: LoggerService, _userService: UserService, _accessService: AccessService, _activeGroupService: ActiveGroupService, _taskResourceService: TaskResourceService, _languageService: LanguageService, _navigationRouteProvider: DynamicNavigationRouteProviderService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     hasChild(_: number, node: NavigationNode): boolean;
@@ -83,29 +79,6 @@ export declare abstract class AbstractNavigationTreeComponent extends AbstractNa
      */
     protected appendRouteSegment(parentUrl: string, routeSegment: string): string;
     protected resolveLevels(nodes: Array<NavigationNode>, parentLevel?: number): void;
-    /**
-     * @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
-     */
-    protected canAccessView(view: View, url: string): boolean;
-    /**
-     * @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
-     */
-    protected passesRoleGuard(view: View, url: string): boolean;
-    /**
-     * @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
-     */
-    protected passesAuthorityGuard(view: View): boolean;
-    /**
-     * @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
-     */
-    protected passesGroupGuard(view: View, url: string): boolean;
     protected resolveChange(): void;
     /**
      * @returns `true` if the layout of the provided {@link View} node's name indicates it is a

package/lib/navigation/public-api.d.ts

@@ -1,13 +1,17 @@
 export * from './quick-panel/public-api';
 export * from './navigation-tree/abstract-navigation-tree.component';
 export * from './navigation-drawer/abstract-navigation-drawer.component';
+export * from './navigation-double-drawer/abstract-navigation-double-drawer';
 export * from './navigation-rail/abstract-navigation-rail.component';
 export * from './group-navigation-component-resolver/abstract-group-navigation-component-resolver.component';
 export * from './group-navigation-component-resolver/group-navigation-component-resolver.service';
 export * from './utility/filter-extraction.service';
+export * from './service/uri.service';
+export * from './service/uri-resource.service';
 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';
+export * from './model/uri-resource';
 export * from './utility/navigation-item-task-utility-methods';
 export * from './group-navigation-component-resolver/group-navigation-view-id-segment-factory';

package/lib/navigation/service/uri-resource.service.d.ts

@@ -0,0 +1,18 @@
+import { AbstractResourceService } from '../../resources/abstract-endpoint/abstract-resource.service';
+import { ResourceProvider } from '../../resources/resource-provider.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { UriNodeResource } from '../model/uri-resource';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service for accessing backend resource to resolve URI objects
+ * */
+export declare class UriResourceService extends AbstractResourceService {
+    constructor(provider: ResourceProvider, configService: ConfigurationService);
+    getRoot(): Observable<UriNodeResource>;
+    getByLevel(level: number): Observable<Array<UriNodeResource>>;
+    getNodesByParent(parentId: string): Observable<Array<UriNodeResource>>;
+    getNodeByUri(uriPath: string): Observable<UriNodeResource>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UriResourceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UriResourceService>;
+}

package/lib/navigation/service/uri.service.d.ts

@@ -0,0 +1,75 @@
+import { OnDestroy } from '@angular/core';
+import { LoggerService } from '../../logger/services/logger.service';
+import { UriResourceService } from './uri-resource.service';
+import { Observable } from 'rxjs';
+import { UriNodeResource } from '../model/uri-resource';
+import { Case } from '../../resources/interface/case';
+import { CaseResourceService } from '../../resources/engine-endpoint/case-resource.service';
+import { ActiveGroupService } from '../../groups/services/active-group.service';
+import { LoadingEmitter } from "../../utility/loading-emitter";
+import * as i0 from "@angular/core";
+/**
+ * Service for managing URIs
+ * */
+export declare class UriService implements OnDestroy {
+    protected _logger: LoggerService;
+    protected _resourceService: UriResourceService;
+    protected _caseResourceService: CaseResourceService;
+    protected _activeGroupService: ActiveGroupService;
+    private _rootNode;
+    private readonly _rootLoading$;
+    private readonly _parentLoading$;
+    private readonly _activeNode$;
+    constructor(_logger: LoggerService, _resourceService: UriResourceService, _caseResourceService: CaseResourceService, _activeGroupService: ActiveGroupService);
+    ngOnDestroy(): void;
+    get root(): UriNodeResource;
+    get rootLoaded$(): LoadingEmitter;
+    isRoot(node: UriNodeResource): boolean;
+    get activeNode(): UriNodeResource;
+    set activeNode(node: UriNodeResource);
+    get activeNode$(): Observable<UriNodeResource>;
+    get parentNodeLoading$(): Observable<boolean>;
+    /**
+     * Loads root ID into variable.
+     * When root node is loaded and active node is not set yet the root node is set as active node
+     * */
+    private loadRoot;
+    reset(): UriNodeResource;
+    /**
+     * Get uri node by uri path.
+     * @param path
+     */
+    getNodeByPath(path: string): Observable<UriNodeResource>;
+    /**
+     * Get child nodes of provides node.
+     * @param node parent node
+     */
+    getChildNodes(node?: UriNodeResource): Observable<Array<UriNodeResource>>;
+    /**
+     * Get cases under uri node
+     * @param node parent node of cases
+     * @param processIdentifiers optional search filter for process identifier to get only cases from the process
+     */
+    getCasesOfNode(node?: UriNodeResource, processIdentifiers?: Array<string>): Observable<Array<Case>>;
+    /**
+     * Get siblings node of the provided node
+     * @param node siblings node
+     */
+    getSiblingsOfNode(node?: UriNodeResource): Observable<Array<UriNodeResource>>;
+    /**
+     * Get nodes on the same uri level starting from 0. Root node is no 0 level.
+     * @param level
+     * @param parent optional parameter to filter nodes with common parent
+     */
+    getNodesOnLevel(level: number, parent?: UriNodeResource): Observable<Array<UriNodeResource>>;
+    resolveParentPath(node?: UriNodeResource): string;
+    private capitalizeNames;
+    /**
+     *  /netgrif/nae_system/processes/... => Netgrif -> Nae Systems -> Processes
+     * @param node
+     * @private
+     */
+    private capitalizeName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UriService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UriService>;
+}

package/lib/panel/abstract/panel-with-immediate-data.d.ts

@@ -4,11 +4,14 @@ import { OnDestroy } from '@angular/core';
 import { FeaturedValue } from './featured-value';
 import { CurrencyPipe } from '@angular/common';
 import { ImmediateData } from '../../resources/interface/immediate-data';
+import { OverflowService } from '../../header/services/overflow.service';
 import * as i0 from "@angular/core";
 export declare abstract class AbstractPanelWithImmediateDataComponent extends AbstractPanelWithHeaderBindingComponent implements OnDestroy {
     protected _translate: TranslateService;
     protected _currencyPipe: CurrencyPipe;
-    protected constructor(_translate: TranslateService, _currencyPipe: CurrencyPipe);
+    protected _overflowService: OverflowService;
+    protected constructor(_translate: TranslateService, _currencyPipe: CurrencyPipe, _overflowService: OverflowService);
+    get overflowMode(): boolean;
     ngOnDestroy(): void;
     protected parseImmediateValue(immediate: ImmediateData): FeaturedValue;
     protected formatCurrencyPipe(value: any, code: string, fraction: number, locale: string, type: string): {

package/lib/panel/abstract-panel.component.d.ts

@@ -1,11 +1,16 @@
 import { AfterViewInit, EventEmitter, OnDestroy, TemplateRef } from '@angular/core';
 import { MatExpansionPanel } from '@angular/material/expansion';
 import { CaseListFontColorService } from '../utility/service/case-list-font-color.service';
+import { ActivatedRoute, Params } from '@angular/router';
 import * as i0 from "@angular/core";
 export declare abstract class AbstractPanelComponent implements AfterViewInit, OnDestroy {
     protected _caseListFontColorService: CaseListFontColorService;
+    protected _activatedRoute?: ActivatedRoute;
+    config: Params;
     expansionDisabled: boolean;
     preventExpand: boolean;
+    preventCollapse: boolean;
+    hidePanelHeader: boolean;
     panelHeader: TemplateRef<object>;
     panelContent: TemplateRef<object>;
     first: boolean;
@@ -14,13 +19,14 @@ export declare abstract class AbstractPanelComponent implements AfterViewInit, O
     stopLoading: EventEmitter<object>;
     getExpansionPanelRef: EventEmitter<MatExpansionPanel>;
     matExpansionPanel: any;
-    protected constructor(_caseListFontColorService: CaseListFontColorService);
+    protected constructor(_caseListFontColorService: CaseListFontColorService, _activatedRoute?: ActivatedRoute);
     ngOnDestroy(): void;
     ngAfterViewInit(): void;
     emitExpand(): void;
     emitCollapse(): void;
     expandPanel(): void;
+    showPanelHeader(): boolean;
     getCaseFontColor(): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractPanelComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractPanelComponent, "ncc-abstract-panel", never, { "expansionDisabled": "expansionDisabled"; "preventExpand": "preventExpand"; "panelHeader": "panelHeader"; "panelContent": "panelContent"; "first": "first"; "last": "last"; "caseColor": "caseColor"; }, { "stopLoading": "stopLoading"; "getExpansionPanelRef": "getExpansionPanelRef"; }, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractPanelComponent, "ncc-abstract-panel", never, { "expansionDisabled": "expansionDisabled"; "preventExpand": "preventExpand"; "preventCollapse": "preventCollapse"; "hidePanelHeader": "hidePanelHeader"; "panelHeader": "panelHeader"; "panelContent": "panelContent"; "first": "first"; "last": "last"; "caseColor": "caseColor"; }, { "stopLoading": "stopLoading"; "getExpansionPanelRef": "getExpansionPanelRef"; }, never, never>;
 }

package/lib/panel/configuration/config-params.d.ts

@@ -0,0 +1,3 @@
+export declare enum ConfigParams {
+    PANEL_HEADER = "panelHeader"
+}

package/lib/panel/public-api.d.ts

@@ -8,7 +8,10 @@ export * from './abstract/tabbed-virtual-scroll.component';
 export * from './immediate/abstract-immediate-filter-text.component';
 export * from './immediate/abstract-immediate-filter-text-content.component';
 export * from './panel-item/abstract-panel-item.component';
+export * from './task-panel-single/abstract-single-task.component';
 export * from './task-panel-list/task-panel-data/task-panel-data';
 export * from './task-panel/models/disable-functions';
 export * from './abstract/featured-value';
 export * from './immediate/model/filter-text-injection-token';
+export * from './task-panel/models/task-panel-context';
+export * from './configuration/config-params';

package/lib/panel/task-panel/abstract-task-panel.component.d.ts

@@ -1,4 +1,4 @@
-import { AfterViewInit, EventEmitter, OnDestroy, OnInit, Type } from '@angular/core';
+import { AfterViewInit, EventEmitter, OnDestroy, OnInit, TemplateRef, Type } from '@angular/core';
 import { MatExpansionPanel } from '@angular/material/expansion';
 import { ComponentPortal } from '@angular/cdk/portal';
 import { TaskContentService } from '../../task-content/services/task-content.service';
@@ -26,6 +26,8 @@ import { FeaturedValue } from '../abstract/featured-value';
 import { CurrencyPipe } from '@angular/common';
 import { PermissionService } from '../../authorization/permission/permission.service';
 import { ChangedFieldsService } from '../../changed-fields/services/changed-fields.service';
+import { TaskPanelContext } from './models/task-panel-context';
+import { OverflowService } from '../../header/services/overflow.service';
 import * as i0 from "@angular/core";
 export declare abstract class AbstractTaskPanelComponent extends AbstractPanelWithImmediateDataComponent implements OnInit, AfterViewInit, OnDestroy {
     protected _taskContentService: TaskContentService;
@@ -58,6 +60,11 @@ export declare abstract class AbstractTaskPanelComponent extends AbstractPanelWi
     first: boolean;
     last: boolean;
     responsiveBody: boolean;
+    preventCollapse: boolean;
+    hidePanelHeader: boolean;
+    actionButtonTemplates: Array<TemplateRef<any>>;
+    actionRowJustifyContent: 'space-between' | 'flex-start' | 'flex-end' | 'center' | 'space-around' | 'initial' | 'start' | 'end' | 'left' | 'right' | 'revert' | 'inherit' | 'unset';
+    thisContext: TaskPanelContext;
     set forceLoadDataOnOpen(force: boolean);
     textEllipsis: boolean;
     /**
@@ -72,7 +79,7 @@ export declare abstract class AbstractTaskPanelComponent extends AbstractPanelWi
     protected _subTaskData: Subscription;
     protected _subPanelUpdate: Subscription;
     protected _taskDisableButtonFunctions: DisableButtonFuntions;
-    protected constructor(_taskContentService: TaskContentService, _log: LoggerService, _taskViewService: TaskViewService, _paperView: PaperViewService, _taskEventService: TaskEventService, _assignTaskService: AssignTaskService, _delegateTaskService: DelegateTaskService, _cancelTaskService: CancelTaskService, _finishTaskService: FinishTaskService, _taskState: TaskRequestStateService, _taskDataService: TaskDataService, _assignPolicyService: AssignPolicyService, _callChain: CallChainService, _taskOperations: SubjectTaskOperations, _disableFunctions: DisableButtonFuntions, _translate: TranslateService, _currencyPipe: CurrencyPipe, _changedFieldsService: ChangedFieldsService, _permissionService: PermissionService);
+    protected constructor(_taskContentService: TaskContentService, _log: LoggerService, _taskViewService: TaskViewService, _paperView: PaperViewService, _taskEventService: TaskEventService, _assignTaskService: AssignTaskService, _delegateTaskService: DelegateTaskService, _cancelTaskService: CancelTaskService, _finishTaskService: FinishTaskService, _taskState: TaskRequestStateService, _taskDataService: TaskDataService, _assignPolicyService: AssignPolicyService, _callChain: CallChainService, _taskOperations: SubjectTaskOperations, _disableFunctions: DisableButtonFuntions, _translate: TranslateService, _currencyPipe: CurrencyPipe, _changedFieldsService: ChangedFieldsService, _permissionService: PermissionService, overflowService: OverflowService);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     protected abstract createContentPortal(): void;
@@ -103,6 +110,6 @@ export declare abstract class AbstractTaskPanelComponent extends AbstractPanelWi
     protected getFeaturedMetaValue(selectedHeader: HeaderColumn): FeaturedValue;
     protected getFeaturedImmediateValue(selectedHeader: HeaderColumn): FeaturedValue;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTaskPanelComponent, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }, null, null, null, null]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractTaskPanelComponent, "ncc-abstract-legal-notice", never, { "panelContentComponent": "panelContentComponent"; "selectedHeaders$": "selectedHeaders$"; "first": "first"; "last": "last"; "responsiveBody": "responsiveBody"; "forceLoadDataOnOpen": "forceLoadDataOnOpen"; "textEllipsis": "textEllipsis"; "taskPanelData": "taskPanelData"; }, { "taskEvent": "taskEvent"; "panelRefOutput": "panelRefOutput"; }, never, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTaskPanelComponent, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractTaskPanelComponent, "ncc-abstract-legal-notice", never, { "panelContentComponent": "panelContentComponent"; "selectedHeaders$": "selectedHeaders$"; "first": "first"; "last": "last"; "responsiveBody": "responsiveBody"; "preventCollapse": "preventCollapse"; "hidePanelHeader": "hidePanelHeader"; "actionButtonTemplates": "actionButtonTemplates"; "actionRowJustifyContent": "actionRowJustifyContent"; "forceLoadDataOnOpen": "forceLoadDataOnOpen"; "textEllipsis": "textEllipsis"; "taskPanelData": "taskPanelData"; }, { "taskEvent": "taskEvent"; "panelRefOutput": "panelRefOutput"; }, never, never>;
 }

package/lib/panel/task-panel/models/task-panel-context.d.ts

@@ -0,0 +1,19 @@
+export interface TaskPanelContext {
+    canAssign: () => boolean;
+    assign: () => void;
+    getAssignTitle: () => string;
+    delegate: () => void;
+    getDelegateTitle: () => string;
+    canReassign: () => boolean;
+    canCancel: () => boolean;
+    cancel: () => void;
+    getCancelTitle: () => string;
+    canFinish: () => boolean;
+    finish: () => void;
+    getFinishTitle: () => string;
+    canCollapse: () => boolean;
+    collapse: () => void;
+    canDisable: (arg: string) => boolean;
+    canDo: (arg: string) => boolean;
+    isLoading: () => boolean;
+}