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::{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 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                _ => <dyn Visitor>::ignore(),
108            })
109        }
110
111        fn deser_default() -> Self {
112            Self {
113                billing_zip: Deserialize::default(),
114                charge: Deserialize::default(),
115                closed_reason: Deserialize::default(),
116                created: Deserialize::default(),
117                id: Deserialize::default(),
118                ip_address: Deserialize::default(),
119                ip_address_location: Deserialize::default(),
120                livemode: Deserialize::default(),
121                open: Deserialize::default(),
122                opened_reason: Deserialize::default(),
123                payment_intent: Deserialize::default(),
124                reason: Deserialize::default(),
125                session: Deserialize::default(),
126            }
127        }
128
129        fn take_out(&mut self) -> Option<Self::Out> {
130            let (
131                Some(billing_zip),
132                Some(charge),
133                Some(closed_reason),
134                Some(created),
135                Some(id),
136                Some(ip_address),
137                Some(ip_address_location),
138                Some(livemode),
139                Some(open),
140                Some(opened_reason),
141                Some(payment_intent),
142                Some(reason),
143                Some(session),
144            ) = (
145                self.billing_zip.take(),
146                self.charge.take(),
147                self.closed_reason,
148                self.created,
149                self.id.take(),
150                self.ip_address.take(),
151                self.ip_address_location.take(),
152                self.livemode,
153                self.open,
154                self.opened_reason,
155                self.payment_intent.take(),
156                self.reason.take(),
157                self.session.take(),
158            )
159            else {
160                return None;
161            };
162            Some(Self::Out {
163                billing_zip,
164                charge,
165                closed_reason,
166                created,
167                id,
168                ip_address,
169                ip_address_location,
170                livemode,
171                open,
172                opened_reason,
173                payment_intent,
174                reason,
175                session,
176            })
177        }
178    }
179
180    impl Map for Builder<'_> {
181        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
182            self.builder.key(k)
183        }
184
185        fn finish(&mut self) -> Result<()> {
186            *self.out = self.builder.take_out();
187            Ok(())
188        }
189    }
190
191    impl ObjectDeser for Review {
192        type Builder = ReviewBuilder;
193    }
194
195    impl FromValueOpt for Review {
196        fn from_value(v: Value) -> Option<Self> {
197            let Value::Object(obj) = v else {
198                return None;
199            };
200            let mut b = ReviewBuilder::deser_default();
201            for (k, v) in obj {
202                match k.as_str() {
203                    "billing_zip" => b.billing_zip = FromValueOpt::from_value(v),
204                    "charge" => b.charge = FromValueOpt::from_value(v),
205                    "closed_reason" => b.closed_reason = FromValueOpt::from_value(v),
206                    "created" => b.created = FromValueOpt::from_value(v),
207                    "id" => b.id = FromValueOpt::from_value(v),
208                    "ip_address" => b.ip_address = FromValueOpt::from_value(v),
209                    "ip_address_location" => b.ip_address_location = FromValueOpt::from_value(v),
210                    "livemode" => b.livemode = FromValueOpt::from_value(v),
211                    "open" => b.open = FromValueOpt::from_value(v),
212                    "opened_reason" => b.opened_reason = FromValueOpt::from_value(v),
213                    "payment_intent" => b.payment_intent = FromValueOpt::from_value(v),
214                    "reason" => b.reason = FromValueOpt::from_value(v),
215                    "session" => b.session = FromValueOpt::from_value(v),
216                    _ => {}
217                }
218            }
219            b.take_out()
220        }
221    }
222};
223#[cfg(feature = "serialize")]
224impl serde::Serialize for Review {
225    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
226        use serde::ser::SerializeStruct;
227        let mut s = s.serialize_struct("Review", 14)?;
228        s.serialize_field("billing_zip", &self.billing_zip)?;
229        s.serialize_field("charge", &self.charge)?;
230        s.serialize_field("closed_reason", &self.closed_reason)?;
231        s.serialize_field("created", &self.created)?;
232        s.serialize_field("id", &self.id)?;
233        s.serialize_field("ip_address", &self.ip_address)?;
234        s.serialize_field("ip_address_location", &self.ip_address_location)?;
235        s.serialize_field("livemode", &self.livemode)?;
236        s.serialize_field("open", &self.open)?;
237        s.serialize_field("opened_reason", &self.opened_reason)?;
238        s.serialize_field("payment_intent", &self.payment_intent)?;
239        s.serialize_field("reason", &self.reason)?;
240        s.serialize_field("session", &self.session)?;
241
242        s.serialize_field("object", "review")?;
243        s.end()
244    }
245}
246/// The reason the review was closed, or null if it has not yet been closed.
247/// One of `approved`, `refunded`, `refunded_as_fraud`, `disputed`, `redacted`, `canceled`, `payment_never_settled`, or `acknowledged`.
248#[derive(Copy, Clone, Eq, PartialEq)]
249pub enum ReviewClosedReason {
250    Acknowledged,
251    Approved,
252    Canceled,
253    Disputed,
254    PaymentNeverSettled,
255    Redacted,
256    Refunded,
257    RefundedAsFraud,
258}
259impl ReviewClosedReason {
260    pub fn as_str(self) -> &'static str {
261        use ReviewClosedReason::*;
262        match self {
263            Acknowledged => "acknowledged",
264            Approved => "approved",
265            Canceled => "canceled",
266            Disputed => "disputed",
267            PaymentNeverSettled => "payment_never_settled",
268            Redacted => "redacted",
269            Refunded => "refunded",
270            RefundedAsFraud => "refunded_as_fraud",
271        }
272    }
273}
274
275impl std::str::FromStr for ReviewClosedReason {
276    type Err = stripe_types::StripeParseError;
277    fn from_str(s: &str) -> Result<Self, Self::Err> {
278        use ReviewClosedReason::*;
279        match s {
280            "acknowledged" => Ok(Acknowledged),
281            "approved" => Ok(Approved),
282            "canceled" => Ok(Canceled),
283            "disputed" => Ok(Disputed),
284            "payment_never_settled" => Ok(PaymentNeverSettled),
285            "redacted" => Ok(Redacted),
286            "refunded" => Ok(Refunded),
287            "refunded_as_fraud" => Ok(RefundedAsFraud),
288            _ => Err(stripe_types::StripeParseError),
289        }
290    }
291}
292impl std::fmt::Display for ReviewClosedReason {
293    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
294        f.write_str(self.as_str())
295    }
296}
297
298impl std::fmt::Debug for ReviewClosedReason {
299    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
300        f.write_str(self.as_str())
301    }
302}
303#[cfg(feature = "serialize")]
304impl serde::Serialize for ReviewClosedReason {
305    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
306    where
307        S: serde::Serializer,
308    {
309        serializer.serialize_str(self.as_str())
310    }
311}
312impl miniserde::Deserialize for ReviewClosedReason {
313    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
314        crate::Place::new(out)
315    }
316}
317
318impl miniserde::de::Visitor for crate::Place<ReviewClosedReason> {
319    fn string(&mut self, s: &str) -> miniserde::Result<()> {
320        use std::str::FromStr;
321        self.out = Some(ReviewClosedReason::from_str(s).map_err(|_| miniserde::Error)?);
322        Ok(())
323    }
324}
325
326stripe_types::impl_from_val_with_from_str!(ReviewClosedReason);
327#[cfg(feature = "deserialize")]
328impl<'de> serde::Deserialize<'de> for ReviewClosedReason {
329    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
330        use std::str::FromStr;
331        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
332        Self::from_str(&s)
333            .map_err(|_| serde::de::Error::custom("Unknown value for ReviewClosedReason"))
334    }
335}
336/// The reason the review was opened. One of `rule` or `manual`.
337#[derive(Copy, Clone, Eq, PartialEq)]
338pub enum ReviewOpenedReason {
339    Manual,
340    Rule,
341}
342impl ReviewOpenedReason {
343    pub fn as_str(self) -> &'static str {
344        use ReviewOpenedReason::*;
345        match self {
346            Manual => "manual",
347            Rule => "rule",
348        }
349    }
350}
351
352impl std::str::FromStr for ReviewOpenedReason {
353    type Err = stripe_types::StripeParseError;
354    fn from_str(s: &str) -> Result<Self, Self::Err> {
355        use ReviewOpenedReason::*;
356        match s {
357            "manual" => Ok(Manual),
358            "rule" => Ok(Rule),
359            _ => Err(stripe_types::StripeParseError),
360        }
361    }
362}
363impl std::fmt::Display for ReviewOpenedReason {
364    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
365        f.write_str(self.as_str())
366    }
367}
368
369impl std::fmt::Debug for ReviewOpenedReason {
370    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
371        f.write_str(self.as_str())
372    }
373}
374#[cfg(feature = "serialize")]
375impl serde::Serialize for ReviewOpenedReason {
376    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
377    where
378        S: serde::Serializer,
379    {
380        serializer.serialize_str(self.as_str())
381    }
382}
383impl miniserde::Deserialize for ReviewOpenedReason {
384    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
385        crate::Place::new(out)
386    }
387}
388
389impl miniserde::de::Visitor for crate::Place<ReviewOpenedReason> {
390    fn string(&mut self, s: &str) -> miniserde::Result<()> {
391        use std::str::FromStr;
392        self.out = Some(ReviewOpenedReason::from_str(s).map_err(|_| miniserde::Error)?);
393        Ok(())
394    }
395}
396
397stripe_types::impl_from_val_with_from_str!(ReviewOpenedReason);
398#[cfg(feature = "deserialize")]
399impl<'de> serde::Deserialize<'de> for ReviewOpenedReason {
400    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
401        use std::str::FromStr;
402        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
403        Self::from_str(&s)
404            .map_err(|_| serde::de::Error::custom("Unknown value for ReviewOpenedReason"))
405    }
406}
407impl stripe_types::Object for Review {
408    type Id = stripe_shared::ReviewId;
409    fn id(&self) -> &Self::Id {
410        &self.id
411    }
412
413    fn into_id(self) -> Self::Id {
414        self.id
415    }
416}
417stripe_types::def_id!(ReviewId);
stripe_shared/review.rs

stripe_shared/
review.rs
