use serde::{Deserialize, Serialize};
use serde_json::Value;
use crate::core::models::common::Currency;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FeeType {
Percentage,
Flat,
Combined,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FeeOwner {
Platform,
Merchant,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct FeeScheduleResponse {
pub id: String,
pub merchant_id: String,
pub fee_type: FeeType,
pub is_active: bool,
pub fee_owner: FeeOwner,
#[serde(default)]
pub shop_id: Option<String>,
#[serde(default)]
pub percentage_fee: Option<f64>,
#[serde(default)]
pub flat_fee_amount: Option<i64>,
#[serde(default)]
pub flat_fee_currency: Option<Currency>,
#[serde(default)]
pub min_fee_amount: Option<i64>,
#[serde(default)]
pub max_fee_amount: Option<i64>,
#[serde(default)]
pub description: Option<String>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct PlatformFeeRuleRecord {
pub name: String,
pub fee_owner: FeeOwner,
pub algorithm: Value,
#[serde(default)]
pub created_at: Option<i64>,
#[serde(default)]
pub modified_at: Option<i64>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct FeeRulePreviewResponse {
pub fell_through: bool,
#[serde(default)]
pub matched_rule: Option<String>,
#[serde(default)]
pub fee_amount: Option<i64>,
#[serde(default)]
pub fee_currency: Option<Currency>,
#[serde(flatten)]
pub extra: serde_json::Map<String, Value>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn fee_schedule_decodes_its_enums_and_keeps_unknown_fields() {
let schedule: FeeScheduleResponse = serde_json::from_str(
r#"{
"id": "fee_1",
"merchant_id": "merch_1",
"fee_type": "combined",
"is_active": true,
"fee_owner": "merchant",
"shop_id": "pro_1",
"percentage_fee": 2.5,
"flat_fee_amount": 30,
"flat_fee_currency": "USD",
"brand_new_field": "keep me"
}"#,
)
.unwrap();
assert_eq!(schedule.fee_type, FeeType::Combined);
assert_eq!(schedule.fee_owner, FeeOwner::Merchant);
assert_eq!(schedule.percentage_fee, Some(2.5));
assert_eq!(schedule.flat_fee_amount, Some(30));
assert_eq!(schedule.min_fee_amount, None);
assert_eq!(schedule.extra["brand_new_field"], "keep me");
}
#[test]
fn fee_type_round_trips_through_its_wire_spelling() {
for (variant, wire) in [
(FeeType::Percentage, "\"percentage\""),
(FeeType::Flat, "\"flat\""),
(FeeType::Combined, "\"combined\""),
] {
assert_eq!(serde_json::to_string(&variant).unwrap(), wire);
assert_eq!(serde_json::from_str::<FeeType>(wire).unwrap(), variant);
}
assert_eq!(
serde_json::to_string(&FeeOwner::Platform).unwrap(),
"\"platform\""
);
}
#[test]
fn fee_rule_record_keeps_the_program_as_raw_json() {
let record: PlatformFeeRuleRecord = serde_json::from_str(
r#"{
"name": "standard",
"fee_owner": "merchant",
"algorithm": {"defaultSelection": {}, "rules": [], "metadata": {}},
"created_at": 1767225600,
"modified_at": 1767312000
}"#,
)
.unwrap();
assert_eq!(record.name, "standard");
assert_eq!(record.fee_owner, FeeOwner::Merchant);
assert_eq!(record.created_at, Some(1767225600));
assert_eq!(record.algorithm["rules"], serde_json::json!([]));
}
#[test]
fn preview_response_decodes_a_fall_through() {
let preview: FeeRulePreviewResponse = serde_json::from_str(
r#"{"matched_rule":null,"fell_through":true,"fee_amount":null,"fee_currency":null}"#,
)
.unwrap();
assert!(preview.fell_through);
assert_eq!(preview.matched_rule, None);
assert_eq!(preview.fee_amount, None);
let matched: FeeRulePreviewResponse = serde_json::from_str(
r#"{"matched_rule":"crypto","fell_through":false,"fee_amount":125,"fee_currency":"USD"}"#,
)
.unwrap();
assert_eq!(matched.matched_rule.as_deref(), Some("crypto"));
assert_eq!(matched.fee_amount, Some(125));
assert_eq!(matched.fee_currency.as_deref(), Some("USD"));
}
}