Validação de CPF para plataformas de aluguel temporário (Airbnb, Booking)

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 imoveis = new Map();
const reservas = new Map();
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 de usuário (hóspede ou anfitrião)
app.post("/api/usuario/cadastro", async (req, res) => {
    const { nome, email, cpf, tipo } = req.body;
    // tipo: "HOSPEDE" ou "ANFITRIAO"

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

    if (!["HOSPEDE", "ANFITRIAO"].includes(tipo)) {
    return res.status(400).json({
    erro: "Tipo deve ser HOSPEDE ou ANFITRIAO",
    });
    }

    const cpfLimpo = limparCpf(cpf);

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

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

    // Verificação de maioridade
    const anoNascimento = dados.year || 0;
    const idade = new Date().getFullYear() - anoNascimento;

    if (idade < 18) {
    return res.status(403).json({
    erro: "É necessário ter pelo menos 18 anos para se cadastrar",
    });
    }

    // Verificação de nome
    const primeiroNomeInformado = nome.trim().split(" ")[0].toUpperCase();
    const primeiroNomeApi = dados.name.trim().split(" ")[0].toUpperCase();

    if (primeiroNomeInformado !== primeiroNomeApi) {
    return res.status(422).json({
    erro: "Nome informado não corresponde ao CPF",
    });
    }

    const id = crypto.randomUUID();

    usuarios.set(id, {
    id,
    nome: dados.name,
    nomeUpper: dados.nameUpper,
    email,
    cpf: cpfLimpo,
    dataNascimento: dados.birthDate,
    genero: dados.gender,
    idade,
    tipo,
    verificado: true,
    avaliacaoMedia: null,
    totalAvaliacoes: 0,
    criadoEm: new Date().toISOString(),
    });

    cpfsCadastrados.add(cpfLimpo);

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

// Anfitrião cadastra imóvel
app.post("/api/imovel/cadastrar", (req, res) => {
    const { anfitriaoId, titulo, endereco, precoDiaria, maxHospedes } = req.body;

    const anfitriao = usuarios.get(anfitriaoId);
    if (!anfitriao || anfitriao.tipo !== "ANFITRIAO") {
    return res.status(403).json({
    erro: "Apenas anfitriões verificados podem cadastrar imóveis",
    });
    }

    if (!anfitriao.verificado) {
    return res.status(403).json({
    erro: "Anfitrião precisa ter CPF verificado",
    });
    }

    const imovelId = crypto.randomUUID();

    imoveis.set(imovelId, {
    id: imovelId,
    anfitriaoId,
    cpfAnfitriao: anfitriao.cpf,
    nomeAnfitriao: anfitriao.nome,
    titulo,
    endereco,
    precoDiaria,
    maxHospedes,
    ativo: true,
    criadoEm: new Date().toISOString(),
    });

    res.json({
    sucesso: true,
    imovelId,
    mensagem: "Imóvel cadastrado com sucesso",
    });
});

// Hóspede faz reserva
app.post("/api/reserva/criar", async (req, res) => {
    const { hospedeId, imovelId, checkin, checkout, numHospedes } = req.body;

    const hospede = usuarios.get(hospedeId);
    if (!hospede || hospede.tipo !== "HOSPEDE") {
    return res.status(403).json({
    erro: "Apenas hóspedes verificados podem fazer reservas",
    });
    }

    if (!hospede.verificado) {
    return res.status(403).json({
    erro: "CPF precisa ser verificado antes de reservar",
    });
    }

    const imovel = imoveis.get(imovelId);
    if (!imovel || !imovel.ativo) {
    return res.status(404).json({ erro: "Imóvel não encontrado ou inativo" });
    }

    if (numHospedes > imovel.maxHospedes) {
    return res.status(400).json({
    erro: `Imóvel comporta no máximo ${imovel.maxHospedes} hóspedes`,
    });
    }

    // Revalida CPF do hóspede antes de reservas de alto valor
    const dataCheckin = new Date(checkin);
    const dataCheckout = new Date(checkout);
    const noites = Math.ceil(
    (dataCheckout - dataCheckin) / (1000 * 60 * 60 * 24)
    );
    const valorTotal = noites * imovel.precoDiaria;

    if (valorTotal > 2000) {
    try {
    const dadosAtuais = await consultarCpf(hospede.cpf);
    if (!dadosAtuais) {
    return res.status(422).json({
    erro: "Falha na revalidação de CPF para reserva de alto valor",
    });
    }
    } catch (error) {
    return res.status(503).json({
    erro: "Não foi possível revalidar CPF. Tente novamente.",
    });
    }
    }

    const reservaId = `RES-${Date.now()}`;

    reservas.set(reservaId, {
    id: reservaId,
    hospedeId,
    cpfHospede: hospede.cpf,
    nomeHospede: hospede.nome,
    imovelId,
    anfitriaoId: imovel.anfitriaoId,
    cpfAnfitriao: imovel.cpfAnfitriao,
    checkin,
    checkout,
    noites,
    numHospedes,
    valorTotal,
    status: "PENDENTE",
    criadoEm: new Date().toISOString(),
    });

    res.json({
    sucesso: true,
    reservaId,
    imovel: imovel.titulo,
    anfitriao: imovel.nomeAnfitriao,
    checkin,
    checkout,
    noites,
    valorTotal: `R$ ${valorTotal.toFixed(2)}`,
    status: "PENDENTE",
    mensagem: "Reserva criada. Aguardando aprovação do anfitrião.",
    });
});

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