rez_core 6.5.27 → 6.5.28

package/src/module/module/entity/module-action.entity.ts

@@ -1,17 +1,21 @@
-import { Column, Entity, PrimaryGeneratedColumn, Unique } from 'typeorm';
+import { Column, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+import { ModuleData } from './module.entity';
 
-@Entity({ name: 'sso_module_action' }) // <- new table name
-@Unique(['module_code', 'action_type']) // enforce uniqueness per module + action
+@Entity({ name: 'sso_module_ucp' }) // <- new table name
 export class ModuleAction {
   @PrimaryGeneratedColumn()
   id: number;
 
-  @Column({ type: 'varchar', length: 100, nullable: true })
-  module_code: string;
+  @Column({ type: 'int', nullable: true })
+  module_id: number;
+
+  @ManyToOne(() => ModuleData, {nullable: true, onDelete: 'SET NULL'})
+  @JoinColumn({ name: 'module_id', referencedColumnName: 'id' })
+  module: ModuleData;
 
   @Column({ type: 'varchar', length: 100, nullable: true })
   action_name: string;
 
   @Column({ type: 'varchar', length: 50, nullable: true })
-  action_type: string;
+  action_code: string;
 }

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

@@ -1,4 +1,5 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { AppMaster } from 'src/module/meta/entity/app-master.entity';
+import { Column, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity({ name: 'sso_module' })
 export class ModuleData {
@@ -20,15 +21,6 @@ export class ModuleData {
   @Column({ type: 'varchar', length: 100, nullable: true })
   module_level: string;
 
-  @Column({ type: 'int', nullable: true })
-  parent_id: number;
-
-  @Column({ type: 'varchar', length: 100, nullable: true })
-  parent_code: string;
-
-  @Column({ type: 'int', nullable: true })
-  ui_visible: number;
-
   @Column({ type: 'varchar', length: 100, nullable: true })
   entity_type: string;
 
@@ -38,11 +30,12 @@ export class ModuleData {
   @Column({ type: 'varchar', length: 100, nullable: true })
   component_name: string;
 
-  @Column({ type: 'json', nullable: true })
-  ui_config: JSON;
+  @Column({type: 'int', nullable: true})
+  app_id: number;
 
-  @Column({ type: 'varchar', length: 100, nullable: true })
-  appcode: string;
+  @ManyToOne(() => AppMaster, {nullable: true, onDelete: 'SET NULL'})
+  @JoinColumn({ name: 'app_id', referencedColumnName: 'id' })
+  app: AppMaster;
 
   @Column({ type: 'varchar', length: 100, nullable: true })
   type: string;

package/src/module/module/module.module.ts

@@ -14,7 +14,6 @@ import { UserRoleMapping } from '../user/entity/user-role-mapping.entity';
 import { UserModule } from '../user/user.module';
 import { Role } from '../user/entity/role.entity';
 import { ModuleAccess } from './entity/module-access.entity';
-import { ListMasterModule } from '../listmaster/listmaster.module';
 
 @Module({
   imports: [
@@ -28,7 +27,6 @@ import { ListMasterModule } from '../listmaster/listmaster.module';
     ]),
     UtilsModule,
     UserModule,
-    ListMasterModule,
   ],
   controllers: [MenuController, ModuleAccessController],
   providers: [
@@ -39,4 +37,5 @@ import { ListMasterModule } from '../listmaster/listmaster.module';
   ],
   exports: [ModuleAccessService,MenuService],
 })
-export class ModuleModule {}
+export class ModuleAccessModule {
+}

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, appcode: string): Promise<number[]> {
+  async getUserRoles(userId: number, app_id: number): 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.appcode = :appcode', { appcode })
+      .andWhere('role.app_id = :app_id', { app_id })
       .getRawMany();
 
     return roles.map((r) => r.role_id);
@@ -34,37 +34,26 @@ export class MenuRepository extends Repository<MenuData> {
 
   async getAccessibleModules(
     roleIds: 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 codes = roleCodes.map((r) => r.code);
-
-    if (codes.length === 0) return [];
+    app_id: number,
+  ): Promise<number[]> {
 
     const modules = await this.moduleAccessRepo
       .createQueryBuilder('moduleAccess')
-      .select('moduleAccess.module_code')
-      .where('moduleAccess.role_code IN (:...codes)', { codes })
+      .select('moduleAccess.module_id')
+      .where('moduleAccess.role_id IN (:...roleIds)', { roleIds })
       .andWhere('moduleAccess.access_flag > 0')
-      .andWhere('LOWER(moduleAccess.appcode) = LOWER(:appCode)', { appCode })
+      .andWhere('moduleAccess.app_id = :app_id', { app_id: app_id })
       .getMany();
 
-    return Array.from(new Set(modules.map((module) => module.module_code)));
+    return Array.from(new Set(modules.map((module) => module.module_id)));
   }
 
   /**
    * ✅ FIXED: Use this.createQueryBuilder() instead of this.menuData.createQueryBuilder()
    */
   async getMenuItems(
-    moduleCodes: string[],
-    appcode: string,
+    modules: number[],
+    app_id: number,
     levelType: string,
   ) {
     return await this.menuData
@@ -74,12 +63,12 @@ export class MenuRepository extends Repository<MenuData> {
         'module',
         `
           menu.module_code = module.module_code
-          AND LOWER(menu.appcode) = LOWER(module.appcode)
+          AND menu.app_id = module.app_id
           AND menu.level_type = module.level_type
         `,
       )
-      .where('menu.module_code IN (:...moduleCodes)', { moduleCodes })
-      .andWhere('LOWER(menu.appcode) = LOWER(:appcode)', { appcode })
+      .where('menu.module_id IN (:...modules)', { modules: modules })
+      .andWhere('menu.app_id = :app_id', { app_id: app_id })
       .andWhere('menu.level_type = :levelType', { levelType })
       .andWhere('menu.ui_visible = 1')
       .select([
@@ -87,15 +76,14 @@ export class MenuRepository extends Repository<MenuData> {
         'module.component_name AS component',
         'module.title AS title',
         'module.entity_type AS entity_type',
-        'module.type AS type',
-        'module.ui_config AS ui_config',
+        'module.type AS type'
       ])
       .getRawMany();
   }
 
   async resolveUserRoles(
     userId: number,
-    appcode: string,
+    app_id: number,
     levelType: string,
     levelId: number,
   ): Promise<number[]> {
@@ -114,7 +102,7 @@ export class MenuRepository extends Repository<MenuData> {
       const getUserUrm = await repo.findOne({
         where: {
           user_id: userId,
-          appcode: appcode,
+          app_id: app_id,
         },
       });
 
@@ -135,7 +123,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.appcode = :appcode', { appcode })
+      .andWhere('role.app_id = :app_id', { app_id: app_id })
       .getRawMany();
 
     if (roles.length) return roles.map((r) => r.urm_role_id);
@@ -160,7 +148,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.appcode = :appcode', { appcode })
+          .andWhere('role.app_id = :app_id', { app_id: app_id })
           .getRawMany();
 
         if (roles.length) return roles.map((r) => r.urm_role_id);
@@ -174,7 +162,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.appcode = :appcode', { appcode })
+          .andWhere('role.app_id = :app_id', { app_id: app_id })
           .getRawMany();
 
         if (roles.length) return roles.map((r) => r.urm_role_id);

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

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

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

@@ -1,45 +1,43 @@
 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.
    */
   async getUserMenu(
     userId: number,
-    appcode: string,
+    app_id: number,
     levelType: 'ORG' | 'SCH',
     levelId: number,
   ): Promise<{ menu: any[] }> {
     // Step 1: Resolve roles (with fallback logic inside)
     const roleCodes = await this.menuRepository.resolveUserRoles(
       userId,
-      appcode,
+      app_id,
       levelType,
       levelId,
     );
     if (!roleCodes.length) return { menu: [] };
 
     // Step 2: Get accessible modules
-    const moduleCodes = await this.menuRepository.getAccessibleModules(
+    const modules = await this.menuRepository.getAccessibleModules(
       roleCodes,
-      appcode,
+      app_id,
     );
-    if (!moduleCodes.length) return { menu: [] };
+    if (!modules.length) return { menu: [] };
 
     // Step 3: Get menu items for the given level type
     const menuItems = await this.menuRepository.getMenuItems(
-      moduleCodes,
-      appcode,
+      modules,
+      app_id,
       levelType,
     );
 
@@ -76,7 +74,7 @@ export class MenuService {
   }
 
   // get user roles
-  async getUserRoles(userId: number, appcode: string): Promise<any> {
-    return this.menuRepository.getUserRoles(userId, appcode);
+  async getUserRoles(userId: number, app_id: number): Promise<any> {
+    return this.menuRepository.getUserRoles(userId, app_id);
   }
 }