rez_core 7.1.2 → 7.1.3

package/package.json

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

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

@@ -37,24 +37,24 @@ export class LayoutPreferenceController {
     );
   }
 
-  @Get('column')
-  @UseGuards(JwtAuthGuard)
-  @HttpCode(HttpStatus.OK)
-  async getColumnValues(
-    @Query('entity_type') entity_type: string,
-    @Query('column') column: string,
-    @Query('sort_by') sort_by: string,
-    @Req() req: Request & { user: any },
-  ) {
-    const loggedInUser = req.user.userData;
+  // @Get('column')
+  // @UseGuards(JwtAuthGuard)
+  // @HttpCode(HttpStatus.OK)
+  // async getColumnValues(
+  //   @Query('entity_type') entity_type: string,
+  //   @Query('column') column: string,
+  //   @Query('sort_by') sort_by: string,
+  //   @Req() req: Request & { user: any },
+  // ) {
+  //   const loggedInUser = req.user.userData;
 
-    return this.layoutPreferenceService.getColumnValue(
-      entity_type,
-      column,
-      sort_by,
-      loggedInUser,
-    );
-  }
+  //   return this.layoutPreferenceService.getColumnValue(
+  //     entity_type,
+  //     column,
+  //     sort_by,
+  //     loggedInUser,
+  //   );
+  // }
 
   @Post('attributes')
   @UseGuards(JwtAuthGuard)

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

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { LayoutPreferenceController } from './controller/layout_preference.controller';
 import { LayoutPreferenceService } from './service/layout_preference.service';
 import { EntityModule } from '../meta/entity.module';
@@ -9,7 +9,7 @@ import { AttributeMaster } from '../meta/entity/attribute-master.entity';
 
 @Module({
   imports: [
-    EntityModule,
+    forwardRef(() => EntityModule),
     TypeOrmModule.forFeature([LayoutPreference, AttributeMaster]),
   ],
   controllers: [LayoutPreferenceController],

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

@@ -75,107 +75,107 @@ export class LayoutPreferenceService extends EntityServiceImpl {
     };
   }
 
-  async getColumnValue(
-    entity_type: string,
-    column: string,
-    sort_by: string,
-    loggedInUser: UserData,
-  ): Promise<{ label: string; value: string }[]> {
-    try {
-      const getTableMeta =
-        await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
-          entity_type,
-          entity_type,
-          'LIST',
-          loggedInUser?.enterprise_id,
-        );
-
-      const tableName = getTableMeta?.data_source;
-
-      if (!tableName) {
-        throw new Error('Invalid or missing table name in metadata');
-      }
-
-      // Query DB to get distinct column values and counts
-      const rawData: { column_value: string; count: number }[] =
-        await this.dataSource
-          .createQueryBuilder()
-          .select(`${column} AS column_value`)
-          .addSelect(`COUNT(*) AS count`)
-          .from(tableName, tableName)
-          .where(`${column} IS NOT NULL`)
-          .andWhere(`enterprise_id = :enterprise_id`, {
-            enterprise_id: loggedInUser?.enterprise_id,
-          })
-          .andWhere(`level_id = :levelId`, { levelId: loggedInUser?.level_id })
-          .andWhere(`level_type = :levelType`, {
-            levelType: loggedInUser?.level_type,
-          })
-          .groupBy(column)
-          .getRawMany();
-
-      if (!rawData.length) {
-        return [];
-      }
-
-      // Prepare payload for resolver
-      const payloadBeforeResolved = rawData.map((row) => ({
-        [column]: row?.column_value,
-      }));
-
-      // Resolve column values using resolverService
-      const resolvedEntityList = await Promise.all(
-        payloadBeforeResolved.map((row) =>
-          this.resolverService.getResolvedData(loggedInUser, row, entity_type),
-        ),
-      );
-
-      // Merge resolved names with counts
-      const resolvedWithCounts = rawData.map((row, index) => {
-        const resolvedValue =
-          resolvedEntityList[index]?.[column] || row.column_value;
-        return {
-          label: resolvedValue, // Human-readable label
-          value: row.column_value, // Original DB value
-          count: Number(row.count),
-        };
-      });
-
-      // Sort based on sort_by parameter
-      switch (sort_by) {
-        case 'asc':
-          resolvedWithCounts.sort((a, b) => a.label.localeCompare(b.label));
-          break;
-        case 'dsc':
-          resolvedWithCounts.sort((a, b) => b.label.localeCompare(a.label));
-          break;
-        case 'count_asc':
-          resolvedWithCounts.sort((a, b) => a.count - b.count);
-          break;
-        case 'count_dsc':
-          resolvedWithCounts.sort((a, b) => b.count - a.count);
-          break;
-        default:
-          break;
-      }
-
-      // Clean and return only label/value pairs
-      return resolvedWithCounts
-        .filter(
-          (item) =>
-            item.label !== null &&
-            item.label !== undefined &&
-            item.label.toString().trim() !== '',
-        )
-        .map((item) => ({
-          label: item.label,
-          value: item.value,
-        }));
-    } catch (error) {
-      this.logger.error(`getColumnValue ERROR: ${error.message}`, error.stack);
-      return [];
-    }
-  }
+  // async getColumnValue(
+  //   entity_type: string,
+  //   column: string,
+  //   sort_by: string,
+  //   loggedInUser: UserData,
+  // ): Promise<{ label: string; value: string }[]> {
+  //   try {
+  //     const getTableMeta =
+  //       await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
+  //         entity_type,
+  //         entity_type,
+  //         'LIST',
+  //         loggedInUser?.enterprise_id,
+  //       );
+
+  //     const tableName = getTableMeta?.data_source;
+
+  //     if (!tableName) {
+  //       throw new Error('Invalid or missing table name in metadata');
+  //     }
+
+  //     // Query DB to get distinct column values and counts
+  //     const rawData: { column_value: string; count: number }[] =
+  //       await this.dataSource
+  //         .createQueryBuilder()
+  //         .select(`${column} AS column_value`)
+  //         .addSelect(`COUNT(*) AS count`)
+  //         .from(tableName, tableName)
+  //         .where(`${column} IS NOT NULL`)
+  //         .andWhere(`enterprise_id = :enterprise_id`, {
+  //           enterprise_id: loggedInUser?.enterprise_id,
+  //         })
+  //         .andWhere(`level_id = :levelId`, { levelId: loggedInUser?.level_id })
+  //         .andWhere(`level_type = :levelType`, {
+  //           levelType: loggedInUser?.level_type,
+  //         })
+  //         .groupBy(column)
+  //         .getRawMany();
+
+  //     if (!rawData.length) {
+  //       return [];
+  //     }
+
+  //     // Prepare payload for resolver
+  //     const payloadBeforeResolved = rawData.map((row) => ({
+  //       [column]: row?.column_value,
+  //     }));
+
+  //     // Resolve column values using resolverService
+  //     const resolvedEntityList = await Promise.all(
+  //       payloadBeforeResolved.map((row) =>
+  //         this.resolverService.getResolvedData(loggedInUser, row, entity_type),
+  //       ),
+  //     );
+
+  //     // Merge resolved names with counts
+  //     const resolvedWithCounts = rawData.map((row, index) => {
+  //       const resolvedValue =
+  //         resolvedEntityList[index]?.[column] || row.column_value;
+  //       return {
+  //         label: resolvedValue, // Human-readable label
+  //         value: row.column_value, // Original DB value
+  //         count: Number(row.count),
+  //       };
+  //     });
+
+  //     // Sort based on sort_by parameter
+  //     switch (sort_by) {
+  //       case 'asc':
+  //         resolvedWithCounts.sort((a, b) => a.label.localeCompare(b.label));
+  //         break;
+  //       case 'dsc':
+  //         resolvedWithCounts.sort((a, b) => b.label.localeCompare(a.label));
+  //         break;
+  //       case 'count_asc':
+  //         resolvedWithCounts.sort((a, b) => a.count - b.count);
+  //         break;
+  //       case 'count_dsc':
+  //         resolvedWithCounts.sort((a, b) => b.count - a.count);
+  //         break;
+  //       default:
+  //         break;
+  //     }
+
+  //     // Clean and return only label/value pairs
+  //     return resolvedWithCounts
+  //       .filter(
+  //         (item) =>
+  //           item.label !== null &&
+  //           item.label !== undefined &&
+  //           item.label.toString().trim() !== '',
+  //       )
+  //       .map((item) => ({
+  //         label: item.label,
+  //         value: item.value,
+  //       }));
+  //   } catch (error) {
+  //     this.logger.error(`getColumnValue ERROR: ${error.message}`, error.stack);
+  //     return [];
+  //   }
+  // }
 
   async getEntityLayoutAttributes(
     entity_type: string,

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

@@ -17,6 +17,7 @@ import { ListMasterService } from '../service/list-master.service';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 import { ListMasterItemService } from '../service/list-master-item.service';
 import { MessagePattern, Payload } from '@nestjs/microservices';
+import { UserData } from '../../auth/dto/user.dto';
 
 @Controller('list-master')
 export class ListMasterController {
@@ -171,38 +172,55 @@ export class ListMasterController {
     @Query('entity_type') entity_type: string,
     @Query('attribute_key') attribute_key: string,
     @Body() body: Record<string, string>,
+    @Query() queryParams: Record<string, string>,
     @Request() req,
   ) {
-
     const loggedInUser = req.user.userData;
-    const authHeader = req.headers.authorization || '';
-    const token = authHeader.replace('Bearer ', '').trim();
+    const {
+      inactiveIds,
+    } = queryParams;
+
+    const inactiveIdsArray = inactiveIds
+      ? inactiveIds.split(',').map((id) => parseInt(id, 10))
+      : [];
 
     return await this.service.getDropDownData(
       entity_type,
       attribute_key,
       loggedInUser,
-      body
+      body,
+      [],
+      inactiveIdsArray,
     );
   }
 
-  @MessagePattern('getDropdownData')
-  async getDropdownDataMS(
+  @MessagePattern('getEntityDropdown')
+  async getEntityDropdownMS(
     @Payload()
     data: {
-      entity_type: string;
-      attribute_key: string;
-      loggedInUser: any;
-      body: Record<string, string>;
+      ds_entityType: string,
+      params: Record<string, any>,
+      loggedInUser: UserData,
+      values?: any[],
+      inactiveIds?: any[],
     },
   ) {
-    const { entity_type, attribute_key, loggedInUser, body } = data;
+    const { ds_entityType, params, loggedInUser, values, inactiveIds } = data;
+    return await this.service.fetchFromEntity(ds_entityType, params, loggedInUser, values, inactiveIds);
+  }
 
-    return this.service.getDropDownData(
-      entity_type,
-      attribute_key,
-      loggedInUser,
-      body,
-    );
+  @MessagePattern('getListMasterDropdown')
+  async getListMasterDropdownMS(
+    @Payload()
+    data: {
+      type: string,
+      params: Record<string, any>,
+      loggedInUser: UserData,
+      values?: any[],
+      inactiveIds?: any[],
+    },
+  ) {
+    const { type, params, loggedInUser, values, inactiveIds } = data;
+    return await this.service.fetchFromListMaster(type, params, loggedInUser, values, inactiveIds);
   }
 }

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

@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository, In, Raw, Or, And, FindOptionsWhere } from 'typeorm';
 import { ListMasterItems } from '../entity/list-master-items.entity';
+import { ListMasterData } from '../entity/list-master.entity';
 
 @Injectable()
 export class ListMasterItemsRepository {
@@ -43,7 +44,7 @@ export class ListMasterItemsRepository {
         });
 
         const itemsMapped = itemValues.map((i) => ({
-          label: `${i.name} [INACTIVE]`,
+          label: `${i.name}`,
           value: String(i.code),
         }));
 

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

@@ -10,6 +10,7 @@ import axios from 'axios';
 import { ConfigService } from '@nestjs/config';
 import { AttributeMasterService } from '../../meta/service/attribute-master.service';
 import { IMicroserviceClients } from '../../microservice-client/service/microservice-clients';
+import { firstValueFrom } from 'rxjs';
 
 @Injectable()
 export class ListMasterService extends EntityServiceImpl {
@@ -146,11 +147,12 @@ export class ListMasterService extends EntityServiceImpl {
     }
   }
 
-  private async fetchFromEntity(
+  public async fetchFromEntity(
     sourceList: string,
     params: Record<string, any>,
     loggedInUser?: UserData,
     values?: any[],
+    inactiveIds?: any[],
   ) {
    
     let result: { label: string; value: number }[] = [];
@@ -201,8 +203,8 @@ export class ListMasterService extends EntityServiceImpl {
         });
       }
 
-      // ✅ New: Exclude customers for USR/UPR
-      if (sourceList === 'USR' || sourceList === 'UPR') {
+      // ✅ New: Exclude customers for USR
+      if (sourceList === 'USR') {
         qb.andWhere(`${tableName}.is_customer is NULL`);
       }
 
@@ -230,6 +232,19 @@ export class ListMasterService extends EntityServiceImpl {
       result.push({ label: r.name, value: r.id });
     });
 
+    if (inactiveIds && inactiveIds.length > 0) {
+      const qb = this.entityManager
+        .createQueryBuilder()
+        .select('*')
+        .from(`${this.schema}.${tableName}`, tableName)
+        .where('id IN (:...inactiveIds)', { inactiveIds });
+
+      const inactiveQuery = await qb.getRawMany();
+
+      inactiveQuery.map((r) => {
+        result.push({ label: `${r.name} [INACTIVE]`, value: r.id });
+      });
+    }
     return result;
   }
 
@@ -300,6 +315,7 @@ export class ListMasterService extends EntityServiceImpl {
     loggedInUser: UserData,
     body: Record<string, any>,
     values?: any[],
+    inactiveIdsArray?: any[],
   ) {
     try {
       // Extract inactiveIds from body
@@ -333,35 +349,17 @@ export class ListMasterService extends EntityServiceImpl {
         );
       }
 
-      const currentAppCode = this.configService.get<string>('appcode');
-
-      // Check if request is for same app (SELF) or cross-app (CROSS)
-      const isSelfApp =
-        !ds_appcode ||
-        ds_appcode.toUpperCase() === 'SELF' ||
-        currentAppCode === ds_appcode;
+      return this.processDropdown(
+        ds_category,
+        ds_entitytype,
+        ds_appcode,
+        ds_filtercode,
+        params,
+        loggedInUser,
+        values,
+        inactiveIdsArray,
+      );
 
-      if (isSelfApp) {
-        // SELF APP - Process locally
-        return this.processLocalDropdown(
-          ds_category,
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          loggedInUser,
-          values,
-        );
-      } else {
-        // CROSS APP - Forward to target microservice
-        return this.processCrossAppDropdown(
-          ds_appcode,
-          entity_type,
-          attribute_key,
-          loggedInUser,
-          body,
-          values,
-        );
-      }
     } catch (error) {
       console.error('❌ Error in getDropDownData:', error.message);
       throw error;
@@ -371,40 +369,77 @@ export class ListMasterService extends EntityServiceImpl {
   /**
    * Process dropdown data locally (SELF APP)
    */
-  private async processLocalDropdown(
+  private async processDropdown(
     ds_category: string,
     ds_entitytype: string,
     ds_filtercode: string,
+    ds_appcode: string,
     params: Record<string, any>,
     loggedInUser: UserData,
     values?: any[],
+    inactives?: any[],
   ) {
-    // Route to appropriate handler based on data source category
+    const currentAppCode = this.configService.get<string>('appcode');
+
+    // Determine if request is SELF or CROSS
+    const isSelfApp =
+      !ds_appcode ||
+      ds_appcode.toUpperCase() === 'SELF' ||
+      currentAppCode === ds_appcode;
+
+    const client = this.factory.getClient(ds_appcode);
+
+    // Helper: safely call microservice
+    const callClient = async (pattern: string, payload: any) => {
+      if (!client) return null;
+      return firstValueFrom(client.send(pattern, payload));
+    };
+
     switch (ds_category.toUpperCase()) {
-      case 'ENT_LIST':
-      case 'ENTITY':
-        // Merge ds_filtercode params with request params
-        const mergedParams = { ...params };
-        if (ds_filtercode) {
-          const filterParams = this.parseFilterCode(ds_filtercode);
-          Object.assign(mergedParams, filterParams);
+      case 'ENTITY': {
+        // Merge params + filter params
+        const mergedParams = {
+          ...params,
+          ...(ds_filtercode ? this.parseFilterCode(ds_filtercode) : {}),
+        };
+
+        if (isSelfApp) {
+          return this.fetchFromEntity(
+            ds_entitytype,
+            mergedParams,
+            loggedInUser,
+            values,
+          );
         }
-        return this.fetchFromEntity(
+
+        return callClient('getEntityDropdown', {
           ds_entitytype,
           mergedParams,
           loggedInUser,
           values,
-        );
+        });
+      }
 
-      case 'LM':
-      case 'LIST_MASTER':
-        return this.fetchFromListMaster(
+      case 'LIST_MASTER': {
+        if (isSelfApp) {
+          return this.fetchFromListMaster(
+            ds_entitytype,
+            params,
+            loggedInUser,
+            values,
+            inactives,
+          );
+        }
+
+        return callClient('getListMasterDropdown', {
           ds_entitytype,
           ds_filtercode,
           params,
           loggedInUser,
           values,
-        );
+          inactives,
+        });
+      }
 
       case 'CAPI':
       case 'CUSTOM_API':
@@ -443,12 +478,12 @@ export class ListMasterService extends EntityServiceImpl {
   /**
    * Fetch dropdown from List Master
    */
-  private async fetchFromListMaster(
+  public async fetchFromListMaster(
     lmCode: string,
-    filterCode: string,
     params: Record<string, any>,
     loggedInUser: UserData,
     values?: any[],
+    inactives?: any[],
   ) {
     try {
       // Get List Master configuration
@@ -469,6 +504,7 @@ export class ListMasterService extends EntityServiceImpl {
         loggedInUser.enterprise_id,
         params,
         values,
+        inactives,
       );
     } catch (error) {
       console.error(`❌ Error fetching from List Master '${lmCode}':`, error.message);
@@ -644,50 +680,6 @@ export class ListMasterService extends EntityServiceImpl {
     }));
   }
 
-  /**
-   * Forward request to cross-app microservice (CROSS APP)
-   */
-  private async processCrossAppDropdown(
-    targetAppCode: string,
-    entity_type: string,
-    attribute_key: string,
-    loggedInUser: UserData,
-    body: Record<string, any>,
-    values?: any[],
-  ) {
-    try {
-      // Get microservice client for target app
-      const client = this.factory.getClient(targetAppCode);
-
-      if (!client) {
-        throw new BadRequestException(
-          `Microservice client for app '${targetAppCode}' not available`,
-        );
-      }
-
-      // Forward the request to target microservice
-      // The target microservice will execute the same process recursively
-      const response = await client
-        .send('getDropdownData', {
-          entity_type,
-          attribute_key,
-          loggedInUser,
-          body,
-        })
-        .toPromise();
-
-      return response;
-    } catch (error) {
-      console.error(
-        `❌ Error calling cross-app microservice '${targetAppCode}':`,
-        error.message,
-      );
-      throw new BadRequestException(
-        `Failed to fetch dropdown from app '${targetAppCode}': ${error.message}`,
-      );
-    }
-  }
-
   // Example custom key handlers
   private async getUserRolesDropdown(
     filterCode: string,

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

@@ -57,6 +57,7 @@ import { EntityUpdateRepository } from './repository/entity-attribute-update.rep
 import { EntityRelationRepository } from './repository/entity-relation.repository';
 import { EAVModule } from '../eav/eav.module';
 import { PopulateMetaService } from '../master/service/poupulate-meta.service';
+import { LayoutPreferenceModule } from '../layout_preference/layout_preference.module';
 
 @Module({
   imports: [
@@ -73,6 +74,7 @@ import { PopulateMetaService } from '../master/service/poupulate-meta.service';
     ]),
     forwardRef(() => ListMasterModule),
     forwardRef(() => FilterModule),
+    forwardRef(() => LayoutPreferenceModule),
     UtilsModule,
     forwardRef(() => WorkflowAutomationModule),
     EAVModule