use serde::{de, Deserialize, Deserializer, Serializer};
use serde_json::Value;
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 fn deserialize_string_or_number_to_i32<'de, D>(deserializer: D) -> Result<i32, D::Error>
where
D: Deserializer<'de>,
{
match Value::deserialize(deserializer)? {
Value::String(s) => s.parse::<i32>().map_err(de::Error::custom),
Value::Number(num) => num
.as_u64()
.map(|n| n as i32)
.ok_or_else(|| de::Error::custom(format!("无效的数字 {}", num))),
_ => Err(de::Error::custom("期望一个字符串或数字")),
}
}
pub fn deserialize_opt_string_or_number_to_i32<'de, D>(
deserializer: D,
) -> Result<Option<i32>, D::Error>
where
D: Deserializer<'de>,
{
match Value::deserialize(deserializer)? {
Value::String(s) => s.parse::<i32>().map(Some).map_err(de::Error::custom),
Value::Number(num) => {
Ok(Some(num.as_u64().map(|n| n as i32).ok_or_else(|| {
de::Error::custom(format!("无效的数字 {}", num))
})?))
}
Value::Null => Ok(None),
_ => Err(de::Error::custom("期望一个字符串或数字")),
}
}
pub fn deserialize_opt_string_or_number_to_u8<'de, D>(
deserializer: D,
) -> Result<Option<u8>, D::Error>
where
D: Deserializer<'de>,
{
match Value::deserialize(deserializer)? {
Value::String(s) => s.parse::<u8>().map(Some).map_err(de::Error::custom),
Value::Number(num) => {
Ok(Some(num.as_u64().map(|n| n as u8).ok_or_else(|| {
de::Error::custom(format!("无效的数字 {}", num))
})?))
}
Value::Null => Ok(None),
_ => Err(de::Error::custom("期望一个字符串或数字")),
}
}
pub fn deserialize_string_or_number_to_u8<'de, D>(deserializer: D) -> Result<u8, D::Error>
where
D: Deserializer<'de>,
{
match Value::deserialize(deserializer)? {
Value::String(s) => s.parse::<u8>().map_err(de::Error::custom),
Value::Number(num) => num
.as_u64()
.map(|n| n as u8)
.ok_or_else(|| de::Error::custom(format!("无效的数字 {}", num))),
_ => Err(de::Error::custom("期望一个字符串或数字")),
}
}
pub fn default_zero_str() -> String {
"0".to_string()
}
pub fn default_zero_i32() -> i32 {
0
}
pub fn default_zero_u8() -> u8 {
0
}
pub fn default_page_num() -> u32 {
1
}
pub fn default_page_size() -> u32 {
10
}
pub fn serialize_i64_as_string<S>(value: &i64, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_str(&value)
}
pub fn serialize_u64_as_string<S>(value: &u64, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_str(&value)
}
pub fn serialize_opt_u64_as_string<S>(value: &Option<u64>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match value {
Some(v) => serializer.collect_str(&v),
None => serializer.serialize_none(),
}
}
pub fn serialize_opt_u8_as_string<S>(value: &Option<u8>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match value {
Some(v) => serializer.collect_str(&v),
None => serializer.serialize_none(),
}
}
pub fn serialize_vec_u64_as_string<S>(value: &Vec<u64>, 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()
}
pub fn deserialize_string_or_number_to_i64<'de, D>(deserializer: D) -> Result<i64, D::Error>
where
D: Deserializer<'de>,
{
match Value::deserialize(deserializer)? {
Value::String(s) => s.parse::<i64>().map_err(de::Error::custom),
Value::Number(num) => num
.as_i64()
.ok_or_else(|| de::Error::custom(format!("无效的数字 {}", num))),
_ => Err(de::Error::custom("期望一个字符串或数字")),
}
}
pub fn deserialize_string_or_number_to_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
where
D: Deserializer<'de>,
{
match Value::deserialize(deserializer)? {
Value::String(s) => s.parse::<u64>().map_err(de::Error::custom),
Value::Number(num) => num
.as_u64()
.ok_or_else(|| de::Error::custom(format!("无效的数字 {}", num))),
_ => Err(de::Error::custom("期望一个字符串或数字")),
}
}
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))
}
}
}
pub fn deserialize_vec_string_or_number_to_u64<'de, D>(
deserializer: D,
) -> Result<Vec<u64>, D::Error>
where
D: Deserializer<'de>,
{
let values: Vec<Value> = Vec::deserialize(deserializer)?;
values
.into_iter()
.enumerate()
.map(|(_index, value)| match value {
Value::String(s) => s
.parse::<u64>()
.map_err(|e| de::Error::custom(format!("无效的字符串 '{}': {}", s, e))),
Value::Number(num) => num
.as_u64()
.ok_or_else(|| de::Error::custom(format!("无效的数字 {}", num))),
_ => Err(de::Error::custom(format!("期望一个字符串或数字"))),
})
.collect()
}
pub fn deserialize_opt_vec_string_or_number_to_u64<'de, D>(
deserializer: D,
) -> Result<Option<Vec<u64>>, 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<u64>, _> = values
.into_iter()
.enumerate()
.map(|(_index, value)| match value {
Value::String(s) => s
.parse::<u64>()
.map_err(|e| de::Error::custom(format!("无效的字符串 '{}': {}", s, e))),
Value::Number(num) => num
.as_u64()
.ok_or_else(|| de::Error::custom(format!("无效的数字 {}", num))),
Value::Null => Ok(0), _ => Err(de::Error::custom(format!("期望一个字符串或数字"))),
})
.collect();
result.map(Some)
}
}
}
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
)))
}
}
}