rez_core 3.1.87 → 3.1.89

package/package.json

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

package/src/module/integration/service/integration.service.ts

@@ -87,12 +87,12 @@ export class IntegrationService {
     private readonly gmailApiStrategy: GmailApiStrategy,
     private readonly sendGridApiStrategy: SendGridApiStrategy,
     private readonly configService: ConfigService,
-    @Inject('FieldMapperService') private readonly fieldMapperService: FieldMapperService,
+    @Inject('FieldMapperService')
+    private readonly fieldMapperService: FieldMapperService,
     private readonly entityService: EntityServiceImpl,
     @Inject(forwardRef(() => IntegrationQueueService))
     private readonly queueService?: IntegrationQueueService,
-  ) {
-  }
+  ) {}
 
   private deriveServiceType(
     integration_type: string,
@@ -104,15 +104,15 @@ export class IntegrationService {
   }
 
   async sendMessage({
-                      levelId,
-                      levelType,
-                      app_code,
-                      to,
-                      message,
-                      mode,
-                      priority = 1,
-                      user_id,
-                    }: SendMessageDto): Promise<IntegrationResult> {
+    levelId,
+    levelType,
+    app_code,
+    to,
+    message,
+    mode,
+    priority = 1,
+    user_id,
+  }: SendMessageDto): Promise<IntegrationResult> {
     try {
       // Get active communication configs for the level
       const configs = await this.getActiveConfigs(
@@ -192,7 +192,9 @@ export class IntegrationService {
       .where('config.level_id = :levelId', { levelId })
       .andWhere('config.level_type = :levelType', { levelType })
       .andWhere('config.app_code = :app_code', { app_code })
-      .andWhere('config.integration_type = :integration_type', { integration_type })
+      .andWhere('config.integration_type = :integration_type', {
+        integration_type,
+      })
       .andWhere('config.status = 1')
       .orderBy('config.is_default', 'DESC')
       .addOrderBy('config.priority', 'ASC')
@@ -703,7 +705,7 @@ export class IntegrationService {
             if (configJson?.[field]) {
               safeConfig[
                 `has${field.charAt(0).toUpperCase() + field.slice(1)}`
-                ] = true;
+              ] = true;
             }
           });
 
@@ -1017,7 +1019,7 @@ export class IntegrationService {
               ...enhancedConfig,
               templateId: externalTemplateId,
               variables,
-              richText
+              richText,
             };
 
             // Handle user integration if user_id provided
@@ -1033,11 +1035,7 @@ export class IntegrationService {
               }
             }
 
-            const result = await strategy.sendMessage(
-              to,
-              message,
-              finalConfig,
-            );
+            const result = await strategy.sendMessage(to, message, finalConfig);
 
             if (result.success) {
               this.logger.log(
@@ -1257,8 +1255,16 @@ export class IntegrationService {
     templateId: number,
     entity_type: any,
     entity_id: any,
-  ): Promise<{ variables?: Record<string, any>; externalTemplateId?: string; rich_text?: string }> {
-    const commTemplate: any = await this.entityService.getEntityData(COMM_TEMPLATE, templateId, {} as any);
+  ): Promise<{
+    variables?: Record<string, any>;
+    externalTemplateId?: string;
+    rich_text?: string;
+  }> {
+    const commTemplate: any = await this.entityService.getEntityData(
+      COMM_TEMPLATE,
+      templateId,
+      {} as any,
+    );
     if (!commTemplate) {
       return {
         variables: {},
@@ -1270,6 +1276,7 @@ export class IntegrationService {
     if (commTemplate.mapper_id) {
       variables = await this.fieldMapperService.resolveData(
         commTemplate.mapper_id,
+        'LOOKUP',
         entity_type,
         entity_id,
         {} as any,
@@ -1973,10 +1980,10 @@ export class IntegrationService {
 
   async getIntegrationConfigById(hubId: number): Promise<
     | (IntegrationConfig & {
-    config: IntegrationConfig;
-    linkedSource?: string;
-    configDetails?: any;
-  })
+        config: IntegrationConfig;
+        linkedSource?: string;
+        configDetails?: any;
+      })
     | null
   > {
     try {
@@ -2468,7 +2475,8 @@ export class IntegrationService {
       if (!userIntegration) {
         return {
           success: false,
-          error: 'User integration mapping not found. Please configure agent details.',
+          error:
+            'User integration mapping not found. Please configure agent details.',
         };
       }
 

package/src/module/integration/strategies/email/sendgrid-api.strategy.ts

@@ -186,7 +186,7 @@ export class SendGridApiStrategy implements IntegrationStrategy {
     }
   }
 
-  async getTemplates(apiKey: string): Promise<{
+  async getTemplates(config: any): Promise<{
     success: boolean;
     data?: Array<{
       label: string;
@@ -195,7 +195,7 @@ export class SendGridApiStrategy implements IntegrationStrategy {
     error?: string;
   }> {
     try {
-      if (!apiKey) {
+      if (!config.apiKey) {
         throw new Error('SendGrid API key is required');
       }
 
@@ -203,7 +203,7 @@ export class SendGridApiStrategy implements IntegrationStrategy {
         'https://api.sendgrid.com/v3/templates?generations=dynamic',
         {
           headers: {
-            Authorization: `Bearer ${apiKey}`,
+            Authorization: `Bearer ${config.apiKey}`,
             'Content-Type': 'application/json',
           },
         },

package/src/module/mapper/controller/field-mapper.controller.ts

@@ -18,18 +18,28 @@ import { FieldMapperDto } from '../dto/field-mapper.dto';
 @Controller('field-mapper')
 @UseGuards(JwtAuthGuard)
 export class FieldMapperController {
-  constructor(@Inject('FieldMapperService') private readonly fieldMapperService: FieldMapperService) {
-  }
+  constructor(
+    @Inject('FieldMapperService')
+    private readonly fieldMapperService: FieldMapperService,
+  ) {}
 
   @Post('resolve')
-  async resolve(@Req() req: any, @Query('integration_component') integration_component: number,
-                @Query('entity_type') entity_type: string,
-                @Query('entity_id') entity_id: number) {
+  async resolve(
+    @Req() req: any,
+    @Query('integration_component') integration_component: number,
+    @Query('entity_type') entity_type: string,
+    @Query('entity_id') entity_id: number,
+  ) {
     const loggedInUser = req.user.userData;
-    return this.fieldMapperService.resolveData(integration_component, entity_type, entity_id, loggedInUser);
+    return this.fieldMapperService.resolveData(
+      integration_component,
+      'LOOKUP',
+      entity_type,
+      entity_id,
+      loggedInUser,
+    );
   }
 
-
   @Post('bulk')
   @HttpCode(HttpStatus.OK)
   async createBulk(@Req() req: any, @Body() dtos: FieldMapperDto[]) {
@@ -53,4 +63,4 @@ export class FieldMapperController {
   async getLovsByMapperField(@Param('mapperFieldId') mapperFieldId: number) {
     return this.fieldMapperService.getFieldLovs(mapperFieldId);
   }
-}
+}

package/src/module/mapper/service/field-mapper.service.ts

@@ -39,7 +39,8 @@ export class FieldMapperService extends EntityServiceImpl {
   async createFieldMappers(dtos: FieldMapperDto[], loggedInUser: UserData) {
     let mapperId = dtos[0].mapper_id;
 
-    let existingMappers = await this.fieldMapperRepository.findByMapperId(mapperId);
+    let existingMappers =
+      await this.fieldMapperRepository.findByMapperId(mapperId);
 
     for (const mapper of existingMappers) {
       await this.fieldLovsRepository.deleteByMapperFieldId(mapper.id);
@@ -65,7 +66,14 @@ export class FieldMapperService extends EntityServiceImpl {
   }
 
   async getMapperFields(mapperId: number) {
-    return await this.fieldMapperRepository.findByMapperId(mapperId);
+    let fieldMappers =
+      await this.fieldMapperRepository.findByMapperId(mapperId);
+    const fieldMapperDtos = fieldMappers as unknown as FieldMapperDto[];
+    for (const fieldMapper of fieldMapperDtos) {
+      fieldMapper.field_lovs =
+        await this.fieldLovsRepository.findByMapperFieldId(fieldMapper.id);
+    }
+    return fieldMapperDtos;
   }
 
   async getFieldLovs(mapperFieldId: number) {
@@ -74,98 +82,92 @@ export class FieldMapperService extends EntityServiceImpl {
 
   async resolveData(
     mapper_id: number,
+    action: 'LOOKUP' | 'LOAD',
     parent_type: string,
     parent_id: number,
     userData: UserData,
+    inputJson?: Record<string, any>,
   ) {
+    // Fetch field mappings for this mapper
     const fieldMappers =
-      await this.fieldMapperRepository.findByMapperId(
-        mapper_id,
-      );
+      await this.fieldMapperRepository.findByMapperId(mapper_id);
 
     const result: Record<string, any> = {};
-    const inMemory: Record<string, Record<string, any>> = {};
+    const inMemory: Record<string, Record<string, any>> = {}; // cache for entity lookups
 
     for (const field of fieldMappers) {
-      const entityType = field.mapped_entity_type
-        ? field.mapped_entity_type
-        : field.mapper_entity_type;
+      const entityType = field.mapped_entity_type || field.mapper_entity_type;
       const filterCode = field.filter_code || 'default';
 
-      if (!inMemory[entityType]) {
-        inMemory[entityType] = {};
-      }
+      // --------------------------
+      //  CASE 1: LOOKUP (System → External)
+      // --------------------------
+      if (action === 'LOOKUP') {
+        // Build cache (fetch entity data if needed)
+        if (!inMemory[entityType]) inMemory[entityType] = {};
 
-      // Case 1️⃣ direct mapping (no mapped_entity_type or equal)
-      if (
-        !inMemory[entityType][filterCode] &&
-        field.mapped_entity_type == field.mapper_entity_type
-      ) {
-        inMemory[entityType][filterCode] = await super.getResolvedEntityData(
-          entityType,
-          parent_id,
-          userData,
-        );
-
-        // Case 2️⃣ mapped_entity_type
-      } else if (
-        field.mapped_entity_type &&
-        !inMemory[entityType][filterCode]
-      ) {
-        // Step 1: get related target entity ids
-        const relations = await this.datasource.query(
-          `SELECT target_entity_id
-           FROM cr_entity_relation_data
-           WHERE source_entity_type = ?
-             AND source_entity_id = ?
-             AND target_entity_type = ?`,
-          [
-            parent_type,
-            parent_id,
-            field.mapped_entity_type,
-          ],
-        );
-
-        const targetEntityIds = relations.map((r) => r.target_entity_id);
-
-        if (targetEntityIds.length > 0) {
-          if (filterCode && filterCode !== 'default') {
-            // Step 2a: filtered fetch with IN clause using applyFilterWrapper
-            inMemory[entityType][filterCode] = inMemory[entityType][
-              filterCode
-              ] = await this.filterService.applyFilterWrapper({
-              entity_type: entityType,
-              savedFilterCode: filterCode,
-              quickFilter: [
-                {
-                  filter_attribute: 'id',
-                  filter_operator: 'equal',
-                  filter_value: targetEntityIds,
-                  filter_entity_type: entityType,
-                },
-              ],
-              attributeFilter: [],
-              loggedInUser: userData,
-              queryParams: {},
-            });
-          } else {
-            // Step 2b: no filter → just pick first related entity
-            const firstId = targetEntityIds[0];
+        if (!inMemory[entityType][filterCode]) {
+          if (field.mapped_entity_type === field.mapper_entity_type) {
+            // Direct mapping
             inMemory[entityType][filterCode] =
-              await super.getResolvedEntityData(entityType, firstId, userData);
+              await super.getResolvedEntityData(
+                entityType,
+                parent_id,
+                userData,
+              );
+          } else {
+            // Indirect mapping through relation
+            const relations = await this.datasource.query(
+              `SELECT target_entity_id
+             FROM cr_entity_relation_data
+             WHERE source_entity_type = ?
+               AND source_entity_id = ?
+               AND target_entity_type = ?`,
+              [parent_type, parent_id, field.mapped_entity_type],
+            );
+
+            const targetEntityIds = relations.map((r) => r.target_entity_id);
+
+            if (targetEntityIds.length > 0) {
+              if (filterCode && filterCode !== 'default') {
+                inMemory[entityType][filterCode] =
+                  await this.filterService.applyFilterWrapper({
+                    entity_type: entityType,
+                    savedFilterCode: filterCode,
+                    quickFilter: [
+                      {
+                        filter_attribute: 'id',
+                        filter_operator: 'equal',
+                        filter_value: targetEntityIds,
+                        filter_entity_type: entityType,
+                      },
+                    ],
+                    attributeFilter: [],
+                    loggedInUser: userData,
+                    queryParams: {},
+                  });
+              } else {
+                const firstId = targetEntityIds[0];
+                inMemory[entityType][filterCode] =
+                  await super.getResolvedEntityData(
+                    entityType,
+                    firstId,
+                    userData,
+                  );
+              }
+            } else {
+              inMemory[entityType][filterCode] = null;
+            }
           }
-        } else {
-          inMemory[entityType][filterCode] = null;
         }
-      }
 
-      // Fetch mapped attribute values
-      const entityData = inMemory[entityType][filterCode];
-      if (entityData) {
-        let value = entityData[field.attribute_key];
+        // Extract and transform values
+        const entityData = inMemory[entityType][filterCode];
+        if (entityData) {
+          let value = entityData[field.attribute_key];
 
-        if (field.is_lov_present) {
-          if (field.action === 'LOOKUP') {
+          // Apply LOV mapping (System → External)
+          if (field.is_lov_present) {
             const fieldLovMapper =
               await this.fieldLovsRepository.findByMapperFieldIdAndDestinationAttributeValue(
                 field.id,
@@ -174,18 +176,38 @@ export class FieldMapperService extends EntityServiceImpl {
             if (fieldLovMapper) {
               value = fieldLovMapper.source_attribute_value;
             }
-          } else {
-            const fieldLovMapper =
-              await this.fieldLovsRepository.findByMapperFieldIdAndSourceAttributeValue(
-                field.id,
-                value,
-              );
-            if (fieldLovMapper) {
-              value = fieldLovMapper.destination_attribute_value;
-            }
           }
+
+          // Add to result
+          result[field.source_attribute] = value;
         }
-        result[field.source_attribute] = value;
+      }
+
+      // --------------------------
+      // CASE 2: LOAD (External → System)
+      // --------------------------
+      else if (action === 'LOAD' && inputJson) {
+        // Ensure nested object exists
+        if (!result[field.mapper_entity_type]) {
+          result[field.mapper_entity_type] = {};
+        }
+
+        // Read from external payload (third-party)
+        let value = inputJson[field.source_attribute];
+
+        // Apply LOV mapping (External → System)
+        if (field.is_lov_present && value !== undefined && value !== null) {
+          const fieldLovMapper =
+            await this.fieldLovsRepository.findByMapperFieldIdAndSourceAttributeValue(
+              field.id,
+              value,
+            );
+          if (fieldLovMapper) {
+            value = fieldLovMapper.destination_attribute_value;
+          }
+        }
+
+        result[field.mapper_entity_type][field.attribute_key] = value;
       }
     }