promptparse 1.2.0

All-in-one Rust library for PromptPay & EMVCo QR Codes
Documentation 
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use crate::parser::parse;

#[derive(Debug, Clone, PartialEq)]
pub struct BillPaymentData {
    /// Biller ID
    pub biller_id: String,
    /// Reference 1 (required)
    pub ref1: String,
    /// Reference 2 (if present)
    pub ref2: Option<String>,
    /// (Undocumented) Reference 3 (if present)
    pub ref3: Option<String>,
    /// Transaction amount (if present)
    pub amount: Option<f64>,
}

/// Validate & extract data from PromptPay Bill Payment (Tag 30) QR Code
///
/// # Arguments
/// * `payload` - QR Code Payload
///
/// # Returns
/// Biller ID, references and optional amount or None if payload invalid
pub fn bill_payment(payload: &str) -> Option<BillPaymentData> {
    let ppqr = parse(payload, true, true)?;

    let aid_type = ppqr.get_tag_value("00", None)?;
    let tag30_aid = ppqr.get_tag_value("30", Some("00"))?;

    if aid_type != "01" || tag30_aid != "A000000677010112" {
        return None;
    }

    let biller_id = ppqr
        .get_tag_value("30", Some("01"))
        .filter(|s| !s.is_empty())?;
    let ref1 = ppqr
        .get_tag_value("30", Some("02"))
        .filter(|s| !s.is_empty())?;

    let ref2 = ppqr.get_tag_value("30", Some("03")).map(|s| s.to_string());
    let ref3 = ppqr.get_tag_value("62", Some("07")).map(|s| s.to_string());

    let amount = ppqr
        .get_tag_value("54", None)
        .and_then(|s| s.parse::<f64>().ok());

    Some(BillPaymentData {
        biller_id: biller_id.to_string(),
        ref1: ref1.to_string(),
        ref2,
        ref3,
        amount,
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::generate::any_id::{any_id as generate_any_id, AnyIdConfig, ProxyType};
    use crate::generate::bill_payment::{bill_payment as generate_bill_payment, BillPaymentConfig};

    #[test]
    fn test_bill_payment_minimal() {
        let payload = generate_bill_payment(BillPaymentConfig {
            biller_id: "0112233445566".to_string(),
            amount: None,
            ref1: "CUSTOMER001".to_string(),
            ref2: None,
            ref3: None,
        })
        .unwrap();

        let result = bill_payment(&payload).unwrap();
        assert_eq!(result.biller_id, "0112233445566");
        assert_eq!(result.ref1, "CUSTOMER001");
        assert_eq!(result.ref2, None);
        assert_eq!(result.ref3, None);
        assert_eq!(result.amount, None);
    }

    #[test]
    fn test_bill_payment_complete() {
        let payload = generate_bill_payment(BillPaymentConfig {
            biller_id: "0112233445566".to_string(),
            amount: Some(100.50),
            ref1: "CUSTOMER001".to_string(),
            ref2: Some("INV001".to_string()),
            ref3: Some("SCB".to_string()),
        })
        .unwrap();

        let result = bill_payment(&payload).unwrap();
        assert_eq!(result.biller_id, "0112233445566");
        assert_eq!(result.ref1, "CUSTOMER001");
        assert_eq!(result.ref2, Some("INV001".to_string()));
        assert_eq!(result.ref3, Some("SCB".to_string()));
        assert_eq!(result.amount, Some(100.50));
    }

    #[test]
    fn test_bill_payment_invalid_payload() {
        assert!(bill_payment("invalid_payload").is_none());
    }

    #[test]
    fn test_bill_payment_rejects_any_id() {
        // An AnyID (Tag 29) payload must not validate as Bill Payment
        let payload = generate_any_id(AnyIdConfig {
            proxy_type: ProxyType::Msisdn,
            target: "0812223333".to_string(),
            amount: None,
        })
        .unwrap();

        assert!(bill_payment(&payload).is_none());
    }
}