Tratamento de Erros

{
  "error": {
    "code": "INVALID_CARD_NUMBER",
    "message": "O número do cartão fornecido é inválido",
    "details": "O número do cartão deve conter entre 13 e 19 dígitos",
    "request_id": "req_123456789",
    "timestamp": "2024-01-15T10:30:00Z"
  }
}

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=60):
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.failure_count = 0
        self.last_failure_time = None
        self.state = 'CLOSED'  # CLOSED, OPEN, HALF_OPEN

    def call(self, func):
        if self.state == 'OPEN':
            if time.time() - self.last_failure_time > self.timeout:
                self.state = 'HALF_OPEN'
            else:
                raise Exception("Circuit breaker is OPEN")

        try:
            result = func()
            self.reset()
            return result
        except Exception as e:
            self.record_failure()
            raise e

    def record_failure(self):
        self.failure_count += 1
        self.last_failure_time = time.time()

        if self.failure_count >= self.failure_threshold:
            self.state = 'OPEN'

    def reset(self):
        self.failure_count = 0
        self.state = 'CLOSED'

{
  "event": "webhook.failed",
  "data": {
    "original_event": "payment.completed",
    "transaction_id": "fb_trans_123456789",
    "failed_attempts": 5,
    "last_error": "Connection timeout",
    "last_attempt": "2024-01-15T12:30:00Z",
    "webhook_url": "https://meusite.com/webhook/failed"
  }
}

def recover_pix_transaction(transaction_id):
    try:
        # Consulta diretamente a transação PIX
        status = firebanking_client.get_pix_transaction(transaction_id)

        if status.status == 'PAID':
            # Processa pagamento que não foi notificado
            process_pix_payment_confirmation(status)
        elif status.status == 'EXPIRED':
            # Notifica expiração para o usuário
            notify_pix_expiration(status)

    except Exception as e:
        log_error(f"Failed to recover PIX transaction {transaction_id}: {e}")

# Consulta periódica para PIX pendentes
def check_pending_pix_transactions():
    pending_pix = get_pending_pix_transactions()

    for pix in pending_pix:
        if datetime.now() - pix.created_at > timedelta(hours=1):
            recover_pix_transaction(pix.transaction_id)

def recover_boleto_transaction(boleto_id):
    try:
        # Consulta status atual do boleto
        boleto = firebanking_client.get_boleto(boleto_id)

        if boleto.status == 'PAID':
            # Processa pagamento confirmado
            process_boleto_payment(boleto)
        elif boleto.status == 'CANCELLED':
            # Notifica cancelamento
            notify_boleto_cancellation(boleto)
        elif boleto.status == 'OVERDUE':
            # Notifica vencimento
            notify_boleto_overdue(boleto)

    except Exception as e:
        log_error(f"Failed to recover boleto {boleto_id}: {e}")

# Verificação diária de boletos
def daily_boleto_check():
    active_boletos = get_active_boletos()

    for boleto in active_boletos:
        if datetime.now().date() > boleto.due_date:
            recover_boleto_transaction(boleto.boleto_id)

def recover_card_transaction(transaction_id):
    try:
        # Consulta status da transação de cartão
        transaction = firebanking_client.get_card_transaction(transaction_id)

        if transaction.status == 'AUTHORIZED':
            # Captura se necessário
            if transaction.auto_capture:
                capture_card_payment(transaction_id)
        elif transaction.status == 'CAPTURED':
            # Confirma captura
            confirm_card_payment(transaction)
        elif transaction.status == 'DECLINED':
            # Notifica recusa
            notify_card_declined(transaction)

    except Exception as e:
        log_error(f"Failed to recover card transaction {transaction_id}: {e}")

@app.route('/webhook/fallback', methods=['POST'])
def webhook_fallback():
    """
    Endpoint alternativo para webhooks críticos
    """
    data = request.get_json()

    try:
        # Log entrada do fallback
        log_webhook_fallback(data)

        # Processa baseado no tipo
        event_type = data.get('event')
        payment_method = data.get('payment_method')

        if payment_method == 'pix':
            handle_pix_fallback(data)
        elif payment_method == 'bank_slip':
            handle_boleto_fallback(data)
        elif payment_method == 'credit_card':
            handle_card_fallback(data)

        return '', 200

    except Exception as e:
        log_error(f"Webhook fallback failed: {e}")
        return '', 500

def handle_pix_fallback(data):
    """Recuperação específica para PIX"""
    transaction_id = data['data']['transaction_id']

    # Força consulta de status
    recover_pix_transaction(transaction_id)

    # Notifica sistemas internos
    notify_internal_systems('pix_recovered', data)

def handle_boleto_fallback(data):
    """Recuperação específica para Boleto"""
    boleto_id = data['data']['boleto_id']

    # Força consulta de status
    recover_boleto_transaction(boleto_id)

    # Atualiza cache local
    invalidate_boleto_cache(boleto_id)

def handle_card_fallback(data):
    """Recuperação específica para Cartão"""
    transaction_id = data['data']['transaction_id']

    # Força consulta de status
    recover_card_transaction(transaction_id)

    # Verifica necessidade de captura
    check_pending_captures()

def setup_webhook_alerts():
    # Alerta se taxa de falha > 5%
    if get_webhook_failure_rate() > 0.05:
        alert_webhook_high_failure()

    # Alerta se não recebeu webhook em 1 hora
    if get_last_webhook_time() > timedelta(hours=1):
        alert_webhook_silence()

    # Alerta para URLs específicas com falha
    failed_urls = get_failed_webhook_urls()
    if failed_urls:
        alert_specific_webhook_failures(failed_urls)

{
  "timestamp": "2024-01-15T10:30:00Z",
  "level": "ERROR",
  "service": "firebanking-integration",
  "transaction_id": "fb_trans_123456789",
  "external_id": "pedido-001",
  "error_code": "CARD_DECLINED",
  "error_message": "Cartão recusado pelo banco emissor",
  "request_id": "req_123456789",
  "user_id": "user_789",
  "additional_context": {
    "amount": 100,
    "payment_method": "credit_card",
    "attempt_count": 1
  }
}

def get_payment_metrics_by_method():
    return {
        'pix': {
            'success_rate': calculate_pix_success_rate(),
            'avg_confirmation_time': get_pix_avg_time(),
            'expired_qr_rate': get_expired_qr_rate(),
            'invalid_key_rate': get_invalid_key_rate()
        },
        'bank_slip': {
            'emission_rate': calculate_boleto_emission_rate(),
            'payment_rate': get_boleto_payment_rate(),
            'cancellation_rate': get_boleto_cancellation_rate(),
            'overdue_rate': get_boleto_overdue_rate()
        },
        'credit_card': {
            'approval_rate': calculate_card_approval_rate(),
            'token_success_rate': get_token_success_rate(),
            'cvv_failure_rate': get_cvv_failure_rate(),
            'chargeback_rate': get_chargeback_rate()
        }
    }

def setup_alerting_by_method():
    # Alertas PIX
    if get_pix_success_rate() < 0.95:
        alert_pix_low_success_rate()

    if get_expired_qr_rate() > 0.20:
        alert_high_qr_expiration()

    # Alertas Boleto
    if get_boleto_payment_rate() < 0.80:
        alert_low_boleto_payment_rate()

    if get_boleto_cancellation_rate() > 0.15:
        alert_high_boleto_cancellation()

    # Alertas Cartão
    if get_card_approval_rate() < 0.85:
        alert_low_card_approval()

    if get_cvv_failure_rate() > 0.10:
        alert_high_cvv_failures()

def check_pending_pix_transactions():
    """Consulta PIX pendentes a cada 30 segundos"""
    pending_pix = get_pending_pix_transactions()

    for pix in pending_pix:
        try:
            # PIX tem tempo de vida limitado
            if datetime.now() - pix.created_at > timedelta(minutes=30):
                status = firebanking_client.get_pix_status(pix.transaction_id)

                if status.status == 'PAID':
                    process_pix_payment(pix, status)
                elif status.status == 'EXPIRED':
                    mark_pix_expired(pix)
                    notify_customer_pix_expired(pix)

        except Exception as e:
            log_error(f"Failed to check PIX {pix.transaction_id}: {e}")

def handle_pix_timeout():
    """Lida com PIX que não foram confirmados"""
    expired_pix = get_expired_pix_transactions()

    for pix in expired_pix:
        # Gera novo PIX automaticamente
        new_pix = generate_new_pix_charge(pix.original_data)
        notify_customer_new_pix(pix.customer_email, new_pix)

def daily_boleto_reconciliation():
    """Verificação diária de boletos"""
    active_boletos = get_active_boletos()

    for boleto in active_boletos:
        try:
            status = firebanking_client.get_boleto_status(boleto.boleto_id)

            if status.status == 'PAID' and boleto.local_status != 'PAID':
                process_boleto_payment(boleto, status)
            elif status.status == 'CANCELLED':
                handle_boleto_cancellation(boleto, status)
            elif status.due_date < datetime.now().date():
                handle_boleto_overdue(boleto)

        except Exception as e:
            log_error(f"Failed to check boleto {boleto.boleto_id}: {e}")

def handle_boleto_overdue(boleto):
    """Gestão de boletos vencidos"""
    # Notifica cliente sobre vencimento
    notify_customer_boleto_overdue(boleto)

    # Oferece renovação automática
    if boleto.auto_renew:
        new_due_date = datetime.now().date() + timedelta(days=7)
        renewed_boleto = renew_boleto(boleto, new_due_date)
        notify_customer_boleto_renewed(boleto.customer_email, renewed_boleto)

def reissue_problematic_boletos():
    """Reemite boletos com problemas"""
    problematic = get_problematic_boletos()

    for boleto in problematic:
        try:
            # Cancela boleto problemático
            firebanking_client.cancel_boleto(boleto.boleto_id)

            # Emite novo boleto
            new_boleto = create_replacement_boleto(boleto)
            notify_customer_boleto_reissued(boleto.customer_email, new_boleto)

        except Exception as e:
            log_error(f"Failed to reissue boleto {boleto.boleto_id}: {e}")

def check_pending_card_authorizations():
    """Verifica autorizações pendentes de cartão"""
    pending_auths = get_pending_card_authorizations()

    for auth in pending_auths:
        try:
            # Autorização válida por 7 dias
            if datetime.now() - auth.created_at > timedelta(days=6):
                status = firebanking_client.get_card_status(auth.transaction_id)

                if status.status == 'AUTHORIZED' and auth.auto_capture:
                    # Captura antes de expirar
                    capture_result = firebanking_client.capture_payment(auth.transaction_id)
                    process_card_capture(auth, capture_result)
                elif status.status == 'EXPIRED':
                    handle_authorization_expired(auth)

        except Exception as e:
            log_error(f"Failed to check card auth {auth.transaction_id}: {e}")

def handle_failed_card_captures():
    """Lida com capturas que falharam"""
    failed_captures = get_failed_card_captures()

    for capture in failed_captures:
        # Tenta captura novamente se dentro do prazo
        if datetime.now() - capture.auth_date < timedelta(days=6):
            try:
                retry_result = firebanking_client.capture_payment(capture.transaction_id)
                process_capture_retry(capture, retry_result)
            except Exception as e:
                log_error(f"Capture retry failed for {capture.transaction_id}: {e}")
                # Notifica falha definitiva
                notify_capture_failed(capture)

def cleanup_expired_tokens():
    """Remove tokens de cartão expirados"""
    expired_tokens = get_expired_card_tokens()

    for token in expired_tokens:
        # Remove token do banco de dados
        remove_card_token(token.token_id)

        # Notifica cliente para atualizar cartão
        if token.auto_renew:
            notify_customer_token_expired(token.customer_email)

def unified_transaction_recovery():
    """Sistema unificado de recuperação"""

    # Recuperação rápida para PIX (a cada 30s)
    if should_check_pix():
        check_pending_pix_transactions()

    # Recuperação de cartão (a cada 5 min)
    if should_check_cards():
        check_pending_card_authorizations()
        handle_failed_card_captures()

    # Recuperação de boleto (diária)
    if should_check_boletos():
        daily_boleto_reconciliation()
        reissue_problematic_boletos()

    # Limpeza geral (semanal)
    if should_cleanup():
        cleanup_expired_tokens()
        archive_old_transactions()

# Agendar tarefas
schedule.every(30).seconds.do(check_pending_pix_transactions)
schedule.every(5).minutes.do(check_pending_card_authorizations)
schedule.every().day.at("02:00").do(daily_boleto_reconciliation)
schedule.every().week.do(cleanup_expired_tokens)

@app.route('/webhook/recovery', methods=['POST'])
def recovery_webhook():
    data = request.get_json()

    # Identifica tipo de transação
    payment_method = data.get('payment_method')
    transaction_id = data.get('transaction_id')
    current_status = data.get('status')

    try:
        if payment_method == 'pix':
            sync_pix_transaction(transaction_id, current_status, data)
        elif payment_method == 'bank_slip':
            sync_boleto_transaction(transaction_id, current_status, data)
        elif payment_method == 'credit_card':
            sync_card_transaction(transaction_id, current_status, data)

        return '', 200

    except Exception as e:
        log_error(f"Recovery webhook failed: {e}")
        return '', 500