Gestion des erreurs

{
  "error": {
    "code": "ERROR_CODE",
    "message": "Description lisible de l'erreur",
    "details": {
      "field": "Information contextuelle"
    }
  }
}

{
  "error": {
    "code": "MISSING_API_KEY",
    "message": "API key is required",
    "details": {
      "header": "X-API-Key"
    }
  }
}

{
  "error": {
    "code": "INVALID_API_KEY",
    "message": "Invalid API key",
    "details": {}
  }
}

{
  "error": {
    "code": "INSUFFICIENT_CREDITS",
    "message": "Insufficient credits",
    "details": {
      "required": 50,
      "available": 10
    }
  }
}

{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Validation failed",
    "details": {
      "job_title": "This field is required",
      "contract_type": "Invalid value. Must be one of: CDI, CDD, Stage"
    }
  }
}

{
  "error": {
    "code": "INVALID_PHONE_NUMBER",
    "message": "Invalid phone number format",
    "details": {
      "phone": "0612345678",
      "reason": "Must be a French mobile number (06 or 07)"
    }
  }
}

{
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Rate limit exceeded",
    "details": {
      "retry_after": 30
    }
  }
}

{
  "error": {
    "code": "RESOURCE_NOT_FOUND",
    "message": "Campaign not found",
    "details": {
      "campaign_id": "abc123def456"
    }
  }
}

{
  "error": {
    "code": "RESOURCE_CONFLICT",
    "message": "Candidate already exists",
    "details": {
      "phone": "0612345678"
    }
  }
}

import requests

def create_campaign(data):
    try:
        response = requests.post(
            "https://app.voicehire.io/api/v1/campaigns/create",
            headers={"X-API-Key": API_KEY},
            json=data
        )
        
        # Vérifier le statut HTTP
        if response.status_code == 201:
            return response.json()
        
        # Gérer les erreurs
        error_data = response.json()
        error_code = error_data['error']['code']
        
        if error_code == 'INSUFFICIENT_CREDITS':
            # Notifier l'utilisateur de recharger
            send_low_credits_notification()
        elif error_code == 'VALIDATION_ERROR':
            # Afficher les erreurs de validation
            for field, message in error_data['error']['details'].items():
                print(f"Erreur sur {field}: {message}")
        
        raise Exception(f"API Error: {error_data['error']['message']}")
        
    except requests.exceptions.RequestException as e:
        # Gérer les erreurs réseau
        print(f"Network error: {e}")
        raise

async function addCandidates(campaignId, candidates) {
  try {
    const response = await fetch(
      `https://app.voicehire.io/api/v1/campaigns/${campaignId}/candidates`,
      {
        method: 'POST',
        headers: {
          'X-API-Key': API_KEY,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ candidates })
      }
    );
    
    const data = await response.json();
    
    if (!response.ok) {
      // Traiter l'erreur selon le code
      switch (data.error.code) {
        case 'INSUFFICIENT_CREDITS':
          alert('Crédits insuffisants. Veuillez recharger votre compte.');
          break;
          
        case 'VALIDATION_ERROR':
          // Afficher les erreurs de validation
          Object.entries(data.error.details).forEach(([field, message]) => {
            console.error(`${field}: ${message}`);
          });
          break;
          
        case 'RATE_LIMIT_EXCEEDED':
          // Attendre et réessayer
          const retryAfter = data.error.details.retry_after;
          console.log(`Rate limited. Retrying in ${retryAfter} seconds...`);
          setTimeout(() => addCandidates(campaignId, candidates), retryAfter * 1000);
          return;
          
        default:
          throw new Error(data.error.message);
      }
    }
    
    return data;
    
  } catch (error) {
    if (error instanceof TypeError) {
      // Erreur réseau
      console.error('Network error:', error.message);
    } else {
      // Autres erreurs
      console.error('Error:', error.message);
    }
    throw error;
  }
}

import time
from functools import wraps

def retry_on_rate_limit(max_retries=3):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except RateLimitError as e:
                    if attempt == max_retries - 1:
                        raise
                    
                    wait_time = e.retry_after or (2 ** attempt)
                    print(f"Rate limited. Waiting {wait_time} seconds...")
                    time.sleep(wait_time)
            
        return wrapper
    return decorator

@retry_on_rate_limit()
def get_campaign_status(campaign_id):
    # Votre code API ici
    pass