rez_core 2.1.10 → 2.1.12

package/package.json

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

package/src/dtos/response.ts

@@ -0,0 +1,5 @@
+export interface ServiceResult<T = any> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}

package/src/module/filter/controller/filter.controller.ts

@@ -52,6 +52,7 @@ export class FilterController {
       user_id: userData.id,
       level_type: userData.level_type,
       level_id: userData.level_id,
+      appcode: userData.appcode,
     });
   }
 

package/src/module/filter/dto/filter-request.dto.ts

@@ -26,4 +26,5 @@ export interface FilterRequestDto {
   user_id?: string | null;
   level_type?: string | null;
   level_id?: string | null;
+  appcode?: string | null;
 }

package/src/module/filter/service/filter.service.ts

@@ -18,7 +18,7 @@ export class FilterService {
     @Inject('SavedFilterService')
     private readonly savedFilterService: SavedFilterService,
   ) {}
-  private readonly skipLevelFilterEntities = [];
+  private readonly skipLevelFilterEntities = ['ROL'];
 
   private async gettab_value_counts(
     tableName: string,
@@ -79,6 +79,7 @@ export class FilterService {
       user_id,
       level_type,
       level_id,
+      appcode,
     } = dto;
 
     // Fetch meta
@@ -138,6 +139,13 @@ export class FilterService {
       });
     }
 
+    if (this.skipLevelFilterEntities.includes(entity_type)) {
+      baseWhere.push({
+        query: 'e.appcode = :appcode',
+        params: { appcode },
+      });
+    }
+
     const layoutPreference = await this.dataSource.query(
       `SELECT layout_json
    FROM cr_layout_preference

package/src/module/listmaster/controller/list-master.controller.ts

@@ -1,13 +1,42 @@
-import { Body, Controller, HttpCode, HttpStatus, Param, Post, Query } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Param,
+  Post,
+  Query,
+  Request,
+  UseGuards,
+} from '@nestjs/common';
 import { ListMasterService } from '../service/list-master.service';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 
 @Controller('list-master')
 export class ListMasterController {
   constructor(private readonly service: ListMasterService) {}
 
   @Post('/getDropdownData/:type')
+  @UseGuards(JwtAuthGuard)
   @HttpCode(HttpStatus.OK)
-  async getDropdownData(@Param('type') type: string, @Body() params: Record<string, string>,) {
-    return await this.service.getDropdownOptions(type, params);
+  async getDropdownData(
+    @Param('type') type: string,
+    @Query() queryParams: Record<string, string>,
+    @Request() req,
+  ) {
+    const { inactiveIds, ...params } = queryParams;
+
+    const inactiveIdsArray = inactiveIds
+      ? inactiveIds.split(',').map((id) => parseInt(id, 10))
+      : [];
+
+    const loggedInUser = req.user.userData;
+
+    return await this.service.getDropdownOptions(
+      type,
+      params,
+      inactiveIdsArray,
+      loggedInUser,
+    );
   }
 }

package/src/module/listmaster/service/list-master.service.ts

@@ -11,6 +11,8 @@ import { firstValueFrom } from 'rxjs';
 import { HttpService } from '@nestjs/axios';
 import { EntityManager } from 'typeorm';
 import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { log } from 'console';
 
 @Injectable()
 export class ListMasterService {
@@ -23,14 +25,24 @@ export class ListMasterService {
     private readonly httpService: HttpService,
   ) {}
 
-  async getDropdownOptions(type: string, params: Record<string, string>) {
+  async getDropdownOptions(
+    type: string,
+    params: Record<string, string>,
+    inactiveIdsArray?: number[],
+    loggedInUser?: UserData,
+  ) {
     const config = await this.listMasterRepo.findByType(type);
 
     if (!config) throw new NotFoundException(`Type ${type} not found`);
 
     switch (config.source) {
       case 'entity':
-        return this.fetchFromEntity(type, params);
+        return this.fetchFromEntity(
+          type,
+          params,
+          inactiveIdsArray,
+          loggedInUser,
+        );
 
       case 'master':
         return this.listItemsRepo.findItemsByType(type);
@@ -46,25 +58,93 @@ export class ListMasterService {
   private async fetchFromEntity(
     sourceList: string,
     params: Record<string, any>,
+    inactiveIdsArray?: number[],
+    loggedInUser?: UserData,
   ) {
     let result: { label: string; value: number }[] = [];
-    const argsObjectList: any[] = [];
-    if (sourceList) {
-      const entityMaster =
-        await this.entityMasterService.getEntityData(sourceList);
+    if (!sourceList) return result;
+
+    const entityMaster =
+      await this.entityMasterService.getEntityData(sourceList);
+    const tableName = entityMaster.db_table_name;
+
+    const applyCommonFilters = (
+      qb: any,
+      status: 'active' | null = 'active',
+    ) => {
+      if (status) {
+        qb.where(`${tableName}.status = :status`, { status });
+      }
 
-      let query = `SELECT * FROM ${entityMaster.db_table_name} WHERE 1=1 `;
+      if (loggedInUser?.level_type && loggedInUser?.level_id) {
+        qb.andWhere(
+          `${tableName}.level_type = :levelType AND ${tableName}.level_id = :levelId`,
+          {
+            levelType: loggedInUser.level_type,
+            levelId: loggedInUser.level_id,
+          },
+        );
+      }
 
-      for (let paramsKey in params) {
-        query += `AND ${paramsKey} = ? `;
-        argsObjectList.push(params[paramsKey]);
+      if (loggedInUser?.appcode && sourceList === 'ROL') {
+        qb.andWhere(`${tableName}.appcode = :appcode`, {
+          appcode: loggedInUser.appcode,
+        });
       }
 
-      let results = await this.entityManager.query(query, argsObjectList);
-      results.forEach((r) => {
-        result.push({ label: r['name'], value: r['id'] });
+      for (const key in params) {
+        qb.andWhere(`${tableName}.${key} = :${key}`, {
+          [key]: params[key],
+        });
+      }
+
+      return qb;
+    };
+
+    // Fetch active records
+    const activeQuery = applyCommonFilters(
+      this.entityManager
+        .createQueryBuilder()
+        .select('*')
+        .from(tableName, tableName),
+      'active',
+    );
+
+    const activeResults = await activeQuery.getRawMany();
+    const activeIds = new Set(activeResults.map((r) => r.id));
+
+    // Add active entries first
+    activeResults.forEach((r) => {
+      result.push({ label: r.name, value: r.id });
+    });
+
+    // Fetch inactive records (with same filters but without status condition)
+    if (inactiveIdsArray?.length) {
+      const inactiveQuery = applyCommonFilters(
+        this.entityManager
+          .createQueryBuilder()
+          .select('*')
+          .from(tableName, tableName),
+        null, // exclude status filter
+      );
+
+      inactiveQuery.andWhere(`${tableName}.id IN (:...ids)`, {
+        ids: inactiveIdsArray,
+      });
+
+      const inactiveResults = await inactiveQuery.getRawMany();
+
+      // Add only those inactive records not already present in active
+      inactiveResults.forEach((item) => {
+        if (!activeIds.has(item.id)) {
+          result.push({
+            label: `${item.name}_INACTIVE`,
+            value: item.id,
+          });
+        }
       });
     }
+
     return result;
   }
 

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

@@ -67,37 +67,61 @@ export class EntityController {
     @Res() res: Response,
     @Req() req: Request & { user: any },
   ) {
-    let requestedUser = req.user.userData;
-    let appcode = requestedUser.appcode;
-    // let loggedInUser = await this.entityService.getEntityData(
-    //   ENTITYTYPE_USER,
-    //   requestedUser.userId,
-    // );
-    let loggedInUser = req.user.userData;
-    if (!entityType) {
-      throw new BadRequestException(
-        'Query parameter "entity_type" is required',
-      );
-    }
-    const entityMaster =
-      await this.entityMasterService.getEntityData(entityType);
+    try {
+      let requestedUser = req.user.userData;
+      let appcode = requestedUser.appcode;
+      // let loggedInUser = await this.entityService.getEntityData(
+      //   ENTITYTYPE_USER,
+      //   requestedUser.userId,
+      // );
+      let loggedInUser = req.user.userData;
+      if (!entityType) {
+        // throw new BadRequestException(
+        //   'Query parameter "entity_type" is required',
+        // );
 
-    const entityService =
-      await this.reflectionHelper.getBean<EntityServiceImpl>(
-        entityMaster.entity_service,
-      );
+        return res.status(HttpStatus.BAD_REQUEST).json({
+          success: false,
+          error: 'Query parameter "entity_type" is required',
+        });
+      }
+      const entityMaster =
+        await this.entityMasterService.getEntityData(entityType);
 
-    if (entityService) {
-      return res
-        .status(HttpStatus.OK)
-        .json(
-          await entityService.createEntity(
-            entityData,
-            loggedInUser as UserData,
-            null,
-            appcode,
-          ),
+      const entityService =
+        await this.reflectionHelper.getBean<EntityServiceImpl>(
+          entityMaster.entity_service,
         );
+
+      if (!entityService) {
+        return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+          success: false,
+          error: `No service found for entity_type "${entityType}"`,
+        });
+      }
+      const createdEntity = await entityService.createEntity(
+        entityData,
+        loggedInUser as UserData,
+        null,
+        appcode,
+      );
+
+      if (!createdEntity || !createdEntity.success) {
+        return res.status(HttpStatus.BAD_REQUEST).json({
+          success: false,
+          error: createdEntity?.error || 'Entity creation failed',
+        });
+      }
+
+      return res.status(HttpStatus.OK).json({
+        success: true,
+        data: createdEntity.data,
+      });
+    } catch (error) {
+      return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+        success: false,
+        error: error.message || 'Internal server error',
+      });
     }
   }
 
@@ -109,34 +133,64 @@ export class EntityController {
     @Res() response: Response,
     @Req() req: Request & { user: any },
   ) {
-    let loggedInUser = req.user.userData;
-    // let loggedInUser = await this.entityService.getEntityData(
-    //   ENTITYTYPE_USER,
-    //   requestedUser.userId,
-    // );
-    if (!entityType) {
-      throw new BadRequestException(
-        'Query parameter "entity_type" is required',
-      );
-    }
+    try {
+      let loggedInUser = req.user.userData;
+      // let loggedInUser = await this.entityService.getEntityData(
+      //   ENTITYTYPE_USER,
+      //   requestedUser.userId,
+      // );
+      if (!entityType) {
+        return response.status(HttpStatus.BAD_REQUEST).json({
+          success: false,
+          error: 'Query parameter "entity_type" is required',
+        });
+      }
+
+      const entityMaster =
+        await this.entityMasterService.getEntityData(entityType);
+
+      const entityService =
+        await this.reflectionHelper.getBean<EntityServiceImpl>(
+          entityMaster.entity_service,
+        );
+
+      if (!entityService) {
+        return response.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+          success: false,
+          error: `No service found for entity_type "${entityType}"`,
+        });
+      }
 
-    const entityMaster =
-      await this.entityMasterService.getEntityData(entityType);
-    const entityService =
-      await this.reflectionHelper.getBean<EntityServiceImpl>(
-        entityMaster.entity_service,
-      );
-    if (entityService) {
       let existingEntity = await entityService.getEntityData(entityType, id);
       if (!existingEntity) {
+        return response.status(HttpStatus.NOT_FOUND).json({
+          success: false,
+          error: `No entity found for id "${id}"`,
+        });
       }
       // let mergeEntity = JsonUtil.merge(existingEntity, entityData);
 
-      entityData = await entityService.updateEntity(
+      const updatedEntity = await entityService.updateEntity(
         entityData,
         loggedInUser as UserData,
       );
-      return response.status(HttpStatus.OK).json(entityData);
+
+      if (!updatedEntity || !updatedEntity.success) {
+        return response.status(HttpStatus.BAD_REQUEST).json({
+          success: false,
+          error: updatedEntity?.error || 'Entity creation failed',
+        });
+      }
+
+      return response.status(HttpStatus.OK).json({
+        success: true,
+        data: updatedEntity.data,
+      });
+    } catch (error) {
+      return response.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+        success: false,
+        error: error.message || 'Internal server error',
+      });
     }
   }
 

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

@@ -45,8 +45,8 @@ export class ModuleAccessController {
   ) {
     const roleIdArray = roleIds.split(',').map(Number);
     const appcode = queryAppcode || req.user.userData.appcode;
-    const level_type =  req.user.userData.appcode;
-    const level_id =  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, appcode, level_type, level_id);
   }
 
@@ -68,10 +68,8 @@ export class ModuleAccessController {
 
   @Post('update')
   async updateModuleAccess(@Body() moduleAccessData: any[], @Request() req) {
-    const appcode = req.user.userData.appcode;
     return this.moduleAccessService.updateModuleAccess(
-      moduleAccessData,
-      appcode,
+      moduleAccessData
     );
   }
 
@@ -95,4 +93,27 @@ export class ModuleAccessController {
       roles.map((id) => Number(id)),
     );
   }
+
+  @Get('user-permissions')
+  async getUserPermissions(@Request() req) {
+    const userData = req.user.userData;
+  
+    const userId = userData?.id;
+    const appcode = userData?.appcode;
+    const level_type = userData?.level_type;
+    const level_id = userData?.level_id;
+  
+    if (!userId || !appcode || !level_type || !level_id) {
+      throw new BadRequestException('Invalid token data');
+    }
+  
+    return this.moduleAccessService.getUserPermissions({
+      userId,
+      appcode,
+      level_type,
+      level_id,
+    });
+  }
+  
+
 }

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

@@ -1,6 +1,6 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { In, Not, Repository , IsNull} 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';
@@ -21,10 +21,13 @@ export class ModuleAccessRepository {
 
     @InjectRepository(ModuleAction)
     private readonly moduleActionRepo: Repository<ModuleAction>,
+
+    private readonly dataSource: DataSource,
   ) {}
 
  
 
+
   async getRoles({
     appcode,
     level_type,
@@ -34,15 +37,23 @@ export class ModuleAccessRepository {
     level_type?: string;
     level_id?: number;
   }) {
-    const where: any = {
-      appcode,
-      is_factory: [Not(1), IsNull()], // Include NULL or anything not 1
-    };
+    const query = this.dataSource
+      .createQueryBuilder()
+      .select('*')
+      .from('cr_role', 'role')
+      .where('role.appcode = :appcode', { appcode })
+      .andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
+  
+      
+    if (level_type) {
+      query.andWhere('role.level_type = :level_type', { level_type });
+    }
   
-    if (level_type) where.level_type = level_type;
-    if (level_id !== undefined) where.level_id = String(level_id);
+    if (level_id !== undefined) {
+      query.andWhere('role.level_id = :level_id', { level_id: String(level_id) });
+    }
   
-    const roles = await this.roleRepo.find({ where });
+    const roles = await query.getRawMany(); // use getRawMany since you're selecting from a raw table
   
     return roles.map((role) => ({
       label: role.name,
@@ -50,6 +61,7 @@ export class ModuleAccessRepository {
     }));
   }
   
+  
 
   async getModules({ appcode }: { appcode: string }) {
     const modules = await this.moduleRepo.find({
@@ -73,7 +85,7 @@ export class ModuleAccessRepository {
   ) {
     let roles;
   
-    if (roleIds.length === 1 && roleIds[0] === '-1') {
+    if (roleIds.length === 1 && roleIds[0] === -1) {
       // Internally call getRoles
       const fetchedRoles = await this.getRoles({
         appcode,
@@ -118,6 +130,7 @@ export class ModuleAccessRepository {
           access: access.access_flag,
           code: access.module_code,
           level_type: access.level_type,
+          appcode: access.appcode,
         })),
     }));
   }
@@ -214,8 +227,7 @@ export class ModuleAccessRepository {
       access_flag: number;
       appcode: string;
       level_type: string;
-    }[],
-    appcode: string,
+    }[]
   ): Promise<boolean> {
     try {
       for (const access of accessList) {
@@ -224,7 +236,7 @@ export class ModuleAccessRepository {
             role_code: access.role_code,
             module_code: access.module_code,
             action_type: access.action_type,
-            appcode: access.appcode || appcode,
+            appcode: access.appcode,
             level_type: access.level_type,
           },
         });
@@ -234,10 +246,7 @@ export class ModuleAccessRepository {
           await this.moduleAccessRepo.save(existing);
         } else {
           await this.moduleAccessRepo.save(
-            this.moduleAccessRepo.create({
-              ...access,
-              appcode: access.appcode || appcode,
-            }),
+           await this.moduleAccessRepo.create(access),
           );
         }
       }
@@ -275,4 +284,34 @@ export class ModuleAccessRepository {
       action: uniqueActions,
     };
   }
+  async getModuleAccessByRoles(roleIds: number[], appcode: string) {
+    // Step 1: Get role codes from cr_role
+    const roles = await this.roleRepo.find({
+      where: {
+        id: In(roleIds),
+        appcode,
+      },
+      select: ['id', 'code'], // fetch only needed fields
+    });
+  
+    const roleCodes = roles.map((r) => r.code);
+  
+    if (!roleCodes.length) return [];
+  
+    // Step 2: Use role codes to fetch access entries
+    return this.moduleAccessRepo
+      .createQueryBuilder('access')
+      .select([
+        'access.module_code',
+        'access.action_type',
+        'access.access_flag',
+        'access.role_code',
+      ])
+      .where('access.role_code IN (:...roleCodes)', { roleCodes })
+      .andWhere('access.appcode = :appcode', { appcode })
+      .getRawMany();
+  }
+  
+  
 }
+

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

@@ -15,6 +15,15 @@ export class ModuleAccessService {
     private readonly menuRepository: MenuRepository,
     private readonly dataSource: DataSource,
   ) {}
+  
+
+  async getModules({ appcode }: { appcode: string }) {
+    return this.moduleAccessRepository.getModules({
+      appcode,
+    });
+  }
+
+  
   async getRoles({
     appcode,
     level_type,
@@ -48,13 +57,6 @@ export class ModuleAccessService {
     }));
   }
   
-  
-
-  async getModules({ appcode }: { appcode: string }) {
-    return this.moduleAccessRepository.getModules({
-      appcode,
-    });
-  }
   async getAccessListing(
     roleIds: number[],
     appcode: string,
@@ -94,7 +96,6 @@ export class ModuleAccessService {
       appcode: string;
       level_type: string;
     }[],
-    appcode: string,
   ): Promise<{ success: boolean; msg: string }> {
     if (!moduleAccessData || moduleAccessData.length === 0) {
       return { success: false, msg: 'No data provided' };
@@ -102,7 +103,6 @@ export class ModuleAccessService {
 
     const result = await this.moduleAccessRepository.updateModuleAccess(
       moduleAccessData,
-      appcode,
     );
 
     if (result) {
@@ -117,4 +117,32 @@ export class ModuleAccessService {
   async getModuleUIConfig(moduleCode: string, roleIds: number[]) {
     return this.moduleAccessRepository.getModuleUIConfig(moduleCode, roleIds);
   }
+
+  async getUserPermissions({
+    userId,
+    appcode,
+    level_type,
+    level_id,
+  }: {
+    userId: number;
+    appcode: string;
+    level_type: string;
+    level_id: number;
+  }) {
+    const roleCodes = await this.menuRepository.resolveUserRoles(
+      userId,
+      appcode,
+      level_type,
+      level_id,
+    );
+  
+    if (!roleCodes || roleCodes.length === 0) {
+      return [];
+    }
+  
+    const roleIds = roleCodes.map(Number);
+    return this.moduleAccessRepository.getModuleAccessByRoles(roleIds, appcode);
+  }
+  
+  
 }