rez_core 2.3.1 → 2.3.2

package/docs/modules/integration.md

@@ -139,7 +139,7 @@ export class IntegrationService {
 ```json
 {
   "app_code": "MYAPP",
-  "integration_type": "WA", 
+  "integration_type": "WA",
   "integration_provider": "whatsapp",
   "integration_source_id": 3,
   "config_json": {
@@ -150,6 +150,60 @@ export class IntegrationService {
 }
 ```
 
+### Gupshup WhatsApp
+```json
+{
+  "app_code": "MYAPP",
+  "integration_type": "WA",
+  "integration_provider": "gupshup",
+  "integration_source_id": 4,
+  "config_json": {
+    "apiKey": "your-gupshup-api-key",
+    "appName": "your-app-name",
+    "sourceNumber": "your-source-number",
+    "baseUrl": "https://api.gupshup.io/sm/api/v1"
+  }
+}
+```
+
+**Gupshup Message Types:**
+- **Text Message**: Default type, just send message
+- **Template**: Requires `messageType: "template"`, `templateId`, optional `templateParams`
+- **Image**: Requires `messageType: "image"`, `mediaUrl`, optional `previewUrl`, `caption`
+- **Document**: Requires `messageType: "document"`, `mediaUrl`, optional `filename`, `caption`
+- **Audio**: Requires `messageType: "audio"`, `mediaUrl`
+- **Video**: Requires `messageType: "video"`, `mediaUrl`, optional `caption`
+- **Location**: Requires `messageType: "location"`, `latitude`, `longitude`, optional `locationName`, `locationAddress`
+- **List**: Requires `messageType: "list"`, `listItems`, optional `listTitle`, `globalButtons`
+- **Quick Reply**: Requires `messageType: "quick_reply"`, `quickReplyOptions`
+
+### Tubelight WhatsApp
+```json
+{
+  "app_code": "MYAPP",
+  "integration_type": "WA",
+  "integration_provider": "tubelight",
+  "integration_source_id": 5,
+  "config_json": {
+    "userName": "your-tubelight-username",
+    "password": "your-tubelight-password",
+    "tenantId": "your-tenant-id",
+    "sourceNumber": "your-source-number",
+    "baseUrl": "https://portal.tubelightcommunications.com/whatsapp/api/v1"
+  }
+}
+```
+
+**Tubelight Message Types:**
+- **Text Message**: Default type with `messageType: "TEXT"` or no messageType specified
+- **Template**: Requires `messageType: "template"`, `templateId`, optional `templateParams`, `templateLanguage` (default: "en")
+- **Image**: Requires `messageType: "image"`, `mediaUrl`, optional `caption`
+- **Document**: Requires `messageType: "document"`, `mediaUrl`, optional `filename`, `caption`
+- **Audio**: Requires `messageType: "audio"`, `mediaUrl`
+- **Video**: Requires `messageType: "video"`, `mediaUrl`, optional `caption`
+- **Location**: Requires `messageType: "location"`, `latitude`, `longitude`, optional `locationName`, `locationAddress`
+- **Interactive**: Requires `messageType: "interactive"`, `interactiveType` ("button" or "list"), optional `buttons`, `sections`, `header`, `footer`
+
 ### Knowlarity Voice
 ```json
 {

package/package.json

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

package/src/module/enterprise/repository/school.repository.ts

@@ -37,7 +37,6 @@ export class SchoolRepository {
       .andWhere('urm.level_type = :levelType', { levelType: 'ORG' })
       .getRawMany();
 
-    console.log('hasOrgAccess', hasOrgAccess);
 
     let currentORGLevel_id = hasOrgAccess[0]?.urm_level_id;
     if (hasOrgAccess[0]?.urm_level_id == 1) {

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

@@ -35,7 +35,6 @@ export class SavedFilterRepositoryService {
   }
 
   async getDetailsByCode(code: string): Promise<SavedFilterDetail[]> {
-    console.log("IN GET DETAILS BY CODE", code);
     return this.savedFilterDetailRepo.find({
       where: { mapped_filter_code: code },
     });

package/src/module/integration/factories/whatsapp.factory.ts

@@ -3,12 +3,16 @@ import { BaseFactory } from './base.factory';
 import { IntegrationStrategy } from '../strategies/integration.strategy';
 import { WhatsAppStrategy } from '../strategies/whatsapp/whatsapp.strategy';
 import { WhatsAppCloudStrategy } from '../strategies/whatsapp/whatsapp-cloud.strategy';
+import { GupshupWhatsAppStrategy } from '../strategies/whatsapp/gupshup-whatsapp.strategy';
+import { TubelightWhatsAppStrategy } from '../strategies/whatsapp/tubelight-whatsapp.strategy';
 
 @Injectable()
 export class WhatsAppFactory implements BaseFactory {
   constructor(
     private whatsappStrategy: WhatsAppStrategy,
     private whatsappCloudStrategy: WhatsAppCloudStrategy,
+    private gupshupWhatsAppStrategy: GupshupWhatsAppStrategy,
+    private tubelightWhatsAppStrategy: TubelightWhatsAppStrategy,
   ) {}
 
   createProvider(service: string, provider: string): IntegrationStrategy {
@@ -20,6 +24,10 @@ export class WhatsAppFactory implements BaseFactory {
       case 'api_whatsapp-cloud':
       case 'api_meta':
         return this.whatsappCloudStrategy;
+      case 'api_gupshup':
+        return this.gupshupWhatsAppStrategy;
+      case 'api_tubelight':
+        return this.tubelightWhatsAppStrategy;
 
       default:
         throw new Error(
@@ -33,6 +41,8 @@ export class WhatsAppFactory implements BaseFactory {
       { service: 'API', provider: 'whatsapp' },
       { service: 'API', provider: 'whatsapp-cloud' },
       { service: 'API', provider: 'meta' },
+      { service: 'API', provider: 'gupshup' },
+      { service: 'API', provider: 'tubelight' },
     ];
   }
 

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

@@ -17,6 +17,8 @@ import { SendGridApiStrategy } from './strategies/email/sendgrid-api.strategy';
 import { WhatsAppCloudStrategy } from './strategies/whatsapp/whatsapp-cloud.strategy';
 import { OzonetelVoiceStrategy } from './strategies/telephone/ozonetel-voice.strategy';
 import { TubelightVoiceStrategy } from './strategies/telephone/tubelight-voice.strategy';
+import { GupshupWhatsAppStrategy } from './strategies/whatsapp/gupshup-whatsapp.strategy';
+import { TubelightWhatsAppStrategy } from './strategies/whatsapp/tubelight-whatsapp.strategy';
 
 // New unified strategies
 import { OutlookStrategy } from './strategies/email/outlook.strategy';
@@ -61,6 +63,8 @@ import { UserIntegration } from './entity/user-integration.entity';
     WhatsAppCloudStrategy,
     OzonetelVoiceStrategy,
     TubelightVoiceStrategy,
+    GupshupWhatsAppStrategy,
+    TubelightWhatsAppStrategy,
 
     // New unified strategies
     OutlookStrategy,

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

@@ -0,0 +1,360 @@
+import { Injectable, Logger } from '@nestjs/common';
+import axios, { AxiosResponse } from 'axios';
+import {
+  IntegrationStrategy,
+  IntegrationResult,
+} from '../integration.strategy';
+
+interface GupshupConfig {
+  apiKey: string;
+  appName: string;
+  sourceNumber: string;
+  baseUrl?: string;
+}
+
+interface GupshupMessage {
+  channel: string;
+  source: string;
+  destination: string;
+  'src.name': string;
+  message: {
+    type: string;
+    text?: string;
+    url?: string;
+    caption?: string;
+    filename?: string;
+  };
+}
+
+interface GupshupApiResponse {
+  status: string;
+  messageId?: string;
+  response?: {
+    id: string;
+    phone: string;
+    details: string;
+  };
+  error?: {
+    code: number;
+    message: string;
+  };
+}
+
+@Injectable()
+export class GupshupWhatsAppStrategy implements IntegrationStrategy {
+  private readonly logger = new Logger(GupshupWhatsAppStrategy.name);
+  private readonly defaultBaseUrl = 'https://api.gupshup.io/sm/api/v1';
+
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<IntegrationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Gupshup WhatsApp configuration');
+      }
+
+      const gupshupConfig = config as GupshupConfig;
+      const baseUrl = gupshupConfig.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/msg`;
+
+      const payload = this.prepareMessagePayload(to, message, config);
+
+      const response: AxiosResponse<GupshupApiResponse> = await axios.post(
+        url,
+        payload,
+        {
+          headers: {
+            apikey: gupshupConfig.apiKey,
+            'Content-Type': 'application/x-www-form-urlencoded',
+          },
+          timeout: 30000,
+        },
+      );
+
+      if (response.data?.status === 'submitted' && response.data?.messageId) {
+        this.logger.log(
+          `Gupshup WhatsApp message sent successfully to ${to}, messageId: ${response.data.messageId}`,
+        );
+
+        return {
+          success: true,
+          messageId: response.data.messageId,
+          provider: 'gupshup',
+          service: 'API',
+          timestamp: new Date(),
+        };
+      } else if (response.data?.response?.id) {
+        this.logger.log(
+          `Gupshup WhatsApp message sent successfully to ${to}, messageId: ${response.data.response.id}`,
+        );
+
+        return {
+          success: true,
+          messageId: response.data.response.id,
+          provider: 'gupshup',
+          service: 'API',
+          timestamp: new Date(),
+        };
+      } else {
+        throw new Error(
+          response.data?.error?.message || 'Invalid response from Gupshup API',
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Failed to send Gupshup WhatsApp message to ${to}`,
+        error.response?.data || error.message,
+      );
+
+      return {
+        success: false,
+        provider: 'gupshup',
+        service: 'API',
+        error: this.extractErrorMessage(error),
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  private prepareMessagePayload(
+    to: string,
+    message: string,
+    config: any,
+  ): URLSearchParams {
+    const gupshupConfig = config as GupshupConfig;
+    const params = new URLSearchParams();
+
+    params.append('channel', 'whatsapp');
+    params.append('source', gupshupConfig.sourceNumber);
+    params.append('destination', this.formatPhoneNumber(to));
+    params.append('src.name', gupshupConfig.appName);
+
+    // Handle different message types based on config
+    if (config.messageType) {
+      switch (config.messageType) {
+        case 'template':
+          params.append('message', JSON.stringify({
+            type: 'template',
+            template: {
+              id: config.templateId,
+              params: config.templateParams || [],
+            },
+          }));
+          break;
+
+        case 'image':
+          params.append('message', JSON.stringify({
+            type: 'image',
+            originalUrl: config.mediaUrl,
+            previewUrl: config.previewUrl || config.mediaUrl,
+            caption: message || config.caption || '',
+          }));
+          break;
+
+        case 'document':
+          params.append('message', JSON.stringify({
+            type: 'file',
+            url: config.mediaUrl,
+            filename: config.filename || 'document',
+            caption: message || config.caption || '',
+          }));
+          break;
+
+        case 'audio':
+          params.append('message', JSON.stringify({
+            type: 'audio',
+            url: config.mediaUrl,
+          }));
+          break;
+
+        case 'video':
+          params.append('message', JSON.stringify({
+            type: 'video',
+            url: config.mediaUrl,
+            caption: message || config.caption || '',
+          }));
+          break;
+
+        case 'location':
+          params.append('message', JSON.stringify({
+            type: 'location',
+            longitude: config.longitude,
+            latitude: config.latitude,
+            name: config.locationName || '',
+            address: config.locationAddress || '',
+          }));
+          break;
+
+        case 'list':
+          params.append('message', JSON.stringify({
+            type: 'list',
+            title: config.listTitle || 'Select an option',
+            body: message,
+            globalButtons: config.globalButtons || [],
+            items: config.listItems || [],
+          }));
+          break;
+
+        case 'quick_reply':
+          params.append('message', JSON.stringify({
+            type: 'quick_reply',
+            content: {
+              type: 'text',
+              text: message,
+            },
+            options: config.quickReplyOptions || [],
+          }));
+          break;
+
+        default:
+          // Fall back to text message
+          break;
+      }
+    }
+
+    // Default text message if no specific type or fallback
+    if (!config.messageType || !['template', 'image', 'document', 'audio', 'video', 'location', 'list', 'quick_reply'].includes(config.messageType)) {
+      params.append('message', JSON.stringify({
+        type: 'text',
+        text: message,
+      }));
+    }
+
+    return params;
+  }
+
+  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('+')) {
+      // Add + if missing
+      formatted = `+${formatted}`;
+    }
+
+    return formatted;
+  }
+
+  private extractErrorMessage(error: any): string {
+    if (error.response?.data?.error?.message) {
+      return error.response.data.error.message;
+    }
+
+    if (error.response?.data?.message) {
+      return error.response.data.message;
+    }
+
+    if (error.response?.data?.response?.details) {
+      return error.response.data.response.details;
+    }
+
+    if (error.message) {
+      return error.message;
+    }
+
+    return 'Unknown Gupshup API error';
+  }
+
+  validateConfig(config: any): boolean {
+    if (!config || typeof config !== 'object') {
+      return false;
+    }
+
+    // Required fields
+    if (!config.apiKey || !config.appName || !config.sourceNumber) {
+      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 'list':
+          if (!config.listItems || !Array.isArray(config.listItems)) {
+            return false;
+          }
+          break;
+
+        case 'quick_reply':
+          if (!config.quickReplyOptions || !Array.isArray(config.quickReplyOptions)) {
+            return false;
+          }
+          break;
+      }
+    }
+
+    return true;
+  }
+
+  async getAppInfo(config: GupshupConfig): Promise<any> {
+    try {
+      const baseUrl = config.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/app`;
+
+      const response = await axios.get(url, {
+        headers: {
+          apikey: config.apiKey,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      this.logger.error(
+        'Failed to get Gupshup app info',
+        error.response?.data || error.message,
+      );
+      throw new Error(
+        `Failed to get app info: ${this.extractErrorMessage(error)}`,
+      );
+    }
+  }
+
+  async getTemplates(config: GupshupConfig): Promise<any> {
+    try {
+      const baseUrl = config.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/template/list/${config.appName}`;
+
+      const response = await axios.get(url, {
+        headers: {
+          apikey: config.apiKey,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      this.logger.error(
+        'Failed to get Gupshup templates',
+        error.response?.data || error.message,
+      );
+      throw new Error(
+        `Failed to get templates: ${this.extractErrorMessage(error)}`,
+      );
+    }
+  }
+}