Guide de dépannage

{
  "success": false,
  "message": "Validation failed",
  "errors": [
    {
      "path": ["phoneNumber"],
      "message": "Required"
    }
  ]
}

{
  "success": false,
  "message": "Validation failed",
  "errors": [
    {
      "path": ["phoneNumber"],
      "message": "Invalid phone number format"
    }
  ]
}

async function sendMessage(phoneNumber, message) {
  console.log("Sending message:", { phoneNumber, message });

  try {
    const response = await fetch("https://sms.chinqit.com/api/v2/notify", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "X-API-Key": process.env.API_KEY,
      },
      body: JSON.stringify({ phoneNumber, message }),
    });

    console.log("Response status:", response.status);
    const data = await response.json();
    console.log("Response data:", data);

    return data;
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

import requests
import logging

logging.basicConfig(level=logging.DEBUG)

def send_message(phone_number, message):
    url = 'https://sms.chinqit.com/api/v2/notify'
    headers = {
        'Content-Type': 'application/json',
        'X-API-Key': os.getenv('API_KEY')
    }
    data = {
        'phoneNumber': phone_number,
        'message': message
    }

    logging.debug(f'Sending request: {data}')
    response = requests.post(url, json=data, headers=headers)
    logging.debug(f'Response status: {response.status_code}')
    logging.debug(f'Response data: {response.json()}')

    return response.json()

# Tester la connectivité de base
curl -X POST https://sms.chinqit.com/api/v2/notify \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phoneNumber": "+1234567890", "message": "Test"}'

class OTPService {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = "https://sms.chinqit.com/api/v2";
  }

  async sendOTPWithRetry(
    phoneNumber,
    language = "fr",
    channel = "sms",
    maxRetries = 3,
  ) {
    let lastError;

    for (let attempt = 0; attempt <= maxRetries; attempt++) {
      try {
        const response = await this.sendOTP(phoneNumber, language, channel);

        if (response.success) {
          return response;
        }

        // Si c'est une erreur 5xx ou réseau, retenter
        if (this.isRetryableError(response)) {
          if (attempt < maxRetries) {
            const delay = Math.pow(2, attempt) * 1000; // Backoff exponentiel
            await this.sleep(delay);
            continue;
          }
        }

        return response; // Erreur non retry-able
      } catch (error) {
        lastError = error;

        // Erreurs réseau ou 5xx sont retry-ables
        if (this.isRetryableNetworkError(error) && attempt < maxRetries) {
          const delay = Math.pow(2, attempt) * 1000;
          await this.sleep(delay);
          continue;
        }

        throw error;
      }
    }

    throw lastError;
  }

  isRetryableError(response) {
    // Erreurs temporaires du serveur
    return response.status >= 500 && response.status < 600;
  }

  isRetryableNetworkError(error) {
    return (
      error.code === "ECONNRESET" ||
      error.code === "ETIMEDOUT" ||
      error.code === "ENOTFOUND"
    );
  }

  async sendOTP(phoneNumber, language, channel) {
    const response = await fetch(`${this.baseURL}/code`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "X-API-Key": this.apiKey,
      },
      body: JSON.stringify({
        phoneNumber,
        language,
        channel,
      }),
    });

    return response.json();
  }

  sleep(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
}

// Utilisation
const otpService = new OTPService("YOUR_API_KEY");

try {
  const result = await otpService.sendOTPWithRetry("+22238089336", "fr", "sms");
  console.log("OTP envoyé avec succès:", result.messageId);
} catch (error) {
  console.error("Échec définitif de l'envoi OTP:", error.message);
}

async function sendOTPWithChannelFallback(
  phoneNumber,
  language = "fr",
  primaryChannel = "sms",
) {
  const channels =
    primaryChannel === "sms" ? ["sms", "whatsapp"] : ["whatsapp", "sms"];

  for (const channel of channels) {
    try {
      console.log(`Tentative d'envoi OTP via ${channel}...`);

      const response = await fetch("https://sms.chinqit.com/api/v2/code", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "X-API-Key": "YOUR_API_KEY",
        },
        body: JSON.stringify({
          phoneNumber,
          language,
          channel,
        }),
      });

      const result = await response.json();

      if (result.success) {
        console.log(`OTP envoyé avec succès via ${channel}`);
        return {
          ...result,
          channelUsed: channel,
        };
      }

      // Si échec définitif (pas d'erreur temporaire), essayer l'autre canal
      if (!isTemporaryFailure(result)) {
        console.log(
          `${channel} a échoué définitivement, essai de l'autre canal...`,
        );
        continue;
      }

      // Erreur temporaire, ne pas essayer l'autre canal immédiatement
      throw new Error(
        `${channel} temporairement indisponible: ${result.message}`,
      );
    } catch (error) {
      console.error(`Erreur avec ${channel}:`, error.message);

      // Continuer vers l'autre canal seulement si c'est le premier essai
      if (channel === channels[0]) {
        continue;
      }

      throw error;
    }
  }

  throw new Error("Les deux canaux ont échoué");
}

function isTemporaryFailure(result) {
  // Considérer comme temporaire les erreurs 5xx ou certains messages spécifiques
  return (
    result.status >= 500 ||
    result.message?.includes("temporarily unavailable") ||
    result.message?.includes("service unavailable")
  );
}

// Utilisation
try {
  const result = await sendOTPWithChannelFallback("+22238089336", "fr", "sms");
  console.log(`OTP envoyé via ${result.channelUsed}:`, result.messageId);
} catch (error) {
  console.error("Échec sur les deux canaux:", error.message);
}

class OTPVerificationManager {
  constructor() {
    this.deliveryAttempts = 0;
    this.maxDeliveryAttempts = 2;
    this.manualEntryEnabled = false;
  }

  async requestOTP(phoneNumber, language = "fr") {
    this.deliveryAttempts = 0;
    this.manualEntryEnabled = false;

    // Essayer la livraison automatique d'abord
    while (this.deliveryAttempts < this.maxDeliveryAttempts) {
      try {
        this.deliveryAttempts++;
        console.log(
          `Tentative de livraison ${this.deliveryAttempts}/${this.maxDeliveryAttempts}`,
        );

        const result = await this.attemptDelivery(phoneNumber, language);

        if (result.success) {
          return {
            success: true,
            method: "automatic",
            messageId: result.messageId,
            channel: result.channelUsed,
            expiresIn: result.expiresIn,
          };
        }

        // Si échec et c'était la dernière tentative, activer la saisie manuelle
        if (this.deliveryAttempts >= this.maxDeliveryAttempts) {
          console.log(
            "Livraison automatique échouée, activation de la saisie manuelle",
          );
          this.manualEntryEnabled = true;
          return {
            success: false,
            method: "manual_required",
            reason: "delivery_failed",
            message: "Veuillez saisir manuellement le code OTP reçu",
          };
        }

        // Attendre avant la prochaine tentative
        await this.sleep(2000);
      } catch (error) {
        console.error(
          `Tentative ${this.deliveryAttempts} échouée:`,
          error.message,
        );

        if (this.deliveryAttempts >= this.maxDeliveryAttempts) {
          this.manualEntryEnabled = true;
          return {
            success: false,
            method: "manual_required",
            reason: "delivery_error",
            message:
              "Erreur de livraison, veuillez saisir manuellement le code OTP",
          };
        }

        await this.sleep(2000);
      }
    }
  }

  async attemptDelivery(phoneNumber, language) {
    // Utiliser la logique de fallback canal précédente
    return await sendOTPWithChannelFallback(phoneNumber, language);
  }

  async verifyOTP(phoneNumber, otp, channel = null) {
    try {
      const response = await fetch("https://sms.chinqit.com/api/v2/check", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "X-API-Key": "YOUR_API_KEY",
        },
        body: JSON.stringify({
          phoneNumber,
          otp,
          ...(channel && { channel }),
        }),
      });

      const result = await response.json();
      return result;
    } catch (error) {
      throw new Error(`Erreur de vérification: ${error.message}`);
    }
  }

  isManualEntryEnabled() {
    return this.manualEntryEnabled;
  }

  sleep(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
}

// Exemple d'utilisation dans une interface utilisateur
async function handleOTPRequest(phoneNumber) {
  const manager = new OTPVerificationManager();

  // Afficher un indicateur de chargement
  showLoadingSpinner();

  try {
    const result = await manager.requestOTP(phoneNumber);

    hideLoadingSpinner();

    if (result.success) {
      // Livraison automatique réussie
      showSuccessMessage(`Code envoyé via ${result.channel}`);
      showOTPInputField();
    } else if (result.method === "manual_required") {
      // Activer le mode saisie manuelle
      showManualEntryMode();
      showInfoMessage(result.message);

      // Optionnellement, permettre à l'utilisateur de demander un nouveau code
      showResendButton();
    }
  } catch (error) {
    hideLoadingSpinner();
    showErrorMessage("Erreur lors de l'envoi du code. Veuillez réessayer.");
  }
}

async function handleOTPVerification(phoneNumber, otp) {
  const manager = new OTPVerificationManager();

  try {
    const result = await manager.verifyOTP(phoneNumber, otp);

    if (result.success) {
      showSuccessMessage("Vérification réussie !");
      proceedToNextStep();
    } else {
      if (result.retriesLeft > 0) {
        showErrorMessage(
          `Code incorrect. ${result.retriesLeft} tentatives restantes.`,
        );
      } else {
        showErrorMessage("Code incorrect. Demandez un nouveau code.");
        showResendButton();
      }
    }
  } catch (error) {
    showErrorMessage("Erreur de vérification. Veuillez réessayer.");
  }
}

class OTPRateLimiter {
  constructor(maxRequestsPerMinute = 10, maxRequestsPerHour = 50) {
    this.requests = [];
    this.maxPerMinute = maxRequestsPerMinute;
    this.maxPerHour = maxRequestsPerHour;
  }

  canSend(phoneNumber) {
    const now = Date.now();
    const oneMinuteAgo = now - 60000;
    const oneHourAgo = now - 3600000;

    // Nettoyer les anciennes requêtes
    this.requests = this.requests.filter((req) => req.timestamp > oneHourAgo);

    // Compter les requêtes pour ce numéro
    const recentRequests = this.requests.filter(
      (req) => req.phoneNumber === phoneNumber && req.timestamp > oneMinuteAgo,
    );

    const hourlyRequests = this.requests.filter(
      (req) => req.phoneNumber === phoneNumber && req.timestamp > oneHourAgo,
    );

    return (
      recentRequests.length < this.maxPerMinute &&
      hourlyRequests.length < this.maxPerHour
    );
  }

  recordRequest(phoneNumber) {
    this.requests.push({
      phoneNumber,
      timestamp: Date.now(),
    });
  }

  getTimeUntilNextAllowed(phoneNumber) {
    if (this.canSend(phoneNumber)) {
      return 0;
    }

    const now = Date.now();
    const recentRequests = this.requests
      .filter((req) => req.phoneNumber === phoneNumber)
      .sort((a, b) => b.timestamp - a.timestamp);

    if (recentRequests.length >= this.maxPerMinute) {
      const oldestRecent = recentRequests[this.maxPerMinute - 1];
      return Math.max(0, 60000 - (now - oldestRecent.timestamp));
    }

    return 0;
  }
}

// Intégration avec le service OTP
async function sendOTPWithRateLimit(phoneNumber, language) {
  const rateLimiter = new OTPRateLimiter();

  if (!rateLimiter.canSend(phoneNumber)) {
    const waitTime = rateLimiter.getTimeUntilNextAllowed(phoneNumber);
    throw new Error(
      `Trop de requêtes. Réessayez dans ${Math.ceil(waitTime / 1000)} secondes.`,
    );
  }

  try {
    const result = await sendOTPWithChannelFallback(phoneNumber, language);
    rateLimiter.recordRequest(phoneNumber);
    return result;
  } catch (error) {
    // Ne pas compter les échecs réseau comme des requêtes réussies
    throw error;
  }
}

class OTPMetrics {
  constructor() {
    this.metrics = {
      totalRequests: 0,
      successfulDeliveries: 0,
      failedDeliveries: 0,
      channelUsage: { sms: 0, whatsapp: 0 },
      fallbackUsage: 0,
      manualEntryUsage: 0,
      averageDeliveryTime: 0,
    };
  }

  recordAttempt(channel, success, deliveryTime = null) {
    this.metrics.totalRequests++;

    if (success) {
      this.metrics.successfulDeliveries++;
    } else {
      this.metrics.failedDeliveries++;
    }

    this.metrics.channelUsage[channel] =
      (this.metrics.channelUsage[channel] || 0) + 1;

    if (deliveryTime) {
      this.metrics.averageDeliveryTime =
        (this.metrics.averageDeliveryTime + deliveryTime) / 2;
    }
  }

  recordFallback() {
    this.metrics.fallbackUsage++;
  }

  recordManualEntry() {
    this.metrics.manualEntryUsage++;
  }

  getSuccessRate() {
    return this.metrics.totalRequests > 0
      ? (this.metrics.successfulDeliveries / this.metrics.totalRequests) * 100
      : 0;
  }

  getChannelPreference() {
    const smsRate = this.metrics.channelUsage.sms || 0;
    const whatsappRate = this.metrics.channelUsage.whatsapp || 0;
    const total = smsRate + whatsappRate;

    return total > 0
      ? {
          sms: (smsRate / total) * 100,
          whatsapp: (whatsappRate / total) * 100,
        }
      : { sms: 0, whatsapp: 0 };
  }

  logMetrics() {
    console.log("OTP Delivery Metrics:");
    console.log(`- Total requests: ${this.metrics.totalRequests}`);
    console.log(`- Success rate: ${this.getSuccessRate().toFixed(2)}%`);
    console.log(`- Channel usage:`, this.getChannelPreference());
    console.log(`- Fallback usage: ${this.metrics.fallbackUsage}`);
    console.log(`- Manual entry usage: ${this.metrics.manualEntryUsage}`);
    console.log(
      `- Avg delivery time: ${this.metrics.averageDeliveryTime.toFixed(2)}ms`,
    );
  }
}

// Utilisation
const metrics = new OTPMetrics();

// Après chaque tentative de livraison
metrics.recordAttempt("sms", true, 2500);
metrics.recordFallback();
metrics.recordManualEntry();

// Afficher les métriques périodiquement
setInterval(() => metrics.logMetrics(), 3600000); // Toutes les heures