rez_core 2.0.86 → 2.0.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.0.86",
+  "version": "2.0.88",
   "description": "",
   "author": "",
   "private": false,
@@ -89,6 +89,7 @@
       "js",
       "json",
       "ts"
+      
     ],
     "rootDir": "src",
     "testRegex": ".*\\.spec\\.ts$",

package/src/module/layout_preference/service/layout_preference.service.ts

@@ -25,15 +25,16 @@ export class LayoutPreferenceService extends EntityServiceImpl {
       );
 
     if (existingLayoutPreference) {
-      console.log('existing preference');
-
       return await super.updateEntity(
         { ...entityData, id: existingLayoutPreference.id },
         loggedInUser,
       );
     }
 
-    return await super.createEntity(entityData, loggedInUser);
+    return await super.createEntity(
+      { ...entityData, user_id: userId } as any,
+      loggedInUser,
+    );
   }
 
   async getLayoutPreferenceByUserID(user_id, mapped_entity_type) {

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

@@ -43,18 +43,33 @@ export class ModuleAccessController {
   }
 
   @Get('access-listing')
-  async getAccessListing(@Query('roles') roleIds: string, @Request() req) {
+  async getAccessListing(
+    @Query('roles') roleIds: string,
+    @Query('appcode') queryAppcode: string,
+    @Request() req,
+  ) {
     const roleIdArray = roleIds.split(',').map(Number);
-    const appcode = req.user.userData.appcode;
-    return this.moduleAccessService.getAccessListing(roleIdArray, appcode);
+    const appcode = queryAppcode || req.user.userData.appcode;
+    return this.moduleAccessService.getAccessListing(roleIdArray, appcode,"");
   }
-
+  
   @Get('menu-listing')
-  async getMenuListing(@Query('mainmod') mainModIds: string, @Request() req) {
+  async getMenuListing(
+    @Query('mainmod') mainModIds: string,
+    @Query('appcode') appcode: string,
+    @Request() req,
+  ) {
     const mainModArray = mainModIds.split(',').map(String);
-    const appcode = req.user.userData.appcode;
-    return this.moduleAccessService.getMenuListing(mainModArray, appcode);
+    const { level_type} = req.user.userData;
+  
+    return this.moduleAccessService.getMenuListing(
+      mainModArray,
+      appcode,
+      level_type
+    );
   }
+  
+  
 
   @Post('update')
   async updateModuleAccess(@Body() moduleAccessData: any[], @Request() req) {

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

@@ -17,6 +17,9 @@ export class ModuleAccess {
   @Column({type: 'varchar', length: 100, nullable: true })
   action_type: string;
 
+  @Column({type: 'varchar', length: 100, nullable: true })
+  level_type: string;
+
   @Column({type: 'varchar', length: 100, nullable: true})
   appcode: string;
 }

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

@@ -32,6 +32,7 @@ export class ModuleData {
   @Column({ type: 'varchar', length: 100, nullable: true })
   entity_type: string;
 
+
   @Column({ type: 'varchar', length: 100, nullable: true })
   title: string;
 
@@ -46,4 +47,7 @@ export class ModuleData {
 
   @Column({ type: 'varchar', length: 100, nullable: true })
   type: string;
+
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  level_type: string;
 }

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

@@ -34,10 +34,10 @@ export class MenuRepository extends Repository<MenuData> {
       .select('role.code')
       .where('role.id IN (:...roleIds)', { roleIds })
       .getMany();
-
+  
     const codes = roleCodes.map((role) => role.code);
     if (codes.length === 0) return [];
-
+  
     const modules = await this.dataSource
       .getRepository(ModuleAccess)
       .createQueryBuilder('moduleAccess')
@@ -46,18 +46,28 @@ export class MenuRepository extends Repository<MenuData> {
       .andWhere('moduleAccess.access_flag > 0')
       .andWhere('LOWER(moduleAccess.appcode) = LOWER(:appCode)', { appCode })
       .getMany();
-
-    return modules.map((module) => module.module_code);
+  
+    return Array.from(new Set(modules.map((module) => module.module_code)));
   }
+  
 
   /**
    * ✅ 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')
+    return await this.menuData
+      .createQueryBuilder('menu')
+      .leftJoin(
+        'cr_module',
+        'module',
+        `
+          menu.module_code = module.module_code
+          AND LOWER(menu.appcode) = LOWER(module.appcode)
+          AND menu.level_type = module.level_type
+        `
+      )
       .where('menu.module_code IN (:...moduleCodes)', { moduleCodes })
-      .andWhere('LOWER(module.appcode) = LOWER(:appcode)', { appcode })
+      .andWhere('LOWER(menu.appcode) = LOWER(:appcode)', { appcode })
       .andWhere('menu.level_type = :levelType', { levelType })
       .select([
         'menu.*',
@@ -69,7 +79,7 @@ export class MenuRepository extends Repository<MenuData> {
       ])
       .getRawMany();
   }
-
+  
   
   async resolveUserRoles(
     userId: number,

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

@@ -5,50 +5,48 @@ 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 { ClockIDGenService } from 'src/utils/service/clockIDGenUtil.service';
-import { UserData } from 'src/module/user/entity/user.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>,
   ) {}
 
   async getRoles({ appcode }: { appcode: string }) {
-    const roles = await this.roleRepo.find({
-      where: { appcode: appcode },
-    });
-    return roles.map((role) => ({
-      label: role.name,
-      value: role.id,
-    }));
+    const roles = await this.roleRepo.find({ where: { appcode } });
+    return roles.map((role) => ({ label: role.name, value: role.id }));
   }
 
   async getModules({ appcode }: { appcode: string }) {
     const modules = await this.moduleRepo.find({
-      where: { module_level: 'MAINMOD', appcode: appcode },
+      where: { module_level: 'MAINMOD', appcode },
     });
-    return modules.map((mod) => ({
-      label: mod.name,
-      value: mod.id,
-    }));
+    return modules.map((mod) => ({ label: mod.name, value: mod.id }));
   }
 
-  async getAccessListing(roleIds: number[], appcode: string) {
+  async getAccessListing(roleIds: number[], appcode: string, levelType: string) {
     const roles = await this.roleRepo.find({
-      where: { id: In(roleIds), appcode: appcode },
+      where: { id: In(roleIds), appcode },
     });
+
     const roleCodes = roles.map((role) => role.code);
 
     const moduleAccesses = await this.moduleAccessRepo.find({
-      where: { role_code: In(roleCodes), appcode: appcode },
+      where: {
+        role_code: In(roleCodes),
+        appcode,
+        level_type: levelType,
+      },
     });
 
     return roles.map((role) => ({
@@ -64,68 +62,67 @@ export class ModuleAccessRepository {
     }));
   }
 
-  async getMenuListing(mainModIds: string[], appcode: string) {
+
+  async getAllModulesByLevel(mainModIds: string[], appcode: string, levelType) {
     const mainModules =
       mainModIds.length === 1 && mainModIds[0] === '-1'
-        ? await this.moduleRepo.find({
-            where: { module_level: 'MAINMOD', appcode: appcode },
-          })
+        ? await this.moduleRepo.find({ where: { module_level: 'MAINMOD', appcode } })
         : await this.moduleRepo.find({
-            where: {
-              id: In(mainModIds),
-              module_level: 'MAINMOD',
-              appcode: appcode,
-            },
+            where: { id: In(mainModIds), module_level: 'MAINMOD', appcode },
           });
-
-    if (!mainModules.length) return [];
-
+  
+    if (!mainModules.length) return {};
+  
     const wbsCodes = mainModules.map((mod) => mod.wbs_code);
-
-    const modules = await this.moduleRepo
+  
+    const allModules = await this.moduleRepo
       .createQueryBuilder('module')
       .where(
-        wbsCodes
-          .map((code) => `module.wbs_code LIKE :code${code}`)
-          .join(' OR '),
+        wbsCodes.map((code) => `module.wbs_code LIKE :code${code}`).join(' OR '),
         Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
       )
+      .andWhere('module.appcode = :appcode', { appcode })
       .getMany();
-
-    const moduleActions = await this.moduleActionRepo.find();
-
-    const buildHierarchy = (parentWbs: string): any[] =>
-      modules
-        .filter(
-          (mod) =>
-            mod.wbs_code.startsWith(`${parentWbs}.`) &&
-            mod.wbs_code.split('.').length === parentWbs.split('.').length + 1,
-        )
+  
+    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: [], // No actions, since you're not using role filtering
+            submod: buildHierarchy(mod.wbs_code),
+          }));
+  
+      const levelModules = mainModules
+        .filter((mod) => mod.level_type === lvl)
         .map((mod) => ({
           name: mod.name,
           code: mod.module_code,
-          permission: moduleActions
-            .filter((action) => action.module_code === mod.module_code)
-            .map((action) => ({
-              action: action.action_type,
-              name: action.action_type,
-            })),
+          permission: [],
           submod: buildHierarchy(mod.wbs_code),
         }));
-
-    return mainModules.map((mod) => ({
-      name: mod.name,
-      code: mod.module_code,
-      permission: moduleActions
-        .filter((action) => action.module_code === mod.module_code)
-        .map((action) => ({
-          action: action.action_type,
-          name: action.action_type,
-        })),
-      submod: buildHierarchy(mod.wbs_code),
-    }));
+  
+      if (levelModules.length) {
+        groupedByLevel[lvl] = levelModules;
+      }
+    }
+  
+    return groupedByLevel;
   }
 
+
   async updateModuleAccess(
     accessList: {
       role_code: string;
@@ -133,6 +130,7 @@ export class ModuleAccessRepository {
       action_type: string;
       access_flag: number;
       appcode: string;
+      level_type: string;
     }[],
     appcode: string,
   ): Promise<boolean> {
@@ -144,6 +142,7 @@ export class ModuleAccessRepository {
             module_code: access.module_code,
             action_type: access.action_type,
             appcode: access.appcode || appcode,
+            level_type: access.level_type,
           },
         });
 
@@ -152,7 +151,10 @@ export class ModuleAccessRepository {
           await this.moduleAccessRepo.save(existing);
         } else {
           await this.moduleAccessRepo.save(
-            this.moduleAccessRepo.create(access),
+            this.moduleAccessRepo.create({
+              ...access,
+              appcode: access.appcode || appcode,
+            }),
           );
         }
       }
@@ -163,21 +165,14 @@ export class ModuleAccessRepository {
     }
   }
 
-  // src/module/module-access/repository/module-access.repository.ts
-
   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) },
-    });
+    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({

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

@@ -6,11 +6,13 @@ import { ENTITYTYPE_ROLE } from '../../../constant/global.constant';
 import { Role } from '../../user/entity/role.entity';
 import { EntityManager } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
+import { MenuRepository } from '../repository/menu.repository';
 
 @Injectable()
 export class ModuleAccessService {
   constructor(
     private readonly moduleAccessRepository: ModuleAccessRepository,
+    private readonly menuRepository: MenuRepository,
   ) {}
 
   async getRoles({ appcode }: { appcode: string }) {
@@ -22,28 +24,48 @@ export class ModuleAccessService {
       appcode,
     });
   }
-
-  async getAccessListing(roleIds: number[], appcode: string) {
-    return this.moduleAccessRepository.getAccessListing(roleIds, appcode);
+  async getAccessListing(
+    roleIds: number[],
+    appcode: string,
+    levelType: string,
+  ) {
+    return this.moduleAccessRepository.getAccessListing(roleIds, appcode, levelType);
   }
-
-  async getMenuListing(mainModIds: string[], appcode: string) {
-    return this.moduleAccessRepository.getMenuListing(mainModIds, appcode);
+  
+  async getMenuListing(
+    mainModIds: string[],
+    appcode: string,
+    levelType: string,
+  ): Promise<Record<string, any[]>> {
+    if (!appcode) {
+      throw new BadRequestException('Appcode is required');
+    }
+  
+    return this.moduleAccessRepository.getAllModulesByLevel(mainModIds, appcode, levelType);
   }
+  
+  
 
   async updateModuleAccess(
-    moduleAccessData: any[],
+    moduleAccessData: {
+      role_code: string;
+      module_code: string;
+      action_type: string;
+      access_flag: number;
+      appcode: string;
+      level_type: string;
+    }[],
     appcode: string,
   ): Promise<{ success: boolean; msg: string }> {
     if (!moduleAccessData || moduleAccessData.length === 0) {
       return { success: false, msg: 'No data provided' };
     }
-
+  
     const result = await this.moduleAccessRepository.updateModuleAccess(
       moduleAccessData,
       appcode,
     );
-
+  
     if (result) {
       return { success: true, msg: 'Module access updated successfully' };
     } else {
@@ -51,6 +73,7 @@ export class ModuleAccessService {
     }
   }
 
+
   // src/module/module-access/service/module-access.service.ts
 
   async getModuleUIConfig(moduleCode: string, roleIds: number[]) {

package/src/module/user/service/user-session.service.ts

@@ -74,7 +74,6 @@ export class UserSessionService {
     level_type: string;
     level_id: string;
   }> {
-    console.log(currentUser, data);
     let payload;
 
     payload = {

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

@@ -113,7 +113,6 @@ export class UserService extends EntityServiceImpl {
       if (insertPromises.length > 0) {
         await Promise.all(insertPromises);
       }
-      console.log('Access levels added successfully');
     } catch (error) {
       console.error('Error adding access levels:', error);
       throw new BadRequestException('Failed to add access levels');
@@ -216,7 +215,6 @@ export class UserService extends EntityServiceImpl {
 
       try {
         await Promise.all(insertPromises);
-        console.log('Access levels updated successfully');
       } catch (error) {
         console.error('Error updating access levels:', error);
         throw new BadRequestException('Failed to update access levels');