rez_core 2.1.6 → 2.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.1.6",
+  "version": "2.1.11",
   "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/master/service/master.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { Brackets, EntityManager } from 'typeorm';
 import { ExcelUtil } from 'src/utils/service/excelUtil.service';
 import { EntityMasterService } from '../../meta/service/entity-master.service';
@@ -199,8 +199,6 @@ export class MasterService {
     loggedInUser,
     duplicateHandling: 'skip_duplicates' | 'overwrite_items',
   ) {
-    const errors: { row: number; errors: any[] }[] = [];
-
     const data = ExcelUtil.readExcel(file.buffer);
     const entityMaster =
       await this.entityMasterService.findByMappedEntityType(entityType);
@@ -218,7 +216,6 @@ export class MasterService {
       await this.attributeMasterService.findAttributesByMappedEntityType(
         entityType,
       );
-
     const uniqueFields = attributes
       .filter((attr) => attr.is_unique)
       .map((attr) => attr.attribute_key);
@@ -227,71 +224,30 @@ export class MasterService {
       throw new Error(`No unique fields found for entityType: ${entityType}`);
     }
 
-    for (const [i, row] of sheetData.entries()) {
+    for (const row of sheetData) {
       if (row.parent_type && row.parent_id) {
         await this.resolveParent(row);
       }
 
       for (const attr of attributes) {
         if (attr.data_source_type === 'entity' && row[attr.attribute_key]) {
-          try {
-            const refEntity = await this.entityMasterService.getEntityData(
-              attr.datasource_list,
-            );
-
-            const refData = await this.entityManager.query(
-              `SELECT * FROM ${refEntity.db_table_name} WHERE code = ? LIMIT 1`,
-              [row[attr.attribute_key]],
+          const refEntity = await this.entityMasterService.getEntityData(
+            attr.datasource_list,
+          );
+          const refData = await this.entityManager.query(
+            `SELECT * FROM ${refEntity.db_table_name} WHERE code = ? LIMIT 1`,
+            [row[attr.attribute_key]],
+          );
+
+          //you will check the org id of refData and loggedInUser.organization_id
+
+          if (!refData.length) {
+            throw new Error(
+              `Reference entity not found for code: ${row[attr.attribute_key]}`,
             );
-
-            if (!refData.length) {
-              errors.push({
-                row: i + 1,
-                errors: [
-                  {
-                    field: attr.name,
-                    message: `Reference entity not found for code: ${row[attr.attribute_key]}`,
-                  },
-                ],
-              });
-              continue;
-            }
-
-            const existingError = errors.find((e) => e.row === i + 1);
-
-            if (refData[0].organization_id !== loggedInUser.organization_id) {
-              if (existingError) {
-                existingError.errors.push({
-                  field: attr.name,
-                  message: `Reference entity not found for code: ${row[attr.attribute_key]} does not belong to the organization`,
-                });
-                continue;
-              } else {
-                errors.push({
-                  row: i + 1,
-                  errors: [
-                    {
-                      field: attr.name,
-                      message: `Reference entity with code ${row[attr.attribute_key]} does not belong to the organization`,
-                    },
-                  ],
-                });
-                continue;
-              }
-            }
-
-            row[attr.attribute_key] = refData[0].id;
-          } catch (err) {
-            errors.push({
-              row: i + 1,
-              errors: [
-                {
-                  field: attr.name,
-                  message: `Error fetching reference entity for ${attr.attribute_key}`,
-                },
-              ],
-            });
           }
+
+          row[attr.attribute_key] = refData[0].id;
         }
       }
     }
@@ -303,7 +259,6 @@ export class MasterService {
       uniqueFields,
       loggedInUser,
       duplicateHandling,
-      errors,
     );
 
     return { message: 'Entity data uploaded successfully' };
@@ -394,7 +349,6 @@ export class MasterService {
     uniqueFields: string[],
     loggedInUser: any,
     duplicateHandling: 'skip_duplicates' | 'overwrite_items',
-    errors: { row: number; errors: any[] }[],
   ): Promise<void> {
     const entityMaster =
       await this.entityMasterService.findByMappedEntityType(entityType);
@@ -407,39 +361,13 @@ export class MasterService {
     if (!entityService)
       throw new Error(`Entity service not found for ${entityType}`);
 
+    const errors: { row: number; errors: any[] }[] = [];
+
     for (const [i, row] of data.entries()) {
       row.entity_type = entityType;
       row.organization_id = loggedInUser.organization_id;
 
-      const rowErrors = await this.entityValidationService.validateEntityData(
-        row,
-        entityMaster,
-        loggedInUser,
-      );
-
-      const existingError = errors.find((e) => e.row === i + 1);
-
-      if (rowErrors?.length > 0) {
-        if (existingError) {
-          existingError.errors.push(...rowErrors);
-        } else {
-          errors.push({
-            row: i + 1,
-            errors: rowErrors,
-          });
-        }
-      }
-    }
-
-    if (errors.length > 0) {
-      throw new BadRequestException({
-        status: false,
-        message: `Validation errors found in the uploaded data.`,
-        error: errors,
-      });
-    }
-
-    for (const row of data) {
+      // 🧠 Check if this already exists
       const qb = this.entityManager
         .createQueryBuilder()
         .select('*')
@@ -476,6 +404,24 @@ export class MasterService {
           await entityService.updateEntity(row, loggedInUser);
         }
       } else {
+        const rowErrors = await this.entityValidationService.validateEntityData(
+          row,
+          entityMaster,
+          loggedInUser,
+        );
+
+        if (rowErrors && rowErrors.length > 0) {
+          errors.push({
+            row: i + 1,
+            errors: rowErrors,
+          });
+        }
+
+        if (errors.length > 0) {
+          throw new Error(
+            `Validation errors found in the uploaded data: ${JSON.stringify(errors)}`,
+          );
+        }
         await entityService.createEntity(row, loggedInUser);
       }
     }

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
     );
   }