debt-pirate/api/src/db/user.rs

use std::fmt::Debug;

use sqlx::prelude::FromRow;
use tracing::error;

use crate::models::AppError;

use super::DbPool;

#[derive(Clone)]
pub struct NewUserEntity {
    pub username: String,
    pub password: String,
    pub email: String,
    pub name: String,
}

impl Debug for NewUserEntity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("NewUserEntity")
            .field("username", &self.username)
            .field("password", &"********")
            .field("email", &self.email)
            .field("name", &self.name)
            .finish()
    }
}

#[allow(dead_code)]
#[derive(Debug, FromRow)]
pub struct UserEntity {
    pub id: i32,
    pub name: String,
    pub email: String,
    pub status_id: i32,
}

pub async fn insert_new_user(
    pool: &DbPool,
    new_user: NewUserEntity,
) -> Result<UserEntity, AppError> {
    let NewUserEntity {
        username,
        password,
        email,
        name,
    } = new_user.clone();

    sqlx::query_as::<_, UserEntity>("INSERT INTO public.user (username, email, password, name) VALUES ($1, $2, $3, $4) RETURNING id, username, email, name, status_id;")
		.bind(username)
		.bind(email)
		.bind(password)
		.bind(name)
		.fetch_one(pool).await
		.map_err(|err| {
			error!(%err, record = ?new_user, "Cannot insert new user record");

			AppError::from(err)
		})
}

#[derive(Debug, FromRow)]
pub struct UserIdAndHashedPassword {
    pub id: i32,
    pub password: String,
}

pub async fn get_username_and_password_by_username(
    pool: &DbPool,
    username: String,
) -> Result<UserIdAndHashedPassword, AppError> {
    sqlx::query_as::<_, UserIdAndHashedPassword>(
        "SELECT id, password FROM public.user WHERE username = $1;",
    )
    .bind(username)
    .fetch_one(pool)
    .await
    .map_err(|err| {
        error!(%err, "Unable to find user");
        AppError::from(err)
    })
}

pub async fn verify_user(pool: &DbPool, user_id: i32) -> Result<(), AppError> {
    sqlx::query("UPDATE public.user SET status_id = 1, updated_at = now() WHERE id = $1;")
        .bind(user_id)
        .execute(pool)
        .await
        .map_err(|err| {
            error!(%err, user_id, "Error verifying user");
            AppError::from(err)
        })
        .map(|_| ())
}