payrail 0.1.1

Provider-neutral Rust payments facade for Stripe, PayPal, and Mobile Money
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

use crate::{
    CurrencyCode, MerchantReference, Money, PaymentError, PaymentEvent, PaymentProvider,
    ProviderReference,
};

use super::{
    mapper::{map_event_type, map_payment_type, map_status},
    models::LipilaCallbackPayload,
};

pub(crate) fn parse_callback(payload: &[u8]) -> Result<PaymentEvent, PaymentError> {
    let callback: LipilaCallbackPayload = serde_json::from_slice(payload)?;
    let status = map_status(&callback.status);
    let _operator = map_payment_type(&callback.payment_type);
    let _redacted_account_number = callback.account_number.as_str();
    let _transaction_type = callback.transaction_type.as_str();
    let _ip_address = callback.ip_address.as_deref();
    let reference = callback
        .external_id
        .as_deref()
        .or(callback.identifier.as_deref())
        .unwrap_or(callback.reference_id.as_str());
    let amount = callback
        .amount
        .as_i64()
        .map(|amount| {
            let currency = CurrencyCode::new(callback.currency.as_str())?;
            let minor = currency.major_integer_to_minor_units(amount)?;
            Money::new_minor(minor, currency.as_str())
        })
        .transpose()?;

    Ok(PaymentEvent {
        id: callback
            .identifier
            .as_deref()
            .map(crate::WebhookEventId::new)
            .transpose()?,
        provider: PaymentProvider::Lipila,
        provider_reference: ProviderReference::new(reference)?,
        merchant_reference: Some(MerchantReference::new(callback.reference_id)?),
        status,
        amount,
        event_type: map_event_type(status),
        message: callback.message,
    })
}

#[cfg(test)]
mod tests {
    use crate::{PaymentEventType, PaymentStatus};

    use super::*;

    #[test]
    fn parse_callback_normalizes_event() {
        let payload = br#"{
            "referenceId":"ORDER-1",
            "currency":"ZMW",
            "amount":50,
            "accountNumber":"260971234567",
            "status":"Successful",
            "paymentType":"MTNMoney",
            "type":"collection",
            "ipAddress":"127.0.0.1",
            "identifier":"evt_1",
            "message":"paid",
            "externalId":"LIPILA-1"
        }"#;

        let event = parse_callback(payload).expect("callback should parse");

        assert_eq!(event.provider_reference.as_str(), "LIPILA-1");
        assert_eq!(event.status, PaymentStatus::Succeeded);
        assert_eq!(event.event_type, PaymentEventType::PaymentSucceeded);
        assert_eq!(
            event
                .amount
                .expect("amount should be present")
                .amount()
                .value(),
            5_000
        );
    }
}