Fehlerbehandlung

{
  "error": {
    "code": "error_code",
    "message": "Menschenlesbare Fehlerbeschreibung",
    "details": {}
  }
}

{
  "error": {
    "code": "invalid_token",
    "message": "Das bereitgestellte API-Token ist ungültig"
  }
}

{
  "error": {
    "code": "token_expired",
    "message": "Das API-Token ist abgelaufen",
    "details": {
      "expired_at": "2024-01-15T00:00:00Z"
    }
  }
}

{
  "error": {
    "code": "insufficient_scope",
    "message": "Token hat nicht die erforderliche Berechtigung",
    "details": {
      "required": "write",
      "provided": ["read"]
    }
  }
}

{
  "error": {
    "code": "board_not_found",
    "message": "Board nicht gefunden oder Zugriff verweigert",
    "details": {
      "board_id": "550e8400-e29b-41d4-a716-446655440000"
    }
  }
}

{
  "error": {
    "code": "project_not_found",
    "message": "Projekt nicht gefunden oder Zugriff verweigert"
  }
}

{
  "error": {
    "code": "task_not_found",
    "message": "Aufgabe nicht gefunden oder Zugriff verweigert"
  }
}

{
  "error": {
    "code": "invalid_request",
    "message": "Anfrage-Validierung fehlgeschlagen",
    "details": {
      "fields": {
        "label": "Label ist erforderlich",
        "status": "Status muss 0, 1 oder 2 sein"
      }
    }
  }
}

{
  "error": {
    "code": "invalid_uuid",
    "message": "Ungültiges UUID-Format",
    "details": {
      "field": "projectId",
      "value": "keine-uuid"
    }
  }
}

{
  "error": {
    "code": "quota_exceeded",
    "message": "Monatliches API-Kontingent überschritten",
    "details": {
      "limit": 12000,
      "used": 12000,
      "reset": "2024-02-01T00:00:00Z"
    }
  }
}

{
  "error": {
    "code": "resource_limit_exceeded",
    "message": "Aufgabenlimit für Ihren Tarif erreicht",
    "details": {
      "resource": "tasks",
      "limit": 500,
      "current": 500
    }
  }
}

async function apiRequest(url, options = {}) {
  const response = await fetch(url, {
    ...options,
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json',
      ...options.headers
    }
  });

  const data = await response.json();

  if (!response.ok) {
    const error = new Error(data.error?.message || 'API-Anfrage fehlgeschlagen');
    error.code = data.error?.code;
    error.status = response.status;
    error.details = data.error?.details;
    throw error;
  }

  return data;
}

// Verwendung
try {
  const task = await apiRequest('https://api.kanman.de/v1/tasks/123');
  console.log(task);
} catch (error) {
  switch (error.code) {
    case 'task_not_found':
      console.log('Aufgabe existiert nicht');
      break;
    case 'token_expired':
      console.log('Bitte erneuern Sie Ihr API-Token');
      break;
    case 'quota_exceeded':
      console.log(`Kontingent wird zurückgesetzt am ${error.details.reset}`);
      break;
    default:
      console.error('API-Fehler:', error.message);
  }
}

import requests

class KanmanAPIError(Exception):
    def __init__(self, code, message, status, details=None):
        self.code = code
        self.message = message
        self.status = status
        self.details = details or {}
        super().__init__(message)

def api_request(method, endpoint, **kwargs):
    response = requests.request(
        method,
        f'https://api.kanman.de/v1{endpoint}',
        headers={'Authorization': f'Bearer {API_TOKEN}'},
        **kwargs
    )

    data = response.json()

    if not response.ok:
        error = data.get('error', {})
        raise KanmanAPIError(
            code=error.get('code', 'unknown'),
            message=error.get('message', 'API-Fehler'),
            status=response.status_code,
            details=error.get('details')
        )

    return data

# Verwendung
try:
    task = api_request('GET', '/tasks/123')
except KanmanAPIError as e:
    if e.code == 'task_not_found':
        print('Aufgabe existiert nicht')
    elif e.code == 'quota_exceeded':
        print(f"Kontingent wird zurückgesetzt am {e.details['reset']}")
    else:
        print(f'Fehler: {e.message}')

async function apiRequestWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);

      // Client-Fehler nicht erneut versuchen
      if (response.status >= 400 && response.status < 500) {
        return response;
      }

      // Server-Fehler erneut versuchen
      if (response.status >= 500) {
        throw new Error(`Server-Fehler: ${response.status}`);
      }

      return response;
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;

      // Exponentielles Backoff: 1s, 2s, 4s
      const delay = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}