stripe_shared/
review.rs

1/// Reviews can be used to supplement automated fraud detection with human expertise.
2///
3/// Learn more about [Radar](/radar) and reviewing payments
4/// [here](https://stripe.com/docs/radar/reviews).
5///
6/// For more details see <<https://stripe.com/docs/api/radar/reviews/object>>.
7#[derive(Clone, Debug)]
8#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
9pub struct Review {
10    /// The ZIP or postal code of the card used, if applicable.
11    pub billing_zip: Option<String>,
12    /// The charge associated with this review.
13    pub charge: Option<stripe_types::Expandable<stripe_shared::Charge>>,
14    /// The reason the review was closed, or null if it has not yet been closed.
15    /// One of `approved`, `refunded`, `refunded_as_fraud`, `disputed`, `redacted`, `canceled`, `payment_never_settled`, or `acknowledged`.
16    pub closed_reason: Option<ReviewClosedReason>,
17    /// Time at which the object was created. Measured in seconds since the Unix epoch.
18    pub created: stripe_types::Timestamp,
19    /// Unique identifier for the object.
20    pub id: stripe_shared::ReviewId,
21    /// The IP address where the payment originated.
22    pub ip_address: Option<String>,
23    /// Information related to the location of the payment.
24    /// Note that this information is an approximation and attempts to locate the nearest population center - it should not be used to determine a specific address.
25    pub ip_address_location: Option<stripe_shared::RadarReviewResourceLocation>,
26    /// Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
27    pub livemode: bool,
28    /// If `true`, the review needs action.
29    pub open: bool,
30    /// The reason the review was opened. One of `rule` or `manual`.
31    pub opened_reason: ReviewOpenedReason,
32    /// The PaymentIntent ID associated with this review, if one exists.
33    pub payment_intent: Option<stripe_types::Expandable<stripe_shared::PaymentIntent>>,
34    /// The reason the review is currently open or closed.
35    /// One of `rule`, `manual`, `approved`, `refunded`, `refunded_as_fraud`, `disputed`, `redacted`, `canceled`, `payment_never_settled`, or `acknowledged`.
36    pub reason: String,
37    /// Information related to the browsing session of the user who initiated the payment.
38    pub session: Option<stripe_shared::RadarReviewResourceSession>,
39}
40#[doc(hidden)]
41pub struct ReviewBuilder {
42    billing_zip: Option<Option<String>>,
43    charge: Option<Option<stripe_types::Expandable<stripe_shared::Charge>>>,
44    closed_reason: Option<Option<ReviewClosedReason>>,
45    created: Option<stripe_types::Timestamp>,
46    id: Option<stripe_shared::ReviewId>,
47    ip_address: Option<Option<String>>,
48    ip_address_location: Option<Option<stripe_shared::RadarReviewResourceLocation>>,
49    livemode: Option<bool>,
50    open: Option<bool>,
51    opened_reason: Option<ReviewOpenedReason>,
52    payment_intent: Option<Option<stripe_types::Expandable<stripe_shared::PaymentIntent>>>,
53    reason: Option<String>,
54    session: Option<Option<stripe_shared::RadarReviewResourceSession>>,
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::{make_place, Deserialize, Result};
68    use stripe_types::miniserde_helpers::FromValueOpt;
69    use stripe_types::{MapBuilder, ObjectDeser};
70
71    make_place!(Place);
72
73    impl Deserialize for Review {
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<Review>,
81        builder: ReviewBuilder,
82    }
83
84    impl Visitor for Place<Review> {
85        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
86            Ok(Box::new(Builder { out: &mut self.out, builder: ReviewBuilder::deser_default() }))
87        }
88    }
89
90    impl MapBuilder for ReviewBuilder {
91        type Out = Review;
92        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
93            Ok(match k {
94                "billing_zip" => Deserialize::begin(&mut self.billing_zip),
95                "charge" => Deserialize::begin(&mut self.charge),
96                "closed_reason" => Deserialize::begin(&mut self.closed_reason),
97                "created" => Deserialize::begin(&mut self.created),
98                "id" => Deserialize::begin(&mut self.id),
99                "ip_address" => Deserialize::begin(&mut self.ip_address),
100                "ip_address_location" => Deserialize::begin(&mut self.ip_address_location),
101                "livemode" => Deserialize::begin(&mut self.livemode),
102                "open" => Deserialize::begin(&mut self.open),
103                "opened_reason" => Deserialize::begin(&mut self.opened_reason),
104                "payment_intent" => Deserialize::begin(&mut self.payment_intent),
105                "reason" => Deserialize::begin(&mut self.reason),
106                "session" => Deserialize::begin(&mut self.session),
107
108                _ => <dyn Visitor>::ignore(),
109            })
110        }
111
112        fn deser_default() -> Self {
113            Self {
114                billing_zip: Deserialize::default(),
115                charge: Deserialize::default(),
116                closed_reason: Deserialize::default(),
117                created: Deserialize::default(),
118                id: Deserialize::default(),
119                ip_address: Deserialize::default(),
120                ip_address_location: Deserialize::default(),
121                livemode: Deserialize::default(),
122                open: Deserialize::default(),
123                opened_reason: Deserialize::default(),
124                payment_intent: Deserialize::default(),
125                reason: Deserialize::default(),
126                session: Deserialize::default(),
127            }
128        }
129
130        fn take_out(&mut self) -> Option<Self::Out> {
131            let (
132                Some(billing_zip),
133                Some(charge),
134                Some(closed_reason),
135                Some(created),
136                Some(id),
137                Some(ip_address),
138                Some(ip_address_location),
139                Some(livemode),
140                Some(open),
141                Some(opened_reason),
142                Some(payment_intent),
143                Some(reason),
144                Some(session),
145            ) = (
146                self.billing_zip.take(),
147                self.charge.take(),
148                self.closed_reason,
149                self.created,
150                self.id.take(),
151                self.ip_address.take(),
152                self.ip_address_location.take(),
153                self.livemode,
154                self.open,
155                self.opened_reason,
156                self.payment_intent.take(),
157                self.reason.take(),
158                self.session.take(),
159            )
160            else {
161                return None;
162            };
163            Some(Self::Out {
164                billing_zip,
165                charge,
166                closed_reason,
167                created,
168                id,
169                ip_address,
170                ip_address_location,
171                livemode,
172                open,
173                opened_reason,
174                payment_intent,
175                reason,
176                session,
177            })
178        }
179    }
180
181    impl Map for Builder<'_> {
182        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
183            self.builder.key(k)
184        }
185
186        fn finish(&mut self) -> Result<()> {
187            *self.out = self.builder.take_out();
188            Ok(())
189        }
190    }
191
192    impl ObjectDeser for Review {
193        type Builder = ReviewBuilder;
194    }
195
196    impl FromValueOpt for Review {
197        fn from_value(v: Value) -> Option<Self> {
198            let Value::Object(obj) = v else {
199                return None;
200            };
201            let mut b = ReviewBuilder::deser_default();
202            for (k, v) in obj {
203                match k.as_str() {
204                    "billing_zip" => b.billing_zip = FromValueOpt::from_value(v),
205                    "charge" => b.charge = FromValueOpt::from_value(v),
206                    "closed_reason" => b.closed_reason = FromValueOpt::from_value(v),
207                    "created" => b.created = FromValueOpt::from_value(v),
208                    "id" => b.id = FromValueOpt::from_value(v),
209                    "ip_address" => b.ip_address = FromValueOpt::from_value(v),
210                    "ip_address_location" => b.ip_address_location = FromValueOpt::from_value(v),
211                    "livemode" => b.livemode = FromValueOpt::from_value(v),
212                    "open" => b.open = FromValueOpt::from_value(v),
213                    "opened_reason" => b.opened_reason = FromValueOpt::from_value(v),
214                    "payment_intent" => b.payment_intent = FromValueOpt::from_value(v),
215                    "reason" => b.reason = FromValueOpt::from_value(v),
216                    "session" => b.session = FromValueOpt::from_value(v),
217
218                    _ => {}
219                }
220            }
221            b.take_out()
222        }
223    }
224};
225#[cfg(feature = "serialize")]
226impl serde::Serialize for Review {
227    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
228        use serde::ser::SerializeStruct;
229        let mut s = s.serialize_struct("Review", 14)?;
230        s.serialize_field("billing_zip", &self.billing_zip)?;
231        s.serialize_field("charge", &self.charge)?;
232        s.serialize_field("closed_reason", &self.closed_reason)?;
233        s.serialize_field("created", &self.created)?;
234        s.serialize_field("id", &self.id)?;
235        s.serialize_field("ip_address", &self.ip_address)?;
236        s.serialize_field("ip_address_location", &self.ip_address_location)?;
237        s.serialize_field("livemode", &self.livemode)?;
238        s.serialize_field("open", &self.open)?;
239        s.serialize_field("opened_reason", &self.opened_reason)?;
240        s.serialize_field("payment_intent", &self.payment_intent)?;
241        s.serialize_field("reason", &self.reason)?;
242        s.serialize_field("session", &self.session)?;
243
244        s.serialize_field("object", "review")?;
245        s.end()
246    }
247}
248/// The reason the review was closed, or null if it has not yet been closed.
249/// One of `approved`, `refunded`, `refunded_as_fraud`, `disputed`, `redacted`, `canceled`, `payment_never_settled`, or `acknowledged`.
250#[derive(Copy, Clone, Eq, PartialEq)]
251pub enum ReviewClosedReason {
252    Approved,
253    Canceled,
254    Disputed,
255    Redacted,
256    Refunded,
257    RefundedAsFraud,
258}
259impl ReviewClosedReason {
260    pub fn as_str(self) -> &'static str {
261        use ReviewClosedReason::*;
262        match self {
263            Approved => "approved",
264            Canceled => "canceled",
265            Disputed => "disputed",
266            Redacted => "redacted",
267            Refunded => "refunded",
268            RefundedAsFraud => "refunded_as_fraud",
269        }
270    }
271}
272
273impl std::str::FromStr for ReviewClosedReason {
274    type Err = stripe_types::StripeParseError;
275    fn from_str(s: &str) -> Result<Self, Self::Err> {
276        use ReviewClosedReason::*;
277        match s {
278            "approved" => Ok(Approved),
279            "canceled" => Ok(Canceled),
280            "disputed" => Ok(Disputed),
281            "redacted" => Ok(Redacted),
282            "refunded" => Ok(Refunded),
283            "refunded_as_fraud" => Ok(RefundedAsFraud),
284            _ => Err(stripe_types::StripeParseError),
285        }
286    }
287}
288impl std::fmt::Display for ReviewClosedReason {
289    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
290        f.write_str(self.as_str())
291    }
292}
293
294impl std::fmt::Debug for ReviewClosedReason {
295    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
296        f.write_str(self.as_str())
297    }
298}
299#[cfg(feature = "serialize")]
300impl serde::Serialize for ReviewClosedReason {
301    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
302    where
303        S: serde::Serializer,
304    {
305        serializer.serialize_str(self.as_str())
306    }
307}
308impl miniserde::Deserialize for ReviewClosedReason {
309    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
310        crate::Place::new(out)
311    }
312}
313
314impl miniserde::de::Visitor for crate::Place<ReviewClosedReason> {
315    fn string(&mut self, s: &str) -> miniserde::Result<()> {
316        use std::str::FromStr;
317        self.out = Some(ReviewClosedReason::from_str(s).map_err(|_| miniserde::Error)?);
318        Ok(())
319    }
320}
321
322stripe_types::impl_from_val_with_from_str!(ReviewClosedReason);
323#[cfg(feature = "deserialize")]
324impl<'de> serde::Deserialize<'de> for ReviewClosedReason {
325    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
326        use std::str::FromStr;
327        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
328        Self::from_str(&s)
329            .map_err(|_| serde::de::Error::custom("Unknown value for ReviewClosedReason"))
330    }
331}
332/// The reason the review was opened. One of `rule` or `manual`.
333#[derive(Copy, Clone, Eq, PartialEq)]
334pub enum ReviewOpenedReason {
335    Manual,
336    Rule,
337}
338impl ReviewOpenedReason {
339    pub fn as_str(self) -> &'static str {
340        use ReviewOpenedReason::*;
341        match self {
342            Manual => "manual",
343            Rule => "rule",
344        }
345    }
346}
347
348impl std::str::FromStr for ReviewOpenedReason {
349    type Err = stripe_types::StripeParseError;
350    fn from_str(s: &str) -> Result<Self, Self::Err> {
351        use ReviewOpenedReason::*;
352        match s {
353            "manual" => Ok(Manual),
354            "rule" => Ok(Rule),
355            _ => Err(stripe_types::StripeParseError),
356        }
357    }
358}
359impl std::fmt::Display for ReviewOpenedReason {
360    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
361        f.write_str(self.as_str())
362    }
363}
364
365impl std::fmt::Debug for ReviewOpenedReason {
366    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
367        f.write_str(self.as_str())
368    }
369}
370#[cfg(feature = "serialize")]
371impl serde::Serialize for ReviewOpenedReason {
372    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
373    where
374        S: serde::Serializer,
375    {
376        serializer.serialize_str(self.as_str())
377    }
378}
379impl miniserde::Deserialize for ReviewOpenedReason {
380    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
381        crate::Place::new(out)
382    }
383}
384
385impl miniserde::de::Visitor for crate::Place<ReviewOpenedReason> {
386    fn string(&mut self, s: &str) -> miniserde::Result<()> {
387        use std::str::FromStr;
388        self.out = Some(ReviewOpenedReason::from_str(s).map_err(|_| miniserde::Error)?);
389        Ok(())
390    }
391}
392
393stripe_types::impl_from_val_with_from_str!(ReviewOpenedReason);
394#[cfg(feature = "deserialize")]
395impl<'de> serde::Deserialize<'de> for ReviewOpenedReason {
396    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
397        use std::str::FromStr;
398        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
399        Self::from_str(&s)
400            .map_err(|_| serde::de::Error::custom("Unknown value for ReviewOpenedReason"))
401    }
402}
403impl stripe_types::Object for Review {
404    type Id = stripe_shared::ReviewId;
405    fn id(&self) -> &Self::Id {
406        &self.id
407    }
408
409    fn into_id(self) -> Self::Id {
410        self.id
411    }
412}
413stripe_types::def_id!(ReviewId);
stripe_shared/review.rs

stripe_shared/
review.rs
