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, AuthenticationType, CaptureMethod, SetupFutureUsage};
use crate::core::models::subscription::{
CancelSubscriptionResponse, ConfirmSubscriptionResponse, PauseSubscriptionResponse,
ResumeSubscriptionResponse, SubscriptionEstimateResponse, SubscriptionItem,
SubscriptionResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct Subscriptions {
inner: Arc<Inner>,
profile_id: Option<String>,
}
impl Subscriptions {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self {
inner,
profile_id: None,
}
}
#[must_use]
pub fn with_profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
fn headers(&self) -> Vec<(&str, &str)> {
match &self.profile_id {
Some(id) => vec![("x-profile-id", id.as_str())],
None => Vec::new(),
}
}
async fn send<T: serde::de::DeserializeOwned>(
&self,
method: HttpMethod,
path: &str,
body: Option<&[u8]>,
query: &[(&str, String)],
) -> Result<T> {
self.inner
.request_with_headers(method, path, body, query, None, &self.headers())
.await
}
pub async fn create_and_confirm(
&self,
params: &CreateAndConfirmSubscriptionRequest,
) -> Result<ConfirmSubscriptionResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.send(HttpMethod::Post, "/subscriptions", Some(&body), &[])
.await
}
pub async fn create(&self, params: &CreateSubscriptionRequest) -> Result<SubscriptionResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.send(HttpMethod::Post, "/subscriptions/create", Some(&body), &[])
.await
}
pub async fn retrieve(&self, subscription_id: &str) -> Result<SubscriptionResponse> {
let path = format!("/subscriptions/{}", encode_segment(subscription_id));
self.send(HttpMethod::Get, &path, None, &[]).await
}
pub async fn confirm(
&self,
subscription_id: &str,
params: &ConfirmSubscriptionRequest,
) -> Result<ConfirmSubscriptionResponse> {
let path = format!("/subscriptions/{}/confirm", encode_segment(subscription_id));
let body = to_json_vec(params)?;
self.send(HttpMethod::Post, &path, Some(&body), &[]).await
}
pub async fn update(
&self,
subscription_id: &str,
params: &UpdateSubscriptionRequest,
) -> Result<SubscriptionResponse> {
let path = format!("/subscriptions/{}/update", encode_segment(subscription_id));
let body = to_json_vec(params)?;
self.send(HttpMethod::Put, &path, Some(&body), &[]).await
}
pub async fn list(
&self,
params: Option<&SubscriptionListParams>,
) -> Result<Vec<SubscriptionResponse>> {
let query = params
.map(SubscriptionListParams::to_query)
.unwrap_or_default();
self.send(HttpMethod::Get, "/subscriptions/list", None, &query)
.await
}
pub async fn estimate(
&self,
params: &SubscriptionEstimateParams,
) -> Result<SubscriptionEstimateResponse> {
self.send(
HttpMethod::Get,
"/subscriptions/estimate",
None,
¶ms.to_query(),
)
.await
}
pub async fn items(&self, params: &SubscriptionItemsParams) -> Result<Vec<SubscriptionItem>> {
self.send(
HttpMethod::Get,
"/subscriptions/items",
None,
¶ms.to_query(),
)
.await
}
pub async fn pause(
&self,
subscription_id: &str,
params: Option<&PauseSubscriptionRequest>,
) -> Result<PauseSubscriptionResponse> {
let path = format!("/subscriptions/{}/pause", encode_segment(subscription_id));
let body = Self::body_or_empty_object(params)?;
self.send(HttpMethod::Post, &path, Some(&body), &[]).await
}
pub async fn resume(
&self,
subscription_id: &str,
params: Option<&ResumeSubscriptionRequest>,
) -> Result<ResumeSubscriptionResponse> {
let path = format!("/subscriptions/{}/resume", encode_segment(subscription_id));
let body = Self::body_or_empty_object(params)?;
self.send(HttpMethod::Post, &path, Some(&body), &[]).await
}
pub async fn cancel(
&self,
subscription_id: &str,
params: Option<&CancelSubscriptionRequest>,
) -> Result<CancelSubscriptionResponse> {
let path = format!("/subscriptions/{}/cancel", encode_segment(subscription_id));
let body = Self::body_or_empty_object(params)?;
self.send(HttpMethod::Post, &path, Some(&body), &[]).await
}
fn body_or_empty_object<T: Serialize>(params: Option<&T>) -> Result<Vec<u8>> {
match params {
Some(p) => to_json_vec(p),
None => Ok(b"{}".to_vec()),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateSubscriptionPaymentDetails {
pub return_url: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<SetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub capture_method: Option<CaptureMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_type: Option<AuthenticationType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_type: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateSubscriptionRequest {
pub item_price_id: String,
pub customer_id: String,
pub payment_details: CreateSubscriptionPaymentDetails,
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_reference_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub coupon_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping: Option<Address>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const CREATE_SUBSCRIPTION_REQUEST_NAMED: &[&str] = &[
"item_price_id",
"customer_id",
"payment_details",
"merchant_reference_id",
"plan_id",
"coupon_code",
"billing",
"shipping",
];
impl ValidateRequest for CreateSubscriptionRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if CREATE_SUBSCRIPTION_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on CreateSubscriptionRequest"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct SubscriptionPaymentDetails {
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_data: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<SetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_acceptance: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub capture_method: Option<CaptureMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_type: Option<AuthenticationType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_id: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateAndConfirmSubscriptionRequest {
pub item_price_id: String,
pub customer_id: String,
pub payment_details: SubscriptionPaymentDetails,
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub coupon_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_reference_id: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const CREATE_AND_CONFIRM_SUBSCRIPTION_REQUEST_NAMED: &[&str] = &[
"item_price_id",
"customer_id",
"payment_details",
"plan_id",
"coupon_code",
"billing",
"shipping",
"merchant_reference_id",
];
impl ValidateRequest for CreateAndConfirmSubscriptionRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if CREATE_AND_CONFIRM_SUBSCRIPTION_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on \
CreateAndConfirmSubscriptionRequest"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ConfirmSubscriptionPaymentDetails {
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_data: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_acceptance: Option<Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_token: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ConfirmSubscriptionRequest {
pub payment_details: ConfirmSubscriptionPaymentDetails,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_secret: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateSubscriptionRequest {
pub plan_id: String,
pub item_price_id: String,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PauseSubscriptionRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub pause_option: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pause_at: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ResumeSubscriptionRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub resume_option: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub resume_date: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub charges_handling: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub unpaid_invoices_handling: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CancelSubscriptionRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub cancel_option: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cancel_at: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub unbilled_charges_option: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub credit_option_for_current_term_charges: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub account_receivables_handling: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub refundable_credits_handling: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cancel_reason_code: Option<String>,
}
#[derive(Debug, Clone, Default)]
pub struct SubscriptionListParams {
pub limit: Option<i64>,
pub offset: Option<i64>,
}
impl SubscriptionListParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
if let Some(v) = self.offset {
q.push(("offset", v.to_string()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct SubscriptionItemsParams {
pub item_type: String,
pub client_secret: Option<String>,
pub limit: Option<i64>,
pub offset: Option<i64>,
}
impl SubscriptionItemsParams {
pub fn new(item_type: impl Into<String>) -> Self {
Self {
item_type: item_type.into(),
..Default::default()
}
}
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = vec![("item_type", self.item_type.clone())];
if let Some(v) = &self.client_secret {
q.push(("client_secret", v.clone()));
}
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
if let Some(v) = self.offset {
q.push(("offset", v.to_string()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct SubscriptionEstimateParams {
pub item_price_id: String,
pub plan_id: Option<String>,
pub coupon_code: Option<String>,
}
impl SubscriptionEstimateParams {
pub fn new(item_price_id: impl Into<String>) -> Self {
Self {
item_price_id: item_price_id.into(),
..Default::default()
}
}
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = vec![("item_price_id", self.item_price_id.clone())];
if let Some(v) = &self.plan_id {
q.push(("plan_id", v.clone()));
}
if let Some(v) = &self.coupon_code {
q.push(("coupon_code", v.clone()));
}
q
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const SUB_JSON: &str = r#"{"id": "sub_1", "status": "active"}"#;
const CONFIRM_JSON: &str = r#"{
"id": "sub_1", "status": "pending",
"redirect_url": "https://paypal.test/approve"
}"#;
fn create_and_confirm_request() -> CreateAndConfirmSubscriptionRequest {
CreateAndConfirmSubscriptionRequest {
item_price_id: "price_1".to_string(),
customer_id: "cus_1".to_string(),
payment_details: SubscriptionPaymentDetails {
payment_method: Some("card".to_string()),
..Default::default()
},
..Default::default()
}
}
#[tokio::test]
async fn sends_x_profile_id_header_when_scoped() {
let (client, mock) = client_with(vec![Step::ok(SUB_JSON)]);
client
.subscriptions()
.with_profile_id("pro_1")
.retrieve("sub_1")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].header("x-profile-id"), Some("pro_1"));
}
#[tokio::test]
async fn omits_the_profile_header_when_unscoped() {
let (client, mock) = client_with(vec![Step::ok(SUB_JSON)]);
client.subscriptions().retrieve("sub_1").await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].header("x-profile-id"), None);
}
#[tokio::test]
async fn create_and_confirm_posts_to_subscriptions_root() {
let (client, mock) = client_with(vec![Step::ok(CONFIRM_JSON)]);
let out = client
.subscriptions()
.with_profile_id("pro_1")
.create_and_confirm(&create_and_confirm_request())
.await
.unwrap();
assert_eq!(
out.redirect_url.as_deref(),
Some("https://paypal.test/approve")
);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/subscriptions");
let body = seen[0].body_json();
assert_eq!(body["item_price_id"], "price_1");
assert_eq!(body["payment_details"]["payment_method"], "card");
}
#[tokio::test]
async fn update_puts_to_the_update_path() {
let (client, mock) = client_with(vec![Step::ok(SUB_JSON)]);
let req = UpdateSubscriptionRequest {
plan_id: "plan_2".to_string(),
item_price_id: "price_2".to_string(),
};
client.subscriptions().update("sub_1", &req).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(seen[0].url, "https://api.test/subscriptions/sub_1/update");
}
#[tokio::test]
async fn pause_resume_cancel_send_an_empty_object_body_by_default() {
let (client, mock) = client_with(vec![
Step::ok(r#"{"id":"sub_1","status":"paused"}"#),
Step::ok(r#"{"id":"sub_1","status":"active"}"#),
Step::ok(r#"{"id":"sub_1","status":"cancelled"}"#),
]);
let subs = client.subscriptions();
subs.pause("sub_1", None).await.unwrap();
subs.resume("sub_1", None).await.unwrap();
subs.cancel("sub_1", None).await.unwrap();
let seen = mock.seen.lock().unwrap();
let paths = [
"https://api.test/subscriptions/sub_1/pause",
"https://api.test/subscriptions/sub_1/resume",
"https://api.test/subscriptions/sub_1/cancel",
];
for (i, path) in paths.iter().enumerate() {
assert_eq!(seen[i].url, *path);
assert_eq!(
seen[i].body_json(),
json!({}),
"call {i} must carry an empty JSON object body"
);
}
}
#[tokio::test]
async fn cancel_serializes_scheduling_options() {
let (client, mock) = client_with(vec![Step::ok(r#"{"id":"sub_1","status":"cancelled"}"#)]);
let req = CancelSubscriptionRequest {
cancel_option: Some("end_of_term".to_string()),
cancel_reason_code: Some("too_expensive".to_string()),
..Default::default()
};
client
.subscriptions()
.cancel("sub_1", Some(&req))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let body = seen[0].body_json();
assert_eq!(body["cancel_option"], "end_of_term");
assert_eq!(body["cancel_reason_code"], "too_expensive");
}
#[tokio::test]
async fn read_endpoints_serialize_their_queries() {
let (client, mock) = client_with(vec![
Step::ok("[]"),
Step::ok(r#"{"amount":999,"currency":"EUR","line_items":[]}"#),
Step::ok("[]"),
]);
let subs = client.subscriptions();
subs.list(Some(&SubscriptionListParams {
limit: Some(10),
offset: Some(20),
}))
.await
.unwrap();
subs.estimate(&SubscriptionEstimateParams::new("price_1"))
.await
.unwrap();
subs.items(&SubscriptionItemsParams::new("plan"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
seen[0].url,
"https://api.test/subscriptions/list?limit=10&offset=20"
);
assert_eq!(
seen[1].url,
"https://api.test/subscriptions/estimate?item_price_id=price_1"
);
assert_eq!(
seen[2].url,
"https://api.test/subscriptions/items?item_type=plan"
);
}
#[test]
fn create_request_named_fields_are_complete() {
let req = CreateSubscriptionRequest {
item_price_id: "price_1".to_string(),
customer_id: "cus_1".to_string(),
payment_details: CreateSubscriptionPaymentDetails {
return_url: "https://example.com/r".to_string(),
setup_future_usage: Some(SetupFutureUsage::OffSession),
capture_method: Some(CaptureMethod::Automatic),
authentication_type: Some(AuthenticationType::NoThreeDs),
payment_type: Some("recurring".to_string()),
},
merchant_reference_id: Some("ref_1".to_string()),
plan_id: Some("plan_1".to_string()),
coupon_code: Some("SAVE10".to_string()),
billing: Some(Address::default()),
shipping: Some(Address::default()),
extra: serde_json::Map::new(),
};
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().unwrap().keys() {
assert!(
CREATE_SUBSCRIPTION_REQUEST_NAMED.contains(&key.as_str()),
"CREATE_SUBSCRIPTION_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn create_and_confirm_request_named_fields_are_complete() {
let req = CreateAndConfirmSubscriptionRequest {
plan_id: Some("plan_1".to_string()),
coupon_code: Some("SAVE10".to_string()),
billing: Some(Address::default()),
shipping: Some(Address::default()),
merchant_reference_id: Some("ref_1".to_string()),
..create_and_confirm_request()
};
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().unwrap().keys() {
assert!(
CREATE_AND_CONFIRM_SUBSCRIPTION_REQUEST_NAMED.contains(&key.as_str()),
"CREATE_AND_CONFIRM_SUBSCRIPTION_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn create_validate_rejects_colliding_extra_key() {
let mut req = CreateSubscriptionRequest::default();
req.extra.insert("customer_id".to_string(), json!("cus_2"));
assert!(matches!(
req.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
}