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

stripe_shared/
source_transaction.rs
