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::{Deserialize, Result, make_place};
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                _ => <dyn Visitor>::ignore(),
103            })
104        }
105
106        fn deser_default() -> Self {
107            Self {
108                ach_credit_transfer: Deserialize::default(),
109                amount: Deserialize::default(),
110                chf_credit_transfer: Deserialize::default(),
111                created: Deserialize::default(),
112                currency: Deserialize::default(),
113                gbp_credit_transfer: Deserialize::default(),
114                id: Deserialize::default(),
115                livemode: Deserialize::default(),
116                paper_check: Deserialize::default(),
117                sepa_credit_transfer: Deserialize::default(),
118                source: Deserialize::default(),
119                status: Deserialize::default(),
120                type_: Deserialize::default(),
121            }
122        }
123
124        fn take_out(&mut self) -> Option<Self::Out> {
125            let (
126                Some(ach_credit_transfer),
127                Some(amount),
128                Some(chf_credit_transfer),
129                Some(created),
130                Some(currency),
131                Some(gbp_credit_transfer),
132                Some(id),
133                Some(livemode),
134                Some(paper_check),
135                Some(sepa_credit_transfer),
136                Some(source),
137                Some(status),
138                Some(type_),
139            ) = (
140                self.ach_credit_transfer.take(),
141                self.amount,
142                self.chf_credit_transfer.take(),
143                self.created,
144                self.currency.take(),
145                self.gbp_credit_transfer.take(),
146                self.id.take(),
147                self.livemode,
148                self.paper_check.take(),
149                self.sepa_credit_transfer.take(),
150                self.source.take(),
151                self.status.take(),
152                self.type_.take(),
153            )
154            else {
155                return None;
156            };
157            Some(Self::Out {
158                ach_credit_transfer,
159                amount,
160                chf_credit_transfer,
161                created,
162                currency,
163                gbp_credit_transfer,
164                id,
165                livemode,
166                paper_check,
167                sepa_credit_transfer,
168                source,
169                status,
170                type_,
171            })
172        }
173    }
174
175    impl Map for Builder<'_> {
176        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
177            self.builder.key(k)
178        }
179
180        fn finish(&mut self) -> Result<()> {
181            *self.out = self.builder.take_out();
182            Ok(())
183        }
184    }
185
186    impl ObjectDeser for SourceTransaction {
187        type Builder = SourceTransactionBuilder;
188    }
189
190    impl FromValueOpt for SourceTransaction {
191        fn from_value(v: Value) -> Option<Self> {
192            let Value::Object(obj) = v else {
193                return None;
194            };
195            let mut b = SourceTransactionBuilder::deser_default();
196            for (k, v) in obj {
197                match k.as_str() {
198                    "ach_credit_transfer" => b.ach_credit_transfer = FromValueOpt::from_value(v),
199                    "amount" => b.amount = FromValueOpt::from_value(v),
200                    "chf_credit_transfer" => b.chf_credit_transfer = FromValueOpt::from_value(v),
201                    "created" => b.created = FromValueOpt::from_value(v),
202                    "currency" => b.currency = FromValueOpt::from_value(v),
203                    "gbp_credit_transfer" => b.gbp_credit_transfer = FromValueOpt::from_value(v),
204                    "id" => b.id = FromValueOpt::from_value(v),
205                    "livemode" => b.livemode = FromValueOpt::from_value(v),
206                    "paper_check" => b.paper_check = FromValueOpt::from_value(v),
207                    "sepa_credit_transfer" => b.sepa_credit_transfer = FromValueOpt::from_value(v),
208                    "source" => b.source = FromValueOpt::from_value(v),
209                    "status" => b.status = FromValueOpt::from_value(v),
210                    "type" => b.type_ = FromValueOpt::from_value(v),
211                    _ => {}
212                }
213            }
214            b.take_out()
215        }
216    }
217};
218#[cfg(feature = "serialize")]
219impl serde::Serialize for SourceTransaction {
220    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
221        use serde::ser::SerializeStruct;
222        let mut s = s.serialize_struct("SourceTransaction", 14)?;
223        s.serialize_field("ach_credit_transfer", &self.ach_credit_transfer)?;
224        s.serialize_field("amount", &self.amount)?;
225        s.serialize_field("chf_credit_transfer", &self.chf_credit_transfer)?;
226        s.serialize_field("created", &self.created)?;
227        s.serialize_field("currency", &self.currency)?;
228        s.serialize_field("gbp_credit_transfer", &self.gbp_credit_transfer)?;
229        s.serialize_field("id", &self.id)?;
230        s.serialize_field("livemode", &self.livemode)?;
231        s.serialize_field("paper_check", &self.paper_check)?;
232        s.serialize_field("sepa_credit_transfer", &self.sepa_credit_transfer)?;
233        s.serialize_field("source", &self.source)?;
234        s.serialize_field("status", &self.status)?;
235        s.serialize_field("type", &self.type_)?;
236
237        s.serialize_field("object", "source_transaction")?;
238        s.end()
239    }
240}
241/// The type of source this transaction is attached to.
242#[derive(Clone, Eq, PartialEq)]
243#[non_exhaustive]
244pub enum SourceTransactionType {
245    AchCreditTransfer,
246    AchDebit,
247    Alipay,
248    Bancontact,
249    Card,
250    CardPresent,
251    Eps,
252    Giropay,
253    Ideal,
254    Klarna,
255    Multibanco,
256    P24,
257    SepaDebit,
258    Sofort,
259    ThreeDSecure,
260    Wechat,
261    /// An unrecognized value from Stripe. Should not be used as a request parameter.
262    Unknown(String),
263}
264impl SourceTransactionType {
265    pub fn as_str(&self) -> &str {
266        use SourceTransactionType::*;
267        match self {
268            AchCreditTransfer => "ach_credit_transfer",
269            AchDebit => "ach_debit",
270            Alipay => "alipay",
271            Bancontact => "bancontact",
272            Card => "card",
273            CardPresent => "card_present",
274            Eps => "eps",
275            Giropay => "giropay",
276            Ideal => "ideal",
277            Klarna => "klarna",
278            Multibanco => "multibanco",
279            P24 => "p24",
280            SepaDebit => "sepa_debit",
281            Sofort => "sofort",
282            ThreeDSecure => "three_d_secure",
283            Wechat => "wechat",
284            Unknown(v) => v,
285        }
286    }
287}
288
289impl std::str::FromStr for SourceTransactionType {
290    type Err = std::convert::Infallible;
291    fn from_str(s: &str) -> Result<Self, Self::Err> {
292        use SourceTransactionType::*;
293        match s {
294            "ach_credit_transfer" => Ok(AchCreditTransfer),
295            "ach_debit" => Ok(AchDebit),
296            "alipay" => Ok(Alipay),
297            "bancontact" => Ok(Bancontact),
298            "card" => Ok(Card),
299            "card_present" => Ok(CardPresent),
300            "eps" => Ok(Eps),
301            "giropay" => Ok(Giropay),
302            "ideal" => Ok(Ideal),
303            "klarna" => Ok(Klarna),
304            "multibanco" => Ok(Multibanco),
305            "p24" => Ok(P24),
306            "sepa_debit" => Ok(SepaDebit),
307            "sofort" => Ok(Sofort),
308            "three_d_secure" => Ok(ThreeDSecure),
309            "wechat" => Ok(Wechat),
310            v => Ok(Unknown(v.to_owned())),
311        }
312    }
313}
314impl std::fmt::Display for SourceTransactionType {
315    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
316        f.write_str(self.as_str())
317    }
318}
319
320impl std::fmt::Debug for SourceTransactionType {
321    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
322        f.write_str(self.as_str())
323    }
324}
325#[cfg(feature = "serialize")]
326impl serde::Serialize for SourceTransactionType {
327    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
328    where
329        S: serde::Serializer,
330    {
331        serializer.serialize_str(self.as_str())
332    }
333}
334impl miniserde::Deserialize for SourceTransactionType {
335    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
336        crate::Place::new(out)
337    }
338}
339
340impl miniserde::de::Visitor for crate::Place<SourceTransactionType> {
341    fn string(&mut self, s: &str) -> miniserde::Result<()> {
342        use std::str::FromStr;
343        self.out = Some(SourceTransactionType::from_str(s).unwrap());
344        Ok(())
345    }
346}
347
348stripe_types::impl_from_val_with_from_str!(SourceTransactionType);
349#[cfg(feature = "deserialize")]
350impl<'de> serde::Deserialize<'de> for SourceTransactionType {
351    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
352        use std::str::FromStr;
353        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
354        Ok(Self::from_str(&s).unwrap())
355    }
356}
357impl stripe_types::Object for SourceTransaction {
358    type Id = stripe_shared::SourceTransactionId;
359    fn id(&self) -> &Self::Id {
360        &self.id
361    }
362
363    fn into_id(self) -> Self::Id {
364        self.id
365    }
366}
367stripe_types::def_id!(SourceTransactionId);
stripe_shared/source_transaction.rs

stripe_shared/
source_transaction.rs
