payjp_shared/
event.rs

1/// eventオブジェクト
2///
3/// For more details see <<https://pay.jp/docs/api>>.
4#[derive(Clone,Debug)]
5#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
6#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
7pub struct Event {
8    /// このイベント作成時のUTCタイムスタンプ
9     pub created: i64,
10    /// このイベントに関連したリソースオブジェクト todo generics????
11    #[cfg_attr(
12        any(feature = "deserialize", feature = "serialize"),
13        serde(with = "payjp_types::with_serde_json")
14    )]
15    pub data: miniserde::json::Value,
16    /// evnt_で始まる一意なオブジェクトを示す文字列
17    pub id: payjp_shared::EventId,
18    /// 本番環境かどうか
19    pub livemode: bool,
20        /// 設定されたURLへの通知が完了していない(2xxのレスポンスが得られていない)webhookの数.
21    pub pending_webhooks: Option<i64>,
22        /// このイベントのタイプ。値の種類については[こちら](https://pay.jp/docs/webhook#%E3%82%A4%E3%83%99%E3%83%B3%E3%83%88).
23    #[cfg_attr(feature = "deserialize", serde(rename = "type"))]
24    pub type_: EventType,
25}
26#[doc(hidden)]
27pub struct EventBuilder {
28    created: Option<i64>,
29data: Option<miniserde::json::Value>,
30id: Option<payjp_shared::EventId>,
31livemode: Option<bool>,
32pending_webhooks: Option<Option<i64>>,
33type_: Option<EventType>,
34
35}
36
37#[allow(unused_variables, irrefutable_let_patterns, clippy::let_unit_value, clippy::match_single_binding, clippy::single_match)]
38const _: () = {
39    use miniserde::de::{Map, Visitor};
40    use miniserde::json::Value;
41    use miniserde::{make_place, Deserialize, Result};
42    use payjp_types::{MapBuilder, ObjectDeser};
43    use payjp_types::miniserde_helpers::FromValueOpt;
44
45    make_place!(Place);
46
47    impl Deserialize for Event {
48    fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
49       Place::new(out)
50    }
51}
52
53struct Builder<'a> {
54    out: &'a mut Option<Event>,
55    builder: EventBuilder,
56}
57
58impl Visitor for Place<Event> {
59    fn map(&mut self) -> Result<Box<dyn Map + '_>> {
60        Ok(Box::new(Builder {
61            out: &mut self.out,
62            builder: EventBuilder::deser_default(),
63        }))
64    }
65}
66
67impl MapBuilder for EventBuilder {
68    type Out = Event;
69    fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
70        Ok(match k {
71            "created" => Deserialize::begin(&mut self.created),
72"data" => Deserialize::begin(&mut self.data),
73"id" => Deserialize::begin(&mut self.id),
74"livemode" => Deserialize::begin(&mut self.livemode),
75"pending_webhooks" => Deserialize::begin(&mut self.pending_webhooks),
76"type" => Deserialize::begin(&mut self.type_),
77
78            _ => <dyn Visitor>::ignore(),
79        })
80    }
81
82    fn deser_default() -> Self {
83        Self {
84            created: Deserialize::default(),
85data: Deserialize::default(),
86id: Deserialize::default(),
87livemode: Deserialize::default(),
88pending_webhooks: Deserialize::default(),
89type_: Deserialize::default(),
90
91        }
92    }
93
94    fn take_out(&mut self) -> Option<Self::Out> {
95        let (Some(created),
96Some(data),
97Some(id),
98Some(livemode),
99Some(pending_webhooks),
100Some(type_),
101) = (self.created,
102self.data.take(),
103self.id.take(),
104self.livemode,
105self.pending_webhooks,
106self.type_,
107) else {
108            return None;
109        };
110        Some(Self::Out { created,data,id,livemode,pending_webhooks,type_ })
111    }
112}
113
114impl<'a> Map for Builder<'a> {
115    fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
116        self.builder.key(k)
117    }
118
119    fn finish(&mut self) -> Result<()> {
120        *self.out = self.builder.take_out();
121        Ok(())
122    }
123}
124
125impl ObjectDeser for Event {
126    type Builder = EventBuilder;
127}
128
129impl FromValueOpt for Event {
130    fn from_value(v: Value) -> Option<Self> {
131        let Value::Object(obj) = v else {
132            return None;
133        };
134        let mut b = EventBuilder::deser_default();
135        for (k, v) in obj {
136            match k.as_str() {
137                "created" => b.created = FromValueOpt::from_value(v),
138"data" => b.data = FromValueOpt::from_value(v),
139"id" => b.id = FromValueOpt::from_value(v),
140"livemode" => b.livemode = FromValueOpt::from_value(v),
141"pending_webhooks" => b.pending_webhooks = FromValueOpt::from_value(v),
142"type" => b.type_ = FromValueOpt::from_value(v),
143
144                _ => {}
145            }
146        }
147        b.take_out()
148    }
149}
150
151};
152/* todo
153#[cfg(feature = "serialize")]
154impl serde::Serialize for Event {
155    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
156        use serde::ser::SerializeStruct;
157        let mut s = s.serialize_struct("Event", 7)?;
158        s.serialize_field("created", &self.created)?;
159s.serialize_field("data", &self.data)?;
160s.serialize_field("id", &self.id)?;
161s.serialize_field("livemode", &self.livemode)?;
162s.serialize_field("pending_webhooks", &self.pending_webhooks)?;
163s.serialize_field("type", &self.type_)?;
164
165        s.serialize_field("object", "event")?;
166        s.end()
167    }
168}
169*/
170/// このイベントのタイプ。値の種類については[こちら](https://pay.jp/docs/webhook#%E3%82%A4%E3%83%99%E3%83%B3%E3%83%88).
171#[derive(Copy,Clone,Eq, PartialEq,)]#[non_exhaustive]pub enum EventType {
172ChargeSucceeded,
173ChargeFailed,
174ChargeUpdated,
175ChargeRefunded,
176ChargeCaptured,
177DisputeCreated,
178TokenCreated,
179CustomerCreated,
180CustomerUpdated,
181CustomerDeleted,
182CustomerCardCreated,
183CustomerCardUpdated,
184CustomerCardDeleted,
185PlanCreated,
186PlanUpdated,
187PlanDeleted,
188SubscriptionCreated,
189SubscriptionUpdated,
190SubscriptionDeleted,
191SubscriptionPaused,
192SubscriptionResumed,
193SubscriptionCanceled,
194SubscriptionRenewed,
195TransferSucceeded,
196TenantCreated,
197TenantDeleted,
198TenantUpdated,
199TenantTransferSucceeded,
200TermCreated,
201TermClosed,
202StatementCreated,
203BalanceCreated,
204BalanceFixed,
205BalanceClosed,
206BalanceMerged,
207Unknown,
208
209}
210impl EventType {
211    pub fn as_str(self) -> &'static str {
212        use EventType::*;
213        match self {
214ChargeSucceeded => "charge.succeeded",
215ChargeFailed => "charge.failed",
216ChargeUpdated => "charge.updated",
217ChargeRefunded => "charge.refunded",
218ChargeCaptured => "charge.captured",
219DisputeCreated => "dispute.created",
220TokenCreated => "token.created",
221CustomerCreated => "customer.created",
222CustomerUpdated => "customer.updated",
223CustomerDeleted => "customer.deleted",
224CustomerCardCreated => "customer.card.created",
225CustomerCardUpdated => "customer.card.updated",
226CustomerCardDeleted => "customer.card.deleted",
227PlanCreated => "plan.created",
228PlanUpdated => "plan.updated",
229PlanDeleted => "plan.deleted",
230SubscriptionCreated => "subscription.created",
231SubscriptionUpdated => "subscription.updated",
232SubscriptionDeleted => "subscription.deleted",
233SubscriptionPaused => "subscription.paused",
234SubscriptionResumed => "subscription.resumed",
235SubscriptionCanceled => "subscription.canceled",
236SubscriptionRenewed => "subscription.renewed",
237TransferSucceeded => "transfer.succeeded",
238TenantCreated => "tenant.created",
239TenantDeleted => "tenant.deleted",
240TenantUpdated => "tenant.updated",
241TenantTransferSucceeded => "tenant_transfer.succeeded",
242TermCreated => "term.created",
243TermClosed => "term.closed",
244StatementCreated => "statement.created",
245BalanceCreated => "balance.created",
246BalanceFixed => "balance.fixed",
247BalanceClosed => "balance.closed",
248BalanceMerged => "balance.merged",
249Unknown => "unknown",
250
251        }
252    }
253}
254
255impl std::str::FromStr for EventType {
256    type Err = std::convert::Infallible;
257    fn from_str(s: &str) -> Result<Self, Self::Err> {
258        use EventType::*;
259        match s {
260    "charge.succeeded" => Ok(ChargeSucceeded),
261"charge.failed" => Ok(ChargeFailed),
262"charge.updated" => Ok(ChargeUpdated),
263"charge.refunded" => Ok(ChargeRefunded),
264"charge.captured" => Ok(ChargeCaptured),
265"dispute.created" => Ok(DisputeCreated),
266"token.created" => Ok(TokenCreated),
267"customer.created" => Ok(CustomerCreated),
268"customer.updated" => Ok(CustomerUpdated),
269"customer.deleted" => Ok(CustomerDeleted),
270"customer.card.created" => Ok(CustomerCardCreated),
271"customer.card.updated" => Ok(CustomerCardUpdated),
272"customer.card.deleted" => Ok(CustomerCardDeleted),
273"plan.created" => Ok(PlanCreated),
274"plan.updated" => Ok(PlanUpdated),
275"plan.deleted" => Ok(PlanDeleted),
276"subscription.created" => Ok(SubscriptionCreated),
277"subscription.updated" => Ok(SubscriptionUpdated),
278"subscription.deleted" => Ok(SubscriptionDeleted),
279"subscription.paused" => Ok(SubscriptionPaused),
280"subscription.resumed" => Ok(SubscriptionResumed),
281"subscription.canceled" => Ok(SubscriptionCanceled),
282"subscription.renewed" => Ok(SubscriptionRenewed),
283"transfer.succeeded" => Ok(TransferSucceeded),
284"tenant.created" => Ok(TenantCreated),
285"tenant.deleted" => Ok(TenantDeleted),
286"tenant.updated" => Ok(TenantUpdated),
287"tenant_transfer.succeeded" => Ok(TenantTransferSucceeded),
288"term.created" => Ok(TermCreated),
289"term.closed" => Ok(TermClosed),
290"statement.created" => Ok(StatementCreated),
291"balance.created" => Ok(BalanceCreated),
292"balance.fixed" => Ok(BalanceFixed),
293"balance.closed" => Ok(BalanceClosed),
294"balance.merged" => Ok(BalanceMerged),
295_ => Ok(Self::Unknown)
296
297        }
298    }
299}
300impl std::fmt::Display for EventType {
301    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
302        f.write_str(self.as_str())
303    }
304}
305
306impl std::fmt::Debug for EventType {
307    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
308        f.write_str(self.as_str())
309    }
310}
311#[cfg(feature = "serialize")]
312impl serde::Serialize for EventType {
313    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
314        serializer.serialize_str(self.as_str())
315    }
316}
317impl miniserde::Deserialize for EventType {
318    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
319        crate::Place::new(out)
320    }
321}
322
323impl miniserde::de::Visitor for crate::Place<EventType> {
324    fn string(&mut self, s: &str) -> miniserde::Result<()> {
325        use std::str::FromStr;
326        self.out = Some(EventType::from_str(s).unwrap());
327        Ok(())
328    }
329}
330
331payjp_types::impl_from_val_with_from_str!(EventType);
332#[cfg(feature = "deserialize")]
333impl<'de> serde::Deserialize<'de> for EventType {
334    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
335        use std::str::FromStr;
336        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
337        Ok(Self::from_str(&s).unwrap())
338    }
339}
340impl payjp_types::Object for Event {
341    type Id = payjp_shared::EventId;
342    fn id(&self) -> &Self::Id {
343        &self.id
344    }
345
346    fn into_id(self) -> Self::Id {
347        self.id
348    }
349}
350payjp_types::def_id!(EventId);
payjp_shared/event.rs

payjp_shared/
event.rs
