use std::sync::Arc;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::{DelopayError, Result};
use crate::core::models::dispute::DisputeResponse;
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct Disputes {
inner: Arc<Inner>,
}
impl Disputes {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn retrieve(&self, dispute_id: &str) -> Result<DisputeResponse> {
let path = format!("/disputes/{}", encode_segment(dispute_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn list(&self) -> Result<Vec<DisputeResponse>> {
self.inner
.request(HttpMethod::Get, "/disputes/list", None, &[], None)
.await
}
pub async fn accept(&self, dispute_id: &str) -> Result<DisputeResponse> {
let path = format!("/disputes/accept/{}", encode_segment(dispute_id));
self.inner
.request(HttpMethod::Post, &path, None, &[], None)
.await
}
pub async fn submit_evidence(
&self,
params: &DisputeEvidenceRequest,
) -> Result<DisputeResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/disputes/evidence",
Some(&body),
&[],
None,
)
.await
}
pub async fn attach_evidence(
&self,
params: &DisputeEvidenceRequest,
) -> Result<DisputeResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Put,
"/disputes/evidence",
Some(&body),
&[],
None,
)
.await
}
pub async fn retrieve_evidence(&self, dispute_id: &str) -> Result<DisputeEvidenceRequest> {
let path = format!("/disputes/evidence/{}", encode_segment(dispute_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn delete_evidence(
&self,
params: &DisputeEvidenceRequest,
) -> Result<DisputeResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Delete,
"/disputes/evidence",
Some(&body),
&[],
None,
)
.await
}
pub async fn fetch_from_connector(
&self,
connector_dispute_id: &str,
) -> Result<DisputeResponse> {
let path = format!("/disputes/{}/fetch", encode_segment(connector_dispute_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DisputeEvidenceRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cancel_dispute: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub customer_email_body: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub customer_email_address: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub customer_name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub customer_signature: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub product_description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub receipt: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub refund_policy: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub refund_policy_disclosure: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub refund_refusal_explanation: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub service_date: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub service_documentation: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub shipping_address: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub shipping_carrier: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub shipping_date: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub shipping_documentation: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub shipping_tracking_number: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub uncategorized_file: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub uncategorized_text: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub access_activity_log: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub billing_address: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cancellation_policy: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cancellation_policy_disclosure: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cancellation_rebuttal: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub customer_communication: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub customer_purchase_ip: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub duplicate_charge_documentation: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub duplicate_charge_explanation: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub duplicate_charge_id: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
const DISPUTE_EVIDENCE_REQUEST_NAMED: &[&str] = &[
"cancel_dispute",
"customer_email_body",
"customer_email_address",
"customer_name",
"customer_signature",
"product_description",
"receipt",
"refund_policy",
"refund_policy_disclosure",
"refund_refusal_explanation",
"service_date",
"service_documentation",
"shipping_address",
"shipping_carrier",
"shipping_date",
"shipping_documentation",
"shipping_tracking_number",
"uncategorized_file",
"uncategorized_text",
"access_activity_log",
"billing_address",
"cancellation_policy",
"cancellation_policy_disclosure",
"cancellation_rebuttal",
"customer_communication",
"customer_purchase_ip",
"duplicate_charge_documentation",
"duplicate_charge_explanation",
"duplicate_charge_id",
];
impl ValidateRequest for DisputeEvidenceRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if DISPUTE_EVIDENCE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on DisputeEvidenceRequest"
)));
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const DISPUTE_JSON: &str = r#"{
"dispute_id": "dp_1", "payment_id": "pay_1", "attempt_id": "att_1",
"amount": "500", "currency": "EUR", "dispute_stage": "dispute",
"dispute_status": "dispute_opened", "connector": "stripe",
"connector_status": "needs_response", "connector_dispute_id": "du_1",
"is_already_refunded": false
}"#;
fn full_evidence_request() -> DisputeEvidenceRequest {
let text = |s: &str| Some(s.to_string());
DisputeEvidenceRequest {
cancel_dispute: Some(false),
customer_email_body: text("body"),
customer_email_address: text("a@example.com"),
customer_name: text("Ada"),
customer_signature: text("file_sig"),
product_description: text("widget"),
receipt: text("file_receipt"),
refund_policy: text("file_policy"),
refund_policy_disclosure: text("shown at checkout"),
refund_refusal_explanation: text("outside window"),
service_date: text("2026-01-01"),
service_documentation: text("file_service"),
shipping_address: text("Somestr. 1"),
shipping_carrier: text("DHL"),
shipping_date: text("2026-01-02"),
shipping_documentation: text("file_ship"),
shipping_tracking_number: text("TRACK1"),
uncategorized_file: text("file_misc"),
uncategorized_text: text("misc"),
access_activity_log: text("log"),
billing_address: text("Somestr. 1"),
cancellation_policy: text("file_cancel"),
cancellation_policy_disclosure: text("shown at checkout"),
cancellation_rebuttal: text("not cancelled"),
customer_communication: text("file_comm"),
customer_purchase_ip: text("203.0.113.7"),
duplicate_charge_documentation: text("file_dup"),
duplicate_charge_explanation: text("separate orders"),
duplicate_charge_id: text("pay_2"),
extra: serde_json::Map::new(),
}
}
#[test]
fn evidence_request_named_fields_are_complete() {
let value = serde_json::to_value(full_evidence_request()).unwrap();
let obj = value.as_object().expect("serializes to a JSON object");
for key in obj.keys() {
assert!(
DISPUTE_EVIDENCE_REQUEST_NAMED.contains(&key.as_str()),
"DISPUTE_EVIDENCE_REQUEST_NAMED is missing wire key `{key}` -- \
add it, or the extra-key collision guard silently stops \
covering this field"
);
}
}
#[test]
fn evidence_validate_rejects_colliding_extra_key() {
let mut req = DisputeEvidenceRequest::default();
req.extra.insert("receipt".to_string(), json!("file_x"));
assert!(matches!(
req.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
#[test]
fn evidence_round_trips_with_dispute_id_in_extra() {
let mut req = DisputeEvidenceRequest {
receipt: Some("file_receipt".to_string()),
..Default::default()
};
req.extra.insert("dispute_id".to_string(), json!("dp_1"));
let wire = serde_json::to_string(&req).unwrap();
let back: DisputeEvidenceRequest = serde_json::from_str(&wire).unwrap();
assert_eq!(back.receipt.as_deref(), Some("file_receipt"));
assert_eq!(back.extra["dispute_id"], "dp_1");
}
#[tokio::test]
async fn submit_uses_post_and_attach_uses_put_on_the_evidence_path() {
let (client, mock) = client_with(vec![Step::ok(DISPUTE_JSON), Step::ok(DISPUTE_JSON)]);
let req = DisputeEvidenceRequest {
receipt: Some("file_receipt".to_string()),
..Default::default()
};
client.disputes().submit_evidence(&req).await.unwrap();
client.disputes().attach_evidence(&req).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("POST", "https://api.test/disputes/evidence")
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("PUT", "https://api.test/disputes/evidence")
);
assert_eq!(seen[1].body_json()["receipt"], "file_receipt");
}
#[tokio::test]
async fn delete_evidence_sends_a_delete_with_a_body() {
let (client, mock) = client_with(vec![Step::ok(DISPUTE_JSON)]);
let mut req = DisputeEvidenceRequest::default();
req.extra.insert("dispute_id".to_string(), json!("dp_1"));
client.disputes().delete_evidence(&req).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(seen[0].url, "https://api.test/disputes/evidence");
assert_eq!(
seen[0].body_json()["dispute_id"],
"dp_1",
"DELETE must still carry the identifying body"
);
}
#[tokio::test]
async fn retrieve_evidence_and_connector_fetch_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(r#"{"receipt":"file_receipt","dispute_id":"dp_1"}"#),
Step::ok(DISPUTE_JSON),
]);
let evidence = client.disputes().retrieve_evidence("dp_1").await.unwrap();
assert_eq!(evidence.receipt.as_deref(), Some("file_receipt"));
client
.disputes()
.fetch_from_connector("du_1")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("GET", "https://api.test/disputes/evidence/dp_1")
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("GET", "https://api.test/disputes/du_1/fetch")
);
}
}