rustauth-stripe 0.2.0

Stripe integration for RustAuth.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};
use time::OffsetDateTime;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Subscription {
    pub id: String,
    pub plan: String,
    #[serde(rename = "referenceId")]
    pub reference_id: String,
    #[serde(default, rename = "stripeCustomerId")]
    pub stripe_customer_id: Option<String>,
    #[serde(default, rename = "stripeSubscriptionId")]
    pub stripe_subscription_id: Option<String>,
    pub status: String,
    #[serde(default, rename = "periodStart", with = "time::serde::rfc3339::option")]
    pub period_start: Option<OffsetDateTime>,
    #[serde(default, rename = "periodEnd", with = "time::serde::rfc3339::option")]
    pub period_end: Option<OffsetDateTime>,
    #[serde(default, rename = "trialStart", with = "time::serde::rfc3339::option")]
    pub trial_start: Option<OffsetDateTime>,
    #[serde(default, rename = "trialEnd", with = "time::serde::rfc3339::option")]
    pub trial_end: Option<OffsetDateTime>,
    #[serde(default, rename = "cancelAtPeriodEnd")]
    pub cancel_at_period_end: bool,
    #[serde(default, rename = "cancelAt", with = "time::serde::rfc3339::option")]
    pub cancel_at: Option<OffsetDateTime>,
    #[serde(default, rename = "canceledAt", with = "time::serde::rfc3339::option")]
    pub canceled_at: Option<OffsetDateTime>,
    #[serde(default, rename = "endedAt", with = "time::serde::rfc3339::option")]
    pub ended_at: Option<OffsetDateTime>,
    #[serde(default)]
    pub seats: Option<i64>,
    #[serde(default, rename = "billingInterval")]
    pub billing_interval: Option<String>,
    #[serde(default, rename = "stripeScheduleId")]
    pub stripe_schedule_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StripePrice {
    pub id: String,
    #[serde(default)]
    pub lookup_key: Option<String>,
    #[serde(default)]
    pub recurring: Option<StripeRecurring>,
}

impl StripePrice {
    pub fn new(id: impl Into<String>) -> Self {
        Self {
            id: id.into(),
            lookup_key: None,
            recurring: None,
        }
    }

    pub fn lookup_key(mut self, lookup_key: impl Into<String>) -> Self {
        self.lookup_key = Some(lookup_key.into());
        self
    }

    pub fn recurring(mut self, interval: impl Into<String>, usage_type: impl Into<String>) -> Self {
        self.recurring = Some(StripeRecurring {
            interval: interval.into(),
            usage_type: Some(usage_type.into()),
        });
        self
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StripeRecurring {
    pub interval: String,
    #[serde(default)]
    pub usage_type: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StripeSubscriptionItem {
    pub id: String,
    pub price: StripePrice,
    #[serde(default)]
    pub quantity: Option<i64>,
    #[serde(default)]
    pub current_period_start: Option<i64>,
    #[serde(default)]
    pub current_period_end: Option<i64>,
}

impl StripeSubscriptionItem {
    pub fn new(id: impl Into<String>, price: StripePrice) -> Self {
        Self {
            id: id.into(),
            price,
            quantity: None,
            current_period_start: None,
            current_period_end: None,
        }
    }

    pub fn quantity(mut self, quantity: i64) -> Self {
        self.quantity = Some(quantity);
        self
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StripeList<T> {
    pub data: Vec<T>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StripeSubscription {
    pub id: String,
    #[serde(default)]
    pub customer: Option<serde_json::Value>,
    pub status: String,
    pub items: StripeList<StripeSubscriptionItem>,
    #[serde(default)]
    pub metadata: BTreeMap<String, String>,
    #[serde(default)]
    pub cancel_at_period_end: bool,
    #[serde(default)]
    pub cancel_at: Option<i64>,
    #[serde(default)]
    pub canceled_at: Option<i64>,
    #[serde(default)]
    pub ended_at: Option<i64>,
    #[serde(default)]
    pub trial_start: Option<i64>,
    #[serde(default)]
    pub trial_end: Option<i64>,
    #[serde(default)]
    pub schedule: Option<serde_json::Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StripeCheckoutSession {
    pub id: String,
    #[serde(default)]
    pub mode: Option<String>,
    #[serde(default)]
    pub subscription: Option<serde_json::Value>,
    #[serde(default)]
    pub client_reference_id: Option<String>,
    #[serde(default)]
    pub metadata: BTreeMap<String, String>,
    #[serde(default)]
    pub url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StripeEvent {
    pub id: String,
    #[serde(rename = "type")]
    pub event_type: String,
    pub data: StripeEventData,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StripeEventData {
    pub object: serde_json::Value,
}