pagbank-cli 0.2.0

CLI para as APIs do PagBank
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use std::path::Path;

use anyhow::{bail, Context, Result};

use crate::cli::ChargebacksAction;
use crate::output;

const MAX_DISPUTE_BYTES: usize = 4 * 1024 * 1024;

fn validate_dispute_file(path: &str, len: usize) -> Result<()> {
    if !path.to_lowercase().ends_with(".pdf") {
        bail!("a evidência da disputa deve ser um arquivo PDF");
    }
    if len > MAX_DISPUTE_BYTES {
        bail!("o PDF excede o limite de 4 MB");
    }
    Ok(())
}

pub async fn run(
    action: ChargebacksAction,
    env_override: Option<&str>,
    output_fmt: &crate::cli::OutputFormat,
) -> Result<()> {
    let client = crate::client::load_client(env_override)?;

    match action {
        ChargebacksAction::Get { id } => {
            let result = pagbank_sdk::endpoints::chargebacks::get(&client, &id).await?;
            let val = serde_json::to_value(result)?;
            match output_fmt {
                crate::cli::OutputFormat::Json => output::print_json(&val),
                crate::cli::OutputFormat::Table => output::print_object_table("Chargeback", &val),
            }
            Ok(())
        }
        ChargebacksAction::Dispute { id, file } => {
            let bytes = std::fs::read(&file)
                .with_context(|| format!("falha ao ler o arquivo de evidência: {file}"))?;
            validate_dispute_file(&file, bytes.len())?;
            let file_name = Path::new(&file)
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("evidencia.pdf")
                .to_string();

            let result = pagbank_sdk::endpoints::chargebacks::create_dispute(
                &client, &id, &file_name, bytes,
            )
            .await?;
            let val = serde_json::to_value(result)?;
            output::print_success("Disputa enviada");
            match output_fmt {
                crate::cli::OutputFormat::Json => output::print_json(&val),
                crate::cli::OutputFormat::Table => output::print_object_table("Disputa", &val),
            }
            Ok(())
        }
        ChargebacksAction::GetDispute {
            chargeback_id,
            dispute_id,
        } => {
            let result = pagbank_sdk::endpoints::chargebacks::get_dispute(
                &client,
                &chargeback_id,
                &dispute_id,
            )
            .await?;
            let val = serde_json::to_value(result)?;
            match output_fmt {
                crate::cli::OutputFormat::Json => output::print_json(&val),
                crate::cli::OutputFormat::Table => output::print_object_table("Disputa", &val),
            }
            Ok(())
        }
    }
}

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

    #[test]
    fn validate_dispute_file_accepts_pdf() {
        assert!(validate_dispute_file("defesa.PDF", 1024).is_ok());
    }

    #[test]
    fn validate_dispute_file_rejects_non_pdf() {
        let err = validate_dispute_file("defesa.jpg", 1024).unwrap_err();
        assert!(err.to_string().contains("PDF"));
    }

    #[test]
    fn validate_dispute_file_rejects_large_file() {
        let err = validate_dispute_file("defesa.pdf", MAX_DISPUTE_BYTES + 1).unwrap_err();
        assert!(err.to_string().contains("4 MB"));
    }
}