rez_core 2.1.75 → 2.1.76

package/package.json

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

package/src/constant/global.constant.ts

@@ -15,7 +15,6 @@ export const ENTITYTYPE_USRROLMAP = 'URM';
 export const ENTITYTYPE_SAVEDFILTERMASTER = 'SFM';
 export const ENTITYTYPE_SAVEDFILTERDETAIL = 'SFD';
 
-
 export const STORAGETYPE_SINGLEJSON = 'singlejson';
 export const STORAGETYPE_COLUMN = 'column';
 
@@ -23,8 +22,8 @@ export const STORAGETYPE_COLUMN = 'column';
 export const secretKey: string = process.env.secret_key || '';
 
 // STATUS
-export const STATUS_ACTIVE = 'ACTIVE';
-export const STATUS_INACTIVE = 'INACTIVE';
+export const STATUS_ACTIVE = 'STATUS_ACTIVE';
+export const STATUS_INACTIVE = 'STATUS_INACTIVE';
 export const STATUS_PENDING = 'PENDING';
 
 // Entity Status
@@ -34,4 +33,4 @@ export const ENTITYSTATUS_PUBLISHED = 'published';
 // Display Type
 export const DISPLAY_LIST = 'LIST';
 export const DISPLAY_EXPORT = 'EXPORT';
-export const DISPLAY_REPORT = 'REPORT';
+export const DISPLAY_REPORT = 'REPORT';

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

@@ -13,8 +13,6 @@ import * as moment from 'moment';
 export class FilterService {
   constructor(
     private dataSource: DataSource,
-    private readonly entityMasterService: EntityMasterService,
-    private readonly attributeMasterService: AttributeMasterService,
     private readonly entityTableService: EntityTableService,
     private readonly entityTableColumnService: EntityTableColumnService,
     @Inject('SavedFilterService')
@@ -91,7 +89,10 @@ export class FilterService {
     } = loggedInUser || {};
 
     // Fetch meta
-    const entityMeta = await this.entityTableService.getEntityData(entity_type);
+    const entityMeta = await this.entityTableService.getEntityData(
+      entity_type,
+      loggedInUser,
+    );
     const tableName = entityMeta?.data_source; // data_souce is the table name
     if (!tableName)
       throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
@@ -101,6 +102,7 @@ export class FilterService {
         entity_type,
         entity_type,
         'LIST',
+        organization_id,
       );
 
     if (!getTableMeta) {

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

@@ -78,6 +78,7 @@ export class SavedFilterService extends EntityServiceImpl {
     const existing = await this.getEntityData(
       ENTITYTYPE_SAVEDFILTERMASTER,
       master.id,
+      loggedInUser,
     );
 
     if (!existing) {
@@ -119,9 +120,11 @@ export class SavedFilterService extends EntityServiceImpl {
     return updated;
   }
 
-  async deleteEntity(entityType: string, entityId: number) {
-    const entityMaster =
-      await this.entityMasterService.getEntityData(entityType);
+  async deleteEntity(entityType: string, entityId: number, loggedInUser) {
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
 
     const repoService = this.reflectionHelper.getRepoService(
       entityMaster.entity_data_class,

package/src/module/layout_preference/controller/layout_preference.controller.ts

@@ -31,12 +31,13 @@ export class LayoutPreferenceController {
     @Query('sort_by') sort_by: string,
     @Req() req: Request & { user: any },
   ) {
-    const userId = req.user.userData.id;
+    const userData = req.user.userData;
 
     return this.layoutPreferenceService.getColumnValue(
       entity_type,
       column,
       sort_by,
+      userData,
     );
   }
 }

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

@@ -14,7 +14,7 @@ export class LayoutPreferenceService extends EntityServiceImpl {
     super();
   }
 
-  async createEntity(entityData: BaseEntity, loggedInUser: UserData | null) {
+  async createEntity(entityData: BaseEntity, loggedInUser: UserData) {
     console.log('lap api called', entityData);
 
     const { mapped_entity_type } = entityData as any;
@@ -54,12 +54,14 @@ export class LayoutPreferenceService extends EntityServiceImpl {
     entity_type: string,
     column: string,
     sort_by: string,
+    loggedInUser: UserData,
   ): Promise<string[]> {
     const getTableMeta =
       await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
         entity_type,
         entity_type,
         'LIST',
+        loggedInUser?.organization_id,
       );
 
     const tableName = getTableMeta?.data_source;

package/src/module/listmaster/repository/list-master-items.repository.ts

@@ -20,14 +20,30 @@ export class ListMasterItemsRepository {
     return this.repo.findOne({ where: { id } });
   }
 
-  async findItemsByType(type: string) {
+  async findItemsByType(type: string, organizationId?: number) {
     const items = await this.repo.find({
-      where: { listtype: type, status: 'active' },
+      where: {
+        listtype: type,
+        organization_id: organizationId,
+        status: 'ACTIVE',
+      },
       order: { sortindex: 'ASC' },
     });
     return items.map((i) => ({ label: i.name, value: i.id }));
   }
 
+  async findItemByCode(
+    code: string,
+    organizationId?: number,
+  ): Promise<ListMasterItems | null> {
+    return this.repo.findOne({
+      where: {
+        code: code,
+        organization_id: organizationId,
+      },
+    });
+  }
+
   async findAllItemsByListType(
     type: string,
     sortBy: string,

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

@@ -10,8 +10,13 @@ export class ListMasterRepository {
     private readonly repo: Repository<ListMasterData>,
   ) {}
 
-  findByType(type: string) {
-    return this.repo.findOne({ where: { type } });
+  findByType(type: string, organizationId?: number) {
+    return this.repo.findOne({
+      where: {
+        type: type,
+        organization_id: organizationId,
+      },
+    });
   }
 
   // much better generic find method

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

@@ -30,13 +30,32 @@ export class ListMasterService {
 
   private readonly skipLevelFilterEntities = ['BRN'];
 
+  async getResolvedListCode(
+    code: string,
+    organization_id: number,
+  ): Promise<any> {
+    if (!code) return code;
+
+    // Check if it's a valid list type
+    const listMaster = await this.listItemsRepo.findItemByCode(
+      code,
+      organization_id,
+    );
+    if (listMaster) {
+      return listMaster;
+    }
+  }
+
   async getDropdownOptions(
     type: string,
     params: Record<string, string>,
     inactiveIdsArray?: number[],
-    loggedInUser?: UserData,
+    loggedInUser?,
   ) {
-    const config = await this.listMasterRepo.findByType(type);
+    const config = await this.listMasterRepo.findByType(
+      type,
+      loggedInUser?.organization_id,
+    );
 
     if (!config) throw new NotFoundException(`Type ${type} not found`);
 
@@ -50,7 +69,10 @@ export class ListMasterService {
         );
 
       case 'master':
-        return this.listItemsRepo.findItemsByType(type);
+        return this.listItemsRepo.findItemsByType(
+          type,
+          loggedInUser?.organization_id,
+        );
 
       case 'custom':
         return this.fetchFromExternalSource(config.custom_source_id, params);
@@ -60,7 +82,6 @@ export class ListMasterService {
     }
   }
 
-
   private async fetchFromEntity(
     sourceList: string,
     params: Record<string, any>,
@@ -70,8 +91,10 @@ export class ListMasterService {
     let result: { label: string; value: number }[] = [];
     if (!sourceList) return result;
 
-    const entityMaster =
-      await this.entityMasterService.getEntityData(sourceList);
+    const entityMaster = await this.entityMasterService.getEntityData(
+      sourceList,
+      loggedInUser,
+    );
     const tableName = entityMaster.db_table_name;
 
     const applyCommonFilters = (
@@ -297,8 +320,16 @@ export class ListMasterService {
     return await this.entityServiceImpl.updateEntity(entityData, loggedInUser);
   }
 
-  async getEntityData(entity_type: string, id: number): Promise<any> {
-    return await this.entityServiceImpl.getEntityData(entity_type, id);
+  async getEntityData(
+    entity_type: string,
+    id: number,
+    loggedInUser,
+  ): Promise<any> {
+    return await this.entityServiceImpl.getEntityData(
+      entity_type,
+      id,
+      loggedInUser,
+    );
   }
 
   async getAllListMasterByOrganization(

package/src/module/master/controller/master.controller.ts

@@ -21,13 +21,13 @@ import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 @Controller('master')
 @UseGuards(JwtAuthGuard)
 export class MasterController {
-  constructor(private readonly masterService: MasterService,
-   private readonly entityService: EntityServiceImpl,
+  constructor(
+    private readonly masterService: MasterService,
+    private readonly entityService: EntityServiceImpl,
   ) {}
 
   @Post('uploadMeta')
   @UseInterceptors(FileInterceptor('file'))
-
   async uploadMasterMetaXls(@UploadedFile() file: Express.Multer.File) {
     if (!file) {
       throw new BadRequestException('File is required');
@@ -37,12 +37,15 @@ export class MasterController {
 
   @Post('uploadData')
   @UseInterceptors(FileInterceptor('file'))
-
-  async uploadMasterDataXls(@UploadedFile() file: Express.Multer.File) {
+  async uploadMasterDataXls(
+    @UploadedFile() file: Express.Multer.File,
+    @Req() req: Request & { user: any },
+  ) {
+    let loggedInUser = req.user.userData;
     if (!file) {
       throw new BadRequestException('File is required');
     }
-    return await this.masterService.uploadData(file.buffer);
+    return await this.masterService.uploadData(file.buffer, loggedInUser);
   }
 
   @Post('uploadEntity/:entityType')
@@ -51,16 +54,21 @@ export class MasterController {
     @Param('entityType') entityType: string,
     @UploadedFile() file: Express.Multer.File,
     @Req() req: Request & { user: any },
-    @Body('duplicateHandling') duplicateHandling: 'skip_duplicates' | 'overwrite_items',
+    @Body('duplicateHandling')
+    duplicateHandling: 'skip_duplicates' | 'overwrite_items',
   ) {
     let loggedInUser = req.user.userData;
     // let loggedInUser = await this.entityService.getEntityData(ENTITYTYPE_USER, requestedUser.userId);
-  
+
     if (!file) {
       throw new BadRequestException('File is required');
     }
-  
-    return await this.masterService.uploadEntityData(file.buffer, entityType, loggedInUser, duplicateHandling);
+
+    return await this.masterService.uploadEntityData(
+      file.buffer,
+      entityType,
+      loggedInUser,
+      duplicateHandling,
+    );
   }
-  
 }

package/src/module/master/service/master.service.ts

@@ -146,7 +146,7 @@ export class MasterService {
     };
   }
 
-  async uploadData(file) {
+  async uploadData(file, loggedInUser) {
     const data = ExcelUtil.readExcel(file.buffer);
 
     for (let i = 0; i < this.dataSequence.length; i++) {
@@ -164,6 +164,7 @@ export class MasterService {
       const attributes =
         await this.attributeMasterService.findAttributesByMappedEntityType(
           entityMasterData?.mapped_entity_type,
+          loggedInUser.organization_id,
         );
 
       for (const row of sheetData) {
@@ -175,6 +176,7 @@ export class MasterService {
           if (attribute.data_source_type === 'entity') {
             let entityMaster = await this.entityMasterService.getEntityData(
               attribute.datasource_list,
+              loggedInUser,
             );
             const entityData = await this.entityManager.query(
               `SELECT * FROM ${entityMaster.db_table_name} WHERE code = ? LIMIT 1`,
@@ -215,6 +217,7 @@ export class MasterService {
     const attributes =
       await this.attributeMasterService.findAttributesByMappedEntityType(
         entityType,
+        loggedInUser.organization_id,
       );
     const uniqueFields = attributes
       .filter((attr) => attr.is_unique)
@@ -233,6 +236,7 @@ export class MasterService {
         if (attr.data_source_type === 'entity' && row[attr.attribute_key]) {
           const refEntity = await this.entityMasterService.getEntityData(
             attr.datasource_list,
+            loggedInUser,
           );
           const refData = await this.entityManager.query(
             `SELECT * FROM ${refEntity.db_table_name} WHERE code = ? LIMIT 1`,

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

@@ -41,15 +41,20 @@ export class EntityController {
   // @Roles('USR', 'VIEW')
   async getById(
     @Param('id') id: number,
+    @Req() req: Request & { user: any },
     @Query('entity_type') entityType?: string,
   ) {
+    const loggedInUser = req.user.userData;
+
     if (!entityType) {
       throw new BadRequestException(
         'Query parameter "entity_type" is required',
       );
     }
-    const entityMaster =
-      await this.entityMasterService.getEntityData(entityType);
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
 
     const entityService =
       await this.reflectionHelper.getBean<EntityServiceImpl>(
@@ -57,7 +62,7 @@ export class EntityController {
       );
 
     if (entityService) {
-      return await entityService.getEntityData(entityType, id);
+      return await entityService.getEntityData(entityType, id, loggedInUser);
     }
   }
 
@@ -77,8 +82,10 @@ export class EntityController {
       );
     }
 
-    const entityMaster =
-      await this.entityMasterService.getEntityData(entityType);
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
     const entityService =
       await this.reflectionHelper.getBean<EntityServiceImpl>(
         entityMaster.entity_service,
@@ -114,8 +121,10 @@ export class EntityController {
       );
     }
 
-    const entityMaster =
-      await this.entityMasterService.getEntityData(entityType);
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
 
     const entityService =
       await this.reflectionHelper.getBean<EntityServiceImpl>(
@@ -128,7 +137,12 @@ export class EntityController {
       );
     }
 
-    const existingEntity = await entityService.getEntityData(entityType, id);
+    const existingEntity = await entityService.getEntityData(
+      entityType,
+      id,
+      loggedInUser,
+    );
+
     if (!existingEntity) {
       throw new NotFoundException(`No entity found for id "${id}"`);
     }
@@ -159,8 +173,10 @@ export class EntityController {
       );
     }
 
-    const entityMaster =
-      await this.entityMasterService.getEntityData(entityType);
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
 
     const entityService =
       await this.reflectionHelper.getBean<EntityServiceImpl>(
@@ -173,12 +189,17 @@ export class EntityController {
       );
     }
 
-    const existingEntity = await entityService.getEntityData(entityType, id);
+    const existingEntity = await entityService.getEntityData(
+      entityType,
+      id,
+      loggedInUser,
+    );
+
     if (!existingEntity) {
       throw new NotFoundException(`No entity found for id "${id}"`);
     }
 
-    return await entityService.deleteEntity(entityType, id);
+    return await entityService.deleteEntity(entityType, id, loggedInUser);
   }
 
   @Post('getFilteredDataWithTabs/:entity_type')

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

@@ -7,6 +7,7 @@ import {
   Get,
   Param,
   UseGuards,
+  Req,
 } from '@nestjs/common';
 import { MediaDataService } from '../service/media-data.service';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
@@ -29,11 +30,15 @@ export class MediaController {
       mapped_entity_type?: string;
       mapped_entity_id?: number;
     },
+    @Req() req: Request & { user: any },
     @Res() res: Response,
   ) {
+    const loggedInUser = req.user.userData;
+
     let result = await this.mediaDataService.generateMediaUploadDetails(
       body.file_name,
       body.attribute_key,
+      loggedInUser,
       body.mapped_entity_type,
       body.mapped_entity_id,
     );
@@ -50,15 +55,21 @@ export class MediaController {
 
   // Method to fetch the download URL for a media file
   @Get('download/:id')
-  async getDownloadUrl(@Param('id') id: number, @Res() res: Response) {
+  async getDownloadUrl(
+    @Param('id') id: number,
+    @Res() res: Response,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
     try {
-      
-  
-      const data = await this.mediaDataService.getMediaDownloadUrl(id);
+      const downloadUrl = await this.mediaDataService.getMediaDownloadUrl(
+        id,
+        loggedInUser,
+      );
       res.status(HttpStatus.OK).json({
         message: 'Download URL fetched successfully',
         success: true,
-        data:data,
+        data: downloadUrl,
       });
     } catch (error) {
       res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({

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

@@ -23,12 +23,12 @@ export class MetaController {
     @Res() response: Response,
     @Req() req: Request & { user: any },
   ) {
-    const userId = req.user.userData?.id;
+    const loggedInUser = req.user.userData;
     let entityTableDto =
       await this.entityTableService.getTableMetaDataForListing(
         entityType,
         listType,
-        userId,
+        loggedInUser,
       );
     return response.status(HttpStatus.OK).json({
       success: true,

package/src/module/meta/repository/attribute-master.repository.ts

@@ -26,13 +26,15 @@ export class AttributeMasterRepository {
     });
   }
 
-
-  async findAttributesByMappedEntityType(entityType: string): Promise<AttributeMaster[]> {
+  async findAttributesByMappedEntityType(
+    entityType: string,
+    organizationId: number,
+  ): Promise<AttributeMaster[]> {
     return await this.attributeMasterRepository.find({
       where: {
         mapped_entity_type: In([entityType, 'DEF']),
+        organization_id: organizationId,
       },
     });
   }
-  
 }

package/src/module/meta/repository/entity-table.repository.ts

@@ -17,9 +17,16 @@ export class EntityTableRepository {
     return temp;
   }
 
-  async findByMappedEntityType(mappedEntityType: string) {
+  async findByMappedEntityType(
+    mappedEntityType: string,
+    organization_id: number,
+  ) {
     return await this.entityTableRepository.findOne({
-      where: { mapped_entity_type: mappedEntityType, display_type: 'LIST' },
+      where: {
+        mapped_entity_type: mappedEntityType,
+        display_type: 'LIST',
+        organization_id: organization_id,
+      },
     });
   }
 
@@ -27,12 +34,20 @@ export class EntityTableRepository {
     entityType: string,
     listType: string,
     displayType: string,
+    organization_id: number | null = null,
   ) {
+    const whereCondition: any = {
+      mapped_entity_type: entityType,
+      list_type: listType,
+      display_type: displayType,
+    };
+    if (organization_id !== null) {
+      whereCondition.organization_id = organization_id;
+    }
+
     return await this.entityTableRepository.findOne({
       where: {
-        mapped_entity_type: entityType,
-        list_type: listType,
-        display_type: displayType,
+        ...whereCondition,
       },
     });
   }

package/src/module/meta/service/attribute-master.service.ts

@@ -9,9 +9,10 @@ export class AttributeMasterService {
     private readonly attributeMasterRepository: AttributeMasterRepository,
   ) {}
 
-  async findAttributesByMappedEntityType(entity_type) {
+  async findAttributesByMappedEntityType(entity_type, organization_id) {
     return await this.attributeMasterRepository.findAttributesByMappedEntityType(
       entity_type,
+      organization_id,
     );
   }
 }

package/src/module/meta/service/entity-master.service.ts

@@ -10,10 +10,16 @@ export class EntityMasterService {
     private entityMasterRepository: Repository<EntityMaster>,
   ) {}
 
-  async getEntityData(mappedEntityType: string|null): Promise<EntityMaster> {
+  async getEntityData(
+    mappedEntityType: string | null,
+    loggedInUser,
+  ): Promise<EntityMaster> {
     if (mappedEntityType) {
       const entityMaster = await this.entityMasterRepository.findOne({
-        where: { mapped_entity_type: mappedEntityType },
+        where: {
+          mapped_entity_type: mappedEntityType,
+          organization_id: loggedInUser.organization_id,
+        },
       });
 
       if (!entityMaster) {
@@ -29,7 +35,7 @@ export class EntityMasterService {
   }
 
   async getEntityByTableName(tableName: string) {
-    const entityMaster = await this.entityMasterRepository.findOne({  
+    const entityMaster = await this.entityMasterRepository.findOne({
       where: { db_table_name: tableName },
     });
     return entityMaster;