@tomei/sso 0.52.1 → 0.52.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomei/sso",
-  "version": "0.52.1",
+  "version": "0.52.3",
   "description": "Tomei SSO Package",
   "main": "dist/index.js",
   "scripts": {

package/src/components/group/group.ts

@@ -1192,11 +1192,6 @@ export class Group extends TreeNodeBase<Group> {
       //Retrieve Roles based on privilege on a system
       let systemWhere: any = {};
 
-      if (search) {
-        if (search.GroupCode.length) {
-        }
-      }
-
       if (SystemCode) {
         systemWhere = {
           SystemCode: {

package/src/components/user-system-access/user-system-access.repository.ts

@@ -9,6 +9,22 @@ export class UserSystemAccessRepository
     super(UserSystemAccessModel);
   }
 
+  async findAndCountAll(options?: any) {
+    try {
+      let UserSystemAccess: any;
+      if (options) {
+        UserSystemAccess = await UserSystemAccessModel.findAndCountAll(options);
+      } else {
+        UserSystemAccess = await UserSystemAccessModel.findAndCountAll();
+      }
+      return UserSystemAccess;
+    } catch (error) {
+      throw new Error(
+        `An Error occured when retriving UserSystemAccess: ${error.message}`,
+      );
+    }
+  }
+
   async delete(UserSystemAccessId: number, dbTransaction?: any) {
     try {
       const options = {

package/src/components/user-system-access/user-system-access.ts

@@ -2,9 +2,12 @@ import { ClassError, ObjectBase } from '@tomei/general';
 import { UserSystemAccessRepository } from './user-system-access.repository';
 import { IUserSystemAccess } from '../../interfaces/user-system-access.interface';
 import { User } from '../login-user/user';
-import { System } from '../system/system';
 import { ApplicationConfig } from '@tomei/config';
 import SystemModel from '../../models/system.entity';
+import SystemPrivilegeModel from '../../models/system-privilege.entity';
+import UserSystemAccessModel from '../../models/user-system-access.entity';
+import GroupModel from '../../models/group.entity';
+import GroupSystemAccessModel from '../../models/group-system-access.entity';
 import UserModel from '../../models/user.entity';
 import { ActionEnum, Activity } from '@tomei/activity-history';
 import { Op } from 'sequelize';
@@ -182,6 +185,232 @@ export class UserSystemAccess extends ObjectBase {
     }
   }
 
+  public static async findAllUsers(
+    loginUser: User, //The currently logged-in user initiating the request.
+    dbTransaction: any, //The active database transaction to ensure consistency during the query.
+    SystemCode: string,
+    Page: number,
+    Rows: number,
+    Search: {
+      UserId?: string | number;
+      Status?: string;
+    },
+  ) {
+    // Part 1: Privilege Checking
+    const systemCode = ApplicationConfig.getComponentConfigValue('system-code');
+    const isPrivileged = await loginUser.checkPrivileges(
+      systemCode,
+      'USER_SYSTEM_ACCESS_LIST',
+    );
+
+    if (!isPrivileged) {
+      throw new ClassError(
+        'UserSystemAccessUser',
+        'UserSystemAccessUserErrMsg01',
+        'You do not have permission to view system access users.',
+      );
+    }
+
+    try {
+      // Part 2: Retrieve System Access Users and returns
+      const queryObj: any = { SystemCode: SystemCode };
+
+      if (Search) {
+        Object.entries(Search).forEach(([key, value]) => {
+          queryObj[key] = value;
+        });
+      }
+
+      let options: any = {
+        where: queryObj,
+        distinct: true,
+        transaction: dbTransaction,
+      };
+
+      if (Page && Rows) {
+        options = {
+          ...options,
+          limit: Rows,
+          offset: Rows * (Page - 1),
+          order: [['CreatedAt', 'DESC']],
+          include: [
+            {
+              model: SystemModel,
+              attributes: ['Name', 'SystemCode'],
+            },
+            {
+              model: UserModel,
+              as: 'User',
+              attributes: ['UserId', 'FullName'],
+            },
+          ],
+        };
+      }
+
+      const userSystemAccesses =
+        await this._Repository.findAndCountAll(options);
+      return userSystemAccesses;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public static async findAllUserPrivileges(
+    loginUser: User, //The currently logged-in user initiating the request.
+    dbTransaction: any, //The active database transaction to ensure consistency during the query.
+    SystemCode: string,
+    search?: {
+      UserId?: string[];
+      Status?: string;
+    },
+  ) {
+    // Part 1: Privilege Checking
+    const systemCode = ApplicationConfig.getComponentConfigValue('system-code');
+    const isPrivileged = await loginUser.checkPrivileges(
+      systemCode,
+      'USER_SYSTEM_ACCESS_LIST',
+    );
+
+    if (!isPrivileged) {
+      throw new ClassError(
+        'UserSystemAccessUser',
+        'UserSystemAccessUserErrMsg01',
+        'You do not have permission to view system access users.',
+      );
+    }
+
+    try {
+      //Part 2: Retrieve User System Access Based on Privileges
+      let systemWhere: any = {};
+
+      if (SystemCode) {
+        systemWhere = {
+          SystemCode: {
+            [Op.substring]: SystemCode,
+          },
+        };
+      }
+
+      const allSystemAccessUsers = await UserSystemAccessModel.findAll({
+        include: [
+          {
+            model: SystemModel,
+            where: systemWhere,
+          },
+          {
+            model: UserModel,
+            as: 'User',
+            attributes: ['UserId', 'FullName'],
+          },
+        ],
+        transaction: dbTransaction,
+      });
+
+      const allPrivileges = await SystemPrivilegeModel.findAll({
+        where: systemWhere,
+        transaction: dbTransaction,
+      });
+
+      const systemAccessUserPrivileges = allPrivileges.map((privilege) => {
+        const filteredUsers = allSystemAccessUsers
+          .map((userAccess) => userAccess.User)
+          .filter((user) => search.UserId.includes(String(user.UserId)));
+
+        return {
+          ...privilege.get({ plain: true }),
+          Users: filteredUsers,
+        };
+      });
+
+      return systemAccessUserPrivileges;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public static async findAllUserRoles(
+    loginUser: User, //The currently logged-in user initiating the request.
+    dbTransaction: any, //The active database transaction to ensure consistency during the query.
+    SystemCode: string,
+    search?: {
+      UserId?: string[];
+      Status?: string;
+    },
+  ) {
+    // Part 1: Privilege Checking
+    const systemCode = ApplicationConfig.getComponentConfigValue('system-code');
+    const isPrivileged = await loginUser.checkPrivileges(
+      systemCode,
+      'USER_SYSTEM_ACCESS_LIST',
+    );
+
+    if (!isPrivileged) {
+      throw new ClassError(
+        'UserSystemAccessUser',
+        'UserSystemAccessUserErrMsg01',
+        'You do not have permission to view system access users.',
+      );
+    }
+
+    try {
+      //Part 2: Retrieve User System Access Based on Privileges
+      let systemWhere: any = {};
+
+      if (SystemCode) {
+        systemWhere = {
+          SystemCode: {
+            [Op.substring]: SystemCode,
+          },
+        };
+      }
+
+      const allGroupSystemAccess = await GroupSystemAccessModel.findAll({
+        where: systemWhere,
+        include: [
+          {
+            model: GroupModel,
+            where: {
+              Type: 'Role',
+            },
+          },
+        ],
+        transaction: dbTransaction,
+      });
+
+      const allSystemAccessUsers = await UserSystemAccessModel.findAll({
+        include: [
+          {
+            model: SystemModel,
+            where: systemWhere,
+          },
+          {
+            model: UserModel,
+            as: 'User',
+            attributes: ['UserId', 'FullName'],
+          },
+        ],
+        transaction: dbTransaction,
+      });
+
+      const systemAccessUserRoles = allGroupSystemAccess.map(
+        (groupSystemAccess) => {
+          const filteredUsers = allSystemAccessUsers
+            .map((userAccess) => userAccess.User)
+            .filter((user) => search.UserId.includes(String(user.UserId)));
+
+          return {
+            ...groupSystemAccess.Group.get({ plain: true }),
+            Users: filteredUsers,
+          };
+        },
+      );
+
+      return systemAccessUserRoles;
+    } catch (error) {
+      throw error;
+    }
+  }
+
   public static async createAccess(
     loginUser: User, //The currently logged-in user initiating the request.
     dbTransaction: any, //The active database transaction to ensure consistency during the query.