@tomei/sso 0.56.1 → 0.57.0

package/migrations/20250210115636-create-user-reporting-hierarchy.js

@@ -0,0 +1,76 @@
+'use strict';
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('sso_UserReportingHierarchy', {
+      UserReportingHierarchyId: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      ReportingUserId: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        references: {
+          model: 'sso_User',
+          key: 'UserId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      UserId: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        references: {
+          model: 'sso_User',
+          key: 'UserId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      Rank: {
+        type: Sequelize.TINYINT,
+        allowNull: false,
+      },
+      Status: {
+        type: Sequelize.STRING(10),
+        allowNull: false,
+        defaultValue: 'Active',
+      },
+      CreatedById: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        references: {
+          model: 'sso_User',
+          key: 'UserId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      CreatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      UpdatedById: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        references: {
+          model: 'sso_User',
+          key: 'UserId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      UpdatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable('sso_UserReportingHierarchy');
+  },
+};

package/package.json

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

package/src/components/index.ts

@@ -15,5 +15,6 @@ export * from './system-privilege';
 export * from './group';
 export * from './api-key';
 export * from './group-reporting-user';
+export * from './user-reporting-hierarchy';
 
 //test ci

package/src/components/login-user/login-user.ts

@@ -7,6 +7,7 @@ import { RedisService } from '../../redis-client/redis.service';
 import { UserRepository } from './user.repository';
 import { IUserAttr, IUserInfo } from './interfaces/user-info.interface';
 import Staff from '../../models/staff.entity';
+import UserModel from '../../models/user.entity';
 import { createHash, randomBytes } from 'crypto';
 
 export class LoginUser extends User implements ILoginUser {
@@ -157,4 +158,73 @@ export class LoginUser extends User implements ILoginUser {
       throw error;
     }
   }
+
+  async getProfile(dbTransaction: any) {
+    const user = await User._Repository.findOne({
+      where: {
+        UserId: this.UserId,
+        Status: 'Active',
+      },
+      include: [
+        {
+          model: Staff,
+        },
+      ],
+      transaction: dbTransaction,
+    });
+    return user;
+  }
+
+  public static async getGroups(loginUser: User, dbTransaction: any) {
+    // This method will retrieve all user groups.
+
+    // Part 2: Retrieve User Groups & Returns
+    const userGroups = await User._UserGroupRepo.findAll({
+      where: {
+        UserId: loginUser.ObjectId,
+        Status: 'Active',
+      },
+      include: [{ model: UserModel, as: 'User' }, { model: GroupModel }],
+      transaction: dbTransaction,
+    });
+
+    return userGroups;
+  }
+
+  public static async getSystems(loginUser: User, dbTransaction: any) {
+    // This method will retrieve all system records which user has accessed to.
+
+    // Part 2: Retrieve System Access
+    const groups = await this.getGroups(loginUser, dbTransaction);
+    const systemAccess = await User.combineSystemAccess(
+      loginUser,
+      dbTransaction,
+      groups,
+    );
+    const output = [];
+    if (systemAccess) {
+      for (let i = 0; i < systemAccess.length; i++) {
+        const system = await User._SystemRepository.findOne({
+          where: {
+            SystemCode: systemAccess[i].SystemCode,
+            Status: 'Active',
+          },
+        });
+        output.push({
+          UserSystemAccessId: systemAccess[i].UserSystemAccessId,
+          UserId: systemAccess[i].UserId,
+          SystemCode: systemAccess[i].SystemCode,
+          Status: systemAccess[i].Status,
+          CreatedById: systemAccess[i].CreatedById,
+          UpdatedById: systemAccess[i].UpdatedById,
+          CreatedAt: systemAccess[i].CreatedAt,
+          UpdatedAt: systemAccess[i].UpdatedAt,
+          System: system,
+        });
+      }
+    }
+
+    // Part 3: Map Result to System Object
+    return output;
+  }
 }

package/src/components/login-user/user.ts

@@ -15,7 +15,6 @@ import { ApplicationConfig, ComponentConfig } from '@tomei/config';
 import { ICheckUserInfoDuplicatedQuery } from './interfaces/check-user-info-duplicated.interface';
 import { Op, where } from 'sequelize';
 import { ActionEnum, Activity } from '@tomei/activity-history';
-import UserModel from '../../models/user.entity';
 import GroupModel from '../../models/group.entity';
 import { GroupSystemAccessRepository } from '../group-system-access/group-system-access.repository';
 import { GroupRepository } from '../group/group.repository';
@@ -34,6 +33,8 @@ import { LoginUser } from './login-user';
 import { SessionService } from '../../session/session.service';
 import { createHash, randomBytes, randomUUID } from 'crypto';
 import { AuthContext } from 'types';
+import UserModel from '../../models/user.entity';
+import { UserReportingHierarchyRepository } from '../user-reporting-hierarchy/user-reporting-hierarchy.repository';
 
 export class User extends UserBase {
   ObjectId: string;
@@ -74,10 +75,12 @@ export class User extends UserBase {
   private static _GroupObjectPrivilegeRepo =
     new GroupObjectPrivilegeRepository();
 
-  private static _SystemRepository = new SystemRepository();
+  protected static _SystemRepository = new SystemRepository();
   protected static _UserSystemAccessRepo = new UserSystemAccessRepository();
   private static _GroupSystemAccessRepo = new GroupSystemAccessRepository();
   private static _GroupRepo = new GroupRepository();
+  protected static _UserReportingHierarchyRepo =
+    new UserReportingHierarchyRepository();
 
   private _dbTransaction: any;
 
@@ -1738,32 +1741,6 @@ export class User extends UserBase {
     );
   }
 
-  public static async getGroups(loginUser: User, dbTransaction: any) {
-    // This method will retrieve all user groups.
-
-    // Part 1: Privilege Checking
-    const systemCode = ApplicationConfig.getComponentConfigValue('system-code');
-    const isPrivileged = await loginUser.checkPrivileges(
-      systemCode,
-      'UserGroup - List Own',
-    );
-    if (!isPrivileged) {
-      throw new Error('You do not have permission to list UserGroup.');
-    }
-
-    // Part 2: Retrieve User Groups & Returns
-    const userGroups = await User._UserGroupRepo.findAll({
-      where: {
-        UserId: loginUser.ObjectId,
-        Status: 'Active',
-      },
-      include: [{ model: UserModel, as: 'User' }, { model: GroupModel }],
-      transaction: dbTransaction,
-    });
-
-    return userGroups;
-  }
-
   protected static async getInheritedSystemAccess(
     dbTransaction: any,
     group: GroupModel,
@@ -1801,7 +1778,7 @@ export class User extends UserBase {
     return systemAccesses;
   }
 
-  private static async combineSystemAccess(
+  protected static async combineSystemAccess(
     loginUser: User,
     dbTransaction: any,
     groups: any,
@@ -1839,53 +1816,6 @@ export class User extends UserBase {
     return Array.from(uniqueAccess) as ISystemAccess[];
   }
 
-  public static async getSystems(loginUser: User, dbTransaction: any) {
-    // This method will retrieve all system records which user has accessed to.
-
-    // Part 1: Privilege Checking
-    const systemCode = ApplicationConfig.getComponentConfigValue('system-code');
-    const isPrivileged = await loginUser.checkPrivileges(
-      systemCode,
-      'System – List Own',
-    );
-    if (!isPrivileged) {
-      throw new Error('You do not have permission to list UserGroup.');
-    }
-
-    // Part 2: Retrieve System Access
-    const groups = await User.getGroups(loginUser, dbTransaction);
-    const systemAccess = await User.combineSystemAccess(
-      loginUser,
-      dbTransaction,
-      groups,
-    );
-    const output = [];
-    if (systemAccess) {
-      for (let i = 0; i < systemAccess.length; i++) {
-        const system = await User._SystemRepository.findOne({
-          where: {
-            SystemCode: systemAccess[i].SystemCode,
-            Status: 'Active',
-          },
-        });
-        output.push({
-          UserSystemAccessId: systemAccess[i].UserSystemAccessId,
-          UserId: systemAccess[i].UserId,
-          SystemCode: systemAccess[i].SystemCode,
-          Status: systemAccess[i].Status,
-          CreatedById: systemAccess[i].CreatedById,
-          UpdatedById: systemAccess[i].UpdatedById,
-          CreatedAt: systemAccess[i].CreatedAt,
-          UpdatedAt: systemAccess[i].UpdatedAt,
-          System: system,
-        });
-      }
-    }
-
-    // Part 3: Map Result to System Object
-    return output;
-  }
-
   //This method will check if user enable 2FA or not.
   private static async check2FA(loginUser: User, dbTransaction: any) {
     try {
@@ -2908,4 +2838,42 @@ export class User extends UserBase {
       throw error;
     }
   }
+
+  public async getReportingUser(dbTransaction: any): Promise<
+    {
+      Email: string;
+      ContactNo: string;
+      Name: string;
+      Rank: number;
+    }[]
+  > {
+    try {
+      const data = await User._UserReportingHierarchyRepo.findAll({
+        where: {
+          ReportingUserId: this.UserId,
+        },
+        include: [
+          {
+            model: UserModel,
+            as: 'User',
+            attributes: ['Email', 'ContactNo', 'FullName'],
+          },
+        ],
+        transaction: dbTransaction,
+      });
+
+      //format the data
+      const result = data.map((item) => {
+        return {
+          Email: item.User.Email,
+          ContactNo: item.User.ContactNo,
+          Name: item.User.FullName,
+          Rank: item.Rank,
+        };
+      });
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
 }

package/src/components/user-reporting-hierarchy/index.ts

@@ -0,0 +1,2 @@
+export * from './user-reporting-hierarchy';
+export * from './user-reporting-hierarchy.repository';

package/src/components/user-reporting-hierarchy/user-reporting-hierarchy.repository.ts

@@ -0,0 +1,30 @@
+import UserReportingHierarchyModel from '../../models/user-reporting-hierarchy.entity';
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
+
+export class UserReportingHierarchyRepository
+  extends RepositoryBase<UserReportingHierarchyModel>
+  implements IRepositoryBase<UserReportingHierarchyModel>
+{
+  constructor() {
+    super(UserReportingHierarchyModel);
+  }
+
+  async findByPk(
+    id: string,
+    options?: any,
+  ): Promise<UserReportingHierarchyModel> {
+    return await UserReportingHierarchyModel.findByPk(parseInt(id), options);
+  }
+
+  async destroy(
+    UserReportingHierarchyId: number,
+    dbTransaction: any,
+  ): Promise<void> {
+    await UserReportingHierarchyModel.destroy({
+      where: {
+        UserReportingHierarchyId: UserReportingHierarchyId,
+      },
+      transaction: dbTransaction,
+    });
+  }
+}

package/src/components/user-reporting-hierarchy/user-reporting-hierarchy.ts

@@ -0,0 +1,90 @@
+import { ClassError, ObjectBase } from '@tomei/general';
+import { IUserReportingHierarchyAttr } from '../../interfaces/user-reporting-hierarchy.interface';
+import { UserReportingHierarchyRepository } from './user-reporting-hierarchy.repository';
+
+export class UserReportingHierarchy
+  extends ObjectBase
+  implements IUserReportingHierarchyAttr
+{
+  ObjectId: string;
+  ObjectName: string;
+  ObjectType = 'UserReportingHierarchy';
+  TableName = 'sso_UserReportingHierarchy';
+  ReportingUserId: number;
+  UserId: number;
+  Rank: number;
+  Status: string;
+  private _CreatedById: number;
+  private _CreatedAt: Date;
+  private _UpdatedById: number;
+  private _UpdatedAt: Date;
+
+  private static _Repo = new UserReportingHierarchyRepository();
+
+  get UserReportingHierarchyId(): number {
+    return parseInt(this.ObjectId);
+  }
+
+  set UserReportingHierarchyId(value: number) {
+    this.ObjectId = value.toString();
+  }
+
+  get CreatedById(): number {
+    return this._CreatedById;
+  }
+
+  get CreatedAt(): Date {
+    return this._CreatedAt;
+  }
+
+  get UpdatedById(): number {
+    return this._UpdatedById;
+  }
+
+  get UpdatedAt(): Date {
+    return this._UpdatedAt;
+  }
+
+  private constructor(params?: IUserReportingHierarchyAttr) {
+    super();
+    if (params) {
+      this.ObjectId = params.UserReportingHierarchyId.toString();
+      this.ReportingUserId = params.ReportingUserId;
+      this.UserId = params.UserId;
+      this.Rank = params.Rank;
+      this.Status = params.Status;
+      this._CreatedById = params.CreatedById;
+      this._CreatedAt = params.CreatedAt;
+      this._UpdatedById = params.UpdatedById;
+      this._UpdatedAt = params.UpdatedAt;
+    }
+  }
+
+  public static async init(
+    userReportingHierarchyId: number,
+    dbTransaction?: any,
+  ): Promise<UserReportingHierarchy> {
+    try {
+      if (userReportingHierarchyId) {
+        const data = await UserReportingHierarchy._Repo.findByPk(
+          userReportingHierarchyId.toString(),
+          dbTransaction,
+        );
+        if (!data) {
+          throw new ClassError(
+            'UserReportingHierarchy',
+            'UserReportingHierarchyErrMsg01',
+            'UserReportingHierarchy not found',
+            'init',
+            400,
+          );
+        }
+
+        return new UserReportingHierarchy(data.get({ plain: true }));
+      }
+      return new UserReportingHierarchy();
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/interfaces/user-reporting-hierarchy.interface.ts

@@ -0,0 +1,11 @@
+export interface IUserReportingHierarchyAttr {
+  UserReportingHierarchyId: number;
+  ReportingUserId: number;
+  UserId: number;
+  Rank: number;
+  Status: string;
+  CreatedById: number;
+  CreatedAt: Date;
+  UpdatedById: number;
+  UpdatedAt: Date;
+}

package/src/models/user-reporting-hierarchy.entity.ts

@@ -0,0 +1,102 @@
+import {
+  BelongsTo,
+  Column,
+  CreatedAt,
+  DataType,
+  ForeignKey,
+  Model,
+  Table,
+  UpdatedAt,
+} from 'sequelize-typescript';
+import User from './user.entity';
+import GroupModel from './group.entity';
+import { IUserReportingHierarchyAttr } from '../interfaces/user-reporting-hierarchy.interface';
+
+@Table({
+  tableName: 'sso_UserReportingHierarchy',
+  timestamps: true,
+  createdAt: 'CreatedAt',
+  updatedAt: 'UpdatedAt',
+})
+export default class UserReportingHierarchyModel
+  extends Model
+  implements IUserReportingHierarchyAttr
+{
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+    type: DataType.INTEGER,
+    autoIncrement: true,
+  })
+  UserReportingHierarchyId: number;
+
+  @ForeignKey(() => User)
+  @Column({
+    allowNull: false,
+    type: DataType.INTEGER,
+  })
+  UserId: number;
+
+  @ForeignKey(() => User)
+  @Column({
+    allowNull: false,
+    type: DataType.INTEGER,
+  })
+  ReportingUserId: number;
+
+  @Column({
+    allowNull: false,
+    type: DataType.TINYINT,
+  })
+  Rank: number;
+
+  @Column({
+    allowNull: false,
+    type: DataType.CHAR(10),
+  })
+  Status: string;
+
+  @ForeignKey(() => User)
+  @Column({
+    allowNull: false,
+    type: DataType.INTEGER,
+  })
+  CreatedById: number;
+
+  @ForeignKey(() => User)
+  @Column({
+    allowNull: false,
+    type: DataType.INTEGER,
+  })
+  UpdatedById: number;
+
+  @CreatedAt
+  CreatedAt: Date;
+
+  @UpdatedAt
+  UpdatedAt: Date;
+
+  @BelongsTo(() => User, {
+    as: 'CreatedByUser',
+    foreignKey: 'CreatedById',
+  })
+  CreatedByUser: User;
+
+  @BelongsTo(() => User, {
+    as: 'ReportingUser',
+    foreignKey: 'ReportingUserId',
+  })
+  ReportingUser: User;
+
+  @BelongsTo(() => User, {
+    as: 'UpdatedByUser',
+    foreignKey: 'UpdatedById',
+  })
+  UpdatedByUser: User;
+
+  @BelongsTo(() => User, {
+    as: 'User',
+    foreignKey: 'UserId',
+  })
+  User: User;
+}