Passer au contenu principal

​
Vue d’ensemble

Vous devez vérifier le statut des paiements car le traitement bancaire est asynchrone. Utilisez deux méthodes simples :
  1. Tâche cron : Vérifiez les commandes en attente toutes les 20 minutes
  2. Vérification manuelle : Lorsque le client consulte sa commande

​
Méthode 1 : Tâche cron (toutes les 20 minutes)

const cron = require("node-cron");

// Exécuter toutes les 20 minutes
cron.schedule("*/20 * * * *", async () => {
  console.log("Vérification des paiements en attente...");

  try {
    // Récupérer les commandes en attente des dernières 24 heures
    const pendingOrders = await db.orders.find({
      status: "PENDING",
      paymentRef: { $exists: true },
      createdAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) },
    });

    for (const order of pendingOrders) {
      await checkAndUpdateOrder(order.id, order.paymentRef);
      await sleep(100); // Petit délai entre les requêtes
    }

    console.log(`Vérifié ${pendingOrders.length} commandes`);
  } catch (error) {
    console.error("Erreur tâche cron :", error);
  }
});

async function checkAndUpdateOrder(orderId, paymentRef) {
  try {
    const response = await fetch(
      `https://api.oneclickdz.com/v3/ocpay/checkPayment/${paymentRef}`,
      {
        headers: { "X-Access-Token": process.env.ONECLICK_API_KEY },
      }
    );

    const data = await response.json();
    const status = data.data.status;

    if (status === "CONFIRMED") {
      await db.orders.update(orderId, { status: "PAID" });
      console.log(`✅ Commande ${orderId} marquée comme PAYÉE`);
    } else if (status === "FAILED") {
      await db.orders.update(orderId, { status: "FAILED" });
      console.log(`❌ Commande ${orderId} marquée comme ÉCHOUÉE`);
    }
  } catch (error) {
    console.error(`Erreur vérification commande ${orderId} :`, error);
  }
}

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

​
Configurer la tâche cron

Ajoutez à votre crontab (Linux/Unix) : 
# Modifier le crontab
crontab -e

# Ajouter une ligne pour exécuter toutes les 20 minutes
*/20 * * * * /usr/bin/node /path/to/cron-job.js >> /var/log/payment-check.log 2>&1

# Ou pour Python
*/20 * * * * /usr/bin/python3 /path/to/cron-job.py >> /var/log/payment-check.log 2>&1

# Ou pour PHP
*/20 * * * * /usr/bin/php /path/to/cron-check-payments.php >> /var/log/payment-check.log 2>&1

​
Méthode 2 : Vérification manuelle (quand le client consulte sa commande)

Déjà implémenté à l’Étape 2 ! Quand le client arrive sur la page de commande, elle vérifie automatiquement une fois. Optionnel : Ajoutez un bouton pour vérifier à la demande (vérifie au maximum toutes les minutes) : 
<!DOCTYPE html>
<html>
  <head>
    <title>Statut de la commande</title>
  </head>
  <body>
    <h1>Statut de la commande</h1>
    <p>Statut : <span id="status">PENDING</span></p>

    <button id="checkBtn" onclick="startChecking()">
      Check Payment Status
    </button>

    <p id="message"></p>

    <script>
      let checking = false;
      let checkInterval = null;
      const orderId = window.location.pathname.split("/").pop();

      async function checkPayment() {
        const response = await fetch(`/orders/${orderId}/check`, {
          method: "POST",
        });

        const data = await response.json();
        document.getElementById("status").textContent = data.status;

        if (data.status === "CONFIRMED") {
          document.getElementById("message").textContent =
            "✅ Paiement confirmé !";
          stopChecking();
          setTimeout(() => location.reload(), 2000);
        } else if (data.status === "FAILED") {
          document.getElementById("message").textContent = "❌ Paiement échoué";
          stopChecking();
        } else {
          document.getElementById("message").textContent =
            "⏳ Toujours en attente...";
        }
      }

      function startChecking() {
        if (checking) return;

        checking = true;
        document.getElementById("checkBtn").disabled = true;

        // Check immediately
        checkPayment();

        // Puis vérifier toutes les minutes
        checkInterval = setInterval(checkPayment, 60000);

        // Arrêter après 10 minutes
        setTimeout(stopChecking, 10 * 60000);
      }

      function stopChecking() {
        checking = false;
        document.getElementById("checkBtn").disabled = false;
        if (checkInterval) {
          clearInterval(checkInterval);
          checkInterval = null;
        }
      }

      // Vérification automatique au chargement (si en attente)
      if (document.getElementById("status").textContent === "PENDING") {
        checkPayment();
      }
    </script>
  </body>
</html>

​
Résumé

Deux méthodes simples :
  1. ✅ Tâche cron toutes les 20 minutes pour toutes les commandes en attente
  2. ✅ Vérification manuelle quand le client consulte sa commande (maximum toutes les minutes)
  3. ✅ Vérification automatique une fois au chargement de la page de commande
Cela couvre tous les scénarios sans surcharger l’API !

​
Prochaines étapes

Continuer vers les bonnes pratiques

Apprenez les bonnes pratiques de sécurité et de gestion des erreurs