use serde::{de, Deserialize, Deserializer, Serializer};
use serde_json::Value;
use std::fmt::Display;
use std::str::FromStr;
pub fn default_page_num() -> u32 {
1
}
pub fn default_page_size() -> u32 {
10
}
pub fn deserialize_number_or_string<'de, D>(deserializer: D) -> Result<String, D::Error>
where
D: Deserializer<'de>,
{
use serde::de::{self, Visitor};
struct StringOrNumberVisitor;
impl<'de> Visitor<'de> for StringOrNumberVisitor {
type Value = String;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a string, number, or boolean")
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(value.to_string())
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(value.to_string())
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(value.to_string())
}
fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(if value { "1" } else { "0" }.to_string())
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok("0".to_string())
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok("0".to_string())
}
}
deserializer.deserialize_any(StringOrNumberVisitor)
}
pub fn deserialize_opt_number_or_string<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
where
D: Deserializer<'de>,
{
use serde::de::{self, Visitor};
struct OptStringOrNumberVisitor;
impl<'de> Visitor<'de> for OptStringOrNumberVisitor {
type Value = Option<String>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a string, number, boolean, or null")
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
if value.is_empty() {
Ok(None)
} else {
Ok(Some(value.to_string()))
}
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Some(value.to_string()))
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Some(value.to_string()))
}
fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Some(if value { "1" } else { "0" }.to_string()))
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(None)
}
}
deserializer.deserialize_any(OptStringOrNumberVisitor)
}
pub fn serialize_opt_string<S>(value: &Option<String>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match value {
Some(v) => serializer.serialize_str(v),
None => serializer.serialize_none(),
}
}
pub(crate) fn value_to_number<T>(value: Value) -> Result<T, String>
where
T: FromStr + TryFrom<u64> + TryFrom<i64>,
<T as FromStr>::Err: Display,
<T as TryFrom<u64>>::Error: Display,
<T as TryFrom<i64>>::Error: Display,
{
match value {
Value::String(s) => {
s.parse::<T>().map_err(|e| format!("无效的字符串 '{s}': {e}"))
}
Value::Number(num) => {
if let Some(n) = num.as_u64() {
T::try_from(n).map_err(|e| format!("数字 {n} 超出目标范围: {e}"))
} else if let Some(n) = num.as_i64() {
T::try_from(n).map_err(|e| format!("数字 {n} 超出目标范围: {e}"))
} else {
Err(format!("无效的数字 {num}"))
}
}
_ => Err("期望一个字符串或数字".to_string()),
}
}
macro_rules! impl_string_or_number_to_num {
($ty:ty, $deser:ident, $opt_deser:ident) => {
pub fn $deser<'de, D>(deserializer: D) -> Result<$ty, D::Error>
where
D: Deserializer<'de>,
{
let value = Value::deserialize(deserializer)?;
value_to_number::<$ty>(value).map_err(de::Error::custom)
}
pub fn $opt_deser<'de, D>(deserializer: D) -> Result<Option<$ty>, D::Error>
where
D: Deserializer<'de>,
{
let value: Option<Value> = Option::deserialize(deserializer)?;
match value {
None => Ok(None),
Some(v) => value_to_number::<$ty>(v).map(Some).map_err(de::Error::custom),
}
}
};
($ty:ty, $deser:ident) => {
pub fn $deser<'de, D>(deserializer: D) -> Result<$ty, D::Error>
where
D: Deserializer<'de>,
{
let value = Value::deserialize(deserializer)?;
value_to_number::<$ty>(value).map_err(de::Error::custom)
}
};
}
impl_string_or_number_to_num!(
i8,
deserialize_string_or_number_to_i8,
deserialize_opt_string_or_number_to_i8
);
impl_string_or_number_to_num!(
u8,
deserialize_string_or_number_to_u8,
deserialize_opt_string_or_number_to_u8
);
impl_string_or_number_to_num!(
i16,
deserialize_string_or_number_to_i16,
deserialize_opt_string_or_number_to_i16
);
impl_string_or_number_to_num!(
u16,
deserialize_string_or_number_to_u16,
deserialize_opt_string_or_number_to_u16
);
impl_string_or_number_to_num!(
i32,
deserialize_string_or_number_to_i32,
deserialize_opt_string_or_number_to_i32
);
impl_string_or_number_to_num!(
u32,
deserialize_string_or_number_to_u32,
deserialize_opt_string_or_number_to_u32
);
impl_string_or_number_to_num!(
i64,
deserialize_string_or_number_to_i64,
deserialize_opt_string_or_number_to_i64
);
impl_string_or_number_to_num!(u64, deserialize_string_or_number_to_u64);
macro_rules! impl_num_as_string {
($ty:ty, $ser:ident, $opt_ser:ident) => {
pub fn $ser<S>(value: &$ty, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_str(value)
}
pub fn $opt_ser<S>(value: &Option<$ty>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match value {
Some(v) => serializer.collect_str(v),
None => serializer.serialize_none(),
}
}
};
}
impl_num_as_string!(i8, serialize_i8_as_string, serialize_opt_i8_as_string);
impl_num_as_string!(u8, serialize_u8_as_string, serialize_opt_u8_as_string);
impl_num_as_string!(i16, serialize_i16_as_string, serialize_opt_i16_as_string);
impl_num_as_string!(u16, serialize_u16_as_string, serialize_opt_u16_as_string);
impl_num_as_string!(i32, serialize_i32_as_string, serialize_opt_i32_as_string);
impl_num_as_string!(u32, serialize_u32_as_string, serialize_opt_u32_as_string);
impl_num_as_string!(i64, serialize_i64_as_string, serialize_opt_i64_as_string);
impl_num_as_string!(u64, serialize_u64_as_string, serialize_opt_u64_as_string);
macro_rules! impl_num_vec_as_string {
($ty:ty, $vec_ser:ident) => {
pub fn $vec_ser<S>(value: &Vec<$ty>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
use serde::ser::SerializeSeq;
let mut seq = serializer.serialize_seq(Some(value.len()))?;
for element in value {
seq.serialize_element(&element.to_string())?;
}
seq.end()
}
};
}
impl_num_vec_as_string!(i8, serialize_vec_i8_as_string);
impl_num_vec_as_string!(u8, serialize_vec_u8_as_string);
impl_num_vec_as_string!(i16, serialize_vec_i16_as_string);
impl_num_vec_as_string!(u16, serialize_vec_u16_as_string);
impl_num_vec_as_string!(i32, serialize_vec_i32_as_string);
impl_num_vec_as_string!(u32, serialize_vec_u32_as_string);
impl_num_vec_as_string!(i64, serialize_vec_i64_as_string);
impl_num_vec_as_string!(u64, serialize_vec_u64_as_string);
pub fn deserialize_opt_string_or_number_to_u64<'de, D>(
deserializer: D,
) -> Result<Option<u64>, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_option(OptU64Visitor)
}
struct OptU64Visitor;
impl<'de> serde::de::Visitor<'de> for OptU64Visitor {
type Value = Option<u64>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a u64 number, string, null, or missing field")
}
fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: serde::Deserializer<'de>,
{
deserializer.deserialize_any(U64OptionValueVisitor)
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(None)
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(None)
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(Some(value))
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if value >= 0 {
Ok(Some(value as u64))
} else {
Err(serde::de::Error::custom(format!(
"负数不能转换为 u64: {}",
value
)))
}
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if value.is_empty() {
Ok(None)
} else {
Ok(value.parse::<u64>().map(Some).unwrap_or(None))
}
}
}
struct U64OptionValueVisitor;
impl<'de> serde::de::Visitor<'de> for U64OptionValueVisitor {
type Value = Option<u64>;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a u64 number or string")
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(Some(value))
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if value >= 0 {
Ok(Some(value as u64))
} else {
Err(serde::de::Error::custom(format!(
"负数不能转换为 u64: {}",
value
)))
}
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if value.is_empty() {
Ok(None)
} else {
Ok(value.parse::<u64>().map(Some).unwrap_or(None))
}
}
}
macro_rules! impl_vec_string_or_number_to_num {
($ty:ty, $deser:ident, $opt_deser:ident) => {
pub fn $deser<'de, D>(deserializer: D) -> Result<Vec<$ty>, D::Error>
where
D: Deserializer<'de>,
{
let values: Vec<Value> = Vec::deserialize(deserializer)?;
values
.into_iter()
.map(|v| value_to_number::<$ty>(v).map_err(de::Error::custom))
.collect()
}
pub fn $opt_deser<'de, D>(deserializer: D) -> Result<Option<Vec<$ty>>, D::Error>
where
D: Deserializer<'de>,
{
let opt_value: Option<Vec<Value>> = Option::deserialize(deserializer)?;
match opt_value {
None => Ok(None),
Some(values) => {
let result: Result<Vec<$ty>, _> = values
.into_iter()
.map(|v| match v {
Value::Null => Ok(Default::default()), other => value_to_number::<$ty>(other).map_err(de::Error::custom),
})
.collect();
result.map(Some)
}
}
}
};
}
impl_vec_string_or_number_to_num!(
i64,
deserialize_vec_string_or_number_to_i64,
deserialize_opt_vec_string_or_number_to_i64
);
impl_vec_string_or_number_to_num!(
u64,
deserialize_vec_string_or_number_to_u64,
deserialize_opt_vec_string_or_number_to_u64
);
pub fn deserialize_string_to_naive_datetime<'de, D>(
deserializer: D,
) -> Result<chrono::NaiveDateTime, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(&s, "%Y-%m-%dT%H:%M:%S") {
return Ok(dt);
}
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(&s, "%Y-%m-%d %H:%M:%S") {
return Ok(dt);
}
if let Ok(date) = chrono::NaiveDate::parse_from_str(&s, "%Y-%m-%d") {
return Ok(date.and_hms_opt(0, 0, 0).unwrap());
}
Err(de::Error::custom(format!(
"无效的日期时间格式: '{}'. 支持的格式: '2026-04-09T00:00:00' 或 '2026-04-09 00:00:00'",
s
)))
}
pub fn deserialize_opt_string_to_naive_datetime<'de, D>(
deserializer: D,
) -> Result<Option<chrono::NaiveDateTime>, D::Error>
where
D: Deserializer<'de>,
{
let opt_s: Option<String> = Option::deserialize(deserializer)?;
match opt_s {
None => Ok(None),
Some(s) => {
if s.is_empty() {
return Ok(None);
}
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(&s, "%Y-%m-%dT%H:%M:%S") {
return Ok(Some(dt));
}
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(&s, "%Y-%m-%d %H:%M:%S") {
return Ok(Some(dt));
}
if let Ok(date) = chrono::NaiveDate::parse_from_str(&s, "%Y-%m-%d") {
return Ok(Some(date.and_hms_opt(0, 0, 0).unwrap()));
}
Err(de::Error::custom(format!(
"无效的日期时间格式: '{}'. 支持的格式: '2026-04-09T00:00:00' 或 '2026-04-09 00:00:00'",
s
)))
}
}
}
pub fn deserialize_string_or_number_to_f64<'de, D>(
deserializer: D,
) -> Result<f64, D::Error>
where
D: Deserializer<'de>,
{
let value = Value::deserialize(deserializer)?;
match value {
Value::String(s) => s
.parse::<f64>()
.map_err(|e| de::Error::custom(format!("无效的浮点字符串 '{}': {}", s, e))),
Value::Number(num) => num
.as_f64()
.ok_or_else(|| de::Error::custom(format!("无效的数字 {}", num))),
_ => Err(de::Error::custom("期望一个字符串或数字")),
}
}
pub fn deserialize_opt_string_or_number_to_f64<'de, D>(
deserializer: D,
) -> Result<Option<f64>, D::Error>
where
D: Deserializer<'de>,
{
let value: Option<Value> = Option::deserialize(deserializer)?;
match value {
None => Ok(None),
Some(Value::String(s)) => {
if s.is_empty() {
return Ok(None);
}
s.parse::<f64>()
.map(Some)
.map_err(|e| de::Error::custom(format!("无效的浮点字符串 '{}': {}", s, e)))
}
Some(Value::Number(num)) => num
.as_f64()
.map(Some)
.ok_or_else(|| de::Error::custom(format!("无效的数字 {}", num))),
Some(Value::Null) => Ok(None),
_ => Err(de::Error::custom("期望一个字符串、数字或 null")),
}
}
pub fn deserialize_string_or_number_to_bool<'de, D>(
deserializer: D,
) -> Result<bool, D::Error>
where
D: Deserializer<'de>,
{
let value = Value::deserialize(deserializer)?;
parse_bool_value(&value).ok_or_else(|| {
de::Error::custom(format!(
"无法解析为 bool,支持: true/false, 1/0, yes/no"
))
})
}
pub fn deserialize_opt_string_or_number_to_bool<'de, D>(
deserializer: D,
) -> Result<Option<bool>, D::Error>
where
D: Deserializer<'de>,
{
let value: Option<Value> = Option::deserialize(deserializer)?;
match value {
None | Some(Value::Null) => Ok(None),
Some(v) => parse_bool_value(&v)
.map(Some)
.ok_or_else(|| {
de::Error::custom(format!(
"无法解析为 bool,支持: true/false, 1/0, yes/no"
))
}),
}
}
fn parse_bool_value(value: &Value) -> Option<bool> {
match value {
Value::Bool(b) => Some(*b),
Value::Number(n) => {
if n.as_u64() == Some(1) {
Some(true)
} else if n.as_u64() == Some(0) {
Some(false)
} else {
None
}
}
Value::String(s) => match s.to_lowercase().as_str() {
"true" | "1" | "yes" => Some(true),
"false" | "0" | "no" => Some(false),
_ => None,
},
_ => None,
}
}
pub fn deserialize_comma_separated_string<'de, D>(
deserializer: D,
) -> Result<Vec<String>, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
Ok(parse_comma_separated(&s))
}
pub fn deserialize_opt_comma_separated_string<'de, D>(
deserializer: D,
) -> Result<Option<Vec<String>>, D::Error>
where
D: Deserializer<'de>,
{
let opt_s: Option<String> = Option::deserialize(deserializer)?;
match opt_s {
None => Ok(None),
Some(s) if s.trim().is_empty() => Ok(None),
Some(s) => Ok(Some(parse_comma_separated(&s))),
}
}
fn parse_comma_separated(s: &str) -> Vec<String> {
s.split(',')
.map(|item| item.trim().to_string())
.filter(|item| !item.is_empty())
.collect()
}
pub fn serialize_vec_string_as_comma_separated<S>(
value: &[String],
serializer: S,
) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&value.join(","))
}
pub fn serialize_opt_vec_string_as_comma_separated<S>(
value: &Option<Vec<String>>,
serializer: S,
) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match value {
Some(v) => serializer.serialize_str(&v.join(",")),
None => serializer.serialize_none(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde::Deserialize;
#[derive(Deserialize)]
struct TestF64 {
#[serde(deserialize_with = "deserialize_string_or_number_to_f64")]
value: f64,
}
#[derive(Deserialize)]
struct TestOptF64 {
#[serde(
default,
deserialize_with = "deserialize_opt_string_or_number_to_f64"
)]
value: Option<f64>,
}
#[derive(Deserialize)]
struct TestBool {
#[serde(deserialize_with = "deserialize_string_or_number_to_bool")]
value: bool,
}
#[derive(Deserialize)]
struct TestOptBool {
#[serde(
default,
deserialize_with = "deserialize_opt_string_or_number_to_bool"
)]
value: Option<bool>,
}
#[derive(Deserialize)]
struct TestCommaSeparated {
#[serde(deserialize_with = "deserialize_comma_separated_string")]
value: Vec<String>,
}
#[derive(Deserialize)]
struct TestOptCommaSeparated {
#[serde(
default,
deserialize_with = "deserialize_opt_comma_separated_string"
)]
value: Option<Vec<String>>,
}
#[test]
fn test_f64_from_number() {
let json = r#"{"value": 3.14}"#;
let result: TestF64 = serde_json::from_str(json).unwrap();
assert!((result.value - 3.14).abs() < f64::EPSILON);
}
#[test]
fn test_f64_from_string() {
let json = r#"{"value": "3.14"}"#;
let result: TestF64 = serde_json::from_str(json).unwrap();
assert!((result.value - 3.14).abs() < f64::EPSILON);
}
#[test]
fn test_opt_f64_none() {
let json = r#"{}"#;
let result: TestOptF64 = serde_json::from_str(json).unwrap();
assert!(result.value.is_none());
}
#[test]
fn test_opt_f64_some() {
let json = r#"{"value": "2.718"}"#;
let result: TestOptF64 = serde_json::from_str(json).unwrap();
assert!((result.value.unwrap() - 2.718).abs() < f64::EPSILON);
}
#[test]
fn test_bool_from_true() {
let json = r#"{"value": true}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(result.value);
}
#[test]
fn test_bool_from_string_true() {
let json = r#"{"value": "true"}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(result.value);
}
#[test]
fn test_bool_from_number_1() {
let json = r#"{"value": 1}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(result.value);
}
#[test]
fn test_bool_from_string_yes() {
let json = r#"{"value": "yes"}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(result.value);
}
#[test]
fn test_bool_from_string_false() {
let json = r#"{"value": "false"}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(!result.value);
}
#[test]
fn test_bool_from_number_0() {
let json = r#"{"value": 0}"#;
let result: TestBool = serde_json::from_str(json).unwrap();
assert!(!result.value);
}
#[test]
fn test_opt_bool_none() {
let json = r#"{}"#;
let result: TestOptBool = serde_json::from_str(json).unwrap();
assert!(result.value.is_none());
}
#[test]
fn test_comma_separated() {
let json = r#"{"value": "a,b,c"}"#;
let result: TestCommaSeparated = serde_json::from_str(json).unwrap();
assert_eq!(result.value, vec!["a", "b", "c"]);
}
#[test]
fn test_comma_separated_with_spaces() {
let json = r#"{"value": "a, b , c"}"#;
let result: TestCommaSeparated = serde_json::from_str(json).unwrap();
assert_eq!(result.value, vec!["a", "b", "c"]);
}
#[test]
fn test_opt_comma_separated_none() {
let json = r#"{}"#;
let result: TestOptCommaSeparated = serde_json::from_str(json).unwrap();
assert!(result.value.is_none());
}
#[test]
fn test_opt_comma_separated_empty() {
let json = r#"{"value": ""}"#;
let result: TestOptCommaSeparated = serde_json::from_str(json).unwrap();
assert!(result.value.is_none());
}
#[test]
fn test_opt_comma_separated_some() {
let json = r#"{"value": "x,y,z"}"#;
let result: TestOptCommaSeparated = serde_json::from_str(json).unwrap();
assert_eq!(result.value.unwrap(), vec!["x", "y", "z"]);
}
}