use serde::{Deserialize, Serialize};
use crate::client::{Client, Response};
use crate::ids::MandateId;
use crate::params::{Expand, Expandable, Object, Timestamp};
use crate::resources::{Currency, PaymentMethod};
#[derive(Clone, Debug, Default, 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>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_behalf_of: Option<String>,
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, Default, Deserialize, Serialize)]
pub struct CustomerAcceptance {
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, Default, Deserialize, Serialize)]
pub struct MandateMultiUse {}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct MandatePaymentMethodDetails {
#[serde(skip_serializing_if = "Option::is_none")]
pub acss_debit: Option<MandateAcssDebit>,
#[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 cashapp: Option<MandateCashapp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub link: Option<MandateLink>,
#[serde(skip_serializing_if = "Option::is_none")]
pub paypal: Option<MandatePaypal>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sepa_debit: Option<MandateSepaDebit>,
#[serde(rename = "type")]
pub type_: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub us_bank_account: Option<MandateUsBankAccount>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CardMandatePaymentMethodDetails {}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct MandateAcssDebit {
#[serde(skip_serializing_if = "Option::is_none")]
pub default_for: Option<Vec<MandateAcssDebitDefaultFor>>,
pub interval_description: Option<String>,
pub payment_schedule: MandateAcssDebitPaymentSchedule,
pub transaction_type: MandateAcssDebitTransactionType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct MandateAuBecsDebit {
pub url: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct MandateBacsDebit {
pub network_status: MandateBacsDebitNetworkStatus,
pub reference: String,
pub revocation_reason: Option<MandateBacsDebitRevocationReason>,
pub url: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct MandateCashapp {}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct MandateLink {}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct MandatePaypal {
pub billing_agreement_id: Option<String>,
pub payer_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct MandateSepaDebit {
pub reference: String,
pub url: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct MandateSingleUse {
pub amount: i64,
pub currency: Currency,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct MandateUsBankAccount {
#[serde(skip_serializing_if = "Option::is_none")]
pub collection_method: Option<MandateUsBankAccountCollectionMethod>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct OfflineAcceptance {}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct OnlineAcceptance {
pub ip_address: Option<String>,
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)
}
}
impl std::default::Default for CustomerAcceptanceType {
fn default() -> Self {
Self::Offline
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum MandateAcssDebitDefaultFor {
Invoice,
Subscription,
}
impl MandateAcssDebitDefaultFor {
pub fn as_str(self) -> &'static str {
match self {
MandateAcssDebitDefaultFor::Invoice => "invoice",
MandateAcssDebitDefaultFor::Subscription => "subscription",
}
}
}
impl AsRef<str> for MandateAcssDebitDefaultFor {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for MandateAcssDebitDefaultFor {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for MandateAcssDebitDefaultFor {
fn default() -> Self {
Self::Invoice
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum MandateAcssDebitPaymentSchedule {
Combined,
Interval,
Sporadic,
}
impl MandateAcssDebitPaymentSchedule {
pub fn as_str(self) -> &'static str {
match self {
MandateAcssDebitPaymentSchedule::Combined => "combined",
MandateAcssDebitPaymentSchedule::Interval => "interval",
MandateAcssDebitPaymentSchedule::Sporadic => "sporadic",
}
}
}
impl AsRef<str> for MandateAcssDebitPaymentSchedule {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for MandateAcssDebitPaymentSchedule {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for MandateAcssDebitPaymentSchedule {
fn default() -> Self {
Self::Combined
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum MandateAcssDebitTransactionType {
Business,
Personal,
}
impl MandateAcssDebitTransactionType {
pub fn as_str(self) -> &'static str {
match self {
MandateAcssDebitTransactionType::Business => "business",
MandateAcssDebitTransactionType::Personal => "personal",
}
}
}
impl AsRef<str> for MandateAcssDebitTransactionType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for MandateAcssDebitTransactionType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for MandateAcssDebitTransactionType {
fn default() -> Self {
Self::Business
}
}
#[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)
}
}
impl std::default::Default for MandateBacsDebitNetworkStatus {
fn default() -> Self {
Self::Accepted
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum MandateBacsDebitRevocationReason {
AccountClosed,
BankAccountRestricted,
BankOwnershipChanged,
CouldNotProcess,
DebitNotAuthorized,
}
impl MandateBacsDebitRevocationReason {
pub fn as_str(self) -> &'static str {
match self {
MandateBacsDebitRevocationReason::AccountClosed => "account_closed",
MandateBacsDebitRevocationReason::BankAccountRestricted => "bank_account_restricted",
MandateBacsDebitRevocationReason::BankOwnershipChanged => "bank_ownership_changed",
MandateBacsDebitRevocationReason::CouldNotProcess => "could_not_process",
MandateBacsDebitRevocationReason::DebitNotAuthorized => "debit_not_authorized",
}
}
}
impl AsRef<str> for MandateBacsDebitRevocationReason {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for MandateBacsDebitRevocationReason {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for MandateBacsDebitRevocationReason {
fn default() -> Self {
Self::AccountClosed
}
}
#[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)
}
}
impl std::default::Default for MandateStatus {
fn default() -> Self {
Self::Active
}
}
#[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)
}
}
impl std::default::Default for MandateType {
fn default() -> Self {
Self::MultiUse
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum MandateUsBankAccountCollectionMethod {
Paper,
}
impl MandateUsBankAccountCollectionMethod {
pub fn as_str(self) -> &'static str {
match self {
MandateUsBankAccountCollectionMethod::Paper => "paper",
}
}
}
impl AsRef<str> for MandateUsBankAccountCollectionMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for MandateUsBankAccountCollectionMethod {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for MandateUsBankAccountCollectionMethod {
fn default() -> Self {
Self::Paper
}
}