Gestion des Erreurs

import { SmartbillsClient } from '@smartbills/sdk';

const client = new SmartbillsClient({
  accessToken: 'VOTRE_CLE_API',
  businessId: 123
});

try {
  const expense = await client.expenses.get(12345);
} catch (error) {
  if (error instanceof SmartbillsValidationError) {
    // Gérer les erreurs de validation - inspecter les détails par champ
    console.error('Echec de validation :', error.message);
    error.détails.forEach(détail => {
      console.error(`  Champ "${detail.field}" : ${detail.message}`);
    });
  } else if (error instanceof SmartbillsAuthenticationError) {
    // Gérer les erreurs d'authentification - rafraichir le jeton ou demander la connexion
    console.error('Echec d\'authentification :', error.message);
  } else if (error instanceof SmartbillsPermissionError) {
    // Gérer les erreurs de permission - l'utilisateur n'a pas l'acces
    console.error('Permission refusee :', error.message);
  } else if (error instanceof SmartbillsNotFoundError) {
    // Gérer les erreurs de ressource introuvable
    console.error('Ressource introuvable :', error.message);
  } else if (error instanceof SmartbillsRateLimitError) {
    // Gérer les erreurs de limite de débit - attendre et réessayer
    console.error('Limite de débit atteinte. Réessayer après :', error.retryAfter);
  } else if (error instanceof SmartbillsApiError) {
    // Gérer toute autre erreur API
    console.error('Erreur API :', error.code, error.message);
    console.error('ID de requête :', error.requestId);
  }
}

from smartbills import SmartbillsClient
from smartbills.errors import (
    SmartbillsApiError,
    SmartbillsValidationError,
    SmartbillsAuthenticationError,
    SmartbillsPermissionError,
    SmartbillsNotFoundError,
    SmartbillsRateLimitError
)

client = SmartbillsClient(access_token="VOTRE_CLE_API", business_id=123)

try:
    expense = client.expenses.get(12345)
except SmartbillsValidationError as e:
    # Gérer les erreurs de validation
    print(f"Echec de validation : {e.message}")
    for détail in e.détails:
        print(f"  Champ '{detail['field']}' : {detail['message']}")
except SmartbillsAuthenticationError as e:
    print(f"Echec d'authentification : {e.message}")
except SmartbillsPermissionError as e:
    print(f"Permission refusee : {e.message}")
except SmartbillsNotFoundError as e:
    print(f"Ressource introuvable : {e.message}")
except SmartbillsRateLimitError as e:
    print(f"Limite de débit atteinte. Réessayer après : {e.retry_after}")
except SmartbillsApiError as e:
    print(f"Erreur API : {e.code} - {e.message}")
    print(f"ID de requête : {e.request_id}")

async function retryableRequest(fn, maxRetries = 3) {
  const retryableStatuses = [408, 429, 500, 502, 503, 504];

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      const isLastAttempt = attempt === maxRetries - 1;
      const shouldRetry = error.status &&
                         retryableStatuses.includes(error.status);

      if (isLastAttempt || !shouldRetry) {
        throw error;
      }

      // Backoff exponentiel : 1s, 2s, 4s...
      const delay = Math.min(1000 * Math.pow(2, attempt), 10000);

      console.log(
        `Requête échouée, nouvelle tentative dans ${delay}ms ` +
        `(tentative ${attempt + 1}/${maxRetries})`
      );

      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

// Utilisation
const expense = await retryableRequest(() =>
  client.expenses.get(12345)
);

import time

def retryable_request(fn, max_retries=3):
    retryable_statuses = [408, 429, 500, 502, 503, 504]

    for attempt in range(max_retries):
        try:
            return fn()
        except SmartbillsApiError as e:
            is_last_attempt = attempt == max_retries - 1
            should_retry = e.status in retryable_statuses

            if is_last_attempt or not should_retry:
                raise

            # Backoff exponentiel : 1s, 2s, 4s...
            delay = min(2 ** attempt, 10)

            print(f"Requête échouée, nouvelle tentative dans {delay}s "
                  f"(tentative {attempt + 1}/{max_retries})")

            time.sleep(delay)

# Utilisation
expense = retryable_request(lambda: client.expenses.get(12345))