Como validar CPF em tempo real usando Rust e APIs REST

pub fn validar_digitos_cpf(cpf: &str) -> bool {
    let digitos: Vec<u32> = cpf.chars()
    .filter(|c| c.is_ascii_digit())
    .filter_map(|c| c.to_digit(10))
    .collect();

    if digitos.len() != 11 {
    return false;
    }

    // Rejeitar CPFs com todos os dígitos iguais
    if digitos.iter().all(|&d| d == digitos[0]) {
    return false;
    }

    // Primeiro dígito verificador
    let soma: u32 = digitos.iter()
    .take(9)
    .enumerate()
    .map(|(i, &d)| d * (10 - i as u32))
    .sum();
    let d1 = if soma % 11 < 2 { 0 } else { 11 - (soma % 11) };

    // Segundo dígito verificador
    let soma: u32 = digitos.iter()
    .take(10)
    .enumerate()
    .map(|(i, &d)| d * (11 - i as u32))
    .sum();
    let d2 = if soma % 11 < 2 { 0 } else { 11 - (soma % 11) };

    digitos[9] == d1 && digitos[10] == d2
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_cpf_invalido_digitos_iguais() {
    assert!(!validar_digitos_cpf("11111111111"));
    }

    #[test]
    fn test_cpf_invalido_tamanho() {
    assert!(!validar_digitos_cpf("1234"));
    }
}

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize)]
pub struct ValidacaoResult {
    pub formato_valido: bool,
    pub encontrado_na_base: bool,
    pub nome: Option<String>,
    pub data_nascimento: Option<String>,
    pub mensagem: String,
}

#[derive(Debug, Deserialize)]
pub struct CpfResponse {
    pub success: bool,
    pub data: CpfData,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CpfData {
    pub cpf: String,
    pub name: String,
    pub name_upper: String,
    pub gender: String,
    pub birth_date: String,
    pub day: String,
    pub month: String,
    pub year: String,
}

use reqwest::header::{HeaderMap, HeaderValue};

pub struct CpfValidator {
    client: reqwest::Client,
    api_key: String,
}

impl CpfValidator {
    pub fn new(api_key: String) -> Self {
    let client = reqwest::Client::builder()
    .timeout(std::time::Duration::from_secs(5))
    .build()
    .expect("Falha ao criar cliente HTTP");

    Self { client, api_key }
    }

    pub async fn validar_completo(&self, cpf: &str) -> ValidacaoResult {
    let cpf_limpo: String = cpf.chars()
    .filter(|c| c.is_ascii_digit())
    .collect();

    // Camada 1: Formato
    if cpf_limpo.len() != 11 {
    return ValidacaoResult {
    formato_valido: false,
    encontrado_na_base: false,
    nome: None,
    data_nascimento: None,
    mensagem: "CPF deve conter 11 dígitos".to_string(),
    };
    }

    // Camada 2: Dígitos verificadores
    if !validar_digitos_cpf(&cpf_limpo) {
    return ValidacaoResult {
    formato_valido: false,
    encontrado_na_base: false,
    nome: None,
    data_nascimento: None,
    mensagem: "Dígitos verificadores inválidos".to_string(),
    };
    }

    // Camada 3: Consulta à API
    match self.consultar_api(&cpf_limpo).await {
    Ok(response) if response.success => ValidacaoResult {
    formato_valido: true,
    encontrado_na_base: true,
    nome: Some(response.data.name),
    data_nascimento: Some(response.data.birth_date),
    mensagem: "CPF válido e encontrado na base".to_string(),
    },
    Ok(_) => ValidacaoResult {
    formato_valido: true,
    encontrado_na_base: false,
    nome: None,
    data_nascimento: None,
    mensagem: "CPF válido, porém não encontrado".to_string(),
    },
    Err(e) => ValidacaoResult {
    formato_valido: true,
    encontrado_na_base: false,
    nome: None,
    data_nascimento: None,
    mensagem: format!("Erro ao consultar API: {}", e),
    },
    }
    }

    async fn consultar_api(&self, cpf: &str) -> Result<CpfResponse, String> {
    let mut headers = HeaderMap::new();
    headers.insert(
    "x-api-key",
    HeaderValue::from_str(&self.api_key)
    .map_err(|e| e.to_string())?,
    );

    let url = format!("https://api.cpfhub.io/cpf/{}", cpf);

    let response = self.client
    .get(&url)
    .headers(headers)
    .send()
    .await
    .map_err(|e| e.to_string())?;

    response.json::<CpfResponse>()
    .await
    .map_err(|e| e.to_string())
    }
}

#[tokio::main]
async fn main() {
    let api_key = std::env::var("CPFHUB_API_KEY")
    .expect("Defina CPFHUB_API_KEY no ambiente");

    let validator = CpfValidator::new(api_key);

    let cpfs = vec!["12345678900", "11111111111", "98765432100"];

    for cpf in cpfs {
    let resultado = validator.validar_completo(cpf).await;
    println!("CPF: {} -> {}", cpf, resultado.mensagem);

    if let Some(nome) = &resultado.nome {
    println!(" Nome: {}", nome);
    }
    if let Some(nascimento) = &resultado.data_nascimento {
    println!(" Nascimento: {}", nascimento);
    }
    println!("---");
    }
}