use crate::config::{Client, Response};
use crate::ids::MandateId;
use crate::params::{Expand, Expandable, Object, Timestamp};
use crate::resources::{Currency, PaymentMethod};
use serde_derive::{Deserialize, Serialize};
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Mandate {
pub id: MandateId,
pub customer_acceptance: CustomerAcceptance,
pub livemode: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub multi_use: Option<MandateMultiUse>,
pub payment_method: Expandable<PaymentMethod>,
pub payment_method_details: MandatePaymentMethodDetails,
#[serde(skip_serializing_if = "Option::is_none")]
pub single_use: Option<MandateSingleUse>,
pub status: MandateStatus,
#[serde(rename = "type")]
pub type_: MandateType,
}
impl Mandate {
pub fn retrieve(client: &Client, id: &MandateId, expand: &[&str]) -> Response<Mandate> {
client.get_query(&format!("/mandates/{}", id), &Expand { expand })
}
}
impl Object for Mandate {
type Id = MandateId;
fn id(&self) -> Self::Id {
self.id.clone()
}
fn object(&self) -> &'static str {
"mandate"
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CustomerAcceptance {
#[serde(skip_serializing_if = "Option::is_none")]
pub accepted_at: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub offline: Option<OfflineAcceptance>,
#[serde(skip_serializing_if = "Option::is_none")]
pub online: Option<OnlineAcceptance>,
#[serde(rename = "type")]
pub type_: CustomerAcceptanceType,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct MandateMultiUse {}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct MandatePaymentMethodDetails {
#[serde(skip_serializing_if = "Option::is_none")]
pub au_becs_debit: Option<MandateAuBecsDebit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bacs_debit: Option<MandateBacsDebit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<CardMandatePaymentMethodDetails>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sepa_debit: Option<MandateSepaDebit>,
#[serde(rename = "type")]
pub type_: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CardMandatePaymentMethodDetails {}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct MandateAuBecsDebit {
pub url: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct MandateBacsDebit {
pub network_status: MandateBacsDebitNetworkStatus,
pub reference: String,
pub url: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct MandateSepaDebit {
pub reference: String,
pub url: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct MandateSingleUse {
pub amount: i64,
pub currency: Currency,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct OfflineAcceptance {}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct OnlineAcceptance {
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub user_agent: Option<String>,
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CustomerAcceptanceType {
Offline,
Online,
}
impl CustomerAcceptanceType {
pub fn as_str(self) -> &'static str {
match self {
CustomerAcceptanceType::Offline => "offline",
CustomerAcceptanceType::Online => "online",
}
}
}
impl AsRef<str> for CustomerAcceptanceType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CustomerAcceptanceType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum MandateBacsDebitNetworkStatus {
Accepted,
Pending,
Refused,
Revoked,
}
impl MandateBacsDebitNetworkStatus {
pub fn as_str(self) -> &'static str {
match self {
MandateBacsDebitNetworkStatus::Accepted => "accepted",
MandateBacsDebitNetworkStatus::Pending => "pending",
MandateBacsDebitNetworkStatus::Refused => "refused",
MandateBacsDebitNetworkStatus::Revoked => "revoked",
}
}
}
impl AsRef<str> for MandateBacsDebitNetworkStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for MandateBacsDebitNetworkStatus {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum MandateStatus {
Active,
Inactive,
Pending,
}
impl MandateStatus {
pub fn as_str(self) -> &'static str {
match self {
MandateStatus::Active => "active",
MandateStatus::Inactive => "inactive",
MandateStatus::Pending => "pending",
}
}
}
impl AsRef<str> for MandateStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for MandateStatus {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum MandateType {
MultiUse,
SingleUse,
}
impl MandateType {
pub fn as_str(self) -> &'static str {
match self {
MandateType::MultiUse => "multi_use",
MandateType::SingleUse => "single_use",
}
}
}
impl AsRef<str> for MandateType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for MandateType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}