Como Marketplaces Podem Evitar Golpes com APIs Gratuitas de CPF

import requests
import os
from datetime import datetime

class AntifraudeMarketplace:
    def __init__(self):
    self.api_key = os.environ.get("CPFHUB_API_KEY", "")
    self.base_url = "https://api.cpfhub.io/cpf"
    self.cpfs_cadastrados = {} # Em produção, usar banco de dados

    def validar_novo_cadastro(self, cpf: str, nome_informado: str) -> dict:
    cpf_limpo = "".join(c for c in cpf if c.isdigit())

    # Verificação 1: CPF já cadastrado no marketplace
    if cpf_limpo in self.cpfs_cadastrados:
    return {
    "aprovado": False,
    "motivo": "CPF já cadastrado em outra conta",
    "risco": "alto"
    }

    # Verificação 2: Consultar CPF na API
    try:
    response = requests.get(
    f"{self.base_url}/{cpf_limpo}",
    headers={"x-api-key": self.api_key},
    timeout=10
    )

    if response.status_code != 200:
    return {
    "aprovado": False,
    "motivo": "CPF não encontrado na base de dados",
    "risco": "alto"
    }

    dados = response.json()
    if not dados.get("success"):
    return {
    "aprovado": False,
    "motivo": "CPF inválido",
    "risco": "alto"
    }

    nome_api = dados["data"]["name"].upper()
    nome_input = nome_informado.upper()

    # Verificação 3: Nome corresponde
    correspondencia = self._calcular_similaridade(nome_api, nome_input)

    if correspondencia < 0.6:
    return {
    "aprovado": False,
    "motivo": "Nome informado não corresponde ao CPF",
    "risco": "alto",
    "detalhe": f"Esperado: {nome_api}"
    }

    # Verificação 4: Idade mínima
    ano_nascimento = int(dados["data"]["year"])
    idade = datetime.now().year - ano_nascimento
    if idade < 18:
    return {
    "aprovado": False,
    "motivo": "Titular do CPF é menor de idade",
    "risco": "medio"
    }

    self.cpfs_cadastrados[cpf_limpo] = {
    "nome": nome_api,
    "data_cadastro": datetime.now().isoformat()
    }

    return {
    "aprovado": True,
    "nome_confirmado": dados["data"]["name"],
    "risco": "baixo"
    }

    except Exception as e:
    return {
    "aprovado": None,
    "motivo": f"Erro na verificação: {str(e)}",
    "risco": "medio"
    }

    def _calcular_similaridade(self, s1: str, s2: str) -> float:
    palavras_s1 = set(s1.split())
    palavras_s2 = set(s2.split())
    if not palavras_s1 or not palavras_s2:
    return 0.0
    intersecao = palavras_s1 & palavras_s2
    uniao = palavras_s1 | palavras_s2
    return len(intersecao) / len(uniao)

class OnboardingVendedor:
    def __init__(self):
    self.antifraude = AntifraudeMarketplace()

    def iniciar_cadastro(self, dados: dict) -> dict:
    etapas = {
    "cpf": self._validar_cpf,
    "dados_pessoais": self._validar_dados,
    "endereco": self._validar_endereco,
    }

    resultados = {}
    for etapa, validador in etapas.items():
    resultado = validador(dados)
    resultados[etapa] = resultado
    if resultado.get("bloqueante"):
    return {
    "status": "rejeitado",
    "etapa_falha": etapa,
    "resultados": resultados
    }

    return {"status": "aprovado", "resultados": resultados}

    def _validar_cpf(self, dados: dict) -> dict:
    resultado = self.antifraude.validar_novo_cadastro(
    cpf=dados.get("cpf", ""),
    nome_informado=dados.get("nome", "")
    )

    return {
    "aprovado": resultado["aprovado"] is True,
    "bloqueante": resultado["aprovado"] is False,
    "risco": resultado.get("risco", "desconhecido"),
    "detalhes": resultado.get("motivo", "")
    }

    def _validar_dados(self, dados: dict) -> dict:
    campos_obrigatorios = ["nome", "email", "telefone"]
    ausentes = [c for c in campos_obrigatorios if not dados.get(c)]
    return {
    "aprovado": len(ausentes) == 0,
    "bloqueante": len(ausentes) > 0,
    "detalhes": f"Campos ausentes: {', '.join(ausentes)}" if ausentes else ""
    }

    def _validar_endereco(self, dados: dict) -> dict:
    return {
    "aprovado": bool(dados.get("cep")),
    "bloqueante": False,
    "detalhes": "" if dados.get("cep") else "CEP não informado"
    }

class MetricasAntifraude:
    def __init__(self):
    self.contadores = {
    "total_validacoes": 0,
    "cpf_invalido": 0,
    "nome_divergente": 0,
    "cpf_duplicado": 0,
    "aprovados": 0,
    }

    def registrar(self, resultado: dict):
    self.contadores["total_validacoes"] += 1

    if resultado.get("aprovado") is True:
    self.contadores["aprovados"] += 1
    elif "não encontrado" in resultado.get("motivo", ""):
    self.contadores["cpf_invalido"] += 1
    elif "não corresponde" in resultado.get("motivo", ""):
    self.contadores["nome_divergente"] += 1
    elif "já cadastrado" in resultado.get("motivo", ""):
    self.contadores["cpf_duplicado"] += 1

    def relatorio(self) -> dict:
    total = max(self.contadores["total_validacoes"], 1)
    return {
    "taxa_aprovacao": f"{self.contadores['aprovados'] / total:.1%}",
    "taxa_cpf_invalido": f"{self.contadores['cpf_invalido'] / total:.1%}",
    "taxa_nome_divergente": f"{self.contadores['nome_divergente'] / total:.1%}",
    "taxa_duplicado": f"{self.contadores['cpf_duplicado'] / total:.1%}",
    }