@tomei/sso 0.37.4 → 0.38.1

package/src/components/group/group.ts

@@ -1,4 +1,4 @@
-import { ClassError, ObjectBase } from '@tomei/general';
+import { ClassError, ObjectBase, TreeNodeBase } from '@tomei/general';
 import { GroupRepository } from './group.repository';
 import { IGroupAttr } from '../../interfaces/group.interface';
 import { GroupTypeEnum } from 'enum';
@@ -19,7 +19,7 @@ import { GroupObjectPrivilegeRepository } from '../group-object-privilege/group-
 import { GroupObjectPrivilege } from '../group-object-privilege/group-object-privilege';
 import { GroupPrivilege } from '../group-privilege/group-privilege';
 
-export class Group extends ObjectBase {
+export class Group extends TreeNodeBase<Group> {
   ObjectId: string;
   ObjectName: string;
   TableName: 'sso_Group';
@@ -33,6 +33,10 @@ export class Group extends ObjectBase {
   InheritParentSystemAccessYN: string;
   Status: string;
   ParentGroup?: any;
+  _Path: string = '';
+  isChildrenLoaded = false;
+  isParentLoaded = false;
+
   private _CreatedById: number;
   private _CreatedAt: Date;
   private _UpdatedById: number;
@@ -43,6 +47,7 @@ export class Group extends ObjectBase {
   private static _GroupObjectPrivilegeRepo =
     new GroupObjectPrivilegeRepository();
   private static _RedisService: RedisService;
+
   get GroupCode(): string {
     return this.ObjectId;
   }
@@ -67,6 +72,10 @@ export class Group extends ObjectBase {
     return this._UpdatedAt;
   }
 
+  set Path(value: string) {
+    this._Path = value;
+  }
+
   private constructor(groupAttr?: IGroupAttr) {
     super();
     if (groupAttr) {
@@ -78,6 +87,7 @@ export class Group extends ObjectBase {
       this.InheritParentPrivilegeYN = groupAttr?.InheritParentPrivilegeYN;
       this.InheritParentSystemAccessYN = groupAttr?.InheritParentSystemAccessYN;
       this.Status = groupAttr?.Status;
+      this._Path = groupAttr?.Path;
       this._CreatedById = groupAttr.CreatedById;
       this._CreatedAt = groupAttr.CreatedAt;
       this._UpdatedById = groupAttr.UpdatedById;
@@ -108,6 +118,82 @@ export class Group extends ObjectBase {
     }
   }
 
+  async loadChildren(dbTransaction?: any) {
+    if (!this.GroupCode) {
+      throw Error('GroupCode is missing.');
+    }
+
+    const children = await Group._Repo.findAll({
+      where: { ParentGroupCode: this.GroupCode },
+      order: [['CreatedAt', 'ASC']],
+      transaction: dbTransaction,
+    });
+
+    this.children = children.map((child) => {
+      return new Group(child.get({ plain: true }));
+    });
+
+    this.isChildrenLoaded = true;
+  }
+
+  async loadParent(dbTransaction?: any) {
+    if (!this.GroupCode) {
+      throw Error('GroupCode are missing.');
+    }
+
+    if (this.ParentGroupCode) {
+      if (this.ParentGroupCode !== this.GroupCode) {
+        const parent = await Group._Repo.findByPk(this.ParentGroupCode, {
+          transaction: dbTransaction,
+        });
+        this.parent = new Group(parent.get({ plain: true }));
+      }
+    }
+
+    this.isParentLoaded = true;
+  }
+
+  async isLeaf(dbTransaction?: any): Promise<boolean> {
+    if (!this.isChildrenLoaded) {
+      await this.loadChildren(dbTransaction);
+    }
+
+    return this.children.length === 0;
+  }
+
+  async getPath(dbTransaction?: any): Promise<string> {
+    if (!this.isParentLoaded) {
+      await this.loadParent(dbTransaction);
+    }
+
+    if (this.parent) {
+      this._Path = (await this.parent.getPath(dbTransaction)) + '/' + this.Name;
+      return this._Path;
+    }
+    this._Path = this.GroupCode;
+    return this._Path;
+  }
+
+  protected async updatePath(dbTransaction?: any): Promise<void> {
+    const path = await this.getPath(dbTransaction);
+    this._Path = path;
+  }
+
+  async setParent(parent: Group, dbTransaction?: any): Promise<void> {
+    this.parent = parent;
+    await this.getPath(dbTransaction);
+  }
+
+  async getPathDetail(dbTransaction?: any): Promise<Group[]> {
+    const path = this._Path.split('/');
+    const groups: Group[] = [];
+    for (let i = 0; i < path.length; i++) {
+      const group = await Group.init(dbTransaction, path[i]);
+      groups.push(group);
+    }
+    return groups;
+  }
+
   public static async findAll(
     page: number,
     row: number,
@@ -263,6 +349,7 @@ export class Group extends ObjectBase {
       newGroup.Status = 'Active';
       newGroup._CreatedById = loginUser.UserId;
       newGroup._UpdatedById = loginUser.UserId;
+      newGroup._Path = await newGroup.getPath(dbTransaction);
 
       //Call Group._Repo create method
       const entityGroupAfter = {
@@ -273,6 +360,7 @@ export class Group extends ObjectBase {
         ParentGroupCode: newGroup.ParentGroupCode,
         InheritParentPrivilegeYN: newGroup.InheritParentPrivilegeYN,
         InheritParentSystemAccessYN: newGroup.InheritParentSystemAccessYN,
+        Path: newGroup._Path,
         Status: newGroup.Status,
         CreatedById: newGroup._CreatedById,
         UpdatedById: newGroup._UpdatedById,
@@ -291,7 +379,7 @@ export class Group extends ObjectBase {
       //Instantiate new activity
       const activity = new Activity();
       activity.ActivityId = activity.createId();
-      activity.Action = ActionEnum.ADD;
+      activity.Action = ActionEnum.CREATE;
       activity.Description = 'Create Group';
       activity.EntityType = 'Group';
       activity.EntityId = newGroup.ObjectId;
@@ -325,19 +413,49 @@ export class Group extends ObjectBase {
     }
   }
 
+  private async updateChildrenPath(oldGroupCode: string, dbTransaction: any) {
+    try {
+      const isLeaf = await this.isLeaf(dbTransaction);
+      if (isLeaf) {
+        return;
+      }
+
+      const childrens = await Group._Repo.findAll({
+        where: {
+          Path: {
+            [Op.like]: `${oldGroupCode}/%`,
+          },
+        },
+        transaction: dbTransaction,
+      });
+
+      childrens.forEach(async (children) => {
+        //Break the path into array with oldGroupCode/ as separator;
+        const path = children.Path.split(`${oldGroupCode}/`);
+        //Retrive the last element of the array
+        const childPath = path[path.length - 1];
+        //Combine the childPath with this.Path
+        children.Path = `${this.Path}/${childPath}`;
+        await children.update({ Path: path }, { transaction: dbTransaction });
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
   public async update(
     loginUser: LoginUser,
     dbTransaction: any,
     group: {
       GroupCode: string;
       NewGroupCode?: string;
-      Name?: string;
-      Description?: string;
-      Type?: GroupTypeEnum;
-      ParentGroupCode?: string;
-      InheritParentPrivilegeYN?: string;
-      InheritParentSystemAccessYN?: string;
-      Status?: string;
+      Name: string;
+      Description: string;
+      Type: GroupTypeEnum;
+      ParentGroupCode: string;
+      InheritParentPrivilegeYN: string;
+      InheritParentSystemAccessYN: string;
+      Status: string;
     },
   ) {
     //Part 1: Privilege Checking
@@ -360,9 +478,34 @@ export class Group extends ObjectBase {
         await Group.checkDuplicateGroupCode(dbTransaction, group.NewGroupCode);
       }
 
+      const entityValueBefore = {
+        GroupCode: currentGroup.GroupCode,
+        Name: currentGroup.Name,
+        Type: currentGroup.Type,
+        Description: currentGroup.Description,
+        ParentGroupCode: currentGroup.ParentGroupCode,
+        InheritParentPrivilegeYN: currentGroup.InheritParentPrivilegeYN,
+        InheritParentSystemAccessYN: currentGroup.InheritParentSystemAccessYN,
+        Path: this.Path,
+        Status: currentGroup.Status,
+        CreatedById: currentGroup._CreatedById,
+        UpdatedById: currentGroup._UpdatedById,
+        CreatedAt: currentGroup._CreatedAt,
+        UpdatedAt: currentGroup._UpdatedAt,
+      };
+
+      let isPathChanged = false;
+      const oldGroupCode = currentGroup.GroupCode;
+      if (group.NewGroupCode) {
+        currentGroup.GroupCode = group.NewGroupCode;
+        isPathChanged = true;
+      }
+
+      //Check if ParentGroupCode is changed or added
       if (
-        group.ParentGroupCode &&
-        currentGroup.ParentGroupCode !== group.ParentGroupCode
+        (group.ParentGroupCode &&
+          currentGroup.ParentGroupCode !== group.ParentGroupCode) ||
+        (group.ParentGroupCode && !currentGroup.ParentGroupCode)
       ) {
         const parentGroup = await Group.init(
           dbTransaction,
@@ -375,24 +518,18 @@ export class Group extends ObjectBase {
             'Parent Group Code not found',
           );
         }
+        await currentGroup.setParent(parentGroup);
+        //Check if ParentGroupCode is removed
+        isPathChanged = true;
+      } else if (!group.ParentGroupCode && currentGroup.ParentGroupCode) {
+        await currentGroup.setParent(null);
+        isPathChanged = true;
       }
 
-      const entityValueBefore = {
-        GroupCode: currentGroup.GroupCode,
-        Name: currentGroup.Name,
-        Type: currentGroup.Type,
-        Description: currentGroup.Description,
-        ParentGroupCode: currentGroup.ParentGroupCode,
-        InheritParentPrivilegeYN: currentGroup.InheritParentPrivilegeYN,
-        InheritParentSystemAccessYN: currentGroup.InheritParentSystemAccessYN,
-        Status: currentGroup.Status,
-        CreatedById: currentGroup._CreatedById,
-        UpdatedById: currentGroup._UpdatedById,
-        CreatedAt: currentGroup._CreatedAt,
-        UpdatedAt: currentGroup._UpdatedAt,
-      };
+      if (isPathChanged) {
+        await this.updateChildrenPath(oldGroupCode, dbTransaction);
+      }
 
-      currentGroup.GroupCode = group?.NewGroupCode || currentGroup.GroupCode;
       currentGroup.Name = group?.Name || currentGroup.Name;
       currentGroup.Type = group?.Type || currentGroup.Type;
       currentGroup.Description = group?.Description || currentGroup.Description;
@@ -780,7 +917,7 @@ export class Group extends ObjectBase {
 
           const activity = new Activity();
           activity.ActivityId = activity.createId();
-          activity.Action = ActionEnum.ADD;
+          activity.Action = ActionEnum.CREATE;
           activity.Description = 'Create Group System Access';
           activity.EntityType = 'GroupSystemAccess';
           activity.EntityId = systemAccess.GroupSystemAccessId?.toString();
@@ -984,6 +1121,15 @@ export class Group extends ObjectBase {
             },
           };
         }
+
+        if (search.PrivilegeCode) {
+          systemPrivilegeWhere = {
+            ...systemPrivilegeWhere,
+            PrivilegeCode: {
+              [Op.substring]: search.PrivilegeCode,
+            },
+          };
+        }
       }
       const group = await Group._Repo.findOne({
         where: where,
@@ -1010,12 +1156,12 @@ export class Group extends ObjectBase {
       const systemWhere: any = {};
       if (search) {
         Object.entries(search).forEach(([key, value]) => {
-          if (key === 'SystemCode') {
-            systemWhere[key] = {
+          if (key === 'Status') {
+            objectWhere[key] = {
               [Op.substring]: value,
             };
           } else {
-            objectWhere[key] = {
+            systemWhere[key] = {
               [Op.substring]: value,
             };
           }
@@ -1064,9 +1210,11 @@ export class Group extends ObjectBase {
 
       //format to make sure no duplicate
       const uniquePrivileges = Array.from(
-        new Set(privileges.map((a) => a.PrivilegeCode)),
-      ).map((PrivilegeCode) => {
-        return privileges.find((a) => a.PrivilegeCode === PrivilegeCode);
+        new Set(privileges.map((a) => a.SystemPrivilegeId)),
+      ).map((SystemPrivilegeId) => {
+        return privileges.find(
+          (a) => a.SystemPrivilegeId === SystemPrivilegeId,
+        );
       });
 
       return uniquePrivileges;
@@ -1129,6 +1277,7 @@ export class Group extends ObjectBase {
     dbTransaction: any,
     GroupCode: string,
     GroupObjectPrivileges: GroupObjectPrivilege[],
+    SystemCode: string,
   ): Promise<string> {
     try {
       //Part 1: Privilege Checking
@@ -1174,7 +1323,7 @@ export class Group extends ObjectBase {
           group.ParentGroupCode,
           1,
           Number.MAX_SAFE_INTEGER,
-          {},
+          undefined,
         );
       }
 
@@ -1183,7 +1332,7 @@ export class Group extends ObjectBase {
         //Initialise existing System privilege
         const systemPrivilege = await SystemPrivilege.init(
           dbTransaction,
-          groupObjectPrivilege.PrivilegeCode,
+          groupObjectPrivilege.SystemPrivilegeId,
         );
         //Check whether the system codes used by that privilege is exist inside the group system access
         const combinedSystemAccesses = {
@@ -1199,7 +1348,7 @@ export class Group extends ObjectBase {
             'Group',
             'GroupErrMsg13',
             'Failed to assign privilege ' +
-              groupObjectPrivilege.PrivilegeCode +
+              groupObjectPrivilege.SystemPrivilegeId +
               ' due to non-existent system access.',
           );
         }
@@ -1209,7 +1358,7 @@ export class Group extends ObjectBase {
           await Group._GroupObjectPrivilegeRepo.findOne({
             where: {
               GroupCode,
-              PrivilegeCode: groupObjectPrivilege.PrivilegeCode,
+              SystemPrivilegeId: groupObjectPrivilege.SystemPrivilegeId,
               ObjectId: groupObjectPrivilege.ObjectId,
               ObjectType: groupObjectPrivilege.ObjectType,
             },
@@ -1276,7 +1425,7 @@ export class Group extends ObjectBase {
 
       if (search) {
         Object.entries(search).forEach(([key, value]) => {
-          if (key === 'SystemCode') {
+          if (key === 'SystemCode' || key === 'PrivilegeCode') {
             systemWhere[key] = {
               [Op.substring]: value,
             };
@@ -1311,9 +1460,11 @@ export class Group extends ObjectBase {
 
       //Remove duplicate
       const uniquePrivileges = Array.from(
-        new Set(privileges.map((a) => a.PrivilegeCode)),
-      ).map((PrivilegeCode) => {
-        return privileges.find((a) => a.PrivilegeCode === PrivilegeCode);
+        new Set(privileges.map((a) => a.SystemPrivilegeId)),
+      ).map((SystemPrivilegeId) => {
+        return privileges.find(
+          (a) => a.SystemPrivilegeId === SystemPrivilegeId,
+        );
       });
 
       // Create the result based on the spec on return then returns it.
@@ -1327,7 +1478,7 @@ export class Group extends ObjectBase {
     loginUser: LoginUser,
     dbTransaction: any,
     GroupCode: string,
-    PrivilegeCodes: string[],
+    SystemPrivilegeIds: string[],
   ) {
     try {
       // Part 1: Privilege Checking
@@ -1379,11 +1530,11 @@ export class Group extends ObjectBase {
       }
 
       // For each Params.PrivilegesCodes.
-      for (const PrivilegeCode of PrivilegeCodes) {
+      for (const SystemPrivilegeId of SystemPrivilegeIds) {
         // Initialise existing System privilege by calling SystemPrivilege.init
         const systemPrivilege = await SystemPrivilege.init(
           dbTransaction,
-          PrivilegeCode,
+          SystemPrivilegeId,
         );
         //Check whether the system codes used by that privilege is exist inside the group system access retrieved from step 2.2 & 2.4. If system code does not exist in group system access, throw a new ClassError by passing:
         // Classname: "Group"
@@ -1402,7 +1553,7 @@ export class Group extends ObjectBase {
             'Group',
             'GroupErrMsg13',
             'Failed to assign privilege ' +
-              PrivilegeCode +
+              SystemPrivilegeId +
               ' due to non-existent system access.',
           );
         }
@@ -1411,8 +1562,13 @@ export class Group extends ObjectBase {
         const groupPrivilege = await Group._GroupPrivilegeRepo.findOne({
           where: {
             GroupCode,
-            PrivilegeCode,
+            SystemPrivilegeId,
           },
+          include: [
+            {
+              model: SystemPrivilegeModel,
+            },
+          ],
           transaction: dbTransaction,
         });
 
@@ -1423,7 +1579,7 @@ export class Group extends ObjectBase {
 
         let entityValueBefore = {};
         let entityValueAfter = {};
-        let action = ActionEnum.ADD;
+        let action = ActionEnum.CREATE;
         let description = 'Create Group Privilege';
         let entityId = null;
         //If GroupPrivilege record exist and status is not "Active" do the following:
@@ -1431,7 +1587,7 @@ export class Group extends ObjectBase {
           //Set this GroupPrivilege entity as EntityValueBefore
           entityValueBefore = {
             GroupCode: groupPrivilege.GroupCode,
-            PrivilegeCode: groupPrivilege.PrivilegeCode,
+            SystemPrivilegeId: groupPrivilege.SystemPrivilegeId,
             Status: groupPrivilege.Status,
             CreatedById: groupPrivilege.CreatedById,
             CreatedAt: groupPrivilege.CreatedAt,
@@ -1445,18 +1601,27 @@ export class Group extends ObjectBase {
             UpdatedById: loginUser.UserId,
             UpdatedAt: new Date(),
           };
-          await Group._GroupPrivilegeRepo.update(updatedPayload, {
+          const data = await Group._GroupPrivilegeRepo.findOne({
             where: {
               GroupCode,
-              PrivilegeCode,
+              SystemPrivilegeId,
             },
+            include: [
+              {
+                model: SystemPrivilegeModel,
+              },
+            ],
             transaction: dbTransaction,
           });
+          data.Status = 'Active';
+          data.UpdatedById = updatedPayload.UpdatedById;
+          data.UpdatedAt = updatedPayload.UpdatedAt;
+          await data.save({ transaction: dbTransaction });
 
           //Set updated GroupPrivilege as EntityValueAfter
           entityValueAfter = {
             GroupCode: groupPrivilege.GroupCode,
-            PrivilegeCode: groupPrivilege.PrivilegeCode,
+            SystemPrivilegeId: groupPrivilege.SystemPrivilegeId,
             Status: updatedPayload.Status,
             CreatedById: groupPrivilege.CreatedById,
             CreatedAt: groupPrivilege.CreatedAt,
@@ -1475,7 +1640,7 @@ export class Group extends ObjectBase {
           //Set the attributes
           newGroupPrivilege.setAttributes({
             GroupCode,
-            PrivilegeCode,
+            SystemPrivilegeId,
             Status: 'Active',
             CreatedById: loginUser.UserId,
             CreatedAt: new Date(),
@@ -1486,7 +1651,7 @@ export class Group extends ObjectBase {
           // Set EntityValueAfter to above instance.
           entityValueAfter = {
             GroupCode: newGroupPrivilege.GroupCode,
-            PrivilegeCode: newGroupPrivilege.PrivilegeCode,
+            SystemPrivilegeId: newGroupPrivilege.SystemPrivilegeId,
             Status: newGroupPrivilege.Status,
             CreatedById: newGroupPrivilege.CreatedById,
             CreatedAt: newGroupPrivilege.CreatedAt,
@@ -1501,7 +1666,7 @@ export class Group extends ObjectBase {
               transaction: dbTransaction,
             },
           );
-          action = ActionEnum.ADD;
+          action = ActionEnum.CREATE;
           description = 'Create Group Privilege';
           entityId = groupPrivilege.GroupPrivilegeId;
         }
@@ -1530,7 +1695,7 @@ export class Group extends ObjectBase {
     loginUser: LoginUser,
     dbTransaction: any,
     GroupCode: string,
-    PrivilegeCodes: string[],
+    SystemPrivilegeIds: string[],
   ) {
     try {
       // Part 1: Privilege Checking
@@ -1551,13 +1716,18 @@ export class Group extends ObjectBase {
 
       // Part 2: Validation, Create and Record Activity
       // For each Params.PrivilegesCodes.
-      for (const PrivilegeCode of PrivilegeCodes) {
+      for (const SystemPrivilegeId of SystemPrivilegeIds) {
         //Check whether the record exist in database by calling Group._GroupPrivilegeRepo.findOne
         const groupPrivilege = await Group._GroupPrivilegeRepo.findOne({
           where: {
             GroupCode,
-            PrivilegeCode,
+            SystemPrivilegeId,
           },
+          include: [
+            {
+              model: SystemPrivilegeModel,
+            },
+          ],
           transaction: dbTransaction,
         });
 
@@ -1573,7 +1743,7 @@ export class Group extends ObjectBase {
         //Set the EntityValueBefore to the GroupPrivilegesValue from step 1.c.
         const entityValueBefore = {
           GroupCode: groupPrivilege.GroupCode,
-          PrivilegeCode: groupPrivilege.PrivilegeCode,
+          SystemPrivilegeId: groupPrivilege.SystemPrivilegeId,
           Status: groupPrivilege.Status,
           CreatedById: groupPrivilege.CreatedById,
           CreatedAt: groupPrivilege.CreatedAt,
@@ -1584,9 +1754,10 @@ export class Group extends ObjectBase {
         //Call Group._GroupPrivilegeRepo.delete
         await Group._GroupPrivilegeRepo.delete(
           GroupCode,
-          PrivilegeCode,
+          SystemPrivilegeId,
           dbTransaction,
         );
+
         // Instantiate new activity from Activity class, call createId() method, then set:
         const activity = new Activity();
         activity.ActivityId = activity.createId();

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

@@ -11,7 +11,7 @@ export class GroupObjectPrivilege extends ObjectBase {
   ObjectName: string;
   GroupObjectPrivilegeId: number;
   GroupCode: string;
-  PrivilegeCode: string;
+  SystemPrivilegeId: string;
   ObjectId: string;
   ObjectType: string;
   Status: ObjectStatus;
@@ -44,7 +44,7 @@ export class GroupObjectPrivilege extends ObjectBase {
       this.GroupObjectPrivilegeId =
         GroupObjectPrivilegeAttr.GroupObjectPrivilegeId;
       this.GroupCode = GroupObjectPrivilegeAttr.GroupCode;
-      this.PrivilegeCode = GroupObjectPrivilegeAttr.PrivilegeCode;
+      this.SystemPrivilegeId = GroupObjectPrivilegeAttr.SystemPrivilegeId;
       this.ObjectId = GroupObjectPrivilegeAttr.ObjectId;
       this.ObjectType = GroupObjectPrivilegeAttr.ObjectType;
       this.Status = GroupObjectPrivilegeAttr.Status;
@@ -115,12 +115,12 @@ export class GroupObjectPrivilege extends ObjectBase {
           'GroupCode is missing.',
         );
       }
-      // Params.groupObjectPrivilege.PrivilegeCode
-      if (!groupObjectPrivilege.PrivilegeCode) {
+      // Params.groupObjectPrivilege.SystemPrivilegeId
+      if (!groupObjectPrivilege.SystemPrivilegeId) {
         throw new ClassError(
           'GroupObjectPrivilege',
           'GroupObjectPrivilegeErrMsg02',
-          'PrivilegeCode is missing.',
+          'SystemPrivilegeId is missing.',
         );
       }
       // Params.groupObjectPrivilege.ObjectId
@@ -145,7 +145,7 @@ export class GroupObjectPrivilege extends ObjectBase {
         await GroupObjectPrivilege._Repository.findOne({
           where: {
             GroupCode: groupObjectPrivilege.GroupCode,
-            PrivilegeCode: groupObjectPrivilege.PrivilegeCode,
+            SystemPrivilegeId: groupObjectPrivilege.SystemPrivilegeId,
             ObjectId: groupObjectPrivilege.ObjectId,
             ObjectType: groupObjectPrivilege.ObjectType,
           },
@@ -165,7 +165,7 @@ export class GroupObjectPrivilege extends ObjectBase {
       // Initialise new Group instance and populate the attributes
       const objectAttr = {
         GroupCode: groupObjectPrivilege.GroupCode,
-        PrivilegeCode: groupObjectPrivilege.PrivilegeCode,
+        SystemPrivilegeId: groupObjectPrivilege.SystemPrivilegeId,
         ObjectId: groupObjectPrivilege.ObjectId,
         ObjectType: groupObjectPrivilege.ObjectType,
         Status: ObjectStatus.ACTIVE,
@@ -194,7 +194,7 @@ export class GroupObjectPrivilege extends ObjectBase {
       // Instantiate new activity from Activity class
       const activity = new Activity();
       activity.createId();
-      activity.Action = ActionEnum.ADD;
+      activity.Action = ActionEnum.CREATE;
       activity.Description = `Create GroupObjectPrivilege for (${newGroupObjectPrivilege.GroupCode})`;
       activity.EntityType = 'GroupObjectPrivilege';
       activity.EntityId =
@@ -245,7 +245,7 @@ export class GroupObjectPrivilege extends ObjectBase {
       // Initialise EntityValueBefore variable and set GroupObjectPrivelege column properties
       const EntityValueBefore = {
         GroupCode: this.GroupCode,
-        PrivilegeCode: this.PrivilegeCode,
+        SystemPrivilegeId: this.SystemPrivilegeId,
         ObjectId: this.ObjectId,
         ObjectType: this.ObjectType,
         Status: this.Status,

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

@@ -1,3 +1,4 @@
+import SystemPrivilegeModel from '../../models/system-privilege.entity';
 import GroupPrivilegeModel from '../../models/group-privilege.entity';
 import { RepositoryBase, IRepositoryBase } from '@tomei/general';
 
@@ -9,12 +10,24 @@ export class GroupPrivilegeRepository
     super(GroupPrivilegeModel);
   }
 
-  async delete(GroupCode: string, PrivilegeCode: string, dbTransaction?: any) {
+  async delete(
+    GroupCode: string,
+    PrivilegeCode: string,
+    SystemCode: string,
+    dbTransaction?: any,
+  ) {
     try {
-      return await GroupPrivilegeModel.destroy({
+      const data = await GroupPrivilegeModel.findOne({
         where: { GroupCode, PrivilegeCode },
-        transaction: dbTransaction,
+        include: [
+          {
+            model: SystemPrivilegeModel,
+            where: { SystemCode },
+          },
+        ],
       });
+      data.destroy({ transaction: dbTransaction });
+      return data;
     } catch (error) {
       throw error;
     }