stripe/resources/
source_ext.rs

1use serde::{Deserialize, Serialize};
2
3/// An enum representing the possible values of an `Source`'s `status` field.
4#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
5#[serde(rename_all = "snake_case")]
6pub enum SourceStatus {
7    Canceled,
8    Chargeable,
9    Consumed,
10    Failed,
11    Pending,
12}
13
14impl SourceStatus {
15    pub fn as_str(self) -> &'static str {
16        match self {
17            SourceStatus::Canceled => "canceled",
18            SourceStatus::Chargeable => "chargeable",
19            SourceStatus::Consumed => "consumed",
20            SourceStatus::Failed => "failed",
21            SourceStatus::Pending => "pending",
22        }
23    }
24}
25
26impl AsRef<str> for SourceStatus {
27    fn as_ref(&self) -> &str {
28        self.as_str()
29    }
30}
31
32impl std::fmt::Display for SourceStatus {
33    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
34        self.as_str().fmt(f)
35    }
36}
37
38impl std::default::Default for SourceStatus {
39    fn default() -> Self {
40        Self::Pending
41    }
42}
43
44/// An enum representing the possible values of an `Source`'s `usage` field.
45#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
46#[serde(rename_all = "snake_case")]
47pub enum SourceUsage {
48    Reusable,
49    SingleUse,
50}
51
52impl SourceUsage {
53    pub fn as_str(self) -> &'static str {
54        match self {
55            SourceUsage::Reusable => "reusable",
56            SourceUsage::SingleUse => "single_use",
57        }
58    }
59}
60
61impl AsRef<str> for SourceUsage {
62    fn as_ref(&self) -> &str {
63        self.as_str()
64    }
65}
66
67impl std::fmt::Display for SourceUsage {
68    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
69        self.as_str().fmt(f)
70    }
71}
72
73/// An enum representing the possible values of an `SourceRedirectFlow`'s `failure_reason` field.
74#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
75#[serde(rename_all = "snake_case")]
76pub enum SourceRedirectFlowFailureReason {
77    Declined,
78    ProcessingError,
79    UserAbort,
80}
81
82impl SourceRedirectFlowFailureReason {
83    pub fn as_str(self) -> &'static str {
84        match self {
85            SourceRedirectFlowFailureReason::Declined => "declined",
86            SourceRedirectFlowFailureReason::ProcessingError => "processing_error",
87            SourceRedirectFlowFailureReason::UserAbort => "user_abort",
88        }
89    }
90}
91
92impl AsRef<str> for SourceRedirectFlowFailureReason {
93    fn as_ref(&self) -> &str {
94        self.as_str()
95    }
96}
97
98impl std::fmt::Display for SourceRedirectFlowFailureReason {
99    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
100        self.as_str().fmt(f)
101    }
102}
103
104impl std::default::Default for SourceRedirectFlowFailureReason {
105    fn default() -> Self {
106        Self::Declined
107    }
108}
109
110/// An enum representing the possible values of an `SourceRedirectFlow`'s `status` field.
111#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
112#[serde(rename_all = "snake_case")]
113pub enum SourceRedirectFlowStatus {
114    Failed,
115    NotRequired,
116    Pending,
117    Succeeded,
118}
119
120impl SourceRedirectFlowStatus {
121    pub fn as_str(self) -> &'static str {
122        match self {
123            SourceRedirectFlowStatus::Failed => "failed",
124            SourceRedirectFlowStatus::NotRequired => "not_required",
125            SourceRedirectFlowStatus::Pending => "pending",
126            SourceRedirectFlowStatus::Succeeded => "succeeded",
127        }
128    }
129}
130
131impl AsRef<str> for SourceRedirectFlowStatus {
132    fn as_ref(&self) -> &str {
133        self.as_str()
134    }
135}
136
137impl std::fmt::Display for SourceRedirectFlowStatus {
138    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
139        self.as_str().fmt(f)
140    }
141}
142
143impl std::default::Default for SourceRedirectFlowStatus {
144    fn default() -> Self {
145        Self::Pending
146    }
147}