Fluxo Completo de Pagamento

curl --request GET \
  --url 'https://api.uvvipague.com.br/api/v1/vehicle/enrichment/ABC1234?uf=SP' \
  --header 'x-api-key: SUA_API_KEY_AQUI' \
  --header 'Content-Type: application/json'

const options = {
  method: 'GET',
  headers: {
    'x-api-key': 'SUA_API_KEY_AQUI',
    'Content-Type': 'application/json'
  }
};

fetch('https://api.uvvipague.com.br/api/v1/vehicle/enrichment/ABC1234?uf=SP', options)
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Erro:', error));

import requests

url = "https://api.uvvipague.com.br/api/v1/vehicle/enrichment/ABC1234"
headers = {
    "x-api-key": "SUA_API_KEY_AQUI",
    "Content-Type": "application/json"
}
params = {
    "uf": "SP"
}

response = requests.get(url, headers=headers, params=params)
data = response.json()
print(data)

curl --request POST \
  --url 'https://api.uvvipague.com.br/uvvi/v1/debts' \
  --header 'x-api-key: SUA_API_KEY_AQUI' \
  --header 'Content-Type: application/json' \
  --data '{
    "state": "SP",
    "licensePlate": "ABC1234",
    "renavam": "12345678901",
    "cpfCnpj": "12345678900"
  }'

const requestBody = {
  state: "SP",
  licensePlate: "ABC1234",
  renavam: "12345678901",
  cpfCnpj: "12345678900"
};

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/debts', 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/debts"
headers = {
    "x-api-key": "SUA_API_KEY_AQUI",
    "Content-Type": "application/json"
}
payload = {
    "state": "SP",
    "licensePlate": "ABC1234",
    "renavam": "12345678901",
    "cpfCnpj": "12345678900"
}

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

curl --request POST \
  --url 'https://api.uvvipague.com.br/uvvi/v1/card-token' \
  --header 'x-api-key: SUA_API_KEY_AQUI' \
  --header 'Content-Type: application/json' \
  --data '{
    "cardNumber": "4111111111111111",
    "cardholderName": "JOAO DA SILVA",
    "expirationDate": "12/2030",
    "cvv": "123"
  }'

const cardData = {
  cardNumber: "4111111111111111",
  cardholderName: "JOAO DA SILVA",
  expirationDate: "12/2030",
  cvv: "123"
};

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

fetch('https://api.uvvipague.com.br/uvvi/v1/card-token', 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/card-token"
headers = {
    "x-api-key": "SUA_API_KEY_AQUI",
    "Content-Type": "application/json"
}
payload = {
    "cardNumber": "4111111111111111",
    "cardholderName": "JOAO DA SILVA",
    "expirationDate": "12/2030",
    "cvv": "123"
}

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

curl --request POST \
  --url 'https://api.uvvipague.com.br/uvvi/v1/installments' \
  --header 'x-api-key: SUA_API_KEY_AQUI' \
  --header 'Content-Type: application/json' \
  --data '{
    "amount": 1302.86,
    "paymentMethod": "credit_card"
  }'

const requestBody = {
  amount: 1302.86,
  paymentMethod: "credit_card"
};

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/installments', 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/installments"
headers = {
    "x-api-key": "SUA_API_KEY_AQUI",
    "Content-Type": "application/json"
}
payload = {
    "amount": 1302.86,
    "paymentMethod": "credit_card"
}

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

curl --request POST \
  --url 'https://api.uvvipague.com.br/uvvi/v1/checkout' \
  --header 'x-api-key: SUA_API_KEY_AQUI' \
  --header 'Content-Type: application/json' \
  --data '{
    "debts": [
      "9547B3A8-05B9-4D1C-8C72-A500BB6D93EF",
      "312D6A5F-2B5A-4694-84DA-F640FC01CC74"
    ],
    "customer": {
      "name": "João da Silva",
      "email": "joao@example.com",
      "cpfCnpj": "12345678900",
      "phone": "11987654321"
    },
    "vehicle": {
      "licensePlate": "ABC1234",
      "renavam": "12345678901",
      "uf": "SP"
    }
  }'

const checkoutData = {
  debts: [
    "9547B3A8-05B9-4D1C-8C72-A500BB6D93EF",
    "312D6A5F-2B5A-4694-84DA-F640FC01CC74"
  ],
  customer: {
    name: "João da Silva",
    email: "joao@example.com",
    cpfCnpj: "12345678900",
    phone: "11987654321"
  },
  vehicle: {
    licensePlate: "ABC1234",
    renavam: "12345678901",
    uf: "SP"
  }
};

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

fetch('https://api.uvvipague.com.br/uvvi/v1/checkout', 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/checkout"
headers = {
    "x-api-key": "SUA_API_KEY_AQUI",
    "Content-Type": "application/json"
}
payload = {
    "debts": [
        "9547B3A8-05B9-4D1C-8C72-A500BB6D93EF",
        "312D6A5F-2B5A-4694-84DA-F640FC01CC74"
    ],
    "customer": {
        "name": "João da Silva",
        "email": "joao@example.com",
        "cpfCnpj": "12345678900",
        "phone": "11987654321"
    },
    "vehicle": {
        "licensePlate": "ABC1234",
        "renavam": "12345678901",
        "uf": "SP"
    }
}

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

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_abc123def456ghi789"
  }'

const requestBody = {
  paymentId: "pay_abc123def456ghi789"
};

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/payment/status', 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/payment/status"
headers = {
    "x-api-key": "SUA_API_KEY_AQUI",
    "Content-Type": "application/json"
}
payload = {
    "paymentId": "pay_abc123def456ghi789"
}

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

const UvvipagueClient = require('./uvvipague-client');

async function processarPagamentoCompleto() {
  const client = new UvvipagueClient(process.env.UVVIPAGUE_API_KEY);
  
  try {
    // 1. Enriquecer dados do veículo (opcional)
    console.log('1. Enriquecendo dados do veículo...');
    const veiculo = await client.enriquecerVeiculo({
      licensePlate: 'ABC1234',
      uf: 'SP'
    });
    console.log('Veículo:', veiculo.data);
    
    // 2. Consultar débitos
    console.log('2. Consultando débitos...');
    const debitos = await client.consultarDebitos({
      state: 'SP',
      licensePlate: 'ABC1234',
      renavam: veiculo.data.renavam,
      cpfCnpj: '12345678900'
    });
    console.log(`Encontrados ${debitos.debts.length} débitos`);
    console.log(`Total: R$ ${debitos.totalAmount}`);
    
    // 3. Simular parcelas
    console.log('3. Simulando parcelas...');
    const simulacao = await client.simularParcelas({
      amount: debitos.totalAmount,
      paymentMethod: 'credit_card'
    });
    console.log(`Opções de parcelamento: ${simulacao.installments.length}`);
    simulacao.installments.forEach(opt => {
      console.log(`${opt.number}x de R$ ${opt.installmentAmount.toFixed(2)} (total: R$ ${opt.totalAmount.toFixed(2)})`);
    });
    
    // 4. Tokenizar cartão
    console.log('4. Tokenizando cartão...');
    const token = await client.tokenizarCartao({
      cardNumber: '4111111111111111',
      cardholderName: 'JOAO DA SILVA',
      expirationMonth: '12',
      expirationYear: '2025',
      securityCode: '123'
    });
    console.log('Token gerado:', token.cardToken);
    
    // 5. Criar checkout
    console.log('5. Criando checkout...');
    const checkout = await client.criarCheckout({
      debts: debitos.debts.map(d => d.id),
      customer: {
        name: 'João da Silva',
        email: 'joao@example.com',
        cpfCnpj: '12345678900',
        phone: '11987654321'
      },
      vehicle: {
        licensePlate: 'ABC1234',
        renavam: veiculo.data.renavam,
        uf: 'SP'
      }
    });
    console.log('Checkout ID:', checkout.checkoutId);
    
    // 6. Efetuar pagamento
    console.log('6. Efetuando pagamento...');
    const pagamento = await client.efetuarPagamento({
      checkoutId: checkout.checkoutId,
      paymentMethod: 'credit_card',
      cardToken: token.cardToken,
      installments: 1
    });
    console.log('Pagamento ID:', pagamento.paymentId);
    console.log('Status:', pagamento.status);
    
    // 7. Aguardar e consultar status
    console.log('7. Aguardando processamento...');
    await sleep(5000);
    
    const status = await client.consultarPagamento({
      paymentId: pagamento.paymentId
    });
    console.log('Status final:', status.status);
    console.log('Status de liquidação:', status.liquidationStatus);
    
    return {
      success: true,
      paymentId: pagamento.paymentId,
      status: status
    };
    
  } catch (error) {
    console.error('Erro no processamento:', error.message);
    throw error;
  }
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// Executar
processarPagamentoCompleto()
  .then(result => console.log('Sucesso!', result))
  .catch(error => console.error('Falha:', error));

import time
from uvvipague_client import UvvipagueClient

def processar_pagamento_completo():
    client = UvvipagueClient(api_key=os.getenv('UVVIPAGUE_API_KEY'))
    
    try:
        # 1. Enriquecer dados do veículo (opcional)
        print('1. Enriquecendo dados do veículo...')
        veiculo = client.enriquecer_veiculo(
            license_plate='ABC1234',
            uf='SP'
        )
        print(f'Veículo: {veiculo["data"]}')
        
        # 2. Consultar débitos
        print('2. Consultando débitos...')
        debitos = client.consultar_debitos(
            state='SP',
            license_plate='ABC1234',
            renavam=veiculo['data']['renavam'],
            cpf_cnpj='12345678900'
        )
        print(f'Encontrados {len(debitos["debts"])} débitos')
        print(f'Total: R$ {debitos["totalAmount"]}')
        
    # 3. Simular parcelas
    print('3. Simulando parcelas...')
    simulacao = client.simular_parcelas(
        amount=debitos['totalAmount'],
        payment_method='credit_card'
    )
    print(f'Opções de parcelamento: {len(simulacao["installments"])}')
    for opt in simulacao['installments']:
        print(f'{opt["number"]}x de R$ {opt["installmentAmount"]:.2f} (total: R$ {opt["totalAmount"]:.2f})')
    
    # 4. Tokenizar cartão
    print('4. Tokenizando cartão...')
    token = client.tokenizar_cartao(
            card_number='4111111111111111',
            cardholder_name='JOAO DA SILVA',
            expiration_month='12',
            expiration_year='2025',
            security_code='123'
        )
        print(f'Token gerado: {token["cardToken"]}')
        
    # 5. Criar checkout
    print('5. Criando checkout...')
    checkout = client.criar_checkout(
            debts=[d['id'] for d in debitos['debts']],
            customer={
                'name': 'João da Silva',
                'email': 'joao@example.com',
                'cpfCnpj': '12345678900',
                'phone': '11987654321'
            },
            vehicle={
                'licensePlate': 'ABC1234',
                'renavam': veiculo['data']['renavam'],
                'uf': 'SP'
            }
        )
        print(f'Checkout ID: {checkout["checkoutId"]}')
        
    # 6. Efetuar pagamento
    print('6. Efetuando pagamento...')
    pagamento = client.efetuar_pagamento(
            checkout_id=checkout['checkoutId'],
            payment_method='credit_card',
            card_token=token['cardToken'],
            installments=1
        )
        print(f'Pagamento ID: {pagamento["paymentId"]}')
        print(f'Status: {pagamento["status"]}')
        
    # 7. Aguardar e consultar status
    print('7. Aguardando processamento...')
    time.sleep(5)
        
        status = client.consultar_pagamento(
            payment_id=pagamento['paymentId']
        )
        print(f'Status final: {status["status"]}')
        print(f'Status de liquidação: {status["liquidationStatus"]}')
        
        return {
            'success': True,
            'paymentId': pagamento['paymentId'],
            'status': status
        }
        
    except Exception as error:
        print(f'Erro no processamento: {str(error)}')
        raise

# Executar
if __name__ == '__main__':
    resultado = processar_pagamento_completo()
    print('Sucesso!', resultado)

async function processarPagamento(paymentData) {
  const timeoutMs = 30000; // 30 segundos
  
  try {
    // Tentar resposta síncrona
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
    
    const response = await fetch('/uvvi/v1/payment', {
      method: 'POST',
      headers: {
        'x-api-key': process.env.API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(paymentData),
      signal: controller.signal
    });
    
    clearTimeout(timeoutId);
    
    const result = await response.json();
    
    // Resposta síncrona recebida
    console.log('Resposta síncrona:', result.status);
    await processarStatusPagamento(result);
    
    return {
      mode: 'sync',
      status: result.status,
      paymentId: result.paymentId
    };
    
  } catch (error) {
    if (error.name === 'AbortError') {
      // Timeout - aguardar webhook
      console.log('Timeout na API - aguardando webhook');
      
      // Salvar no banco como "aguardando webhook"
      await database.payments.create({
        externalId: paymentData.externalId,
        status: 'awaiting_webhook',
        createdAt: new Date()
      });
      
      return {
        mode: 'async',
        status: 'awaiting_webhook',
        message: 'Aguardando confirmação via webhook'
      };
    }
    
    throw error;
  }
}

// Handler do webhook
app.post('/webhook/uvvipague', async (req, res) => {
  // Retornar 200 imediatamente
  res.status(200).json({ received: true });
  
  const { paymentId, status, externalId } = req.body;
  
  // Atualizar status no banco
  await database.payments.update(
    { externalId },
    { 
      status,
      paymentId,
      processedAt: new Date(),
      mode: 'webhook'
    }
  );
  
  console.log(`Pagamento ${paymentId} atualizado via webhook: ${status}`);
});

import asyncio
import requests
from datetime import datetime

async def processar_pagamento(payment_data):
    timeout_seconds = 30
    
    try:
        # Tentar resposta síncrona
        response = requests.post(
            'https://api.uvvipague.com.br/uvvi/v1/payment',
            headers={
                'x-api-key': os.getenv('API_KEY'),
                'Content-Type': 'application/json'
            },
            json=payment_data,
            timeout=timeout_seconds
        )
        
        result = response.json()
        
        # Resposta síncrona recebida
        print(f'Resposta síncrona: {result["status"]}')
        await processar_status_pagamento(result)
        
        return {
            'mode': 'sync',
            'status': result['status'],
            'paymentId': result['paymentId']
        }
        
    except requests.Timeout:
        # Timeout - aguardar webhook
        print('Timeout na API - aguardando webhook')
        
        # Salvar no banco como "aguardando webhook"
        database.payments.create({
            'externalId': payment_data['externalId'],
            'status': 'awaiting_webhook',
            'createdAt': datetime.now()
        })
        
        return {
            'mode': 'async',
            'status': 'awaiting_webhook',
            'message': 'Aguardando confirmação via webhook'
        }

# Handler do webhook
@app.route('/webhook/uvvipague', methods=['POST'])
def webhook_uvvipague():
    # Retornar 200 imediatamente
    payload = request.json
    
    payment_id = payload['paymentId']
    status = payload['status']
    external_id = payload['externalId']
    
    # Atualizar status no banco
    database.payments.update(
        {'externalId': external_id},
        {
            'status': status,
            'paymentId': payment_id,
            'processedAt': datetime.now(),
            'mode': 'webhook'
        }
    )
    
    print(f'Pagamento {payment_id} atualizado via webhook: {status}')
    
    return jsonify({'received': True}), 200