stripe_terminal/
terminal_reader_reader_resource_reader_action.rs

1/// Represents an action performed by the reader
2#[derive(Clone, Debug)]
3#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
4#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
5pub struct TerminalReaderReaderResourceReaderAction {
6    pub collect_inputs: Option<stripe_terminal::TerminalReaderReaderResourceCollectInputsAction>,
7    pub collect_payment_method:
8        Option<stripe_terminal::TerminalReaderReaderResourceCollectPaymentMethodAction>,
9    pub confirm_payment_intent:
10        Option<stripe_terminal::TerminalReaderReaderResourceConfirmPaymentIntentAction>,
11    /// Failure code, only set if status is `failed`.
12    pub failure_code: Option<String>,
13    /// Detailed failure message, only set if status is `failed`.
14    pub failure_message: Option<String>,
15    pub process_payment_intent:
16        Option<stripe_terminal::TerminalReaderReaderResourceProcessPaymentIntentAction>,
17    pub process_setup_intent:
18        Option<stripe_terminal::TerminalReaderReaderResourceProcessSetupIntentAction>,
19    pub refund_payment: Option<stripe_terminal::TerminalReaderReaderResourceRefundPaymentAction>,
20    pub set_reader_display:
21        Option<stripe_terminal::TerminalReaderReaderResourceSetReaderDisplayAction>,
22    /// Status of the action performed by the reader.
23    pub status: TerminalReaderReaderResourceReaderActionStatus,
24    /// Type of action performed by the reader.
25    #[cfg_attr(any(feature = "deserialize", feature = "serialize"), serde(rename = "type"))]
26    pub type_: TerminalReaderReaderResourceReaderActionType,
27}
28#[doc(hidden)]
29pub struct TerminalReaderReaderResourceReaderActionBuilder {
30    collect_inputs:
31        Option<Option<stripe_terminal::TerminalReaderReaderResourceCollectInputsAction>>,
32    collect_payment_method:
33        Option<Option<stripe_terminal::TerminalReaderReaderResourceCollectPaymentMethodAction>>,
34    confirm_payment_intent:
35        Option<Option<stripe_terminal::TerminalReaderReaderResourceConfirmPaymentIntentAction>>,
36    failure_code: Option<Option<String>>,
37    failure_message: Option<Option<String>>,
38    process_payment_intent:
39        Option<Option<stripe_terminal::TerminalReaderReaderResourceProcessPaymentIntentAction>>,
40    process_setup_intent:
41        Option<Option<stripe_terminal::TerminalReaderReaderResourceProcessSetupIntentAction>>,
42    refund_payment:
43        Option<Option<stripe_terminal::TerminalReaderReaderResourceRefundPaymentAction>>,
44    set_reader_display:
45        Option<Option<stripe_terminal::TerminalReaderReaderResourceSetReaderDisplayAction>>,
46    status: Option<TerminalReaderReaderResourceReaderActionStatus>,
47    type_: Option<TerminalReaderReaderResourceReaderActionType>,
48}
49
50#[allow(
51    unused_variables,
52    irrefutable_let_patterns,
53    clippy::let_unit_value,
54    clippy::match_single_binding,
55    clippy::single_match
56)]
57const _: () = {
58    use miniserde::de::{Map, Visitor};
59    use miniserde::json::Value;
60    use miniserde::{Deserialize, Result, make_place};
61    use stripe_types::miniserde_helpers::FromValueOpt;
62    use stripe_types::{MapBuilder, ObjectDeser};
63
64    make_place!(Place);
65
66    impl Deserialize for TerminalReaderReaderResourceReaderAction {
67        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
68            Place::new(out)
69        }
70    }
71
72    struct Builder<'a> {
73        out: &'a mut Option<TerminalReaderReaderResourceReaderAction>,
74        builder: TerminalReaderReaderResourceReaderActionBuilder,
75    }
76
77    impl Visitor for Place<TerminalReaderReaderResourceReaderAction> {
78        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
79            Ok(Box::new(Builder {
80                out: &mut self.out,
81                builder: TerminalReaderReaderResourceReaderActionBuilder::deser_default(),
82            }))
83        }
84    }
85
86    impl MapBuilder for TerminalReaderReaderResourceReaderActionBuilder {
87        type Out = TerminalReaderReaderResourceReaderAction;
88        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
89            Ok(match k {
90                "collect_inputs" => Deserialize::begin(&mut self.collect_inputs),
91                "collect_payment_method" => Deserialize::begin(&mut self.collect_payment_method),
92                "confirm_payment_intent" => Deserialize::begin(&mut self.confirm_payment_intent),
93                "failure_code" => Deserialize::begin(&mut self.failure_code),
94                "failure_message" => Deserialize::begin(&mut self.failure_message),
95                "process_payment_intent" => Deserialize::begin(&mut self.process_payment_intent),
96                "process_setup_intent" => Deserialize::begin(&mut self.process_setup_intent),
97                "refund_payment" => Deserialize::begin(&mut self.refund_payment),
98                "set_reader_display" => Deserialize::begin(&mut self.set_reader_display),
99                "status" => Deserialize::begin(&mut self.status),
100                "type" => Deserialize::begin(&mut self.type_),
101
102                _ => <dyn Visitor>::ignore(),
103            })
104        }
105
106        fn deser_default() -> Self {
107            Self {
108                collect_inputs: Deserialize::default(),
109                collect_payment_method: Deserialize::default(),
110                confirm_payment_intent: Deserialize::default(),
111                failure_code: Deserialize::default(),
112                failure_message: Deserialize::default(),
113                process_payment_intent: Deserialize::default(),
114                process_setup_intent: Deserialize::default(),
115                refund_payment: Deserialize::default(),
116                set_reader_display: Deserialize::default(),
117                status: Deserialize::default(),
118                type_: Deserialize::default(),
119            }
120        }
121
122        fn take_out(&mut self) -> Option<Self::Out> {
123            let (
124                Some(collect_inputs),
125                Some(collect_payment_method),
126                Some(confirm_payment_intent),
127                Some(failure_code),
128                Some(failure_message),
129                Some(process_payment_intent),
130                Some(process_setup_intent),
131                Some(refund_payment),
132                Some(set_reader_display),
133                Some(status),
134                Some(type_),
135            ) = (
136                self.collect_inputs.take(),
137                self.collect_payment_method.take(),
138                self.confirm_payment_intent.take(),
139                self.failure_code.take(),
140                self.failure_message.take(),
141                self.process_payment_intent.take(),
142                self.process_setup_intent.take(),
143                self.refund_payment.take(),
144                self.set_reader_display.take(),
145                self.status,
146                self.type_,
147            )
148            else {
149                return None;
150            };
151            Some(Self::Out {
152                collect_inputs,
153                collect_payment_method,
154                confirm_payment_intent,
155                failure_code,
156                failure_message,
157                process_payment_intent,
158                process_setup_intent,
159                refund_payment,
160                set_reader_display,
161                status,
162                type_,
163            })
164        }
165    }
166
167    impl Map for Builder<'_> {
168        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
169            self.builder.key(k)
170        }
171
172        fn finish(&mut self) -> Result<()> {
173            *self.out = self.builder.take_out();
174            Ok(())
175        }
176    }
177
178    impl ObjectDeser for TerminalReaderReaderResourceReaderAction {
179        type Builder = TerminalReaderReaderResourceReaderActionBuilder;
180    }
181
182    impl FromValueOpt for TerminalReaderReaderResourceReaderAction {
183        fn from_value(v: Value) -> Option<Self> {
184            let Value::Object(obj) = v else {
185                return None;
186            };
187            let mut b = TerminalReaderReaderResourceReaderActionBuilder::deser_default();
188            for (k, v) in obj {
189                match k.as_str() {
190                    "collect_inputs" => b.collect_inputs = FromValueOpt::from_value(v),
191                    "collect_payment_method" => {
192                        b.collect_payment_method = FromValueOpt::from_value(v)
193                    }
194                    "confirm_payment_intent" => {
195                        b.confirm_payment_intent = FromValueOpt::from_value(v)
196                    }
197                    "failure_code" => b.failure_code = FromValueOpt::from_value(v),
198                    "failure_message" => b.failure_message = FromValueOpt::from_value(v),
199                    "process_payment_intent" => {
200                        b.process_payment_intent = FromValueOpt::from_value(v)
201                    }
202                    "process_setup_intent" => b.process_setup_intent = FromValueOpt::from_value(v),
203                    "refund_payment" => b.refund_payment = FromValueOpt::from_value(v),
204                    "set_reader_display" => b.set_reader_display = FromValueOpt::from_value(v),
205                    "status" => b.status = FromValueOpt::from_value(v),
206                    "type" => b.type_ = FromValueOpt::from_value(v),
207
208                    _ => {}
209                }
210            }
211            b.take_out()
212        }
213    }
214};
215/// Status of the action performed by the reader.
216#[derive(Copy, Clone, Eq, PartialEq)]
217pub enum TerminalReaderReaderResourceReaderActionStatus {
218    Failed,
219    InProgress,
220    Succeeded,
221}
222impl TerminalReaderReaderResourceReaderActionStatus {
223    pub fn as_str(self) -> &'static str {
224        use TerminalReaderReaderResourceReaderActionStatus::*;
225        match self {
226            Failed => "failed",
227            InProgress => "in_progress",
228            Succeeded => "succeeded",
229        }
230    }
231}
232
233impl std::str::FromStr for TerminalReaderReaderResourceReaderActionStatus {
234    type Err = stripe_types::StripeParseError;
235    fn from_str(s: &str) -> Result<Self, Self::Err> {
236        use TerminalReaderReaderResourceReaderActionStatus::*;
237        match s {
238            "failed" => Ok(Failed),
239            "in_progress" => Ok(InProgress),
240            "succeeded" => Ok(Succeeded),
241            _ => Err(stripe_types::StripeParseError),
242        }
243    }
244}
245impl std::fmt::Display for TerminalReaderReaderResourceReaderActionStatus {
246    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
247        f.write_str(self.as_str())
248    }
249}
250
251impl std::fmt::Debug for TerminalReaderReaderResourceReaderActionStatus {
252    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
253        f.write_str(self.as_str())
254    }
255}
256#[cfg(feature = "serialize")]
257impl serde::Serialize for TerminalReaderReaderResourceReaderActionStatus {
258    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
259    where
260        S: serde::Serializer,
261    {
262        serializer.serialize_str(self.as_str())
263    }
264}
265impl miniserde::Deserialize for TerminalReaderReaderResourceReaderActionStatus {
266    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
267        crate::Place::new(out)
268    }
269}
270
271impl miniserde::de::Visitor for crate::Place<TerminalReaderReaderResourceReaderActionStatus> {
272    fn string(&mut self, s: &str) -> miniserde::Result<()> {
273        use std::str::FromStr;
274        self.out = Some(
275            TerminalReaderReaderResourceReaderActionStatus::from_str(s)
276                .map_err(|_| miniserde::Error)?,
277        );
278        Ok(())
279    }
280}
281
282stripe_types::impl_from_val_with_from_str!(TerminalReaderReaderResourceReaderActionStatus);
283#[cfg(feature = "deserialize")]
284impl<'de> serde::Deserialize<'de> for TerminalReaderReaderResourceReaderActionStatus {
285    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
286        use std::str::FromStr;
287        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
288        Self::from_str(&s).map_err(|_| {
289            serde::de::Error::custom(
290                "Unknown value for TerminalReaderReaderResourceReaderActionStatus",
291            )
292        })
293    }
294}
295/// Type of action performed by the reader.
296#[derive(Copy, Clone, Eq, PartialEq)]
297pub enum TerminalReaderReaderResourceReaderActionType {
298    CollectInputs,
299    CollectPaymentMethod,
300    ConfirmPaymentIntent,
301    ProcessPaymentIntent,
302    ProcessSetupIntent,
303    RefundPayment,
304    SetReaderDisplay,
305}
306impl TerminalReaderReaderResourceReaderActionType {
307    pub fn as_str(self) -> &'static str {
308        use TerminalReaderReaderResourceReaderActionType::*;
309        match self {
310            CollectInputs => "collect_inputs",
311            CollectPaymentMethod => "collect_payment_method",
312            ConfirmPaymentIntent => "confirm_payment_intent",
313            ProcessPaymentIntent => "process_payment_intent",
314            ProcessSetupIntent => "process_setup_intent",
315            RefundPayment => "refund_payment",
316            SetReaderDisplay => "set_reader_display",
317        }
318    }
319}
320
321impl std::str::FromStr for TerminalReaderReaderResourceReaderActionType {
322    type Err = stripe_types::StripeParseError;
323    fn from_str(s: &str) -> Result<Self, Self::Err> {
324        use TerminalReaderReaderResourceReaderActionType::*;
325        match s {
326            "collect_inputs" => Ok(CollectInputs),
327            "collect_payment_method" => Ok(CollectPaymentMethod),
328            "confirm_payment_intent" => Ok(ConfirmPaymentIntent),
329            "process_payment_intent" => Ok(ProcessPaymentIntent),
330            "process_setup_intent" => Ok(ProcessSetupIntent),
331            "refund_payment" => Ok(RefundPayment),
332            "set_reader_display" => Ok(SetReaderDisplay),
333            _ => Err(stripe_types::StripeParseError),
334        }
335    }
336}
337impl std::fmt::Display for TerminalReaderReaderResourceReaderActionType {
338    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
339        f.write_str(self.as_str())
340    }
341}
342
343impl std::fmt::Debug for TerminalReaderReaderResourceReaderActionType {
344    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
345        f.write_str(self.as_str())
346    }
347}
348#[cfg(feature = "serialize")]
349impl serde::Serialize for TerminalReaderReaderResourceReaderActionType {
350    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
351    where
352        S: serde::Serializer,
353    {
354        serializer.serialize_str(self.as_str())
355    }
356}
357impl miniserde::Deserialize for TerminalReaderReaderResourceReaderActionType {
358    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
359        crate::Place::new(out)
360    }
361}
362
363impl miniserde::de::Visitor for crate::Place<TerminalReaderReaderResourceReaderActionType> {
364    fn string(&mut self, s: &str) -> miniserde::Result<()> {
365        use std::str::FromStr;
366        self.out = Some(
367            TerminalReaderReaderResourceReaderActionType::from_str(s)
368                .map_err(|_| miniserde::Error)?,
369        );
370        Ok(())
371    }
372}
373
374stripe_types::impl_from_val_with_from_str!(TerminalReaderReaderResourceReaderActionType);
375#[cfg(feature = "deserialize")]
376impl<'de> serde::Deserialize<'de> for TerminalReaderReaderResourceReaderActionType {
377    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
378        use std::str::FromStr;
379        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
380        Self::from_str(&s).map_err(|_| {
381            serde::de::Error::custom(
382                "Unknown value for TerminalReaderReaderResourceReaderActionType",
383            )
384        })
385    }
386}
stripe_terminal/terminal_reader_reader_resource_reader_action.rs

stripe_terminal/
terminal_reader_reader_resource_reader_action.rs
