rez_core 3.1.86 → 3.1.88

package/package.json

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

package/src/module/integration/controller/integration.controller.ts

@@ -19,6 +19,7 @@ import {
   CreateConfigDto,
   CreateUserIntegrationDto,
   GenericSendMessageDto,
+  GetIntegrationTemplatesDto,
   SendGridTemplatesDto,
   SendGridVerifiedSendersDto,
   UpdateConfigDto,
@@ -327,6 +328,26 @@ export class IntegrationController {
     }
   }
 
+  @Post('templates')
+  @HttpCode(HttpStatus.OK)
+  async getIntegrationTemplates(@Body() dto: GetIntegrationTemplatesDto) {
+    try {
+      return await this.integrationService.getIntegrationTemplates(
+        dto.levelId,
+        dto.levelType,
+        dto.app_code,
+        dto.integration_type,
+      );
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'GET_TEMPLATES_ERROR',
+        message: error.message || 'Failed to get templates',
+        code: 'INTEGRATION_TEMPLATES_ERROR',
+      });
+    }
+  }
+
   @Post('config/delete/:configId')
   @HttpCode(HttpStatus.OK)
   async disconnectConfig(@Param('configId', ParseIntPipe) configId: number) {

package/src/module/integration/dto/create-config.dto.ts

@@ -360,6 +360,24 @@ export class SendGridTemplatesDto {
   app_code: string;
 }
 
+export class GetIntegrationTemplatesDto {
+  @IsNotEmpty()
+  @IsNumber()
+  levelId: number;
+
+  @IsNotEmpty()
+  @IsString()
+  levelType: string;
+
+  @IsNotEmpty()
+  @IsString()
+  app_code: string;
+
+  @IsNotEmpty()
+  @IsString()
+  integration_type: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
+}
+
 export class VerifiedSenderDto {
   @IsString()
   label: string;

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

@@ -1000,7 +1000,7 @@ export class IntegrationService {
             let variables;
             let externalTemplateId: string | undefined = undefined;
             let richText;
-            if (templateId && entity_type && entity_id) {
+            if (templateId) {
               const templateData = await this.processTemplate(
                 parseInt(templateId, 10),
                 entity_type,
@@ -1255,8 +1255,8 @@ export class IntegrationService {
 
   private async processTemplate(
     templateId: number,
-    entity_type: string,
-    entity_id: 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);
     if (!commTemplate) {
@@ -2019,6 +2019,64 @@ export class IntegrationService {
     }
   }
 
+  async getIntegrationTemplates(
+    levelId: number,
+    levelType: string,
+    app_code: string,
+    integration_type: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+  ): Promise<{
+    success: boolean;
+    data?: Array<{
+      label: string;
+      value: string;
+    }>;
+    error?: string;
+  }> {
+    try {
+      // Get active configuration for the integration type
+      const config = await this.getSingleActiveConfig(
+        levelId,
+        levelType,
+        app_code,
+        integration_type,
+      );
+
+      if (!config) {
+        return {
+          success: false,
+          error: `No active ${integration_type} configuration found for this level`,
+        };
+      }
+
+      // Create strategy instance
+      const strategy = this.integrationFactory.create(
+        config.integration_type,
+        'API',
+        config.integration_provider,
+      );
+
+      // Check if strategy supports getTemplates
+      if (typeof (strategy as any).getTemplates !== 'function') {
+        return {
+          success: false,
+          error: `Template retrieval not supported for provider: ${config.integration_provider}`,
+        };
+      }
+
+      // Call getTemplates method
+      return await (strategy as any).getTemplates(config.config_json);
+    } catch (error) {
+      this.logger.error(
+        `Error fetching templates for ${integration_type} level ${levelId}/${levelType}:`,
+        error.message,
+      );
+      return {
+        success: false,
+        error: `Failed to fetch templates: ${error.message}`,
+      };
+    }
+  }
+
   async getSendGridTemplates(
     levelId: number,
     levelType: string,

package/src/module/integration/strategies/whatsapp/tubelight-whatsapp.strategy.ts

@@ -1,5 +1,6 @@
 import { Injectable, Logger } from '@nestjs/common';
 import axios, { AxiosResponse } from 'axios';
+import { randomUUID } from 'crypto';
 import {
   IntegrationResult,
   IntegrationStrategy,
@@ -9,19 +10,12 @@ interface TubelightWhatsAppConfig {
   userName: string;
   password: string;
   tenantId: string;
+  custUuid?: string;
   baseUrl?: string;
-  sourceNumber?: string;
-}
-
-interface TubelightMessage {
-  to: string;
-  message: string;
-  messageType?: string;
-  mediaUrl?: string;
-  caption?: string;
-  filename?: string;
   templateId?: string;
-  templateParams?: any[];
+  templateName?: string;
+  templateLanguage?: string;
+  variables?: string;
 }
 
 interface TubelightApiResponse {
@@ -38,7 +32,7 @@ interface TubelightApiResponse {
 export class TubelightWhatsAppStrategy implements IntegrationStrategy {
   private readonly logger = new Logger(TubelightWhatsAppStrategy.name);
   private readonly defaultBaseUrl =
-    'https://portal.tubelightcommunications.com/whatsapp/api/v1';
+      'https://portal.tubelightcommunications.com/whatsapp/api/v1';
 
   async sendMessage(
     to: string,
@@ -58,16 +52,15 @@ export class TubelightWhatsAppStrategy implements IntegrationStrategy {
       }
 
       const baseUrl = tubelightConfig.baseUrl || this.defaultBaseUrl;
-      const url = `${baseUrl}/messages/send`;
+      const url = `${baseUrl}/bulk/send`;
 
-      const payload = this.prepareMessagePayload(to, message, config);
+      const payload = [this.prepareMessagePayload(to, message, config)];
 
       const response: AxiosResponse<TubelightApiResponse> = await axios.post(
         url,
         payload,
         {
           headers: {
-            'X-TENANT-ID': tubelightConfig.tenantId,
             'Content-Type': 'application/json',
             Authorization: `Bearer ${token}`,
           },
@@ -76,8 +69,7 @@ export class TubelightWhatsAppStrategy implements IntegrationStrategy {
       );
 
       if (
-        response.data?.success &&
-        (response.data?.messageId || response.data?.id)
+        response.status === 200
       ) {
         const messageId = response.data.messageId || response.data.id;
         this.logger.log(
@@ -166,98 +158,55 @@ export class TubelightWhatsAppStrategy implements IntegrationStrategy {
 
   private prepareMessagePayload(to: string, message: string, config: any): any {
     const basePayload = {
-      to: this.formatPhoneNumber(to),
-      from: config.sourceNumber || config.from,
-    };
+      cust_uuid: config.custUuid || randomUUID(),
+      to: [this.formatPhoneNumber(to)],
+      };
+
+    // If templateId exists, send template message
+    if (config.templateId || config.templateName) {
+      const messagePayload: any = {
+        type: 'template',
+        template_name: config.templateId || config.templateName,
+        language: config.templateLanguage || 'en',
+      };
 
-    // Handle different message types based on config
-    if (config.messageType) {
-      switch (config.messageType) {
-        case 'template':
-          return {
-            ...basePayload,
-            messageType: 'TEMPLATE',
-            templateId: config.templateId,
-            templateParams: config.templateParams || [],
-            language: config.templateLanguage || 'en',
-          };
-
-        case 'image':
-          return {
-            ...basePayload,
-            messageType: 'IMAGE',
-            mediaUrl: config.mediaUrl,
-            caption: message || config.caption || '',
-          };
-
-        case 'document':
-          return {
-            ...basePayload,
-            messageType: 'DOCUMENT',
-            mediaUrl: config.mediaUrl,
-            filename: config.filename || 'document',
-            caption: message || config.caption || '',
-          };
-
-        case 'audio':
-          return {
-            ...basePayload,
-            messageType: 'AUDIO',
-            mediaUrl: config.mediaUrl,
-          };
-
-        case 'video':
-          return {
-            ...basePayload,
-            messageType: 'VIDEO',
-            mediaUrl: config.mediaUrl,
-            caption: message || config.caption || '',
-          };
-
-        case 'location':
-          return {
-            ...basePayload,
-            messageType: 'LOCATION',
-            latitude: config.latitude,
-            longitude: config.longitude,
-            name: config.locationName || '',
-            address: config.locationAddress || '',
-          };
-
-        case 'interactive':
-          return {
-            ...basePayload,
-            messageType: 'INTERACTIVE',
-            interactiveType: config.interactiveType || 'button',
-            text: message,
-            buttons: config.buttons || [],
-            sections: config.sections || [],
-            header: config.header,
-            footer: config.footer,
-          };
-
-        default:
-          // Fall back to text message
-          break;
+      // Add body_params if provided
+      if (config.variables) {
+        try {
+          // Parse JSON string
+          const parsedVariables = typeof config.variables === 'string'
+            ? JSON.parse(config.variables)
+            : config.variables;
+
+          // Convert object to array of values, or use array as-is
+          messagePayload.body_params = Array.isArray(parsedVariables)
+            ? parsedVariables
+            : Object.values(parsedVariables);
+        } catch (e) {
+          this.logger.error('Failed to parse variables JSON:', e.message);
+          messagePayload.body_params = [];
+        }
       }
+
+      return {
+        ...basePayload,
+        message: messagePayload,
+      };
     }
 
     // Default text message
     return {
       ...basePayload,
-      messageType: 'TEXT',
-      text: message,
+      message: {
+        type: 'text',
+        text: message,
+      },
     };
   }
 
   private formatPhoneNumber(phoneNumber: string): string {
-    // Remove any non-digit characters except +
-    let formatted = phoneNumber.replace(/[^\d+]/g, '');
-
-    // If it doesn't start with +, assume it needs country code
-    if (!formatted.startsWith('+')) {
-      formatted = `+${formatted}`;
-    }
+    // Remove any non-digit characters
+    let formatted = phoneNumber.replace(/\D/g, '');
 
     return formatted;
   }
@@ -292,46 +241,6 @@ export class TubelightWhatsAppStrategy implements IntegrationStrategy {
       return false;
     }
 
-    // Validate message type specific requirements
-    if (config.messageType) {
-      switch (config.messageType) {
-        case 'template':
-          if (!config.templateId) {
-            return false;
-          }
-          break;
-
-        case 'image':
-        case 'document':
-        case 'audio':
-        case 'video':
-          if (!config.mediaUrl) {
-            return false;
-          }
-          break;
-
-        case 'location':
-          if (
-            typeof config.latitude !== 'number' ||
-            typeof config.longitude !== 'number'
-          ) {
-            return false;
-          }
-          break;
-
-        case 'interactive':
-          if (
-            !config.buttons &&
-            !config.sections &&
-            (!config.interactiveType ||
-              !['button', 'list'].includes(config.interactiveType))
-          ) {
-            return false;
-          }
-          break;
-      }
-    }
-
     return true;
   }
 
@@ -347,7 +256,6 @@ export class TubelightWhatsAppStrategy implements IntegrationStrategy {
 
       const response = await axios.get(url, {
         headers: {
-          'X-TENANT-ID': config.tenantId,
           Authorization: `Bearer ${token}`,
         },
       });
@@ -364,7 +272,14 @@ export class TubelightWhatsAppStrategy implements IntegrationStrategy {
     }
   }
 
-  async getTemplates(config: TubelightWhatsAppConfig): Promise<any> {
+  async getTemplates(config: TubelightWhatsAppConfig): Promise<{
+    success: boolean;
+    data?: Array<{
+      label: string;
+      value: string;
+    }>;
+    error?: string;
+  }> {
     try {
       const token = await this.authenticate(config);
       if (!token) {
@@ -372,24 +287,52 @@ export class TubelightWhatsAppStrategy implements IntegrationStrategy {
       }
 
       const baseUrl = config.baseUrl || this.defaultBaseUrl;
-      const url = `${baseUrl}/templates`;
+      const url = `${baseUrl}/retreive/template`;
 
-      const response = await axios.get(url, {
-        headers: {
-          'X-TENANT-ID': config.tenantId,
-          Authorization: `Bearer ${token}`,
+      const response = await axios.post(
+        url,
+        {},
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+          },
         },
-      });
+      );
 
-      return response.data;
+      const templates = response.data?.data || response.data?.templates || response.data || [];
+
+      // Format the response with templateName as both label and value
+      const formattedTemplates = Array.isArray(templates)
+        ? templates.map((template: any) => ({
+            label: template.templateName,
+            value: template.templateName,
+          }))
+        : [];
+
+      return {
+        success: true,
+        data: formattedTemplates,
+      };
     } catch (error) {
-      this.logger.error(
-        'Failed to get Tubelight templates',
-        error.response?.data || error.message,
-      );
-      throw new Error(
-        `Failed to get templates: ${this.extractErrorMessage(error)}`,
-      );
+      let errorMessage = 'Failed to fetch Tubelight templates';
+
+      if (error.response?.status === 401) {
+        errorMessage = 'Authentication failed';
+      } else if (error.response?.data?.message) {
+        errorMessage = error.response.data.message;
+      } else if (error.response?.data?.error) {
+        errorMessage = error.response.data.error;
+      } else if (error.message) {
+        errorMessage = error.message;
+      }
+
+      this.logger.error('Failed to get Tubelight templates', errorMessage);
+
+      return {
+        success: false,
+        error: errorMessage,
+      };
     }
   }
 
@@ -408,7 +351,6 @@ export class TubelightWhatsAppStrategy implements IntegrationStrategy {
 
       const response = await axios.get(url, {
         headers: {
-          'X-TENANT-ID': config.tenantId,
           Authorization: `Bearer ${token}`,
         },
       });

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

@@ -65,7 +65,12 @@ 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) {