use std::fmt;
use serde::Deserialize;
use serde_json::Value;
use crate::core::models::common::{
AttemptStatus, Currency, ExternalRecordMarker, IntentStatus, PaymentMethod, PaymentMethodType,
ProcessorCostEstimateBasis,
};
use crate::core::models::payment_detail::{BuyerRiskEvaluation, PaymentProductLine};
#[derive(Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentResponse {
pub payment_id: String,
pub merchant_id: String,
pub status: IntentStatus,
pub amount: i64,
pub currency: Currency,
#[serde(default)]
pub net_amount: Option<i64>,
#[serde(default)]
pub amount_capturable: Option<i64>,
#[serde(default)]
pub amount_received: Option<i64>,
#[serde(default)]
pub client_secret: Option<String>,
#[serde(default)]
pub connector: Option<String>,
#[serde(default)]
pub customer_id: Option<String>,
#[serde(default)]
pub profile_id: Option<String>,
#[serde(default)]
pub payment_method: Option<PaymentMethod>,
#[serde(default)]
pub error_code: Option<String>,
#[serde(default)]
pub error_message: Option<String>,
#[serde(default)]
pub next_action: Option<Value>,
#[serde(default)]
pub created: Option<String>,
#[serde(default)]
pub expires_on: Option<String>,
#[serde(default)]
pub metadata: Option<Value>,
#[serde(default)]
pub test_mode: Option<bool>,
#[serde(default)]
pub connector_transaction_id: Option<String>,
#[serde(default)]
pub connector_settlement_status: Option<ConnectorSettlementStatus>,
#[serde(default)]
pub routing_approach: Option<RoutingApproach>,
#[serde(default)]
pub buyer_risk: Option<BuyerRiskEvaluation>,
#[serde(default)]
pub is_integration_test: bool,
#[serde(default)]
pub failure_substatus: Option<FailureSubstatus>,
#[serde(default)]
pub vault: Option<AttemptVaultUsage>,
#[serde(default)]
pub buyer_failure_reason: Option<String>,
#[serde(default)]
pub buyer_blocked: Option<bool>,
#[serde(default)]
pub buyer_block_note: Option<String>,
#[serde(default)]
pub processor_reference: Option<String>,
#[serde(default)]
pub connector_environment: Option<String>,
#[serde(default)]
pub product_summary: Option<PaymentProductLineSummary>,
#[serde(default)]
pub cancel_url: Option<String>,
#[serde(default)]
pub state_metadata: Option<PaymentIntentStateMetadata>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
pub type FailureSubstatus = String;
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct AttemptVaultUsage {
pub status: String,
#[serde(default)]
pub direct_reason: Option<String>,
#[serde(default)]
pub vault_connector_id: Option<String>,
#[serde(default)]
pub vault_connector_label: Option<String>,
#[serde(default)]
pub vault_connector: Option<String>,
#[serde(default)]
pub handover: Option<String>,
#[serde(default)]
pub handover_error: Option<String>,
#[serde(default)]
pub recorded_at: Option<String>,
#[serde(default)]
pub recorded_since: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentProductLineSummary {
#[serde(default)]
pub first_line: Option<PaymentProductLine>,
pub line_count: i32,
pub attributed: bool,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentIntentStateMetadata {
#[serde(default)]
pub post_capture_void: Option<PostCaptureVoidResponse>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PostCaptureVoidResponse {
#[serde(default)]
pub status: Option<String>,
#[serde(default)]
pub connector_reference_id: Option<String>,
#[serde(default)]
pub description: Option<String>,
pub updated_at: String,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
impl fmt::Debug for PaymentResponse {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PaymentResponse")
.field("payment_id", &self.payment_id)
.field("merchant_id", &self.merchant_id)
.field("status", &self.status)
.field("amount", &self.amount)
.field("currency", &self.currency)
.field("net_amount", &self.net_amount)
.field("amount_capturable", &self.amount_capturable)
.field("amount_received", &self.amount_received)
.field(
"client_secret",
&self.client_secret.as_ref().map(|_| "[redacted]"),
)
.field("connector", &self.connector)
.field("customer_id", &self.customer_id)
.field("profile_id", &self.profile_id)
.field("payment_method", &self.payment_method)
.field("error_code", &self.error_code)
.field("error_message", &self.error_message)
.field("next_action", &self.next_action)
.field("created", &self.created)
.field("expires_on", &self.expires_on)
.field("metadata", &self.metadata)
.field("connector_transaction_id", &self.connector_transaction_id)
.field(
"connector_settlement_status",
&self.connector_settlement_status,
)
.field("routing_approach", &self.routing_approach)
.field("buyer_risk", &self.buyer_risk)
.field("is_integration_test", &self.is_integration_test)
.field("failure_substatus", &self.failure_substatus)
.field("vault", &self.vault)
.field("buyer_failure_reason", &self.buyer_failure_reason)
.field("buyer_blocked", &self.buyer_blocked)
.field("buyer_block_note", &self.buyer_block_note)
.field("processor_reference", &self.processor_reference)
.field("connector_environment", &self.connector_environment)
.field("product_summary", &self.product_summary)
.field("cancel_url", &self.cancel_url)
.field("state_metadata", &self.state_metadata)
.field("extra", &self.extra)
.finish()
}
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentAttemptResponse {
pub attempt_id: String,
pub status: AttemptStatus,
#[serde(default)]
pub amount: Option<i64>,
#[serde(default)]
pub currency: Option<Currency>,
#[serde(default)]
pub connector: Option<String>,
#[serde(default)]
pub connector_transaction_id: Option<String>,
#[serde(default)]
pub payment_method: Option<PaymentMethod>,
#[serde(default)]
pub payment_method_type: Option<PaymentMethodType>,
#[serde(default)]
pub error_code: Option<String>,
#[serde(default)]
pub error_message: Option<String>,
#[serde(default)]
pub unified_code: Option<String>,
#[serde(default)]
pub unified_message: Option<String>,
#[serde(default)]
pub created_at: Option<String>,
#[serde(default)]
pub modified_at: Option<String>,
#[serde(default)]
pub merchant_connector_id: Option<String>,
#[serde(default)]
pub routing_approach: Option<RoutingApproach>,
#[serde(default)]
pub failure_substatus: Option<FailureSubstatus>,
#[serde(default)]
pub vault: Option<AttemptVaultUsage>,
#[serde(default)]
pub processor_reference: Option<String>,
#[serde(default)]
pub network_transaction_id: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentStatusHistoryEvent {
pub entity_type: String,
pub timestamp: String,
#[serde(default)]
pub entity_id: Option<String>,
#[serde(default)]
pub attempt_id: Option<String>,
#[serde(default)]
pub previous_status: Option<String>,
#[serde(default)]
pub status: Option<String>,
#[serde(default)]
pub connector: Option<String>,
#[serde(default)]
pub error_code: Option<String>,
#[serde(default)]
pub error_message: Option<String>,
#[serde(default)]
pub is_creation: bool,
#[serde(default)]
pub derived: bool,
#[serde(default)]
pub actor: Option<PaymentHistoryActor>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentHistoryActor {
pub kind: String,
#[serde(default)]
pub email: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentStatusHistoryResponse {
pub payment_id: String,
#[serde(default)]
pub complete: bool,
#[serde(default)]
pub count: i64,
#[serde(default = "Vec::new")]
pub events: Vec<PaymentStatusHistoryEvent>,
#[serde(default)]
pub external_record: Option<ExternalRecordMarker>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentsDeleteResponse {
pub payment_id: String,
pub merchant_id: String,
pub deleted: bool,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentClientContextEntry {
pub source: String,
#[serde(default)]
pub device_id: Option<String>,
#[serde(default)]
pub partitioned_device_id: Option<String>,
#[serde(default)]
pub ip_address: Option<String>,
#[serde(default)]
pub ip_country: Option<String>,
#[serde(default)]
pub user_agent: Option<String>,
#[serde(default)]
pub accept_language: Option<String>,
#[serde(default)]
pub device_model: Option<String>,
#[serde(rename = "extra", default)]
pub extra_data: Option<Value>,
pub created_at: String,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentClientContextListResponse {
pub payment_id: String,
#[serde(default)]
pub count: i64,
#[serde(default = "Vec::new")]
pub data: Vec<PaymentClientContextEntry>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn payment_response_decodes_the_newer_fields() {
let payment: PaymentResponse = serde_json::from_str(
r#"{
"payment_id": "pay_1", "merchant_id": "mer_1", "status": "failed",
"amount": 1000, "currency": "EUR",
"is_integration_test": true,
"failure_substatus": "insufficient_funds",
"buyer_failure_reason": "insufficient_funds",
"buyer_blocked": false, "buyer_block_note": null,
"processor_reference": "ch_1", "connector_environment": "sandbox",
"cancel_url": "https://shop.test/cart",
"vault": {"status": "direct", "direct_reason": "vault_switched_off"},
"buyer_risk": {"score": 10, "band": "low", "action": "allow",
"applied_action": "allow", "reasons": [], "model_version": "p1",
"merchant_initiated": false, "evaluated_at": "2026-09-01T00:00:00Z"},
"product_summary": {"line_count": 2, "attributed": true,
"first_line": {"id": "pli_1", "attributed": true, "name": "Hat",
"quantity": 1, "unit_amount": 500, "line_total": 500,
"currency": "EUR", "role": "product"}},
"state_metadata": {"post_capture_void": {"status": "pending",
"updated_at": "2026-09-01T00:00:00Z"}, "required_connector_test_mode": true},
"surprise_field": 1
}"#,
)
.unwrap();
assert!(payment.is_integration_test);
assert_eq!(
payment.failure_substatus.as_deref(),
Some("insufficient_funds")
);
assert_eq!(payment.vault.as_ref().unwrap().status, "direct");
assert_eq!(payment.buyer_risk.as_ref().unwrap().band, "low");
let summary = payment.product_summary.as_ref().unwrap();
assert_eq!(summary.line_count, 2);
assert_eq!(summary.first_line.as_ref().unwrap().name, "Hat");
let metadata = payment.state_metadata.as_ref().unwrap();
assert_eq!(
metadata
.post_capture_void
.as_ref()
.unwrap()
.status
.as_deref(),
Some("pending")
);
assert_eq!(metadata.extra["required_connector_test_mode"], true);
assert_eq!(
payment.cancel_url.as_deref(),
Some("https://shop.test/cart")
);
assert_eq!(payment.extra["surprise_field"], 1);
let older: PaymentResponse = serde_json::from_str(
r#"{"payment_id":"pay_1","merchant_id":"mer_1","status":"succeeded","amount":1,"currency":"EUR"}"#,
)
.unwrap();
assert!(!older.is_integration_test);
assert!(older.vault.is_none());
}
#[test]
fn attempt_history_settlement_and_replay_decode_the_newer_fields() {
let attempt: PaymentAttemptResponse = serde_json::from_str(
r#"{"attempt_id":"att_1","status":"failure","failure_substatus":"card_declined",
"processor_reference":"ch_1","network_transaction_id":"ntid_1",
"vault":{"status":"vault","vault_connector":"vgs","handover":"handed_over"}}"#,
)
.unwrap();
assert_eq!(attempt.network_transaction_id.as_deref(), Some("ntid_1"));
assert_eq!(
attempt.vault.as_ref().unwrap().handover.as_deref(),
Some("handed_over")
);
let history: PaymentStatusHistoryResponse = serde_json::from_str(
r#"{"payment_id":"pay_1","events":[{"entity_type":"integration_test",
"timestamp":"2026-09-01T00:00:00Z","status":"marked",
"actor":{"kind":"merchant_user","email":"ada@example.com"}}],
"external_record":{"recorded_by":"usr_1","recorded_at":"2026-09-01T00:00:00Z",
"reason":"refunded in the processor dashboard","created_by_recording":false,
"recording_count":1}}"#,
)
.unwrap();
assert_eq!(
history.events[0].actor.as_ref().unwrap().kind,
"merchant_user"
);
assert_eq!(history.external_record.as_ref().unwrap().recording_count, 1);
let settlement: ConnectorSettlementAttempt = serde_json::from_str(
r#"{"attempt_id":"att_1","attempt_status":"charged","status":"paid_out",
"processor_cost_amount":29,"processor_cost_currency":"EUR",
"processor_cost_exponent":2,"processor_cost_source":"estimated",
"processor_cost_basis":{"schedule_id":"fs_1","merchant_scoped":false,
"percentage":1.4,"effective_from":"2026-01-01T00:00:00Z"},
"connector_method_code":"card"}"#,
)
.unwrap();
assert_eq!(settlement.processor_cost_amount, Some(29));
assert_eq!(
settlement.processor_cost_basis.as_ref().unwrap().percentage,
Some(1.4)
);
let playback: ReplayPlaybackResponse = serde_json::from_str(
r#"{"playback_id":"pb_1","total_events":0,"has_redirect_gap":false,
"slices":[{"sequence":0,"event_count":3,"byte_size":100,"first_event_at":1,
"last_event_at":2,"encoding":"gzip","stored_bytes":40}],
"expired":{"swept_at":"2026-10-01T00:00:00Z","retention_days_applied":30}}"#,
)
.unwrap();
assert_eq!(playback.slices[0].encoding, "gzip");
assert_eq!(playback.slices[0].stored_bytes, 40);
assert_eq!(
playback.expired.as_ref().unwrap().retention_days_applied,
30
);
}
const WITH_SECRET: &str = r#"{
"payment_id": "pay_1", "merchant_id": "mer_1", "status": "requires_confirmation",
"amount": 1999, "currency": "EUR", "client_secret": "pay_1_secret_abc123"
}"#;
#[test]
fn payment_response_debug_redacts_the_client_secret() {
let res: PaymentResponse = serde_json::from_str(WITH_SECRET).unwrap();
let printed = format!("{res:?}");
assert!(!printed.contains("pay_1_secret_abc123"));
assert!(printed.contains("client_secret: Some(\"[redacted]\")"));
assert!(printed.contains("pay_1"));
assert!(printed.contains("1999"));
}
#[test]
fn payment_response_debug_shows_none_when_no_client_secret() {
let res: PaymentResponse = serde_json::from_str(
r#"{"payment_id":"pay_1","merchant_id":"mer_1","status":"succeeded",
"amount":1999,"currency":"EUR"}"#,
)
.unwrap();
assert!(format!("{res:?}").contains("client_secret: None"));
}
#[test]
fn status_history_parses_derived_and_non_status_events() {
let history: PaymentStatusHistoryResponse = serde_json::from_str(
r#"{
"payment_id": "pay_1",
"complete": false,
"count": 3,
"events": [
{
"entity_type": "payment",
"timestamp": "2026-08-01T10:00:00Z",
"status": "requires_confirmation",
"is_creation": true,
"derived": true
},
{
"entity_type": "attempt",
"entity_id": "pay_1_1",
"attempt_id": "pay_1_1",
"previous_status": "pending",
"status": "charged",
"connector": "stripe",
"timestamp": "2026-08-01T10:00:05Z",
"is_creation": false,
"derived": false
},
{
"entity_type": "checkout",
"entity_id": "apple_pay",
"status": "native_pane_selected",
"timestamp": "2026-08-01T10:00:03Z",
"is_creation": false,
"derived": false
}
]
}"#,
)
.unwrap();
assert_eq!(history.payment_id, "pay_1");
assert!(!history.complete);
assert_eq!(history.count, 3);
assert!(history.events[0].derived);
assert!(history.events[0].is_creation);
assert_eq!(history.events[0].previous_status, None);
assert_eq!(history.events[1].connector.as_deref(), Some("stripe"));
assert_eq!(history.events[2].entity_type, "checkout");
assert_eq!(
history.events[2].status.as_deref(),
Some("native_pane_selected")
);
}
#[test]
fn status_history_defaults_to_no_events() {
let history: PaymentStatusHistoryResponse =
serde_json::from_str(r#"{"payment_id":"pay_1"}"#).unwrap();
assert!(history.events.is_empty());
assert!(!history.complete);
}
}
pub type ConnectorSettlementStatus = String;
pub type RoutingApproach = String;
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ConnectorSettlementAttempt {
pub attempt_id: String,
pub attempt_status: AttemptStatus,
#[serde(default)]
pub connector: Option<String>,
#[serde(default)]
pub merchant_connector_id: Option<String>,
pub status: ConnectorSettlementStatus,
#[serde(default)]
pub available_on: Option<String>,
#[serde(default)]
pub payout_reference: Option<String>,
#[serde(default)]
pub paid_out_at: Option<String>,
#[serde(default)]
pub last_recorded_at: Option<String>,
#[serde(default)]
pub processor_cost_amount: Option<i64>,
#[serde(default)]
pub processor_cost_currency: Option<String>,
#[serde(default)]
pub processor_cost_exponent: Option<i32>,
#[serde(default)]
pub processor_cost_source: Option<String>,
#[serde(default)]
pub processor_cost_basis: Option<ProcessorCostEstimateBasis>,
#[serde(default)]
pub connector_method_code: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentConnectorSettlementResponse {
pub payment_id: String,
pub count: u64,
pub attempts: Vec<ConnectorSettlementAttempt>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ReplayPlaybackResponse {
pub playback_id: String,
#[serde(default)]
pub session_id: Option<String>,
#[serde(default)]
pub first_event_at: Option<i64>,
#[serde(default)]
pub last_event_at: Option<i64>,
pub total_events: u64,
pub has_redirect_gap: bool,
pub slices: Vec<ReplaySliceInfo>,
#[serde(default)]
pub expired: Option<ReplayExpiry>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ReplaySliceInfo {
pub sequence: u64,
pub event_count: u64,
pub byte_size: u64,
pub first_event_at: i64,
pub last_event_at: i64,
#[serde(default)]
pub encoding: String,
#[serde(default)]
pub stored_bytes: i64,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ReplayExpiry {
pub swept_at: String,
pub retention_days_applied: i32,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ReplaySliceResponse {
pub sequence: u64,
pub events: Vec<Value>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ReplayIngestResponse {
pub sequence: u64,
pub duplicate: bool,
pub full: bool,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentAbandonAttemptResponse {
pub payment_id: String,
pub status: IntentStatus,
pub attempt_id: String,
#[serde(default)]
pub abandoned_attempt_id: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentReopenAttemptResponse {
pub payment_id: String,
pub status: IntentStatus,
pub attempt_id: String,
pub redirect_url: String,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PaymentPostSessionTokensResponse {
pub payment_id: String,
pub status: IntentStatus,
#[serde(default)]
pub next_action: Option<Value>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}