@netgrif/components-core 6.0.1

package/esm2015/lib/user/services/user-preference.service.js

@@ -0,0 +1,152 @@
+import { Injectable } from '@angular/core';
+import { UserService } from './user.service';
+import { UserResourceService } from '../../resources/engine-endpoint/user-resource.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { Subject } from 'rxjs';
+import { TranslateService } from '@ngx-translate/core';
+import { debounceTime } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./user.service";
+import * as i2 from "../../resources/engine-endpoint/user-resource.service";
+import * as i3 from "../../logger/services/logger.service";
+import * as i4 from "../../snack-bar/services/snack-bar.service";
+import * as i5 from "@ngx-translate/core";
+const DRAWER_DEFAULT_WIDTH = 200;
+const DRAWER_DEBOUNCE = 1000;
+export class UserPreferenceService {
+    constructor(_userService, _userResourceService, _logger, _snackbar, _translate) {
+        this._userService = _userService;
+        this._userResourceService = _userResourceService;
+        this._logger = _logger;
+        this._snackbar = _snackbar;
+        this._translate = _translate;
+        this._preferences = this._emptyPreferences();
+        this._preferencesChanged$ = new Subject();
+        this._drawerWidthChanged$ = new Subject();
+        this._anonym = false;
+        this._sub = this._userService.user$.subscribe(loggedUser => {
+            if (loggedUser && loggedUser.id !== '') {
+                this._userResourceService.getPreferences().subscribe(prefs => {
+                    this._preferences = this._emptyPreferences();
+                    Object.assign(this._preferences, prefs);
+                    this._preferencesChanged$.next();
+                });
+            }
+            else {
+                this._preferences = this._emptyPreferences();
+                this._preferencesChanged$.next();
+            }
+        });
+        this._subAnonym = this._userService.anonymousUser$.subscribe(loggedUser => {
+            if (loggedUser && loggedUser.id !== '') {
+                this._userResourceService.getPublicPreferences().subscribe(prefs => {
+                    this._preferences = this._emptyPreferences();
+                    Object.assign(this._preferences, prefs);
+                    this._preferencesChanged$.next();
+                    this._anonym = true;
+                });
+            }
+            else {
+                this._preferences = this._emptyPreferences();
+                this._preferencesChanged$.next();
+                this._anonym = false;
+            }
+        });
+        this._drawerWidthChanged$.asObservable().pipe(debounceTime(DRAWER_DEBOUNCE)).subscribe(newWidth => {
+            this.drawerWidth = newWidth;
+        });
+    }
+    ngOnDestroy() {
+        this._sub.unsubscribe();
+        this._preferencesChanged$.complete();
+    }
+    setTaskFilters(viewId, value) {
+        this._preferences.taskFilters[viewId] = value;
+        this._savePreferences();
+    }
+    getTaskFilters(viewId) {
+        return this._preferences.taskFilters[viewId];
+    }
+    setCaseFilters(viewId, value) {
+        this._preferences.caseFilters[viewId] = value;
+        this._savePreferences();
+    }
+    getCaseFilters(viewId) {
+        return this._preferences.caseFilters[viewId];
+    }
+    setHeaders(viewId, value) {
+        this._preferences.headers[viewId] = value;
+        this._savePreferences();
+    }
+    getHeaders(viewId) {
+        return this._preferences.headers[viewId];
+    }
+    setLocale(locale) {
+        this._preferences.locale = locale;
+        this._savePreferences();
+    }
+    getLocale() {
+        return this._preferences.locale;
+    }
+    set drawerWidth(drawerWidth) {
+        this._preferences.drawerWidth = drawerWidth;
+        this._savePreferences();
+    }
+    get drawerWidth() {
+        return this._preferences.drawerWidth;
+    }
+    get preferencesChanged$() {
+        return this._preferencesChanged$.asObservable();
+    }
+    _savePreferences() {
+        if (!this._anonym) {
+            this._userResourceService.setPreferences(this._preferences).subscribe(resultMessage => {
+                this.resultMessage(resultMessage);
+            });
+        }
+        else {
+            this._userResourceService.setPublicPreferences(this._preferences).subscribe(resultMessage => {
+                this.resultMessage(resultMessage);
+            });
+        }
+    }
+    resultMessage(resultMessage) {
+        if (typeof resultMessage.success === 'string') {
+            this._snackbar.openSuccessSnackBar(this._translate.instant('preferences.snackbar.saveSuccess'));
+        }
+        else {
+            this._snackbar.openErrorSnackBar(this._translate.instant('preferences.snackbar.saveFailure'));
+            this._logger.error('User preferences failed to save', resultMessage);
+        }
+    }
+    _emptyPreferences() {
+        return {
+            drawerWidth: DRAWER_DEFAULT_WIDTH,
+            headers: {},
+            caseFilters: {},
+            taskFilters: {}
+        };
+    }
+}
+UserPreferenceService.ctorParameters = () => [
+    { type: UserService },
+    { type: UserResourceService },
+    { type: LoggerService },
+    { type: SnackBarService },
+    { type: TranslateService }
+];
+UserPreferenceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserPreferenceService_Factory() { return new UserPreferenceService(i0.ɵɵinject(i1.UserService), i0.ɵɵinject(i2.UserResourceService), i0.ɵɵinject(i3.LoggerService), i0.ɵɵinject(i4.SnackBarService), i0.ɵɵinject(i5.TranslateService)); }, token: UserPreferenceService, providedIn: "root" });
+UserPreferenceService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+UserPreferenceService.ctorParameters = () => [
+    { type: UserService },
+    { type: UserResourceService },
+    { type: LoggerService },
+    { type: SnackBarService },
+    { type: TranslateService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-preference.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/user/services/user-preference.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {Preferences} from '../../resources/interface/preferences';\nimport {UserService} from './user.service';\nimport {UserResourceService} from '../../resources/engine-endpoint/user-resource.service';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {Observable, Subject, Subscription} from 'rxjs';\nimport {TranslateService} from '@ngx-translate/core';\nimport {debounceTime} from 'rxjs/operators';\n\nconst DRAWER_DEFAULT_WIDTH = 200;\nconst DRAWER_DEBOUNCE = 1000;\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UserPreferenceService implements OnDestroy {\n\n    protected _preferences: Preferences;\n    protected _preferencesChanged$: Subject<void>;\n    protected _sub: Subscription;\n    protected _subAnonym: Subscription;\n    public _drawerWidthChanged$: Subject<number>;\n    protected _anonym: boolean;\n\n    constructor(protected _userService: UserService,\n                protected _userResourceService: UserResourceService,\n                protected _logger: LoggerService,\n                protected _snackbar: SnackBarService,\n                protected _translate: TranslateService) {\n        this._preferences = this._emptyPreferences();\n        this._preferencesChanged$ = new Subject<void>();\n        this._drawerWidthChanged$ = new Subject<number>();\n        this._anonym = false;\n\n        this._sub = this._userService.user$.subscribe(loggedUser => {\n            if (loggedUser && loggedUser.id !== '') {\n                this._userResourceService.getPreferences().subscribe(prefs => {\n                        this._preferences = this._emptyPreferences();\n                        Object.assign(this._preferences, prefs);\n                        this._preferencesChanged$.next();\n                    }\n                );\n            } else {\n                this._preferences = this._emptyPreferences();\n                this._preferencesChanged$.next();\n            }\n        });\n\n        this._subAnonym = this._userService.anonymousUser$.subscribe(loggedUser => {\n            if (loggedUser && loggedUser.id !== '') {\n                this._userResourceService.getPublicPreferences().subscribe(prefs => {\n                        this._preferences = this._emptyPreferences();\n                        Object.assign(this._preferences, prefs);\n                        this._preferencesChanged$.next();\n                        this._anonym = true;\n                    }\n                );\n            } else {\n                this._preferences = this._emptyPreferences();\n                this._preferencesChanged$.next();\n                this._anonym = false;\n            }\n        });\n\n        this._drawerWidthChanged$.asObservable().pipe(\n            debounceTime(DRAWER_DEBOUNCE)\n        ).subscribe(newWidth => {\n            this.drawerWidth = newWidth;\n        });\n    }\n\n    ngOnDestroy(): void {\n        this._sub.unsubscribe();\n        this._preferencesChanged$.complete();\n    }\n\n    public setTaskFilters(viewId: string, value: Array<string>): void {\n        this._preferences.taskFilters[viewId] = value;\n        this._savePreferences();\n    }\n\n    public getTaskFilters(viewId: string): Array<string> | undefined {\n        return this._preferences.taskFilters[viewId];\n    }\n\n    public setCaseFilters(viewId: string, value: Array<string>): void {\n        this._preferences.caseFilters[viewId] = value;\n        this._savePreferences();\n    }\n\n    public getCaseFilters(viewId: string): Array<string> | undefined {\n        return this._preferences.caseFilters[viewId];\n    }\n\n    public setHeaders(viewId: string, value: Array<string>): void {\n        this._preferences.headers[viewId] = value;\n        this._savePreferences();\n    }\n\n    public getHeaders(viewId: string): Array<string> | undefined {\n        return this._preferences.headers[viewId];\n    }\n\n    public setLocale(locale: string): void {\n        this._preferences.locale = locale;\n        this._savePreferences();\n    }\n\n    public getLocale(): string {\n        return this._preferences.locale;\n    }\n\n    set drawerWidth(drawerWidth: number) {\n        this._preferences.drawerWidth = drawerWidth;\n        this._savePreferences();\n    }\n\n    get drawerWidth(): number {\n        return this._preferences.drawerWidth;\n    }\n\n    public get preferencesChanged$(): Observable<void> {\n        return this._preferencesChanged$.asObservable();\n    }\n\n    protected _savePreferences(): void {\n        if (!this._anonym) {\n            this._userResourceService.setPreferences(this._preferences).subscribe(resultMessage => {\n                this.resultMessage(resultMessage);\n            });\n        } else {\n            this._userResourceService.setPublicPreferences(this._preferences).subscribe(resultMessage => {\n                this.resultMessage(resultMessage);\n            });\n        }\n    }\n\n    protected resultMessage(resultMessage): void {\n        if (typeof resultMessage.success === 'string') {\n            this._snackbar.openSuccessSnackBar(this._translate.instant('preferences.snackbar.saveSuccess'));\n        } else {\n            this._snackbar.openErrorSnackBar(this._translate.instant('preferences.snackbar.saveFailure'));\n            this._logger.error('User preferences failed to save', resultMessage);\n        }\n    }\n\n    protected _emptyPreferences(): Preferences {\n        return {\n            drawerWidth: DRAWER_DEFAULT_WIDTH,\n            headers: {},\n            caseFilters: {},\n            taskFilters: {}\n        };\n    }\n}\n"]}

package/esm2015/lib/user/services/user.service.js

@@ -0,0 +1,203 @@
+import { Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { User } from '../models/user';
+import { take, tap } from 'rxjs/operators';
+import { AuthenticationService } from '../../authentication/services/authentication/authentication.service';
+import { UserResourceService } from '../../resources/engine-endpoint/user-resource.service';
+import { UserTransformer } from '../../authentication/models/user.transformer';
+import { LoggerService } from '../../logger/services/logger.service';
+import { HttpErrorResponse } from '@angular/common/http';
+import { SessionService } from '../../authentication/session/services/session.service';
+import { AnonymousService } from '../../authentication/anonymous/anonymous.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../authentication/services/authentication/authentication.service";
+import * as i2 from "../../resources/engine-endpoint/user-resource.service";
+import * as i3 from "../../authentication/models/user.transformer";
+import * as i4 from "../../logger/services/logger.service";
+import * as i5 from "../../authentication/session/services/session.service";
+import * as i6 from "../../authentication/anonymous/anonymous.service";
+export class UserService {
+    constructor(_authService, _userResource, _userTransform, _log, _session, _anonymousService) {
+        this._authService = _authService;
+        this._userResource = _userResource;
+        this._userTransform = _userTransform;
+        this._log = _log;
+        this._session = _session;
+        this._anonymousService = _anonymousService;
+        this._user = this.emptyUser();
+        this._loginCalled = false;
+        this._userChange$ = new ReplaySubject(1);
+        this._anonymousUserChange$ = new ReplaySubject(1);
+        setTimeout(() => {
+            this._subAuth = this._authService.authenticated$.subscribe(auth => {
+                if (auth && !this._loginCalled) {
+                    this.loadUser();
+                }
+                else if (!auth) {
+                    this.clearUser();
+                    this.publishUserChange();
+                }
+            });
+        });
+        this._subAnonym = this._anonymousService.tokenSet.subscribe(token => {
+            if (token) {
+                this.loadPublicUser();
+            }
+            else {
+                this.clearUser();
+                this.publishAnonymousUserChange();
+            }
+        });
+    }
+    get user() {
+        return this._user;
+    }
+    get user$() {
+        return this._userChange$.asObservable();
+    }
+    get anonymousUser$() {
+        return this._anonymousUserChange$.asObservable();
+    }
+    ngOnDestroy() {
+        this._userChange$.complete();
+        this._anonymousUserChange$.complete();
+        this._subAuth.unsubscribe();
+        this._subAnonym.unsubscribe();
+    }
+    /**
+     * Check if user has specified authority.
+     * @param authority - If provided authority is array of authorities.
+     *                    Method make intersection of the provided authorities and user's authorities.
+     *                    If calculated intersection isn't empty returns true, otherwise false.
+     */
+    hasAuthority(authority) {
+        if (!authority || !this._user.authorities) {
+            return false;
+        }
+        if (authority instanceof Array) {
+            return authority.some(a => this._user.authorities.some(u => u === a));
+        }
+        else {
+            return this._user.authorities.some(a => a === authority);
+        }
+    }
+    hasRole(role) {
+        if (!role || !this._user.roles) {
+            return false;
+        }
+        return this._user.roles.some(r => r === role);
+    }
+    /**
+     * Checks whether the user has role with a specific stringId
+     * @param roleStringId ID of the role we want to check
+     */
+    hasRoleById(roleStringId) {
+        if (!roleStringId || !this._user.roles) {
+            return false;
+        }
+        return this._user.roles.some(r => r.stringId === roleStringId);
+    }
+    /**
+     * Checks whether the user has role with the specified identifier in a process with the specified identifier (any version)
+     * @param roleIdentifier identifier (import ID) of the role we want to check
+     * @param netIdentifier identifier (import ID) of the process the role is defined in
+     */
+    hasRoleByIdentifier(roleIdentifier, netIdentifier) {
+        if (!roleIdentifier || !netIdentifier || !this._user.roles) {
+            return false;
+        }
+        return this._user.roles.some(r => r.netImportId === netIdentifier && r.importId === roleIdentifier);
+    }
+    /**
+     * Checks whether the user has role with the specified name in a process with the specified identifier (any version)
+     * @param roleName name of the role we want to check
+     * @param netIdentifier identifier (import ID) of the process the role is defined in
+     */
+    hasRoleByName(roleName, netIdentifier) {
+        if (!roleName || !netIdentifier || !this._user.roles) {
+            return false;
+        }
+        return this._user.roles.some(r => r.netImportId === netIdentifier && r.name === roleName);
+    }
+    login(credentials) {
+        this._loginCalled = true;
+        return this._authService.login(credentials).pipe(tap((authUser) => {
+            this._user = authUser;
+            this._loginCalled = false;
+            this.publishUserChange();
+        }));
+    }
+    logout() {
+        return this._authService.logout().pipe(tap(() => {
+            this._user = this.emptyUser();
+            this.publishUserChange();
+        }));
+    }
+    reload() {
+        this.loadUser();
+    }
+    emptyUser() {
+        return new User('', '', '', '', [], [], [], []);
+    }
+    loadUser() {
+        this._userResource.getLoggedUser().pipe(take(1)).subscribe((user) => {
+            if (user) {
+                const backendUser = Object.assign(Object.assign({}, user), { id: user.id.toString() });
+                this._user = this._userTransform.transform(backendUser);
+                this.publishUserChange();
+            }
+        }, error => {
+            if (error instanceof HttpErrorResponse && error.status === 401) {
+                this._log.debug('Authentication token is invalid. Clearing stream');
+                this._session.clear();
+            }
+            else {
+                this._log.error('Loading logged user has failed! Initialisation has not be completed successfully!', error);
+            }
+        });
+    }
+    loadPublicUser() {
+        this._userResource.getPublicLoggedUser().pipe(take(1)).subscribe((user) => {
+            if (user) {
+                const backendUser = Object.assign(Object.assign({}, user), { id: user.id.toString() });
+                this._user = this._userTransform.transform(backendUser);
+                this.publishAnonymousUserChange();
+            }
+        }, error => {
+            this._log.error('Loading logged user has failed! Initialisation has not be completed successfully!', error);
+            this._publicLoadCalled = false;
+        });
+    }
+    clearUser() {
+        this._user = this.emptyUser();
+    }
+    publishUserChange() {
+        this._userChange$.next(this.user);
+    }
+    publishAnonymousUserChange() {
+        this._anonymousUserChange$.next(this.user);
+    }
+}
+UserService.ctorParameters = () => [
+    { type: AuthenticationService },
+    { type: UserResourceService },
+    { type: UserTransformer },
+    { type: LoggerService },
+    { type: SessionService },
+    { type: AnonymousService }
+];
+UserService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserService_Factory() { return new UserService(i0.ɵɵinject(i1.AuthenticationService), i0.ɵɵinject(i2.UserResourceService), i0.ɵɵinject(i3.UserTransformer), i0.ɵɵinject(i4.LoggerService), i0.ɵɵinject(i5.SessionService), i0.ɵɵinject(i6.AnonymousService)); }, token: UserService, providedIn: "root" });
+UserService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+UserService.ctorParameters = () => [
+    { type: AuthenticationService },
+    { type: UserResourceService },
+    { type: UserTransformer },
+    { type: LoggerService },
+    { type: SessionService },
+    { type: AnonymousService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/user/services/user.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {Observable, ReplaySubject, Subscription} from 'rxjs';\nimport {ProcessRole} from '../../resources/interface/process-role';\nimport {User} from '../models/user';\nimport {Credentials} from '../../authentication/models/credentials';\nimport {take, tap} from 'rxjs/operators';\nimport {AuthenticationService} from '../../authentication/services/authentication/authentication.service';\nimport {UserResourceService} from '../../resources/engine-endpoint/user-resource.service';\nimport {UserTransformer} from '../../authentication/models/user.transformer';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {HttpErrorResponse} from '@angular/common/http';\nimport {SessionService} from '../../authentication/session/services/session.service';\nimport {UserResource} from '../../resources/interface/user-resource';\nimport {AnonymousService} from '../../authentication/anonymous/anonymous.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UserService implements OnDestroy {\n\n    protected _user: User;\n    protected _userChange$: ReplaySubject<User>;\n    protected _anonymousUserChange$: ReplaySubject<User>;\n    protected _loginCalled: boolean;\n    protected _subAuth: Subscription;\n    protected _subAnonym: Subscription;\n    private _publicLoadCalled: boolean;\n\n    constructor(protected _authService: AuthenticationService,\n                protected _userResource: UserResourceService,\n                protected _userTransform: UserTransformer,\n                protected _log: LoggerService,\n                protected _session: SessionService,\n                protected _anonymousService: AnonymousService) {\n        this._user = this.emptyUser();\n        this._loginCalled = false;\n        this._userChange$ = new ReplaySubject<User>(1);\n        this._anonymousUserChange$ = new ReplaySubject<User>(1);\n        setTimeout(() => {\n            this._subAuth = this._authService.authenticated$.subscribe(auth => {\n                if (auth && !this._loginCalled) {\n                    this.loadUser();\n                } else if (!auth) {\n                    this.clearUser();\n                    this.publishUserChange();\n                }\n            });\n        });\n        this._subAnonym = this._anonymousService.tokenSet.subscribe(token => {\n            if (token) {\n                this.loadPublicUser();\n            } else {\n                this.clearUser();\n                this.publishAnonymousUserChange();\n            }\n        });\n    }\n\n    get user() {\n        return this._user;\n    }\n\n    get user$(): Observable<User> {\n        return this._userChange$.asObservable();\n    }\n\n    get anonymousUser$(): Observable<User> {\n        return this._anonymousUserChange$.asObservable();\n    }\n\n    ngOnDestroy(): void {\n        this._userChange$.complete();\n        this._anonymousUserChange$.complete();\n        this._subAuth.unsubscribe();\n        this._subAnonym.unsubscribe();\n    }\n\n    /**\n     * Check if user has specified authority.\n     * @param authority - If provided authority is array of authorities.\n     *                    Method make intersection of the provided authorities and user's authorities.\n     *                    If calculated intersection isn't empty returns true, otherwise false.\n     */\n    public hasAuthority(authority: Array<string> | string): boolean {\n        if (!authority || !this._user.authorities) {\n            return false;\n        }\n        if (authority instanceof Array) {\n            return authority.some(a => this._user.authorities.some(u => u === a));\n        } else {\n            return this._user.authorities.some(a => a === authority);\n        }\n    }\n\n    public hasRole(role: ProcessRole): boolean {\n        if (!role || !this._user.roles) {\n            return false;\n        }\n        return this._user.roles.some(r => r === role);\n    }\n\n    /**\n     * Checks whether the user has role with a specific stringId\n     * @param roleStringId ID of the role we want to check\n     */\n    public hasRoleById(roleStringId: string): boolean {\n        if (!roleStringId || !this._user.roles) {\n            return false;\n        }\n        return this._user.roles.some(r => r.stringId === roleStringId);\n    }\n\n    /**\n     * Checks whether the user has role with the specified identifier in a process with the specified identifier (any version)\n     * @param roleIdentifier identifier (import ID) of the role we want to check\n     * @param netIdentifier identifier (import ID) of the process the role is defined in\n     */\n    public hasRoleByIdentifier(roleIdentifier: string, netIdentifier: string): boolean {\n        if (!roleIdentifier || !netIdentifier || !this._user.roles) {\n            return false;\n        }\n        return this._user.roles.some(r => r.netImportId === netIdentifier && r.importId === roleIdentifier);\n    }\n\n    /**\n     * Checks whether the user has role with the specified name in a process with the specified identifier (any version)\n     * @param roleName name of the role we want to check\n     * @param netIdentifier identifier (import ID) of the process the role is defined in\n     */\n    public hasRoleByName(roleName: string, netIdentifier: string): boolean {\n        if (!roleName || !netIdentifier || !this._user.roles) {\n            return false;\n        }\n        return this._user.roles.some(r => r.netImportId === netIdentifier && r.name === roleName);\n    }\n\n    public login(credentials: Credentials): Observable<User> {\n        this._loginCalled = true;\n        return this._authService.login(credentials).pipe(\n            tap((authUser: User) => {\n                this._user = authUser;\n                this._loginCalled = false;\n                this.publishUserChange();\n            })\n        );\n    }\n\n    public logout(): Observable<object> {\n        return this._authService.logout().pipe(\n            tap(() => {\n                this._user = this.emptyUser();\n                this.publishUserChange();\n            })\n        );\n    }\n\n    public reload(): void {\n        this.loadUser();\n    }\n\n    protected emptyUser() {\n        return new User('', '', '', '', [], [], [], []);\n    }\n\n    protected loadUser(): void {\n        this._userResource.getLoggedUser().pipe(take(1)).subscribe((user: UserResource) => {\n            if (user) {\n                const backendUser = {...user, id: user.id.toString()};\n                this._user = this._userTransform.transform(backendUser);\n                this.publishUserChange();\n            }\n        }, error => {\n            if (error instanceof HttpErrorResponse && error.status === 401) {\n                this._log.debug('Authentication token is invalid. Clearing stream');\n                this._session.clear();\n            } else {\n                this._log.error('Loading logged user has failed! Initialisation has not be completed successfully!', error);\n            }\n        });\n    }\n\n    public loadPublicUser(): void {\n        this._userResource.getPublicLoggedUser().pipe(take(1)).subscribe((user: UserResource) => {\n            if (user) {\n                const backendUser = {...user, id: user.id.toString()};\n                this._user = this._userTransform.transform(backendUser);\n                this.publishAnonymousUserChange();\n            }\n        }, error => {\n            this._log.error('Loading logged user has failed! Initialisation has not be completed successfully!', error);\n            this._publicLoadCalled = false;\n        });\n    }\n\n    public clearUser() {\n        this._user = this.emptyUser();\n    }\n\n    protected publishUserChange(): void {\n        this._userChange$.next(this.user);\n    }\n\n    protected publishAnonymousUserChange(): void {\n        this._anonymousUserChange$.next(this.user);\n    }\n}\n"]}

package/esm2015/lib/user/services/view-id.service.js

@@ -0,0 +1,30 @@
+import { Inject, Injectable, Injector, Optional, SkipSelf } from '@angular/core';
+import { NAE_VIEW_ID_SEGMENT } from '../models/view-id-injection-tokens';
+export class ViewIdService {
+    constructor(parentInjector, idSegment) {
+        this._viewId = '';
+        if (parentInjector !== null) {
+            const parentIdService = parentInjector.get(ViewIdService, null);
+            if (parentIdService !== null) {
+                this._viewId = parentIdService.viewId + ViewIdService.VIEW_ID_SEGMENT_SEPARATOR;
+            }
+        }
+        this._viewId += idSegment;
+    }
+    get viewId() {
+        return this._viewId;
+    }
+}
+ViewIdService.VIEW_ID_SEGMENT_SEPARATOR = '-';
+ViewIdService.ctorParameters = () => [
+    { type: Injector, decorators: [{ type: Optional }, { type: SkipSelf }] },
+    { type: String, decorators: [{ type: Inject, args: [NAE_VIEW_ID_SEGMENT,] }] }
+];
+ViewIdService.decorators = [
+    { type: Injectable }
+];
+ViewIdService.ctorParameters = () => [
+    { type: Injector, decorators: [{ type: Optional }, { type: SkipSelf }] },
+    { type: String, decorators: [{ type: Inject, args: [NAE_VIEW_ID_SEGMENT,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/array-to-observable.js

@@ -0,0 +1,10 @@
+import { timer } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+/**
+ * @param observables an array of items
+ * @returns an observable that emits each item from the array in order.
+ */
+export function arrayToObservable(observables) {
+    return timer(0, 1).pipe(take(observables.length), map(i => observables[i]));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktdG8tb2JzZXJ2YWJsZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L2FycmF5LXRvLW9ic2VydmFibGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFhLEtBQUssRUFBQyxNQUFNLE1BQU0sQ0FBQztBQUN2QyxPQUFPLEVBQUMsR0FBRyxFQUFFLElBQUksRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBRXpDOzs7R0FHRztBQUNILE1BQU0sVUFBVSxpQkFBaUIsQ0FBSSxXQUFxQjtJQUN0RCxPQUFPLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUNoRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtPYnNlcnZhYmxlLCB0aW1lcn0gZnJvbSAncnhqcyc7XG5pbXBvcnQge21hcCwgdGFrZX0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuXG4vKipcbiAqIEBwYXJhbSBvYnNlcnZhYmxlcyBhbiBhcnJheSBvZiBpdGVtc1xuICogQHJldHVybnMgYW4gb2JzZXJ2YWJsZSB0aGF0IGVtaXRzIGVhY2ggaXRlbSBmcm9tIHRoZSBhcnJheSBpbiBvcmRlci5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGFycmF5VG9PYnNlcnZhYmxlPFQ+KG9ic2VydmFibGVzOiBBcnJheTxUPik6IE9ic2VydmFibGU8VD4ge1xuICAgIHJldHVybiB0aW1lcigwLCAxKS5waXBlKHRha2Uob2JzZXJ2YWJsZXMubGVuZ3RoKSwgbWFwKGkgPT4gb2JzZXJ2YWJsZXNbaV0pKTtcbn1cbiJdfQ==

package/esm2015/lib/utility/call-chain/after-action.js

@@ -0,0 +1,12 @@
+import { Subject } from 'rxjs';
+export class AfterAction extends Subject {
+    /**
+     * Emits the `resolution` and completes.
+     * @param resolution
+     */
+    resolve(resolution) {
+        this.next(resolution);
+        this.complete();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWZ0ZXItYWN0aW9uLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3V0aWxpdHkvY2FsbC1jaGFpbi9hZnRlci1hY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLE9BQU8sRUFBQyxNQUFNLE1BQU0sQ0FBQztBQUU3QixNQUFNLE9BQU8sV0FBWSxTQUFRLE9BQWdCO0lBRTdDOzs7T0FHRztJQUNJLE9BQU8sQ0FBQyxVQUFtQjtRQUM5QixJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ3RCLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUNwQixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1N1YmplY3R9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgY2xhc3MgQWZ0ZXJBY3Rpb24gZXh0ZW5kcyBTdWJqZWN0PGJvb2xlYW4+IHtcblxuICAgIC8qKlxuICAgICAqIEVtaXRzIHRoZSBgcmVzb2x1dGlvbmAgYW5kIGNvbXBsZXRlcy5cbiAgICAgKiBAcGFyYW0gcmVzb2x1dGlvblxuICAgICAqL1xuICAgIHB1YmxpYyByZXNvbHZlKHJlc29sdXRpb246IGJvb2xlYW4pIHtcbiAgICAgICAgdGhpcy5uZXh0KHJlc29sdXRpb24pO1xuICAgICAgICB0aGlzLmNvbXBsZXRlKCk7XG4gICAgfVxufVxuIl19

package/esm2015/lib/utility/call-chain/call-chain.service.js

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { AfterAction } from './after-action';
+import * as i0 from "@angular/core";
+export class CallChainService {
+    constructor() {
+    }
+    /**
+     * Creates a call chain `Subject` that performs an action when a value is emitted into it.
+     *
+     * Useful for creating call chains for methods like [assign Task]{@link AssignTaskService#assign}.
+     * By using this function you don't have to handle the `Subject` logic and can only focus on the callback.
+     * This can make the code easier to understand as the intent is not obscured by the `Subject` handling.
+     *
+     * @param callback the function that should be executed when a value is emitted into the `Subject`.
+     * The emitted value is passed as the argument.
+     * @returns a subscribed `Subject` instance that performs the provided `callback` on the first emission and then completes
+     */
+    create(callback) {
+        const chain = new AfterAction();
+        chain.subscribe(result => {
+            callback(result);
+            chain.complete();
+        });
+        return chain;
+    }
+}
+CallChainService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CallChainService_Factory() { return new CallChainService(); }, token: CallChainService, providedIn: "root" });
+CallChainService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+CallChainService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/clear-time-information.js

@@ -0,0 +1,11 @@
+/**
+ * Sets milliseconds, seconds, minutes and hours of the provided Moment object to 0
+ * @param date object that we want to clear time information from
+ */
+export function clearTimeInformation(date) {
+    date.milliseconds(0);
+    date.seconds(0);
+    date.minutes(0);
+    date.hours(0);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xlYXItdGltZS1pbmZvcm1hdGlvbi5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L2NsZWFyLXRpbWUtaW5mb3JtYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLG9CQUFvQixDQUFDLElBQVk7SUFDN0MsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNyQixJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2hCLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDaEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUNsQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtNb21lbnR9IGZyb20gJ21vbWVudCc7XG5cbi8qKlxuICogU2V0cyBtaWxsaXNlY29uZHMsIHNlY29uZHMsIG1pbnV0ZXMgYW5kIGhvdXJzIG9mIHRoZSBwcm92aWRlZCBNb21lbnQgb2JqZWN0IHRvIDBcbiAqIEBwYXJhbSBkYXRlIG9iamVjdCB0aGF0IHdlIHdhbnQgdG8gY2xlYXIgdGltZSBpbmZvcm1hdGlvbiBmcm9tXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjbGVhclRpbWVJbmZvcm1hdGlvbihkYXRlOiBNb21lbnQpOiB2b2lkIHtcbiAgICBkYXRlLm1pbGxpc2Vjb25kcygwKTtcbiAgICBkYXRlLnNlY29uZHMoMCk7XG4gICAgZGF0ZS5taW51dGVzKDApO1xuICAgIGRhdGUuaG91cnMoMCk7XG59XG4iXX0=

package/esm2015/lib/utility/destroy-subscription.js

@@ -0,0 +1,10 @@
+/**
+ * Unsubscribes the provided subscription, if it exists and is still opened
+ * @param sub the subscription that should be destroyed
+ */
+export function destroySubscription(sub) {
+    if (sub && !sub.closed) {
+        sub.unsubscribe();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJveS1zdWJzY3JpcHRpb24uanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdXRpbGl0eS9kZXN0cm95LXN1YnNjcmlwdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsbUJBQW1CLENBQUMsR0FBaUI7SUFDakQsSUFBSSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFO1FBQ3BCLEdBQUcsQ0FBQyxXQUFXLEVBQUUsQ0FBQztLQUNyQjtBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1N1YnNjcmlwdGlvbn0gZnJvbSAncnhqcyc7XG5cbi8qKlxuICogVW5zdWJzY3JpYmVzIHRoZSBwcm92aWRlZCBzdWJzY3JpcHRpb24sIGlmIGl0IGV4aXN0cyBhbmQgaXMgc3RpbGwgb3BlbmVkXG4gKiBAcGFyYW0gc3ViIHRoZSBzdWJzY3JpcHRpb24gdGhhdCBzaG91bGQgYmUgZGVzdHJveWVkXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZXN0cm95U3Vic2NyaXB0aW9uKHN1YjogU3Vic2NyaXB0aW9uKTogdm9pZCB7XG4gICAgaWYgKHN1YiAmJiAhc3ViLmNsb3NlZCkge1xuICAgICAgICBzdWIudW5zdWJzY3JpYmUoKTtcbiAgICB9XG59XG4iXX0=

package/esm2015/lib/utility/get-field.js

@@ -0,0 +1,48 @@
+/**
+ * @param fields a collection of data fields
+ * @param fieldId the id of the desired field
+ * @returns a reference to the datafield with the specified id or `undefined` if such datafield could not be found
+ */
+export function getField(fields, fieldId) {
+    const index = getFieldIndex(fields, fieldId);
+    return index === -1 ? undefined : fields[index];
+}
+/**
+ * @param fields a collection of data fields
+ * @param fieldId the id of the desired field
+ * @returns the index of the datafield with the specified id or `-1` if such datafield could not be found
+ */
+export function getFieldIndex(fields, fieldId) {
+    return fields.findIndex(field => field.stringId === fieldId);
+}
+/**
+ * @param groups a list of searched data groups
+ * @param fieldId the id of the desired field
+ * @returns a reference to the first occurrence of the datafield with the specified id or `undefined` if such datafield could not be found
+ */
+export function getFieldFromDataGroups(groups, fieldId) {
+    const indices = getFieldIndexFromDataGroups(groups, fieldId);
+    if (indices !== undefined) {
+        return groups[indices.dataGroupIndex].fields[indices.fieldIndex];
+    }
+    return undefined;
+}
+/**
+ * @param groups a list of searched data groups
+ * @param fieldId the id of the desired field
+ * @returns an object containing the index of the data group and the field within it corresponding to the first occurrence of a
+ * datafield with the specified id or `undefined` if such datafield could not be found
+ */
+export function getFieldIndexFromDataGroups(groups, fieldId) {
+    for (let i = 0; i < groups.length; i++) {
+        const fieldIndex = getFieldIndex(groups[i].fields, fieldId);
+        if (fieldIndex !== -1) {
+            return {
+                dataGroupIndex: i,
+                fieldIndex
+            };
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/get-immediate-data.js

@@ -0,0 +1,9 @@
+/**
+ * @param useCase the {@link Case} object who's immediate data we want to get
+ * @param fieldId the identifier of the field we want to get
+ * @returns the immediate data field if it exists on the case, `undefined` otherwise
+ */
+export function getImmediateData(useCase, fieldId) {
+    return useCase.immediateData.find(field => field.stringId === fieldId);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWltbWVkaWF0ZS1kYXRhLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3V0aWxpdHkvZ2V0LWltbWVkaWF0ZS1kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsT0FBYSxFQUFFLE9BQWU7SUFDM0QsT0FBTyxPQUFPLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxRQUFRLEtBQUssT0FBTyxDQUFDLENBQUM7QUFDM0UsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Q2FzZX0gZnJvbSAnLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9jYXNlJztcbmltcG9ydCB7SW1tZWRpYXRlRGF0YX0gZnJvbSAnLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9pbW1lZGlhdGUtZGF0YSc7XG5cbi8qKlxuICogQHBhcmFtIHVzZUNhc2UgdGhlIHtAbGluayBDYXNlfSBvYmplY3Qgd2hvJ3MgaW1tZWRpYXRlIGRhdGEgd2Ugd2FudCB0byBnZXRcbiAqIEBwYXJhbSBmaWVsZElkIHRoZSBpZGVudGlmaWVyIG9mIHRoZSBmaWVsZCB3ZSB3YW50IHRvIGdldFxuICogQHJldHVybnMgdGhlIGltbWVkaWF0ZSBkYXRhIGZpZWxkIGlmIGl0IGV4aXN0cyBvbiB0aGUgY2FzZSwgYHVuZGVmaW5lZGAgb3RoZXJ3aXNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRJbW1lZGlhdGVEYXRhKHVzZUNhc2U6IENhc2UsIGZpZWxkSWQ6IHN0cmluZyk6IEltbWVkaWF0ZURhdGEgfCB1bmRlZmluZWQge1xuICAgIHJldHVybiB1c2VDYXNlLmltbWVkaWF0ZURhdGEuZmluZChmaWVsZCA9PiBmaWVsZC5zdHJpbmdJZCA9PT0gZmllbGRJZCk7XG59XG4iXX0=