use crate::error::BaseError;
use regex::Regex;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
pub type ValidatorFn = Arc<dyn Fn(&str, &serde_json::Value) -> Result<(), BaseError> + Send + Sync>;
#[derive(Clone)]
pub enum Validator {
MinLength(usize),
MaxLength(usize),
Min(f64),
Max(f64),
Email,
Phone,
Url,
Regex(String),
Custom(ValidatorFn),
}
impl Validator {
pub fn display_name(&self) -> &str {
match self {
Validator::MinLength(_) => "最小长度",
Validator::MaxLength(_) => "最大长度",
Validator::Min(_) => "最小值",
Validator::Max(_) => "最大值",
Validator::Email => "邮箱格式",
Validator::Phone => "手机号格式",
Validator::Url => "URL格式",
Validator::Regex(_) => "正则表达式",
Validator::Custom(_) => "自定义验证",
}
}
pub fn validate(&self, field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
match self {
Validator::MinLength(min_len) => {
if let Some(s) = value.as_str() {
let len = s.chars().count();
if len < *min_len {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
format!("字符串长度不能小于 {},当前长度: {}", min_len, len),
));
}
Ok(())
} else {
Err(BaseError::ValidationFailed(
field_name.to_string(),
"MinLength 验证器只能用于字符串类型".to_string(),
))
}
}
Validator::MaxLength(max_len) => {
if let Some(s) = value.as_str() {
let len = s.chars().count();
if len > *max_len {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
format!("字符串长度不能大于 {},当前长度: {}", max_len, len),
));
}
Ok(())
} else {
Err(BaseError::ValidationFailed(
field_name.to_string(),
"MaxLength 验证器只能用于字符串类型".to_string(),
))
}
}
Validator::Min(min_val) => {
let num = if let Some(n) = value.as_f64() {
n
} else if let Some(n) = value.as_i64() {
n as f64
} else if let Some(n) = value.as_u64() {
n as f64
} else {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
"Min 验证器只能用于数值类型".to_string(),
));
};
if num < *min_val {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
format!("数值不能小于 {},当前值: {}", min_val, num),
));
}
Ok(())
}
Validator::Max(max_val) => {
let num = if let Some(n) = value.as_f64() {
n
} else if let Some(n) = value.as_i64() {
n as f64
} else if let Some(n) = value.as_u64() {
n as f64
} else {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
"Max 验证器只能用于数值类型".to_string(),
));
};
if num > *max_val {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
format!("数值不能大于 {},当前值: {}", max_val, num),
));
}
Ok(())
}
Validator::Email => {
if let Some(s) = value.as_str() {
if !s.contains('@') {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
"邮箱格式无效,必须包含 @ 符号".to_string(),
));
}
Ok(())
} else {
Err(BaseError::ValidationFailed(
field_name.to_string(),
"Email 验证器只能用于字符串类型".to_string(),
))
}
}
Validator::Phone => {
if let Some(s) = value.as_str() {
if !s.chars().all(|c| c.is_ascii_digit() || c == '-') {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
"手机号格式无效,只能包含数字和连字符".to_string(),
));
}
Ok(())
} else {
Err(BaseError::ValidationFailed(
field_name.to_string(),
"Phone 验证器只能用于字符串类型".to_string(),
))
}
}
Validator::Url => {
if let Some(s) = value.as_str() {
if !s.starts_with("http://") && !s.starts_with("https://") {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
"URL 格式无效,必须以 http:// 或 https:// 开头".to_string(),
));
}
Ok(())
} else {
Err(BaseError::ValidationFailed(
field_name.to_string(),
"Url 验证器只能用于字符串类型".to_string(),
))
}
}
Validator::Regex(pattern) => {
if let Some(s) = value.as_str() {
let re = Regex::new(pattern).map_err(|e| {
BaseError::ValidationFailed(
field_name.to_string(),
format!("正则表达式无效: {}", e),
)
})?;
if !re.is_match(s) {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
format!("值不匹配正则表达式: {}", pattern),
));
}
Ok(())
} else {
Err(BaseError::ValidationFailed(
field_name.to_string(),
"Regex 验证器只能用于字符串类型".to_string(),
))
}
}
Validator::Custom(func) => func(field_name, value),
}
}
}
impl std::fmt::Debug for Validator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Validator::MinLength(len) => write!(f, "MinLength({})", len),
Validator::MaxLength(len) => write!(f, "MaxLength({})", len),
Validator::Min(val) => write!(f, "Min({})", val),
Validator::Max(val) => write!(f, "Max({})", val),
Validator::Email => write!(f, "Email"),
Validator::Phone => write!(f, "Phone"),
Validator::Url => write!(f, "Url"),
Validator::Regex(pattern) => write!(f, "Regex(\"{}\")", pattern),
Validator::Custom(_) => write!(f, "Custom(<function>)"),
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type", content = "value")]
enum ValidatorSerde {
MinLength(usize),
MaxLength(usize),
Min(f64),
Max(f64),
Email,
Phone,
Url,
Regex(String),
}
impl Serialize for Validator {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let serde_variant = match self {
Validator::MinLength(len) => ValidatorSerde::MinLength(*len),
Validator::MaxLength(len) => ValidatorSerde::MaxLength(*len),
Validator::Min(val) => ValidatorSerde::Min(*val),
Validator::Max(val) => ValidatorSerde::Max(*val),
Validator::Email => ValidatorSerde::Email,
Validator::Phone => ValidatorSerde::Phone,
Validator::Url => ValidatorSerde::Url,
Validator::Regex(pattern) => ValidatorSerde::Regex(pattern.clone()),
Validator::Custom(_) => {
return Err(serde::ser::Error::custom("Custom 验证器无法序列化"));
}
};
serde_variant.serialize(serializer)
}
}
impl<'de> Deserialize<'de> for Validator {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let serde_variant = ValidatorSerde::deserialize(deserializer)?;
Ok(match serde_variant {
ValidatorSerde::MinLength(len) => Validator::MinLength(len),
ValidatorSerde::MaxLength(len) => Validator::MaxLength(len),
ValidatorSerde::Min(val) => Validator::Min(val),
ValidatorSerde::Max(val) => Validator::Max(val),
ValidatorSerde::Email => Validator::Email,
ValidatorSerde::Phone => Validator::Phone,
ValidatorSerde::Url => Validator::Url,
ValidatorSerde::Regex(pattern) => Validator::Regex(pattern),
})
}
}