@tomei/sso 0.60.4-dev.6 → 0.60.4

package/dist/components/group/group.js

@@ -0,0 +1,1337 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Group = void 0;
+const general_1 = require("@tomei/general");
+const group_repository_1 = require("./group.repository");
+const config_1 = require("@tomei/config");
+const sequelize_1 = require("sequelize");
+const activity_history_1 = require("@tomei/activity-history");
+const group_system_access_repository_1 = require("../group-system-access/group-system-access.repository");
+const system_entity_1 = __importDefault(require("../../models/system.entity"));
+const group_system_access_1 = require("../group-system-access");
+const redis_service_1 = require("../../redis-client/redis.service");
+const system_privilege_entity_1 = __importDefault(require("../../models/system-privilege.entity"));
+const group_privilege_repository_1 = require("../group-privilege/group-privilege.repository");
+const system_privilege_1 = require("../system-privilege/system-privilege");
+const group_privilege_entity_1 = __importDefault(require("../../models/group-privilege.entity"));
+const group_object_privilege_repository_1 = require("../group-object-privilege/group-object-privilege.repository");
+const group_object_privilege_1 = require("../group-object-privilege/group-object-privilege");
+const group_privilege_1 = require("../group-privilege/group-privilege");
+const group_reporting_user_entity_1 = __importDefault(require("../../models/group-reporting-user.entity"));
+const group_entity_1 = __importDefault(require("../../models/group.entity"));
+const user_entity_1 = __importDefault(require("../../models/user.entity"));
+class Group extends general_1.TreeNodeBase {
+    get GroupCode() {
+        return this.ObjectId;
+    }
+    set GroupCode(value) {
+        this.ObjectId = value;
+    }
+    get CreatedById() {
+        return this._CreatedById;
+    }
+    get CreatedAt() {
+        return this._CreatedAt;
+    }
+    get UpdatedById() {
+        return this._UpdatedById;
+    }
+    get UpdatedAt() {
+        return this._UpdatedAt;
+    }
+    get Path() {
+        return this._Path;
+    }
+    set Path(value) {
+        this._Path = value;
+    }
+    constructor(groupAttr) {
+        super();
+        this.ObjectType = 'Group';
+        this._Path = '';
+        this.isChildrenLoaded = false;
+        this.isParentLoaded = false;
+        if (groupAttr) {
+            this.GroupCode = groupAttr.GroupCode;
+            this.Name = groupAttr.Name;
+            this.Description = groupAttr?.Description;
+            this.Type = groupAttr?.Type;
+            this.ParentGroupCode = groupAttr?.ParentGroupCode;
+            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;
+            this._UpdatedAt = groupAttr.UpdatedAt;
+        }
+    }
+    static async init(dbTransaction, GroupCode) {
+        try {
+            Group._RedisService = await redis_service_1.RedisService.init();
+            if (GroupCode) {
+                const group = await Group._Repo.findByPk(GroupCode, {
+                    transaction: dbTransaction,
+                });
+                if (group) {
+                    return new Group(group);
+                }
+                else {
+                    throw Error('Group not found');
+                }
+            }
+            return new Group();
+        }
+        catch (error) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group');
+        }
+    }
+    async loadChildren(dbTransaction) {
+        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) {
+        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) {
+        if (!this.isChildrenLoaded) {
+            await this.loadChildren(dbTransaction);
+        }
+        return this.children.length === 0;
+    }
+    async getPath(dbTransaction) {
+        if (!this.isParentLoaded) {
+            await this.loadParent(dbTransaction);
+        }
+        if (this.parent) {
+            this._Path =
+                (await this.parent.getPath(dbTransaction)) + '/' + this.GroupCode;
+            return this._Path;
+        }
+        this._Path = this.GroupCode;
+        return this._Path;
+    }
+    async updatePath(dbTransaction) {
+        const path = await this.getPath(dbTransaction);
+        this._Path = path;
+    }
+    async setParent(parent, dbTransaction) {
+        this.parent = parent;
+        await this.updatePath(dbTransaction);
+    }
+    async getPathDetail(dbTransaction) {
+        const path = this._Path.split('/');
+        const groups = [];
+        for (let i = 0; i < path.length; i++) {
+            const group = await Group.init(dbTransaction, path[i]);
+            groups.push(group);
+        }
+        return groups;
+    }
+    static async findAll(page, row, dbTransaction, loginUser, search) {
+        const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+        const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_LIST');
+        if (!isPrivileged) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg04', 'User is not privileged to list group');
+        }
+        const queryObj = {};
+        let options = {
+            transaction: dbTransaction,
+        };
+        if (page && row) {
+            options = {
+                ...options,
+                limit: row,
+                offset: row * (page - 1),
+                order: [['CreatedAt', 'DESC']],
+            };
+        }
+        if (search) {
+            Object.entries(search).forEach(([key, value]) => {
+                queryObj[key] = {
+                    [sequelize_1.Op.substring]: value,
+                };
+            });
+            options = {
+                ...options,
+                where: queryObj,
+            };
+            const result = await Group._Repo.findAllWithPagination(options);
+            return {
+                Count: result.count,
+                Groups: result.rows.map((group) => new Group(group.get({ plain: true }))),
+            };
+        }
+    }
+    static async create(loginUser, dbTransaction, group) {
+        try {
+            const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+            const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_CREATE');
+            if (!isPrivileged) {
+                throw new Error('You do not have permission to create group');
+            }
+            if (!group.GroupCode) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg02', 'Group Code is required');
+            }
+            if (!group.Name) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg02', 'Group Name is required');
+            }
+            if (!group.Type) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg02', 'Group Type is required');
+            }
+            const existingGroupCode = await Group._Repo.findByPk(group.GroupCode, {
+                transaction: dbTransaction,
+            });
+            if (existingGroupCode) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg03', 'Duplicate GroupCode found.');
+            }
+            if (group.ParentGroupCode) {
+                const parentGroup = await Group._Repo.findByPk(group.ParentGroupCode, {
+                    transaction: dbTransaction,
+                });
+                if (!parentGroup) {
+                    throw new general_1.ClassError('Group', 'GroupErrMsg04', 'ParentGroupCode is not found.');
+                }
+                if (group.GroupCode === group.ParentGroupCode) {
+                    throw new general_1.ClassError('Group', 'GroupErrMsg05', 'GroupCode and ParentGroupCode cannot be the same.');
+                }
+            }
+            const newGroup = new Group(group);
+            newGroup.ObjectId = group.GroupCode;
+            newGroup.Name = group.Name;
+            newGroup.Type = group.Type;
+            newGroup.Description = group.Description;
+            newGroup.ParentGroupCode = group.ParentGroupCode;
+            newGroup.InheritParentPrivilegeYN = group.InheritParentPrivilegeYN;
+            newGroup.InheritParentSystemAccessYN = group.InheritParentSystemAccessYN;
+            newGroup.Status = 'Active';
+            newGroup._CreatedById = loginUser.UserId;
+            newGroup._UpdatedById = loginUser.UserId;
+            newGroup._Path = await newGroup.getPath(dbTransaction);
+            const entityGroupAfter = {
+                GroupCode: newGroup.ObjectId,
+                Name: newGroup.Name,
+                Type: newGroup.Type,
+                Description: newGroup.Description,
+                ParentGroupCode: newGroup.ParentGroupCode,
+                InheritParentPrivilegeYN: newGroup.InheritParentPrivilegeYN,
+                InheritParentSystemAccessYN: newGroup.InheritParentSystemAccessYN,
+                Path: newGroup._Path,
+                Status: newGroup.Status,
+                CreatedById: newGroup._CreatedById,
+                UpdatedById: newGroup._UpdatedById,
+                CreatedAt: newGroup._CreatedAt,
+                UpdatedAt: newGroup._UpdatedAt,
+            };
+            await Group._Repo.create(entityGroupAfter, {
+                transaction: dbTransaction,
+            });
+            const entityValueBefore = {};
+            const activity = new activity_history_1.Activity();
+            activity.ActivityId = activity.createId();
+            activity.Action = activity_history_1.ActionEnum.CREATE;
+            activity.Description = 'Create Group';
+            activity.EntityType = 'Group';
+            activity.EntityId = newGroup.ObjectId;
+            activity.EntityValueBefore = JSON.stringify(entityValueBefore);
+            activity.EntityValueAfter = JSON.stringify(entityGroupAfter);
+            await activity.create(loginUser.ObjectId, dbTransaction);
+            return newGroup;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async checkDuplicateGroupCode(dbTransaction, GroupCode) {
+        const isGroupCodeExist = await Group._Repo.findOne({
+            where: { GroupCode },
+            transaction: dbTransaction,
+        });
+        if (isGroupCodeExist) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg07', 'GroupCode already exists.');
+        }
+    }
+    async updateChildrenPath(oldGroupCode, dbTransaction) {
+        try {
+            const isLeaf = await this.isLeaf(dbTransaction);
+            if (isLeaf) {
+                return;
+            }
+            const childrens = await Group._Repo.findAll({
+                where: {
+                    Path: {
+                        [sequelize_1.Op.like]: `${oldGroupCode}/%`,
+                    },
+                },
+                transaction: dbTransaction,
+            });
+            childrens.forEach(async (children) => {
+                const path = children.Path.split(`${oldGroupCode}/`);
+                const childPath = path[1];
+                await children.update({ Path: `${this._Path}/${childPath}` }, { transaction: dbTransaction });
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async update(loginUser, dbTransaction, group) {
+        const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+        const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_UPDATE');
+        if (!isPrivileged) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg06', 'You do not have the privilege to update Group');
+        }
+        try {
+            if (group.NewGroupCode) {
+                await Group.checkDuplicateGroupCode(dbTransaction, group.NewGroupCode);
+            }
+            const entityValueBefore = {
+                GroupCode: this.GroupCode,
+                Name: this.Name,
+                Type: this.Type,
+                Description: this.Description,
+                ParentGroupCode: this.ParentGroupCode,
+                InheritParentPrivilegeYN: this.InheritParentPrivilegeYN,
+                InheritParentSystemAccessYN: this.InheritParentSystemAccessYN,
+                Path: this.Path,
+                Status: this.Status,
+                CreatedById: this._CreatedById,
+                UpdatedById: this._UpdatedById,
+                CreatedAt: this._CreatedAt,
+                UpdatedAt: this._UpdatedAt,
+            };
+            let isPathChanged = false;
+            const oldGroupCode = this.GroupCode;
+            if (group.NewGroupCode) {
+                this.GroupCode = group.NewGroupCode;
+                isPathChanged = true;
+            }
+            if ((group.ParentGroupCode &&
+                this.ParentGroupCode !== group.ParentGroupCode) ||
+                (group.ParentGroupCode && !this.ParentGroupCode)) {
+                const parentGroup = await Group.init(dbTransaction, group.ParentGroupCode);
+                if (!parentGroup) {
+                    throw new general_1.ClassError('Group', 'GroupErrMsg08', 'Parent Group Code not found');
+                }
+                await this.setParent(parentGroup);
+                isPathChanged = true;
+            }
+            else if (!group.ParentGroupCode && this.ParentGroupCode) {
+                await this.setParent(null);
+                isPathChanged = true;
+            }
+            if (isPathChanged) {
+                await this.updateChildrenPath(oldGroupCode, dbTransaction);
+            }
+            this.Name = group?.Name || this.Name;
+            this.Type = group?.Type || this.Type;
+            this.Description = group?.Description || this.Description;
+            this.ParentGroupCode = group?.ParentGroupCode || this.ParentGroupCode;
+            this.InheritParentPrivilegeYN =
+                group?.InheritParentPrivilegeYN || this.InheritParentPrivilegeYN;
+            this.InheritParentSystemAccessYN =
+                group?.InheritParentSystemAccessYN || this.InheritParentSystemAccessYN;
+            this.Status = group?.Status || this.Status;
+            this._UpdatedById = loginUser.UserId;
+            this._UpdatedAt = new Date();
+            await Group._Repo.update({
+                GroupCode: this.GroupCode,
+                Name: this.Name,
+                Type: this.Type,
+                Description: this.Description,
+                ParentGroupCode: this.ParentGroupCode,
+                InheritParentPrivilegeYN: this.InheritParentPrivilegeYN,
+                InheritParentSystemAccessYN: this.InheritParentSystemAccessYN,
+                Status: this.Status,
+                Path: this._Path,
+                UpdatedById: this._UpdatedById,
+                UpdatedAt: this._UpdatedAt,
+            }, {
+                where: {
+                    GroupCode: group.GroupCode,
+                },
+                transaction: dbTransaction,
+            });
+            const entityValueAfter = {
+                GroupCode: this.GroupCode,
+                Name: this.Name,
+                Type: this.Type,
+                Description: this.Description,
+                ParentGroupCode: this.ParentGroupCode,
+                InheritParentPrivilegeYN: this.InheritParentPrivilegeYN,
+                InheritParentSystemAccessYN: this.InheritParentSystemAccessYN,
+                Status: this.Status,
+                Path: this._Path,
+                CreatedById: this._CreatedById,
+                UpdatedById: this._UpdatedById,
+                CreatedAt: this._CreatedAt,
+                UpdatedAt: this._UpdatedAt,
+            };
+            const activity = new activity_history_1.Activity();
+            activity.ActivityId = activity.createId();
+            activity.Action = activity_history_1.ActionEnum.UPDATE;
+            activity.Description = `Update Group ${group.Type}`;
+            activity.EntityType = 'Group';
+            activity.EntityId = group.GroupCode;
+            activity.EntityValueBefore = JSON.stringify(entityValueBefore);
+            activity.EntityValueAfter = JSON.stringify(entityValueAfter);
+            await activity.create(loginUser.ObjectId, dbTransaction);
+            return this;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async delete(loginUser, dbTransaction, GroupCode) {
+        const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+        const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_DELETE');
+        if (!isPrivileged) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg03', 'You do not have the privilege to delete groups records.');
+        }
+        try {
+            const group = await Group.init(dbTransaction, GroupCode);
+            if (group.Status === 'Active') {
+                throw new general_1.ClassError('Group', 'GroupErrMsg03', 'Active Group cant be deleted');
+            }
+            const relatedGroup = await Group.findAll(1, Number.MAX_SAFE_INTEGER, dbTransaction, loginUser, {
+                ParentGroupCode: GroupCode,
+            });
+            if (relatedGroup.Count > 0) {
+                const listOfRelatedGroup = relatedGroup.Groups.map((group) => {
+                    return group.GroupCode;
+                });
+                throw new general_1.ClassError('Group', 'GroupErrMsg03', `Group still has associated user group ${listOfRelatedGroup}`);
+            }
+            await Group._Repo.delete(GroupCode, dbTransaction);
+            const EntityValueBefore = {
+                GroupCode: group.GroupCode,
+                Name: group.Name,
+                Type: group.Type,
+                Description: group.Description,
+                ParentGroupCode: group.ParentGroupCode,
+                InheritParentPrivilegeYN: group.InheritParentPrivilegeYN,
+                InheritParentSystemAccessYN: group.InheritParentSystemAccessYN,
+                Status: group.Status,
+                CreatedById: group._CreatedById,
+                UpdatedById: group._UpdatedById,
+                CreatedAt: group._CreatedAt,
+                UpdatedAt: group._UpdatedAt,
+            };
+            const activity = new activity_history_1.Activity();
+            activity.ActivityId = activity.createId();
+            activity.Action = activity_history_1.ActionEnum.DELETE;
+            activity.Description = 'Delete Group';
+            activity.EntityType = 'Group';
+            activity.EntityId = group.ObjectId;
+            activity.EntityValueBefore = JSON.stringify(EntityValueBefore);
+            activity.EntityValueAfter = JSON.stringify({});
+            await activity.create(loginUser.ObjectId, dbTransaction);
+            return { Message: 'Group removed.' };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async getSystemAccesses(loginUser, dbTransaction, GroupCode, Page, Rows, Search) {
+        const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+        const isPrivileged = await loginUser.checkPrivileges(systemCode, 'SYSTEM_ACCESS_VIEW');
+        if (!isPrivileged) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg06', 'You do not have the privilege to view system access');
+        }
+        try {
+            await Group.init(dbTransaction, GroupCode);
+            const queryObj = { GroupCode: GroupCode };
+            if (Search) {
+                Object.entries(Search).forEach(([key, value]) => {
+                    queryObj[key] = value;
+                });
+            }
+            let options = {
+                where: queryObj,
+                distinct: true,
+                transaction: dbTransaction,
+            };
+            if (Page && Rows) {
+                options = {
+                    ...options,
+                    limit: Rows,
+                    offset: Rows * (Page - 1),
+                    order: [['CreatedAt', 'DESC']],
+                };
+            }
+            const systemAccess = await Group._GroupSystemAccessRepo.findAndCountAll(options);
+            return systemAccess;
+        }
+        catch (error) {
+            return error;
+        }
+    }
+    static async getSystemAccessRoles(loginUser, dbTransaction, SystemCode, Page, Rows, Search) {
+        const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+        const isPrivileged = await loginUser.checkPrivileges(systemCode, 'SYSTEM_ACCESS_VIEW');
+        if (!isPrivileged) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg06', 'You do not have the privilege to view system access');
+        }
+        try {
+            const queryObj = { SystemCode: SystemCode };
+            if (Search) {
+                Object.entries(Search).forEach(([key, value]) => {
+                    queryObj[key] = value;
+                });
+            }
+            let options = {
+                where: queryObj,
+                distinct: true,
+                transaction: dbTransaction,
+            };
+            if (Page && Rows) {
+                options = {
+                    ...options,
+                    limit: Rows,
+                    offset: Rows * (Page - 1),
+                    order: [['CreatedAt', 'DESC']],
+                    include: {
+                        model: group_entity_1.default,
+                        where: {
+                            Type: 'Role',
+                        },
+                    },
+                };
+            }
+            const systemAccess = await Group._GroupSystemAccessRepo.findAndCountAll(options);
+            return systemAccess;
+        }
+        catch (error) {
+            return error;
+        }
+    }
+    static async getInheritedSystemAccess(dbTransaction, group) {
+        const options = {
+            where: {
+                GroupCode: group.GroupCode,
+                Status: 'Active',
+            },
+            include: [
+                {
+                    model: system_entity_1.default,
+                },
+            ],
+            transaction: dbTransaction,
+        };
+        let systemAccess = await Group._GroupSystemAccessRepo.findAll(options);
+        if (group.InheritParentSystemAccessYN === 'Y' && group.ParentGroupCode) {
+            const parentGroup = await Group.init(dbTransaction, group.ParentGroupCode);
+            const parentSystemAccesses = await this.getInheritedSystemAccess(dbTransaction, parentGroup);
+            systemAccess = systemAccess.concat(parentSystemAccesses);
+        }
+        return systemAccess;
+    }
+    static async isGroupCodeInHierarchy(dbTransaction, GroupCode, ListGroupCode = []) {
+        ListGroupCode.push(GroupCode);
+        const group = await Group._Repo.findOne({
+            where: { GroupCode },
+            transaction: dbTransaction,
+        });
+        if (group?.ParentGroupCode) {
+            const isGroupCodeExist = ListGroupCode.includes(group.ParentGroupCode);
+            if (!isGroupCodeExist) {
+                await this.isGroupCodeInHierarchy(dbTransaction, group.ParentGroupCode, ListGroupCode);
+            }
+            {
+                return false;
+            }
+        }
+        else {
+            return true;
+        }
+    }
+    static async getParentSystemAccesses(loginUser, dbTransaction, GroupCode) {
+        const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+        const isPrivileged = await loginUser.checkPrivileges(systemCode, 'SYSTEM_ACCESS_VIEW');
+        if (!isPrivileged) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg06', 'You do not have the privilege to view system access');
+        }
+        try {
+            const group = await Group.init(dbTransaction, GroupCode);
+            if (group.InheritParentSystemAccessYN !== 'Y' || !group.ParentGroupCode) {
+                return [];
+            }
+            else {
+                const parentGroup = await Group.init(dbTransaction, group.ParentGroupCode);
+                const inheritSystemAccess = await Group.getInheritedSystemAccess(dbTransaction, parentGroup);
+                return inheritSystemAccess;
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async addSystemAccesses(loginUser, dbTransaction, GroupCode, SystemCodes) {
+        const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+        const isPrivileged = await loginUser.checkPrivileges(systemCode, 'SYSTEM_ACCESS_CREATE');
+        if (!isPrivileged) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg07', 'You do not have the privilege to create system access');
+        }
+        try {
+            if (SystemCodes.length > 0) {
+                for (const element of SystemCodes) {
+                    const CurrentGroupSystemAccess = await Group.getSystemAccesses(loginUser, dbTransaction, GroupCode, 1, Number.MAX_SAFE_INTEGER, { SystemCode: element });
+                    if (CurrentGroupSystemAccess?.count > 0) {
+                        throw new general_1.ClassError('Group', 'GroupErrMsg08', 'System access already exists');
+                    }
+                    const groupSystemAccess = await group_system_access_1.GroupSystemAccess.init(dbTransaction);
+                    groupSystemAccess.createId();
+                    groupSystemAccess.GroupCode = GroupCode;
+                    groupSystemAccess.SystemCode = element;
+                    groupSystemAccess.Status = 'Active';
+                    groupSystemAccess.CreatedById = +loginUser.ObjectId;
+                    groupSystemAccess.CreatedAt = new Date();
+                    groupSystemAccess.UpdatedById = +loginUser.ObjectId;
+                    groupSystemAccess.UpdatedAt = new Date();
+                    const EntityValueAfter = {
+                        GroupCode: groupSystemAccess.GroupCode,
+                        SystemCode: groupSystemAccess.SystemCode,
+                        Status: groupSystemAccess.Status,
+                        CreatedById: groupSystemAccess.CreatedById,
+                        CreatedAt: groupSystemAccess.CreatedAt,
+                        UpdatedById: groupSystemAccess.UpdatedById,
+                        UpdatedAt: groupSystemAccess.UpdatedAt,
+                    };
+                    const systemAccess = await Group._GroupSystemAccessRepo.create(EntityValueAfter, {
+                        transaction: dbTransaction,
+                    });
+                    const activity = new activity_history_1.Activity();
+                    activity.ActivityId = activity.createId();
+                    activity.Action = activity_history_1.ActionEnum.CREATE;
+                    activity.Description = 'Create Group System Access';
+                    activity.EntityType = 'GroupSystemAccess';
+                    activity.EntityId = systemAccess.GroupSystemAccessId?.toString();
+                    activity.EntityValueBefore = JSON.stringify({});
+                    activity.EntityValueAfter = JSON.stringify(EntityValueAfter);
+                    await activity.create(loginUser.ObjectId, dbTransaction);
+                }
+                return { Message: 'Successfully added.' };
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async deleteSystemAccess(loginUser, dbTransaction, GroupCode, SystemCode) {
+        const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+        const isPrivileged = await loginUser.checkPrivileges(systemCode, 'SYSTEM_ACCESS_DELETE');
+        if (!isPrivileged) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg08', 'You do not have the privilege to delete system access');
+        }
+        try {
+            const currentGroupSystemAccess = await Group.getSystemAccesses(loginUser, dbTransaction, GroupCode, 1, Number.MAX_SAFE_INTEGER, { SystemCode: SystemCode });
+            if (currentGroupSystemAccess.count < 1) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg10', 'No associated system access found.');
+            }
+            await Group._GroupSystemAccessRepo.delete(GroupCode, SystemCode, dbTransaction);
+            const EntityValueBefore = {
+                GroupCode: currentGroupSystemAccess?.rows[0]?.GroupCode,
+                SystemCode: currentGroupSystemAccess?.rows[0]?.SystemCode,
+                Status: currentGroupSystemAccess?.rows[0]?.Status,
+                CreatedById: currentGroupSystemAccess?.rows[0]?.CreatedById,
+                CreatedAt: currentGroupSystemAccess?.rows[0]?.CreatedAt,
+                UpdatedById: currentGroupSystemAccess?.rows[0]?.UpdatedById,
+                UpdatedAt: currentGroupSystemAccess?.rows[0]?.UpdatedAt,
+            };
+            const activity = new activity_history_1.Activity();
+            activity.ActivityId = activity.createId();
+            activity.Action = activity_history_1.ActionEnum.DELETE;
+            activity.Description = 'Delete Group System Access';
+            activity.EntityType = 'GroupSystemAccess';
+            activity.EntityId =
+                currentGroupSystemAccess?.rows[0]?.GroupSystemAccessId?.toString();
+            activity.EntityValueBefore = JSON.stringify(EntityValueBefore);
+            activity.EntityValueAfter = JSON.stringify({});
+            await activity.create(loginUser.ObjectId, dbTransaction);
+            return { Message: 'System access removed.', SystemCode: SystemCode };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async getSystemPrivileges(loginUser, dbTransaction, GroupCode, search) {
+        try {
+            const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+            const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_PRIVILEGE_VIEW');
+            if (!isPrivileged) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg11', 'You do not have the privilege to view group privileges');
+            }
+            await Group.init(dbTransaction, GroupCode);
+            let where = {
+                GroupCode,
+            };
+            let systemWhere = {};
+            if (search) {
+                if (search.Status) {
+                    where = {
+                        ...where,
+                        Status: search.Status,
+                    };
+                }
+                if (search.SystemCode) {
+                    systemWhere = {
+                        SystemCode: {
+                            [sequelize_1.Op.substring]: search.SystemCode,
+                        },
+                    };
+                }
+            }
+            const groupOwnPrivileges = await Group._GroupPrivilegeRepo.findAll({
+                where,
+                include: [
+                    {
+                        model: system_privilege_entity_1.default,
+                        where: systemWhere,
+                    },
+                ],
+                transaction: dbTransaction,
+            });
+            const privileges = [];
+            for (const groupPrivilege of groupOwnPrivileges) {
+                const systemPrivilege = await system_privilege_1.SystemPrivilege.init(dbTransaction);
+                systemPrivilege.setAttributes(groupPrivilege.Privilege.get({ plain: true }));
+                privileges.push(systemPrivilege);
+            }
+            return privileges;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async getSystemPrivilegeRoles(loginUser, dbTransaction, SystemCode, search) {
+        try {
+            const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+            const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_PRIVILEGE_VIEW');
+            if (!isPrivileged) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg11', 'You do not have the privilege to view group privileges');
+            }
+            let systemWhere = {};
+            if (SystemCode) {
+                systemWhere = {
+                    SystemCode: {
+                        [sequelize_1.Op.substring]: SystemCode,
+                    },
+                };
+            }
+            const groupCodesPrivileges = [];
+            const allGroupCodePrivileges = await Group._GroupPrivilegeRepo.findAll({
+                include: [
+                    {
+                        model: system_privilege_entity_1.default,
+                        where: systemWhere,
+                    },
+                    {
+                        model: group_entity_1.default,
+                        where: {
+                            Type: 'Role',
+                        },
+                    },
+                ],
+                transaction: dbTransaction,
+            });
+            const privilegesMap = new Map();
+            for (const groupCodePrivilege of allGroupCodePrivileges) {
+                const { SystemPrivilegeId, GroupCode, Group } = groupCodePrivilege;
+                if (!privilegesMap.has(SystemPrivilegeId)) {
+                    privilegesMap.set(SystemPrivilegeId, []);
+                }
+                if (GroupCode && Group?.Name) {
+                    const groupCodes = privilegesMap.get(SystemPrivilegeId);
+                    const newGroupEntry = { Code: GroupCode, Name: Group.Name };
+                    if (groupCodes &&
+                        !groupCodes.some((g) => g.Code === GroupCode && g.Name === Group.Name)) {
+                        groupCodes.push(newGroupEntry);
+                    }
+                }
+            }
+            privilegesMap.forEach((groupCodes, SystemPrivilegeId) => {
+                groupCodesPrivileges.push({
+                    SystemPrivilegeId,
+                    GroupCodes: groupCodes,
+                });
+            });
+            const allPrivileges = await system_privilege_entity_1.default.findAll({
+                where: systemWhere,
+                transaction: dbTransaction,
+            });
+            const groupPrivilegeRoles = [];
+            for (const privilege of allPrivileges) {
+                const matchingGroupPrivilege = groupCodesPrivileges.find((groupPrivilege) => groupPrivilege.SystemPrivilegeId === privilege.SystemPrivilegeId);
+                if (matchingGroupPrivilege) {
+                    groupPrivilegeRoles.push({
+                        SystemPrivilegeId: privilege.SystemPrivilegeId,
+                        PrivilegeCode: privilege.PrivilegeCode,
+                        Description: privilege.Description,
+                        GroupCodes: matchingGroupPrivilege.GroupCodes,
+                    });
+                }
+                else {
+                    groupPrivilegeRoles.push({
+                        SystemPrivilegeId: privilege.SystemPrivilegeId,
+                        PrivilegeCode: privilege.PrivilegeCode,
+                        Description: privilege.Description,
+                        GroupCodes: [],
+                    });
+                }
+            }
+            const filteredGroupPrivilegeRoles = groupPrivilegeRoles
+                .map((role) => {
+                if (search.GroupCode?.length) {
+                    const matchingGroupCodes = role.GroupCodes.filter((groupCode) => search.GroupCode.includes(groupCode.Code));
+                    if (matchingGroupCodes.length === 0) {
+                        return null;
+                    }
+                    return {
+                        ...role,
+                        GroupCodes: matchingGroupCodes,
+                    };
+                }
+                return role;
+            })
+                .filter(Boolean);
+            return filteredGroupPrivilegeRoles;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async getInheritedSystemPrivileges(dbTransaction, GroupCode, search) {
+        try {
+            const where = {
+                GroupCode,
+            };
+            let groupPrivilegeWhere = {};
+            let systemPrivilegeWhere = {};
+            if (search) {
+                if (search.Status) {
+                    groupPrivilegeWhere = {
+                        Status: search.Status,
+                    };
+                }
+                if (search.SystemCode) {
+                    systemPrivilegeWhere = {
+                        SystemCode: {
+                            [sequelize_1.Op.substring]: search.SystemCode,
+                        },
+                    };
+                }
+                if (search.PrivilegeCode) {
+                    systemPrivilegeWhere = {
+                        ...systemPrivilegeWhere,
+                        PrivilegeCode: {
+                            [sequelize_1.Op.substring]: search.PrivilegeCode,
+                        },
+                    };
+                }
+            }
+            const group = await Group._Repo.findOne({
+                where: where,
+                include: [
+                    {
+                        model: group_privilege_entity_1.default,
+                        where: groupPrivilegeWhere,
+                        separate: true,
+                        include: [
+                            {
+                                model: system_privilege_entity_1.default,
+                                where: systemPrivilegeWhere,
+                            },
+                        ],
+                    },
+                ],
+                transaction: dbTransaction,
+            });
+            const objectWhere = {
+                GroupCode,
+            };
+            const systemWhere = {};
+            if (search) {
+                Object.entries(search).forEach(([key, value]) => {
+                    if (key === 'Status') {
+                        objectWhere[key] = {
+                            [sequelize_1.Op.substring]: value,
+                        };
+                    }
+                    else {
+                        systemWhere[key] = {
+                            [sequelize_1.Op.substring]: value,
+                        };
+                    }
+                });
+            }
+            const groupObjectPrivileges = await Group._GroupObjectPrivilegeRepo.findAll({
+                where: objectWhere,
+                include: [
+                    {
+                        model: system_privilege_entity_1.default,
+                        where: systemWhere,
+                    },
+                ],
+                transaction: dbTransaction,
+            });
+            let privileges = [];
+            for (const groupPrivilege of group.GroupPrivileges) {
+                const systemPrivilege = await system_privilege_1.SystemPrivilege.init(dbTransaction);
+                systemPrivilege.setAttributes(groupPrivilege.Privilege.get({ plain: true }));
+                privileges.push(systemPrivilege);
+            }
+            for (const groupObjectPrivilege of groupObjectPrivileges) {
+                const systemPrivilege = await system_privilege_1.SystemPrivilege.init(dbTransaction);
+                systemPrivilege.setAttributes(groupObjectPrivilege.Privilege.get({ plain: true }));
+                privileges.push(systemPrivilege);
+            }
+            if (group.InheritParentPrivilegeYN === 'Y' && group.ParentGroupCode) {
+                const inheritedPrivileges = await Group.getInheritedSystemPrivileges(dbTransaction, group.ParentGroupCode, search);
+                privileges = privileges.concat(inheritedPrivileges);
+            }
+            const uniquePrivileges = Array.from(new Set(privileges.map((a) => a.SystemPrivilegeId))).map((SystemPrivilegeId) => {
+                return privileges.find((a) => a.SystemPrivilegeId === SystemPrivilegeId);
+            });
+            return uniquePrivileges;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async getParentSystemPrivileges(loginUser, dbTransaction, GroupCode, search) {
+        try {
+            const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+            const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_PRIVILEGE_VIEW');
+            if (!isPrivileged) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg11', 'You do not have the privilege to view group privileges');
+            }
+            const group = await Group.init(dbTransaction, GroupCode);
+            if (group.InheritParentPrivilegeYN !== 'Y' || !group.ParentGroupCode) {
+                return [];
+            }
+            const privileges = await Group.getInheritedSystemPrivileges(dbTransaction, group.ParentGroupCode, search);
+            return privileges;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async assignGroupObjectPrivilege(loginUser, dbTransaction, GroupCode, GroupObjectPrivileges, SystemCode) {
+        try {
+            const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+            const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_OBJECT_PRIVILEGE_ASSIGN');
+            if (!isPrivileged) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg12', 'You do not have the privilege to assign group object privilege');
+            }
+            const group = await Group.init(dbTransaction, GroupCode);
+            const groupSystemAccesses = await Group.getSystemAccesses(loginUser, dbTransaction, GroupCode, 1, Number.MAX_SAFE_INTEGER, {});
+            let parentGroupSystemAccesses = {
+                rows: [],
+                count: 0,
+            };
+            if (group.InheritParentSystemAccessYN === 'Y' && group.ParentGroupCode) {
+                parentGroupSystemAccesses = await Group.getSystemAccesses(loginUser, dbTransaction, group.ParentGroupCode, 1, Number.MAX_SAFE_INTEGER, undefined);
+            }
+            for (const groupObjectPrivilege of GroupObjectPrivileges) {
+                const systemPrivilege = await system_privilege_1.SystemPrivilege.init(dbTransaction, groupObjectPrivilege.SystemPrivilegeId);
+                const combinedSystemAccesses = {
+                    ...groupSystemAccesses.rows,
+                    ...parentGroupSystemAccesses.rows,
+                };
+                const systemAccess = combinedSystemAccesses.find((systemAccess) => systemAccess.SystemCode === systemPrivilege.SystemCode);
+                if (!systemAccess) {
+                    throw new general_1.ClassError('Group', 'GroupErrMsg13', 'Failed to assign privilege ' +
+                        groupObjectPrivilege.SystemPrivilegeId +
+                        ' due to non-existent system access.');
+                }
+                const groupObjectPrivilegeData = await Group._GroupObjectPrivilegeRepo.findOne({
+                    where: {
+                        GroupCode,
+                        SystemPrivilegeId: groupObjectPrivilege.SystemPrivilegeId,
+                        ObjectId: groupObjectPrivilege.ObjectId,
+                        ObjectType: groupObjectPrivilege.ObjectType,
+                    },
+                    transaction: dbTransaction,
+                });
+                if (groupObjectPrivilegeData) {
+                    continue;
+                }
+                else {
+                    await group_object_privilege_1.GroupObjectPrivilege.create(loginUser, dbTransaction, groupObjectPrivilege);
+                }
+            }
+            return 'Successfully added.';
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async getGroubObjectPrivileges(loginUser, dbTransaction, GroupCode, search) {
+        try {
+            const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+            const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_PRIVILEGE_VIEW');
+            if (!isPrivileged) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg11', 'You do not have the privilege to view group privileges');
+            }
+            await Group.init(dbTransaction, GroupCode);
+            const where = {
+                GroupCode,
+            };
+            const systemWhere = {};
+            if (search) {
+                Object.entries(search).forEach(([key, value]) => {
+                    if (key === 'SystemCode' || key === 'PrivilegeCode') {
+                        systemWhere[key] = {
+                            [sequelize_1.Op.substring]: value,
+                        };
+                    }
+                    else {
+                        where[key] = {
+                            [sequelize_1.Op.substring]: value,
+                        };
+                    }
+                });
+            }
+            const groupObjectPrivileges = await Group._GroupObjectPrivilegeRepo.findAll({
+                where,
+                include: [
+                    {
+                        model: system_privilege_entity_1.default,
+                        where: systemWhere,
+                    },
+                ],
+                transaction: dbTransaction,
+            });
+            const privileges = [];
+            for (const groupObjectPrivilege of groupObjectPrivileges) {
+                const systemPrivilege = await system_privilege_1.SystemPrivilege.init(dbTransaction);
+                systemPrivilege.setAttributes(groupObjectPrivilege.Privilege.get({ plain: true }));
+                privileges.push(systemPrivilege);
+            }
+            const uniquePrivileges = Array.from(new Set(privileges.map((a) => a.SystemPrivilegeId))).map((SystemPrivilegeId) => {
+                return privileges.find((a) => a.SystemPrivilegeId === SystemPrivilegeId);
+            });
+            return uniquePrivileges;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async assignGroupPrivileges(loginUser, dbTransaction, GroupCode, SystemPrivilegeIds) {
+        try {
+            const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+            const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_PRIVILEGE_ASSIGN');
+            if (!isPrivileged) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg06', 'You do not have the privilege to assign group privileges');
+            }
+            const group = await Group.init(dbTransaction, GroupCode);
+            const groupSystemAccesses = await Group.getSystemAccesses(loginUser, dbTransaction, GroupCode, 1, Number.MAX_SAFE_INTEGER, {});
+            let parentGroupSystemAccesses = {
+                rows: [],
+                count: 0,
+            };
+            if (group.InheritParentSystemAccessYN === 'Y' && group.ParentGroupCode) {
+                parentGroupSystemAccesses = await Group.getSystemAccesses(loginUser, dbTransaction, group.ParentGroupCode, 1, Number.MAX_SAFE_INTEGER, {});
+            }
+            for (const SystemPrivilegeId of SystemPrivilegeIds) {
+                const systemPrivilege = await system_privilege_1.SystemPrivilege.init(dbTransaction, SystemPrivilegeId);
+                const combinedSystemAccesses = [
+                    ...groupSystemAccesses.rows,
+                    ...parentGroupSystemAccesses.rows,
+                ];
+                const systemAccess = combinedSystemAccesses.find((systemAccess) => systemAccess.SystemCode === systemPrivilege.SystemCode);
+                if (!systemAccess) {
+                    throw new general_1.ClassError('Group', 'GroupErrMsg13', 'Failed to assign privilege ' +
+                        SystemPrivilegeId +
+                        ' due to non-existent system access.');
+                }
+                const groupPrivilege = await Group._GroupPrivilegeRepo.findOne({
+                    where: {
+                        GroupCode,
+                        SystemPrivilegeId,
+                    },
+                    include: [
+                        {
+                            model: system_privilege_entity_1.default,
+                        },
+                    ],
+                    transaction: dbTransaction,
+                });
+                if (groupPrivilege && groupPrivilege.Status === 'Active') {
+                    continue;
+                }
+                let entityValueBefore = {};
+                let entityValueAfter = {};
+                let action = activity_history_1.ActionEnum.CREATE;
+                let description = 'Create Group Privilege';
+                let entityId = null;
+                if (groupPrivilege && groupPrivilege.Status !== 'Active') {
+                    entityValueBefore = {
+                        GroupCode: groupPrivilege.GroupCode,
+                        SystemPrivilegeId: groupPrivilege.SystemPrivilegeId,
+                        Status: groupPrivilege.Status,
+                        CreatedById: groupPrivilege.CreatedById,
+                        CreatedAt: groupPrivilege.CreatedAt,
+                        UpdatedById: groupPrivilege.UpdatedById,
+                        UpdatedAt: groupPrivilege.UpdatedAt,
+                    };
+                    const updatedPayload = {
+                        Status: 'Active',
+                        UpdatedById: loginUser.UserId,
+                        UpdatedAt: new Date(),
+                    };
+                    const data = await Group._GroupPrivilegeRepo.findOne({
+                        where: {
+                            GroupCode,
+                            SystemPrivilegeId,
+                        },
+                        include: [
+                            {
+                                model: system_privilege_entity_1.default,
+                            },
+                        ],
+                        transaction: dbTransaction,
+                    });
+                    data.Status = 'Active';
+                    data.UpdatedById = updatedPayload.UpdatedById;
+                    data.UpdatedAt = updatedPayload.UpdatedAt;
+                    await data.save({ transaction: dbTransaction });
+                    entityValueAfter = {
+                        GroupCode: groupPrivilege.GroupCode,
+                        SystemPrivilegeId: groupPrivilege.SystemPrivilegeId,
+                        Status: updatedPayload.Status,
+                        CreatedById: groupPrivilege.CreatedById,
+                        CreatedAt: groupPrivilege.CreatedAt,
+                        UpdatedById: updatedPayload.UpdatedById,
+                        UpdatedAt: updatedPayload.UpdatedAt,
+                    };
+                    action = activity_history_1.ActionEnum.UPDATE;
+                    description = 'Update Group Privilege';
+                    entityId = groupPrivilege.GroupPrivilegeId;
+                }
+                else {
+                    const newGroupPrivilege = await group_privilege_1.GroupPrivilege.init(dbTransaction);
+                    newGroupPrivilege.setAttributes({
+                        GroupCode,
+                        SystemPrivilegeId,
+                        Status: 'Active',
+                        CreatedById: loginUser.UserId,
+                        CreatedAt: new Date(),
+                        UpdatedById: loginUser.UserId,
+                        UpdatedAt: new Date(),
+                    });
+                    entityValueAfter = {
+                        GroupCode: newGroupPrivilege.GroupCode,
+                        SystemPrivilegeId: newGroupPrivilege.SystemPrivilegeId,
+                        Status: newGroupPrivilege.Status,
+                        CreatedById: newGroupPrivilege.CreatedById,
+                        CreatedAt: newGroupPrivilege.CreatedAt,
+                        UpdatedById: newGroupPrivilege.UpdatedById,
+                        UpdatedAt: newGroupPrivilege.UpdatedAt,
+                    };
+                    const groupPrivilege = await Group._GroupPrivilegeRepo.create(entityValueAfter, {
+                        transaction: dbTransaction,
+                    });
+                    action = activity_history_1.ActionEnum.CREATE;
+                    description = 'Create Group Privilege';
+                    entityId = groupPrivilege.GroupPrivilegeId;
+                }
+                const activity = new activity_history_1.Activity();
+                activity.ActivityId = activity.createId();
+                activity.Action = action;
+                activity.Description = description;
+                activity.EntityType = 'GroupPrivilege';
+                activity.EntityId = entityId;
+                activity.EntityValueBefore = JSON.stringify(entityValueBefore);
+                activity.EntityValueAfter = JSON.stringify(entityValueAfter);
+                await activity.create(loginUser.ObjectId, dbTransaction);
+            }
+            return 'Successfully added.';
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async deleteGroupPrivilege(loginUser, dbTransaction, GroupCode, SystemPrivilegeIds) {
+        try {
+            const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+            const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_PRIVILEGE_DELETE');
+            if (!isPrivileged) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg06', 'You do not have the privilege to delete group privileges');
+            }
+            for (const SystemPrivilegeId of SystemPrivilegeIds) {
+                const groupPrivilege = await Group._GroupPrivilegeRepo.findOne({
+                    where: {
+                        GroupCode,
+                        SystemPrivilegeId,
+                    },
+                    include: [
+                        {
+                            model: system_privilege_entity_1.default,
+                        },
+                    ],
+                    transaction: dbTransaction,
+                });
+                if (!groupPrivilege) {
+                    throw new general_1.ClassError('Group', 'GroupErrMsg14', 'GroupPrivilege not found.');
+                }
+                const entityValueBefore = {
+                    GroupCode: groupPrivilege.GroupCode,
+                    SystemPrivilegeId: groupPrivilege.SystemPrivilegeId,
+                    Status: groupPrivilege.Status,
+                    CreatedById: groupPrivilege.CreatedById,
+                    CreatedAt: groupPrivilege.CreatedAt,
+                    UpdatedById: groupPrivilege.UpdatedById,
+                    UpdatedAt: groupPrivilege.UpdatedAt,
+                };
+                await Group._GroupPrivilegeRepo.delete(GroupCode, SystemPrivilegeId, dbTransaction);
+                const activity = new activity_history_1.Activity();
+                activity.ActivityId = activity.createId();
+                activity.Action = activity_history_1.ActionEnum.DELETE;
+                activity.Description = 'DELETE Group Privilege';
+                activity.EntityType = 'GroupPrivilege';
+                activity.EntityId = groupPrivilege.GroupPrivilegeId.toString();
+                activity.EntityValueBefore = JSON.stringify(entityValueBefore);
+                activity.EntityValueAfter = JSON.stringify({});
+                await activity.create(loginUser.ObjectId, dbTransaction);
+            }
+            return 'Successfully deleted.';
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static async getHierarchy(loginUser, dbTransaction, Status, Type, ParentGroupCode) {
+        const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+        const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_VIEW');
+        if (!isPrivileged) {
+            throw new general_1.ClassError('Group', 'GroupErrMsg04', 'User is not privileged to view group');
+        }
+        const queryObj = {};
+        let options = {
+            transaction: dbTransaction,
+        };
+        const search = {
+            Status: Status ? Status : 'Active',
+            Type: Type,
+            ParentGroupCode: ParentGroupCode,
+        };
+        if (search) {
+            Object.entries(search).forEach(([key, value]) => {
+                if (value) {
+                    queryObj[key] = {
+                        [sequelize_1.Op.substring]: value,
+                    };
+                }
+            });
+            options = {
+                ...options,
+                where: queryObj,
+            };
+            const result = await Group._Repo.findAll(options);
+            const data = result.map((group) => new Group(group.get({ plain: true })));
+            const generateTree = async (groups) => {
+                const data = groups.map((group) => {
+                    return {
+                        GroupCode: group.ObjectId,
+                        Name: group.Name,
+                        Description: group.Description,
+                        Type: group.Type,
+                        ParentGroupCode: group.ParentGroupCode,
+                        InheritParentPrivilegeYN: group.InheritParentPrivilegeYN,
+                        InheritParentSystemAccessYN: group.InheritParentSystemAccessYN,
+                        Path: group._Path,
+                        Status: group.Status,
+                        CreatedById: group._CreatedById,
+                        CreatedAt: group._CreatedAt,
+                        UpdatedById: group._UpdatedById,
+                        UpdatedAt: group._UpdatedAt,
+                        childrens: [],
+                    };
+                });
+                const groupMap = {};
+                data.forEach((group) => {
+                    group.childrens = [];
+                    groupMap[group.GroupCode] = group;
+                });
+                const tree = [];
+                data.forEach((group) => {
+                    if (group.ParentGroupCode) {
+                        const parent = groupMap[group.ParentGroupCode];
+                        if (parent) {
+                            parent.childrens.push(group);
+                        }
+                    }
+                    else {
+                        tree.push(group);
+                    }
+                });
+                return tree;
+            };
+            const tree = await generateTree(data);
+            return tree;
+        }
+    }
+    static async getGroupsWithReportingUser(loginUser, dbTransaction, whereOptions) {
+        try {
+            const systemCode = config_1.ApplicationConfig.getComponentConfigValue('system-code');
+            const isPrivileged = await loginUser.checkPrivileges(systemCode, 'GROUP_VIEW');
+            if (!isPrivileged) {
+                throw new general_1.ClassError('Group', 'GroupErrMsg04', 'User is not privileged to view group');
+            }
+            const options = {
+                where: whereOptions,
+                include: [
+                    {
+                        model: group_reporting_user_entity_1.default,
+                        where: { Status: 'Active' },
+                        include: [
+                            {
+                                model: user_entity_1.default,
+                                as: 'User',
+                                attributes: ['UserId', 'FullName'],
+                            },
+                        ],
+                    },
+                ],
+                transaction: dbTransaction,
+            };
+            const groups = await Group._Repo.findAll(options);
+            return groups;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+exports.Group = Group;
+Group._Repo = new group_repository_1.GroupRepository();
+Group._GroupSystemAccessRepo = new group_system_access_repository_1.GroupSystemAccessRepository();
+Group._GroupPrivilegeRepo = new group_privilege_repository_1.GroupPrivilegeRepository();
+Group._GroupObjectPrivilegeRepo = new group_object_privilege_repository_1.GroupObjectPrivilegeRepository();
+//# sourceMappingURL=group.js.map