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
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    Acknowledged,
253    Approved,
254    Canceled,
255    Disputed,
256    PaymentNeverSettled,
257    Redacted,
258    Refunded,
259    RefundedAsFraud,
260}
261impl ReviewClosedReason {
262    pub fn as_str(self) -> &'static str {
263        use ReviewClosedReason::*;
264        match self {
265            Acknowledged => "acknowledged",
266            Approved => "approved",
267            Canceled => "canceled",
268            Disputed => "disputed",
269            PaymentNeverSettled => "payment_never_settled",
270            Redacted => "redacted",
271            Refunded => "refunded",
272            RefundedAsFraud => "refunded_as_fraud",
273        }
274    }
275}
276
277impl std::str::FromStr for ReviewClosedReason {
278    type Err = stripe_types::StripeParseError;
279    fn from_str(s: &str) -> Result<Self, Self::Err> {
280        use ReviewClosedReason::*;
281        match s {
282            "acknowledged" => Ok(Acknowledged),
283            "approved" => Ok(Approved),
284            "canceled" => Ok(Canceled),
285            "disputed" => Ok(Disputed),
286            "payment_never_settled" => Ok(PaymentNeverSettled),
287            "redacted" => Ok(Redacted),
288            "refunded" => Ok(Refunded),
289            "refunded_as_fraud" => Ok(RefundedAsFraud),
290            _ => Err(stripe_types::StripeParseError),
291        }
292    }
293}
294impl std::fmt::Display for ReviewClosedReason {
295    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
296        f.write_str(self.as_str())
297    }
298}
299
300impl std::fmt::Debug for ReviewClosedReason {
301    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
302        f.write_str(self.as_str())
303    }
304}
305#[cfg(feature = "serialize")]
306impl serde::Serialize for ReviewClosedReason {
307    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
308    where
309        S: serde::Serializer,
310    {
311        serializer.serialize_str(self.as_str())
312    }
313}
314impl miniserde::Deserialize for ReviewClosedReason {
315    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
316        crate::Place::new(out)
317    }
318}
319
320impl miniserde::de::Visitor for crate::Place<ReviewClosedReason> {
321    fn string(&mut self, s: &str) -> miniserde::Result<()> {
322        use std::str::FromStr;
323        self.out = Some(ReviewClosedReason::from_str(s).map_err(|_| miniserde::Error)?);
324        Ok(())
325    }
326}
327
328stripe_types::impl_from_val_with_from_str!(ReviewClosedReason);
329#[cfg(feature = "deserialize")]
330impl<'de> serde::Deserialize<'de> for ReviewClosedReason {
331    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
332        use std::str::FromStr;
333        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
334        Self::from_str(&s)
335            .map_err(|_| serde::de::Error::custom("Unknown value for ReviewClosedReason"))
336    }
337}
338/// The reason the review was opened. One of `rule` or `manual`.
339#[derive(Copy, Clone, Eq, PartialEq)]
340pub enum ReviewOpenedReason {
341    Manual,
342    Rule,
343}
344impl ReviewOpenedReason {
345    pub fn as_str(self) -> &'static str {
346        use ReviewOpenedReason::*;
347        match self {
348            Manual => "manual",
349            Rule => "rule",
350        }
351    }
352}
353
354impl std::str::FromStr for ReviewOpenedReason {
355    type Err = stripe_types::StripeParseError;
356    fn from_str(s: &str) -> Result<Self, Self::Err> {
357        use ReviewOpenedReason::*;
358        match s {
359            "manual" => Ok(Manual),
360            "rule" => Ok(Rule),
361            _ => Err(stripe_types::StripeParseError),
362        }
363    }
364}
365impl std::fmt::Display for ReviewOpenedReason {
366    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
367        f.write_str(self.as_str())
368    }
369}
370
371impl std::fmt::Debug for ReviewOpenedReason {
372    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
373        f.write_str(self.as_str())
374    }
375}
376#[cfg(feature = "serialize")]
377impl serde::Serialize for ReviewOpenedReason {
378    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
379    where
380        S: serde::Serializer,
381    {
382        serializer.serialize_str(self.as_str())
383    }
384}
385impl miniserde::Deserialize for ReviewOpenedReason {
386    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
387        crate::Place::new(out)
388    }
389}
390
391impl miniserde::de::Visitor for crate::Place<ReviewOpenedReason> {
392    fn string(&mut self, s: &str) -> miniserde::Result<()> {
393        use std::str::FromStr;
394        self.out = Some(ReviewOpenedReason::from_str(s).map_err(|_| miniserde::Error)?);
395        Ok(())
396    }
397}
398
399stripe_types::impl_from_val_with_from_str!(ReviewOpenedReason);
400#[cfg(feature = "deserialize")]
401impl<'de> serde::Deserialize<'de> for ReviewOpenedReason {
402    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
403        use std::str::FromStr;
404        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
405        Self::from_str(&s)
406            .map_err(|_| serde::de::Error::custom("Unknown value for ReviewOpenedReason"))
407    }
408}
409impl stripe_types::Object for Review {
410    type Id = stripe_shared::ReviewId;
411    fn id(&self) -> &Self::Id {
412        &self.id
413    }
414
415    fn into_id(self) -> Self::Id {
416        self.id
417    }
418}
419stripe_types::def_id!(ReviewId);
stripe_shared/review.rs

stripe_shared/
review.rs
