rez_core 6.5.10 → 6.5.11

package/src/module/auth/strategies/jwt.strategy.ts

@@ -27,6 +27,7 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
       enterprise_id,
       level_id,
       level_type,
+      appcode
     } = payload;
 
     // Check if session exists and is valid
@@ -51,6 +52,7 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
       enterprise_id: enterprise_id,
       level_id: level_id,
       level_type: level_type,
+      appcode: appcode
     };
 
     return { userData };

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

@@ -82,8 +82,7 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
     forwardRef(() => ListMasterModule),
     forwardRef(() => FilterModule),
     UtilsModule,
-    WorkflowAutomationModule,
-    
+    WorkflowAutomationModule
   ],
   providers: [
     EntityMasterService,
@@ -104,8 +103,6 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
     MediaDataService,
     AttributeMasterService,
     EntityUpdateService,
-    // SectionMasterService,
-    // FieldGroupService,
     ViewMaterRespository,
     EntityValidationService,
     { provide: 'ViewMasterService', useClass: ViewMasterService },
@@ -114,9 +111,6 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
       provide: 'EntityRelationDataService',
       useClass: EntityRelationDataService,
     },
-
-    // UserAppMappingService,
-    // UserAppMappingRepository,
     UserRoleMappingRepository,
     AppMasterRespository,
     AppMasterService,
@@ -135,20 +129,15 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
     MediaDataService,
     EntityUpdateService,
     EntityUpdateRepository,
-    // SectionMasterService,
-    // FieldGroupService,
     'ViewMasterService',
     AttributeMasterService,
-    // UserAppMappingService,
-    // UserAppMappingRepository,
     AppMasterService,
     MasterService,
     ResolverService,
     EntityDynamicService,
     'CommonService',
     'EntityRelationService',
-    EntityMasterRepository,
-    AttributeMasterRepository,
+    AppMasterRespository
   ],
   controllers: [
     EntityController,
@@ -161,7 +150,7 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
     EntityDynamicController,
     EntityRelationController,
     EntityMasterController,
-    EntityPublicController,
+    EntityPublicController
   ],
 })
-export class EntityModule {}
+export class EntityModule { }

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

@@ -26,14 +26,14 @@ export class ModuleAccessController {
   @Get('roles')
   @HttpCode(HttpStatus.OK)
   async getRoles(
-    @Query('app_id') appId: number,
+    @Query('appcode') appcode: string,
     @Query('include') include: string, // ✅ declare it as boolean
     @Request() req,
   ) {
     const { level_type, level_id } = req.user.userData;
 
     return this.moduleAccessService.getRoles({
-      appId,
+      appcode,
       level_type,
       level_id,
       include: include === 'true', // ensure it's either true or false
@@ -42,10 +42,10 @@ export class ModuleAccessController {
 
   @Get('modules')
   @HttpCode(HttpStatus.OK)
-  async getModules(@Query('app_id') app_id: number, @Request() req) {
+  async getModules(@Query('appcode') appcode: string, @Request() req) {
      const loggedInUser = req.user.userData;
     return this.moduleAccessService.getModules({
-      app_id,
+      appcode,
       loggedInUser
     });
   }
@@ -54,16 +54,16 @@ export class ModuleAccessController {
   @HttpCode(HttpStatus.OK)
   async getAccessListing(
     @Query('roles') roleIds: string,
-    @Query('app_id') queryAppId: string,
+    @Query('appcode') queryAppCode: string,
     @Request() req,
   ) {
     const roleIdArray = roleIds.split(',').map(Number);
-    const appId = queryAppId || req.user.userData.app_id;
+    const appcode = queryAppCode || req.user.userData.appcode;
     const level_type = req.user.userData.level_type;
     const level_id = req.user.userData.level_id;
     return this.moduleAccessService.getAccessListing(
       roleIdArray,
-      appId,
+      appcode,
       level_type,
       level_id,
     );
@@ -73,7 +73,7 @@ export class ModuleAccessController {
   @HttpCode(HttpStatus.OK)
   async getMenuListing(
     @Query('mainmod') mainModIds: string,
-    @Query('app_id') appId: number,
+    @Query('appcode') appcode: string,
     @Request() req,
   ) {
     const mainModArray = mainModIds.split(',').map(String);
@@ -81,7 +81,7 @@ export class ModuleAccessController {
 
     return this.moduleAccessService.getMenuListing(
       mainModArray,
-      appId,
+      appcode,
       level_type,
     );
   }
@@ -97,7 +97,7 @@ export class ModuleAccessController {
   @Get('ui-config')
   @HttpCode(HttpStatus.OK)
   async getModuleUIConfig(
-    @Query('module_id') moduleId: number,
+    @Query('module_code') moduleCode: string,
     @Request() req,
   ) {
     const userId = req.user.userData?.id;
@@ -109,7 +109,7 @@ export class ModuleAccessController {
     }
 
     return this.moduleAccessService.getModuleUIConfig(
-      moduleId,
+      moduleCode,
       roles.map((id) => Number(id)),
     );
   }

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

@@ -2,8 +2,8 @@ import { Column, Entity, JoinColumn, ManyToMany, ManyToOne, OneToOne, PrimaryGen
 import { ModuleData } from './module.entity';
 import { Role } from 'src/module/user/entity/role.entity';
 import { ModuleAction } from './module-action.entity';
-import { AppMaster } from 'src/module/meta/entity/app-master.entity';
 import { EnterpriseData } from 'src/module/enterprise/entity/enterprise.entity';
+import { AppMaster } from '../../meta/entity/app-master.entity';
 
 @Entity({ name: 'sso_module_access' })
 export class ModuleAccess {

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

@@ -15,6 +15,7 @@ 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';
+import { EntityModule } from '../meta/entity.module';
 
 @Module({
   imports: [
@@ -27,7 +28,8 @@ import { ListMasterModule } from '../listmaster/listmaster.module';
       Role,
     ]),
     UtilsModule,
-    UserModule
+    UserModule,
+    EntityModule
   ],
   controllers: [MenuController, ModuleAccessController],
   providers: [

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

@@ -1,10 +1,11 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { In, Not, Repository, IsNull, DataSource } from 'typeorm';
+import { In, Not, Repository, Or, DataSource, IsNull } 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 { AppMasterRespository } from '../../meta/repository/app-master.repository';
 
 @Injectable()
 export class ModuleAccessRepository {
@@ -21,36 +22,39 @@ export class ModuleAccessRepository {
     @InjectRepository(ModuleAction)
     private readonly moduleActionRepo: Repository<ModuleAction>,
 
+    private readonly appMasterRepo: AppMasterRespository,
+
     private readonly dataSource: DataSource,
   ) {}
 
   async getRoles({
-    appId,
+    appcode,
     level_type,
     level_id,
   }: {
-    appId: number;
+    appcode: string;
     level_type?: string;
     level_id?: number;
   }) {
-    const query = this.dataSource
-      .createQueryBuilder()
-      .select('*')
-      .from('sso_role', 'role')
-      .where('role.app_id = :appId', { appId })
-      .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 +63,26 @@ export class ModuleAccessRepository {
   }
 
   async getModules({
-    app_id,
+    appcode,
     loggedInUser,
   }: {
-    app_id: any;
+    appcode: string;
     loggedInUser: any;
   }) {
     let modules: any[];
     if (loggedInUser.level_type == 'SCH') {
       modules = await this.moduleRepo.find({
-        where: { module_level: 'MAINMOD', app_id, level_type: 'SCH' },
+        where: { module_level: 'MAINMOD',
+          app: {
+            code: appcode
+          },
+          level_type: 'SCH'
+        },
       });
     } else {
       modules = await this.moduleRepo.find({
-        where: { module_level: 'MAINMOD', app_id },
+        where: { module_level: 'MAINMOD', app : {code: appcode
+          } },
       });
     }
 
@@ -87,7 +97,7 @@ export class ModuleAccessRepository {
 
   async getAccessListing(
     roleIds: (number | string)[],
-    appId: number,
+    appcode: string,
     levelType: string,
     levelId?: number, // add levelId as input so we can fetch roles based on it
   ) {
@@ -96,7 +106,7 @@ export class ModuleAccessRepository {
     if (roleIds.length === 1 && roleIds[0] === -1) {
       // Internally call getRoles
       const fetchedRoles = await this.getRoles({
-        appId,
+        appcode,
         level_type: levelType,
         level_id: levelId,
       });
@@ -105,14 +115,18 @@ export class ModuleAccessRepository {
       roles = await this.roleRepo.find({
         where: {
           id: In(fetchedRoleIds),
-          app_id: appId,
+          app: {
+            code: appcode
+          },
         },
       });
     } else {
       roles = await this.roleRepo.find({
         where: {
           id: In(roleIds.map((id) => Number(id))),
-          app_id: appId,
+          app: {
+            code: appcode
+          },
         },
       });
     }
@@ -122,9 +136,15 @@ export class ModuleAccessRepository {
     const moduleAccesses = await this.moduleAccessRepo.find({
       where: {
         role_id: In(roles.map((role) => role.id)),
-        app_id: appId,
-        level_type: levelType,
+        app: {
+          code: appcode
+        },
+        level_type: levelType
       },
+      relations: {
+        app: true,
+        module: true
+      }
     });
 
     return roles.map((role) => ({
@@ -133,23 +153,31 @@ export class ModuleAccessRepository {
       permission: moduleAccesses
         .filter((access) => access.role_id === role.id)
         .map((access) => ({
-          action_id: access.action_id,
+          action: access.action_type,
           access: access.access_flag,
           module_id: access.module_id,
           level_type: access.level_type,
           app_id: access.app_id,
+          code: access.module.module_code,
+          appcode: access.app.code
         })),
     }));
   }
 
-  async getAllModulesByLevel(mainModIds: string[], app_id: number, levelType) {
+  async getAllModulesByLevel(mainModIds: string[], appcode: string, levelType) {
+    const appMaster = await this.appMasterRepo.getAppMasterDataByAppCode(appcode);
+
+    if (!appMaster) {
+      return {};
+    }
+
     const mainModules =
       mainModIds.length === 1 && mainModIds[0] === '-1'
         ? await this.moduleRepo.find({
-          where: { module_level: 'MAINMOD', app_id },
+          where: { module_level: 'MAINMOD', app_id: appMaster[0].id },
           })
         : await this.moduleRepo.find({
-            where: { id: In(mainModIds), module_level: 'MAINMOD', app_id },
+            where: { id: In(mainModIds), module_level: 'MAINMOD', app: {code: appcode} },
           });
 
     if (!mainModules.length) return {};
@@ -164,7 +192,7 @@ export class ModuleAccessRepository {
           .join(' OR '),
         Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
       )
-      .andWhere('module.app_id = :app_id', { app_id })
+      .andWhere('module.app_id = :app_id', { app_id: appMaster[0].id })
       .andWhere('module.module_code != :excludedCode', {
         excludedCode: 'all_organization_adm_org',
       })
@@ -219,6 +247,7 @@ export class ModuleAccessRepository {
           .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 +257,7 @@ export class ModuleAccessRepository {
         .map((mod) => ({
           name: mod.name,
           module_id: mod.id,
+          code: mod.module_code,
           permission: actionMap[mod.module_code] || [],
           submod: buildHierarchy(mod.wbs_code),
         }));
@@ -241,11 +271,11 @@ export class ModuleAccessRepository {
 
   async updateModuleAccess(
     accessList: {
-      role_id: number;
-      module_id: number;
+      role_code: string;
+      module_code: string;
       action_type: string;
       access_flag: number;
-      app_id: number;
+      appcode: string;
       level_type: string;
     }[],
   ): Promise<boolean> {
@@ -253,10 +283,16 @@ export class ModuleAccessRepository {
       for (const access of accessList) {
         const existing = await this.moduleAccessRepo.findOne({
           where: {
-            role_id: access.role_id,
-            module_id: access.module_id,
+            role: {
+              code: access.role_code,
+            },
+            module: {
+              module_code: access.module_code
+            },
             action_type: access.action_type,
-            app_id: access.app_id,
+            app: {
+              code: access.appcode
+            },
             level_type: access.level_type,
           },
         });
@@ -266,7 +302,7 @@ export class ModuleAccessRepository {
           await this.moduleAccessRepo.save(existing);
         } else {
           await this.moduleAccessRepo.save(
-            await this.moduleAccessRepo.create(access),
+            this.moduleAccessRepo.create(access),
           );
         }
       }
@@ -277,16 +313,16 @@ export class ModuleAccessRepository {
     }
   }
 
-  async getModuleUIConfig(moduleId: number, roleIds: number[]) {
+  async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
     const module = await this.moduleRepo.findOne({
-      where: { id: moduleId },
+      where: { module_code: moduleCode },
     });
 
     if (!module) throw new BadRequestException('Module not found');
 
     const actions = await this.moduleAccessRepo.find({
       where: {
-        module_id: moduleId,
+        module_id: module.id,
         role_id: In(roleIds),
         access_flag: 1,
       },

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

@@ -1,57 +1,61 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { ModuleAccessRepository } from '../repository/module-access.repository';
-import { STATUS_INACTIVE } from '../../../constant/global.constant';
-import { DataSource } from 'typeorm';
+import { IsNull, Not, Or, Repository } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { MenuRepository } from '../repository/menu.repository';
 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,
     private readonly reflectionHelper: ReflectionHelper,
+    @InjectRepository(Role)
+    private readonly roleRepo: Repository<Role>
   ) {
   }
 
-  async getModules({ app_id, loggedInUser }: { app_id: number, loggedInUser: UserData }) {
+  async getModules({ appcode, loggedInUser }: { appcode: string, loggedInUser: UserData }) {
     return this.moduleAccessRepository.getModules({
-      app_id, loggedInUser,
+      appcode, loggedInUser,
     });
   }
 
   async getRoles({
-                   appId,
+                   appcode,
                    level_type,
                    level_id,
                    include,
                  }: {
-    appId: number;
+    appcode: string;
     level_type?: string;
     level_id?: number;
     include?: boolean;
   }) {
-    const query = this.dataSource
-      .createQueryBuilder()
-      .select('*')
-      .from('sso_role', 'role')
-      .where('role.app_id = :appId', { appId });
 
-    // Only add this condition if `include` is false (exclude factory roles)
+    const where: any = {
+      app: {
+        code: appcode
+      }
+    };
+
     if (!include) {
-      query.andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
+      where.is_factory = Or(IsNull(), Not(1));
     }
 
     if (level_type && level_id) {
-      query.andWhere('role.level_type = :level_type', { level_type });
-      query.andWhere('role.level_id = :level_id', {
-        level_id: String(level_id),
-      });
+      where.level_type = level_type;
+      where.level_id = String(level_id);
     }
 
-    const roles = await query.getRawMany();
+    const roles = await this.roleRepo.find({
+      where,
+    });
+
 
     return roles.map((role) => ({
       label: role.name,
@@ -61,13 +65,13 @@ export class ModuleAccessService {
 
   async getAccessListing(
     roleIds: number[],
-    appId: number,
+    appcode: string,
     levelType: string,
     level_id?: number,
   ) {
     return this.moduleAccessRepository.getAccessListing(
       roleIds,
-      appId,
+      appcode,
       levelType,
       level_id,
     );
@@ -75,27 +79,27 @@ export class ModuleAccessService {
 
   async getMenuListing(
     mainModIds: string[],
-    appId: number,
+    appcode: string,
     levelType: string,
   ): Promise<Record<string, any[]>> {
-    if (!appId) {
-      throw new BadRequestException('AppId is required');
+    if (!appcode) {
+      throw new BadRequestException('App code is required');
     }
 
     return this.moduleAccessRepository.getAllModulesByLevel(
       mainModIds,
-      appId,
+      appcode,
       levelType,
     );
   }
 
   async updateModuleAccess(
     moduleAccessData: {
-      role_id: number;
-      module_id: number;
+      role_code: string;
+      module_code: string;
       action_type: string;
       access_flag: number;
-      app_id: number;
+      appcode: string;
       level_type: string;
     }[],
   ): Promise<{ success: boolean; msg: string }> {
@@ -115,8 +119,8 @@ export class ModuleAccessService {
 
   // src/module/module-access/service/module-access.service.ts
 
-  async getModuleUIConfig(moduleId: number, roleIds: number[]) {
-    return this.moduleAccessRepository.getModuleUIConfig(moduleId, roleIds);
+  async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
+    return this.moduleAccessRepository.getModuleUIConfig(moduleCode, roleIds);
   }
 
   async getUserPermissions({
@@ -161,7 +165,7 @@ export class ModuleAccessService {
         },
       });
 
-      if (!school || school.status === STATUS_INACTIVE) {
+      if (!school || school.status === StatusConstant.INACTIVE) {
         // Return only VIEW permissions
         return allPermissions.filter((perm) => perm.action === 'VIEW');
       }

package/src/module/user/repository/role.repository.ts

@@ -8,7 +8,7 @@ export class RoleRepository {
   constructor(
     @InjectRepository(Role)
     private readonly roleRepo: Repository<Role>,
-  ) {}
+  ) { }
 
   async findByCode(code: string): Promise<Role | null> {
     return this.roleRepo.findOne({ where: { code } });
@@ -98,7 +98,11 @@ export class RoleRepository {
     return await this.roleRepo.save(entity);
   }
 
-  async updateRole(id:number, role:Role) {
+  async updateRole(id: number, role: Role) {
     return await this.roleRepo.update(id, role);
   }
+
+  async findRoles(options: any): Promise<Role[]> {
+    return await this.roleRepo.find(options);
+  }
 }

package/src/module/user/repository/user-role-mapping.repository.ts

@@ -9,7 +9,7 @@ export class UserRoleMappingRepository {
   constructor(
     @InjectRepository(UserRoleMapping)
     private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
-  ) {}
+  ) { }
 
   async save(
     userRoleMapping: UserRoleMapping,
@@ -123,4 +123,8 @@ export class UserRoleMappingRepository {
       },
     });
   }
+
+  async find(options: any): Promise<UserRoleMapping[]> {
+    return await this.userRoleMappingRepository.find(options);
+  }
 }