@netgrif/components-core 6.0.1

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

@@ -0,0 +1,126 @@
+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";
+var PermissionService = /** @class */ (function () {
+    function PermissionService(userComparator, _userService) {
+        this.userComparator = userComparator;
+        this._userService = _userService;
+    }
+    PermissionService.prototype.hasTaskPermission = function (task, permission) {
+        if (!task) {
+            return false;
+        }
+        var rolePermValue = this.checkRolePerms(task.roles, permission);
+        var userPermValue = this.checkUserPerms(task.users, permission);
+        return this.resolvePermissions(rolePermValue, userPermValue);
+    };
+    PermissionService.prototype.hasCasePermission = function (case_, permission) {
+        if (!case_) {
+            return false;
+        }
+        var rolePermValue = this.checkRolePerms(case_.permissions, permission);
+        var userPermValue = this.checkUserPerms(case_.users, permission);
+        return this.resolvePermissions(rolePermValue, userPermValue);
+    };
+    PermissionService.prototype.resolvePermissions = function (rolePermValue, userPermValue) {
+        return userPermValue === undefined ? (!!rolePermValue) : userPermValue;
+    };
+    PermissionService.prototype.hasNetPermission = function (action, net) {
+        var _this = this;
+        if (!net
+            || !net.permissions
+            || !action
+            || !(net.permissions instanceof Object)) {
+            return false;
+        }
+        if (Object.keys(net.permissions).some(function (role) {
+            return _this._userService.hasRoleById(role) ? net.permissions[role][action] === false : false;
+        })) {
+            return false;
+        }
+        if (!Object.keys(net.permissions).filter(function (role) { return Object.keys(net.permissions[role])
+            .some(function (perm) { return perm === action; }); }).some(function (role) {
+            return !!net.permissions[role][action];
+        })) {
+            return true;
+        }
+        return Object.keys(net.permissions).some(function (role) {
+            return _this._userService.hasRoleById(role) ? !!net.permissions[role][action] : false;
+        });
+    };
+    PermissionService.prototype.canAssign = function (task) {
+        return !!task
+            && ((task.assignPolicy === AssignPolicy.manual
+                && !task.user
+                && this.hasTaskPermission(task, PermissionType.ASSIGN)));
+    };
+    PermissionService.prototype.canCancel = function (task) {
+        return !!task && !!task.user
+            && this.hasTaskPermission(task, PermissionType.CANCEL)
+            && ((task.assignedUserPolicy === undefined || task.assignedUserPolicy.cancel === undefined)
+                || task.assignedUserPolicy.cancel);
+    };
+    PermissionService.prototype.canReassign = function (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);
+    };
+    PermissionService.prototype.canFinish = function (task) {
+        return !!task
+            && !!task.user
+            && this.userComparator.compareUsers(task.user)
+            && this.hasTaskPermission(task, PermissionType.FINISH);
+    };
+    PermissionService.prototype.canCollapse = function (task) {
+        return !!task
+            && task.assignPolicy === AssignPolicy.manual;
+    };
+    PermissionService.prototype.checkRolePerms = function (roles, permission) {
+        var _this = this;
+        var rolePermValue;
+        if (!!roles) {
+            Object.keys(roles).forEach(function (role) {
+                if (roles[role][permission] !== undefined && _this._userService.hasRoleById(role)) {
+                    rolePermValue = rolePermValue === undefined ? roles[role][permission] : rolePermValue && roles[role][permission];
+                }
+            });
+        }
+        return rolePermValue;
+    };
+    PermissionService.prototype.checkUserPerms = function (users, permission) {
+        var userPermValue;
+        if (!!users) {
+            var loggedUserId_1 = this._userService.user.id;
+            Object.keys(users).forEach(function (user) {
+                if (user === loggedUserId_1 && users[user][permission] !== undefined) {
+                    userPermValue = userPermValue === undefined ?
+                        users[user][permission] : userPermValue && users[user][permission];
+                }
+            });
+        }
+        return userPermValue;
+    };
+    PermissionService.ctorParameters = function () { return [
+        { 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 = function () { return [
+        { type: UserComparatorService },
+        { type: UserService }
+    ]; };
+    return PermissionService;
+}());
+export { PermissionService };
+//# 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/esm5/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/esm5/lib/authorization/role/role-guard.service.js

@@ -0,0 +1,108 @@
+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";
+var RoleGuardService = /** @class */ (function () {
+    function RoleGuardService(_redirectService, _userService, _configService, _log) {
+        this._redirectService = _redirectService;
+        this._userService = _userService;
+        this._configService = _configService;
+        this._log = _log;
+        this._loginUrl = this._redirectService.resolveLoginPath();
+    }
+    RoleGuardService.prototype.canActivate = function (route, state) {
+        this._redirectService.intendedRoute = route;
+        var view = this._configService.getViewByUrl(state.url.toString());
+        return this.canAccessView(view, state.url.toString());
+    };
+    RoleGuardService.prototype.canAccessView = function (view, url) {
+        var _this = this;
+        if (typeof view.access !== 'string' && view.access.hasOwnProperty('role')) {
+            var allowedRoles = this.parseRoleConstraints(view.access.role, url);
+            return allowedRoles.some(function (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."));
+    };
+    RoleGuardService.prototype.parseRoleConstraints = function (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
+     */
+    RoleGuardService.prototype.parseStringRoleConstraints = function (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(function (constraint) {
+            var 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>');
+            }
+        });
+    };
+    RoleGuardService.prototype.parseObjectRoleConstrains = function (roleConstrains) {
+        if (!Array.isArray(roleConstrains)) {
+            roleConstrains = [roleConstrains];
+        }
+        return roleConstrains.map(function (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 = function () { return [
+        { 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 = function () { return [
+        { type: RedirectService },
+        { type: UserService },
+        { type: ConfigurationService },
+        { type: LoggerService }
+    ]; };
+    return RoleGuardService;
+}());
+export { RoleGuardService };
+//# 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/esm5/lib/changed-fields/public-api.js

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

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

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

package/esm5/lib/configuration/configuration.service.js

@@ -0,0 +1,208 @@
+import { __assign, __read, __spread, __values } from "tslib";
+import { of } from 'rxjs';
+var ConfigurationService = /** @class */ (function () {
+    function ConfigurationService(configuration) {
+        this.configuration = configuration;
+        this.resolveEndpointURLs();
+        this._dataFieldConfiguration = this.getConfigurationSubtree(['services', 'dataFields']);
+    }
+    ConfigurationService.prototype.getAsync = function () {
+        return of(this.get());
+    };
+    /**
+     * @returns a deep copy of the entire configuration object
+     */
+    ConfigurationService.prototype.get = function () {
+        return this.createConfigurationCopy();
+    };
+    /**
+     * Get view configuration from nae.json for view at given config path.
+     * @param viewConfigPath configuration path to the requested view. No leading backslash.
+     * @return requested configuration if it exists. `undefined` otherwise.
+     */
+    ConfigurationService.prototype.getViewByPath = function (viewConfigPath) {
+        var viewPathSegments = viewConfigPath.split('/');
+        var configTreePathSegments = ['views'];
+        for (var i = 0; i < viewPathSegments.length; i++) {
+            if (i > 0) {
+                configTreePathSegments.push('children');
+            }
+            configTreePathSegments.push(viewPathSegments[i]);
+        }
+        return this.getConfigurationSubtree(configTreePathSegments);
+    };
+    /**
+     * Get view configuration from nae.json for view at given url.
+     * @param url to the requested view. Necessary backslash.
+     * @return requested configuration if it exists. `undefined` otherwise.
+     */
+    ConfigurationService.prototype.getViewByUrl = function (url) {
+        var config = this.createConfigurationCopy();
+        var views = config.views;
+        if (!views) {
+            return undefined;
+        }
+        var map = new Map();
+        map = this.getChildren(views, map, '');
+        if (map.get(url) === undefined) {
+            map.forEach(function (value, key) {
+                if (key.includes('/**') && url.includes(key.split('/**')[0]))
+                    return value;
+            });
+        }
+        return map.get(url);
+    };
+    ConfigurationService.prototype.getChildren = function (views, map, prefix) {
+        var _this = this;
+        Object.keys(views).forEach(function (view) {
+            if (!!views[view].routing.path) {
+                prefix = prefix.charAt(prefix.length - 1) === '/' ?
+                    prefix.length > 1 ? prefix.substring(0, prefix.length - 2) : '' :
+                    prefix;
+                var viewPath = views[view].routing.path.charAt(0) === '/' ?
+                    views[view].routing.path.length > 1 ? views[view].routing.path.substring(1) : '' :
+                    views[view].routing.path;
+                map.set(views[view].routing.match ?
+                    prefix + '/' + viewPath + '/**' :
+                    prefix + '/' + viewPath, views[view]);
+            }
+            if (views[view].children) {
+                _this.getChildren(views[view].children, map, prefix + '/' + views[view].routing.path);
+            }
+        });
+        return map;
+    };
+    /**
+     * Get all URLs/paths of views with specified layout.
+     * @param layout Search views with this layout
+     * @returns Paths with prefixed '/' of all views with specified layout, empty array otherwise.
+     */
+    ConfigurationService.prototype.getPathsByView = function (layout) {
+        var _this = this;
+        var config = this.createConfigurationCopy();
+        var result = [];
+        if (!config.views) {
+            return result;
+        }
+        Object.values(config.views).forEach(function (view) {
+            result.push.apply(result, __spread(_this.getView(layout, view).map(function (path) { return '/' + path; })));
+        });
+        return result;
+    };
+    /**
+     * @param pathSegments the keys specifying the path trough the configuration that should be accessed
+     * @returns a deep copy of a specified subsection of the configuration object, or `undefined` if such subsection doesn't exist.
+     * Calling this method with an empty array as argument is equivalent to calling the [get()]{@link ConfigurationService#get} method.
+     */
+    ConfigurationService.prototype.getConfigurationSubtree = function (pathSegments) {
+        var e_1, _a;
+        var root = this.configuration;
+        try {
+            for (var pathSegments_1 = __values(pathSegments), pathSegments_1_1 = pathSegments_1.next(); !pathSegments_1_1.done; pathSegments_1_1 = pathSegments_1.next()) {
+                var segment = pathSegments_1_1.value;
+                if (root[segment] === undefined) {
+                    return undefined;
+                }
+                root = root[segment];
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (pathSegments_1_1 && !pathSegments_1_1.done && (_a = pathSegments_1.return)) _a.call(pathSegments_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return this.deepCopy(root);
+    };
+    /**
+     * @returns the appropriate template configuration for data fields, or `undefined` if such configuration is not present.
+     */
+    ConfigurationService.prototype.getDatafieldConfiguration = function () {
+        if (this._dataFieldConfiguration === undefined) {
+            return undefined;
+        }
+        return __assign({}, this._dataFieldConfiguration);
+    };
+    /**
+     * Resolves the URL addresses of backend endpoints based on the provided configuration.
+     *
+     * If the URLs begin with either `http://`, or `https://` the provided URL will be used.
+     *
+     * If not, then the URLs are considered to be relative to the location of the frontend application and it's URL will be used
+     * as the base path. `/api` is appended automatically.
+     */
+    ConfigurationService.prototype.resolveEndpointURLs = function () {
+        var _this = this;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (((_c = (_b = (_a = this.configuration) === null || _a === void 0 ? void 0 : _a.providers) === null || _b === void 0 ? void 0 : _b.auth) === null || _c === void 0 ? void 0 : _c.address) === undefined) {
+            throw new Error("'provider.auth.address' is a required property and must be present in the configuration!");
+        }
+        this.configuration.providers.auth.address = this.resolveURL(this.configuration.providers.auth.address);
+        if (((_e = (_d = this.configuration) === null || _d === void 0 ? void 0 : _d.providers) === null || _e === void 0 ? void 0 : _e.resources) === undefined) {
+            throw new Error("'provider.resources' is a required property and must be present in the configuration!");
+        }
+        if (Array.isArray(this.configuration.providers.resources)) {
+            this.configuration.providers.resources.forEach(function (resource) {
+                if ((resource === null || resource === void 0 ? void 0 : resource.address) === undefined) {
+                    throw new Error("Resources defined in 'provider.resources' must define an address property!");
+                }
+                resource.address = _this.resolveURL(resource.address);
+            });
+        }
+        else {
+            if (((_h = (_g = (_f = this.configuration) === null || _f === void 0 ? void 0 : _f.providers) === null || _g === void 0 ? void 0 : _g.resources) === null || _h === void 0 ? void 0 : _h.address) === undefined) {
+                throw new Error("Resources defined in 'provider.resources' must define an address property!");
+            }
+            this.configuration.providers.resources.address = this.resolveURL(this.configuration.providers.resources.address);
+        }
+    };
+    /**
+     * Resolves a single URL address.
+     *
+     * If the URL begins with either `http://`, or `https://` the provided URL will be used.
+     *
+     * If not, then the URL is considered to be relative to the location of the frontend application and it's URL will be used
+     * as the base path. `/api` is appended automatically.
+     *
+     * @param configURL value from the configuration file
+     * @returns the resolved URL
+     */
+    ConfigurationService.prototype.resolveURL = function (configURL) {
+        if (configURL.startsWith('http://') || configURL.startsWith('https://')) {
+            return configURL;
+        }
+        else {
+            return location.origin + '/api' + configURL;
+        }
+    };
+    /**
+     * @returns the services configuration, or `undefined` if such configuration is not present.
+     */
+    ConfigurationService.prototype.getServicesConfiguration = function () {
+        var subtree = this.getConfigurationSubtree(['services']);
+        return subtree !== undefined ? this.deepCopy(subtree) : undefined;
+    };
+    ConfigurationService.prototype.getView = function (searched, view) {
+        var _this = this;
+        var paths = [];
+        if (!!view.layout && view.layout.name === searched) {
+            paths.push(view.routing.path);
+        }
+        if (view.children && Object.keys(view.children).length !== 0) {
+            Object.values(view.children).forEach(function (child) {
+                paths.push.apply(paths, __spread(_this.getView(searched, child).map(function (path) { return view.routing.path + '/' + path; })));
+            });
+        }
+        return paths;
+    };
+    ConfigurationService.prototype.createConfigurationCopy = function () {
+        return this.deepCopy(this.configuration);
+    };
+    ConfigurationService.prototype.deepCopy = function (obj) {
+        return JSON.parse(JSON.stringify(obj));
+    };
+    return ConfigurationService;
+}());
+export { ConfigurationService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/configuration/configuration.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {NetgrifApplicationEngine, Services, View, Views} from '../../commons/schema';\nimport {Observable, of} from 'rxjs';\n\nexport abstract class ConfigurationService {\n\n    private readonly _dataFieldConfiguration: Services['dataFields'];\n\n    protected constructor(protected configuration: NetgrifApplicationEngine) {\n        this.resolveEndpointURLs();\n        this._dataFieldConfiguration = this.getConfigurationSubtree(['services', 'dataFields']);\n    }\n\n    public getAsync(): Observable<NetgrifApplicationEngine> {\n        return of(this.get());\n    }\n\n    /**\n     * @returns a deep copy of the entire configuration object\n     */\n    public get(): NetgrifApplicationEngine {\n        return this.createConfigurationCopy();\n    }\n\n    /**\n     * Get view configuration from nae.json for view at given config path.\n     * @param viewConfigPath configuration path to the requested view. No leading backslash.\n     * @return requested configuration if it exists. `undefined` otherwise.\n     */\n    public getViewByPath(viewConfigPath: string): View | undefined {\n        const viewPathSegments = viewConfigPath.split('/');\n        const configTreePathSegments = ['views'];\n        for (let i = 0; i < viewPathSegments.length; i++) {\n            if (i > 0) {\n                configTreePathSegments.push('children');\n            }\n            configTreePathSegments.push(viewPathSegments[i]);\n        }\n        return this.getConfigurationSubtree(configTreePathSegments);\n    }\n\n    /**\n     * Get view configuration from nae.json for view at given url.\n     * @param url to the requested view. Necessary backslash.\n     * @return requested configuration if it exists. `undefined` otherwise.\n     */\n    public getViewByUrl(url: string): View | undefined {\n        const config = this.createConfigurationCopy() as NetgrifApplicationEngine;\n        const views = config.views;\n        if (!views) {\n            return undefined;\n        }\n        let map: Map<string, View> = new Map();\n        map = this.getChildren(views, map, '');\n        if (map.get(url) === undefined) {\n            map.forEach((value, key) => {\n                if (key.includes('/**') && url.includes(key.split('/**')[0]))\n                    return value;\n            });\n        }\n        return map.get(url);\n    }\n\n    private getChildren(views: Views, map: Map<string, View>, prefix: string): Map<string, View> {\n        Object.keys(views).forEach(view => {\n            if (!!views[view].routing.path) {\n                prefix = prefix.charAt(prefix.length - 1) === '/' ?\n                    prefix.length > 1 ? prefix.substring(0, prefix.length - 2) : '' :\n                    prefix;\n                const viewPath = views[view].routing.path.charAt(0) === '/' ?\n                    views[view].routing.path.length > 1 ? views[view].routing.path.substring(1) : '' :\n                    views[view].routing.path;\n                map.set(\n                    views[view].routing.match ?\n                        prefix + '/' + viewPath + '/**' :\n                        prefix + '/' + viewPath,\n                    views[view]);\n            }\n            if (views[view].children) {\n                this.getChildren(views[view].children, map, prefix + '/' + views[view].routing.path);\n            }\n        });\n        return map;\n    }\n\n    /**\n     * Get all URLs/paths of views with specified layout.\n     * @param layout Search views with this layout\n     * @returns Paths with prefixed '/' of all views with specified layout, empty array otherwise.\n     */\n    public getPathsByView(layout: string): Array<string> {\n        const config = this.createConfigurationCopy() as NetgrifApplicationEngine;\n        const result = [];\n        if (!config.views) {\n            return result;\n        }\n        Object.values(config.views).forEach(view => {\n            result.push(...this.getView(layout, view).map(path => '/' + path));\n        });\n\n        return result;\n    }\n\n    /**\n     * @param pathSegments the keys specifying the path trough the configuration that should be accessed\n     * @returns a deep copy of a specified subsection of the configuration object, or `undefined` if such subsection doesn't exist.\n     * Calling this method with an empty array as argument is equivalent to calling the [get()]{@link ConfigurationService#get} method.\n     */\n    public getConfigurationSubtree(pathSegments: Array<string>): any | undefined {\n        let root = this.configuration;\n        for (const segment of pathSegments) {\n            if (root[segment] === undefined) {\n                return undefined;\n            }\n            root = root[segment];\n        }\n        return this.deepCopy(root);\n    }\n\n    /**\n     * @returns the appropriate template configuration for data fields, or `undefined` if such configuration is not present.\n     */\n    public getDatafieldConfiguration(): Services['dataFields'] | undefined {\n        if (this._dataFieldConfiguration === undefined) {\n            return undefined;\n        }\n        return {...this._dataFieldConfiguration};\n    }\n\n    /**\n     * Resolves the URL addresses of backend endpoints based on the provided configuration.\n     *\n     * If the URLs begin with either `http://`, or `https://` the provided URL will be used.\n     *\n     * If not, then the URLs are considered to be relative to the location of the frontend application and it's URL will be used\n     * as the base path. `/api` is appended automatically.\n     */\n    protected resolveEndpointURLs() {\n        if (this.configuration?.providers?.auth?.address === undefined) {\n            throw new Error(`'provider.auth.address' is a required property and must be present in the configuration!`);\n        }\n        this.configuration.providers.auth.address = this.resolveURL(this.configuration.providers.auth.address);\n\n        if (this.configuration?.providers?.resources === undefined) {\n            throw new Error(`'provider.resources' is a required property and must be present in the configuration!`);\n        }\n        if (Array.isArray(this.configuration.providers.resources)) {\n            this.configuration.providers.resources.forEach(resource => {\n                if (resource?.address === undefined) {\n                    throw new Error(`Resources defined in 'provider.resources' must define an address property!`);\n                }\n                resource.address = this.resolveURL(resource.address);\n            });\n        } else {\n            if (this.configuration?.providers?.resources?.address === undefined) {\n                throw new Error(`Resources defined in 'provider.resources' must define an address property!`);\n            }\n            this.configuration.providers.resources.address = this.resolveURL(this.configuration.providers.resources.address);\n        }\n    }\n\n    /**\n     * Resolves a single URL address.\n     *\n     * If the URL begins with either `http://`, or `https://` the provided URL will be used.\n     *\n     * If not, then the URL is considered to be relative to the location of the frontend application and it's URL will be used\n     * as the base path. `/api` is appended automatically.\n     *\n     * @param configURL value from the configuration file\n     * @returns the resolved URL\n     */\n    protected resolveURL(configURL: string): string {\n        if (configURL.startsWith('http://') || configURL.startsWith('https://')) {\n            return configURL;\n        } else {\n            return location.origin + '/api' + configURL;\n        }\n    }\n\n    /**\n     * @returns the services configuration, or `undefined` if such configuration is not present.\n     */\n    public getServicesConfiguration(): Services | undefined {\n        const subtree = this.getConfigurationSubtree(['services']) as Services;\n        return subtree !== undefined ? this.deepCopy(subtree) as Services : undefined;\n    }\n\n    private getView(searched: string, view: View): Array<string> {\n        const paths = [];\n        if (!!view.layout && view.layout.name === searched) {\n            paths.push(view.routing.path);\n        }\n        if (view.children && Object.keys(view.children).length !== 0) {\n            Object.values(view.children).forEach(child => {\n                paths.push(...this.getView(searched, child).map(path => view.routing.path + '/' + path));\n            });\n        }\n        return paths;\n    }\n\n    private createConfigurationCopy(): any {\n        return this.deepCopy(this.configuration);\n    }\n\n    private deepCopy(obj: object): object {\n        return JSON.parse(JSON.stringify(obj));\n    }\n}\n"]}

package/esm5/lib/configuration/public-api.js

@@ -0,0 +1,3 @@
+/* SERVICES */
+export * from './configuration.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9jb25maWd1cmF0aW9uL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBTRVJWSUNFUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9jb25maWd1cmF0aW9uLnNlcnZpY2UnO1xuIl19

package/esm5/lib/covalent/covalent.module.js

@@ -0,0 +1,26 @@
+import { NgModule } from '@angular/core';
+import { CovalentHighlightModule } from '@covalent/highlight';
+import { CovalentMarkdownModule } from '@covalent/markdown';
+import { CovalentCommonModule } from '@covalent/core/common';
+import { CovalentLayoutModule } from '@covalent/core/layout';
+import { CovalentStepsModule } from '@covalent/core/steps';
+import { CovalentTextEditorModule } from '@covalent/text-editor';
+var CovalentModule = /** @class */ (function () {
+    function CovalentModule() {
+    }
+    CovalentModule.decorators = [
+        { type: NgModule, args: [{
+                    exports: [
+                        CovalentHighlightModule,
+                        CovalentMarkdownModule,
+                        CovalentLayoutModule,
+                        CovalentStepsModule,
+                        CovalentCommonModule,
+                        CovalentTextEditorModule,
+                    ]
+                },] }
+    ];
+    return CovalentModule;
+}());
+export { CovalentModule };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY292YWxlbnQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL2NvdmFsZW50L2NvdmFsZW50Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyx1QkFBdUIsRUFBQyxNQUFNLHFCQUFxQixDQUFDO0FBQzVELE9BQU8sRUFBQyxzQkFBc0IsRUFBQyxNQUFNLG9CQUFvQixDQUFDO0FBQzFELE9BQU8sRUFBQyxvQkFBb0IsRUFBQyxNQUFNLHVCQUF1QixDQUFDO0FBQzNELE9BQU8sRUFBQyxvQkFBb0IsRUFBQyxNQUFNLHVCQUF1QixDQUFDO0FBQzNELE9BQU8sRUFBQyxtQkFBbUIsRUFBQyxNQUFNLHNCQUFzQixDQUFDO0FBQ3pELE9BQU8sRUFBQyx3QkFBd0IsRUFBQyxNQUFNLHVCQUF1QixDQUFDO0FBRy9EO0lBQUE7SUFXQSxDQUFDOztnQkFYQSxRQUFRLFNBQUM7b0JBQ04sT0FBTyxFQUFFO3dCQUNMLHVCQUF1Qjt3QkFDdkIsc0JBQXNCO3dCQUN0QixvQkFBb0I7d0JBQ3BCLG1CQUFtQjt3QkFDbkIsb0JBQW9CO3dCQUNwQix3QkFBd0I7cUJBQzNCO2lCQUNKOztJQUVELHFCQUFDO0NBQUEsQUFYRCxJQVdDO1NBRFksY0FBYyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtDb3ZhbGVudEhpZ2hsaWdodE1vZHVsZX0gZnJvbSAnQGNvdmFsZW50L2hpZ2hsaWdodCc7XG5pbXBvcnQge0NvdmFsZW50TWFya2Rvd25Nb2R1bGV9IGZyb20gJ0Bjb3ZhbGVudC9tYXJrZG93bic7XG5pbXBvcnQge0NvdmFsZW50Q29tbW9uTW9kdWxlfSBmcm9tICdAY292YWxlbnQvY29yZS9jb21tb24nO1xuaW1wb3J0IHtDb3ZhbGVudExheW91dE1vZHVsZX0gZnJvbSAnQGNvdmFsZW50L2NvcmUvbGF5b3V0JztcbmltcG9ydCB7Q292YWxlbnRTdGVwc01vZHVsZX0gZnJvbSAnQGNvdmFsZW50L2NvcmUvc3RlcHMnO1xuaW1wb3J0IHtDb3ZhbGVudFRleHRFZGl0b3JNb2R1bGV9IGZyb20gJ0Bjb3ZhbGVudC90ZXh0LWVkaXRvcic7XG5cblxuQE5nTW9kdWxlKHtcbiAgICBleHBvcnRzOiBbXG4gICAgICAgIENvdmFsZW50SGlnaGxpZ2h0TW9kdWxlLFxuICAgICAgICBDb3ZhbGVudE1hcmtkb3duTW9kdWxlLFxuICAgICAgICBDb3ZhbGVudExheW91dE1vZHVsZSxcbiAgICAgICAgQ292YWxlbnRTdGVwc01vZHVsZSxcbiAgICAgICAgQ292YWxlbnRDb21tb25Nb2R1bGUsXG4gICAgICAgIENvdmFsZW50VGV4dEVkaXRvck1vZHVsZSxcbiAgICBdXG59KVxuZXhwb3J0IGNsYXNzIENvdmFsZW50TW9kdWxlIHtcbn1cbiJdfQ==