@tomei/sso 0.33.7 → 0.34.0

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

@@ -8,4 +8,18 @@ export class GroupObjectPrivilegeRepository
   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,197 @@ 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

@@ -8,4 +8,15 @@ export class GroupPrivilegeRepository
   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,76 @@ 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
+      const 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/interfaces/group-object-privilege.interface.ts

@@ -1,7 +1,7 @@
 import { ObjectStatus } from '../enum/object-status.enum';
 
 export interface IGroupObjectPrivilegeAttr {
-  GroupObjectPrivilegeId: number;
+  GroupObjectPrivilegeId?: number;
   GroupCode: string;
   PrivilegeCode: string;
   ObjectId: string;

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/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"]
+}
   

package/tsconfig.json

@@ -1,23 +1,23 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "allowSyntheticDefaultImports": true,
-    "moduleResolution": "node",
-    "target": "es6",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "baseUrl": "./src",
-    "rootDir": "./",
-    "incremental": true,
-    "skipLibCheck": true,
-    "noImplicitAny": false,
-    "strictBindCallApply": false,
-    "forceConsistentCasingInFileNames": false,
-    "noFallthroughCasesInSwitch": false,
-    "strictNullChecks": false,
-  },
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "node",
+    "target": "es6",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./src",
+    "rootDir": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "strictNullChecks": false,
+  },
 }