Error Handling

from nekuda import NekudaClient, NekudaError, CardNotFoundError, NekudaValidationError

client = NekudaClient.from_env()
user_id = "user_example_456"
user = client.user(user_id)

# Assume mandate_id is obtained after user.create_mandate(...)
mandate_id_example = "mand_0abc123def456"

try:
    # This call requires a valid mandate_id obtained from user.create_mandate()
    response = user.request_card_reveal_token(mandate_id=mandate_id_example)
    print(f"Token: {response.reveal_token}")

except CardNotFoundError as exc:
    # Specific error if the card associated with user_id (and potentially mandate_id) is not found
    print(f"Card not found for user {exc.user_id}. Message: {exc.message}")
    # Ensure the user_id is correct and card details were collected.

except InvalidRequestError as exc:
    # Handles 4xx errors like invalid parameters (e.g., malformed mandate_id)
    print(f"Invalid request: {exc.message} (Code: {exc.code}, Status: {exc.status_code})")

except NekudaValidationError as exc:
    # If API response doesn't match expected Pydantic model format, or input validation fails
    print(f"Validation Error: {exc}")

except AuthenticationError as exc:
    print(f"Authentication failed: {exc.message}. Check your NEKUDA_API_KEY.")

except NekudaApiError as exc:
    # Catch other API errors (5xx, rate limits if not retried, etc.)
    print(f"nekuda API Error: {exc.message} (Code: {exc.code}, Status: {exc.status_code})")

except NekudaError as exc:
    # Catch-all for other SDK-specific errors (e.g., NekudaConnectionError)
    print(f"A nekuda SDK error occurred: {exc}")

# import logging_library as logger # Fictional logging library

# try:
#    # ... SDK call ...
# except NekudaApiError as e:
#     logger.error(
#         "nekuda API call failed",
#         status_code=e.status_code,
#         error_code=e.code,
#         error_message=e.message,
#         user_id=current_user_id # Add your own contextual info
#     )
#     if e.status_code == 400 and e.code == "invalid_parameter_foo":
#         # Specific handling for a known bad parameter
#         return "Please correct parameter foo."

import logging # Python's built-in logging
# import structlog # Or a structured logging library like structlog

logger = logging.getLogger(__name__)

# try:
#     # ... Your SDK call ...
# except NekudaError as e:
#     log_data = {
#         "error_type": type(e).__name__,
#         "message": str(e), # Use str(e) for the full message
#     }
#     if hasattr(e, 'code') and e.code:
#         log_data["error_code"] = e.code
#     if hasattr(e, 'status_code') and e.status_code:
#         log_data["http_status_code"] = e.status_code
#
#     logger.error("nekuda SDK operation failed", extra=log_data)

# def get_user_card_for_checkout(user_id: str, mandate_id: str):
#     user = client.user(user_id)
#     try:
#         token_response = user.request_card_reveal_token(mandate_id)
#         card_details = user.reveal_card_details(token_response.reveal_token)
#         return card_details # Proceed to checkout
#     except CardNotFoundError:
#         # Card not found, guide user to add/update payment method in your frontend
#         # This might involve redirecting them or showing a message.
#         print(f"No card on file for user {user_id} for this transaction.")
#         return None # Or raise a custom application error
#     except NekudaError as e:
#         print(f"Could not retrieve card: {e}")
#         return None # Or raise

# import time
# from nekuda import NekudaConnectionError, ServerError

# MAX_APP_RETRIES = 3
# for attempt in range(MAX_APP_RETRIES):
#     try:
#         # Your business logic that includes one or more SDK calls
#         # result = make_payment_attempt_with_nekuda_sdk(...)
#         # if result.is_success(): break
#     except NekudaConnectionError as e:
#         if attempt == MAX_APP_RETRIES - 1:
#             # Log final failure and give up or alert
#             raise
#         print(f"Connection error (attempt {attempt + 1}), retrying in {2 ** attempt}s...")
#         time.sleep(2 ** attempt)  # Exponential backoff for connection errors
#     except ServerError as e: # SDK already retried this, this is the final one
#          print(f"nekuda server error after SDK retries: {e}. Might need to investigate.")
#          # Depending on the error, might break or schedule for later.
#          break

# from nekuda import MandateData, NekudaValidationError
#
# try:
#     # Example: Price is negative, which is invalid
#     mandate = MandateData(product="Test Item", price=-10.00, currency="USD", merchant="Test Store")
# except NekudaValidationError as e:
#     print(f"Invalid mandate data: {e}")
#     # Correct the data based on the error before attempting user.create_mandate(mandate)