Splits database into a separate crate

gamenight-database/src/user.rs

@@ -0,0 +1,140 @@
+use argon2::password_hash::Salt;
+use diesel::Connection;
+use serde::{Serialize, Deserialize};
+use uuid::Uuid;
+use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl, Insertable, Queryable};
+use diesel_derive_enum::DbEnum;
+use argon2::password_hash::SaltString;
+use argon2::PasswordHash;
+use argon2::PasswordVerifier;
+use argon2::Argon2;
+use argon2::password_hash::PasswordHasher;
+use argon2::password_hash::rand_core::OsRng;
+use argon2::password_hash::rand_core::RngCore;
+use crate::DbConnection;
+
+use super::schema::{pwd, users};
+pub use super::error::DatabaseError;
+
+
+
+#[derive(Serialize, Deserialize, Debug, Insertable, Queryable)]
+#[diesel(table_name = pwd)]
+struct Pwd {
+    user_id: Uuid,
+    password: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Insertable, Queryable)]
+#[diesel(table_name = users)]
+pub struct User {
+    pub id: Uuid,
+    pub username: String,
+    pub email: String,
+    pub role: Role,
+}
+
+#[derive(DbEnum, Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
+#[ExistingTypePath = "crate::schema::sql_types::Role"]
+pub enum Role {
+    Admin,
+    User
+}
+
+pub struct LoginUser {
+    pub username: String,
+    pub password: String
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct LoginResult {
+    pub result: bool,
+    pub user: Option<User>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct RegisterResult {
+    pub result: bool,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Register {
+    pub username: String,
+    pub email: String,
+    pub password: String
+}
+
+pub fn login(conn: &mut DbConnection, user: LoginUser) -> Result<Option<User>, DatabaseError> {
+    let id: Uuid = users::table
+        .filter(users::username.eq(&user.username))
+        .or_filter(users::email.eq(&user.username))
+        .select(users::id)
+        .first(conn)?;
+
+    let pwd: String = pwd::table
+        .filter(pwd::user_id.eq(id))
+        .select(pwd::password)
+        .first(conn)?;
+
+    let parsed_hash = PasswordHash::new(&pwd)?;
+
+    if Argon2::default()
+        .verify_password(user.password.as_bytes(), &parsed_hash)
+        .is_ok()
+    {
+        Ok(Some(users::table.find(id).first(conn)?))
+    } else {
+        Ok(None)
+    } 
+}
+
+pub fn get_user(conn: &mut DbConnection, id: Uuid) -> Result<User, DatabaseError> {
+    Ok(users::table.find(id).first(conn)?)
+}
+
+pub fn register(conn: &mut DbConnection, register: Register) -> Result<(), DatabaseError> {
+    let mut bytes = [0u8; Salt::RECOMMENDED_LENGTH];
+    OsRng.try_fill_bytes(&mut bytes).unwrap();
+    let salt = SaltString::encode_b64(&bytes).unwrap();
+    let argon2 = Argon2::default();
+
+    let password_hash = argon2
+        .hash_password(register.password.as_bytes(), &salt)?
+        .to_string();
+
+    conn.transaction(|c| {
+        let id = Uuid::new_v4();
+
+        diesel::insert_into(users::table)
+            .values(User {
+                id,
+                username: register.username,
+                email: register.email,
+                role: Role::User,
+            })
+            .execute(c)?;
+
+        diesel::insert_into(pwd::table)
+            .values(Pwd {
+                user_id: id,
+                password: password_hash,
+            })
+            .execute(c)?;
+
+        Ok(())
+    })
+}
+
+pub fn count_users_with_username(conn: &mut DbConnection, username: &String) -> Result<i64, DatabaseError> {
+    Ok(users::table
+        .count()
+        .filter(users::username.eq(username))
+        .get_result::<i64>(conn)?)
+}
+
+pub fn count_users_with_email(conn: &mut DbConnection, email: &String) -> Result<i64, DatabaseError> {
+    Ok(users::table
+        .count()
+        .filter(users::email.eq(email))
+        .get_result::<i64>(conn)?)
+}