stripe_terminal/terminal_reader/
types.rs

1/// A Reader represents a physical device for accepting payment details.
2///
3/// Related guide: [Connecting to a reader](https://stripe.com/docs/terminal/payments/connect-reader)
4///
5/// For more details see <<https://stripe.com/docs/api/terminal/readers/object>>.
6#[derive(Clone, Debug)]
7#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
8pub struct TerminalReader {
9    /// The most recent action performed by the reader.
10    pub action: Option<stripe_terminal::TerminalReaderReaderResourceReaderAction>,
11    /// The current software version of the reader.
12    pub device_sw_version: Option<String>,
13    /// Device type of the reader.
14    pub device_type: stripe_terminal::TerminalReaderDeviceType,
15    /// Unique identifier for the object.
16    pub id: stripe_terminal::TerminalReaderId,
17    /// The local IP address of the reader.
18    pub ip_address: Option<String>,
19    /// Custom label given to the reader for easier identification.
20    pub label: String,
21    /// Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
22    pub livemode: bool,
23    /// The location identifier of the reader.
24    pub location: Option<stripe_types::Expandable<stripe_terminal::TerminalLocation>>,
25    /// Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object.
26    /// This can be useful for storing additional information about the object in a structured format.
27    pub metadata: std::collections::HashMap<String, String>,
28    /// Serial number of the reader.
29    pub serial_number: String,
30    /// The networking status of the reader.
31    /// We do not recommend using this field in flows that may block taking payments.
32    pub status: Option<stripe_terminal::TerminalReaderStatus>,
33}
34#[doc(hidden)]
35pub struct TerminalReaderBuilder {
36    action: Option<Option<stripe_terminal::TerminalReaderReaderResourceReaderAction>>,
37    device_sw_version: Option<Option<String>>,
38    device_type: Option<stripe_terminal::TerminalReaderDeviceType>,
39    id: Option<stripe_terminal::TerminalReaderId>,
40    ip_address: Option<Option<String>>,
41    label: Option<String>,
42    livemode: Option<bool>,
43    location: Option<Option<stripe_types::Expandable<stripe_terminal::TerminalLocation>>>,
44    metadata: Option<std::collections::HashMap<String, String>>,
45    serial_number: Option<String>,
46    status: Option<Option<stripe_terminal::TerminalReaderStatus>>,
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 TerminalReader {
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<TerminalReader>,
73        builder: TerminalReaderBuilder,
74    }
75
76    impl Visitor for Place<TerminalReader> {
77        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
78            Ok(Box::new(Builder {
79                out: &mut self.out,
80                builder: TerminalReaderBuilder::deser_default(),
81            }))
82        }
83    }
84
85    impl MapBuilder for TerminalReaderBuilder {
86        type Out = TerminalReader;
87        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
88            Ok(match k {
89                "action" => Deserialize::begin(&mut self.action),
90                "device_sw_version" => Deserialize::begin(&mut self.device_sw_version),
91                "device_type" => Deserialize::begin(&mut self.device_type),
92                "id" => Deserialize::begin(&mut self.id),
93                "ip_address" => Deserialize::begin(&mut self.ip_address),
94                "label" => Deserialize::begin(&mut self.label),
95                "livemode" => Deserialize::begin(&mut self.livemode),
96                "location" => Deserialize::begin(&mut self.location),
97                "metadata" => Deserialize::begin(&mut self.metadata),
98                "serial_number" => Deserialize::begin(&mut self.serial_number),
99                "status" => Deserialize::begin(&mut self.status),
100
101                _ => <dyn Visitor>::ignore(),
102            })
103        }
104
105        fn deser_default() -> Self {
106            Self {
107                action: Deserialize::default(),
108                device_sw_version: Deserialize::default(),
109                device_type: Deserialize::default(),
110                id: Deserialize::default(),
111                ip_address: Deserialize::default(),
112                label: Deserialize::default(),
113                livemode: Deserialize::default(),
114                location: Deserialize::default(),
115                metadata: Deserialize::default(),
116                serial_number: Deserialize::default(),
117                status: Deserialize::default(),
118            }
119        }
120
121        fn take_out(&mut self) -> Option<Self::Out> {
122            let (
123                Some(action),
124                Some(device_sw_version),
125                Some(device_type),
126                Some(id),
127                Some(ip_address),
128                Some(label),
129                Some(livemode),
130                Some(location),
131                Some(metadata),
132                Some(serial_number),
133                Some(status),
134            ) = (
135                self.action.take(),
136                self.device_sw_version.take(),
137                self.device_type,
138                self.id.take(),
139                self.ip_address.take(),
140                self.label.take(),
141                self.livemode,
142                self.location.take(),
143                self.metadata.take(),
144                self.serial_number.take(),
145                self.status,
146            )
147            else {
148                return None;
149            };
150            Some(Self::Out {
151                action,
152                device_sw_version,
153                device_type,
154                id,
155                ip_address,
156                label,
157                livemode,
158                location,
159                metadata,
160                serial_number,
161                status,
162            })
163        }
164    }
165
166    impl Map for Builder<'_> {
167        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
168            self.builder.key(k)
169        }
170
171        fn finish(&mut self) -> Result<()> {
172            *self.out = self.builder.take_out();
173            Ok(())
174        }
175    }
176
177    impl ObjectDeser for TerminalReader {
178        type Builder = TerminalReaderBuilder;
179    }
180
181    impl FromValueOpt for TerminalReader {
182        fn from_value(v: Value) -> Option<Self> {
183            let Value::Object(obj) = v else {
184                return None;
185            };
186            let mut b = TerminalReaderBuilder::deser_default();
187            for (k, v) in obj {
188                match k.as_str() {
189                    "action" => b.action = FromValueOpt::from_value(v),
190                    "device_sw_version" => b.device_sw_version = FromValueOpt::from_value(v),
191                    "device_type" => b.device_type = FromValueOpt::from_value(v),
192                    "id" => b.id = FromValueOpt::from_value(v),
193                    "ip_address" => b.ip_address = FromValueOpt::from_value(v),
194                    "label" => b.label = FromValueOpt::from_value(v),
195                    "livemode" => b.livemode = FromValueOpt::from_value(v),
196                    "location" => b.location = FromValueOpt::from_value(v),
197                    "metadata" => b.metadata = FromValueOpt::from_value(v),
198                    "serial_number" => b.serial_number = FromValueOpt::from_value(v),
199                    "status" => b.status = FromValueOpt::from_value(v),
200
201                    _ => {}
202                }
203            }
204            b.take_out()
205        }
206    }
207};
208#[cfg(feature = "serialize")]
209impl serde::Serialize for TerminalReader {
210    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
211        use serde::ser::SerializeStruct;
212        let mut s = s.serialize_struct("TerminalReader", 12)?;
213        s.serialize_field("action", &self.action)?;
214        s.serialize_field("device_sw_version", &self.device_sw_version)?;
215        s.serialize_field("device_type", &self.device_type)?;
216        s.serialize_field("id", &self.id)?;
217        s.serialize_field("ip_address", &self.ip_address)?;
218        s.serialize_field("label", &self.label)?;
219        s.serialize_field("livemode", &self.livemode)?;
220        s.serialize_field("location", &self.location)?;
221        s.serialize_field("metadata", &self.metadata)?;
222        s.serialize_field("serial_number", &self.serial_number)?;
223        s.serialize_field("status", &self.status)?;
224
225        s.serialize_field("object", "terminal.reader")?;
226        s.end()
227    }
228}
229impl stripe_types::Object for TerminalReader {
230    type Id = stripe_terminal::TerminalReaderId;
231    fn id(&self) -> &Self::Id {
232        &self.id
233    }
234
235    fn into_id(self) -> Self::Id {
236        self.id
237    }
238}
239stripe_types::def_id!(TerminalReaderId);
240#[derive(Copy, Clone, Eq, PartialEq)]
241pub enum TerminalReaderDeviceType {
242    BbposChipper2x,
243    BbposWisepad3,
244    BbposWiseposE,
245    MobilePhoneReader,
246    SimulatedStripeS700,
247    SimulatedWiseposE,
248    StripeM2,
249    StripeS700,
250    VerifoneP400,
251}
252impl TerminalReaderDeviceType {
253    pub fn as_str(self) -> &'static str {
254        use TerminalReaderDeviceType::*;
255        match self {
256            BbposChipper2x => "bbpos_chipper2x",
257            BbposWisepad3 => "bbpos_wisepad3",
258            BbposWiseposE => "bbpos_wisepos_e",
259            MobilePhoneReader => "mobile_phone_reader",
260            SimulatedStripeS700 => "simulated_stripe_s700",
261            SimulatedWiseposE => "simulated_wisepos_e",
262            StripeM2 => "stripe_m2",
263            StripeS700 => "stripe_s700",
264            VerifoneP400 => "verifone_P400",
265        }
266    }
267}
268
269impl std::str::FromStr for TerminalReaderDeviceType {
270    type Err = stripe_types::StripeParseError;
271    fn from_str(s: &str) -> Result<Self, Self::Err> {
272        use TerminalReaderDeviceType::*;
273        match s {
274            "bbpos_chipper2x" => Ok(BbposChipper2x),
275            "bbpos_wisepad3" => Ok(BbposWisepad3),
276            "bbpos_wisepos_e" => Ok(BbposWiseposE),
277            "mobile_phone_reader" => Ok(MobilePhoneReader),
278            "simulated_stripe_s700" => Ok(SimulatedStripeS700),
279            "simulated_wisepos_e" => Ok(SimulatedWiseposE),
280            "stripe_m2" => Ok(StripeM2),
281            "stripe_s700" => Ok(StripeS700),
282            "verifone_P400" => Ok(VerifoneP400),
283            _ => Err(stripe_types::StripeParseError),
284        }
285    }
286}
287impl std::fmt::Display for TerminalReaderDeviceType {
288    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
289        f.write_str(self.as_str())
290    }
291}
292
293impl std::fmt::Debug for TerminalReaderDeviceType {
294    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
295        f.write_str(self.as_str())
296    }
297}
298impl serde::Serialize for TerminalReaderDeviceType {
299    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
300    where
301        S: serde::Serializer,
302    {
303        serializer.serialize_str(self.as_str())
304    }
305}
306impl miniserde::Deserialize for TerminalReaderDeviceType {
307    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
308        crate::Place::new(out)
309    }
310}
311
312impl miniserde::de::Visitor for crate::Place<TerminalReaderDeviceType> {
313    fn string(&mut self, s: &str) -> miniserde::Result<()> {
314        use std::str::FromStr;
315        self.out = Some(TerminalReaderDeviceType::from_str(s).map_err(|_| miniserde::Error)?);
316        Ok(())
317    }
318}
319
320stripe_types::impl_from_val_with_from_str!(TerminalReaderDeviceType);
321#[cfg(feature = "deserialize")]
322impl<'de> serde::Deserialize<'de> for TerminalReaderDeviceType {
323    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
324        use std::str::FromStr;
325        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
326        Self::from_str(&s)
327            .map_err(|_| serde::de::Error::custom("Unknown value for TerminalReaderDeviceType"))
328    }
329}
330#[derive(Copy, Clone, Eq, PartialEq)]
331pub enum TerminalReaderStatus {
332    Offline,
333    Online,
334}
335impl TerminalReaderStatus {
336    pub fn as_str(self) -> &'static str {
337        use TerminalReaderStatus::*;
338        match self {
339            Offline => "offline",
340            Online => "online",
341        }
342    }
343}
344
345impl std::str::FromStr for TerminalReaderStatus {
346    type Err = stripe_types::StripeParseError;
347    fn from_str(s: &str) -> Result<Self, Self::Err> {
348        use TerminalReaderStatus::*;
349        match s {
350            "offline" => Ok(Offline),
351            "online" => Ok(Online),
352            _ => Err(stripe_types::StripeParseError),
353        }
354    }
355}
356impl std::fmt::Display for TerminalReaderStatus {
357    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
358        f.write_str(self.as_str())
359    }
360}
361
362impl std::fmt::Debug for TerminalReaderStatus {
363    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
364        f.write_str(self.as_str())
365    }
366}
367impl serde::Serialize for TerminalReaderStatus {
368    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
369    where
370        S: serde::Serializer,
371    {
372        serializer.serialize_str(self.as_str())
373    }
374}
375impl miniserde::Deserialize for TerminalReaderStatus {
376    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
377        crate::Place::new(out)
378    }
379}
380
381impl miniserde::de::Visitor for crate::Place<TerminalReaderStatus> {
382    fn string(&mut self, s: &str) -> miniserde::Result<()> {
383        use std::str::FromStr;
384        self.out = Some(TerminalReaderStatus::from_str(s).map_err(|_| miniserde::Error)?);
385        Ok(())
386    }
387}
388
389stripe_types::impl_from_val_with_from_str!(TerminalReaderStatus);
390#[cfg(feature = "deserialize")]
391impl<'de> serde::Deserialize<'de> for TerminalReaderStatus {
392    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
393        use std::str::FromStr;
394        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
395        Self::from_str(&s)
396            .map_err(|_| serde::de::Error::custom("Unknown value for TerminalReaderStatus"))
397    }
398}
stripe_terminal/terminal_reader/types.rs

stripe_terminal/terminal_reader/
types.rs
