Webhooks

curl --request POST \
  --url 'https://api.uvvipague.com.br/uvvi/v1/webhook-register' \
  --header 'x-api-key: SUA_API_KEY_AQUI' \
  --header 'Content-Type: application/json' \
  --data '{
    "url": "https://sua-api.com.br/webhook/uvvipague"
  }'

const requestBody = {
  url: "https://sua-api.com.br/webhook/uvvipague"
};

const options = {
  method: 'POST',
  headers: {
    'x-api-key': 'SUA_API_KEY_AQUI',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(requestBody)
};

fetch('https://api.uvvipague.com.br/uvvi/v1/webhook-register', options)
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Erro:', error));

import requests

url = "https://api.uvvipague.com.br/uvvi/v1/webhook-register"
headers = {
    "x-api-key": "SUA_API_KEY_AQUI",
    "Content-Type": "application/json"
}
payload = {
    "url": "https://sua-api.com.br/webhook/uvvipague"
}

response = requests.post(url, headers=headers, json=payload)
data = response.json()
print(data)

<?php
$curl = curl_init();

$payload = json_encode([
    "url" => "https://sua-api.com.br/webhook/uvvipague"
]);

curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.uvvipague.com.br/uvvi/v1/webhook-register",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => $payload,
    CURLOPT_HTTPHEADER => [
        "x-api-key: SUA_API_KEY_AQUI",
        "Content-Type: application/json"
    ],
]);

$response = curl_exec($curl);
curl_close($curl);

$data = json_decode($response, true);
print_r($data);
?>

const express = require('express');
const app = express();

app.use(express.json());

// Endpoint para receber webhooks
app.post('/webhook/uvvipague', async (req, res) => {
  try {
    // 1. Retorne 200 imediatamente
    res.status(200).json({ received: true });
    
    // 2. Processe o webhook de forma assíncrona
    processWebhookAsync(req.body);
    
  } catch (error) {
    console.error('Erro ao receber webhook:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

async function processWebhookAsync(payload) {
  const { type, transactionId, externalId } = payload;
  
  console.log(`Webhook recebido: ${type}`);
  console.log(`Transaction ID: ${transactionId}`);
  console.log(`External ID: ${externalId}`);
  
  // Processar baseado no tipo
  switch (type) {
    case 'debts':
      await handleDebtsFound(payload);
      break;
      
    case 'VehicleWithoutDebts':
      await handleNoDebts(payload);
      break;
      
    case 'VehicleNotFound':
      await handleVehicleNotFound(payload);
      break;
      
    case 'search-error-event':
      await handleSearchError(payload);
      break;
      
    case 'payment-status-update':
      await handlePaymentUpdate(payload);
      break;
      
    default:
      console.warn(`Tipo de webhook desconhecido: ${type}`);
  }
}

async function handleDebtsFound(payload) {
  const { transactionId, debts } = payload;
  
  // Salvar débitos no banco de dados
  await database.debts.create({
    transactionId,
    debts: debts,
    status: 'found',
    receivedAt: new Date()
  });
  
  // Notificar cliente
  await notifyClient(transactionId, 'Débitos encontrados');
}

async function handlePaymentUpdate(payload) {
  const { paymentId, status, liquidationStatus } = payload;
  
  // Atualizar status do pagamento
  await database.payments.update(
    { paymentId },
    { 
      status, 
      liquidationStatus,
      updatedAt: new Date() 
    }
  );
  
  // Se pago e liquidado, liberar serviço
  if (status === 'paid' && liquidationStatus === 'settled') {
    await releaseService(paymentId);
  }
}

app.listen(3000, () => {
  console.log('Servidor rodando na porta 3000');
});

from flask import Flask, request, jsonify
import threading
import logging

app = Flask(__name__)
logging.basicConfig(level=logging.INFO)

@app.route('/webhook/uvvipague', methods=['POST'])
def webhook_uvvipague():
    try:
        payload = request.json
        
        # 1. Retorne 200 imediatamente
        response = jsonify({'received': True})
        
        # 2. Processe o webhook em background
        thread = threading.Thread(
            target=process_webhook_async,
            args=(payload,)
        )
        thread.start()
        
        return response, 200
        
    except Exception as e:
        logging.error(f'Erro ao receber webhook: {e}')
        return jsonify({'error': 'Internal server error'}), 500

def process_webhook_async(payload):
    webhook_type = payload.get('type')
    transaction_id = payload.get('transactionId')
    external_id = payload.get('externalId')
    
    logging.info(f'Webhook recebido: {webhook_type}')
    logging.info(f'Transaction ID: {transaction_id}')
    logging.info(f'External ID: {external_id}')
    
    # Processar baseado no tipo
    if webhook_type == 'debts':
        handle_debts_found(payload)
    elif webhook_type == 'VehicleWithoutDebts':
        handle_no_debts(payload)
    elif webhook_type == 'VehicleNotFound':
        handle_vehicle_not_found(payload)
    elif webhook_type == 'search-error-event':
        handle_search_error(payload)
    elif webhook_type == 'payment-status-update':
        handle_payment_update(payload)
    else:
        logging.warning(f'Tipo de webhook desconhecido: {webhook_type}')

def handle_debts_found(payload):
    transaction_id = payload['transactionId']
    debts = payload['debts']
    
    # Salvar débitos no banco de dados
    # database.save_debts(transaction_id, debts)
    
    # Notificar cliente
    # notify_client(transaction_id, 'Débitos encontrados')
    
    logging.info(f'Débitos processados para transação {transaction_id}')

def handle_payment_update(payload):
    payment_id = payload['paymentId']
    status = payload['status']
    liquidation_status = payload.get('liquidationStatus')
    
    # Atualizar status do pagamento
    # database.update_payment(payment_id, status, liquidation_status)
    
    # Se pago e liquidado, liberar serviço
    if status == 'paid' and liquidation_status == 'settled':
        # release_service(payment_id)
        logging.info(f'Serviço liberado para pagamento {payment_id}')

if __name__ == '__main__':
    app.run(port=3000)

curl --request POST \
  --url 'https://api.uvvipague.com.br/uvvi/v1/payment/status' \
  --header 'x-api-key: SUA_API_KEY_AQUI' \
  --header 'Content-Type: application/json' \
  --data '{
    "paymentId": "pay_abc123def456"
  }'

// Usando transactionId
const response = await fetch('https://api.uvvipague.com.br/uvvi/v1/payment/status', {
  method: 'POST',
  headers: {
    'x-api-key': 'SUA_API_KEY_AQUI',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    transactionId: 817210768
  })
});

// Ou usando externalId
const response = await fetch('https://api.uvvipague.com.br/uvvi/v1/payment/status', {
  method: 'POST',
  headers: {
    'x-api-key': 'SUA_API_KEY_AQUI',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    externalId: "seu-id-interno-123"
  })
});