rez_core 2.3.1 → 2.3.4

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.4",
   "description": "",
   "author": "",
   "private": false,

package/src/app.module.ts

@@ -19,6 +19,7 @@ import { DashboardModule } from './module/dashboard/dashboard.module';
 import { IntegrationModule } from './module/integration/integration.module';
 import { ScheduleModule } from '@nestjs/schedule';
 import { AuthModule } from './module/auth/auth.module';
+import { MapperModule } from './module/mapper/mapper.module';
 
 @Module({
   imports: [
@@ -41,6 +42,7 @@ import { AuthModule } from './module/auth/auth.module';
     DashboardModule,
     IntegrationModule,
     AuthModule,
+    MapperModule,
     ScheduleModule.forRoot(),
   ],
 })

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/controller/integration.controller.ts

@@ -15,6 +15,7 @@ import {
 import { IntegrationService } from '../service/integration.service';
 import {
   BulkMessageDto,
+  CheckAgentStatusDto,
   CreateConfigDto,
   CreateUserIntegrationDto,
   GenericSendMessageDto,
@@ -69,6 +70,29 @@ export class IntegrationController {
     return this.integrationService.sendTemplateMessage(templateMessage);
   }
 
+  @Post('check-agent-status')
+  @HttpCode(HttpStatus.OK)
+  async checkAgentStatus(@Body() checkAgentStatusDto: CheckAgentStatusDto) {
+    try {
+      const result = await this.integrationService.checkAgentStatus(
+        checkAgentStatusDto.levelId,
+        checkAgentStatusDto.levelType,
+        checkAgentStatusDto.app_code,
+        checkAgentStatusDto.user_id,
+        checkAgentStatusDto.type || 'TELEPHONE',
+      );
+
+      return result;
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'CHECK_AGENT_STATUS_ERROR',
+        message: error.message || 'Failed to check agent status',
+        code: 'AGENT_STATUS_ERROR',
+      });
+    }
+  }
+
   @Post('config')
   @HttpCode(HttpStatus.OK)
   async createConfig(@Body() createConfigDto: CreateConfigDto) {

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

@@ -473,3 +473,25 @@ export class UpdateUserIntegrationDto {
   @IsBoolean()
   is_active?: boolean;
 }
+
+export class CheckAgentStatusDto {
+  @IsNotEmpty()
+  @IsNumber()
+  levelId: number;
+
+  @IsNotEmpty()
+  @IsString()
+  levelType: string;
+
+  @IsNotEmpty()
+  @IsString()
+  app_code: string;
+
+  @IsNotEmpty()
+  @IsNumber()
+  user_id: number;
+
+  @IsOptional()
+  @IsIn(['TELEPHONE'])
+  type?: 'TELEPHONE';
+}

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

@@ -1,19 +1,52 @@
 import { Injectable } from '@nestjs/common';
+import { BaseFactory } from './base.factory';
 import { IntegrationStrategy } from '../strategies/integration.strategy';
+import { GupshupSmsStrategy } from '../strategies/sms/gupshup-sms.strategy';
+import { TubelightSmsStrategy } from '../strategies/sms/tubelight-sms.strategy';
+import { Msg91SmsStrategy } from '../strategies/sms/msg91-sms.strategy';
 
 @Injectable()
-export class SmsFactory {
+export class SmsFactory implements BaseFactory {
+  constructor(
+    private gupshupSmsStrategy: GupshupSmsStrategy,
+    private tubelightSmsStrategy: TubelightSmsStrategy,
+    private msg91SmsStrategy: Msg91SmsStrategy,
+  ) {}
+
   createProvider(service: string, provider: string): IntegrationStrategy {
-    throw new Error(`SMS integration is not supported. Provider: ${provider}, Service: ${service}`);
+    const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
+
+    switch (key) {
+      case 'api_gupshup':
+      case 'sms_gupshup':
+        return this.gupshupSmsStrategy;
+      case 'api_tubelight':
+      case 'sms_tubelight':
+        return this.tubelightSmsStrategy;
+      case 'api_msg91':
+      case 'sms_msg91':
+        return this.msg91SmsStrategy;
+
+      default:
+        throw new Error(
+          `Unsupported SMS service/provider: ${service}/${provider}`,
+        );
+    }
   }
 
   getSupportedCombinations(): Array<{ service: string; provider: string }> {
-    // Return empty array since no SMS strategies are supported
-    return [];
+    return [
+      { service: 'API', provider: 'gupshup' },
+      { service: 'API', provider: 'tubelight' },
+      { service: 'API', provider: 'msg91' },
+    ];
   }
 
   validateCombination(service: string, provider: string): boolean {
-    // No SMS combinations are valid since we removed all strategies
-    return false;
+    return this.getSupportedCombinations().some(
+      (combo) =>
+        combo.service.toLowerCase() === service.toLowerCase() &&
+        combo.provider.toLowerCase() === provider.toLowerCase(),
+    );
   }
 }

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,13 @@ 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';
+
+// SMS Strategies
+import { GupshupSmsStrategy } from './strategies/sms/gupshup-sms.strategy';
+import { TubelightSmsStrategy } from './strategies/sms/tubelight-sms.strategy';
+import { Msg91SmsStrategy } from './strategies/sms/msg91-sms.strategy';
 
 // New unified strategies
 import { OutlookStrategy } from './strategies/email/outlook.strategy';
@@ -61,6 +68,13 @@ import { UserIntegration } from './entity/user-integration.entity';
     WhatsAppCloudStrategy,
     OzonetelVoiceStrategy,
     TubelightVoiceStrategy,
+    GupshupWhatsAppStrategy,
+    TubelightWhatsAppStrategy,
+
+    // SMS Strategies
+    GupshupSmsStrategy,
+    TubelightSmsStrategy,
+    Msg91SmsStrategy,
 
     // New unified strategies
     OutlookStrategy,

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

@@ -2164,4 +2164,111 @@ export class IntegrationService {
       return null;
     }
   }
+
+  /**
+   * Check agent status for TELEPHONE integration
+   * Currently supports: Ozonetel
+   */
+  async checkAgentStatus(
+    levelId: number,
+    levelType: string,
+    appCode: string,
+    userId: number,
+    integrationType: 'TELEPHONE' = 'TELEPHONE',
+  ): Promise<{
+    success: boolean;
+    isReady?: boolean;
+    state?: string;
+    agentInfo?: any;
+    error?: string;
+  }> {
+    try {
+      // Get the active configuration
+      const config = await this.getSingleActiveConfig(
+        levelId,
+        levelType,
+        appCode,
+        integrationType,
+      );
+
+      if (!config) {
+        return {
+          success: false,
+          error: 'No active TELEPHONE configuration found',
+        };
+      }
+
+      // Get user integration mapping
+      const userIntegration = await this.getUserIntegrationByUserAndConfig(
+        userId,
+        config.id,
+      );
+
+      if (!userIntegration) {
+        return {
+          success: false,
+          error: 'User integration mapping not found. Please configure agent details.',
+        };
+      }
+
+      // Create strategy instance
+      const strategy = this.integrationFactory.create(
+        config.integration_type,
+        'API', // service is deprecated, using default
+        config.integration_provider,
+      );
+
+      // Get the merged config with user data
+      let mergedConfig = config.config_json;
+
+      if (strategy.createUserSpecificConfig) {
+        mergedConfig = strategy.createUserSpecificConfig(
+          config.config_json,
+          userIntegration.external_user_id,
+        );
+      }
+
+      // Check if strategy is Ozonetel (currently only Ozonetel supports status check)
+      if (config.integration_provider.toLowerCase() === 'ozonetel') {
+        const ozonetelStrategy = strategy as any;
+
+        // Generate token
+        const token = await ozonetelStrategy.generateToken(mergedConfig);
+        if (!token) {
+          return {
+            success: false,
+            error: 'Failed to authenticate with telephone provider',
+          };
+        }
+
+        // Check agent status
+        const statusResult = await ozonetelStrategy.checkAgentStatus(
+          mergedConfig,
+          token,
+        );
+
+        return {
+          success: true,
+          isReady: statusResult.isReady,
+          state: statusResult.state,
+          error: statusResult.error,
+        };
+      }
+
+      // For other providers, return not supported
+      return {
+        success: false,
+        error: `Agent status check not supported for provider: ${config.integration_provider}`,
+      };
+    } catch (error) {
+      this.logger.error(
+        `Error checking agent status: ${error.message}`,
+        error.stack,
+      );
+      return {
+        success: false,
+        error: error.message || 'Failed to check agent status',
+      };
+    }
+  }
 }

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

@@ -0,0 +1,146 @@
+import { Injectable, Logger } from '@nestjs/common';
+import axios, { AxiosResponse } from 'axios';
+import {
+  IntegrationStrategy,
+  IntegrationResult,
+} from '../integration.strategy';
+
+interface GupshupSmsConfig {
+  apiKey: string;
+  sourceNumber: string;
+  baseUrl?: string;
+  method?: string; // 'SendMessage' or 'SendSMS'
+}
+
+interface GupshupSmsApiResponse {
+  status: string;
+  messageId?: string;
+  response?: {
+    id: string;
+    phone: string;
+    details: string;
+  };
+  error?: {
+    code: number;
+    message: string;
+  };
+}
+
+@Injectable()
+export class GupshupSmsStrategy implements IntegrationStrategy {
+  private readonly logger = new Logger(GupshupSmsStrategy.name);
+  private readonly defaultBaseUrl = 'https://enterprise.smsgupshup.com/GatewayAPI/rest';
+
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<IntegrationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Gupshup SMS configuration');
+      }
+
+      const gupshupConfig = config as GupshupSmsConfig;
+      const baseUrl = gupshupConfig.baseUrl || this.defaultBaseUrl;
+      const method = gupshupConfig.method || 'SendMessage';
+
+      const params = new URLSearchParams();
+      params.append('method', method);
+      params.append('send_to', this.formatPhoneNumber(to));
+      params.append('msg', message);
+      params.append('msg_type', 'TEXT');
+      params.append('userid', gupshupConfig.apiKey);
+      params.append('auth_scheme', 'plain');
+      params.append('v', '1.1');
+      params.append('format', 'text');
+
+      const url = `${baseUrl}?${params.toString()}`;
+
+      const response: AxiosResponse = await axios.get(url, {
+        timeout: 30000,
+      });
+
+      // Gupshup SMS API returns text response like: "success | message-id"
+      const responseText = response.data?.toString() || '';
+
+      if (responseText.toLowerCase().includes('success')) {
+        const parts = responseText.split('|');
+        const messageId = parts.length > 1 ? parts[1].trim() : new Date().getTime().toString();
+
+        this.logger.log(
+          `Gupshup SMS sent successfully to ${to}, messageId: ${messageId}`,
+        );
+
+        return {
+          success: true,
+          messageId: messageId,
+          provider: 'gupshup',
+          service: 'SMS',
+          timestamp: new Date(),
+        };
+      } else {
+        throw new Error(responseText || 'Failed to send SMS via Gupshup');
+      }
+    } catch (error) {
+      this.logger.error(
+        `Failed to send Gupshup SMS to ${to}`,
+        error.response?.data || error.message,
+      );
+
+      return {
+        success: false,
+        provider: 'gupshup',
+        service: 'SMS',
+        error: this.extractErrorMessage(error),
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  private formatPhoneNumber(phoneNumber: string): string {
+    // Remove any non-digit characters except +
+    let formatted = phoneNumber.replace(/[^\d+]/g, '');
+
+    // Remove + if present as Gupshup expects just numbers
+    formatted = formatted.replace(/\+/g, '');
+
+    return formatted;
+  }
+
+  private extractErrorMessage(error: any): string {
+    if (error.response?.data) {
+      const data = error.response.data.toString();
+      if (data) {
+        return data;
+      }
+    }
+
+    if (error.response?.data?.error?.message) {
+      return error.response.data.error.message;
+    }
+
+    if (error.response?.data?.message) {
+      return error.response.data.message;
+    }
+
+    if (error.message) {
+      return error.message;
+    }
+
+    return 'Unknown Gupshup SMS API error';
+  }
+
+  validateConfig(config: any): boolean {
+    if (!config || typeof config !== 'object') {
+      return false;
+    }
+
+    // Required fields
+    if (!config.apiKey || !config.sourceNumber) {
+      return false;
+    }
+
+    return true;
+  }
+}