马其顿短信最佳实践、合规性和功能

import { Twilio } from 'twilio';

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

// Function to send SMS to Macedonia
async function sendSMSToMacedonia(
  to: string,
  message: string,
  senderId: string
) {
  try {
    // Ensure proper formatting for Macedonia numbers (+389)
    const formattedNumber = to.startsWith('+389') ? to : `+389${to}`;
    
    const response = await client.messages.create({
      body: message,
      from: senderId, // Alphanumeric sender ID
      to: formattedNumber,
      // Optional parameters for delivery tracking
      statusCallback: 'https://your-webhook.com/status'
    });
    
    return response.sid;
  } catch (error) {
    console.error('SMS sending failed:', error);
    throw error;
  }
}

import axios from 'axios';

class SinchSMSClient {
  private readonly apiToken: string;
  private readonly serviceId: string;
  
  constructor(apiToken: string, serviceId: string) {
    this.apiToken = apiToken;
    this.serviceId = serviceId;
  }

  async sendSMS(to: string, message: string) {
    const url = `https://sms.api.sinch.com/xms/v1/${this.serviceId}/batches`;
    
    try {
      const response = await axios.post(
        url,
        {
          from: 'YourBrand', // Alphanumeric sender ID
          to: [to],
          body: message,
          encoding: 'AUTO' // Automatically handles Cyrillic
        },
        {
          headers: {
            'Authorization': `Bearer ${this.apiToken}`,
            'Content-Type': 'application/json'
          }
        }
      );
      
      return response.data.id;
    } catch (error) {
      console.error('Sinch SMS failed:', error);
      throw error;
    }
  }
}

import { MessageBird } from 'messagebird';

class MessageBirdSMS {
  private client: MessageBird;
  
  constructor(apiKey: string) {
    this.client = new MessageBird(apiKey);
  }

  sendSMS(
    recipient: string,
    message: string,
    originator: string
  ): Promise<any> {
    return new Promise((resolve, reject) => {
      this.client.messages.create({
        originator, // Max 11 characters for alphanumeric
        recipients: [recipient],
        body: message,
        datacoding: 'unicode' // For Cyrillic support
      }, (err, response) => {
        if (err) {
          reject(err);
        } else {
          resolve(response);
        }
      });
    });
  }
}

import * as plivo from 'plivo';

class PlivoSMSService {
  private client: plivo.Client;
  
  constructor(authId: string, authToken: string) {
    this.client = new plivo.Client(authId, authToken);
  }

  async sendBulkSMS(
    recipients: string[],
    message: string,
    senderId: string
  ) {
    try {
      const response = await this.client.messages.create({
        src: senderId,
        dst: recipients.join('<'), // Bulk sending format
        text: message,
        // Optional parameters
        url_strip_query: false,
        method: 'POST'
      });
      
      return response;
    } catch (error) {
      console.error('Plivo SMS failed:', error);
      throw error;
    }
  }
}