rez_core 5.0.34 → 5.0.35

package/src/module/module/repository/module-access.repository.ts

@@ -1,344 +1,344 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { In, Not, Repository, IsNull, DataSource } from 'typeorm';
-import { Role } from 'src/module/user/entity/role.entity';
-import { ModuleAccess } from '../entity/module-access.entity';
-import { ModuleAction } from '../entity/module-action.entity';
-import { ModuleData } from '../entity/module.entity';
-
-@Injectable()
-export class ModuleAccessRepository {
-  constructor(
-    @InjectRepository(Role)
-    private readonly roleRepo: Repository<Role>,
-
-    @InjectRepository(ModuleData)
-    private readonly moduleRepo: Repository<ModuleData>,
-
-    @InjectRepository(ModuleAccess)
-    private readonly moduleAccessRepo: Repository<ModuleAccess>,
-
-    @InjectRepository(ModuleAction)
-    private readonly moduleActionRepo: Repository<ModuleAction>,
-
-    private readonly dataSource: DataSource,
-  ) {}
-
-  async getRoles({
-    appcode,
-    level_type,
-    level_id,
-  }: {
-    appcode: string;
-    level_type?: string;
-    level_id?: number;
-  }) {
-    const query = this.dataSource
-      .createQueryBuilder()
-      .select('*')
-      .from('sso_role', 'role')
-      .where('role.appcode = :appcode', { appcode })
-      .andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
-
-    if (level_type) {
-      query.andWhere('role.level_type = :level_type', { level_type });
-    }
-
-    if (level_id !== undefined) {
-      query.andWhere('role.level_id = :level_id', {
-        level_id: String(level_id),
-      });
-    }
-
-    const roles = await query.getRawMany(); // use getRawMany since you're selecting from a raw table
-
-    return roles.map((role) => ({
-      label: role.name,
-      value: role.id,
-    }));
-  }
-
-  async getModules({
-    appcode,
-    loggedInUser,
-  }: {
-    appcode: string;
-    loggedInUser: any;
-  }) {
-    let modules: any[];
-    if (loggedInUser.level_type == 'SCH') {
-      modules = await this.moduleRepo.find({
-        where: { module_level: 'MAINMOD', appcode, level_type: 'SCH' },
-      });
-    } else {
-      modules = await this.moduleRepo.find({
-        where: { module_level: 'MAINMOD', appcode },
-      });
-    }
-
-    return modules
-      .map((mod) => ({
-        label: mod.name,
-        value: mod.id,
-        group: mod.level_type,
-      }))
-      .sort((a, b) => a.group.localeCompare(b.group));
-  }
-
-  async getAccessListing(
-    roleIds: (number | string)[],
-    appcode: string,
-    levelType: string,
-    levelId?: number, // add levelId as input so we can fetch roles based on it
-  ) {
-    let roles;
-
-    if (roleIds.length === 1 && roleIds[0] === -1) {
-      // Internally call getRoles
-      const fetchedRoles = await this.getRoles({
-        appcode,
-        level_type: levelType,
-        level_id: levelId,
-      });
-
-      const fetchedRoleIds = fetchedRoles.map((r) => r.value);
-      roles = await this.roleRepo.find({
-        where: {
-          id: In(fetchedRoleIds),
-          appcode,
-        },
-      });
-    } else {
-      roles = await this.roleRepo.find({
-        where: {
-          id: In(roleIds.map((id) => Number(id))),
-          appcode,
-        },
-      });
-    }
-
-    if (!roles.length) return [];
-
-    const roleCodes = roles.map((role) => role.code);
-
-    const moduleAccesses = await this.moduleAccessRepo.find({
-      where: {
-        role_code: In(roleCodes),
-        appcode,
-      },
-    });
-
-    return roles.map((role) => ({
-      role_code: role.code,
-      name: role.name,
-      permission: moduleAccesses
-        .filter((access) => access.role_code === role.code)
-        .map((access) => ({
-          action: access.action_type,
-          access: access.access_flag,
-          code: access.module_code,
-          level_type: access.level_type,
-          appcode: access.appcode,
-        })),
-    }));
-  }
-
-  async getAllModulesByLevel(mainModIds: string[], appcode: string, levelType) {
-    const mainModules =
-      mainModIds.length === 1 && mainModIds[0] === '-1'
-        ? await this.moduleRepo.find({
-            where: { module_level: 'MAINMOD', appcode },
-          })
-        : await this.moduleRepo.find({
-            where: { id: In(mainModIds), module_level: 'MAINMOD', appcode },
-          });
-
-    if (!mainModules.length) return {};
-
-    const wbsCodes = mainModules.map((mod) => mod.wbs_code);
-
-    let allModules = await this.moduleRepo
-      .createQueryBuilder('module')
-      .where(
-        wbsCodes
-          .map((code) => `module.wbs_code LIKE :code${code}`)
-          .join(' OR '),
-        Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
-      )
-      .andWhere('module.appcode = :appcode', { appcode })
-      .andWhere('module.module_code != :excludedCode', {
-        excludedCode: 'all_organization_adm_org',
-      })
-      .getMany();
-
-    allModules = allModules.filter(
-      (mod) => mod.module_code != 'all_organization_adm_org',
-    );
-
-    const moduleCodes = allModules.map((m) => m.module_code);
-
-    const allActions = await this.moduleActionRepo.find({
-      where: { module_code: In(moduleCodes) },
-    });
-
-    // Map actions by module_code with VIEW action first
-    const actionMap = allActions.reduce(
-      (acc, action) => {
-        if (!acc[action.module_code]) acc[action.module_code] = [];
-
-        const actionItem = {
-          action: action.action_type,
-          name: action.action_name,
-        };
-
-        if (action.action_type === 'VIEW') {
-          acc[action.module_code].unshift(actionItem); // ➕ Add VIEW at start
-        } else {
-          acc[action.module_code].push(actionItem); // ➕ Add others at end
-        }
-
-        return acc;
-      },
-      {} as Record<string, { action: string; name: string }[]>,
-    );
-
-    const levelsToReturn = levelType === 'ORG' ? ['ORG', 'SCH'] : ['SCH'];
-
-    const groupedByLevel: Record<string, any[]> = {};
-
-    for (const lvl of levelsToReturn) {
-      const filteredModules = allModules.filter((m) => m.level_type === lvl);
-
-      const buildHierarchy = (parentWbs: string): any[] =>
-        filteredModules
-          .filter(
-            (mod) =>
-              mod.wbs_code.startsWith(`${parentWbs}.`) &&
-              mod.wbs_code.split('.').length ===
-                parentWbs.split('.').length + 1,
-          )
-          .map((mod) => ({
-            name: mod.name,
-            code: mod.module_code,
-            permission: actionMap[mod.module_code] || [],
-            submod: buildHierarchy(mod.wbs_code),
-          }));
-
-      const levelModules = mainModules
-        .filter((mod) => mod.level_type === lvl)
-        .map((mod) => ({
-          name: mod.name,
-          code: mod.module_code,
-          permission: actionMap[mod.module_code] || [],
-          submod: buildHierarchy(mod.wbs_code),
-        }));
-
-      if (levelModules.length) {
-        groupedByLevel[lvl] = levelModules;
-      }
-    }
-    return groupedByLevel;
-  }
-
-  async updateModuleAccess(
-    accessList: {
-      role_code: string;
-      module_code: string;
-      action_type: string;
-      access_flag: number;
-      appcode: string;
-      level_type: string;
-    }[],
-  ): Promise<boolean> {
-    try {
-      for (const access of accessList) {
-        const existing = await this.moduleAccessRepo.findOne({
-          where: {
-            role_code: access.role_code,
-            module_code: access.module_code,
-            action_type: access.action_type,
-            appcode: access.appcode,
-            level_type: access.level_type,
-          },
-        });
-
-        if (existing) {
-          existing.access_flag = access.access_flag;
-          await this.moduleAccessRepo.save(existing);
-        } else {
-          await this.moduleAccessRepo.save(
-            await this.moduleAccessRepo.create(access),
-          );
-        }
-      }
-      return true;
-    } catch (error) {
-      console.error('Error updating module access:', error);
-      return false;
-    }
-  }
-
-  async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
-    const module = await this.moduleRepo.findOne({
-      where: { module_code: moduleCode },
-    });
-
-    if (!module) throw new BadRequestException('Module not found');
-
-    const roles = await this.roleRepo.find({ where: { id: In(roleIds) } });
-    const roleCodes = roles.map((role) => role.code);
-
-    const actions = await this.moduleAccessRepo.find({
-      where: {
-        module_code: moduleCode,
-        role_code: In(roleCodes),
-        access_flag: 1,
-      },
-    });
-
-    const uniqueActions = [...new Set(actions.map((a) => a.action_type))];
-
-    return {
-      entity_type: module.entity_type,
-      title: module.title,
-      ui_config: module.ui_config || {},
-      action: uniqueActions,
-    };
-  }
-  async getModuleAccessByRoles(roleIds: number[], appcode: string) {
-    // Step 1: Get role codes from sso_role
-    const roles = await this.roleRepo.find({
-      where: {
-        id: In(roleIds),
-        appcode,
-      },
-      select: ['id', 'code'],
-    });
-
-    const roleCodes = roles.map((r) => r.code);
-    if (!roleCodes.length) return [];
-
-    // Step 2: Fetch full access data
-    const accessRecords = await this.moduleAccessRepo
-      .createQueryBuilder('access')
-      .select([
-        'access.module_code AS module_code',
-        'access.action_type AS action_type',
-        'access.access_flag AS access_flag',
-        'access.level_type AS level_type',
-        'access.appcode AS appcode',
-      ])
-      .where('access.role_code IN (:...roleCodes)', { roleCodes })
-      .andWhere('access.appcode = :appcode', { appcode })
-      .getRawMany();
-
-    // Step 3: Format output
-    return accessRecords.map((record) => ({
-      action: record.action_type,
-      access: record.access_flag,
-      code: record.module_code,
-      level_type: record.level_type,
-      appcode: record.appcode,
-    }));
-  }
-}
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { In, Not, Repository, IsNull, DataSource } from 'typeorm';
+import { Role } from 'src/module/user/entity/role.entity';
+import { ModuleAccess } from '../entity/module-access.entity';
+import { ModuleAction } from '../entity/module-action.entity';
+import { ModuleData } from '../entity/module.entity';
+
+@Injectable()
+export class ModuleAccessRepository {
+  constructor(
+    @InjectRepository(Role)
+    private readonly roleRepo: Repository<Role>,
+
+    @InjectRepository(ModuleData)
+    private readonly moduleRepo: Repository<ModuleData>,
+
+    @InjectRepository(ModuleAccess)
+    private readonly moduleAccessRepo: Repository<ModuleAccess>,
+
+    @InjectRepository(ModuleAction)
+    private readonly moduleActionRepo: Repository<ModuleAction>,
+
+    private readonly dataSource: DataSource,
+  ) {}
+
+  async getRoles({
+    appcode,
+    level_type,
+    level_id,
+  }: {
+    appcode: string;
+    level_type?: string;
+    level_id?: number;
+  }) {
+    const query = this.dataSource
+      .createQueryBuilder()
+      .select('*')
+      .from('sso_role', 'role')
+      .where('role.appcode = :appcode', { appcode })
+      .andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
+
+    if (level_type) {
+      query.andWhere('role.level_type = :level_type', { level_type });
+    }
+
+    if (level_id !== undefined) {
+      query.andWhere('role.level_id = :level_id', {
+        level_id: String(level_id),
+      });
+    }
+
+    const roles = await query.getRawMany(); // use getRawMany since you're selecting from a raw table
+
+    return roles.map((role) => ({
+      label: role.name,
+      value: role.id,
+    }));
+  }
+
+  async getModules({
+    appcode,
+    loggedInUser,
+  }: {
+    appcode: string;
+    loggedInUser: any;
+  }) {
+    let modules: any[];
+    if (loggedInUser.level_type == 'SCH') {
+      modules = await this.moduleRepo.find({
+        where: { module_level: 'MAINMOD', appcode, level_type: 'SCH' },
+      });
+    } else {
+      modules = await this.moduleRepo.find({
+        where: { module_level: 'MAINMOD', appcode },
+      });
+    }
+
+    return modules
+      .map((mod) => ({
+        label: mod.name,
+        value: mod.id,
+        group: mod.level_type,
+      }))
+      .sort((a, b) => a.group.localeCompare(b.group));
+  }
+
+  async getAccessListing(
+    roleIds: (number | string)[],
+    appcode: string,
+    levelType: string,
+    levelId?: number, // add levelId as input so we can fetch roles based on it
+  ) {
+    let roles;
+
+    if (roleIds.length === 1 && roleIds[0] === -1) {
+      // Internally call getRoles
+      const fetchedRoles = await this.getRoles({
+        appcode,
+        level_type: levelType,
+        level_id: levelId,
+      });
+
+      const fetchedRoleIds = fetchedRoles.map((r) => r.value);
+      roles = await this.roleRepo.find({
+        where: {
+          id: In(fetchedRoleIds),
+          appcode,
+        },
+      });
+    } else {
+      roles = await this.roleRepo.find({
+        where: {
+          id: In(roleIds.map((id) => Number(id))),
+          appcode,
+        },
+      });
+    }
+
+    if (!roles.length) return [];
+
+    const roleCodes = roles.map((role) => role.code);
+
+    const moduleAccesses = await this.moduleAccessRepo.find({
+      where: {
+        role_code: In(roleCodes),
+        appcode,
+      },
+    });
+
+    return roles.map((role) => ({
+      role_code: role.code,
+      name: role.name,
+      permission: moduleAccesses
+        .filter((access) => access.role_code === role.code)
+        .map((access) => ({
+          action: access.action_type,
+          access: access.access_flag,
+          code: access.module_code,
+          level_type: access.level_type,
+          appcode: access.appcode,
+        })),
+    }));
+  }
+
+  async getAllModulesByLevel(mainModIds: string[], appcode: string, levelType) {
+    const mainModules =
+      mainModIds.length === 1 && mainModIds[0] === '-1'
+        ? await this.moduleRepo.find({
+            where: { module_level: 'MAINMOD', appcode },
+          })
+        : await this.moduleRepo.find({
+            where: { id: In(mainModIds), module_level: 'MAINMOD', appcode },
+          });
+
+    if (!mainModules.length) return {};
+
+    const wbsCodes = mainModules.map((mod) => mod.wbs_code);
+
+    let allModules = await this.moduleRepo
+      .createQueryBuilder('module')
+      .where(
+        wbsCodes
+          .map((code) => `module.wbs_code LIKE :code${code}`)
+          .join(' OR '),
+        Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
+      )
+      .andWhere('module.appcode = :appcode', { appcode })
+      .andWhere('module.module_code != :excludedCode', {
+        excludedCode: 'all_organization_adm_org',
+      })
+      .getMany();
+
+    allModules = allModules.filter(
+      (mod) => mod.module_code != 'all_organization_adm_org',
+    );
+
+    const moduleCodes = allModules.map((m) => m.module_code);
+
+    const allActions = await this.moduleActionRepo.find({
+      where: { module_code: In(moduleCodes) },
+    });
+
+    // Map actions by module_code with VIEW action first
+    const actionMap = allActions.reduce(
+      (acc, action) => {
+        if (!acc[action.module_code]) acc[action.module_code] = [];
+
+        const actionItem = {
+          action: action.action_type,
+          name: action.action_name,
+        };
+
+        if (action.action_type === 'VIEW') {
+          acc[action.module_code].unshift(actionItem); // ➕ Add VIEW at start
+        } else {
+          acc[action.module_code].push(actionItem); // ➕ Add others at end
+        }
+
+        return acc;
+      },
+      {} as Record<string, { action: string; name: string }[]>,
+    );
+
+    const levelsToReturn = levelType === 'ORG' ? ['ORG', 'SCH'] : ['SCH'];
+
+    const groupedByLevel: Record<string, any[]> = {};
+
+    for (const lvl of levelsToReturn) {
+      const filteredModules = allModules.filter((m) => m.level_type === lvl);
+
+      const buildHierarchy = (parentWbs: string): any[] =>
+        filteredModules
+          .filter(
+            (mod) =>
+              mod.wbs_code.startsWith(`${parentWbs}.`) &&
+              mod.wbs_code.split('.').length ===
+                parentWbs.split('.').length + 1,
+          )
+          .map((mod) => ({
+            name: mod.name,
+            code: mod.module_code,
+            permission: actionMap[mod.module_code] || [],
+            submod: buildHierarchy(mod.wbs_code),
+          }));
+
+      const levelModules = mainModules
+        .filter((mod) => mod.level_type === lvl)
+        .map((mod) => ({
+          name: mod.name,
+          code: mod.module_code,
+          permission: actionMap[mod.module_code] || [],
+          submod: buildHierarchy(mod.wbs_code),
+        }));
+
+      if (levelModules.length) {
+        groupedByLevel[lvl] = levelModules;
+      }
+    }
+    return groupedByLevel;
+  }
+
+  async updateModuleAccess(
+    accessList: {
+      role_code: string;
+      module_code: string;
+      action_type: string;
+      access_flag: number;
+      appcode: string;
+      level_type: string;
+    }[],
+  ): Promise<boolean> {
+    try {
+      for (const access of accessList) {
+        const existing = await this.moduleAccessRepo.findOne({
+          where: {
+            role_code: access.role_code,
+            module_code: access.module_code,
+            action_type: access.action_type,
+            appcode: access.appcode,
+            level_type: access.level_type,
+          },
+        });
+
+        if (existing) {
+          existing.access_flag = access.access_flag;
+          await this.moduleAccessRepo.save(existing);
+        } else {
+          await this.moduleAccessRepo.save(
+            await this.moduleAccessRepo.create(access),
+          );
+        }
+      }
+      return true;
+    } catch (error) {
+      console.error('Error updating module access:', error);
+      return false;
+    }
+  }
+
+  async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
+    const module = await this.moduleRepo.findOne({
+      where: { module_code: moduleCode },
+    });
+
+    if (!module) throw new BadRequestException('Module not found');
+
+    const roles = await this.roleRepo.find({ where: { id: In(roleIds) } });
+    const roleCodes = roles.map((role) => role.code);
+
+    const actions = await this.moduleAccessRepo.find({
+      where: {
+        module_code: moduleCode,
+        role_code: In(roleCodes),
+        access_flag: 1,
+      },
+    });
+
+    const uniqueActions = [...new Set(actions.map((a) => a.action_type))];
+
+    return {
+      entity_type: module.entity_type,
+      title: module.title,
+      ui_config: module.ui_config || {},
+      action: uniqueActions,
+    };
+  }
+  async getModuleAccessByRoles(roleIds: number[], appcode: string) {
+    // Step 1: Get role codes from sso_role
+    const roles = await this.roleRepo.find({
+      where: {
+        id: In(roleIds),
+        appcode,
+      },
+      select: ['id', 'code'],
+    });
+
+    const roleCodes = roles.map((r) => r.code);
+    if (!roleCodes.length) return [];
+
+    // Step 2: Fetch full access data
+    const accessRecords = await this.moduleAccessRepo
+      .createQueryBuilder('access')
+      .select([
+        'access.module_code AS module_code',
+        'access.action_type AS action_type',
+        'access.access_flag AS access_flag',
+        'access.level_type AS level_type',
+        'access.appcode AS appcode',
+      ])
+      .where('access.role_code IN (:...roleCodes)', { roleCodes })
+      .andWhere('access.appcode = :appcode', { appcode })
+      .getRawMany();
+
+    // Step 3: Format output
+    return accessRecords.map((record) => ({
+      action: record.action_type,
+      access: record.access_flag,
+      code: record.module_code,
+      level_type: record.level_type,
+      appcode: record.appcode,
+    }));
+  }
+}