stripe_shared/
source_transaction.rs

1/// Some payment methods have no required amount that a customer must send.
2/// Customers can be instructed to send any amount, and it can be made up of
3/// multiple transactions. As such, sources can have multiple associated
4/// transactions.
5#[derive(Clone, Debug)]
6#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
7pub struct SourceTransaction {
8    pub ach_credit_transfer: Option<stripe_shared::SourceTransactionAchCreditTransferData>,
9    /// A positive integer in the smallest currency unit (that is, 100 cents for $1.00, or 1 for ¥1, Japanese Yen being a zero-decimal currency) representing the amount your customer has pushed to the receiver.
10    pub amount: i64,
11    pub chf_credit_transfer: Option<stripe_shared::SourceTransactionChfCreditTransferData>,
12    /// Time at which the object was created. Measured in seconds since the Unix epoch.
13    pub created: stripe_types::Timestamp,
14    /// Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase.
15    /// Must be a [supported currency](https://stripe.com/docs/currencies).
16    pub currency: stripe_types::Currency,
17    pub gbp_credit_transfer: Option<stripe_shared::SourceTransactionGbpCreditTransferData>,
18    /// Unique identifier for the object.
19    pub id: stripe_shared::SourceTransactionId,
20    /// Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
21    pub livemode: bool,
22    pub paper_check: Option<stripe_shared::SourceTransactionPaperCheckData>,
23    pub sepa_credit_transfer: Option<stripe_shared::SourceTransactionSepaCreditTransferData>,
24    /// The ID of the source this transaction is attached to.
25    pub source: String,
26    /// The status of the transaction, one of `succeeded`, `pending`, or `failed`.
27    pub status: String,
28    /// The type of source this transaction is attached to.
29    #[cfg_attr(feature = "deserialize", serde(rename = "type"))]
30    pub type_: SourceTransactionType,
31}
32#[doc(hidden)]
33pub struct SourceTransactionBuilder {
34    ach_credit_transfer: Option<Option<stripe_shared::SourceTransactionAchCreditTransferData>>,
35    amount: Option<i64>,
36    chf_credit_transfer: Option<Option<stripe_shared::SourceTransactionChfCreditTransferData>>,
37    created: Option<stripe_types::Timestamp>,
38    currency: Option<stripe_types::Currency>,
39    gbp_credit_transfer: Option<Option<stripe_shared::SourceTransactionGbpCreditTransferData>>,
40    id: Option<stripe_shared::SourceTransactionId>,
41    livemode: Option<bool>,
42    paper_check: Option<Option<stripe_shared::SourceTransactionPaperCheckData>>,
43    sepa_credit_transfer: Option<Option<stripe_shared::SourceTransactionSepaCreditTransferData>>,
44    source: Option<String>,
45    status: Option<String>,
46    type_: Option<SourceTransactionType>,
47}
48
49#[allow(
50    unused_variables,
51    irrefutable_let_patterns,
52    clippy::let_unit_value,
53    clippy::match_single_binding,
54    clippy::single_match
55)]
56const _: () = {
57    use miniserde::de::{Map, Visitor};
58    use miniserde::json::Value;
59    use miniserde::{make_place, Deserialize, Result};
60    use stripe_types::miniserde_helpers::FromValueOpt;
61    use stripe_types::{MapBuilder, ObjectDeser};
62
63    make_place!(Place);
64
65    impl Deserialize for SourceTransaction {
66        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
67            Place::new(out)
68        }
69    }
70
71    struct Builder<'a> {
72        out: &'a mut Option<SourceTransaction>,
73        builder: SourceTransactionBuilder,
74    }
75
76    impl Visitor for Place<SourceTransaction> {
77        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
78            Ok(Box::new(Builder {
79                out: &mut self.out,
80                builder: SourceTransactionBuilder::deser_default(),
81            }))
82        }
83    }
84
85    impl MapBuilder for SourceTransactionBuilder {
86        type Out = SourceTransaction;
87        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
88            Ok(match k {
89                "ach_credit_transfer" => Deserialize::begin(&mut self.ach_credit_transfer),
90                "amount" => Deserialize::begin(&mut self.amount),
91                "chf_credit_transfer" => Deserialize::begin(&mut self.chf_credit_transfer),
92                "created" => Deserialize::begin(&mut self.created),
93                "currency" => Deserialize::begin(&mut self.currency),
94                "gbp_credit_transfer" => Deserialize::begin(&mut self.gbp_credit_transfer),
95                "id" => Deserialize::begin(&mut self.id),
96                "livemode" => Deserialize::begin(&mut self.livemode),
97                "paper_check" => Deserialize::begin(&mut self.paper_check),
98                "sepa_credit_transfer" => Deserialize::begin(&mut self.sepa_credit_transfer),
99                "source" => Deserialize::begin(&mut self.source),
100                "status" => Deserialize::begin(&mut self.status),
101                "type" => Deserialize::begin(&mut self.type_),
102
103                _ => <dyn Visitor>::ignore(),
104            })
105        }
106
107        fn deser_default() -> Self {
108            Self {
109                ach_credit_transfer: Deserialize::default(),
110                amount: Deserialize::default(),
111                chf_credit_transfer: Deserialize::default(),
112                created: Deserialize::default(),
113                currency: Deserialize::default(),
114                gbp_credit_transfer: Deserialize::default(),
115                id: Deserialize::default(),
116                livemode: Deserialize::default(),
117                paper_check: Deserialize::default(),
118                sepa_credit_transfer: Deserialize::default(),
119                source: Deserialize::default(),
120                status: Deserialize::default(),
121                type_: Deserialize::default(),
122            }
123        }
124
125        fn take_out(&mut self) -> Option<Self::Out> {
126            let (
127                Some(ach_credit_transfer),
128                Some(amount),
129                Some(chf_credit_transfer),
130                Some(created),
131                Some(currency),
132                Some(gbp_credit_transfer),
133                Some(id),
134                Some(livemode),
135                Some(paper_check),
136                Some(sepa_credit_transfer),
137                Some(source),
138                Some(status),
139                Some(type_),
140            ) = (
141                self.ach_credit_transfer.take(),
142                self.amount,
143                self.chf_credit_transfer.take(),
144                self.created,
145                self.currency,
146                self.gbp_credit_transfer.take(),
147                self.id.take(),
148                self.livemode,
149                self.paper_check.take(),
150                self.sepa_credit_transfer.take(),
151                self.source.take(),
152                self.status.take(),
153                self.type_.take(),
154            )
155            else {
156                return None;
157            };
158            Some(Self::Out {
159                ach_credit_transfer,
160                amount,
161                chf_credit_transfer,
162                created,
163                currency,
164                gbp_credit_transfer,
165                id,
166                livemode,
167                paper_check,
168                sepa_credit_transfer,
169                source,
170                status,
171                type_,
172            })
173        }
174    }
175
176    impl<'a> Map for Builder<'a> {
177        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
178            self.builder.key(k)
179        }
180
181        fn finish(&mut self) -> Result<()> {
182            *self.out = self.builder.take_out();
183            Ok(())
184        }
185    }
186
187    impl ObjectDeser for SourceTransaction {
188        type Builder = SourceTransactionBuilder;
189    }
190
191    impl FromValueOpt for SourceTransaction {
192        fn from_value(v: Value) -> Option<Self> {
193            let Value::Object(obj) = v else {
194                return None;
195            };
196            let mut b = SourceTransactionBuilder::deser_default();
197            for (k, v) in obj {
198                match k.as_str() {
199                    "ach_credit_transfer" => b.ach_credit_transfer = FromValueOpt::from_value(v),
200                    "amount" => b.amount = FromValueOpt::from_value(v),
201                    "chf_credit_transfer" => b.chf_credit_transfer = FromValueOpt::from_value(v),
202                    "created" => b.created = FromValueOpt::from_value(v),
203                    "currency" => b.currency = FromValueOpt::from_value(v),
204                    "gbp_credit_transfer" => b.gbp_credit_transfer = FromValueOpt::from_value(v),
205                    "id" => b.id = FromValueOpt::from_value(v),
206                    "livemode" => b.livemode = FromValueOpt::from_value(v),
207                    "paper_check" => b.paper_check = FromValueOpt::from_value(v),
208                    "sepa_credit_transfer" => b.sepa_credit_transfer = FromValueOpt::from_value(v),
209                    "source" => b.source = FromValueOpt::from_value(v),
210                    "status" => b.status = FromValueOpt::from_value(v),
211                    "type" => b.type_ = FromValueOpt::from_value(v),
212
213                    _ => {}
214                }
215            }
216            b.take_out()
217        }
218    }
219};
220#[cfg(feature = "serialize")]
221impl serde::Serialize for SourceTransaction {
222    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
223        use serde::ser::SerializeStruct;
224        let mut s = s.serialize_struct("SourceTransaction", 14)?;
225        s.serialize_field("ach_credit_transfer", &self.ach_credit_transfer)?;
226        s.serialize_field("amount", &self.amount)?;
227        s.serialize_field("chf_credit_transfer", &self.chf_credit_transfer)?;
228        s.serialize_field("created", &self.created)?;
229        s.serialize_field("currency", &self.currency)?;
230        s.serialize_field("gbp_credit_transfer", &self.gbp_credit_transfer)?;
231        s.serialize_field("id", &self.id)?;
232        s.serialize_field("livemode", &self.livemode)?;
233        s.serialize_field("paper_check", &self.paper_check)?;
234        s.serialize_field("sepa_credit_transfer", &self.sepa_credit_transfer)?;
235        s.serialize_field("source", &self.source)?;
236        s.serialize_field("status", &self.status)?;
237        s.serialize_field("type", &self.type_)?;
238
239        s.serialize_field("object", "source_transaction")?;
240        s.end()
241    }
242}
243/// The type of source this transaction is attached to.
244#[derive(Clone, Eq, PartialEq)]
245#[non_exhaustive]
246pub enum SourceTransactionType {
247    AchCreditTransfer,
248    AchDebit,
249    Alipay,
250    Bancontact,
251    Card,
252    CardPresent,
253    Eps,
254    Giropay,
255    Ideal,
256    Klarna,
257    Multibanco,
258    P24,
259    SepaDebit,
260    Sofort,
261    ThreeDSecure,
262    Wechat,
263    /// An unrecognized value from Stripe. Should not be used as a request parameter.
264    Unknown(String),
265}
266impl SourceTransactionType {
267    pub fn as_str(&self) -> &str {
268        use SourceTransactionType::*;
269        match self {
270            AchCreditTransfer => "ach_credit_transfer",
271            AchDebit => "ach_debit",
272            Alipay => "alipay",
273            Bancontact => "bancontact",
274            Card => "card",
275            CardPresent => "card_present",
276            Eps => "eps",
277            Giropay => "giropay",
278            Ideal => "ideal",
279            Klarna => "klarna",
280            Multibanco => "multibanco",
281            P24 => "p24",
282            SepaDebit => "sepa_debit",
283            Sofort => "sofort",
284            ThreeDSecure => "three_d_secure",
285            Wechat => "wechat",
286            Unknown(v) => v,
287        }
288    }
289}
290
291impl std::str::FromStr for SourceTransactionType {
292    type Err = std::convert::Infallible;
293    fn from_str(s: &str) -> Result<Self, Self::Err> {
294        use SourceTransactionType::*;
295        match s {
296            "ach_credit_transfer" => Ok(AchCreditTransfer),
297            "ach_debit" => Ok(AchDebit),
298            "alipay" => Ok(Alipay),
299            "bancontact" => Ok(Bancontact),
300            "card" => Ok(Card),
301            "card_present" => Ok(CardPresent),
302            "eps" => Ok(Eps),
303            "giropay" => Ok(Giropay),
304            "ideal" => Ok(Ideal),
305            "klarna" => Ok(Klarna),
306            "multibanco" => Ok(Multibanco),
307            "p24" => Ok(P24),
308            "sepa_debit" => Ok(SepaDebit),
309            "sofort" => Ok(Sofort),
310            "three_d_secure" => Ok(ThreeDSecure),
311            "wechat" => Ok(Wechat),
312            v => Ok(Unknown(v.to_owned())),
313        }
314    }
315}
316impl std::fmt::Display for SourceTransactionType {
317    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
318        f.write_str(self.as_str())
319    }
320}
321
322impl std::fmt::Debug for SourceTransactionType {
323    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
324        f.write_str(self.as_str())
325    }
326}
327#[cfg(feature = "serialize")]
328impl serde::Serialize for SourceTransactionType {
329    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
330    where
331        S: serde::Serializer,
332    {
333        serializer.serialize_str(self.as_str())
334    }
335}
336impl miniserde::Deserialize for SourceTransactionType {
337    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
338        crate::Place::new(out)
339    }
340}
341
342impl miniserde::de::Visitor for crate::Place<SourceTransactionType> {
343    fn string(&mut self, s: &str) -> miniserde::Result<()> {
344        use std::str::FromStr;
345        self.out = Some(SourceTransactionType::from_str(s).unwrap());
346        Ok(())
347    }
348}
349
350stripe_types::impl_from_val_with_from_str!(SourceTransactionType);
351#[cfg(feature = "deserialize")]
352impl<'de> serde::Deserialize<'de> for SourceTransactionType {
353    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
354        use std::str::FromStr;
355        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
356        Ok(Self::from_str(&s).unwrap())
357    }
358}
359impl stripe_types::Object for SourceTransaction {
360    type Id = stripe_shared::SourceTransactionId;
361    fn id(&self) -> &Self::Id {
362        &self.id
363    }
364
365    fn into_id(self) -> Self::Id {
366        self.id
367    }
368}
369stripe_types::def_id!(SourceTransactionId);
stripe_shared/source_transaction.rs

stripe_shared/
source_transaction.rs
