@tomei/sso 0.60.4 → 0.61.0

package/dist/components/group/group.js

@@ -1,1337 +0,0 @@
-"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