@netgrif/components-core 6.0.1

package/esm2015/lib/authentication/sign-up/services/sign-up.service.js

@@ -0,0 +1,105 @@
+import { Injectable } from '@angular/core';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { ConfigurationService } from '../../../configuration/configuration.service';
+import { HttpClient } from '@angular/common/http';
+import { switchMap } from 'rxjs/operators';
+import { SignUpModule } from '../sign-up.module';
+import { processMessageResponse } from '../../../utility/process-message-response';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../configuration/configuration.service";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../../../logger/services/logger.service";
+import * as i4 from "../sign-up.module";
+export class SignUpService {
+    constructor(_config, _http, _log) {
+        this._config = _config;
+        this._http = _http;
+        this._log = _log;
+        const authAddress = _config.get().providers.auth.address;
+        if (!authAddress) {
+            throw new Error('Authentication provider address is not set!');
+        }
+        this._signUpUrl = this.resolveEndpoint('signup', authAddress);
+        this._verifyUrl = this.resolveEndpoint('verify', authAddress);
+        this._inviteUrl = this.resolveEndpoint('invite', authAddress);
+        this._resetUrl = this.resolveEndpoint('reset', authAddress);
+        this._recoverUrl = this.resolveEndpoint('recover', authAddress);
+    }
+    signup(newUser) {
+        if (!this._signUpUrl) {
+            throw new Error('SingUp URL is not set in authentication provider endpoints!');
+        }
+        newUser.password = btoa(newUser.password);
+        return this._http.post(this._signUpUrl, newUser).pipe(switchMap(processMessageResponse));
+    }
+    invite(invitation) {
+        if (!this._inviteUrl) {
+            throw new Error('Invite URL is not set in authentication provider endpoints!');
+        }
+        if (!invitation.groups) {
+            invitation.groups = [];
+        }
+        if (!invitation.processRoles) {
+            invitation.processRoles = [];
+        }
+        return this._http.post(this._inviteUrl, invitation).pipe(switchMap(processMessageResponse));
+    }
+    resetPassword(email) {
+        if (!this._resetUrl) {
+            throw new Error('Reset URL is not set in authentication provider endpoints!');
+        }
+        return this._http.post(this._resetUrl, email).pipe(switchMap(processMessageResponse));
+    }
+    recoverPassword(token, password) {
+        if (!this._recoverUrl) {
+            throw new Error('Recover URL is not set in authentication provider endpoints!');
+        }
+        const request = {
+            token,
+            password: btoa(password),
+            email: '',
+            name: '',
+            surname: ''
+        };
+        return this._http.post(this._recoverUrl, request).pipe(switchMap(processMessageResponse));
+    }
+    verify(token) {
+        if (!this._verifyUrl) {
+            throw new Error('Verify URL is not set in authentication provider endpoints!');
+        }
+        return this._http.post(this._verifyUrl, token).pipe(switchMap(processMessageResponse));
+    }
+    /**
+     * @param endpointKey the attribute name of the endpoint address in `nae.json`
+     * @param baseUrl the base of the endpoint URL. Content resolved by key from `nae.json` is appended to the URL provided by this argument
+     * @returns the endpoint address or `undefined` if such endpoint is not defined in `nae.json`
+     */
+    resolveEndpoint(endpointKey, baseUrl) {
+        const config = this._config.get();
+        if (!config
+            || !config.providers
+            || !config.providers.auth
+            || !config.providers.auth.endpoints
+            || !config.providers.auth.endpoints[endpointKey]) {
+            return undefined;
+        }
+        return baseUrl + config.providers.auth.endpoints[endpointKey];
+    }
+}
+SignUpService.ctorParameters = () => [
+    { type: ConfigurationService },
+    { type: HttpClient },
+    { type: LoggerService }
+];
+SignUpService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SignUpService_Factory() { return new SignUpService(i0.ɵɵinject(i1.ConfigurationService), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.LoggerService)); }, token: SignUpService, providedIn: i4.SignUpModule });
+SignUpService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: SignUpModule
+            },] }
+];
+SignUpService.ctorParameters = () => [
+    { type: ConfigurationService },
+    { type: HttpClient },
+    { type: LoggerService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign-up.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/authentication/sign-up/services/sign-up.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {ConfigurationService} from '../../../configuration/configuration.service';\nimport {HttpClient} from '@angular/common/http';\nimport {Observable} from 'rxjs';\nimport {UserRegistrationRequest} from '../models/user-registration-request';\nimport {MessageResource} from '../../../resources/interface/message-resource';\nimport {switchMap} from 'rxjs/operators';\nimport {UserInvitationRequest} from '../models/user-invitation-request';\nimport {SignUpModule} from '../sign-up.module';\nimport {processMessageResponse} from '../../../utility/process-message-response';\n\n@Injectable({\n    providedIn: SignUpModule\n})\nexport class SignUpService {\n\n    protected readonly _signUpUrl: string;\n    protected readonly _verifyUrl: string;\n    protected readonly _inviteUrl: string;\n    protected readonly _resetUrl: string;\n    protected readonly _recoverUrl: string;\n\n    constructor(protected _config: ConfigurationService, protected _http: HttpClient, protected _log: LoggerService) {\n        const authAddress = _config.get().providers.auth.address;\n        if (!authAddress) {\n            throw new Error('Authentication provider address is not set!');\n        }\n        this._signUpUrl = this.resolveEndpoint('signup', authAddress);\n        this._verifyUrl = this.resolveEndpoint('verify', authAddress);\n        this._inviteUrl = this.resolveEndpoint('invite', authAddress);\n        this._resetUrl = this.resolveEndpoint('reset', authAddress);\n        this._recoverUrl = this.resolveEndpoint('recover', authAddress);\n    }\n\n    public signup(newUser: UserRegistrationRequest): Observable<MessageResource> {\n        if (!this._signUpUrl) {\n            throw new Error('SingUp URL is not set in authentication provider endpoints!');\n        }\n        newUser.password = btoa(newUser.password);\n        return this._http.post<MessageResource>(this._signUpUrl, newUser).pipe(\n            switchMap(processMessageResponse)\n        );\n    }\n\n    public invite(invitation: UserInvitationRequest): Observable<MessageResource> {\n        if (!this._inviteUrl) {\n            throw new Error('Invite URL is not set in authentication provider endpoints!');\n        }\n        if (!invitation.groups) {\n            invitation.groups = [];\n        }\n        if (!invitation.processRoles) {\n            invitation.processRoles = [];\n        }\n        return this._http.post<MessageResource>(this._inviteUrl, invitation).pipe(\n            switchMap(processMessageResponse)\n        );\n    }\n\n    public resetPassword(email: string): Observable<MessageResource> {\n        if (!this._resetUrl) {\n            throw new Error('Reset URL is not set in authentication provider endpoints!');\n        }\n        return this._http.post<MessageResource>(this._resetUrl, email).pipe(\n            switchMap(processMessageResponse)\n        );\n    }\n\n    public recoverPassword(token, password): Observable<MessageResource> {\n        if (!this._recoverUrl) {\n            throw new Error('Recover URL is not set in authentication provider endpoints!');\n        }\n        const request = {\n            token,\n            password: btoa(password),\n            email: '',\n            name: '',\n            surname: ''\n        };\n        return this._http.post<MessageResource>(this._recoverUrl, request).pipe(\n            switchMap(processMessageResponse)\n        );\n    }\n\n    public verify(token: string): Observable<MessageResource> {\n        if (!this._verifyUrl) {\n            throw new Error('Verify URL is not set in authentication provider endpoints!');\n        }\n        return this._http.post<MessageResource>(this._verifyUrl, token).pipe(\n            switchMap(processMessageResponse)\n        );\n    }\n\n    /**\n     * @param endpointKey the attribute name of the endpoint address in `nae.json`\n     * @param baseUrl the base of the endpoint URL. Content resolved by key from `nae.json` is appended to the URL provided by this argument\n     * @returns the endpoint address or `undefined` if such endpoint is not defined in `nae.json`\n     */\n    protected resolveEndpoint(endpointKey: string, baseUrl: string): string | undefined {\n        const config = this._config.get();\n        if (!config\n            || !config.providers\n            || !config.providers.auth\n            || !config.providers.auth.endpoints\n            || !config.providers.auth.endpoints[endpointKey]) {\n            return undefined;\n        }\n        return baseUrl + config.providers.auth.endpoints[endpointKey];\n    }\n}\n"]}

package/esm2015/lib/authentication/sign-up/sign-up.module.js

@@ -0,0 +1,13 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+export class SignUpModule {
+}
+SignUpModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [],
+                imports: [
+                    CommonModule
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbi11cC5tb2R1bGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvYXV0aGVudGljYXRpb24vc2lnbi11cC9zaWduLXVwLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQVM3QyxNQUFNLE9BQU8sWUFBWTs7O1lBTnhCLFFBQVEsU0FBQztnQkFDTixZQUFZLEVBQUUsRUFBRTtnQkFDaEIsT0FBTyxFQUFFO29CQUNMLFlBQVk7aUJBQ2Y7YUFDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5cblxuQE5nTW9kdWxlKHtcbiAgICBkZWNsYXJhdGlvbnM6IFtdLFxuICAgIGltcG9ydHM6IFtcbiAgICAgICAgQ29tbW9uTW9kdWxlXG4gICAgXVxufSlcbmV4cG9ydCBjbGFzcyBTaWduVXBNb2R1bGUge1xufVxuIl19

package/esm2015/lib/authorization/authority/authority-guard.service.js

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivate, Router, RouterStateSnapshot, UrlTree } from '@angular/router';
+import { UserService } from '../../user/services/user.service';
+import { AuthenticationModule } from '../../authentication/authentication.module';
+import { RedirectService } from '../../routing/redirect-service/redirect.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../routing/redirect-service/redirect.service";
+import * as i2 from "../../user/services/user.service";
+import * as i3 from "../../configuration/configuration.service";
+import * as i4 from "@angular/router";
+import * as i5 from "../../authentication/authentication.module";
+export class AuthorityGuardService {
+    constructor(_redirectService, _userService, _configService, _router) {
+        this._redirectService = _redirectService;
+        this._userService = _userService;
+        this._configService = _configService;
+        this._router = _router;
+        this._loginUrl = this._redirectService.resolveLoginPath();
+    }
+    canActivate(route, state) {
+        this._redirectService.intendedRoute = route;
+        const view = this._configService.getViewByUrl(state.url.toString());
+        return this.canAccessView(view);
+    }
+    canAccessView(view) {
+        if (typeof view.access !== 'string' && view.access.hasOwnProperty('authority')) {
+            return this._userService.hasAuthority(view.access.authority);
+        }
+    }
+}
+AuthorityGuardService.ctorParameters = () => [
+    { type: RedirectService },
+    { type: UserService },
+    { type: ConfigurationService },
+    { type: Router }
+];
+AuthorityGuardService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AuthorityGuardService_Factory() { return new AuthorityGuardService(i0.ɵɵinject(i1.RedirectService), i0.ɵɵinject(i2.UserService), i0.ɵɵinject(i3.ConfigurationService), i0.ɵɵinject(i4.Router)); }, token: AuthorityGuardService, providedIn: i5.AuthenticationModule });
+AuthorityGuardService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: AuthenticationModule
+            },] }
+];
+AuthorityGuardService.ctorParameters = () => [
+    { type: RedirectService },
+    { type: UserService },
+    { type: ConfigurationService },
+    { type: Router }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/authorization/group/group-guard.service.js

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import { AuthenticationModule } from '../../authentication/authentication.module';
+import { RedirectService } from '../../routing/redirect-service/redirect.service';
+import { UserService } from '../../user/services/user.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { NextGroupService } from '../../groups/services/next-group.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../routing/redirect-service/redirect.service";
+import * as i2 from "../../user/services/user.service";
+import * as i3 from "../../groups/services/next-group.service";
+import * as i4 from "../../configuration/configuration.service";
+import * as i5 from "../../logger/services/logger.service";
+import * as i6 from "../../authentication/authentication.module";
+export class GroupGuardService {
+    constructor(_redirectService, _userService, _nextGroupService, _configService, _log) {
+        this._redirectService = _redirectService;
+        this._userService = _userService;
+        this._nextGroupService = _nextGroupService;
+        this._configService = _configService;
+        this._log = _log;
+        this._loginUrl = this._redirectService.resolveLoginPath();
+    }
+    canActivate(route, state) {
+        this._redirectService.intendedRoute = route;
+        const view = this._configService.getViewByUrl(state.url.toString());
+        return this.canAccessView(view, state.url.toString());
+    }
+    canAccessView(view, url) {
+        if (typeof view.access !== 'string' && view.access.hasOwnProperty('group')) {
+            let allowedGroups;
+            if (Array.isArray(view.access.group)) {
+                allowedGroups = view.access.group;
+            }
+            else {
+                allowedGroups = [view.access.group];
+            }
+            const groupOfUser = this._nextGroupService.groupOfUser.map(group => group.title);
+            return allowedGroups.some(groupTitle => {
+                return groupOfUser.includes(groupTitle);
+            });
+        }
+        throw new Error('Group guard is declared for a view with no group guard configuration!'
+            + ` Add group guard configuration for view at ${url}, or remove the guard.`);
+    }
+}
+GroupGuardService.ctorParameters = () => [
+    { type: RedirectService },
+    { type: UserService },
+    { type: NextGroupService },
+    { type: ConfigurationService },
+    { type: LoggerService }
+];
+GroupGuardService.ɵprov = i0.ɵɵdefineInjectable({ factory: function GroupGuardService_Factory() { return new GroupGuardService(i0.ɵɵinject(i1.RedirectService), i0.ɵɵinject(i2.UserService), i0.ɵɵinject(i3.NextGroupService), i0.ɵɵinject(i4.ConfigurationService), i0.ɵɵinject(i5.LoggerService)); }, token: GroupGuardService, providedIn: i6.AuthenticationModule });
+GroupGuardService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: AuthenticationModule
+            },] }
+];
+GroupGuardService.ctorParameters = () => [
+    { type: RedirectService },
+    { type: UserService },
+    { type: NextGroupService },
+    { type: ConfigurationService },
+    { type: LoggerService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/authorization/permission/permission.service.js

@@ -0,0 +1,116 @@
+import { Injectable } from '@angular/core';
+import { UserComparatorService } from '../../user/services/user-comparator.service';
+import { AssignPolicy } from '../../task-content/model/policy';
+import { UserService } from '../../user/services/user.service';
+import { PermissionType } from '../../process/permissions';
+import * as i0 from "@angular/core";
+import * as i1 from "../../user/services/user-comparator.service";
+import * as i2 from "../../user/services/user.service";
+export class PermissionService {
+    constructor(userComparator, _userService) {
+        this.userComparator = userComparator;
+        this._userService = _userService;
+    }
+    hasTaskPermission(task, permission) {
+        if (!task) {
+            return false;
+        }
+        const rolePermValue = this.checkRolePerms(task.roles, permission);
+        const userPermValue = this.checkUserPerms(task.users, permission);
+        return this.resolvePermissions(rolePermValue, userPermValue);
+    }
+    hasCasePermission(case_, permission) {
+        if (!case_) {
+            return false;
+        }
+        const rolePermValue = this.checkRolePerms(case_.permissions, permission);
+        const userPermValue = this.checkUserPerms(case_.users, permission);
+        return this.resolvePermissions(rolePermValue, userPermValue);
+    }
+    resolvePermissions(rolePermValue, userPermValue) {
+        return userPermValue === undefined ? (!!rolePermValue) : userPermValue;
+    }
+    hasNetPermission(action, net) {
+        if (!net
+            || !net.permissions
+            || !action
+            || !(net.permissions instanceof Object)) {
+            return false;
+        }
+        if (Object.keys(net.permissions).some(role => this._userService.hasRoleById(role) ? net.permissions[role][action] === false : false)) {
+            return false;
+        }
+        if (!Object.keys(net.permissions).filter(role => Object.keys(net.permissions[role])
+            .some(perm => perm === action)).some(role => !!net.permissions[role][action])) {
+            return true;
+        }
+        return Object.keys(net.permissions).some(role => this._userService.hasRoleById(role) ? !!net.permissions[role][action] : false);
+    }
+    canAssign(task) {
+        return !!task
+            && ((task.assignPolicy === AssignPolicy.manual
+                && !task.user
+                && this.hasTaskPermission(task, PermissionType.ASSIGN)));
+    }
+    canCancel(task) {
+        return !!task && !!task.user
+            && this.hasTaskPermission(task, PermissionType.CANCEL)
+            && ((task.assignedUserPolicy === undefined || task.assignedUserPolicy.cancel === undefined)
+                || task.assignedUserPolicy.cancel);
+    }
+    canReassign(task) {
+        return !!task && !!task.user && this.userComparator.compareUsers(task.user)
+            && this.hasTaskPermission(task, PermissionType.DELEGATE)
+            && ((task.assignedUserPolicy === undefined || task.assignedUserPolicy.reassign === undefined)
+                || task.assignedUserPolicy.reassign);
+    }
+    canFinish(task) {
+        return !!task
+            && !!task.user
+            && this.userComparator.compareUsers(task.user)
+            && this.hasTaskPermission(task, PermissionType.FINISH);
+    }
+    canCollapse(task) {
+        return !!task
+            && task.assignPolicy === AssignPolicy.manual;
+    }
+    checkRolePerms(roles, permission) {
+        let rolePermValue;
+        if (!!roles) {
+            Object.keys(roles).forEach(role => {
+                if (roles[role][permission] !== undefined && this._userService.hasRoleById(role)) {
+                    rolePermValue = rolePermValue === undefined ? roles[role][permission] : rolePermValue && roles[role][permission];
+                }
+            });
+        }
+        return rolePermValue;
+    }
+    checkUserPerms(users, permission) {
+        let userPermValue;
+        if (!!users) {
+            const loggedUserId = this._userService.user.id;
+            Object.keys(users).forEach(user => {
+                if (user === loggedUserId && users[user][permission] !== undefined) {
+                    userPermValue = userPermValue === undefined ?
+                        users[user][permission] : userPermValue && users[user][permission];
+                }
+            });
+        }
+        return userPermValue;
+    }
+}
+PermissionService.ctorParameters = () => [
+    { type: UserComparatorService },
+    { type: UserService }
+];
+PermissionService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PermissionService_Factory() { return new PermissionService(i0.ɵɵinject(i1.UserComparatorService), i0.ɵɵinject(i2.UserService)); }, token: PermissionService, providedIn: "root" });
+PermissionService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+PermissionService.ctorParameters = () => [
+    { type: UserComparatorService },
+    { type: UserService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permission.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/authorization/permission/permission.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {UserComparatorService} from '../../user/services/user-comparator.service';\nimport {AssignPolicy} from '../../task-content/model/policy';\nimport {Task} from '../../resources/interface/task';\nimport {UserService} from '../../user/services/user.service';\nimport {Case} from '../../resources/interface/case';\nimport {PetriNetReferenceWithPermissions} from '../../process/petri-net-reference-with-permissions';\nimport {Permissions, PermissionType, UserPermissions} from '../../process/permissions';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class PermissionService {\n\n    constructor(protected userComparator: UserComparatorService, protected _userService: UserService) {\n    }\n\n    public hasTaskPermission(task: Task | undefined, permission: string): boolean {\n        if (!task) {\n            return false;\n        }\n\n        const rolePermValue = this.checkRolePerms(task.roles, permission);\n        const userPermValue = this.checkUserPerms(task.users, permission);\n        return this.resolvePermissions(rolePermValue, userPermValue);\n    }\n\n    public hasCasePermission(case_: Case | undefined, permission: string): boolean {\n        if (!case_) {\n            return false;\n        }\n\n        const rolePermValue = this.checkRolePerms(case_.permissions, permission);\n        const userPermValue = this.checkUserPerms(case_.users, permission);\n        return this.resolvePermissions(rolePermValue, userPermValue);\n    }\n\n    public resolvePermissions(rolePermValue: boolean | undefined, userPermValue: boolean | undefined): boolean {\n        return userPermValue === undefined ? (!!rolePermValue) : userPermValue;\n    }\n\n    public hasNetPermission(action: string, net: PetriNetReferenceWithPermissions): boolean {\n        if (!net\n            || !net.permissions\n            || !action\n            || !(net.permissions instanceof Object)\n        ) {\n            return false;\n        }\n        if (Object.keys(net.permissions).some(role =>\n            this._userService.hasRoleById(role) ? net.permissions[role][action] === false : false)) {\n            return false;\n        }\n        if (!Object.keys(net.permissions).filter(role => Object.keys(net.permissions[role])\n            .some(perm => perm === action)).some(role =>\n            !!net.permissions[role][action])) {\n            return true;\n        }\n        return Object.keys(net.permissions).some(role =>\n            this._userService.hasRoleById(role) ? !!net.permissions[role][action] : false\n        );\n    }\n\n    public canAssign(task: Task | undefined): boolean {\n        return !!task\n            && (\n                (\n                    task.assignPolicy === AssignPolicy.manual\n                    && !task.user\n                    && this.hasTaskPermission(task, PermissionType.ASSIGN)\n                )\n            );\n    }\n\n    public canCancel(task: Task | undefined): boolean {\n        return !!task && !!task.user\n            && this.hasTaskPermission(task, PermissionType.CANCEL)\n            && ((task.assignedUserPolicy === undefined || task.assignedUserPolicy.cancel === undefined)\n                || task.assignedUserPolicy.cancel);\n    }\n\n    public canReassign(task: Task | undefined): boolean {\n        return !!task && !!task.user && this.userComparator.compareUsers(task.user)\n            && this.hasTaskPermission(task, PermissionType.DELEGATE)\n            && ((task.assignedUserPolicy === undefined || task.assignedUserPolicy.reassign === undefined)\n                || task.assignedUserPolicy.reassign);\n    }\n\n    public canFinish(task: Task | undefined): boolean {\n        return !!task\n            && !!task.user\n            && this.userComparator.compareUsers(task.user)\n            && this.hasTaskPermission(task, PermissionType.FINISH);\n    }\n\n    public canCollapse(task: Task | undefined): boolean {\n        return !!task\n            && task.assignPolicy === AssignPolicy.manual;\n    }\n\n    public checkRolePerms(roles: Permissions, permission: string): boolean | undefined {\n        let rolePermValue: boolean;\n        if (!!roles) {\n            Object.keys(roles).forEach(role => {\n                if (roles[role][permission] !== undefined && this._userService.hasRoleById(role)) {\n                    rolePermValue = rolePermValue === undefined ? roles[role][permission] : rolePermValue && roles[role][permission];\n                }\n            });\n        }\n        return rolePermValue;\n    }\n\n    public checkUserPerms(users: UserPermissions, permission): boolean | undefined {\n        let userPermValue: boolean;\n        if (!!users) {\n            const loggedUserId = this._userService.user.id;\n            Object.keys(users).forEach(user => {\n                if (user === loggedUserId && users[user][permission] !== undefined) {\n                    userPermValue = userPermValue === undefined ?\n                        users[user][permission] : userPermValue && users[user][permission];\n                }\n            });\n        }\n        return userPermValue;\n    }\n}\n"]}

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

@@ -0,0 +1,10 @@
+/* APIS */
+/* MODULES */
+/* CLASSES */
+/* SERVICES */
+export * from './authority/authority-guard.service';
+export * from './role/role-guard.service';
+export * from './group/group-guard.service';
+export * from './permission/permission.service';
+/* COMPONENTS */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9hdXRob3JpemF0aW9uL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsVUFBVTtBQUVWLGFBQWE7QUFFYixhQUFhO0FBRWIsY0FBYztBQUNkLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsaUNBQWlDLENBQUM7QUFFaEQsZ0JBQWdCIiwic291cmNlc0NvbnRlbnQiOlsiLyogQVBJUyAqL1xuXG4vKiBNT0RVTEVTICovXG5cbi8qIENMQVNTRVMgKi9cblxuLyogU0VSVklDRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vYXV0aG9yaXR5L2F1dGhvcml0eS1ndWFyZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcm9sZS9yb2xlLWd1YXJkLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9ncm91cC9ncm91cC1ndWFyZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcGVybWlzc2lvbi9wZXJtaXNzaW9uLnNlcnZpY2UnO1xuXG4vKiBDT01QT05FTlRTICovXG4iXX0=

package/esm2015/lib/authorization/role/role-guard.service.js

@@ -0,0 +1,105 @@
+import { Injectable } from '@angular/core';
+import { UserService } from '../../user/services/user.service';
+import { AuthenticationModule } from '../../authentication/authentication.module';
+import { RedirectService } from '../../routing/redirect-service/redirect.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../routing/redirect-service/redirect.service";
+import * as i2 from "../../user/services/user.service";
+import * as i3 from "../../configuration/configuration.service";
+import * as i4 from "../../logger/services/logger.service";
+import * as i5 from "../../authentication/authentication.module";
+export class RoleGuardService {
+    constructor(_redirectService, _userService, _configService, _log) {
+        this._redirectService = _redirectService;
+        this._userService = _userService;
+        this._configService = _configService;
+        this._log = _log;
+        this._loginUrl = this._redirectService.resolveLoginPath();
+    }
+    canActivate(route, state) {
+        this._redirectService.intendedRoute = route;
+        const view = this._configService.getViewByUrl(state.url.toString());
+        return this.canAccessView(view, state.url.toString());
+    }
+    canAccessView(view, url) {
+        if (typeof view.access !== 'string' && view.access.hasOwnProperty('role')) {
+            const allowedRoles = this.parseRoleConstraints(view.access.role, url);
+            return allowedRoles.some(constraint => {
+                if (constraint.roleIdentifier) {
+                    return this._userService.hasRoleByIdentifier(constraint.roleIdentifier, constraint.processIdentifier);
+                }
+                else {
+                    return this._userService.hasRoleByName(constraint.roleName, constraint.processIdentifier);
+                }
+            });
+        }
+        throw new Error('Role guard is declared for a view with no role guard configuration!'
+            + ` Add role guard configuration for view at ${url}, or remove the guard.`);
+    }
+    parseRoleConstraints(roleConstrains, viewUrl) {
+        if (typeof roleConstrains === 'string') {
+            return this.parseStringRoleConstraints(roleConstrains);
+        }
+        if (Array.isArray(roleConstrains)) {
+            if (roleConstrains.length === 0) {
+                this._log.warn(`View at '${viewUrl}' defines role access constraint with an empty array!`
+                    + ` No users will be allowed to enter this view!`);
+                return [];
+            }
+            if (typeof roleConstrains[0] === 'string') {
+                return this.parseStringRoleConstraints(roleConstrains);
+            }
+        }
+        return this.parseObjectRoleConstrains(roleConstrains);
+    }
+    /**
+     * @deprecated in 5.0.0
+     */
+    parseStringRoleConstraints(roleConstrains) {
+        if (!Array.isArray(roleConstrains)) {
+            roleConstrains = [roleConstrains];
+        }
+        this._log.warn('Using string role guard configuration is deprecated! Migrate to object based configuration instead.');
+        return roleConstrains.map(constraint => {
+            const splitRoleArray = constraint.split('.');
+            if (splitRoleArray.length === 2) {
+                return { processIdentifier: splitRoleArray[0], roleName: splitRoleArray[1] };
+            }
+            else {
+                throw new Error('Please enter the correct format <net import id>.<role name>');
+            }
+        });
+    }
+    parseObjectRoleConstrains(roleConstrains) {
+        if (!Array.isArray(roleConstrains)) {
+            roleConstrains = [roleConstrains];
+        }
+        return roleConstrains.map(constraint => {
+            if (!constraint.roleId || !constraint.processId) {
+                throw new Error('Please enter both process and role id for a role constraint: ' + constraint);
+            }
+            return { processIdentifier: constraint.processId, roleIdentifier: constraint.roleId };
+        });
+    }
+}
+RoleGuardService.ctorParameters = () => [
+    { type: RedirectService },
+    { type: UserService },
+    { type: ConfigurationService },
+    { type: LoggerService }
+];
+RoleGuardService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RoleGuardService_Factory() { return new RoleGuardService(i0.ɵɵinject(i1.RedirectService), i0.ɵɵinject(i2.UserService), i0.ɵɵinject(i3.ConfigurationService), i0.ɵɵinject(i4.LoggerService)); }, token: RoleGuardService, providedIn: i5.AuthenticationModule });
+RoleGuardService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: AuthenticationModule
+            },] }
+];
+RoleGuardService.ctorParameters = () => [
+    { type: RedirectService },
+    { type: UserService },
+    { type: ConfigurationService },
+    { type: LoggerService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role-guard.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/authorization/role/role-guard.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {ActivatedRouteSnapshot, CanActivate, RouterStateSnapshot, UrlTree} from '@angular/router';\nimport {UserService} from '../../user/services/user.service';\nimport {AuthenticationModule} from '../../authentication/authentication.module';\nimport {RedirectService} from '../../routing/redirect-service/redirect.service';\nimport {ConfigurationService} from '../../configuration/configuration.service';\nimport {Access, RoleAccess, View} from '../../../commons/schema';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {Observable} from 'rxjs';\n\n\ninterface RoleConstraint {\n    processIdentifier: string;\n    roleIdentifier?: string;\n    roleName?: string;\n}\n\n@Injectable({\n    providedIn: AuthenticationModule\n})\nexport class RoleGuardService implements CanActivate {\n\n    private readonly _loginUrl: string;\n\n    constructor(protected _redirectService: RedirectService,\n                protected _userService: UserService,\n                protected _configService: ConfigurationService,\n                protected _log: LoggerService) {\n        this._loginUrl = this._redirectService.resolveLoginPath();\n    }\n\n    canActivate(route: ActivatedRouteSnapshot,\n                state: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree {\n        this._redirectService.intendedRoute = route;\n        const view = this._configService.getViewByUrl(state.url.toString());\n        return this.canAccessView(view, state.url.toString());\n    }\n\n    public canAccessView(view: View, url: string): boolean {\n        if (typeof view.access !== 'string' && view.access.hasOwnProperty('role')) {\n            const allowedRoles = this.parseRoleConstraints(view.access.role, url);\n\n            return allowedRoles.some(constraint => {\n                if (constraint.roleIdentifier) {\n                    return this._userService.hasRoleByIdentifier(constraint.roleIdentifier, constraint.processIdentifier);\n                } else {\n                    return this._userService.hasRoleByName(constraint.roleName, constraint.processIdentifier);\n                }\n            });\n        }\n        throw new Error('Role guard is declared for a view with no role guard configuration!'\n            + ` Add role guard configuration for view at ${url}, or remove the guard.`);\n    }\n\n    protected parseRoleConstraints(roleConstrains: Access['role'], viewUrl: string): Array<RoleConstraint> {\n        if (typeof roleConstrains === 'string') {\n            return this.parseStringRoleConstraints(roleConstrains);\n        }\n        if (Array.isArray(roleConstrains)) {\n            if (roleConstrains.length === 0) {\n                this._log.warn(`View at '${viewUrl}' defines role access constraint with an empty array!`\n                    + ` No users will be allowed to enter this view!`);\n                return [];\n            }\n            if (typeof roleConstrains[0] === 'string') {\n                return this.parseStringRoleConstraints(roleConstrains as Array<string>);\n            }\n        }\n        return this.parseObjectRoleConstrains(roleConstrains as RoleAccess | Array<RoleAccess>);\n    }\n\n    /**\n     * @deprecated in 5.0.0\n     */\n    protected parseStringRoleConstraints(roleConstrains: string | Array<string>): Array<RoleConstraint> {\n        if (!Array.isArray(roleConstrains)) {\n            roleConstrains = [roleConstrains];\n        }\n\n        this._log.warn('Using string role guard configuration is deprecated! Migrate to object based configuration instead.');\n\n        return roleConstrains.map(constraint => {\n            const splitRoleArray = constraint.split('.');\n            if (splitRoleArray.length === 2) {\n                return {processIdentifier: splitRoleArray[0], roleName: splitRoleArray[1]};\n            } else {\n                throw new Error('Please enter the correct format <net import id>.<role name>');\n            }\n        });\n    }\n\n    protected parseObjectRoleConstrains(roleConstrains: RoleAccess | Array<RoleAccess>): Array<RoleConstraint> {\n        if (!Array.isArray(roleConstrains)) {\n            roleConstrains = [roleConstrains];\n        }\n\n        return roleConstrains.map(constraint => {\n            if (!constraint.roleId || !constraint.processId) {\n                throw new Error('Please enter both process and role id for a role constraint: ' + constraint);\n            }\n            return {processIdentifier: constraint.processId, roleIdentifier: constraint.roleId};\n        });\n    }\n\n}\n"]}

package/esm2015/lib/changed-fields/public-api.js

@@ -0,0 +1,2 @@
+export * from './services/changed-fields.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9jaGFuZ2VkLWZpZWxkcy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUNBQW1DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2NoYW5nZWQtZmllbGRzLnNlcnZpY2UnO1xuIl19

package/esm2015/lib/changed-fields/services/changed-fields.service.js

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+export class ChangedFieldsService {
+    constructor() {
+        this._changedFields$ = new Subject();
+    }
+    ngOnDestroy() {
+        this._changedFields$.complete();
+    }
+    get changedFields$() {
+        return this._changedFields$.asObservable();
+    }
+    emitChangedFields(changedFields) {
+        if (changedFields === undefined || Object.keys(changedFields).length === 0) {
+            return;
+        }
+        this._changedFields$.next(changedFields);
+    }
+    parseChangedFieldsByCaseAndTaskIds(caseId, taskIds, changedFieldsMap) {
+        const changedFields = [];
+        const filteredTaskIds = Object.keys(changedFieldsMap[caseId]).filter(taskId => taskIds.includes(taskId));
+        filteredTaskIds.forEach(taskId => {
+            changedFields.push(changedFieldsMap[caseId][taskId]);
+        });
+        return changedFields;
+    }
+}
+ChangedFieldsService.decorators = [
+    { type: Injectable }
+];
+ChangedFieldsService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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