rsgl/rust-demo
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加 UserInput 模型，更新用户服务以支持新用户注册功能，重构相关路由

Browse Source
This commit is contained in:
rsgl 2024-11-16 23:45:37 +08:00
parent 5c8ac42e8a
commit 7f89249f83
6 changed files with 126 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/models/mod.rs
View File

@ -1 +1,2 @@
pub mod user;
pub mod user_input;

4
src/models/user.rs
View File

@ -3,7 +3,7 @@ use mysql::{FromRowError, Row};
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct User {
pub id: i32,
pub id: Option<i32>,
pub name: String,
pub age: i32,
pub email: String,
@ -15,7 +15,7 @@ impl FromRow for User {
let (id, name, age, email, password) =
mysql::from_row::<(i32, String, i32, String, String)>(row);
Ok(User {
id,
id: Some(id),
name,
age,
email,

7
src/models/user_input.rs Normal file
View File

@ -0,0 +1,7 @@
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct UserInput {
pub name: Option<String>,
pub age: Option<i32>,
pub email: Option<String>,
pub password: Option<String>,
}

174
src/repositories/user_repository.rs
View File

@ -1,25 +1,24 @@
use crate::models::user::User;
use mysql::params;
use mysql::prelude::Queryable;
use r2d2::Pool;
use r2d2_mysql::MySqlConnectionManager;
pub struct UserRepository<'a> {
pub pool: &'a mut Pool<MySqlConnectionManager>,
pub pool: &'a mut r2d2::Pool<r2d2_mysql::MySqlConnectionManager>,
}
impl<'a> UserRepository<'a> {
pub fn new(pool: &'a mut Pool<MySqlConnectionManager>) -> UserRepository {
pub fn new(pool: &'a mut r2d2::Pool<r2d2_mysql::MySqlConnectionManager>) -> UserRepository {
UserRepository { pool }
}
/**
* 新建用户
*/
pub fn create_user(&mut self, user: &User) -> Result<(), mysql::Error> {
pub fn create_user(&mut self, user: &mut User) -> Result<(), mysql::Error> {
let mut conn = self.pool.get().unwrap();
let sql = r"INSERT INTO users (id, name, age, email, password) VALUES (:id, :name, :age, :email, :password)";
conn.exec_drop(
r"INSERT INTO users (id, name, age, email, password) VALUES (:id, :name, :age, :email, :password)",
sql,
params! {
"id" => &user.id,
"name" => &user.name,
@ -30,91 +29,90 @@ impl<'a> UserRepository<'a> {
)
}
/**
* 删除用户
*/
pub fn delete_user(&mut self, user: &User) -> Result<(), mysql::Error> {
let mut conn = self.pool.get().unwrap();
conn.exec_drop(
r"DELETE FROM users WHERE id = :id",
params! {
"id" => &user.id,
},
)
}
// /**
// * 删除用户
// */
// pub fn delete_user(&mut self, user: &User) -> Result<(), mysql::Error> {
// let mut conn = self.pool.get().unwrap();
// conn.exec_drop(
// r"DELETE FROM users WHERE id = :id",
// params! {
// "id" => &user.id,
// },
// )
// }
/**
* 更新用户
*/
pub fn update_user(&mut self, user: &User) -> Result<(), mysql::Error> {
let mut conn = self.pool.get().unwrap();
conn.exec_drop(
r"UPDATE users SET name = :name, age = :age, email = :email, password = :password WHERE id = :id",
params! {
"id" => &user.id,
"name" => &user.name,
"age" => &user.age,
"email" => &user.email,
"password" => &user.password,
},
)
}
// /**
// * 更新用户
// */
// pub fn update_user(&mut self, user: &User) -> Result<(), mysql::Error> {
// let mut conn = self.pool.get().unwrap();
// conn.exec_drop(
// r"UPDATE users SET name = :name, age = :age, email = :email, password = :password WHERE id = :id",
// params! {
// "id" => &user.id,
// "name" => &user.name,
// "age" => &user.age,
// "email" => &user.email,
// "password" => &user.password,
// },
// )
// }
/**
* 查询所有用户
*/
// /**
// * 查询所有用户
// */
// pub fn query_all_user(&mut self) -> Result<Vec<User>, mysql::Error> {
// let mut conn = self.pool.get().unwrap();
// conn.query_map(
// "SELECT id, name, age, email, password FROM users",
// |(id, name, age, email, password)| User {
// id,
// name,
// age,
// email,
// password,
// },
// )
// }
pub fn query_all_user(&mut self) -> Result<Vec<User>, mysql::Error> {
let mut conn = self.pool.get().unwrap();
conn.query_map(
"SELECT id, name, age, email, password FROM users",
|(id, name, age, email, password)| User {
id,
name,
age,
email,
password,
},
)
}
// /**
// * 根据ID查询用户
// */
// pub fn query_user_by_id(&mut self, id: i32) -> Result<Option<User>, mysql::Error> {
// let mut conn = self.pool.get().unwrap();
// let result: Option<User> = conn.exec_first(
// "SELECT id, name, age, email, password FROM users WHERE id = :id",
// params! {
// "id" => id,
// },
// )?;
// Ok(result)
// }
/**
* 根据ID查询用户
*/
pub fn query_user_by_id(&mut self, id: i32) -> Result<Option<User>, mysql::Error> {
let mut conn = self.pool.get().unwrap();
let result: Option<User> = conn.exec_first(
"SELECT id, name, age, email, password FROM users WHERE id = :id",
params! {
"id" => id,
},
)?;
Ok(result)
}
// /**
// * 根据用户名查询用户
// */
// pub fn query_user_by_name(&mut self, name: &str) -> Result<Option<User>, mysql::Error> {
// let mut conn = self.pool.get().unwrap();
// conn.exec_first(
// "SELECT id, name, age, email, password FROM users WHERE name = :name",
// params! {
// "name" => name,
// },
// )
// }
/**
* 根据用户名查询用户
*/
pub fn query_user_by_name(&mut self, name: &str) -> Result<Option<User>, mysql::Error> {
let mut conn = self.pool.get().unwrap();
conn.exec_first(
"SELECT id, name, age, email, password FROM users WHERE name = :name",
params! {
"name" => name,
},
)
}
/**
* 根据邮箱查询用户
*/
pub fn query_user_by_email(&mut self, email: &str) -> Result<Option<User>, mysql::Error> {
let mut conn = self.pool.get().unwrap();
conn.exec_first(
"SELECT id, name, age, email, password FROM users WHERE email = :email",
params! {
"email" => email,
},
)
}
// /**
// * 根据邮箱查询用户
// */
// pub fn query_user_by_email(&mut self, email: &str) -> Result<Option<User>, mysql::Error> {
// let mut conn = self.pool.get().unwrap();
// conn.exec_first(
// "SELECT id, name, age, email, password FROM users WHERE email = :email",
// params! {
// "email" => email,
// },
// )
// }
}

94
src/routes/user_routes.rs
View File

@ -1,96 +1,18 @@
use crate::models::user::User;
use crate::models::user_input::UserInput;
use crate::repositories::user_repository;
use crate::services::user_service;
use crate::utils::pool;
use actix_web::{get, post, web, HttpResponse, Responder};
use serde::Deserialize;
use actix_web::{post, web, HttpResponse, Responder};
pub(crate) fn register(config: &mut web::ServiceConfig) {
config.service(register_user);
config.service(query_all_user);
config.service(query_user_by_id);
config.service(query_user_by_email);
config.service(query_user_by_name);
config.service(update_user);
config.service(delete_user);
}
#[derive(Deserialize)]
struct RegisterUser {
name: String,
age: i32,
email: String,
password: String,
}
#[post("/user/register")]
async fn register_user(user: web::Json<RegisterUser>) -> impl Responder {
let pool = pool::get_database_pool().unwrap();
let mut conn = pool.get().unwrap();
let mut new_user = User {
id: 0,
name: user.name.clone(),
age: user.age,
email: user.email.clone(),
password: user.password.clone(),
};
user_service::create_user(&mut conn, &mut new_user).unwrap();
async fn register_user(mut user: web::Json<UserInput>) -> impl Responder {
let mut pool = pool::get_database_pool().unwrap();
let mut user_repository = user_repository::UserRepository::new(&mut pool);
let mut user_service = user_service::UserService::new(&mut user_repository);
user_service.create_user(&mut user).unwrap();
HttpResponse::Ok().json("SUCCESS")
}
#[get("/user/query_all_user")]
async fn query_all_user() -> impl Responder {
let pool = pool::get_database_pool().unwrap();
let mut conn = pool.get().unwrap();
let users = user_service::query_all_user(&mut conn).unwrap();
HttpResponse::Ok().json(users)
}
#[get("/user/{id}")]
async fn query_user_by_id(path: web::Path<i32>) -> impl Responder {
let id = path.into_inner();
let pool = pool::get_database_pool().unwrap();
let mut conn = pool.get().unwrap();
match user_service::query_user_by_id(&mut conn, id) {
Ok(user) => HttpResponse::Ok().json(user),
Err(_) => HttpResponse::NotFound().json("User not found"),
}
}
#[get("/user/{email}")]
async fn query_user_by_email(path: web::Path<String>) -> impl Responder {
let pool = pool::get_database_pool().unwrap();
let mut conn = pool.get().unwrap();
let email = path.into_inner();
match user_service::query_user_by_email(&mut conn, email.as_str()) {
Ok(user) => HttpResponse::Ok().json(user),
Err(_) => HttpResponse::NotFound().json("User not found"),
}
}
#[get("/user/{name}")]
async fn query_user_by_name(path: web::Path<String>) -> impl Responder {
let pool = pool::get_database_pool().unwrap();
let mut conn = pool.get().unwrap();
let name = path.into_inner();
match user_service::query_user_by_name(&mut conn, name.as_str()) {
Ok(user) => HttpResponse::Ok().json(user),
Err(_) => HttpResponse::NotFound().json("User not found"),
}
}
#[post("/user/update")]
async fn update_user(user: web::Json<User>) -> impl Responder {
let pool = pool::get_database_pool().unwrap();
let mut conn = pool.get().unwrap();
user_service::update_user(&mut conn, &user).unwrap();
HttpResponse::Ok().json("User updated successfully")
}
#[post("/user/delete")]
async fn delete_user(user: web::Json<User>) -> impl Responder {
let pool = pool::get_database_pool().unwrap();
let mut conn = pool.get().unwrap();
user_service::delete_user(&mut conn, &user).unwrap();
HttpResponse::Ok().json("User deleted successfully")
}

94
src/services/user_service.rs
View File

@ -1,81 +1,31 @@
use crate::models::user::User;
use crate::repositories::user_repository;
use crate::{
models::{user::User, user_input::UserInput},
repositories::user_repository::UserRepository,
};
use bcrypt::{hash, DEFAULT_COST};
use mysql;
use r2d2::PooledConnection;
use r2d2_mysql::{MySqlConnectionManager, mysql::PooledConn};
use mysql::*;
/**
* 新建用户
*/
pub fn create_user(
conn: &mut PooledConn,
user: &mut User,
) -> Result<(), mysql::Error> {
let mut new_user = User {
password: hash(&user.password, DEFAULT_COST).unwrap(),
..user.clone()
};
user_repository::create_user(conn, &mut new_user)
pub struct UserService<'a> {
repository: &'a mut UserRepository<'a>,
}
/**
* 查询所有用户
*/
pub fn query_all_user(
conn: &mut PooledConnection<MySqlConnectionManager>,
) -> Result<Vec<User>, mysql::Error> {
user_repository::query_all_user(conn)
}
pub fn query_user_by_id(
conn: &mut PooledConnection<MySqlConnectionManager>,
id: i32,
) -> Result<Option<User>, mysql::Error> {
user_repository::query_user_by_id(conn, id)
}
pub fn query_user_by_email(
conn: &mut PooledConnection<MySqlConnectionManager>,
email: &str,
) -> Result<Option<User>, mysql::Error> {
user_repository::query_user_by_email(conn, email)
}
pub fn query_user_by_name(
conn: &mut PooledConnection<MySqlConnectionManager>,
name: &str,
) -> Result<Option<User>, mysql::Error> {
user_repository::query_user_by_name(conn, name)
}
pub fn update_user(
conn: &mut PooledConnection<MySqlConnectionManager>,
user: &User,
) -> Result<(), mysql::Error> {
if user_repository::query_user_by_id(conn, user.id)?.is_none() {
return Err(mysql::Error::MySqlError(mysql::MySqlError {
code: 1062,
message: "User not found".to_string(),
state: "".to_string(),
}));
impl<'a> UserService<'a> {
pub fn new(repository: &'a mut UserRepository<'a>) -> Self {
UserService { repository }
}
user_repository::update_user(conn, user)
}
/**
* 新建用户
*/
pub fn create_user(&mut self, user: &UserInput) -> Result<(), mysql::Error> {
let mut new_user = User {
id: Some(0),
name: user.name.as_ref().unwrap().to_string(),
age: *user.age.as_ref().unwrap(),
email: user.email.as_ref().unwrap().to_string(),
password: hash(user.password.as_ref().unwrap(), DEFAULT_COST).unwrap(),
};
pub fn delete_user(
conn: &mut PooledConnection<MySqlConnectionManager>,
user: &User,
) -> Result<(), mysql::Error> {
if user_repository::query_user_by_id(conn, user.id)?.is_none() {
return Err(mysql::Error::MySqlError(mysql::MySqlError {
code: 1062,
message: "User not found".to_string(),
state: "".to_string(),
}));
self.repository.create_user(&mut &mut new_user)
}
user_repository::delete_user(conn, user)
}