use async_trait::async_trait;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum OrderOrigin {
WhatsApp,
Mcp,
Web,
IosApp,
AndroidApp,
Api,
}
impl OrderOrigin {
pub fn parse(value: &str) -> Option<Self> {
match value.trim().to_ascii_lowercase().as_str() {
"whatsapp" | "wa" => Some(Self::WhatsApp),
"mcp" | "chatgpt" | "chatgpt_mcp" | "chatgpt-mcp" => Some(Self::Mcp),
"web" | "checkout" => Some(Self::Web),
"ios" | "ios_app" | "ios-app" | "iphone" | "ipad" => Some(Self::IosApp),
"android" | "android_app" | "android-app" => Some(Self::AndroidApp),
"api" | "backend" => Some(Self::Api),
_ => None,
}
}
pub fn as_str(self) -> &'static str {
match self {
Self::WhatsApp => "whatsapp",
Self::Mcp => "mcp",
Self::Web => "web",
Self::IosApp => "ios_app",
Self::AndroidApp => "android_app",
Self::Api => "api",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum PaymentKind {
Xendit,
}
impl std::fmt::Display for PaymentKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
PaymentKind::Xendit => write!(f, "xendit"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
pub enum Currency {
#[default]
IDR,
USD,
PHP,
THB,
MYR,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChargeRequest {
pub amount: i64,
pub currency: Currency,
pub reference_id: String,
pub description: Option<String>,
pub payment_method: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub order_origin: Option<OrderOrigin>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub idempotency_key: Option<String>,
pub return_url: Option<String>,
pub metadata: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChargeResponse {
pub charge_id: String,
pub status: ChargeStatus,
pub redirect_url: Option<String>,
pub qr_code: Option<String>,
pub payment_code: Option<String>,
pub expires_at: Option<String>,
pub raw: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaymentDisplay {
pub charge_id: String,
pub status: ChargeStatus,
pub amount: i64,
pub currency: Currency,
pub reference_id: String,
pub description: Option<String>,
pub payment_method: Option<String>,
pub order_origin: Option<OrderOrigin>,
pub redirect_url: Option<String>,
pub qr_code: Option<String>,
pub payment_code: Option<String>,
pub expires_at: Option<String>,
}
impl ChargeResponse {
pub fn display_for(&self, request: &ChargeRequest) -> PaymentDisplay {
PaymentDisplay {
charge_id: self.charge_id.clone(),
status: self.status,
amount: request.amount,
currency: request.currency,
reference_id: request.reference_id.clone(),
description: request.description.clone(),
payment_method: request.payment_method.clone(),
order_origin: request.order_origin,
redirect_url: self.redirect_url.clone(),
qr_code: self.qr_code.clone(),
payment_code: self.payment_code.clone(),
expires_at: self.expires_at.clone(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ChargeStatus {
Pending,
Paid,
Failed,
Expired,
Refunded,
}
impl std::fmt::Display for ChargeStatus {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ChargeStatus::Pending => write!(f, "pending"),
ChargeStatus::Paid => write!(f, "paid"),
ChargeStatus::Failed => write!(f, "failed"),
ChargeStatus::Expired => write!(f, "expired"),
ChargeStatus::Refunded => write!(f, "refunded"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaymentEvent {
pub charge_id: String,
pub status: ChargeStatus,
pub amount: Option<i64>,
pub reference_id: Option<String>,
pub payment_method: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub order_origin: Option<OrderOrigin>,
pub metadata: Option<serde_json::Value>,
}
#[derive(Debug)]
pub enum PaymentError {
InvalidAmount(String),
ProviderError(String),
WebhookVerificationFailed(String),
RateLimited {
retry_after_secs: u64,
},
Other(String),
}
impl std::fmt::Display for PaymentError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
PaymentError::InvalidAmount(e) => write!(f, "Invalid amount: {}", e),
PaymentError::ProviderError(e) => write!(f, "Provider error: {}", e),
PaymentError::WebhookVerificationFailed(e) => {
write!(f, "Webhook verification failed: {}", e)
}
PaymentError::RateLimited { retry_after_secs } => {
write!(f, "Rate limited, retry after {}s", retry_after_secs)
}
PaymentError::Other(e) => write!(f, "{}", e),
}
}
}
impl std::error::Error for PaymentError {}
#[allow(clippy::double_must_use)]
#[async_trait]
pub trait PaymentProvider: Send + Sync {
async fn create_charge(&self, req: ChargeRequest) -> Result<ChargeResponse, PaymentError>;
fn verify_webhook(
&self,
headers: &[(String, String)],
body: &[u8],
) -> Result<PaymentEvent, PaymentError>;
fn kind(&self) -> PaymentKind;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_charge_request_serialization() {
let req = ChargeRequest {
amount: 150_000,
currency: Currency::IDR,
reference_id: "booking-001".into(),
description: Some("Ferry ticket Bali-Nusa Penida".into()),
payment_method: Some("QRIS".into()),
order_origin: Some(OrderOrigin::WhatsApp),
idempotency_key: Some("charge:booking-001".into()),
return_url: None,
metadata: None,
};
let json = serde_json::to_string(&req).unwrap();
let restored: ChargeRequest = serde_json::from_str(&json).unwrap();
assert_eq!(restored.amount, 150_000);
assert_eq!(restored.reference_id, "booking-001");
assert_eq!(restored.order_origin, Some(OrderOrigin::WhatsApp));
assert_eq!(
restored.idempotency_key.as_deref(),
Some("charge:booking-001")
);
}
#[test]
fn test_charge_response_serialization() {
let res = ChargeResponse {
charge_id: "xendit-abc123".into(),
status: ChargeStatus::Pending,
redirect_url: None,
qr_code: Some("00020101021226610014ID.CO.XENDIT".into()),
payment_code: None,
expires_at: Some("2026-02-13T16:00:00Z".into()),
raw: None,
};
let json = serde_json::to_string(&res).unwrap();
let restored: ChargeResponse = serde_json::from_str(&json).unwrap();
assert_eq!(restored.charge_id, "xendit-abc123");
assert_eq!(restored.status, ChargeStatus::Pending);
}
#[test]
fn test_payment_event_serialization() {
let event = PaymentEvent {
charge_id: "xendit-abc123".into(),
status: ChargeStatus::Paid,
amount: Some(150_000),
reference_id: Some("booking-001".into()),
payment_method: Some("QRIS".into()),
order_origin: Some(OrderOrigin::WhatsApp),
metadata: None,
};
let json = serde_json::to_string(&event).unwrap();
let restored: PaymentEvent = serde_json::from_str(&json).unwrap();
assert_eq!(restored.status, ChargeStatus::Paid);
assert_eq!(restored.order_origin, Some(OrderOrigin::WhatsApp));
}
#[test]
fn test_payment_kind_display() {
assert_eq!(PaymentKind::Xendit.to_string(), "xendit");
}
#[test]
fn test_order_origin_parse() {
assert_eq!(OrderOrigin::parse("whatsapp"), Some(OrderOrigin::WhatsApp));
assert_eq!(OrderOrigin::parse("wa"), Some(OrderOrigin::WhatsApp));
assert_eq!(OrderOrigin::parse("mcp"), Some(OrderOrigin::Mcp));
assert_eq!(OrderOrigin::parse("chatgpt"), Some(OrderOrigin::Mcp));
assert_eq!(OrderOrigin::parse("ios"), Some(OrderOrigin::IosApp));
assert_eq!(
OrderOrigin::parse("android-app"),
Some(OrderOrigin::AndroidApp)
);
assert_eq!(OrderOrigin::parse("unknown"), None);
}
#[test]
fn test_payment_display_omits_raw_provider_data() {
let req = ChargeRequest {
amount: 150_000,
currency: Currency::IDR,
reference_id: "booking-001".into(),
description: Some("Ferry ticket Bali-Nusa Penida".into()),
payment_method: Some("QRIS".into()),
order_origin: Some(OrderOrigin::Mcp),
idempotency_key: Some("idem-1".into()),
return_url: None,
metadata: None,
};
let res = ChargeResponse {
charge_id: "xendit-abc123".into(),
status: ChargeStatus::Pending,
redirect_url: None,
qr_code: Some("00020101021226610014ID.CO.XENDIT".into()),
payment_code: None,
expires_at: Some("2026-02-13T16:00:00Z".into()),
raw: Some(serde_json::json!({"secret": "do-not-show"})),
};
let display = res.display_for(&req);
let value = serde_json::to_value(display).unwrap();
assert!(value.get("raw").is_none());
assert_eq!(
value.get("order_origin").and_then(|v| v.as_str()),
Some("mcp")
);
}
#[test]
fn test_charge_status_display() {
assert_eq!(ChargeStatus::Pending.to_string(), "pending");
assert_eq!(ChargeStatus::Paid.to_string(), "paid");
assert_eq!(ChargeStatus::Expired.to_string(), "expired");
}
}