Como prevenir fraude em gift cards usando validação de CPF do comprador

const express = require('express');
const crypto = require('crypto');
const app = express();
app.use(express.json());

const CPFHUB_API_KEY = 'SUA_CHAVE_DE_API';

// Simulacao de banco de dados
const giftCardsDb = new Map();
const comprasPorCpf = new Map();

async function validarCpf(cpf) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 10000);

    try {
    const response = await fetch(
    `https://api.cpfhub.io/cpf/${cpf}`,
    {
    method: 'GET',
    headers: {
    'x-api-key': CPFHUB_API_KEY,
    'Accept': 'application/json'
    },
    signal: controller.signal
    }
    );
    clearTimeout(timeoutId);
    return await response.json();
    } catch (error) {
    clearTimeout(timeoutId);
    throw error;
    }
}

// Configuracao de limites
const LIMITES = {
    maxValorPorCompra: 1000,
    maxComprasPorDia: 3,
    maxValorDiarioPorCpf: 2000
};

function verificarLimites(cpf, valor) {
    const historico = comprasPorCpf.get(cpf) || [];
    const hoje = new Date().toISOString().split('T')[0];

    const comprasHoje = historico.filter(
    c => c.data.startsWith(hoje)
    );

    if (comprasHoje.length >= LIMITES.maxComprasPorDia) {
    return {
    permitido: false,
    motivo: `Limite de ${LIMITES.maxComprasPorDia} compras `
    + `por dia atingido`
    };
    }

    const valorHoje = comprasHoje.reduce(
    (sum, c) => sum + c.valor, 0
    );

    if (valorHoje + valor > LIMITES.maxValorDiarioPorCpf) {
    return {
    permitido: false,
    motivo: `Limite diario de R$ ${LIMITES.maxValorDiarioPorCpf} `
    + `por CPF atingido`
    };
    }

    if (valor > LIMITES.maxValorPorCompra) {
    return {
    permitido: false,
    motivo: `Valor maximo por gift card: `
    + `R$ ${LIMITES.maxValorPorCompra}`
    };
    }

    return { permitido: true };
}

// Endpoint: comprar gift card
app.post('/api/gift-cards/comprar', async (req, res) => {
    const { cpf_comprador, nome_comprador, valor, cpf_destinatario } = req.body;

    // 1. Validar CPF do comprador
    try {
    const resultadoComprador = await validarCpf(cpf_comprador);

    if (!resultadoComprador.success) {
    return res.status(400).json({
    erro: 'CPF do comprador nao encontrado'
    });
    }

    // Verificar nome
    const nomeApi = resultadoComprador.data.nameUpper;
    const nomeInf = nome_comprador.toUpperCase().trim();
    const palavrasApi = nomeApi.split(' ');
    const palavrasInf = nomeInf.split(' ');
    const coincid = palavrasInf.filter(p => palavrasApi.includes(p));

    if (coincid.length / Math.max(palavrasApi.length, palavrasInf.length) < 0.5) {
    return res.status(400).json({
    erro: 'Nome do comprador nao corresponde ao CPF'
    });
    }

    // 2. Verificar limites
    const limiteCheck = verificarLimites(cpf_comprador, valor);
    if (!limiteCheck.permitido) {
    return res.status(403).json({ erro: limiteCheck.motivo });
    }

    // 3. Se há destinatário diferente, validar também
    let nomeDestinatario = resultadoComprador.data.name;
    if (cpf_destinatario && cpf_destinatario !== cpf_comprador) {
    const resultadoDest = await validarCpf(cpf_destinatario);
    if (!resultadoDest.success) {
    return res.status(400).json({
    erro: 'CPF do destinatario nao encontrado'
    });
    }
    nomeDestinatario = resultadoDest.data.name;
    }

    // 4. Gerar gift card
    const codigo = crypto.randomBytes(8).toString('hex').toUpperCase();
    const giftCard = {
    codigo,
    valor,
    saldo: valor,
    cpf_comprador,
    nome_comprador: resultadoComprador.data.name,
    cpf_destinatario: cpf_destinatario || cpf_comprador,
    nome_destinatario: nomeDestinatario,
    status: 'ATIVO',
    criado_em: new Date().toISOString(),
    transacoes: []
    };

    giftCardsDb.set(codigo, giftCard);

    // Registrar compra no historico
    const historico = comprasPorCpf.get(cpf_comprador) || [];
    historico.push({
    codigo,
    valor,
    data: new Date().toISOString()
    });
    comprasPorCpf.set(cpf_comprador, historico);

    return res.status(201).json({
    sucesso: true,
    gift_card: {
    codigo,
    valor,
    destinatario: nomeDestinatario
    }
    });
    } catch (error) {
    return res.status(500).json({ erro: 'Erro na validacao' });
    }
});

// Endpoint: resgatar gift card
app.post('/api/gift-cards/resgatar', async (req, res) => {
    const { codigo, cpf_resgatante, valor_uso } = req.body;

    const giftCard = giftCardsDb.get(codigo);

    if (!giftCard) {
    return res.status(404).json({ erro: 'Gift card nao encontrado' });
    }

    if (giftCard.status !== 'ATIVO') {
    return res.status(400).json({ erro: 'Gift card inativo' });
    }

    if (cpf_resgatante !== giftCard.cpf_destinatario) {
    return res.status(403).json({
    erro: 'CPF nao autorizado a resgatar este gift card'
    });
    }

    if (valor_uso > giftCard.saldo) {
    return res.status(400).json({
    erro: `Saldo insuficiente. Disponivel: R$ ${giftCard.saldo}`
    });
    }

    giftCard.saldo -= valor_uso;
    giftCard.transacoes.push({
    tipo: 'RESGATE',
    valor: valor_uso,
    cpf: cpf_resgatante,
    data: new Date().toISOString()
    });

    if (giftCard.saldo === 0) {
    giftCard.status = 'UTILIZADO';
    }

    return res.json({
    sucesso: true,
    saldo_restante: giftCard.saldo,
    status: giftCard.status
    });
});

app.listen(3000);