rez_core 2.0.53 → 2.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.0.53",
+  "version": "2.0.55",
   "description": "",
   "author": "",
   "private": false,

package/src/module/module/controller/menu.controller.ts

@@ -9,8 +9,8 @@ export class MenuController {
   @UseGuards(JwtAuthGuard)
   @Get()
   async getMenu(@Request() req) {
-    const userId = req.user.userData?.id;
-    const appcode = req.user.userData?.appcode;
-    return this.menuService.getUserMenu(userId, appcode);
+    const { id: userId, appcode, level_type, level_id } = req.user.userData;
+    return this.menuService.getUserMenu(userId, appcode, level_type, level_id);
   }
+  
 }

package/src/module/module/entity/menu.entity.ts

@@ -37,4 +37,7 @@ export class MenuData {
 
   @Column({ type: 'varchar', nullable: true })
   appcode: string;
+  
+  @Column({ type: 'varchar', nullable: true })
+  level_type: string;
 }

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

@@ -4,21 +4,21 @@ import { MenuData } from '../entity/menu.entity';
 import { ModuleAccess } from '../entity/module-access.entity';
 import { UserRoleMapping } from 'src/module/user/entity/user-role-mapping.entity';
 import { Role } from 'src/module/user/entity/role.entity';
+import { InjectRepository } from '@nestjs/typeorm';
 
 @Injectable()
 export class MenuRepository extends Repository<MenuData> {
-  constructor(private readonly dataSource: DataSource) {
+  constructor(private readonly dataSource: DataSource,
+    @InjectRepository(MenuData) private readonly menuData: Repository<MenuData>
+  ) {
     super(MenuData, dataSource.createEntityManager());
   }
 
-  /**
-   * Get all role IDs assigned to a user.
-   */
   async getUserRoles(userId: number, appcode: string): Promise<number[]> {
     const roles = await this.dataSource
       .getRepository(UserRoleMapping)
       .createQueryBuilder('urm')
-      .innerJoin('cr_role', 'role', 'role.id = urm.role_id') // manual join
+      .innerJoin('cr_role', 'role', 'role.id = urm.role_id')
       .select('urm.role_id')
       .where('urm.user_id = :userId', { userId })
       .andWhere('role.appcode = :appcode', { appcode })
@@ -27,13 +27,7 @@ export class MenuRepository extends Repository<MenuData> {
     return roles.map((r) => r.urm_role_id);
   }
 
-  /**
-   * Get module codes that the user has access to based on their role IDs.
-   */ async getAccessibleModules(
-    roleIds: number[],
-    appCode: string,
-  ): Promise<string[]> {
-    // Get role codes from role IDs
+  async getAccessibleModules(roleIds: number[], appCode: string): Promise<string[]> {
     const roleCodes = await this.dataSource
       .getRepository(Role)
       .createQueryBuilder('role')
@@ -42,32 +36,29 @@ export class MenuRepository extends Repository<MenuData> {
       .getMany();
 
     const codes = roleCodes.map((role) => role.code);
+    if (codes.length === 0) return [];
 
-    if (codes.length === 0) {
-      return [];
-    }
-
-    // Get accessible modules using role codes and appCode
     const modules = await this.dataSource
       .getRepository(ModuleAccess)
       .createQueryBuilder('moduleAccess')
       .select('moduleAccess.module_code')
       .where('moduleAccess.role_code IN (:...codes)', { codes })
       .andWhere('moduleAccess.access_flag > 0')
-      .andWhere('LOWER(moduleAccess.appcode) = LOWER(:appCode)', { appCode }) // case-insensitive
+      .andWhere('LOWER(moduleAccess.appcode) = LOWER(:appCode)', { appCode })
       .getMany();
 
     return modules.map((module) => module.module_code);
   }
 
-  async getMenuItems(
-    moduleCodes: string[],
-    appcode: string,
-  ): Promise<MenuData[]> {
-    const menuItems = await this.createQueryBuilder('menu')
+  /**
+   * ✅ FIXED: Use this.createQueryBuilder() instead of this.menuData.createQueryBuilder()
+   */
+  async getMenuItems(moduleCodes: string[], appcode: string, levelType: string) {
+    return await this.menuData.createQueryBuilder('menu')
       .leftJoin('cr_module', 'module', 'menu.module_code = module.module_code')
       .where('menu.module_code IN (:...moduleCodes)', { moduleCodes })
-      .andWhere('LOWER(module.appcode) = LOWER(:appcode)', { appcode }) // appcode filter
+      .andWhere('LOWER(module.appcode) = LOWER(:appcode)', { appcode })
+      .andWhere('menu.level_type = :levelType', { levelType })
       .select([
         'menu.*',
         'module.component_name AS component',
@@ -77,7 +68,68 @@ export class MenuRepository extends Repository<MenuData> {
         'module.ui_config AS ui_config',
       ])
       .getRawMany();
+  }
+
+  
+  async resolveUserRoles(
+    userId: number,
+    appcode: string,
+    levelType: string,
+    levelId: number,
+  ): Promise<number[]> {
+    const repo = this.dataSource.getRepository(UserRoleMapping);
+
+    // 1. Try exact level match
+    let roles = await repo.createQueryBuilder('urm')
+      .innerJoin('cr_role', 'role', 'role.id = urm.role_id')
+      .select('urm.role_id')
+      .where('urm.user_id = :userId', { userId })
+      .andWhere('urm.level_type = :levelType', { levelType })
+      .andWhere('urm.level_id = :levelId', { levelId })
+      .andWhere('role.appcode = :appcode', { appcode })
+      .getRawMany();
+
+    if (roles.length) return roles.map(r => r.urm_role_id);
+
+    // 2. If SCH fallback → BRN → ORG
+    if (levelType === 'SCH') {
+      const [sch] = await this.dataSource.query(`
+        SELECT s.brn_id, b.org_id
+        FROM cr_school s
+        LEFT JOIN cr_branch b ON s.brn_id = b.id
+        WHERE s.id = $1
+      `, [levelId]);
+
+      const branchId = sch?.brn_id;
+      const orgId = sch?.org_id;
+
+      if (branchId) {
+        roles = await repo.createQueryBuilder('urm')
+          .innerJoin('cr_role', 'role', 'role.id = urm.role_id')
+          .select('urm.role_id')
+          .where('urm.user_id = :userId', { userId })
+          .andWhere('urm.level_type = :levelType', { levelType: 'BRN' })
+          .andWhere('urm.level_id = :levelId', { levelId: branchId })
+          .andWhere('role.appcode = :appcode', { appcode })
+          .getRawMany();
+
+        if (roles.length) return roles.map(r => r.urm_role_id);
+      }
+
+      if (orgId) {
+        roles = await repo.createQueryBuilder('urm')
+          .innerJoin('cr_role', 'role', 'role.id = urm.role_id')
+          .select('urm.role_id')
+          .where('urm.user_id = :userId', { userId })
+          .andWhere('urm.level_type = :levelType', { levelType: 'ORG' })
+          .andWhere('urm.level_id = :levelId', { levelId: orgId })
+          .andWhere('role.appcode = :appcode', { appcode })
+          .getRawMany();
+
+        if (roles.length) return roles.map(r => r.urm_role_id);
+      }
+    }
 
-    return menuItems;
+    return [];
   }
 }

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

@@ -1,42 +1,40 @@
 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) {}
+  constructor(private readonly menuRepository: MenuRepository,
+    private readonly datasource:DataSource
+  ) {}
 
   /**
    * Fetch and construct menu hierarchy for a given user.
    */
-  async getUserMenu(userId: number, appcode: string): Promise<{ menu: any[] }> {
-    // Step 1: Get the roles of the user
-    const roleCodes = await this.menuRepository.getUserRoles(userId, appcode);
-    if (!roleCodes.length) {
-      return { menu: [] }; // Return empty menu if user has no roles
-    }
-
-    // Step 2: Get the modules the user has access to
-    const moduleCodes = await this.menuRepository.getAccessibleModules(
-      roleCodes,
-      appcode,
-    );
-    if (!moduleCodes.length) {
-      return { menu: [] }; // Return empty menu if no accessible modules
-    }
-
-    // Step 3: Get the menu items based on accessible modules
-    const menuItems = await this.menuRepository.getMenuItems(
-      moduleCodes,
-      appcode,
-    );
-
-    // Step 4: Build hierarchical menu structure
+  async getUserMenu(
+    userId: number,
+    appcode: string,
+    levelType: 'ORG' | 'SCH',
+    levelId: number,
+  ): Promise<{ menu: any[] }> {
+    // Step 1: Resolve roles (with fallback logic inside)
+    const roleCodes = await this.menuRepository.resolveUserRoles(userId, appcode, levelType, levelId);
+    if (!roleCodes.length) return { menu: [] };
+  
+    // Step 2: Get accessible modules
+    const moduleCodes = await this.menuRepository.getAccessibleModules(roleCodes, appcode);
+    if (!moduleCodes.length) return { menu: [] };
+  
+    // Step 3: Get menu items for the given level type
+    const menuItems = await this.menuRepository.getMenuItems(moduleCodes, appcode, levelType);
+  
+    // Step 4: Build hierarchy
     const menuTree = this.buildMenuHierarchy(menuItems);
-
     return { menu: menuTree };
   }
-
+  
   /**
    * Converts a flat list of menu items into a hierarchical tree.
    */
@@ -67,4 +65,8 @@ export class MenuService {
   async getUserRoles(userId: number, appcode: string): Promise<any> {
     return this.menuRepository.getUserRoles(userId, appcode);
   }
+
+
+
+  
 }

package/src/module/user/service/login.service.ts

@@ -89,7 +89,7 @@ export class LoginService {
 
     const token = await this.userSessionService.createSession(
       user,
-      user.appcode,
+      appcode,
       {
         level_type: defaultAccess.level_type,
         level_id: defaultAccess.level_id,