@tomei/sso 0.33.6 → 0.33.8

package/src/components/group-object-privilege/group-object-privilege.repository.ts

@@ -3,9 +3,22 @@ import { RepositoryBase, IRepositoryBase } from '@tomei/general';
 
 export class GroupObjectPrivilegeRepository
   extends RepositoryBase<GroupObjectPrivilegeModel>
-  implements IRepositoryBase<GroupObjectPrivilegeModel>
-{
+  implements IRepositoryBase<GroupObjectPrivilegeModel> {
   constructor() {
     super(GroupObjectPrivilegeModel);
   }
+
+  public async delete(
+    where: any,
+    transaction?: any
+  ): Promise<number | undefined> {
+    try {
+      return await GroupObjectPrivilegeModel.destroy({
+        where,
+        transaction,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
 }

package/src/components/group-object-privilege/group-object-privilege.ts

@@ -2,6 +2,9 @@ import { ClassError, ObjectBase } from '@tomei/general';
 import { GroupObjectPrivilegeRepository } from './group-object-privilege.repository';
 import { IGroupObjectPrivilegeAttr } from '../../interfaces/group-object-privilege.interface';
 import { ObjectStatus } from '../../enum/object-status.enum';
+import { LoginUser } from '../login-user/login-user';
+import { ApplicationConfig } from '@tomei/config';
+import { ActionEnum, Activity } from '@tomei/activity-history';
 
 export class GroupObjectPrivilege extends ObjectBase {
   TableName = 'sso_GroupObjectPrivilege';
@@ -79,4 +82,184 @@ export class GroupObjectPrivilege extends ObjectBase {
       throw error;
     }
   }
+
+  public static async create(loginUser: LoginUser, dbTransaction: any, groupObjectPrivilege: GroupObjectPrivilege) {
+    try {
+      // Part 1: Privilege Checking
+      const systemCode = ApplicationConfig.getComponentConfigValue('system-code');
+      const isPrivileged = await loginUser.checkPrivileges(
+        systemCode,
+        'GROUP_OBJECT_PRIVILEGE_CREATE',
+      );
+
+      if (!isPrivileged) {
+        throw new ClassError(
+          'GroupObjectPrivilege',
+          'GroupErrMsg01',
+          'You do not have the privilege to create Group Object Privilege',
+        );
+      }
+
+
+      // Part 2: Validation
+      // Make sure below variables exists:
+      // Params.groupObjectPrivilege.GroupCode
+      if (!groupObjectPrivilege.GroupCode) {
+        throw new ClassError(
+          'GroupObjectPrivilege',
+          'GroupObjectPrivilegeErrMsg01',
+          'GroupCode is missing.',
+        );
+      }
+      // Params.groupObjectPrivilege.PrivilegeCode
+      if (!groupObjectPrivilege.PrivilegeCode) {
+        throw new ClassError(
+          'GroupObjectPrivilege',
+          'GroupObjectPrivilegeErrMsg02',
+          'PrivilegeCode is missing.',
+        );
+      }
+      // Params.groupObjectPrivilege.ObjectId
+      if (!groupObjectPrivilege.ObjectId) {
+        throw new ClassError(
+          'GroupObjectPrivilege',
+          'GroupObjectPrivilegeErrMsg03',
+          'ObjectId is missing.',
+        );
+      }
+      // Params.groupObjectPrivilege.ObjectType
+      if (!groupObjectPrivilege.ObjectType) {
+        throw new ClassError(
+          'GroupObjectPrivilege',
+          'GroupObjectPrivilegeErrMsg04',
+          'ObjectType is missing.',
+        );
+      }
+
+      // Call GroupObjectPrivilege._Repo findOne
+      const existingGroupObjectPrivilege = await GroupObjectPrivilege._Repository.findOne({
+        where: {
+          GroupCode: groupObjectPrivilege.GroupCode,
+          PrivilegeCode: groupObjectPrivilege.PrivilegeCode,
+          ObjectId: groupObjectPrivilege.ObjectId,
+          ObjectType: groupObjectPrivilege.ObjectType,
+        },
+        transaction: dbTransaction,
+      });
+
+      // If GroupObjectPrivilege found, throw new ClassError
+      if (existingGroupObjectPrivilege) {
+        throw new ClassError(
+          'GroupObjectPrivilege',
+          'GroupObjectPrivilegeErrMsg05',
+          'Duplicate GroupObjectPrivilege found.',
+        );
+      }
+
+      // Part 3: Create GroupObjectPrivilege
+      // Initialise new Group instance and populate the attributes
+      const objectAttr = {
+        GroupCode: groupObjectPrivilege.GroupCode,
+        PrivilegeCode: groupObjectPrivilege.PrivilegeCode,
+        ObjectId: groupObjectPrivilege.ObjectId,
+        ObjectType: groupObjectPrivilege.ObjectType,
+        Status: ObjectStatus.ACTIVE,
+        CreatedById: loginUser.UserId,
+        CreatedAt: new Date(),
+        UpdatedById: loginUser.UserId,
+        UpdatedAt: new Date(),
+      };
+      const newGroupObjectPrivilege = new GroupObjectPrivilege(objectAttr);
+
+      // Call GroupObjectPrivilege._Repo create method
+      const createdObject = await GroupObjectPrivilege._Repository.create(newGroupObjectPrivilege, {
+        transaction: dbTransaction,
+      });
+      newGroupObjectPrivilege.GroupObjectPrivilegeId = createdObject.GroupObjectPrivilegeId;
+
+
+      // Part 4: Record Create Group Activity
+      // Initialise EntityValueBefore variable and set to empty object.
+      const EntityValueBefore = {};
+      // Initialise EntityValueAfter variable and set to new Group instance in Part 3.
+      const EntityValueAfter = objectAttr;
+      // Instantiate new activity from Activity class
+      const activity = new Activity();
+      activity.createId();
+      activity.Action = ActionEnum.ADD;
+      activity.Description = `Create GroupObjectPrivilege for (${newGroupObjectPrivilege.GroupCode})`;
+      activity.EntityType = 'GroupObjectPrivilege';
+      activity.EntityId = newGroupObjectPrivilege.GroupObjectPrivilegeId.toString();
+      activity.EntityValueBefore = JSON.stringify(EntityValueBefore);
+      activity.EntityValueAfter = JSON.stringify(EntityValueAfter);
+      // Call new activity create method.Make sure to pass the dbTransaction and loginUser.userId.
+      await activity.create(dbTransaction, loginUser.UserId);
+
+      // Return new Group instance
+      return newGroupObjectPrivilege;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async delete(loginUser: LoginUser, dbTransaction: any) {
+    try {
+      //Part 1: Privilege Checking
+      const systemCode = ApplicationConfig.getComponentConfigValue('system-code');
+      const isPrivileged = await loginUser.checkPrivileges(
+        systemCode,
+        'GROUP_OBJECT_PRIVILEGE_DELETE',
+      );
+
+      if (!isPrivileged) {
+        throw new ClassError(
+          'GroupObjectPrivilege',
+          'GroupErrMsg01',
+          'You do not have the privilege to delete Group Object Privilege',
+        );
+      }
+
+      // Part 2: Delete GroupObjectPrivilege
+      // Call GroupObjectPrivilege._Repo delete method by passing:
+      // dbTransaction
+      // GroupObjectPrivilege: this.GroupObjectPrivilegeId
+
+      await GroupObjectPrivilege._Repository.delete(this.GroupObjectPrivilegeId, {
+        transaction: dbTransaction,
+      });
+
+      // Part 4: Record Create Group Activity
+      // Initialise EntityValueBefore variable and set GroupObjectPrivelege column properties
+      const EntityValueBefore = {
+        GroupCode: this.GroupCode,
+        PrivilegeCode: this.PrivilegeCode,
+        ObjectId: this.ObjectId,
+        ObjectType: this.ObjectType,
+        Status: this.Status,
+        CreatedById: this.CreatedById,
+        UpdatedById: this.UpdatedById,
+      };
+
+      // Initialise EntityValueAfter variable and set empty object
+      const EntityValueAfter = {};
+      
+      // Instantiate new activity from Activity class
+      const activity = new Activity();
+      activity.createId();
+      activity.Action = ActionEnum.DELETE;
+      activity.Description = `Delete GroupObjectPrivilege ${this.GroupObjectPrivilegeId}`;
+      activity.EntityType = 'GroupObjectPrivilege';
+      activity.EntityId = this.GroupObjectPrivilegeId.toString();
+      activity.EntityValueBefore = JSON.stringify(EntityValueBefore);
+      activity.EntityValueAfter = JSON.stringify(EntityValueAfter);
+
+      // Call new activity create method.Make sure to pass the dbTransaction and LoginUser.userId.
+      await activity.create(dbTransaction, loginUser.UserId);
+
+      // Return this
+      return this;
+    } catch (error) {
+      throw error;
+    }
+  }
 }

package/src/components/group-privilege/group-privilege.repository.ts

@@ -3,9 +3,19 @@ import { RepositoryBase, IRepositoryBase } from '@tomei/general';
 
 export class GroupPrivilegeRepository
   extends RepositoryBase<GroupPrivilegeModel>
-  implements IRepositoryBase<GroupPrivilegeModel>
-{
+  implements IRepositoryBase<GroupPrivilegeModel> {
   constructor() {
     super(GroupPrivilegeModel);
   }
+
+  async delete(GroupCode: string, PrivilegeCode: string, dbTransaction?: any) {
+    try {
+      return await GroupPrivilegeModel.destroy({
+        where: { GroupCode, PrivilegeCode },
+        transaction: dbTransaction,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
 }

package/src/components/group-privilege/group-privilege.ts

@@ -48,6 +48,17 @@ export class GroupPrivilege extends ObjectBase {
     }
   }
 
+  setAttributes(GroupPrivilegeAttr: IGroupPrivilegeAttr) {
+    this.GroupPrivilegeId = GroupPrivilegeAttr.GroupPrivilegeId;
+    this.GroupCode = GroupPrivilegeAttr.GroupCode;
+    this.PrivilegeCode = GroupPrivilegeAttr.PrivilegeCode;
+    this.Status = GroupPrivilegeAttr.Status;
+    this._CreatedAt = GroupPrivilegeAttr.CreatedAt;
+    this._UpdatedAt = GroupPrivilegeAttr.UpdatedAt;
+    this._CreatedById = GroupPrivilegeAttr.CreatedById;
+    this._UpdatedById = GroupPrivilegeAttr.UpdatedById;
+  }
+
   public static async init(dbTransaction?: any, GroupPrivilegeId?: number) {
     try {
       if (GroupPrivilegeId) {

package/src/components/system-privilege/system-privilege.ts

@@ -6,6 +6,8 @@ import { LoginUser } from '../login-user/login-user';
 import { ApplicationConfig } from '@tomei/config';
 import { System } from '../system/system';
 import { ActionEnum, Activity } from '@tomei/activity-history';
+import { ISystemPrivilegeSearch } from '../../interfaces/system-privilege-search.interface';
+import { Op } from 'sequelize';
 
 export class SystemPrivilege extends ObjectBase {
   ObjectType = 'SystemPrivilege';
@@ -61,6 +63,17 @@ export class SystemPrivilege extends ObjectBase {
     }
   }
 
+  setAttributes(systemPrivilegeAttr: ISystemPrivilegeAttr) {
+    this.ObjectId = systemPrivilegeAttr.PrivilegeCode;
+    this.SystemCode = systemPrivilegeAttr.SystemCode;
+    this.Description = systemPrivilegeAttr.Description;
+    this.Status = systemPrivilegeAttr.Status;
+    this._CreatedAt = systemPrivilegeAttr.CreatedAt;
+    this._UpdatedAt = systemPrivilegeAttr.UpdatedAt;
+    this._CreatedById = systemPrivilegeAttr.CreatedById;
+    this._UpdatedById = systemPrivilegeAttr.UpdatedById;
+  }
+
   static async init(dbTransaction: any, PrivilegeCode?: string) {
     try {
       const systemPrivilege = new SystemPrivilege();
@@ -108,8 +121,10 @@ export class SystemPrivilege extends ObjectBase {
         'PRIVILEGE_CREATE',
       );
       if (!isPrivileged) {
-        throw new Error(
-          'You do not have permission to create system privilege',
+        throw new ClassError(
+          'SystemPrivilege',
+          'SystemPrivilegeErrMsg01',
+          'You do not have permission to create system privileges',
         );
       }
 
@@ -202,4 +217,73 @@ export class SystemPrivilege extends ObjectBase {
       throw error;
     }
   }
+
+  public static async findAll(
+    loginUser: LoginUser,
+    dbTransaction: any,
+    page?: number,
+    row?: number,
+    search?: ISystemPrivilegeSearch,
+  ) {
+    try {
+      // Part 1: Privilege Checking
+      const systemCode = ApplicationConfig.getComponentConfigValue('system-code');
+      const isPrivileged = await loginUser.checkPrivileges(
+        systemCode,
+        'PRIVILEGE_LIST',
+      );
+
+      if (!isPrivileged) {
+        throw new ClassError(
+          'SystemPrivilege',
+          'SystemPrivilegeErrMsg01',
+          'You do not have permission to list system privileges',
+        );
+      }
+
+      // Part 2: Retrieve listing
+      let options: any = {
+        order: [['createdAt', 'DESC']],
+        transaction: dbTransaction,
+      };
+      //If page and row exist, please add limit and offset to the findAll options
+      if (page && row) {
+        const offset = row * (page - 1);
+        const limit = row;
+
+        options.offset = offset;
+        options.limit = limit;
+      }
+
+      //If search query exists, please set it to sequelize where option.
+      if (search) {
+        const queryObj: any = {};
+        Object.entries(search).forEach(([key, value]) => {
+          queryObj[key] = {
+            [Op.substring]: value,
+          };
+        });
+
+        options.where = queryObj;
+      }
+
+      const result = await SystemPrivilege._Repository.findAllWithPagination(options);
+
+      // Part 3: Return result
+      // Map the result to SystemPrivilege object
+      const systemPrivileges: SystemPrivilege[] = [];
+      for (const systemPrivilegeAttr of result.rows) {
+        systemPrivileges.push(
+          new SystemPrivilege(systemPrivilegeAttr.get({ plain: true })),
+        );
+      }
+
+      return {
+        count: result.count,
+        SystemPrivileges: systemPrivileges,
+      };
+    } catch (error) {
+      throw error;
+    }
+  }
 }

package/src/components/user-object-privilege/user-object-privilege.ts

@@ -76,4 +76,5 @@ export class UserObjectPrivilege extends ObjectBase {
       throw error;
     }
   }
+
 }

package/src/interfaces/group-object-privilege.interface.ts

@@ -1,14 +1,14 @@
-import { ObjectStatus } from '../enum/object-status.enum';
-
-export interface IGroupObjectPrivilegeAttr {
-  GroupObjectPrivilegeId: number;
-  GroupCode: string;
-  PrivilegeCode: string;
-  ObjectId: string;
-  ObjectType: string;
-  Status: ObjectStatus;
-  CreatedById: number;
-  UpdatedById: number;
-  CreatedAt: Date;
-  UpdatedAt: Date;
-}
+import { ObjectStatus } from '../enum/object-status.enum';
+
+export interface IGroupObjectPrivilegeAttr {
+  GroupObjectPrivilegeId?: number;
+  GroupCode: string;
+  PrivilegeCode: string;
+  ObjectId: string;
+  ObjectType: string;
+  Status: ObjectStatus;
+  CreatedById: number;
+  UpdatedById: number;
+  CreatedAt: Date;
+  UpdatedAt: Date;
+}

package/src/interfaces/group-privilege.interface.ts

@@ -1,5 +1,5 @@
 export interface IGroupPrivilegeAttr {
-  GroupPrivilegeId: number;
+  GroupPrivilegeId?: number;
   GroupCode: string;
   PrivilegeCode: string;
   Status: string;

package/src/interfaces/system-privilege-search.interface.ts

@@ -0,0 +1,5 @@
+export interface ISystemPrivilegeSearch {
+    PrivilegeCode?: string;
+    SystemCode?: string;
+    Status?: string;
+}

package/src/models/group-object-privilege.entity.ts

@@ -24,6 +24,7 @@ export default class GroupObjectPrivilegeModel extends Model {
     primaryKey: true,
     type: DataType.INTEGER,
     allowNull: false,
+    autoIncrement: true,
   })
   GroupObjectPrivilegeId: number;
 

package/src/models/group-privilege.entity.ts

@@ -23,6 +23,7 @@ export default class GroupPrivilegeModel extends Model {
     primaryKey: true,
     type: DataType.INTEGER,
     allowNull: false,
+    autoIncrement: true,
   })
   GroupPrivilegeId: number;
 

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

@@ -22,6 +22,7 @@ export default class GroupReportingUserModel extends Model {
     primaryKey: true,
     allowNull: false,
     type: DataType.INTEGER,
+    autoIncrement: true,
   })
   GroupReportingUserId: number;
 

package/src/models/group-system-access.entity.ts

@@ -1,81 +1,81 @@
-import {
-  BelongsTo,
-  Column,
-  CreatedAt,
-  DataType,
-  ForeignKey,
-  Model,
-  Table,
-  UpdatedAt,
-} from 'sequelize-typescript';
-import User from './user.entity';
-import GroupModel from './group.entity';
-import SystemModel from './system.entity';
-
-@Table({
-  tableName: 'sso_GroupSystemAccess',
-  timestamps: true,
-  createdAt: 'CreatedAt',
-  updatedAt: 'UpdatedAt',
-})
-export default class GroupSystemAccessModel extends Model {
-  @Column({
-    autoIncrement: true,
-    primaryKey: true,
-    allowNull: false,
-    type: DataType.INTEGER,
-  })
-  GroupSystemAccessId: number;
-
-  @ForeignKey(() => GroupModel)
-  @Column({
-    allowNull: false,
-    type: DataType.STRING(10),
-  })
-  GroupCode: string;
-
-  @ForeignKey(() => SystemModel)
-  @Column({
-    allowNull: false,
-    type: DataType.STRING(10),
-  })
-  SystemCode: string;
-
-  @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, 'CreatedById')
-  CreatedByUser: User;
-
-  @BelongsTo(() => User, 'UpdatedById')
-  UpdatedByUser: User;
-
-  @BelongsTo(() => SystemModel, 'SystemCode')
-  System: SystemModel;
-
-  @BelongsTo(() => GroupModel, 'GroupCode')
-  Group: GroupModel;
-}
+import {
+  BelongsTo,
+  Column,
+  CreatedAt,
+  DataType,
+  ForeignKey,
+  Model,
+  Table,
+  UpdatedAt,
+} from 'sequelize-typescript';
+import User from './user.entity';
+import GroupModel from './group.entity';
+import SystemModel from './system.entity';
+
+@Table({
+  tableName: 'sso_GroupSystemAccess',
+  timestamps: true,
+  createdAt: 'CreatedAt',
+  updatedAt: 'UpdatedAt',
+})
+export default class GroupSystemAccessModel extends Model {
+  @Column({
+    autoIncrement: true,
+    primaryKey: true,
+    allowNull: false,
+    type: DataType.INTEGER,
+  })
+  GroupSystemAccessId: number;
+
+  @ForeignKey(() => GroupModel)
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(10),
+  })
+  GroupCode: string;
+
+  @ForeignKey(() => SystemModel)
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(10),
+  })
+  SystemCode: string;
+
+  @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, 'CreatedById')
+  CreatedByUser: User;
+
+  @BelongsTo(() => User, 'UpdatedById')
+  UpdatedByUser: User;
+
+  @BelongsTo(() => SystemModel, 'SystemCode')
+  System: SystemModel;
+
+  @BelongsTo(() => GroupModel, 'GroupCode')
+  Group: GroupModel;
+}

package/src/models/user-object-privilege.entity.ts

@@ -23,6 +23,7 @@ export default class UserObjectPrivilegeModel extends Model {
     primaryKey: true,
     type: DataType.INTEGER,
     allowNull: false,
+    autoIncrement: true,
   })
   ObjectPrivilegeId: number;
 

package/src/models/user-privilege.entity.ts

@@ -22,6 +22,7 @@ export default class UserPrivilegeModel extends Model {
     primaryKey: true,
     type: DataType.INTEGER,
     allowNull: false,
+    autoIncrement: true,
   })
   UserPrivilegeId: number;
 

package/src/models/user-system-access.entity.ts

@@ -22,6 +22,7 @@ export default class UserSystemAccessModel extends Model {
     primaryKey: true,
     type: DataType.INTEGER,
     allowNull: false,
+    autoIncrement: true,
   })
   UserSystemAccessId: number;
 

package/tsconfig.build.json

@@ -1,6 +1,6 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["**/*.ts"],
-  "exclude": ["node_modules", "__tests__", "dist", "**/*spec.ts"]
-}
+{
+  "extends": "./tsconfig.json",
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "__tests__", "dist", "**/*spec.ts"]
+}