Fraude em avaliações falsas: como vincular CPF para reviews autenticados

const express = require("express");
const axios = require("axios");
const crypto = require("crypto");

const app = express();
app.use(express.json());

const CPFHUB_API_URL = "https://api.cpfhub.io/cpf";
const CPFHUB_API_KEY = "SUA_CHAVE_DE_API";
const REQUEST_TIMEOUT = 10000; // 10 segundos

// Simulação de banco de dados
const usuarios = new Map();
const compras = new Map(); // `${cpf}-${produtoId}` -> compra
const avaliacoes = new Map(); // `${cpf}-${produtoId}` -> avaliacao
const cpfsCadastrados = new Set();

function limparCpf(cpf) {
    return cpf.replace(/\D/g, "");
}

async function consultarCpf(cpf) {
    const cpfLimpo = limparCpf(cpf);

    try {
    const response = await axios.get(`${CPFHUB_API_URL}/${cpfLimpo}`, {
    headers: {
    "x-api-key": CPFHUB_API_KEY,
    Accept: "application/json",
    },
    timeout: REQUEST_TIMEOUT,
    });

    if (response.data.success) {
    return response.data.data;
    }
    return null;
    } catch (error) {
    if (error.code === "ECONNABORTED") {
    throw new Error("Timeout na consulta de CPF");
    }
    if (error.response) {
    const { status } = error.response;
    if (status === 401) throw new Error("API key inválida");
    if (status === 404) return null;
    }
    throw new Error("Erro na consulta de CPF");
    }
}

// Cadastro com CPF
app.post("/api/usuario/cadastro", async (req, res) => {
    const { nome, email, cpf } = req.body;

    if (!cpf || !nome || !email) {
    return res.status(400).json({
    erro: "Nome, email e CPF são obrigatórios",
    });
    }

    const cpfLimpo = limparCpf(cpf);

    if (cpfsCadastrados.has(cpfLimpo)) {
    return res.status(409).json({
    erro: "Este CPF já está cadastrado",
    });
    }

    try {
    const dados = await consultarCpf(cpfLimpo);
    if (!dados) {
    return res.status(422).json({
    erro: "CPF não encontrado na base de dados",
    });
    }

    const id = crypto.randomUUID();

    usuarios.set(id, {
    id,
    nome: dados.name,
    email,
    cpf: cpfLimpo,
    verificado: true,
    criadoEm: new Date().toISOString(),
    });

    cpfsCadastrados.add(cpfLimpo);

    res.json({ sucesso: true, usuarioId: id, nome: dados.name });
    } catch (error) {
    res.status(503).json({ erro: error.message });
    }
});

// Registrar compra (simulação)
app.post("/api/compra/registrar", (req, res) => {
    const { usuarioId, produtoId, nomeProduto, valor } = req.body;

    const usuario = usuarios.get(usuarioId);
    if (!usuario) {
    return res.status(404).json({ erro: "Usuário não encontrado" });
    }

    const chave = `${usuario.cpf}-${produtoId}`;

    compras.set(chave, {
    usuarioId,
    cpf: usuario.cpf,
    produtoId,
    nomeProduto,
    valor,
    dataCompra: new Date().toISOString(),
    entregue: true,
    });

    res.json({ sucesso: true, mensagem: "Compra registrada" });
});

// Publicar avaliação
app.post("/api/avaliacao/publicar", (req, res) => {
    const { usuarioId, produtoId, nota, titulo, texto } = req.body;

    // Validações básicas
    if (!usuarioId || !produtoId || nota === undefined || !texto) {
    return res.status(400).json({
    erro: "usuarioId, produtoId, nota e texto são obrigatórios",
    });
    }

    if (nota < 1 || nota > 5) {
    return res.status(400).json({
    erro: "Nota deve ser entre 1 e 5",
    });
    }

    const usuario = usuarios.get(usuarioId);
    if (!usuario) {
    return res.status(404).json({ erro: "Usuário não encontrado" });
    }

    // Verificação 1: CPF verificado
    if (!usuario.verificado) {
    return res.status(403).json({
    erro: "Apenas usuários com CPF verificado podem avaliar",
    });
    }

    // Verificação 2: Comprou o produto
    const chaveCompra = `${usuario.cpf}-${produtoId}`;
    const compra = compras.get(chaveCompra);

    if (!compra) {
    return res.status(403).json({
    erro: "Apenas compradores verificados podem avaliar este produto",
    seloDisponivel: false,
    });
    }

    // Verificação 3: Produto foi entregue
    if (!compra.entregue) {
    return res.status(403).json({
    erro: "Aguarde a entrega do produto para avaliar",
    });
    }

    // Verificação 4: Período mínimo após entrega (7 dias)
    const dataCompra = new Date(compra.dataCompra);
    const agora = new Date();
    const diasDesdeCompra = (agora - dataCompra) / (1000 * 60 * 60 * 24);

    // Em produção, usar data de entrega em vez de data de compra
    const DIAS_MINIMOS = 7;
    if (diasDesdeCompra < DIAS_MINIMOS) {
    return res.status(403).json({
    erro: `Aguarde ${DIAS_MINIMOS} dias após a compra para avaliar`,
    diasRestantes: Math.ceil(DIAS_MINIMOS - diasDesdeCompra),
    });
    }

    // Verificação 5: Apenas uma avaliação por CPF por produto
    const chaveAvaliacao = `${usuario.cpf}-${produtoId}`;
    if (avaliacoes.has(chaveAvaliacao)) {
    return res.status(409).json({
    erro: "Você já avaliou este produto",
    avaliacaoExistente: avaliacoes.get(chaveAvaliacao).id,
    });
    }

    // Cria avaliação autenticada
    const avaliacaoId = crypto.randomUUID();
    const avaliacao = {
    id: avaliacaoId,
    produtoId,
    cpfHash: crypto
    .createHash("sha256")
    .update(usuario.cpf)
    .digest("hex")
    .substring(0, 16),
    nomeExibicao: gerarNomeExibicao(usuario.nome),
    nota,
    titulo: titulo || "",
    texto,
    compraVerificada: true,
    dataPublicacao: agora.toISOString(),
    diasAposCompra: Math.floor(diasDesdeCompra),
    util: 0,
    denuncias: 0,
    };

    avaliacoes.set(chaveAvaliacao, avaliacao);

    res.json({
    sucesso: true,
    avaliacaoId,
    selo: "COMPRA_VERIFICADA",
    mensagem: "Avaliação publicada com sucesso",
    });
});

function gerarNomeExibicao(nomeCompleto) {
    const partes = nomeCompleto.split(" ");
    if (partes.length < 2) return `${partes[0].charAt(0)}***`;
    const primeiro = partes[0];
    const ultimo = partes[partes.length - 1];
    return `${primeiro} ${ultimo.charAt(0)}.`;
}

// Listar avaliações de um produto
app.get("/api/avaliacao/produto/:produtoId", (req, res) => {
    const { produtoId } = req.params;

    const avaliacoesProduto = [];

    for (const [chave, avaliacao] of avaliacoes) {
    if (avaliacao.produtoId === produtoId) {
    avaliacoesProduto.push({
    id: avaliacao.id,
    nome: avaliacao.nomeExibicao,
    nota: avaliacao.nota,
    titulo: avaliacao.titulo,
    texto: avaliacao.texto,
    selo: avaliacao.compraVerificada ? "COMPRA_VERIFICADA" : null,
    diasAposCompra: avaliacao.diasAposCompra,
    data: avaliacao.dataPublicacao,
    util: avaliacao.util,
    });
    }
    }

    // Calcula média
    const media =
    avaliacoesProduto.length > 0
    ? avaliacoesProduto.reduce((acc, a) => acc + a.nota, 0) /
    avaliacoesProduto.length
    : 0;

    res.json({
    produtoId,
    mediaNotas: Math.round(media * 10) / 10,
    totalAvaliacoes: avaliacoesProduto.length,
    percentualVerificado:
    avaliacoesProduto.length > 0
    ? Math.round(
    (avaliacoesProduto.filter((a) => a.selo).length /
    avaliacoesProduto.length) *
    100
    )
    : 0,
    avaliacoes: avaliacoesProduto.sort(
    (a, b) => new Date(b.data) - new Date(a.data)
    ),
    });
});

// Denunciar avaliação suspeita
app.post("/api/avaliacao/:avaliacaoId/denunciar", (req, res) => {
    const { avaliacaoId } = req.params;
    const { motivo } = req.body;

    for (const [, avaliacao] of avaliacoes) {
    if (avaliacao.id === avaliacaoId) {
    avaliacao.denuncias += 1;

    // Auto-ocultação após 5 denúncias
    if (avaliacao.denuncias >= 5) {
    avaliacao.status = "OCULTA_POR_DENUNCIAS";
    }

    return res.json({
    sucesso: true,
    mensagem: "Denúncia registrada",
    });
    }
    }

    res.status(404).json({ erro: "Avaliação não encontrada" });
});

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