rez_core 2.3.2 → 2.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.3.2",
+  "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/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/integration.module.ts

@@ -20,6 +20,11 @@ import { TubelightVoiceStrategy } from './strategies/telephone/tubelight-voice.s
 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';
 import { WhatsAppStrategy } from './strategies/whatsapp/whatsapp.strategy';
@@ -66,6 +71,11 @@ import { UserIntegration } from './entity/user-integration.entity';
     GupshupWhatsAppStrategy,
     TubelightWhatsAppStrategy,
 
+    // SMS Strategies
+    GupshupSmsStrategy,
+    TubelightSmsStrategy,
+    Msg91SmsStrategy,
+
     // New unified strategies
     OutlookStrategy,
     WhatsAppStrategy,

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;
+  }
+}

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

@@ -0,0 +1,164 @@
+import { Injectable, Logger } from '@nestjs/common';
+import axios, { AxiosResponse } from 'axios';
+import {
+  IntegrationStrategy,
+  IntegrationResult,
+} from '../integration.strategy';
+
+interface Msg91SmsConfig {
+  authKey: string;
+  senderId: string;
+  route?: string; // Route like '4' for transactional, '1' for promotional
+  baseUrl?: string;
+  dltTemplateId?: string;
+  entityId?: string;
+}
+
+interface Msg91SmsApiResponse {
+  type: string;
+  message?: string;
+  request_id?: string;
+  error?: {
+    code: string;
+    message: string;
+  };
+}
+
+@Injectable()
+export class Msg91SmsStrategy implements IntegrationStrategy {
+  private readonly logger = new Logger(Msg91SmsStrategy.name);
+  private readonly defaultBaseUrl = 'https://api.msg91.com/api/v5';
+
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<IntegrationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid MSG91 SMS configuration');
+      }
+
+      const msg91Config = config as Msg91SmsConfig;
+      const baseUrl = msg91Config.baseUrl || this.defaultBaseUrl;
+      const url = `${baseUrl}/flow`;
+
+      const payload = {
+        sender: msg91Config.senderId,
+        route: msg91Config.route || '4', // Default to transactional
+        country: '91', // Default to India
+        sms: [
+          {
+            message: message,
+            to: [this.formatPhoneNumber(to)],
+          },
+        ],
+      };
+
+      // Add DLT Template ID if provided
+      if (msg91Config.dltTemplateId) {
+        payload['DLT_TE_ID'] = msg91Config.dltTemplateId;
+      }
+
+      // Add Entity ID if provided
+      if (msg91Config.entityId) {
+        payload['DLT_PE_ID'] = msg91Config.entityId;
+      }
+
+      const response: AxiosResponse<Msg91SmsApiResponse> = await axios.post(
+        url,
+        payload,
+        {
+          headers: {
+            authkey: msg91Config.authKey,
+            'Content-Type': 'application/json',
+          },
+          timeout: 30000,
+        },
+      );
+
+      if (
+        response.data?.type === 'success' ||
+        response.status === 200
+      ) {
+        const messageId =
+          response.data?.request_id || new Date().getTime().toString();
+
+        this.logger.log(
+          `MSG91 SMS sent successfully to ${to}, messageId: ${messageId}`,
+        );
+
+        return {
+          success: true,
+          messageId: messageId,
+          provider: 'msg91',
+          service: 'SMS',
+          timestamp: new Date(),
+        };
+      } else {
+        throw new Error(
+          response.data?.error?.message ||
+            response.data?.message ||
+            'Failed to send SMS via MSG91',
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Failed to send MSG91 SMS to ${to}`,
+        error.response?.data || error.message,
+      );
+
+      return {
+        success: false,
+        provider: 'msg91',
+        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
+    formatted = formatted.replace(/\+/g, '');
+
+    // Remove country code if it's 91 (India) as MSG91 handles it separately
+    if (formatted.startsWith('91')) {
+      formatted = formatted.substring(2);
+    }
+
+    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.message) {
+      return error.message;
+    }
+
+    return 'Unknown MSG91 SMS API error';
+  }
+
+  validateConfig(config: any): boolean {
+    if (!config || typeof config !== 'object') {
+      return false;
+    }
+
+    // Required fields
+    if (!config.authKey || !config.senderId) {
+      return false;
+    }
+
+    return true;
+  }
+}