use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::json;
use crate::authentification::{Credentials, CredentialsOrApiKey};
use crate::billing::{RedirectUrl, ReturnOptions};
use crate::error::Result;
use crate::http::{client, encode, ok};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum PaymentStatus {
Pending,
Succeeded,
Expired,
Refunded,
Disputed,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Payment {
pub id: String,
pub status: PaymentStatus,
pub amount: f64,
pub fee: f64,
pub refunded: f64,
pub currency: String,
pub payee: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub payer: Option<String>,
pub reference: String,
pub description: String,
pub created: DateTime<Utc>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentRequest {
pub payee: String,
pub amount: f64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub payer: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub currency: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reference: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub return_url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cancel_url: Option<String>,
}
#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Payouts {
pub connected: bool,
pub charges_enabled: bool,
pub payouts_enabled: bool,
pub details_submitted: bool,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct Quote {
pub amount: f64,
pub fee: f64,
pub payout: f64,
}
#[derive(Debug, Clone, Default)]
pub struct PaymentQuery {
pub reference: Option<String>,
}
pub async fn connect(credentials: &Credentials, options: &ReturnOptions) -> Result<RedirectUrl> {
let response = client()
.post(format!("{}/payments/payouts/connect", crate::get_url()))
.header("Authorization", format!("Token {}", credentials.token))
.json(&json!({ "returnUrl": options.return_url }))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn payouts(credentials: &Credentials) -> Result<Payouts> {
let response = client()
.get(format!("{}/payments/payouts", crate::get_url()))
.header("Authorization", format!("Token {}", credentials.token))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn dashboard(credentials: &Credentials) -> Result<RedirectUrl> {
let response = client()
.post(format!("{}/payments/payouts/dashboard", crate::get_url()))
.header("Authorization", format!("Token {}", credentials.token))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn quote(authorization: &CredentialsOrApiKey, amount: f64) -> Result<Quote> {
let response = client()
.get(format!("{}/payments/quote", crate::get_url()))
.query(&[("amount", amount.to_string())])
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn create(
authorization: &CredentialsOrApiKey,
request: &PaymentRequest,
) -> Result<Payment> {
let response = client()
.post(format!("{}/payments", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.json(request)
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn get(authorization: &CredentialsOrApiKey, id: &str) -> Result<Payment> {
let response = client()
.get(format!("{}/payments/{}", crate::get_url(), encode(id)))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn list(
authorization: &CredentialsOrApiKey,
query: &PaymentQuery,
) -> Result<Vec<Payment>> {
let mut request = client()
.get(format!("{}/payments", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(reference) = &query.reference {
request = request.query(&[("reference", reference)]);
}
let response = request.send().await?;
Ok(ok(response).await?.json().await?)
}
pub async fn refund(authorization: &CredentialsOrApiKey, id: &str) -> Result<Payment> {
let response = client()
.post(format!(
"{}/payments/{}/refund",
crate::get_url(),
encode(id)
))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.send()
.await?;
Ok(ok(response).await?.json().await?)
}