use std::sync::Arc;
use serde::Serialize;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::Result;
use crate::core::models::chargeback_prevention::{
PreventionCaseDetail, PreventionCaseList, PreventionConnectionList, PreventionRefundActionList,
PreventionRefundLimit, PreventionRefundPreview, PreventionRefundRuleList,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
#[derive(Debug, Clone)]
pub struct ChargebackPrevention {
inner: Arc<Inner>,
}
impl ChargebackPrevention {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn list_connections(&self) -> Result<PreventionConnectionList> {
self.inner
.request(
HttpMethod::Get,
"/chargeback-prevention/connections",
None,
&[],
None,
)
.await
}
pub async fn list_cases(
&self,
params: &PreventionCaseListParams,
) -> Result<PreventionCaseList> {
self.inner
.request(
HttpMethod::Get,
"/chargeback-prevention/cases",
None,
¶ms.query(),
None,
)
.await
}
pub async fn retrieve_case(&self, case_id: &str) -> Result<PreventionCaseDetail> {
let path = format!("/chargeback-prevention/cases/{}", encode_segment(case_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn list_refund_rules(&self) -> Result<PreventionRefundRuleList> {
self.inner
.request(
HttpMethod::Get,
"/chargeback-prevention/refund-rules",
None,
&[],
None,
)
.await
}
pub async fn preview_refund_rule(
&self,
params: &PreventionRefundPreviewRequest,
) -> Result<PreventionRefundPreview> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/chargeback-prevention/refund-rules/preview",
Some(&body),
&[],
None,
)
.await
}
pub async fn list_refund_actions(
&self,
params: &PreventionRefundActionListParams,
) -> Result<PreventionRefundActionList> {
self.inner
.request(
HttpMethod::Get,
"/chargeback-prevention/refund-actions",
None,
¶ms.query(),
None,
)
.await
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PreventionRefundRuleSettings {
pub enabled: bool,
pub alert_sources: Vec<String>,
pub amount_limits: Vec<PreventionRefundLimit>,
pub daily_limit: i32,
pub max_alert_age_hours: i32,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PreventionRefundPreviewRequest {
pub merchant_connector_id: String,
pub test_mode: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub settings: Option<PreventionRefundRuleSettings>,
}
#[derive(Debug, Clone, Default)]
pub struct PreventionRefundActionListParams {
pub merchant_connector_id: Option<String>,
pub test_mode: Option<bool>,
pub state: Option<String>,
pub payment_id: Option<String>,
pub limit: Option<i64>,
pub offset: Option<i64>,
}
impl PreventionRefundActionListParams {
fn query(&self) -> Vec<(&'static str, String)> {
let mut query = Vec::new();
if let Some(value) = &self.merchant_connector_id {
query.push(("merchant_connector_id", value.clone()));
}
if let Some(test_mode) = self.test_mode {
query.push(("test_mode", test_mode.to_string()));
}
if let Some(value) = &self.state {
query.push(("state", value.clone()));
}
if let Some(value) = &self.payment_id {
query.push(("payment_id", value.clone()));
}
if let Some(limit) = self.limit {
query.push(("limit", limit.to_string()));
}
if let Some(offset) = self.offset {
query.push(("offset", offset.to_string()));
}
query
}
}
#[derive(Debug, Clone, Default)]
pub struct PreventionCaseListParams {
pub profile_id: Option<String>,
pub connection_id: Option<String>,
pub payment_id: Option<String>,
pub test_mode: Option<bool>,
pub provider: Vec<String>,
pub source: Vec<String>,
pub status: Vec<String>,
pub outcome: Vec<String>,
pub match_status: Vec<String>,
pub respond_by_from: Option<String>,
pub respond_by_to: Option<String>,
pub alerted_from: Option<String>,
pub alerted_to: Option<String>,
pub sort: Option<String>,
pub limit: Option<i64>,
pub offset: Option<i64>,
}
impl PreventionCaseListParams {
fn query(&self) -> Vec<(&'static str, String)> {
let mut query = Vec::new();
let single = [
("profile_id", &self.profile_id),
("connection_id", &self.connection_id),
("payment_id", &self.payment_id),
("respond_by_from", &self.respond_by_from),
("respond_by_to", &self.respond_by_to),
("alerted_from", &self.alerted_from),
("alerted_to", &self.alerted_to),
("sort", &self.sort),
];
for (name, value) in single {
if let Some(value) = value {
query.push((name, value.clone()));
}
}
if let Some(test_mode) = self.test_mode {
query.push(("test_mode", test_mode.to_string()));
}
let lists = [
("provider", &self.provider),
("source", &self.source),
("status", &self.status),
("outcome", &self.outcome),
("match_status", &self.match_status),
];
for (name, values) in lists {
if !values.is_empty() {
query.push((name, values.join(",")));
}
}
if let Some(limit) = self.limit {
query.push(("limit", limit.to_string()));
}
if let Some(offset) = self.offset {
query.push(("offset", offset.to_string()));
}
query
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
const CASE_JSON: &str = r#"{
"id": "cbpa_1", "merchant_id": "mer_1", "connection_id": "cbpc_1",
"provider": "chargebackio", "test_mode": true, "provider_account_id": "ba_1",
"provider_case_id": "a390ba0c", "source": "ethoca", "provider_status": "Attention",
"status": "attention", "outcome": "open", "amount": "61.00", "currency": "EUR",
"processors": ["stripe"], "match_status": "matched", "payment_id": "pay_1",
"refund_confirmed": false, "created_at": "2026-11-04T12:00:00",
"modified_at": "2026-11-04T12:00:00", "case_surprise": 1
}"#;
#[tokio::test]
async fn list_cases_sends_lists_as_comma_separated_values() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"data":[{CASE_JSON}],"total":1,"connections":[]}}"#
))]);
let params = PreventionCaseListParams {
outcome: vec!["open".to_string(), "refund_confirmed".to_string()],
sort: Some("respond_by".to_string()),
limit: Some(50),
..Default::default()
};
let out = client
.chargeback_prevention()
.list_cases(¶ms)
.await
.unwrap();
assert_eq!(out.total, 1);
assert_eq!(out.data[0].outcome, "open");
assert_eq!(out.data[0].extra["case_surprise"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/chargeback-prevention/cases?sort=respond_by&outcome=open,refund_confirmed&limit=50"
);
}
#[tokio::test]
async fn retrieve_case_reads_the_detail_and_its_history() {
let detail = CASE_JSON.trim_end().trim_end_matches('}').to_string()
+ r#", "arn": "123", "transaction_ids": ["pi_1"], "events": [{
"provider_status": "Attention", "status": "attention",
"provider_updated_at": "2026-11-04T12:00:00", "observed_at": "2026-11-04T12:01:00"
}]}"#;
let (client, mock) = client_with(vec![Step::ok(&detail)]);
let out = client
.chargeback_prevention()
.retrieve_case("cbpa/1")
.await
.unwrap();
assert_eq!(out.case.id, "cbpa_1");
assert_eq!(out.arn.as_deref(), Some("123"));
assert_eq!(out.events.len(), 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/chargeback-prevention/cases/cbpa%2F1"
);
}
#[tokio::test]
async fn an_answered_case_carries_its_answer_and_withdrawal() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"data":[{
"id": "cbpa_2", "merchant_id": "mer_1", "connection_id": "cbpc_2",
"provider": "chargebackhit", "test_mode": true, "provider_account_id": "pk_1",
"provider_case_id": "alert_1", "source": "ethoca", "alert_type": "inquiry",
"provider_status": "withdrawn", "status": "answered", "outcome": "withdrawn",
"processors": [], "match_status": "matched", "refund_confirmed": false,
"answer": {"outcome": "acknowledged", "reason": "matched", "elapsed_ms": 840,
"answered_at": "2026-11-05T09:00:00", "answer_surprise": true},
"withdrawn_at": "2026-11-05T10:00:00",
"created_at": "2026-11-05T09:00:00", "modified_at": "2026-11-05T10:00:00"
}, {
"id": "cbpa_3", "merchant_id": "mer_1", "connection_id": "cbpc_1",
"provider": "chargebackio", "test_mode": true, "provider_account_id": "ba_1",
"provider_case_id": "a390ba0d", "provider_status": "Attention",
"status": "attention", "outcome": "open", "processors": [],
"match_status": "unmatched", "refund_confirmed": false, "answer": null,
"created_at": "2026-11-05T09:00:00", "modified_at": "2026-11-05T09:00:00"
}],"total":2,"connections":[]}"#,
)]);
let params = PreventionCaseListParams {
provider: vec!["chargebackhit".to_string()],
status: vec!["answered".to_string(), "issuer_report".to_string()],
outcome: vec!["withdrawn".to_string(), "informational".to_string()],
..Default::default()
};
let out = client
.chargeback_prevention()
.list_cases(¶ms)
.await
.unwrap();
let answered = &out.data[0];
let answer = answered.answer.as_ref().unwrap();
assert_eq!(answer.outcome.as_deref(), Some("acknowledged"));
assert_eq!(answer.reason.as_deref(), Some("matched"));
assert_eq!(answer.elapsed_ms, Some(840));
assert_eq!(answer.answered_at.as_deref(), Some("2026-11-05T09:00:00"));
assert_eq!(answer.extra["answer_surprise"], true);
assert_eq!(
answered.withdrawn_at.as_deref(),
Some("2026-11-05T10:00:00")
);
assert!(!answered.extra.contains_key("answer"));
assert!(!answered.extra.contains_key("withdrawn_at"));
assert!(out.data[1].answer.is_none());
assert!(out.data[1].withdrawn_at.is_none());
let seen = mock.seen.lock().unwrap();
assert_eq!(
seen[0].url,
"https://api.test/chargeback-prevention/cases?provider=chargebackhit&status=answered,issuer_report&outcome=withdrawn,informational"
);
}
const RULE_JSON: &str = r#"{
"merchant_id": "mer_1", "merchant_connector_id": "mca_1", "connection_id": "cbpc_1",
"provider": "chargebackio", "test_mode": true, "enabled": true,
"alert_sources": ["cdrn", "ethoca"],
"amount_limits": [{"currency": "USD", "max_amount": 5000}],
"daily_limit": 5, "max_alert_age_hours": 48, "version": 1,
"updated_by": "usr_1", "updated_at": "2026-11-07T08:00:00", "rule_surprise": 1
}"#;
#[tokio::test]
async fn list_refund_rules_reads_every_accounts_rule() {
let (client, mock) = client_with(vec![Step::ok(&format!(r#"{{"rules":[{RULE_JSON}]}}"#))]);
let out = client
.chargeback_prevention()
.list_refund_rules()
.await
.unwrap();
let rule = &out.rules[0];
assert!(rule.enabled);
assert_eq!(rule.version, 1);
assert_eq!(
rule.amount_limits,
vec![PreventionRefundLimit {
currency: "USD".to_string(),
max_amount: 5000
}]
);
assert_eq!(rule.extra["rule_surprise"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/chargeback-prevention/refund-rules"
);
}
#[tokio::test]
async fn preview_refund_rule_posts_the_proposed_settings() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"rule":{RULE_JSON},"items":[{{"case_id":"cbpa_1","payment_id":"pay_1",
"amount":"49.99","currency":"USD","decision":"skip","reason":"over_limit"}}]}}"#
))]);
let params = PreventionRefundPreviewRequest {
merchant_connector_id: "mca_1".to_string(),
test_mode: true,
settings: Some(PreventionRefundRuleSettings {
enabled: true,
alert_sources: vec!["ethoca".to_string()],
amount_limits: vec![PreventionRefundLimit {
currency: "USD".to_string(),
max_amount: 1000,
}],
daily_limit: 5,
max_alert_age_hours: 48,
}),
};
let out = client
.chargeback_prevention()
.preview_refund_rule(¶ms)
.await
.unwrap();
assert_eq!(out.items[0].decision, "skip");
assert_eq!(out.items[0].reason.as_deref(), Some("over_limit"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/chargeback-prevention/refund-rules/preview"
);
let body: serde_json::Value =
serde_json::from_slice(seen[0].body.as_ref().unwrap()).unwrap();
assert_eq!(body["merchant_connector_id"], "mca_1");
assert_eq!(body["settings"]["amount_limits"][0]["max_amount"], 1000);
}
#[tokio::test]
async fn a_preview_of_the_stored_rule_sends_no_settings() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"rule":{RULE_JSON},"items":[]}}"#
))]);
let params = PreventionRefundPreviewRequest {
merchant_connector_id: "mca_1".to_string(),
test_mode: false,
settings: None,
};
client
.chargeback_prevention()
.preview_refund_rule(¶ms)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let body: serde_json::Value =
serde_json::from_slice(seen[0].body.as_ref().unwrap()).unwrap();
assert!(body.get("settings").is_none());
}
#[tokio::test]
async fn list_refund_actions_sends_its_filters_and_a_case_shows_its_action() {
let (client, mock) = client_with(vec![
Step::ok(
r#"{"data":[{"id":"cbpr_1","merchant_id":"mer_1","case_id":"cbpa_1",
"merchant_connector_id":"mca_1","test_mode":true,"payment_id":"pay_1",
"refund_id":"cbpr_1","amount":4999,"currency":"USD","state":"succeeded",
"rule_version":1,"rule":{"version":1},"report_status":"Manually refunded",
"report_state":"reported","created_at":"2026-11-07T08:00:00",
"modified_at":"2026-11-07T08:05:00"}],"total":1}"#,
),
Step::ok(&format!(
r#"{{"data":[{}],"total":1,"connections":[]}}"#,
CASE_JSON.trim_end().trim_end_matches('}').to_string()
+ r#", "refund_action": {"id":"cbpr_1","case_id":"cbpa_1","refund_id":"cbpr_1",
"amount":4999,"currency":"USD","state":"succeeded","report_state":"reported"}}"#
)),
]);
let params = PreventionRefundActionListParams {
state: Some("succeeded".to_string()),
limit: Some(10),
..Default::default()
};
let actions = client
.chargeback_prevention()
.list_refund_actions(¶ms)
.await
.unwrap();
assert_eq!(actions.data[0].state, "succeeded");
assert_eq!(actions.data[0].refund_id, actions.data[0].id);
let cases = client
.chargeback_prevention()
.list_cases(&PreventionCaseListParams::default())
.await
.unwrap();
let action = cases.data[0].refund_action.as_ref().unwrap();
assert_eq!(action.state, "succeeded");
assert!(!cases.data[0].extra.contains_key("refund_action"));
let seen = mock.seen.lock().unwrap();
assert_eq!(
seen[0].url,
"https://api.test/chargeback-prevention/refund-actions?state=succeeded&limit=10"
);
}
#[tokio::test]
async fn list_connections_reads_sync_health() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"connections":[{"id":"cbpc_1","merchant_id":"mer_1","provider":"chargebackio",
"test_mode":true,"status":"active","sync":{"status":"rate_limited",
"retry_at":"2026-11-04T13:00:00","stale":false},"accounts":[],
"created_at":"2026-11-04T12:00:00"}]}"#,
)]);
let out = client
.chargeback_prevention()
.list_connections()
.await
.unwrap();
assert_eq!(
out.connections[0].sync.status.as_deref(),
Some("rate_limited")
);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen.len(), 1);
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/chargeback-prevention/connections"
);
}
}