105 lines
3.4 KiB
Rust
105 lines
3.4 KiB
Rust
cfg_if::cfg_if! {
|
|
if #[cfg(feature = "ssr")] {
|
|
use diesel::prelude::*;
|
|
use crate::database::get_db_conn;
|
|
|
|
use pbkdf2::{
|
|
password_hash::{
|
|
rand_core::OsRng,
|
|
PasswordHasher, PasswordHash, SaltString, PasswordVerifier, Error
|
|
},
|
|
Pbkdf2
|
|
};
|
|
}
|
|
}
|
|
|
|
use leptos::*;
|
|
use crate::models::User;
|
|
|
|
/// Get a user from the database by username or email
|
|
/// Returns a Result with the user if found, None if not found, or an error if there was a problem
|
|
#[cfg(feature = "ssr")]
|
|
pub async fn find_user(username_or_email: String) -> Result<Option<User>, ServerFnError> {
|
|
use crate::schema::users::dsl::*;
|
|
|
|
// Look for either a username or email that matches the input, and return an option with None if no user is found
|
|
let db_con = &mut get_db_conn();
|
|
let user = users.filter(username.eq(username_or_email.clone())).or_filter(email.eq(username_or_email))
|
|
.first::<User>(db_con).optional()
|
|
.map_err(|e| ServerFnError::ServerError(format!("Error getting user from database: {}", e)))?;
|
|
|
|
Ok(user)
|
|
}
|
|
|
|
/// Create a new user in the database
|
|
/// Returns an empty Result if successful, or an error if there was a problem
|
|
#[cfg(feature = "ssr")]
|
|
pub async fn create_user(new_user: &User) -> Result<(), ServerFnError> {
|
|
use crate::schema::users::dsl::*;
|
|
|
|
let new_password = new_user.password.clone()
|
|
.ok_or(ServerFnError::ServerError(format!("No password provided for user {}", new_user.username)))?;
|
|
|
|
let salt = SaltString::generate(&mut OsRng);
|
|
let password_hash = Pbkdf2.hash_password(new_password.as_bytes(), &salt)
|
|
.map_err(|_| ServerFnError::ServerError("Error hashing password".to_string()))?.to_string();
|
|
|
|
let new_user = User {
|
|
password: Some(password_hash),
|
|
..new_user.clone()
|
|
};
|
|
|
|
let db_con = &mut get_db_conn();
|
|
|
|
diesel::insert_into(users).values(&new_user).execute(db_con)
|
|
.map_err(|e| ServerFnError::ServerError(format!("Error creating user: {}", e)))?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Validate a user's credentials
|
|
/// Returns a Result with the user if the credentials are valid, None if not valid, or an error if there was a problem
|
|
#[cfg(feature = "ssr")]
|
|
pub async fn validate_user(username_or_email: String, password: String) -> Result<Option<User>, ServerFnError> {
|
|
let db_user = find_user(username_or_email.clone()).await
|
|
.map_err(|e| ServerFnError::ServerError(format!("Error getting user from database: {}", e)))?;
|
|
|
|
// If the user is not found, return None
|
|
let db_user = match db_user {
|
|
Some(user) => user,
|
|
None => return Ok(None)
|
|
};
|
|
|
|
let db_password = db_user.password.clone()
|
|
.ok_or(ServerFnError::ServerError(format!("No password found for user {}", db_user.username)))?;
|
|
|
|
let password_hash = PasswordHash::new(&db_password)
|
|
.map_err(|e| ServerFnError::ServerError(format!("Error hashing supplied password: {}", e)))?;
|
|
|
|
match Pbkdf2.verify_password(password.as_bytes(), &password_hash) {
|
|
Ok(()) => {},
|
|
Err(Error::Password) => {
|
|
return Ok(None);
|
|
},
|
|
Err(e) => {
|
|
return Err(ServerFnError::ServerError(format!("Error verifying password: {}", e)));
|
|
}
|
|
}
|
|
|
|
Ok(Some(db_user))
|
|
}
|
|
|
|
/// Get a user from the database by username or email
|
|
/// Returns a Result with the user if found, None if not found, or an error if there was a problem
|
|
#[server(endpoint = "get_user")]
|
|
pub async fn get_user(username_or_email: String) -> Result<Option<User>, ServerFnError> {
|
|
let mut user = find_user(username_or_email).await?;
|
|
|
|
// Remove the password hash before returning the user
|
|
if let Some(user) = user.as_mut() {
|
|
user.password = None;
|
|
}
|
|
|
|
Ok(user)
|
|
}
|