> ## Documentation Index
> Fetch the complete documentation index at: https://docs.oneclickdz.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Stratégies d'Interrogation

> Modèles d'interrogation de statut efficaces pour les opérations asynchrones

## Vue d'ensemble

Bonnes pratiques pour interroger les endpoints API afin de suivre efficacement le statut des commandes.

## Modèle de base d'interrogation

<CodeGroup>
  ```javascript Node.js theme={null}
  async function pollStatus(checkFunction, options = {}) {
    const {
      maxAttempts = 60,
      interval = 5000,
      finalStates = ["FULFILLED", "REFUNDED"],
    } = options;

    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
      const result = await checkFunction();

      if (finalStates.includes(result.status)) {
        return result;
      }

      if (attempt < maxAttempts) {
        await new Promise((resolve) => setTimeout(resolve, interval));
      }
    }

    throw new Error("Polling timeout");
  }

  // Usage
  const result = await pollStatus(() => checkTopupStatus(topupId), {
    maxAttempts: 60,
    interval: 5000,
  });
  ```

  ```python Python theme={null}
  import time

  def poll_status(check_function, max_attempts=60, interval=5, final_states=None):
      if final_states is None:
          final_states = ["FULFILLED", "REFUNDED"]

      for attempt in range(1, max_attempts + 1):
          result = check_function()

          if result['status'] in final_states:
              return result

          if attempt < max_attempts:
              time.sleep(interval)

      raise Exception("Polling timeout")

  # Usage
  result = poll_status(lambda: check_topup_status(topup_id), max_attempts=60, interval=5)
  ```

  ```php PHP theme={null}
  <?php
  function pollStatus($checkFunction, $maxAttempts = 60, $interval = 5, $finalStates = null) {
      if ($finalStates === null) {
          $finalStates = ['FULFILLED', 'REFUNDED'];
      }

      for ($attempt = 1; $attempt <= $maxAttempts; $attempt++) {
          $result = $checkFunction();

          if (in_array($result['status'], $finalStates)) {
              return $result;
          }

          if ($attempt < $maxAttempts) {
              sleep($interval);
          }
      }

      throw new Exception('Polling timeout');
  }

  // Usage
  $result = pollStatus(fn() => checkTopupStatus($topupId), 60, 5);
  ?>
  ```
</CodeGroup>

## Interrogation spécifique par service

### Recharges mobiles (5 minutes max)

<CodeGroup>
  ```javascript Node.js theme={null}
  async function pollMobileTopup(topupId) {
    return await pollStatus(() => checkMobileStatus(topupId), {
      maxAttempts: 60,
      interval: 5000,
      finalStates: ["FULFILLED", "REFUNDED", "UNKNOWN_ERROR"],
    });
  }
  ```

  ```python Python theme={null}
  def poll_mobile_topup(topup_id):
      return poll_status(
          lambda: check_mobile_status(topup_id),
          max_attempts=60,
          interval=5,
          final_states=['FULFILLED', 'REFUNDED', 'UNKNOWN_ERROR']
      )
  ```

  ```php PHP theme={null}
  <?php
  function pollMobileTopup($topupId) {
      return pollStatus(
          fn() => checkMobileStatus($topupId),
          60,
          5,
          ['FULFILLED', 'REFUNDED', 'UNKNOWN_ERROR']
      );
  }
  ?>
  ```
</CodeGroup>

### Recharges internet (5 minutes max)

<CodeGroup>
  ```javascript Node.js theme={null}
  async function pollInternetTopup(topupId) {
    return await pollStatus(() => checkInternetStatus(topupId), {
      maxAttempts: 60,
      interval: 5000,
      finalStates: ["FULFILLED", "REFUNDED", "QUEUED"],
    });
  }
  ```

  ```python Python theme={null}
  def poll_internet_topup(topup_id):
      return poll_status(
          lambda: check_internet_status(topup_id),
          max_attempts=60,
          interval=5,
          final_states=['FULFILLED', 'REFUNDED', 'QUEUED']
      )
  ```

  ```php PHP theme={null}
  <?php
  function pollInternetTopup($topupId) {
      return pollStatus(
          fn() => checkInternetStatus($topupId),
          60,
          5,
          ['FULFILLED', 'REFUNDED', 'QUEUED']
      );
  }
  ?>
  ```
</CodeGroup>

### Cartes cadeaux (10 minutes max)

<CodeGroup>
  ```javascript Node.js theme={null}
  async function pollGiftCardOrder(orderId) {
    return await pollStatus(() => checkGiftCardOrder(orderId), {
      maxAttempts: 120,
      interval: 5000,
      finalStates: ["FULFILLED", "PARTIALLY_FILLED", "REFUNDED"],
    });
  }
  ```

  ```python Python theme={null}
  def poll_gift_card_order(order_id):
      return poll_status(
          lambda: check_gift_card_order(order_id),
          max_attempts=120,
          interval=5,
          final_states=['FULFILLED', 'PARTIALLY_FILLED', 'REFUNDED']
      )
  ```

  ```php PHP theme={null}
  <?php
  function pollGiftCardOrder($orderId) {
      return pollStatus(
          fn() => checkGiftCardOrder($orderId),
          120,
          5,
          ['FULFILLED', 'PARTIALLY_FILLED', 'REFUNDED']
      );
  }
  ?>
  ```
</CodeGroup>

## Bonnes pratiques

<CardGroup cols={2}>
  <Card title="Définir des délais d'attente" icon="clock">
    Définissez toujours une durée d'interrogation maximale
  </Card>

  <Card title="Gérer les erreurs" icon="triangle-exclamation">
    Capturez et gérez les délais d'interrogation
  </Card>

  <Card title="Journaliser la progression" icon="list-check">
    Suivez les tentatives d'interrogation pour le débogage
  </Card>

  <Card title="États finaux" icon="flag-checkered">
    Définissez des états terminaux clairs
  </Card>
</CardGroup>

## Paramètres recommandés

| Service        | Intervalle | Durée max | États finaux                           |
| -------------- | ---------- | --------- | -------------------------------------- |
| Mobile         | 5s         | 5 min     | FULFILLED, REFUNDED, UNKNOWN\_ERROR    |
| Internet       | 5s         | 5 min     | FULFILLED, REFUNDED, QUEUED            |
| Cartes cadeaux | 5s         | 10 min    | FULFILLED, PARTIALLY\_FILLED, REFUNDED |

## Liens utiles

<CardGroup cols={2}>
  <Card title="Guide Recharge Mobile" href="/fr/mobile-topup-guides/overview">
    Workflow d'intégration mobile complet
  </Card>

  <Card title="Gestion des erreurs" href="/fr/api-reference/error-handling">
    Gérer correctement les erreurs
  </Card>

  <Card title="Webhooks" href="/fr/webhooks">
    Notifications de statut en temps réel
  </Card>

  <Card title="Bonnes pratiques" href="/fr/security-best-practices">
    Bonnes pratiques de sécurité
  </Card>
</CardGroup>