payrust 0.1.0

PayPal REST API client for Rust
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use crate::models::order::{Capture, Order, Refund};
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize)]
pub struct WebhookEvent {
    pub id: String,
    pub event_type: String,
    pub event_version: Option<String>,
    pub create_time: String,
    pub resource_type: String,
    pub resource_version: Option<String>,
    pub summary: Option<String>,
    pub resource: serde_json::Value,
    #[serde(default)]
    pub links: Vec<WebhookLink>,
}

#[derive(Debug, Deserialize)]
pub struct WebhookLink {
    pub href: String,
    pub rel: String,
    pub method: Option<String>,
}

#[derive(Debug)]
pub enum ParsedWebhookEvent {
    OrderApproved(Order),
    OrderCompleted(Order),
    PaymentCaptureCompleted(Capture),
    PaymentCaptureDenied(Capture),
    PaymentCapturePending(Capture),
    PaymentCaptureRefunded(Capture),
    RefundCompleted(Refund),
    Unknown {
        event_type: String,
        resource: serde_json::Value,
    },
}

impl WebhookEvent {
    pub fn parse(&self) -> Result<ParsedWebhookEvent, serde_json::Error> {
        match self.event_type.as_str() {
            "CHECKOUT.ORDER.APPROVED" => Ok(ParsedWebhookEvent::OrderApproved(
                serde_json::from_value(self.resource.clone())?,
            )),
            "CHECKOUT.ORDER.COMPLETED" => Ok(ParsedWebhookEvent::OrderCompleted(
                serde_json::from_value(self.resource.clone())?,
            )),
            "PAYMENT.CAPTURE.COMPLETED" => Ok(ParsedWebhookEvent::PaymentCaptureCompleted(
                serde_json::from_value(self.resource.clone())?,
            )),
            "PAYMENT.CAPTURE.DENIED" => Ok(ParsedWebhookEvent::PaymentCaptureDenied(
                serde_json::from_value(self.resource.clone())?,
            )),
            "PAYMENT.CAPTURE.PENDING" => Ok(ParsedWebhookEvent::PaymentCapturePending(
                serde_json::from_value(self.resource.clone())?,
            )),
            "PAYMENT.CAPTURE.REFUNDED" => Ok(ParsedWebhookEvent::PaymentCaptureRefunded(
                serde_json::from_value(self.resource.clone())?,
            )),
            "PAYMENT.REFUND.COMPLETED" => Ok(ParsedWebhookEvent::RefundCompleted(
                serde_json::from_value(self.resource.clone())?,
            )),
            _ => Ok(ParsedWebhookEvent::Unknown {
                event_type: self.event_type.clone(),
                resource: self.resource.clone(),
            }),
        }
    }

    pub fn order_id(&self) -> Option<&str> {
        self.resource.get("id").and_then(|v| v.as_str())
    }

    pub fn is_payment_success(&self) -> bool {
        matches!(
            self.event_type.as_str(),
            "CHECKOUT.ORDER.COMPLETED" | "PAYMENT.CAPTURE.COMPLETED"
        )
    }
}

#[derive(Debug)]
pub struct WebhookHeaders {
    pub transmission_id: String,
    pub transmission_time: String,
    pub cert_url: String,
    pub auth_algo: String,
    pub transmission_sig: String,
}

impl WebhookHeaders {
    pub fn from_headers<'a, I>(headers: I) -> Option<Self>
    where
        I: IntoIterator<Item = (&'a str, &'a str)>,
    {
        let mut transmission_id = None;
        let mut transmission_time = None;
        let mut cert_url = None;
        let mut auth_algo = None;
        let mut transmission_sig = None;

        for (key, value) in headers {
            match key.to_lowercase().as_str() {
                "paypal-transmission-id" => transmission_id = Some(value.to_string()),
                "paypal-transmission-time" => transmission_time = Some(value.to_string()),
                "paypal-cert-url" => cert_url = Some(value.to_string()),
                "paypal-auth-algo" => auth_algo = Some(value.to_string()),
                "paypal-transmission-sig" => transmission_sig = Some(value.to_string()),
                _ => {}
            }
        }

        Some(Self {
            transmission_id: transmission_id?,
            transmission_time: transmission_time?,
            cert_url: cert_url?,
            auth_algo: auth_algo?,
            transmission_sig: transmission_sig?,
        })
    }
}

#[derive(Debug, Serialize)]
pub(crate) struct VerifyWebhookRequest {
    pub webhook_id: String,
    pub transmission_id: String,
    pub transmission_time: String,
    pub cert_url: String,
    pub auth_algo: String,
    pub transmission_sig: String,
    pub webhook_event: serde_json::Value,
}

#[derive(Debug, Deserialize)]
pub(crate) struct VerifyWebhookResponse {
    pub verification_status: String,
}

impl VerifyWebhookResponse {
    pub fn is_success(&self) -> bool {
        self.verification_status == "SUCCESS"
    }
}

pub mod event_types {
    pub const ORDER_APPROVED: &str = "CHECKOUT.ORDER.APPROVED";
    pub const ORDER_COMPLETED: &str = "CHECKOUT.ORDER.COMPLETED";
    pub const CAPTURE_COMPLETED: &str = "PAYMENT.CAPTURE.COMPLETED";
    pub const CAPTURE_DENIED: &str = "PAYMENT.CAPTURE.DENIED";
    pub const CAPTURE_PENDING: &str = "PAYMENT.CAPTURE.PENDING";
    pub const CAPTURE_REFUNDED: &str = "PAYMENT.CAPTURE.REFUNDED";
    pub const REFUND_COMPLETED: &str = "PAYMENT.REFUND.COMPLETED";
}