@mediusinc/mng-commons 6.0.0-rc.7 → 6.0.0

package/core/security/permission.service.d.ts

@@ -1,4 +1,4 @@
-import { ActivatedRouteSnapshot } from '@angular/router';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
 import { Observable } from 'rxjs';
 import { CommonsMenuItem } from '../models/menu.model';
 import { APermissions, IActionContextValidation } from './permissions.model';
@@ -8,7 +8,7 @@ export declare class PermissionService {
     private readonly commons;
     private readonly logger;
     private userRoles$;
-    canActivateRoute(permissions: APermissions, route?: ActivatedRouteSnapshot): Observable<boolean>;
+    canActivateRoute(permissions: APermissions, route?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): Observable<boolean>;
     private canActivateRouteAll;
     private canActivateRouteAny;
     private canActivateRouteService;
@@ -16,7 +16,7 @@ export declare class PermissionService {
     private isMenuItemVisibleAll;
     private isMenuItemVisibleAny;
     private isMenuItemVisibleService;
-    isActionVisible(permissions: APermissions, actionCtx?: IActionContextValidation<any, any>, route?: ActivatedRouteSnapshot): Observable<boolean>;
+    isActionVisible(permissions: APermissions, actionCtx?: IActionContextValidation<any, any>, route?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): Observable<boolean>;
     private isActionVisibleAll;
     private isActionVisibleAny;
     private isActionVisibleService;

package/core/security/permissions.model.d.ts

@@ -1,5 +1,5 @@
 import { Type } from '@angular/core';
-import { ActivatedRouteSnapshot } from '@angular/router';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
 import { Observable } from 'rxjs';
 import { ActionParameters } from '../action/action-parameters.model';
 import { IDataProvider } from '../data-providers/base.data-provider';
@@ -22,10 +22,11 @@ export interface IPermissionService {
      * Determines whether a route can be activated.
      *
      * @param {ActivatedRouteSnapshot} route - The route snapshot object representing the current route for activation.
+     * @param {RouterStateSnapshot} state - The router state snapshot
      *
      * @returns {Observable<boolean>} - An observable that emits a boolean value indicating whether the route can be activated.
      */
-    canActivateRoute(route?: ActivatedRouteSnapshot): Observable<boolean>;
+    canActivateRoute(route?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): Observable<boolean>;
     /**
      * Determines the visibility of menu item.
      *
@@ -39,10 +40,11 @@ export interface IPermissionService {
      *
      * @param {IActionContextValidation<any, any>} [actionCtx] - The action context object containing the necessary information for validation.
      * @param {ActivatedRouteSnapshot} [route] - The current route snapshot containing the necessary information for validation.
+     * @param {RouterStateSnapshot} state - The router state snapshot
      *
      * @return {Observable<boolean>} - An Observable that emits the visibility status of the action.
      */
-    isActionVisible(actionCtx?: IActionContextValidation<any, any>, route?: ActivatedRouteSnapshot): Observable<boolean>;
+    isActionVisible(actionCtx?: IActionContextValidation<any, any>, route?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): Observable<boolean>;
 }
 export declare abstract class APermissions {
     private readonly _authorizationType;

package/fesm2022/mediusinc-mng-commons-core.mjs

@@ -2832,31 +2832,31 @@ class PermissionService {
         this.logger = inject(LoggerService).create('AuthorizationService');
         this.userRoles$ = toObservable$1(this.commons.userRoles);
     }
-    canActivateRoute(permissions, route) {
+    canActivateRoute(permissions, route, state) {
         switch (permissions.authorizationType) {
             case PermissionTypeEnum.All:
-                return this.canActivateRouteAll(permissions, route);
+                return this.canActivateRouteAll(permissions, route, state);
             case PermissionTypeEnum.Any:
-                return this.canActivateRouteAny(permissions, route);
+                return this.canActivateRouteAny(permissions, route, state);
             case PermissionTypeEnum.Service:
-                return this.canActivateRouteService(permissions, route);
+                return this.canActivateRouteService(permissions, route, state);
             default:
                 return this.userRoles$.pipe(map(ur => isPermitted(permissions, ur)));
         }
     }
-    canActivateRouteAll(permission, route) {
-        return combineLatest(permission.permissions.map(p => this.canActivateRoute(p, route))).pipe(map(res => res.every(ip => ip === true)));
+    canActivateRouteAll(permission, route, state) {
+        return combineLatest(permission.permissions.map(p => this.canActivateRoute(p, route, state))).pipe(map(res => res.every(ip => ip === true)));
     }
-    canActivateRouteAny(permissions, route) {
-        return combineLatest(permissions.permissions.map(p => this.canActivateRoute(p, route))).pipe(map(res => res.some(ip => ip === true)));
+    canActivateRouteAny(permissions, route, state) {
+        return combineLatest(permissions.permissions.map(p => this.canActivateRoute(p, route, state))).pipe(map(res => res.some(ip => ip === true)));
     }
-    canActivateRouteService(permission, route) {
+    canActivateRouteService(permission, route, state) {
         const serviceInstance = this.injector.get(permission.service);
         if (!serviceInstance) {
             this.logger.debug(`WARNING: Service instance could not be retrieved for type ${permission.service}`);
             return of(false);
         }
-        return serviceInstance.canActivateRoute(route);
+        return serviceInstance.canActivateRoute(route, state);
     }
     isMenuItemVisible(permissions, menuItem) {
         switch (permissions.authorizationType) {
@@ -2884,31 +2884,31 @@ class PermissionService {
         }
         return serviceInstance.isMenuitemVisible(menuItem);
     }
-    isActionVisible(permissions, actionCtx, route) {
+    isActionVisible(permissions, actionCtx, route, state) {
         switch (permissions.authorizationType) {
             case PermissionTypeEnum.All:
-                return this.isActionVisibleAll(permissions, actionCtx, route);
+                return this.isActionVisibleAll(permissions, actionCtx, route, state);
             case PermissionTypeEnum.Any:
-                return this.isActionVisibleAny(permissions, actionCtx, route);
+                return this.isActionVisibleAny(permissions, actionCtx, route, state);
             case PermissionTypeEnum.Service:
-                return this.isActionVisibleService(permissions, actionCtx, route);
+                return this.isActionVisibleService(permissions, actionCtx, route, state);
             default:
                 return this.userRoles$.pipe(map(ur => isPermitted(permissions, ur)));
         }
     }
-    isActionVisibleAll(permission, actionCtx, route) {
-        return combineLatest(permission.permissions.map(p => this.isActionVisible(p, actionCtx, route))).pipe(map(res => res.every(ip => ip === true)));
+    isActionVisibleAll(permission, actionCtx, route, state) {
+        return combineLatest(permission.permissions.map(p => this.isActionVisible(p, actionCtx, route, state))).pipe(map(res => res.every(ip => ip === true)));
     }
-    isActionVisibleAny(permission, actionCtx, route) {
-        return combineLatest(permission.permissions.map(p => this.isActionVisible(p, actionCtx, route))).pipe(map(res => res.some(ip => ip === true)));
+    isActionVisibleAny(permission, actionCtx, route, state) {
+        return combineLatest(permission.permissions.map(p => this.isActionVisible(p, actionCtx, route, state))).pipe(map(res => res.some(ip => ip === true)));
     }
-    isActionVisibleService(permission, actionCtx, route) {
+    isActionVisibleService(permission, actionCtx, route, state) {
         const serviceInstance = this.injector.get(permission.service);
         if (!serviceInstance) {
             this.logger.debug(`WARNING: Service instance could not be retreived for type ${permission.service}`);
             return of(false);
         }
-        return serviceInstance.isActionVisible(actionCtx, route);
+        return serviceInstance.isActionVisible(actionCtx, route, state);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: PermissionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: PermissionService }); }
@@ -2917,11 +2917,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.7", ngImpor
             type: Injectable
         }] });
 
-const permissionGuard = (route) => {
+const permissionGuard = (route, state) => {
     const permission = inject(PermissionService);
     const data = route.data;
     if (data.permissions) {
-        return permission.canActivateRoute(data.permissions, route).pipe(first());
+        return permission.canActivateRoute(data.permissions, route, state).pipe(first());
     }
     else {
         return of(true);