在柬埔寨发送短信的最佳做法

import { Twilio } from 'twilio';

// Initialize client with environment variables
const client = new Twilio(
  process.env.TWILIO_ACCOUNT_SID,
  process.env.TWILIO_AUTH_TOKEN
);

async function sendSMSCambodia(
  to: string,
  message: string,
  senderId: string
): Promise<void> {
  try {
    // Send message with error handling
    const response = await client.messages.create({
      from: senderId,  // Registered alphanumeric sender ID
      to: to,         // Format: +85512345678
      body: message,
      // Optional parameters for delivery tracking
      statusCallback: 'https://your-callback-url.com/status'
    });
    
    console.log(`Message sent successfully: ${response.sid}`);
  } catch (error) {
    console.error('Error sending message:', error);
    throw error;
  }
}

import axios from 'axios';

interface SinchMessage {
  from: string;
  to: string[];
  body: string;
  delivery_report: string;
}

async function sendSinchSMS(
  apiToken: string,
  message: SinchMessage
): Promise<void> {
  const baseUrl = 'https://sms.api.sinch.com/xms/v1';
  const servicePlanId = process.env.SINCH_SERVICE_PLAN_ID;

  try {
    const response = await axios.post(
      `${baseUrl}/${servicePlanId}/batches`,
      message,
      {
        headers: {
          'Authorization': `Bearer ${apiToken}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    console.log('Batch ID:', response.data.id);
  } catch (error) {
    console.error('Sinch SMS Error:', error);
    throw error;
  }
}

import messagebird from 'messagebird';

class MessageBirdService {
  private client: any;

  constructor(apiKey: string) {
    this.client = messagebird(apiKey);
  }

  async sendSMS(
    originator: string,
    recipient: string,
    message: string
  ): Promise<void> {
    return new Promise((resolve, reject) => {
      this.client.messages.create({
        originator,
        recipients: [recipient],
        body: message,
        type: 'sms'
      }, (err: any, response: any) => {
        if (err) {
          reject(err);
          return;
        }
        resolve(response);
      });
    });
  }
}

interface SMSError {
  code: string;
  message: string;
  timestamp: Date;
  recipient: string;
}

class SMSErrorHandler {
  private errors: SMSError[] = [];

  logError(error: SMSError): void {
    this.errors.push(error);
    // Implement your logging logic
    console.error(`SMS Error [${error.code}]: ${error.message}`);
  }

  async retryFailedMessages(): Promise<void> {
    // Implement retry logic with exponential backoff
    const retryDelay = (attempt: number) => Math.pow(2, attempt) * 1000;
    // Retry implementation
  }
}