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::{ListResponse, RefundType};
use crate::core::models::refund::RefundResponse;
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct Refunds {
inner: Arc<Inner>,
}
impl Refunds {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn create(&self, params: &RefundCreateRequest) -> Result<RefundResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/refunds", Some(&body), &[], None)
.await
}
pub async fn create_idempotent(
&self,
params: &RefundCreateRequest,
idempotency_key: &str,
) -> Result<RefundResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/refunds",
Some(&body),
&[],
Some(idempotency_key),
)
.await
}
pub async fn retrieve(&self, refund_id: &str) -> Result<RefundResponse> {
let path = format!("/refunds/{}", encode_segment(refund_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update(
&self,
refund_id: &str,
params: &RefundUpdateRequest,
) -> Result<RefundResponse> {
let path = format!("/refunds/{}", encode_segment(refund_id));
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn list(&self, params: Option<&Value>) -> Result<ListResponse<RefundResponse>> {
let body = params
.cloned()
.unwrap_or_else(|| Value::Object(Default::default()));
let bytes = to_json_vec(&body)?;
self.inner
.request(HttpMethod::Post, "/refunds/list", Some(&bytes), &[], None)
.await
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct RefundCreateRequest {
pub payment_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub refund_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub refund_type: Option<RefundType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Value>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const REFUND_CREATE_REQUEST_NAMED: &[&str] = &[
"payment_id",
"refund_id",
"amount",
"reason",
"refund_type",
"metadata",
];
impl ValidateRequest for RefundCreateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if REFUND_CREATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on RefundCreateRequest"
)));
}
}
Ok(())
}
}
impl RefundCreateRequest {
pub fn new(payment_id: impl Into<String>) -> Self {
Self {
payment_id: payment_id.into(),
..Default::default()
}
}
pub fn amount(mut self, amount: i64) -> Self {
self.amount = Some(amount);
self
}
pub fn reason(mut self, reason: impl Into<String>) -> Self {
self.reason = Some(reason.into());
self
}
pub fn refund_type(mut self, refund_type: RefundType) -> Self {
self.refund_type = Some(refund_type);
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct RefundUpdateRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Value>,
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn full_refund_create_request() -> RefundCreateRequest {
RefundCreateRequest {
payment_id: "pay_1".to_string(),
refund_id: Some("ref_1".to_string()),
amount: Some(500),
reason: Some("requested_by_customer".to_string()),
refund_type: Some(RefundType::Instant),
metadata: Some(json!({"order_id": "o_1"})),
extra: serde_json::Map::new(),
}
}
#[test]
fn refund_create_request_named_fields_are_complete() {
let value = serde_json::to_value(full_refund_create_request()).unwrap();
let obj = value.as_object().expect("serializes to a JSON object");
for key in obj.keys() {
assert!(
REFUND_CREATE_REQUEST_NAMED.contains(&key.as_str()),
"REFUND_CREATE_REQUEST_NAMED is missing wire key `{key}` -- \
add it, or RefundCreateRequest's extra-key collision guard \
will silently stop covering this field"
);
}
}
#[test]
fn validate_rejects_extra_key_colliding_with_named_field() {
let mut req = RefundCreateRequest::new("pay_1");
req.extra.insert("amount".to_string(), json!(999));
let err = req.validate().unwrap_err();
match err {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("amount")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
}