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

use crate::resources::billing::subscriptions::{BillingThresholds, SubscriptionBilling};
use crate::resources::common::object::Object;
use crate::resources::common::path::{UrlPath};
use crate::util::{List, Expandable};
use crate::Client;
use std::collections::HashMap;
use crate::resources::core::customer::Customer;
use crate::resources::billing::coupons::Coupon;
use crate::resources::billing::plans::Plans;
use crate::resources::billing::invoices::InvoiceBilling;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct SubscriptionSchedules {
    pub id: String,
    pub object: Object,
    pub billing: InvoiceBilling,
    pub billing_thresholds: Option<BillingThresholds>,
    pub canceled_at: Option<i64>,
    pub completed_at: Option<i64>,
    pub created: i64,
    pub current_phase: Option<CurrentPhase>,
    pub customer: Expandable<Customer>,
    pub invoice_settings: Option<InvoiceSettings>,
    pub livemode: bool,
    pub metadata: HashMap<String, String>,
    pub phases: Vec<Phase>,
    pub released_at: Option<i64>,
    pub released_subscription: Option<String>,
    pub renewal_behavior: String,
    pub renewal_interval: Option<RenewalInterval>,
    pub revision: String,
    pub status: SubscriptionSchedulesStatus,
    pub subscription: Option<String>, //Expandable?
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct InvoiceSettings {
    pub days_until_due: i64,
}

#[derive(Default, Serialize, Deserialize, Debug, PartialEq)]
pub struct Phase {
    pub application_fee_percent: Option<f64>,
    pub coupon: Option<Expandable<Coupon>>,
    pub end_date: Option<i64>,
    pub start_date: Option<i64>,
    pub trail_end: Option<i64>,
    pub trail: Option<bool>,
    pub tax_percent: Option<f64>,
    pub plans: Option<Vec<PhasePlans>>,
}

#[derive(Default, Serialize, Deserialize, Debug, PartialEq)]
pub struct PhasePlans {
    pub billing_thresholds: Option<BillingThresholds>,
    pub plan: Option<Expandable<Plans>>,
    pub quantity: Option<i64>,
}
#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct CurrentPhase {
    pub start_date: i64,
    pub end_date: i64,
}

#[derive(Default, Serialize, Deserialize, Debug, PartialEq)]
pub struct RenewalInterval {
    pub interval: Option<String>,
    pub length: Option<i64>,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum SubscriptionSchedulesStatus {
    NotStarted,
    Active,
    Completed,
    Released,
    Canceled,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum RenewalBehavior {
    None,
    Renew,
    Release,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct SubscriptionSchedulesParam<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing: Option<SubscriptionBilling>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_threshold: Option<BillingThresholds>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub customer: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from_subscription: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub invoice_settings: Option<InvoiceSettings>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<HashMap<String, String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phases: Option<Vec<Phase>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub renewal_behavior: Option<RenewalBehavior>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub renewal_interval: Option<RenewalInterval>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_date: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub invoice_now: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prorate: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub preserve_cancel_date: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expand: Option<Vec<&'a str>>,
}

impl SubscriptionSchedules {
    pub fn create<B: serde::Serialize>(client: &Client, param: B) -> crate::Result<Self> {
        client.post(UrlPath::SubscriptionSchedules, vec![], param)
    }

    pub fn retrieve(client: &Client, id: &str) -> crate::Result<Self> {
        client.get(
            UrlPath::SubscriptionSchedules,
            vec![id],
            serde_json::Map::new(),
        )
    }

    pub fn update<B: serde::Serialize>(client: &Client, id: &str, param: B) -> crate::Result<Self> {
        client.post(UrlPath::SubscriptionSchedules, vec![id], param)
    }

    pub fn cancel<B: serde::Serialize>(client: &Client, id: &str, param: B) -> crate::Result<Self> {
        client.delete(UrlPath::SubscriptionSchedules, vec![id, "cancel"], param)
    }

    pub fn release<B: serde::Serialize>(
        client: &Client,
        id: &str,
        param: B,
    ) -> crate::Result<Self> {
        client.post(UrlPath::SubscriptionSchedules, vec![id, "release"], param)
    }

    pub fn list<B: serde::Serialize>(client: &Client, param: B) -> crate::Result<List<Self>> {
        client.get(UrlPath::SubscriptionSchedules, vec![], param)
    }
}