razorpay_api/resources/
webhooks.rs1use serde::Deserialize;
12
13use crate::error::RazorpayError;
14use crate::resources::invoices::Invoice;
15use crate::resources::orders::Order;
16use crate::resources::payments::Payment;
17use crate::resources::refunds::Refund;
18use crate::resources::subscriptions::Subscription;
19use crate::signature::verify_webhook_signature;
20
21#[derive(Debug, Clone, PartialEq, Deserialize)]
23pub struct Wrapped<T> {
24 pub entity: T,
26}
27
28#[derive(Debug, Clone, PartialEq, Deserialize)]
30pub struct PaymentPayload {
31 pub payment: Wrapped<Payment>,
33 #[serde(default)]
35 pub order: Option<Wrapped<Order>>,
36}
37
38#[derive(Debug, Clone, PartialEq, Deserialize)]
40pub struct OrderPayload {
41 pub order: Wrapped<Order>,
43 #[serde(default)]
45 pub payment: Option<Wrapped<Payment>>,
46}
47
48#[derive(Debug, Clone, PartialEq, Deserialize)]
50pub struct RefundPayload {
51 pub refund: Wrapped<Refund>,
53 #[serde(default)]
55 pub payment: Option<Wrapped<Payment>>,
56}
57
58#[derive(Debug, Clone, PartialEq, Deserialize)]
60pub struct SubscriptionPayload {
61 pub subscription: Wrapped<Subscription>,
63}
64
65#[derive(Debug, Clone, PartialEq, Deserialize)]
67pub struct InvoicePayload {
68 pub invoice: Wrapped<Invoice>,
70 #[serde(default)]
72 pub payment: Option<Wrapped<Payment>>,
73}
74
75#[derive(Debug, Clone, PartialEq, Deserialize)]
81#[serde(tag = "event", content = "payload", remote = "Self")]
82pub enum WebhookEvent {
83 #[serde(rename = "payment.authorized")]
85 PaymentAuthorized(PaymentPayload),
86
87 #[serde(rename = "payment.captured")]
89 PaymentCaptured(PaymentPayload),
90
91 #[serde(rename = "payment.failed")]
93 PaymentFailed(PaymentPayload),
94
95 #[serde(rename = "order.paid")]
97 OrderPaid(OrderPayload),
98
99 #[serde(rename = "refund.created")]
101 RefundCreated(RefundPayload),
102
103 #[serde(rename = "refund.processed")]
105 RefundProcessed(RefundPayload),
106
107 #[serde(rename = "refund.failed")]
109 RefundFailed(RefundPayload),
110
111 #[serde(rename = "subscription.authenticated")]
113 SubscriptionAuthenticated(SubscriptionPayload),
114
115 #[serde(rename = "subscription.activated")]
117 SubscriptionActivated(SubscriptionPayload),
118
119 #[serde(rename = "subscription.charged")]
121 SubscriptionCharged(SubscriptionPayload),
122
123 #[serde(rename = "subscription.cancelled")]
125 SubscriptionCancelled(SubscriptionPayload),
126
127 #[serde(rename = "subscription.paused")]
129 SubscriptionPaused(SubscriptionPayload),
130
131 #[serde(rename = "subscription.halted")]
133 SubscriptionHalted(SubscriptionPayload),
134
135 #[serde(rename = "subscription.completed")]
137 SubscriptionCompleted(SubscriptionPayload),
138
139 #[serde(rename = "invoice.paid")]
141 InvoicePaid(InvoicePayload),
142
143 #[serde(rename = "invoice.expired")]
145 InvoiceExpired(InvoicePayload),
146
147 #[serde(other)]
150 Unknown,
151}
152
153impl<'de> serde::Deserialize<'de> for WebhookEvent {
159 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
160 where
161 D: serde::Deserializer<'de>,
162 {
163 let value = serde_json::Value::deserialize(deserializer)?;
164 Ok(WebhookEvent::deserialize(value).unwrap_or(WebhookEvent::Unknown))
165 }
166}
167
168impl WebhookEvent {
169 pub fn parse_verified(
201 raw_body: &str,
202 signature: &str,
203 webhook_secret: &str,
204 ) -> Result<Self, RazorpayError> {
205 verify_webhook_signature(raw_body, signature, webhook_secret)?;
206 Ok(serde_json::from_str(raw_body)?)
207 }
208}
209
210#[cfg(test)]
211mod tests {
212 use super::*;
213 use crate::signature::compute_signature;
214
215 const CAPTURED: &str = r#"{"event":"payment.captured","payload":{"payment":{"entity":
216 {"id":"pay_1","amount":50000,"currency":"INR","status":"captured","created_at":1}}}}"#;
217
218 #[test]
219 fn parses_payment_captured() {
220 let event: WebhookEvent = serde_json::from_str(CAPTURED).unwrap();
221 match event {
222 WebhookEvent::PaymentCaptured(p) => {
223 assert_eq!(p.payment.entity.id, "pay_1");
224 assert!(p.payment.entity.is_captured());
225 }
226 other => panic!("expected PaymentCaptured, got {other:?}"),
227 }
228 }
229
230 #[test]
231 fn unmodelled_event_becomes_unknown_rather_than_erroring() {
232 let json = r#"{"event":"virtual_account.credited","payload":{"anything":1}}"#;
233 assert_eq!(serde_json::from_str::<WebhookEvent>(json).unwrap(), WebhookEvent::Unknown);
234 }
235
236 #[test]
237 fn parse_verified_rejects_bad_signature_before_parsing() {
238 let err = WebhookEvent::parse_verified(CAPTURED, "deadbeef", "whsec").unwrap_err();
239 assert!(matches!(err, RazorpayError::SignatureMismatch));
240 }
241
242 #[test]
243 fn parse_verified_accepts_good_signature() {
244 let sig = compute_signature(CAPTURED, "whsec");
245 let event = WebhookEvent::parse_verified(CAPTURED, &sig, "whsec").unwrap();
246 assert!(matches!(event, WebhookEvent::PaymentCaptured(_)));
247 }
248
249 #[test]
250 fn subscription_charged_parses() {
251 let json = r#"{"event":"subscription.charged","payload":{"subscription":{"entity":
252 {"id":"sub_1","plan_id":"plan_1","status":"active"}}}}"#;
253 match serde_json::from_str::<WebhookEvent>(json).unwrap() {
254 WebhookEvent::SubscriptionCharged(s) => assert_eq!(s.subscription.entity.id, "sub_1"),
255 other => panic!("expected SubscriptionCharged, got {other:?}"),
256 }
257 }
258}