feat: 增强错误处理，添加更多错误类型和验证消息，优化用户创建和删除逻辑

Author: ftzahao

src/errors.rs

@@ -4,14 +4,33 @@ use sea_orm::DbErr;
 use serde::Serialize;
 use std::fmt;
 
+/// 应用程序的统一错误类型
 #[derive(Debug)]
 pub enum AppError {
+    /// 数据库相关错误
     DbError(DbErr),
+    /// JWT 相关错误
     JwtError(JwtError),
+    /// 校验失败错误，包含错误信息
     ValidationError(String),
+    /// 资源未找到错误，包含错误信息
     NotFound(String),
+    /// 未授权访问错误，包含错误信息
     Unauthorized(String),
+    /// 内部服务器错误，包含错误信息
     InternalError(String),
+    /// 解析错误，包含错误信息
+    ParseError(String),
+    /// 冲突错误，包含错误信息
+    Conflict(String),
+    /// 禁止访问错误，包含错误信息
+    Forbidden(String),
+    /// 请求超时错误，包含错误信息
+    Timeout(String),
+    /// 错误请求，包含错误信息
+    BadRequest(String),
+    /// 服务不可用，包含错误信息
+    ServiceUnavailable(String),
 }
 
 #[derive(Serialize)]
@@ -23,12 +42,18 @@ struct ErrorResponse {
 impl fmt::Display for AppError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            AppError::DbError(e) => write!(f, "Database error: {}", e),
-            AppError::JwtError(e) => write!(f, "Token error: {}", e),
+            AppError::DbError(e) => write!(f, "{e}"),
+            AppError::JwtError(e) => write!(f, "{e}"),
             AppError::ValidationError(m)
             | AppError::NotFound(m)
             | AppError::Unauthorized(m)
-            | AppError::InternalError(m) => write!(f, "{}", m),
+            | AppError::InternalError(m)
+            | AppError::ParseError(m)
+            | AppError::Conflict(m)
+            | AppError::Forbidden(m)
+            | AppError::Timeout(m)
+            | AppError::BadRequest(m)
+            | AppError::ServiceUnavailable(m) => write!(f, "{m}"),
         }
     }
 }
@@ -37,9 +62,15 @@ impl ResponseError for AppError {
     fn status_code(&self) -> StatusCode {
         match self {
             AppError::DbError(_) | AppError::InternalError(_) => StatusCode::INTERNAL_SERVER_ERROR,
-            AppError::ValidationError(_) => StatusCode::BAD_REQUEST,
+            AppError::ValidationError(_) | AppError::ParseError(_) | AppError::BadRequest(_) => {
+                StatusCode::BAD_REQUEST
+            }
             AppError::NotFound(_) => StatusCode::NOT_FOUND,
             AppError::Unauthorized(_) | AppError::JwtError(_) => StatusCode::UNAUTHORIZED,
+            AppError::Conflict(_) => StatusCode::CONFLICT,
+            AppError::Forbidden(_) => StatusCode::FORBIDDEN,
+            AppError::Timeout(_) => StatusCode::REQUEST_TIMEOUT,
+            AppError::ServiceUnavailable(_) => StatusCode::SERVICE_UNAVAILABLE,
         }
     }
     fn error_response(&self) -> HttpResponse {
@@ -50,7 +81,6 @@ impl ResponseError for AppError {
     }
 }
 
-// 自动从 sea_orm::DbErr & jsonwebtoken::Error 转换
 impl From<DbErr> for AppError {
     fn from(e: DbErr) -> Self {
         AppError::DbError(e)
@@ -61,3 +91,9 @@ impl From<JwtError> for AppError {
         AppError::JwtError(e)
     }
 }
+
+impl From<std::num::ParseIntError> for AppError {
+    fn from(e: std::num::ParseIntError) -> Self {
+        AppError::ParseError(format!("{e}"))
+    }
+}

src/handlers/users.rs

@@ -8,6 +8,7 @@ use sea_orm::{
     ActiveModelTrait, ActiveValue::NotSet, ColumnTrait, DeleteResult, EntityTrait, QueryFilter, Set,
 };
 use serde::{Deserialize, Serialize};
+use validator::Validate;
 
 #[derive(Deserialize, Serialize, Debug)]
 struct Info {
@@ -45,7 +46,7 @@ pub async fn get_query_users(
 #[derive(Deserialize, Serialize, Debug, Validate)]
 struct CreateUser {
     name: String,
-    #[validate(email)]
+    #[validate(email(message = "无效的邮箱地址"))]
     email: String,
     pass_word: String,
 }
@@ -55,11 +56,15 @@ pub async fn create_user(
     app_data: web::Data<AppState>,
 ) -> Result<HttpResponse, AppError> {
     println!("{:#?}", params);
+    // 参数验证
+    if let Err(e) = params.validate() {
+        return Err(AppError::ValidationError(format!("{e}")));
+    }
 
     let argon2_config = argon2::Config::default();
     let hashed_password =
         argon2::hash_encoded(params.pass_word.as_bytes(), ARGON2_SALT, &argon2_config)
-            .map_err(|e| AppError::InternalError(format!("Password hashing error: {}", e)))?;
+            .map_err(|e| AppError::InternalError(format!("{e}")))?;
 
     // 使用 sea-orm 创建用户
     let user = users::ActiveModel {
@@ -84,10 +89,13 @@ pub async fn create_user(
 
 #[delete("/users/delete/{id}")]
 pub async fn delete_user(
-    id: web::Path<i64>,
+    id: web::Path<String>,
     app_data: web::Data<AppState>,
 ) -> Result<HttpResponse, AppError> {
-    let user_id = id.into_inner();
+    let id_str = id.into_inner();
+    let user_id: i64 = id_str
+        .parse()
+        .map_err(|_| AppError::ParseError(format!("无法解析用户ID: {id_str}")))?;
     println!("删除用户 ID: {}", user_id);
 
     // 先删除该用户下的所有设备
@@ -99,12 +107,11 @@ pub async fn delete_user(
 
     // 使用 sea-orm 删除用户
     let model = users::Entity::find_by_id(user_id).one(&app_data.db).await?;
-    let user: users::ActiveModel = model
-        .ok_or(AppError::NotFound(format!(
-            "User with id {} not found",
-            user_id
-        )))?
-        .into();
+    if model.is_none() {
+        // 统一返回 AppError::NotFound，保证响应格式一致
+        return Err(AppError::NotFound(format!("用户ID {user_id} 不存在")));
+    }
+    let user: users::ActiveModel = model.unwrap().into();
 
     let delete_result = user.delete(&app_data.db).await?;
     println!("删除结果: {:?}", delete_result);