rez_core 6.5.46 → 6.5.50

package/src/module/module/repository/menu.repository.ts

@@ -17,7 +17,7 @@ export class MenuRepository extends Repository<MenuData> {
     super(MenuData, dataSource.createEntityManager());
   }
 
-  async getUserRoles(userId: number, app_id: number): Promise<number[]> {
+  async getUserRoles(userId: number, appcode: string): Promise<number[]> {
     const userRoleMappingRepo =
       this.reflectionHelper.getRepoService('UserRoleMapping');
 
@@ -26,7 +26,7 @@ export class MenuRepository extends Repository<MenuData> {
       .innerJoin('sso_role', 'role', 'role.id = urm.role_id')
       .select('urm.role_id', 'role_id')
       .where('urm.user_id = :userId', { userId })
-      .andWhere('role.app_id = :app_id', { app_id })
+      .andWhere('role.appcode = :appcode', { appcode })
       .getRawMany();
 
     return roles.map((r) => r.role_id);
@@ -34,65 +34,61 @@ export class MenuRepository extends Repository<MenuData> {
 
   async getAccessibleModules(
     roleIds: number[],
-    appcode: string,
-  ): Promise<number[]> {
+    appCode: string,
+  ): Promise<string[]> {
+    const roleRepo = this.reflectionHelper.getRepoService('Role');
+
+    const roleCodes = await roleRepo
+      .createQueryBuilder('role')
+      .select('role.code', 'code')
+      .where('role.id IN (:...roleIds)', { roleIds })
+      .getRawMany();
 
-    const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
-    const appMaster = await appMasterRepo.findOne({
-      where: {
-        code: appcode
-      }
-    });
+    const codes = roleCodes.map((r) => r.code);
+
+    if (codes.length === 0) return [];
 
     const modules = await this.moduleAccessRepo
       .createQueryBuilder('moduleAccess')
-      .select('moduleAccess.module_id')
-      .where('moduleAccess.role_id IN (:...roleIds)', { roleIds })
+      .select('moduleAccess.module_code')
+      .where('moduleAccess.role_code IN (:...codes)', { codes })
       .andWhere('moduleAccess.access_flag > 0')
-      .andWhere('moduleAccess.app_id = :app_id', { app_id: appMaster.id })
+      .andWhere('LOWER(moduleAccess.appcode) = LOWER(:appCode)', { appCode })
       .getMany();
 
-    return Array.from(new Set(modules.map((module) => module.module_id)));
+    return Array.from(new Set(modules.map((module) => module.module_code)));
   }
 
   /**
    * ✅ FIXED: Use this.createQueryBuilder() instead of this.menuData.createQueryBuilder()
    */
   async getMenuItems(
-    modules: number[],
+    moduleCodes: string[],
     appcode: string,
     levelType: string,
   ) {
-    const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
-
-    const appMaster = await appMasterRepo.findOne({
-      where: {
-        code: appcode
-      }
-    })
-
     return await this.menuData
       .createQueryBuilder('menu')
       .leftJoin(
         'sso_module',
         'module',
         `
-          menu.module_id = module.id
-          AND menu.app_id = module.app_id
+          menu.module_code = module.module_code
+          AND LOWER(menu.appcode) = LOWER(module.appcode)
           AND menu.level_type = module.level_type
         `,
       )
-      .where('menu.module_id IN (:...modules)', { modules: modules })
-      .andWhere('menu.app_id = :app_id', { app_id: appMaster.id })
+      .where('menu.module_code IN (:...moduleCodes)', { moduleCodes })
+      .andWhere('LOWER(menu.appcode) = LOWER(:appcode)', { appcode })
       .andWhere('menu.level_type = :levelType', { levelType })
       .andWhere('menu.ui_visible = 1')
       .select([
         'menu.*',
-        'module.module_code AS module_code',
         'module.component_name AS component',
         'module.title AS title',
         'module.entity_type AS entity_type',
-        'module.type AS type'
+        'module.type AS type',
+        'module.ui_config AS ui_config',
       ])
       .getRawMany();
   }
@@ -103,14 +99,6 @@ export class MenuRepository extends Repository<MenuData> {
     levelType: string,
     levelId: number,
   ): Promise<number[]> {
-    const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
-
-    const appMaster = await appMasterRepo.findOne({
-      where: {
-        code: appcode
-      }
-    })
-
     const repo = this.reflectionHelper.getRepoService('UserRoleMapping');
 
     if (userId) {
@@ -126,9 +114,7 @@ export class MenuRepository extends Repository<MenuData> {
       const getUserUrm = await repo.findOne({
         where: {
           user_id: userId,
-          app: {
-            code: appcode
-          },
+          appcode: appcode,
         },
       });
 
@@ -149,7 +135,7 @@ export class MenuRepository extends Repository<MenuData> {
       .where('urm.user_id = :userId', { userId: userId })
       .andWhere('urm.level_type = :levelType', { levelType })
       .andWhere('urm.level_id = :levelId', { levelId: levelId })
-      .andWhere('role.app_id = :app_id', { app_id: appMaster.id })
+      .andWhere('role.appcode = :appcode', { appcode })
       .getRawMany();
 
     if (roles.length) return roles.map((r) => r.urm_role_id);
@@ -174,7 +160,7 @@ export class MenuRepository extends Repository<MenuData> {
           .where('urm.user_id = :userId', { userId })
           .andWhere('urm.level_type = :levelType', { levelType: 'BRN' })
           .andWhere('urm.level_id = :levelId', { levelId: brandId })
-          .andWhere('role.app_id = :app_id', { app_id: appMaster.id })
+          .andWhere('role.appcode = :appcode', { appcode })
           .getRawMany();
 
         if (roles.length) return roles.map((r) => r.urm_role_id);
@@ -188,7 +174,7 @@ export class MenuRepository extends Repository<MenuData> {
           .where('urm.user_id = :userId', { userId })
           .andWhere('urm.level_type = :levelType', { levelType: 'ORG' })
           .andWhere('urm.level_id = :levelId', { levelId: orgId })
-          .andWhere('role.app_id = :app_id', { app_id: appMaster.id })
+          .andWhere('role.appcode = :appcode', { appcode })
           .getRawMany();
 
         if (roles.length) return roles.map((r) => r.urm_role_id);

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

@@ -1,55 +1,56 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { In, IsNull, Not, Or, Repository } from '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';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @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 reflectionHelper: ReflectionHelper,
-  ) {
-  }
+
+    private readonly dataSource: DataSource,
+  ) {}
 
   async getRoles({
-                   appcode,
-                   level_type,
-                   level_id,
-                 }: {
+    appcode,
+    level_type,
+    level_id,
+  }: {
     appcode: string;
     level_type?: string;
     level_id?: number;
   }) {
-    const where: any = {
-      app: {
-        code: appcode,
-      },
-      is_factory: Or(IsNull(), Not(1)), // 👈 include NULL and exclude factory roles
-    };
+    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) {
-      where.level_type = level_type;
+      query.andWhere('role.level_type = :level_type', { level_type });
     }
 
     if (level_id !== undefined) {
-      where.level_id = String(level_id);
+      query.andWhere('role.level_id = :level_id', {
+        level_id: String(level_id),
+      });
     }
 
-    const roles = await this.roleRepo.find({
-      where,
-      select: ['id', 'name'], // keep returned data same as your mapping
-    });
+    const roles = await query.getRawMany(); // use getRawMany since you're selecting from a raw table
 
     return roles.map((role) => ({
       label: role.name,
@@ -58,30 +59,20 @@ export class ModuleAccessRepository {
   }
 
   async getModules({
-                     appcode,
-                     loggedInUser,
-                   }: {
+    appcode,
+    loggedInUser,
+  }: {
     appcode: string;
     loggedInUser: any;
   }) {
     let modules: any[];
     if (loggedInUser.level_type == 'SCH') {
       modules = await this.moduleRepo.find({
-        where: {
-          module_level: 'MAINMOD',
-          app: {
-            code: appcode,
-          },
-          level_type: 'SCH',
-        },
+        where: { module_level: 'MAINMOD', appcode, level_type: 'SCH' },
       });
     } else {
       modules = await this.moduleRepo.find({
-        where: {
-          module_level: 'MAINMOD', app: {
-            code: appcode,
-          },
-        },
+        where: { module_level: 'MAINMOD', appcode },
       });
     }
 
@@ -114,76 +105,53 @@ export class ModuleAccessRepository {
       roles = await this.roleRepo.find({
         where: {
           id: In(fetchedRoleIds),
-          app: {
-            code: appcode,
-          },
+          appcode,
         },
       });
     } else {
       roles = await this.roleRepo.find({
         where: {
           id: In(roleIds.map((id) => Number(id))),
-          app: {
-            code: appcode,
-          },
+          appcode,
         },
       });
     }
 
     if (!roles.length) return [];
 
+    const roleCodes = roles.map((role) => role.code);
+
     const moduleAccesses = await this.moduleAccessRepo.find({
       where: {
-        role_id: In(roles.map((role) => role.id)),
-        app: {
-          code: appcode,
-        },
-        level_type: levelType,
-      },
-      relations: {
-        app: true,
-        module: true,
+        role_code: In(roleCodes),
+        appcode,
       },
     });
 
     return roles.map((role) => ({
-      role_id: role.id,
+      role_code: role.code,
       name: role.name,
       permission: moduleAccesses
-        .filter((access) => access.role_id === role.id)
+        .filter((access) => access.role_code === role.code)
         .map((access) => ({
           action: access.action_type,
           access: access.access_flag,
-          module_id: access.module_id,
+          code: access.module_code,
           level_type: access.level_type,
-          app_id: access.app_id,
-          code: access.module.module_code,
-          appcode: access.app.code,
+          appcode: access.appcode,
         })),
     }));
   }
 
   async getAllModulesByLevel(mainModIds: string[], appcode: string, levelType) {
-    const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
-
-    const appMaster = await appMasterRepo.find({
-      where: {
-        code: appcode,
-      },
-    });
-
-    if (!appMaster) {
-      return {};
-    }
-
     const mainModules =
       mainModIds.length === 1 && mainModIds[0] === '-1'
         ? await this.moduleRepo.find({
-          where: { module_level: 'MAINMOD', app_id: appMaster[0].id },
-        })
+            where: { module_level: 'MAINMOD', appcode },
+          })
         : await this.moduleRepo.find({
-          where: { id: In(mainModIds), module_level: 'MAINMOD', app: { code: appcode } },
-        });
+            where: { id: In(mainModIds), module_level: 'MAINMOD', appcode },
+          });
 
     if (!mainModules.length) return {};
 
@@ -197,7 +165,7 @@ export class ModuleAccessRepository {
           .join(' OR '),
         Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
       )
-      .andWhere('module.app_id = :app_id', { app_id: appMaster[0].id })
+      .andWhere('module.appcode = :appcode', { appcode })
       .andWhere('module.module_code != :excludedCode', {
         excludedCode: 'all_organization_adm_org',
       })
@@ -207,26 +175,26 @@ export class ModuleAccessRepository {
       (mod) => mod.module_code != 'all_organization_adm_org',
     );
 
-    const modules = allModules.map((m) => m.id);
+    const moduleCodes = allModules.map((m) => m.module_code);
 
     const allActions = await this.moduleActionRepo.find({
-      where: { module_id: In(modules) },
+      where: { module_code: In(moduleCodes) },
     });
 
     // Map actions by module_code with VIEW action first
     const actionMap = allActions.reduce(
       (acc, action) => {
-        if (!acc[action.module_id]) acc[action.module_id] = [];
+        if (!acc[action.module_code]) acc[action.module_code] = [];
 
         const actionItem = {
-          action: action.action_code,
+          action: action.action_type,
           name: action.action_name,
         };
 
-        if (action.action_code === 'VIEW') {
-          acc[action.module_id].unshift(actionItem); // ➕ Add VIEW at start
+        if (action.action_type === 'VIEW') {
+          acc[action.module_code].unshift(actionItem); // ➕ Add VIEW at start
         } else {
-          acc[action.module_id].push(actionItem); // ➕ Add others at end
+          acc[action.module_code].push(actionItem); // ➕ Add others at end
         }
 
         return acc;
@@ -247,11 +215,10 @@ export class ModuleAccessRepository {
             (mod) =>
               mod.wbs_code.startsWith(`${parentWbs}.`) &&
               mod.wbs_code.split('.').length ===
-              parentWbs.split('.').length + 1,
+                parentWbs.split('.').length + 1,
           )
           .map((mod) => ({
             name: mod.name,
-            module_id: mod.id,
             code: mod.module_code,
             permission: actionMap[mod.module_code] || [],
             submod: buildHierarchy(mod.wbs_code),
@@ -261,7 +228,6 @@ export class ModuleAccessRepository {
         .filter((mod) => mod.level_type === lvl)
         .map((mod) => ({
           name: mod.name,
-          module_id: mod.id,
           code: mod.module_code,
           permission: actionMap[mod.module_code] || [],
           submod: buildHierarchy(mod.wbs_code),
@@ -288,16 +254,10 @@ export class ModuleAccessRepository {
       for (const access of accessList) {
         const existing = await this.moduleAccessRepo.findOne({
           where: {
-            role: {
-              code: access.role_code,
-            },
-            module: {
-              module_code: access.module_code,
-            },
+            role_code: access.role_code,
+            module_code: access.module_code,
             action_type: access.action_type,
-            app: {
-              code: access.appcode,
-            },
+            appcode: access.appcode,
             level_type: access.level_type,
           },
         });
@@ -307,7 +267,7 @@ export class ModuleAccessRepository {
           await this.moduleAccessRepo.save(existing);
         } else {
           await this.moduleAccessRepo.save(
-            this.moduleAccessRepo.create(access),
+            await this.moduleAccessRepo.create(access),
           );
         }
       }
@@ -325,10 +285,13 @@ export class ModuleAccessRepository {
 
     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_id: module.id,
-        role_id: In(roleIds),
+        module_code: moduleCode,
+        role_code: In(roleCodes),
         access_flag: 1,
       },
     });
@@ -338,18 +301,16 @@ export class ModuleAccessRepository {
     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),
-        app: {
-          code: appcode,
-        },
+        appcode,
       },
       select: ['id', 'code'],
     });
@@ -357,27 +318,18 @@ export class ModuleAccessRepository {
     const roleCodes = roles.map((r) => r.code);
     if (!roleCodes.length) return [];
 
-    const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
-    const appMaster = await appMasterRepo.findOne({
-      where: {
-        code: appcode,
-      },
-    });
-
     // Step 2: Fetch full access data
     const accessRecords = await this.moduleAccessRepo
       .createQueryBuilder('access')
       .select([
-        'access.module_id AS module_id',
-        'm.module_code AS module_code',
+        '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',
       ])
-      .innerJoin('sso_module', 'm', 'm.id = access.module_id')
       .where('access.role_code IN (:...roleCodes)', { roleCodes })
-      .andWhere('access.app_id = :app_id', { app_id: appMaster.id })
+      .andWhere('access.appcode = :appcode', { appcode })
       .getRawMany();
 
     // Step 3: Format output

package/src/module/module/service/menu.service.ts

@@ -1,13 +1,15 @@
 import { Injectable } from '@nestjs/common';
 import { MenuRepository } from '../repository/menu.repository';
 import { MenuData } from '../entity/menu.entity';
+import { DataSource } from 'typeorm';
+import { UserRoleMapping } from 'src/module/user/entity/user-role-mapping.entity';
 
 @Injectable()
 export class MenuService {
   constructor(
     private readonly menuRepository: MenuRepository,
-  ) {
-  }
+    private readonly datasource: DataSource,
+  ) {}
 
   /**
    * Fetch and construct menu hierarchy for a given user.
@@ -28,15 +30,15 @@ export class MenuService {
     if (!roleCodes.length) return { menu: [] };
 
     // Step 2: Get accessible modules
-    const modules = await this.menuRepository.getAccessibleModules(
+    const moduleCodes = await this.menuRepository.getAccessibleModules(
       roleCodes,
       appcode,
     );
-    if (!modules.length) return { menu: [] };
+    if (!moduleCodes.length) return { menu: [] };
 
     // Step 3: Get menu items for the given level type
     const menuItems = await this.menuRepository.getMenuItems(
-      modules,
+      moduleCodes,
       appcode,
       levelType,
     );
@@ -74,7 +76,7 @@ export class MenuService {
   }
 
   // get user roles
-  async getUserRoles(userId: number, app_id: number): Promise<any> {
-    return this.menuRepository.getUserRoles(userId, app_id);
+  async getUserRoles(userId: number, appcode: string): Promise<any> {
+    return this.menuRepository.getUserRoles(userId, appcode);
   }
 }

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

@@ -1,21 +1,27 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { ModuleAccessRepository } from '../repository/module-access.repository';
-import { IsNull, Not, Or, Repository } from 'typeorm';
+import { RoleRepository } from 'src/module/user/repository/role.repository';
+import { RoleService } from '../../user/service/role.service';
+import {
+  ENTITYTYPE_ROLE,
+  STATUS_INACTIVE,
+} from '../../../constant/global.constant';
+import { Role } from '../../user/entity/role.entity';
+import { DataSource, EntityManager } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { MenuRepository } from '../repository/menu.repository';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-import { Role } from '../../user/entity/role.entity';
-import { InjectRepository } from '@nestjs/typeorm';
-import { StatusConstant } from '../../../constant/status.constant';
 
 @Injectable()
 export class ModuleAccessService {
   constructor(
     private readonly moduleAccessRepository: ModuleAccessRepository,
     private readonly menuRepository: MenuRepository,
+    private readonly dataSource: DataSource,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
     private readonly reflectionHelper: ReflectionHelper,
-    @InjectRepository(Role)
-    private readonly roleRepo: Repository<Role>
   ) {
   }
 
@@ -36,26 +42,25 @@ export class ModuleAccessService {
     level_id?: number;
     include?: boolean;
   }) {
+    const query = this.dataSource
+      .createQueryBuilder()
+      .select('*')
+      .from('sso_role', 'role')
+      .where('role.appcode = :appcode', { appcode });
 
-    const where: any = {
-      app: {
-        code: appcode
-      }
-    };
-
+    // Only add this condition if `include` is false (exclude factory roles)
     if (!include) {
-      where.is_factory = Or(IsNull(), Not(1));
+      query.andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
     }
 
     if (level_type && level_id) {
-      where.level_type = level_type;
-      where.level_id = String(level_id);
+      query.andWhere('role.level_type = :level_type', { level_type });
+      query.andWhere('role.level_id = :level_id', {
+        level_id: String(level_id),
+      });
     }
 
-    const roles = await this.roleRepo.find({
-      where,
-    });
-
+    const roles = await query.getRawMany();
 
     return roles.map((role) => ({
       label: role.name,
@@ -83,7 +88,7 @@ export class ModuleAccessService {
     levelType: string,
   ): Promise<Record<string, any[]>> {
     if (!appcode) {
-      throw new BadRequestException('App code is required');
+      throw new BadRequestException('Appcode is required');
     }
 
     return this.moduleAccessRepository.getAllModulesByLevel(
@@ -128,11 +133,13 @@ export class ModuleAccessService {
                              appcode,
                              level_type,
                              level_id,
+                             enterprise_id,
                            }: {
     userId: number;
     appcode: string;
     level_type: string;
     level_id: number;
+    enterprise_id: number;
   }) {
     // Step 1: Resolve roles
     const roleCodes = await this.menuRepository.resolveUserRoles(
@@ -165,7 +172,12 @@ export class ModuleAccessService {
         },
       });
 
-      if (!school || school.status === StatusConstant.INACTIVE) {
+      const resolveStatus = await this.listMasterService.getResolvedListCode(
+        STATUS_INACTIVE,
+        enterprise_id || 0,
+      );
+
+      if (!school || school.status === resolveStatus.id) {
         // Return only VIEW permissions
         return allPermissions.filter((perm) => perm.action === 'VIEW');
       }