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::common::{Currency, DisputeStage, DisputeStatus};
use crate::core::models::dispute::DisputeResponse;
use crate::core::models::dispute_workspace::{
DisputeBulkAcceptResponse, DisputeBulkBlockBuyerResponse, DisputeBulkPreviewResponse,
DisputeRefundAssociationsResponse, DisputeRefundDeclaration, DisputeWorkspaceAggregate,
DisputeWorkspaceExport, DisputeWorkspaceFilters, DisputeWorkspaceResponse,
};
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, params: Option<&DisputeListParams>) -> Result<Vec<DisputeResponse>> {
let query = params.map(DisputeListParams::to_query).unwrap_or_default();
self.inner
.request(HttpMethod::Get, "/disputes/list", None, &query, 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 list_by_profile(
&self,
params: Option<&DisputeListParams>,
) -> Result<Vec<DisputeResponse>> {
let query = params.map(DisputeListParams::to_query).unwrap_or_default();
self.inner
.request(
HttpMethod::Get,
"/disputes/profile/list",
None,
&query,
None,
)
.await
}
pub async fn filters(&self, query: &[(&str, String)]) -> Result<Value> {
self.inner
.request(HttpMethod::Get, "/disputes/filter", None, query, None)
.await
}
pub async fn filters_by_profile(&self, query: &[(&str, String)]) -> Result<Value> {
self.inner
.request(
HttpMethod::Get,
"/disputes/profile/filter",
None,
query,
None,
)
.await
}
pub async fn aggregate(&self, query: &[(&str, String)]) -> Result<Value> {
self.inner
.request(HttpMethod::Get, "/disputes/aggregate", None, query, None)
.await
}
pub async fn aggregate_by_profile(&self, query: &[(&str, String)]) -> Result<Value> {
self.inner
.request(
HttpMethod::Get,
"/disputes/profile/aggregate",
None,
query,
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
}
pub async fn workspace(
&self,
params: Option<&DisputeWorkspaceParams>,
) -> Result<DisputeWorkspaceResponse> {
let query = workspace_query(params);
self.inner
.request(HttpMethod::Get, "/disputes/workspace", None, &query, None)
.await
}
pub async fn workspace_filters(
&self,
params: Option<&DisputeWorkspaceParams>,
) -> Result<DisputeWorkspaceFilters> {
let query = workspace_query(params);
self.inner
.request(
HttpMethod::Get,
"/disputes/workspace/filters",
None,
&query,
None,
)
.await
}
pub async fn workspace_aggregate(
&self,
params: Option<&DisputeWorkspaceParams>,
) -> Result<DisputeWorkspaceAggregate> {
let query = workspace_query(params);
self.inner
.request(
HttpMethod::Get,
"/disputes/workspace/aggregate",
None,
&query,
None,
)
.await
}
pub async fn workspace_export(
&self,
params: Option<&DisputeWorkspaceParams>,
) -> Result<DisputeWorkspaceExport> {
let query = workspace_query(params);
let export: DisputeWorkspaceExport = self
.inner
.request(
HttpMethod::Get,
"/disputes/workspace/export",
None,
&query,
None,
)
.await?;
let rows = export.data.len();
if i64::try_from(rows).ok() != Some(export.total_count) {
return Err(DelopayError::Decode(format!(
"dispute workspace export is incomplete: {rows} of {} cases arrived",
export.total_count
)));
}
Ok(export)
}
pub async fn workspace_export_pdf(
&self,
params: Option<&DisputeWorkspaceParams>,
) -> Result<Vec<u8>> {
let query = workspace_query(params);
self.inner
.request_bytes(
HttpMethod::Get,
"/disputes/workspace/export",
&query,
"application/pdf",
)
.await
}
pub async fn bulk_preview(
&self,
params: &DisputeBulkPreviewRequest,
) -> Result<DisputeBulkPreviewResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request_body_keyed(
HttpMethod::Post,
"/disputes/workspace/bulk/preview",
Some(&body),
None,
)
.await
}
pub async fn bulk_accept(
&self,
params: &DisputeBulkAcceptRequest,
) -> Result<DisputeBulkAcceptResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request_body_keyed(
HttpMethod::Post,
"/disputes/workspace/bulk/accept",
Some(&body),
None,
)
.await
}
pub async fn bulk_block_buyer(
&self,
params: &DisputeBulkBlockBuyerRequest,
) -> Result<DisputeBulkBlockBuyerResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request_body_keyed(
HttpMethod::Post,
"/disputes/workspace/bulk/block-buyer",
Some(&body),
None,
)
.await
}
pub async fn reconcile(
&self,
dispute_id: &str,
params: &DisputeReconcileRequest,
) -> Result<DisputeResponse> {
let path = format!("/disputes/{}/reconcile", encode_segment(dispute_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed(HttpMethod::Post, &path, Some(&body), None)
.await
}
pub async fn list_refund_associations(
&self,
dispute_id: &str,
) -> Result<DisputeRefundAssociationsResponse> {
let path = format!(
"/disputes/{}/refund-associations",
encode_segment(dispute_id)
);
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn set_refund_association(
&self,
dispute_id: &str,
params: &DisputeRefundAssociationRequest,
) -> Result<DisputeRefundDeclaration> {
params.validate()?;
let path = format!(
"/disputes/{}/refund-associations",
encode_segment(dispute_id)
);
let body = to_json_vec(params)?;
self.inner
.request_body_keyed(HttpMethod::Put, &path, Some(&body), None)
.await
}
}
#[derive(Debug, Clone, Default)]
pub struct DisputeListParams {
pub limit: Option<i64>,
pub offset: Option<i64>,
pub dispute_id: Option<String>,
pub payment_id: Option<String>,
pub profile_id: Option<String>,
pub dispute_status: Option<DisputeStatus>,
pub dispute_stage: Option<DisputeStage>,
pub reason: Option<String>,
pub connector: Option<String>,
pub connector_dispute_id: Option<String>,
pub currency: Option<Currency>,
pub start_time: Option<String>,
pub end_time: Option<String>,
pub test_mode: Option<bool>,
}
impl DisputeListParams {
pub(crate) 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()));
}
if let Some(v) = &self.dispute_id {
q.push(("dispute_id", v.clone()));
}
if let Some(v) = &self.payment_id {
q.push(("payment_id", v.clone()));
}
if let Some(v) = &self.profile_id {
q.push(("profile_id", v.clone()));
}
if let Some(v) = &self.dispute_status {
q.push(("dispute_status", v.clone()));
}
if let Some(v) = &self.dispute_stage {
q.push(("dispute_stage", v.clone()));
}
if let Some(v) = &self.reason {
q.push(("reason", v.clone()));
}
if let Some(v) = &self.connector {
q.push(("connector", v.clone()));
}
if let Some(v) = &self.connector_dispute_id {
q.push(("connector_dispute_id", v.clone()));
}
if let Some(v) = &self.currency {
q.push(("currency", v.clone()));
}
if let Some(v) = &self.start_time {
q.push(("start_time", v.clone()));
}
if let Some(v) = &self.end_time {
q.push(("end_time", v.clone()));
}
if let Some(v) = self.test_mode {
q.push(("test_mode", v.to_string()));
}
q
}
}
#[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(())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum DisputeWorkspaceSortBy {
ReceivedAt,
Amount,
RespondBy,
}
impl DisputeWorkspaceSortBy {
pub fn as_str(self) -> &'static str {
match self {
Self::ReceivedAt => "received_at",
Self::Amount => "amount",
Self::RespondBy => "respond_by",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum SortDirection {
Ascending,
Descending,
}
impl SortDirection {
pub fn as_str(self) -> &'static str {
match self {
Self::Ascending => "asc",
Self::Descending => "desc",
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct DisputeWorkspaceParams {
#[serde(skip_serializing_if = "Option::is_none")]
pub search: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub native_dispute_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_dispute_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub project_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_connector_id: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty", serialize_with = "csv")]
pub connector: Vec<String>,
#[serde(skip_serializing_if = "Vec::is_empty", serialize_with = "csv")]
pub currency: Vec<String>,
#[serde(skip_serializing_if = "Vec::is_empty", serialize_with = "csv")]
pub dispute_status: Vec<String>,
#[serde(skip_serializing_if = "Vec::is_empty", serialize_with = "csv")]
pub dispute_stage: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub test_mode: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub offset: Option<u32>,
#[serde(
skip_serializing_if = "Option::is_none",
serialize_with = "sort_by_token"
)]
pub sort_by: Option<DisputeWorkspaceSortBy>,
#[serde(
skip_serializing_if = "Option::is_none",
serialize_with = "sort_order_token"
)]
pub sort_order: Option<SortDirection>,
}
#[allow(clippy::ptr_arg)]
fn csv<S: serde::Serializer>(
values: &Vec<String>,
serializer: S,
) -> std::result::Result<S::Ok, S::Error> {
serializer.serialize_str(&values.join(","))
}
fn sort_by_token<S: serde::Serializer>(
value: &Option<DisputeWorkspaceSortBy>,
serializer: S,
) -> std::result::Result<S::Ok, S::Error> {
match value {
Some(v) => serializer.serialize_str(v.as_str()),
None => serializer.serialize_none(),
}
}
fn sort_order_token<S: serde::Serializer>(
value: &Option<SortDirection>,
serializer: S,
) -> std::result::Result<S::Ok, S::Error> {
match value {
Some(v) => serializer.serialize_str(v.as_str()),
None => serializer.serialize_none(),
}
}
impl DisputeWorkspaceParams {
pub fn new() -> Self {
Self::default()
}
pub(crate) fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
let mut text = |key: &'static str, value: &Option<String>| {
if let Some(v) = value {
q.push((key, v.clone()));
}
};
text("search", &self.search);
text("native_dispute_id", &self.native_dispute_id);
text("payment_id", &self.payment_id);
text("subscription_dispute_id", &self.subscription_dispute_id);
text("profile_id", &self.profile_id);
text("project_id", &self.project_id);
text("merchant_connector_id", &self.merchant_connector_id);
for (key, values) in [
("connector", &self.connector),
("currency", &self.currency),
("dispute_status", &self.dispute_status),
("dispute_stage", &self.dispute_stage),
] {
if !values.is_empty() {
q.push((key, values.join(",")));
}
}
if let Some(v) = &self.reason {
q.push(("reason", v.clone()));
}
if let Some(v) = &self.start_time {
q.push(("start_time", v.clone()));
}
if let Some(v) = &self.end_time {
q.push(("end_time", v.clone()));
}
if let Some(v) = self.test_mode {
q.push(("test_mode", v.to_string()));
}
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
if let Some(v) = self.offset {
q.push(("offset", v.to_string()));
}
if let Some(v) = self.sort_by {
q.push(("sort_by", v.as_str().to_string()));
}
if let Some(v) = self.sort_order {
q.push(("sort_order", v.as_str().to_string()));
}
q
}
}
fn workspace_query(params: Option<&DisputeWorkspaceParams>) -> Vec<(&'static str, String)> {
params
.map(DisputeWorkspaceParams::to_query)
.unwrap_or_default()
}
fn reject_extra_collisions(
extra: &serde_json::Map<String, Value>,
named: &[&str],
type_name: &str,
) -> Result<()> {
for key in extra.keys() {
if named.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on {type_name}"
)));
}
}
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum DisputeBulkAction {
Accept,
BlockBuyer,
}
#[derive(Debug, Clone, Serialize)]
pub struct DisputeBulkPreviewRequest {
pub action: DisputeBulkAction,
#[serde(skip_serializing_if = "Option::is_none")]
pub ids: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<DisputeWorkspaceParams>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl DisputeBulkPreviewRequest {
pub fn for_ids(action: DisputeBulkAction, ids: Vec<String>) -> Self {
Self {
action,
ids: Some(ids),
filters: None,
extra: serde_json::Map::new(),
}
}
pub fn for_filters(action: DisputeBulkAction, filters: DisputeWorkspaceParams) -> Self {
Self {
action,
ids: None,
filters: Some(filters),
extra: serde_json::Map::new(),
}
}
}
const DISPUTE_BULK_PREVIEW_REQUEST_NAMED: &[&str] = &["action", "ids", "filters"];
impl ValidateRequest for DisputeBulkPreviewRequest {
fn validate(&self) -> Result<()> {
reject_extra_collisions(
&self.extra,
DISPUTE_BULK_PREVIEW_REQUEST_NAMED,
"DisputeBulkPreviewRequest",
)
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct DisputeBulkAcceptRequest {
pub ids: Vec<String>,
pub note: String,
pub request_id: String,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl DisputeBulkAcceptRequest {
pub fn new(ids: Vec<String>, note: impl Into<String>, request_id: impl Into<String>) -> Self {
Self {
ids,
note: note.into(),
request_id: request_id.into(),
extra: serde_json::Map::new(),
}
}
}
const DISPUTE_BULK_ACCEPT_REQUEST_NAMED: &[&str] = &["ids", "note", "request_id"];
impl ValidateRequest for DisputeBulkAcceptRequest {
fn validate(&self) -> Result<()> {
reject_extra_collisions(
&self.extra,
DISPUTE_BULK_ACCEPT_REQUEST_NAMED,
"DisputeBulkAcceptRequest",
)
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct DisputeBulkBlockBuyerRequest {
pub ids: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub note: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl DisputeBulkBlockBuyerRequest {
pub fn new(ids: Vec<String>) -> Self {
Self {
ids,
..Default::default()
}
}
#[must_use]
pub fn note(mut self, note: impl Into<String>) -> Self {
self.note = Some(note.into());
self
}
}
const DISPUTE_BULK_BLOCK_BUYER_REQUEST_NAMED: &[&str] = &["ids", "note"];
impl ValidateRequest for DisputeBulkBlockBuyerRequest {
fn validate(&self) -> Result<()> {
reject_extra_collisions(
&self.extra,
DISPUTE_BULK_BLOCK_BUYER_REQUEST_NAMED,
"DisputeBulkBlockBuyerRequest",
)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(tag = "action", rename_all = "snake_case")]
#[non_exhaustive]
pub enum DisputeReconcileRequest {
CorrectRate {
exchange_rate: String,
},
Settle {
settled_amount: i64,
reason: String,
},
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct DisputeRefundAssociationRequest {
pub refund_id: String,
pub allocated_amount: Option<i64>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl DisputeRefundAssociationRequest {
pub fn allocate(refund_id: impl Into<String>, allocated_amount: i64) -> Self {
Self {
refund_id: refund_id.into(),
allocated_amount: Some(allocated_amount),
extra: serde_json::Map::new(),
}
}
pub fn clear(refund_id: impl Into<String>) -> Self {
Self {
refund_id: refund_id.into(),
allocated_amount: None,
extra: serde_json::Map::new(),
}
}
}
const DISPUTE_REFUND_ASSOCIATION_REQUEST_NAMED: &[&str] = &["refund_id", "allocated_amount"];
impl ValidateRequest for DisputeRefundAssociationRequest {
fn validate(&self) -> Result<()> {
reject_extra_collisions(
&self.extra,
DISPUTE_REFUND_ASSOCIATION_REQUEST_NAMED,
"DisputeRefundAssociationRequest",
)
}
}
#[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 list_and_list_by_profile_serialize_the_same_filters() {
let (client, mock) = client_with(vec![Step::ok("[]"), Step::ok("[]")]);
let params = DisputeListParams {
limit: Some(10),
dispute_status: Some("dispute_opened".to_string()),
test_mode: Some(true),
..Default::default()
};
client.disputes().list(Some(¶ms)).await.unwrap();
client
.disputes()
.list_by_profile(Some(¶ms))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
(
"GET",
"https://api.test/disputes/list?limit=10&dispute_status=dispute_opened&test_mode=true"
)
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
(
"GET",
"https://api.test/disputes/profile/list?limit=10&dispute_status=dispute_opened&test_mode=true"
)
);
}
#[tokio::test]
async fn list_without_params_sends_no_query() {
let (client, mock) = client_with(vec![Step::ok("[]")]);
client.disputes().list(None).await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].url, "https://api.test/disputes/list");
}
#[tokio::test]
async fn filter_and_aggregate_paths_are_distinct() {
let (client, mock) = client_with(vec![
Step::ok("{}"),
Step::ok("{}"),
Step::ok("{}"),
Step::ok("{}"),
]);
let query = [("start_time", "2026-01-01T00:00:00Z".to_string())];
client.disputes().filters(&[]).await.unwrap();
client.disputes().filters_by_profile(&[]).await.unwrap();
client.disputes().aggregate(&query).await.unwrap();
client
.disputes()
.aggregate_by_profile(&query)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("GET", "https://api.test/disputes/filter")
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("GET", "https://api.test/disputes/profile/filter")
);
assert_eq!(
(seen[2].method, seen[2].url.as_str()),
(
"GET",
"https://api.test/disputes/aggregate?start_time=2026-01-01T00:00:00Z"
)
);
assert_eq!(
(seen[3].method, seen[3].url.as_str()),
(
"GET",
"https://api.test/disputes/profile/aggregate?start_time=2026-01-01T00:00:00Z"
)
);
}
#[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")
);
}
const WORKSPACE_ROW_JSON: &str = r#"{
"id": "dp_1", "origin": "bank_card_issuer", "category": "bank_chargeback",
"native_dispute_id": "dp_1", "payment_id": "pay_1", "connector": "stripe",
"connector_dispute_id": "du_1", "currency": "EUR", "amount_minor": "500",
"dispute_status": "dispute_opened", "created_at": "2026-01-01T00:00:00Z",
"updated_at": "2026-01-02T00:00:00Z", "available_actions": ["accept"],
"row_surprise": 1
}"#;
fn workspace_filters() -> DisputeWorkspaceParams {
DisputeWorkspaceParams {
profile_id: Some("pro_1".to_string()),
connector: vec!["stripe".to_string(), "paypal".to_string()],
dispute_status: vec!["dispute_opened".to_string()],
test_mode: Some(false),
limit: Some(25),
sort_by: Some(DisputeWorkspaceSortBy::RespondBy),
sort_order: Some(SortDirection::Ascending),
..Default::default()
}
}
#[tokio::test]
async fn workspace_joins_list_filters_as_csv_in_the_query() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"data":[{WORKSPACE_ROW_JSON}],"has_more":true,"page_surprise":2}}"#
))]);
let page = client
.disputes()
.workspace(Some(&workspace_filters()))
.await
.unwrap();
assert!(page.has_more);
assert_eq!(page.data[0].connector_dispute_id, "du_1");
assert_eq!(page.data[0].available_actions, ["accept"]);
assert_eq!(page.data[0].extra["row_surprise"], 1);
assert_eq!(page.extra["page_surprise"], 2);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/disputes/workspace?profile_id=pro_1&connector=stripe,paypal\
&dispute_status=dispute_opened&test_mode=false&limit=25\
&sort_by=respond_by&sort_order=asc"
);
}
#[tokio::test]
async fn workspace_filters_gets_the_filters_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"connector":["stripe"],"currency":["EUR"],"dispute_status":[],"dispute_stage":["dispute"],"x":1}"#,
)]);
let filters = client.disputes().workspace_filters(None).await.unwrap();
assert_eq!(filters.connector, ["stripe"]);
assert_eq!(filters.dispute_stage, ["dispute"]);
assert_eq!(filters.extra["x"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/disputes/workspace/filters");
}
#[tokio::test]
async fn workspace_aggregate_gets_the_aggregate_path() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"total_count":3,"status_with_count":{"dispute_opened":2,"unknown":1},"unknown_count":1,"x":1}"#,
)]);
let params = DisputeWorkspaceParams {
currency: vec!["EUR".to_string(), "USD".to_string()],
..Default::default()
};
let agg = client
.disputes()
.workspace_aggregate(Some(¶ms))
.await
.unwrap();
assert_eq!(agg.total_count, 3);
assert_eq!(agg.status_with_count["dispute_opened"], 2);
assert_eq!(agg.unknown_count, 1);
assert_eq!(agg.extra["x"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/disputes/workspace/aggregate?currency=EUR,USD"
);
}
#[tokio::test]
async fn workspace_export_returns_a_complete_set() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"data":[{WORKSPACE_ROW_JSON}],"total_count":1,"x":1}}"#
))]);
let export = client.disputes().workspace_export(None).await.unwrap();
assert_eq!(export.total_count, 1);
assert_eq!(export.data[0].id, "dp_1");
assert_eq!(export.extra["x"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/disputes/workspace/export");
assert_eq!(seen[0].header("accept"), Some("application/json"));
}
#[tokio::test]
async fn workspace_export_refuses_a_short_set() {
let (client, _mock) = client_with(vec![Step::ok(&format!(
r#"{{"data":[{WORKSPACE_ROW_JSON}],"total_count":2}}"#
))]);
match client.disputes().workspace_export(None).await.unwrap_err() {
DelopayError::Decode(msg) => assert!(msg.contains("1 of 2"), "{msg}"),
other => panic!("expected Decode, got {other:?}"),
}
}
#[tokio::test]
async fn workspace_export_pdf_asks_for_a_pdf_and_returns_the_bytes() {
let (client, mock) = client_with(vec![Step::ok("%PDF-1.7")]);
let params = DisputeWorkspaceParams {
search: Some("du_1".to_string()),
..Default::default()
};
let bytes = client
.disputes()
.workspace_export_pdf(Some(¶ms))
.await
.unwrap();
assert_eq!(bytes, b"%PDF-1.7");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/disputes/workspace/export?search=du_1"
);
assert_eq!(seen[0].header("accept"), Some("application/pdf"));
}
#[tokio::test]
async fn bulk_preview_sends_filters_with_csv_values() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"action":"accept","selected_count":1,
"eligible":[{"id":"dp_1","connector":"stripe","connector_dispute_id":"du_1","currency":"EUR","amount_minor":"500"}],
"ineligible":[{"id":"pp_1","connector":"paypal","reason":"closed"}],
"totals":[{"currency":"EUR","amount_minor":"500","count":1,"unpriced_count":0}],
"truncated":false,"max_cases":1000,"max_run_cases":50,"x":1}"#,
)]);
let req = DisputeBulkPreviewRequest::for_filters(
DisputeBulkAction::Accept,
DisputeWorkspaceParams {
connector: vec!["stripe".to_string(), "paypal".to_string()],
test_mode: Some(true),
..Default::default()
},
);
let preview = client.disputes().bulk_preview(&req).await.unwrap();
assert_eq!(preview.eligible[0].connector_dispute_id, "du_1");
assert_eq!(preview.ineligible[0].reason, "closed");
assert_eq!(preview.totals[0].count, 1);
assert_eq!(preview.max_run_cases, 50);
assert_eq!(preview.extra["x"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/disputes/workspace/bulk/preview"
);
assert_eq!(
seen[0].body_json(),
json!({
"action": "accept",
"filters": {"connector": "stripe,paypal", "test_mode": true}
})
);
}
#[tokio::test]
async fn bulk_accept_posts_the_ids_and_is_not_retried_on_5xx() {
let (client, mock) = crate::http::mock::client_with_retries(
vec![Step::status(
503,
r#"{"error":{"type":"api","message":"down"}}"#,
)],
2,
);
let req = DisputeBulkAcceptRequest::new(vec!["dp_1".to_string()], "refunded", "req_1");
client.disputes().bulk_accept(&req).await.unwrap_err();
assert_eq!(mock.call_count(), 1);
let seen = mock.seen.lock().unwrap();
assert!(!seen[0].had_idempotency_key());
}
#[tokio::test]
async fn bulk_accept_decodes_each_result() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"results":[{"id":"dp_1","connector":"stripe","outcome":"unknown","error_code":"CE_00","x":1}]}"#,
)]);
let req = DisputeBulkAcceptRequest::new(vec!["dp_1".to_string()], "refunded", "req_1");
let out = client.disputes().bulk_accept(&req).await.unwrap();
assert_eq!(out.results[0].outcome, "unknown");
assert_eq!(out.results[0].error_code.as_deref(), Some("CE_00"));
assert_eq!(out.results[0].extra["x"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/disputes/workspace/bulk/accept"
);
assert_eq!(
seen[0].body_json(),
json!({"ids": ["dp_1"], "note": "refunded", "request_id": "req_1"})
);
}
#[tokio::test]
async fn bulk_block_buyer_posts_the_ids_and_redacts_identifier_values() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"results":[{"id":"dp_1","payment_id":"pay_1","outcome":"blocked",
"identifiers":[{"kind":"email","value":"buyer@example.com","state":"added","entry_id":"bbl_1"}],
"unattributed":["device_id"],"x":1}]}"#,
)]);
let req = DisputeBulkBlockBuyerRequest::new(vec!["dp_1".to_string()]).note("fraud");
let out = client.disputes().bulk_block_buyer(&req).await.unwrap();
let result = &out.results[0];
assert_eq!(result.outcome, "blocked");
assert_eq!(result.identifiers[0].value, "buyer@example.com");
assert_eq!(result.unattributed, ["device_id"]);
assert_eq!(result.extra["x"], 1);
assert!(!format!("{out:?}").contains("buyer@example.com"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/disputes/workspace/bulk/block-buyer"
);
assert_eq!(
seen[0].body_json(),
json!({"ids": ["dp_1"], "note": "fraud"})
);
}
#[tokio::test]
async fn reconcile_posts_the_tagged_action() {
let (client, mock) = client_with(vec![Step::ok(DISPUTE_JSON), Step::ok(DISPUTE_JSON)]);
client
.disputes()
.reconcile(
"dp/1",
&DisputeReconcileRequest::CorrectRate {
exchange_rate: "0.92010000".to_string(),
},
)
.await
.unwrap();
client
.disputes()
.reconcile(
"dp_1",
&DisputeReconcileRequest::Settle {
settled_amount: 980,
reason: "statement".to_string(),
},
)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/disputes/dp%2F1/reconcile");
assert_eq!(
seen[0].body_json(),
json!({"action": "correct_rate", "exchange_rate": "0.92010000"})
);
assert_eq!(
seen[1].body_json(),
json!({"action": "settle", "settled_amount": 980, "reason": "statement"})
);
}
const ASSOCIATION_JSON: &str = r#"{
"merchant_id": "mer_1", "dispute_id": "dp_1", "refund_id": "ref_1",
"payment_id": "pay_1", "merchant_connector_id": "mca_1", "currency": "EUR",
"test_mode": false, "allocated_amount": 500, "declared_by": "user_1",
"provider_reference": null, "created_at": "2026-01-01T00:00:00Z",
"modified_at": "2026-01-01T00:00:00Z", "x": 1
}"#;
#[tokio::test]
async fn list_refund_associations_gets_the_encoded_path() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"associations":[{ASSOCIATION_JSON}]}}"#
))]);
let out = client
.disputes()
.list_refund_associations("dp/1")
.await
.unwrap();
assert_eq!(out.associations[0].allocated_amount, Some(500));
assert_eq!(out.associations[0].refund_id.as_deref(), Some("ref_1"));
assert_eq!(out.associations[0].extra["x"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/disputes/dp%2F1/refund-associations"
);
}
#[tokio::test]
async fn set_refund_association_puts_and_sends_a_null_to_clear() {
let (client, mock) = client_with(vec![Step::ok(ASSOCIATION_JSON)]);
let out = client
.disputes()
.set_refund_association("dp_1", &DisputeRefundAssociationRequest::clear("ref_1"))
.await
.unwrap();
assert_eq!(out.refund_id, "ref_1");
assert_eq!(out.extra["x"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/disputes/dp_1/refund-associations"
);
assert_eq!(
seen[0].body_json(),
json!({"refund_id": "ref_1", "allocated_amount": null})
);
}
#[test]
fn dispute_bulk_preview_request_named_fields_are_complete() {
let mut req = DisputeBulkPreviewRequest::for_ids(
DisputeBulkAction::BlockBuyer,
vec!["dp_1".to_string()],
);
req.filters = Some(DisputeWorkspaceParams::new());
assert_named_complete(&req, DISPUTE_BULK_PREVIEW_REQUEST_NAMED);
}
#[test]
fn dispute_bulk_accept_request_named_fields_are_complete() {
let req = DisputeBulkAcceptRequest::new(vec!["dp_1".to_string()], "n", "r");
assert_named_complete(&req, DISPUTE_BULK_ACCEPT_REQUEST_NAMED);
}
#[test]
fn dispute_bulk_block_buyer_request_named_fields_are_complete() {
let req = DisputeBulkBlockBuyerRequest::new(vec!["dp_1".to_string()]).note("n");
assert_named_complete(&req, DISPUTE_BULK_BLOCK_BUYER_REQUEST_NAMED);
}
#[test]
fn dispute_refund_association_request_named_fields_are_complete() {
let req = DisputeRefundAssociationRequest::allocate("ref_1", 500);
assert_named_complete(&req, DISPUTE_REFUND_ASSOCIATION_REQUEST_NAMED);
}
#[test]
fn bulk_accept_validate_rejects_colliding_extra_key() {
let mut req = DisputeBulkAcceptRequest::new(vec![], "n", "r");
req.extra.insert("request_id".to_string(), json!("other"));
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("request_id")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
fn assert_named_complete<T: Serialize>(req: &T, named: &[&str]) {
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
named.contains(&key.as_str()),
"NAMED is missing wire key `{key}`"
);
}
}
#[tokio::test]
async fn writes_ignore_the_client_wide_idempotency_key() {
let steps = (0..5)
.map(|_| Step::status(503, r#"{"error":{"message":"down"}}"#))
.collect();
let (client, mock) = crate::http::mock::client_with_retries(steps, 2);
let client = client.with_idempotency_key("client-key");
client
.disputes()
.bulk_preview(&DisputeBulkPreviewRequest::for_ids(
DisputeBulkAction::Accept,
vec!["dp_1".to_string()],
))
.await
.unwrap_err();
client
.disputes()
.bulk_accept(&DisputeBulkAcceptRequest::new(
vec!["dp_1".to_string()],
"n",
"req_1",
))
.await
.unwrap_err();
client
.disputes()
.bulk_block_buyer(&DisputeBulkBlockBuyerRequest::new(vec!["dp_1".to_string()]))
.await
.unwrap_err();
client
.disputes()
.reconcile(
"dp_1",
&DisputeReconcileRequest::Settle {
settled_amount: 1,
reason: "r".to_string(),
},
)
.await
.unwrap_err();
client
.disputes()
.set_refund_association(
"dp_1",
&DisputeRefundAssociationRequest::allocate("ref_1", 1),
)
.await
.unwrap_err();
assert_eq!(mock.call_count(), 5);
for seen in mock.seen.lock().unwrap().iter() {
assert!(
!seen.had_idempotency_key(),
"{} sent the client key",
seen.url
);
}
}
}