use std::sync::Arc;
use serde::Serialize;
use serde_json::Value;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::{DelopayError, Result};
use crate::core::models::common::Address;
use crate::core::models::payment_method::{
CustomerPaymentMethodsListResponse, PaymentMethodListResponse,
PaymentMethodPresentationResponse, PaymentMethodResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct PaymentMethods {
inner: Arc<Inner>,
}
impl PaymentMethods {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn create(
&self,
params: &PaymentMethodCreateRequest,
) -> Result<PaymentMethodResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/payment-methods", Some(&body), &[], None)
.await
}
pub async fn retrieve(&self, method_id: &str) -> Result<PaymentMethodResponse> {
let path = format!("/payment-methods/{}", encode_segment(method_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update(
&self,
method_id: &str,
params: &PaymentMethodUpdateRequest,
) -> Result<PaymentMethodResponse> {
params.validate()?;
let path = format!("/payment-methods/{}/update", encode_segment(method_id));
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn delete(&self, method_id: &str) -> Result<Value> {
let path = format!("/payment-methods/{}", encode_segment(method_id));
self.inner
.request(HttpMethod::Delete, &path, None, &[], None)
.await
}
pub async fn list(
&self,
params: Option<&PaymentMethodListParams>,
) -> Result<PaymentMethodListResponse> {
let query = params
.map(PaymentMethodListParams::to_query)
.unwrap_or_default();
self.inner
.request(HttpMethod::Get, "/payment-methods", None, &query, None)
.await
}
pub async fn list_for_customer(
&self,
customer_id: &str,
params: Option<&CustomerPaymentMethodsListParams>,
) -> Result<CustomerPaymentMethodsListResponse> {
let path = format!("/customers/{}/payment-methods", encode_segment(customer_id));
let query = params
.map(CustomerPaymentMethodsListParams::to_query)
.unwrap_or_default();
self.inner
.request(HttpMethod::Get, &path, None, &query, None)
.await
}
pub async fn set_default(
&self,
customer_id: &str,
method_id: &str,
) -> Result<PaymentMethodResponse> {
let path = format!(
"/customers/{}/payment-methods/{}/default",
encode_segment(customer_id),
encode_segment(method_id)
);
self.inner
.request(HttpMethod::Post, &path, None, &[], None)
.await
}
pub async fn presentation(
&self,
params: &PaymentMethodPresentationParams,
) -> Result<PaymentMethodPresentationResponse> {
self.inner
.request(
HttpMethod::Get,
"/account/payment-methods/presentation",
None,
¶ms.to_query(),
None,
)
.await
}
}
#[derive(Clone, Default)]
pub struct PaymentMethodPresentationParams {
pub client_secret: Option<String>,
pub profile_id: Option<String>,
pub environment: Option<String>,
pub country: Option<String>,
pub currency: Option<String>,
pub amount: Option<i64>,
pub contract_version: Option<u32>,
pub locale: Option<String>,
}
impl PaymentMethodPresentationParams {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
#[must_use]
pub fn client_secret(mut self, client_secret: impl Into<String>) -> Self {
self.client_secret = Some(client_secret.into());
self
}
#[must_use]
pub fn environment(mut self, environment: impl Into<String>) -> Self {
self.environment = Some(environment.into());
self
}
#[must_use]
pub fn country(mut self, country: impl Into<String>) -> Self {
self.country = Some(country.into());
self
}
#[must_use]
pub fn amount(mut self, amount: i64, currency: impl Into<String>) -> Self {
self.amount = Some(amount);
self.currency = Some(currency.into());
self
}
#[must_use]
pub fn contract_version(mut self, contract_version: u32) -> Self {
self.contract_version = Some(contract_version);
self
}
#[must_use]
pub fn locale(mut self, locale: impl Into<String>) -> Self {
self.locale = Some(locale.into());
self
}
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = &self.client_secret {
q.push(("client_secret", v.clone()));
}
if let Some(v) = &self.profile_id {
q.push(("profile_id", v.clone()));
}
if let Some(v) = &self.environment {
q.push(("environment", v.clone()));
}
if let Some(v) = &self.country {
q.push(("country", v.clone()));
}
if let Some(v) = &self.currency {
q.push(("currency", v.clone()));
}
if let Some(v) = self.amount {
q.push(("amount", v.to_string()));
}
if let Some(v) = self.contract_version {
q.push(("contract_version", v.to_string()));
}
if let Some(v) = &self.locale {
q.push(("locale", v.clone()));
}
q
}
}
impl std::fmt::Debug for PaymentMethodPresentationParams {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PaymentMethodPresentationParams")
.field(
"client_secret",
&self.client_secret.as_ref().map(|_| "<redacted>"),
)
.field("profile_id", &self.profile_id)
.field("environment", &self.environment)
.field("country", &self.country)
.field("currency", &self.currency)
.field("amount", &self.amount)
.field("contract_version", &self.contract_version)
.field("locale", &self.locale)
.finish()
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PaymentMethodCreateRequest {
pub payment_method: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_issuer: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_network: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bank_transfer: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub wallet: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_secret: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing: Option<Address>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const PAYMENT_METHOD_CREATE_REQUEST_NAMED: &[&str] = &[
"payment_method",
"payment_method_type",
"payment_method_issuer",
"card",
"metadata",
"customer_id",
"card_network",
"bank_transfer",
"wallet",
"client_secret",
"billing",
];
impl ValidateRequest for PaymentMethodCreateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if PAYMENT_METHOD_CREATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on PaymentMethodCreateRequest"
)));
}
}
Ok(())
}
}
impl PaymentMethodCreateRequest {
pub fn new(payment_method: impl Into<String>) -> Self {
Self {
payment_method: payment_method.into(),
..Default::default()
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CardUpdate {
#[serde(skip_serializing_if = "Option::is_none")]
pub card_exp_month: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_exp_year: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_holder_name: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PaymentMethodUpdateRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<CardUpdate>,
#[serde(skip_serializing_if = "Option::is_none")]
pub wallet: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_secret: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const PAYMENT_METHOD_UPDATE_REQUEST_NAMED: &[&str] = &["card", "wallet", "client_secret"];
impl ValidateRequest for PaymentMethodUpdateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if PAYMENT_METHOD_UPDATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on PaymentMethodUpdateRequest"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default)]
pub struct PaymentMethodListParams {
pub client_secret: Option<String>,
pub country: Option<String>,
pub amount: Option<i64>,
pub recurring_enabled: Option<bool>,
pub installment_payment_enabled: Option<bool>,
pub limit: Option<i64>,
pub card_networks: Option<Vec<String>>,
}
impl PaymentMethodListParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = &self.client_secret {
q.push(("client_secret", v.clone()));
}
if let Some(v) = &self.country {
q.push(("country", v.clone()));
}
if let Some(v) = self.amount {
q.push(("amount", v.to_string()));
}
if let Some(v) = self.recurring_enabled {
q.push(("recurring_enabled", v.to_string()));
}
if let Some(v) = self.installment_payment_enabled {
q.push(("installment_payment_enabled", v.to_string()));
}
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
if let Some(values) = &self.card_networks {
for v in values {
q.push(("card_networks", v.clone()));
}
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct CustomerPaymentMethodsListParams {
pub client_secret: Option<String>,
pub accepted_countries: Option<Vec<String>>,
pub accepted_currencies: Option<Vec<String>>,
pub amount: Option<i64>,
pub recurring_enabled: Option<bool>,
pub installment_payment_enabled: Option<bool>,
pub limit: Option<i64>,
pub card_networks: Option<Vec<String>>,
}
impl CustomerPaymentMethodsListParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = &self.client_secret {
q.push(("client_secret", v.clone()));
}
for v in self.accepted_countries.iter().flatten() {
q.push(("accepted_countries", v.clone()));
}
for v in self.accepted_currencies.iter().flatten() {
q.push(("accepted_currencies", v.clone()));
}
if let Some(v) = self.amount {
q.push(("amount", v.to_string()));
}
if let Some(v) = self.recurring_enabled {
q.push(("recurring_enabled", v.to_string()));
}
if let Some(v) = self.installment_payment_enabled {
q.push(("installment_payment_enabled", v.to_string()));
}
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
for v in self.card_networks.iter().flatten() {
q.push(("card_networks", v.clone()));
}
q
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const PM_JSON: &str = r#"{
"merchant_id": "mer_1", "payment_method_id": "pm_1",
"payment_method": "card"
}"#;
const PRESENTATION_JSON: &str = r#"{
"contract_version": 1,
"revision": "rev_1",
"scope": "shop",
"environment": "live",
"locale": "de",
"context": {"country": "DE", "currency": "EUR", "amount": 4999},
"status": "ready",
"layout_source": "stored",
"cache": {"max_age_seconds": 300, "stale_if_error_seconds": 86400},
"entries": [{
"id": "ent_card",
"kind": "card",
"tier": "normal",
"label": "Karte",
"sublabel": "Visa, Mastercard",
"label_source": "default",
"sublabel_source": "merchant",
"category": "card",
"icon": {"type": "builtin", "key": "card"},
"fallback_icon": "card",
"payment_method": "card",
"requires_device_support": false,
"further_choice": "none",
"children_detail": "known",
"children": [{
"id": "card_network:visa",
"kind": "card_network",
"label": "Visa",
"icon": {"type": "svg", "data_uri": "data:image/svg+xml;base64,PHN2Zy8+", "sha256": "ab12", "source": "default"},
"source": "account_configuration",
"selection": "display_only"
}],
"children_status": "available",
"children_stale": false,
"children_narrowed": true,
"action": {"type": "hosted_checkout"},
"entry_surprise": 1
}],
"surprise_field": "kept"
}"#;
#[tokio::test]
async fn presentation_gets_the_presentation_path_with_every_set_parameter() {
let (client, mock) = client_with(vec![Step::ok(PRESENTATION_JSON)]);
let params = PaymentMethodPresentationParams::new()
.profile_id("pro_1")
.environment("test")
.country("DE")
.amount(4999, "EUR")
.contract_version(1)
.locale("de");
let out = client
.payment_methods()
.presentation(¶ms)
.await
.unwrap();
assert_eq!(out.contract_version, 1);
assert_eq!(out.context.amount, Some(4999));
assert_eq!(out.cache.max_age_seconds, 300);
let entry = &out.entries[0];
assert_eq!(entry.kind, "card");
assert_eq!(entry.sublabel.as_deref(), Some("Visa, Mastercard"));
assert_eq!(entry.icon.as_ref().unwrap().kind, "builtin");
assert_eq!(entry.icon.as_ref().unwrap().key.as_deref(), Some("card"));
let child_icon = entry.children[0].icon.as_ref().unwrap();
assert_eq!(child_icon.kind, "svg");
assert_eq!(child_icon.sha256.as_deref(), Some("ab12"));
assert_eq!(entry.action.as_ref().unwrap().kind, "hosted_checkout");
assert!(entry.children_narrowed);
assert!(entry.members.is_none());
assert_eq!(entry.extra["entry_surprise"], 1);
assert_eq!(out.extra["surprise_field"], "kept");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/account/payment-methods/presentation?profile_id=pro_1\
&environment=test&country=DE¤cy=EUR&amount=4999&contract_version=1&locale=de"
);
assert!(seen[0].body.is_none());
}
#[tokio::test]
async fn presentation_for_a_payment_sends_only_the_client_secret() {
let (client, mock) = client_with(vec![Step::ok(PRESENTATION_JSON)]);
client
.payment_methods()
.presentation(&PaymentMethodPresentationParams::new().client_secret("pay_1_secret_x"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
seen[0].url,
"https://api.test/account/payment-methods/presentation?client_secret=pay_1_secret_x"
);
}
#[test]
fn presentation_params_debug_redacts_the_client_secret() {
let params = PaymentMethodPresentationParams::new().client_secret("pay_1_secret_x");
let printed = format!("{params:?}");
assert!(!printed.contains("pay_1_secret_x"), "{printed}");
assert!(printed.contains("<redacted>"));
}
fn full_create_request() -> PaymentMethodCreateRequest {
PaymentMethodCreateRequest {
payment_method: "card".to_string(),
payment_method_type: Some("credit".to_string()),
payment_method_issuer: Some("Big Bank".to_string()),
card: Some(json!({"card_number": "4242424242424242"})),
metadata: Some(json!({"k": "v"})),
customer_id: Some("cus_1".to_string()),
card_network: Some("Visa".to_string()),
bank_transfer: Some(json!({"iban": "DE00"})),
wallet: Some(json!({"type": "apple_pay"})),
client_secret: Some("cs_1".to_string()),
billing: Some(Address::default()),
extra: serde_json::Map::new(),
}
}
#[test]
fn create_request_named_fields_are_complete() {
let value = serde_json::to_value(full_create_request()).unwrap();
let obj = value.as_object().expect("serializes to a JSON object");
for key in obj.keys() {
assert!(
PAYMENT_METHOD_CREATE_REQUEST_NAMED.contains(&key.as_str()),
"PAYMENT_METHOD_CREATE_REQUEST_NAMED is missing wire key `{key}` -- \
add it, or the extra-key collision guard silently stops \
covering this field"
);
}
}
fn full_update_request() -> PaymentMethodUpdateRequest {
PaymentMethodUpdateRequest {
card: Some(CardUpdate {
card_exp_month: Some("09".to_string()),
card_exp_year: Some("2030".to_string()),
card_holder_name: Some("Ada".to_string()),
}),
wallet: Some(json!({"type": "apple_pay"})),
client_secret: Some("cs_1".to_string()),
extra: serde_json::Map::new(),
}
}
#[test]
fn update_request_named_fields_are_complete() {
let value = serde_json::to_value(full_update_request()).unwrap();
let obj = value.as_object().expect("serializes to a JSON object");
for key in obj.keys() {
assert!(
PAYMENT_METHOD_UPDATE_REQUEST_NAMED.contains(&key.as_str()),
"PAYMENT_METHOD_UPDATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn create_validate_rejects_colliding_extra_key() {
let mut req = PaymentMethodCreateRequest::new("card");
req.extra.insert("customer_id".to_string(), json!("cus_2"));
assert!(matches!(
req.validate().unwrap_err(),
crate::core::error::DelopayError::InvalidRequest(_)
));
}
#[tokio::test]
async fn create_posts_to_payment_methods() {
let (client, mock) = client_with(vec![Step::ok(PM_JSON)]);
let req = PaymentMethodCreateRequest::new("card");
client.payment_methods().create(&req).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/payment-methods");
assert_eq!(seen[0].body_json()["payment_method"], "card");
}
#[tokio::test]
async fn update_posts_to_the_update_path() {
let (client, mock) = client_with(vec![Step::ok(PM_JSON)]);
let req = full_update_request();
client.payment_methods().update("pm_1", &req).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/payment-methods/pm_1/update");
assert_eq!(seen[0].body_json()["card"]["card_exp_year"], "2030");
}
#[tokio::test]
async fn list_for_customer_serializes_repeated_array_params() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"customer_payment_methods":[],"is_guest_customer":true}"#,
)]);
let params = CustomerPaymentMethodsListParams {
accepted_currencies: Some(vec!["EUR".to_string(), "USD".to_string()]),
amount: Some(5000),
..Default::default()
};
client
.payment_methods()
.list_for_customer("cus_1", Some(¶ms))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
seen[0].url,
"https://api.test/customers/cus_1/payment-methods\
?accepted_currencies=EUR&accepted_currencies=USD&amount=5000",
"array filters must be repeated keys, not comma-joined"
);
}
#[tokio::test]
async fn list_filters_by_client_secret_and_country() {
let (client, mock) = client_with(vec![Step::ok(r#"{"payment_methods":[]}"#)]);
let params = PaymentMethodListParams {
client_secret: Some("cs_1".to_string()),
country: Some("DE".to_string()),
..Default::default()
};
client.payment_methods().list(Some(¶ms)).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
seen[0].url,
"https://api.test/payment-methods?client_secret=cs_1&country=DE"
);
}
#[tokio::test]
async fn list_sends_the_order_value_and_capability_filters() {
let (client, mock) = client_with(vec![Step::ok(r#"{"payment_methods":[]}"#)]);
let params = PaymentMethodListParams {
amount: Some(25_000),
recurring_enabled: Some(true),
installment_payment_enabled: Some(false),
limit: Some(20),
card_networks: Some(vec!["Visa".to_string(), "Mastercard".to_string()]),
..Default::default()
};
client.payment_methods().list(Some(¶ms)).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
seen[0].url,
"https://api.test/payment-methods\
?amount=25000&recurring_enabled=true&installment_payment_enabled=false\
&limit=20&card_networks=Visa&card_networks=Mastercard"
);
}
}