From 06d5b6ef9d5a0b8b675bba9ff355a32372c2a39e Mon Sep 17 00:00:00 2001 From: Franklin Date: Sat, 23 Sep 2023 18:40:14 -0400 Subject: [PATCH] Cargo fmt --- src/dao/token.rs | 5 +- src/dao/user.rs | 10 +- src/domain/credential.rs | 4 +- src/dto/users.rs | 2 +- src/resources/expirations.rs | 3 +- src/resources/mod.rs | 2 +- src/service/user.rs | 242 ++++++++++++++++++------------- src/validation/user_validator.rs | 14 +- 8 files changed, 173 insertions(+), 109 deletions(-) diff --git a/src/dao/token.rs b/src/dao/token.rs index cf3af55..bfb4bc3 100644 --- a/src/dao/token.rs +++ b/src/dao/token.rs @@ -27,7 +27,10 @@ pub(crate) async fn update_token( } #[allow(unused)] -pub(crate) async fn remove_token(conn: &mut PgConnection, token_id: &i32) -> Result, Error> { +pub(crate) async fn remove_token( + conn: &mut PgConnection, + token_id: &i32, +) -> Result, Error> { sqlx::query_as(r#"DELETE FROM token WHERE id = $1 RETURNING *;"#) .bind(token_id) .fetch_optional(conn) diff --git a/src/dao/user.rs b/src/dao/user.rs index 193a35f..300b465 100644 --- a/src/dao/user.rs +++ b/src/dao/user.rs @@ -16,7 +16,10 @@ pub(crate) async fn insert_user(conn: &mut PgConnection, user: User) -> Result Result, sqlx::Error> { +pub(crate) async fn get_user_with_id( + conn: &mut PgConnection, + user_id: &i32, +) -> Result, sqlx::Error> { sqlx::query_as( r#" SELECT * FROM "user" where id = $1; @@ -45,7 +48,10 @@ pub(crate) async fn update_user(conn: &mut PgConnection, user: User) -> Result Result, sqlx::Error> { +pub(crate) async fn delete_user( + conn: &mut PgConnection, + user_id: &i32, +) -> Result, sqlx::Error> { sqlx::query_as( r#" DELETE FROM "user" where id = $1 RETURNING *; diff --git a/src/domain/credential.rs b/src/domain/credential.rs index ab5a003..9f541a2 100644 --- a/src/domain/credential.rs +++ b/src/domain/credential.rs @@ -1,6 +1,6 @@ use crate::resources::variable_lengths::{ - MAX_EMAIL_LENGTH, MAX_PHONE_NUMBER_LENGTH, MAX_USERNAME_LENGTH, - MIN_EMAIL_LENGTH, MIN_PHONE_NUMBER_LENGTH, MIN_USERNAME_LENGTH, + MAX_EMAIL_LENGTH, MAX_PHONE_NUMBER_LENGTH, MAX_USERNAME_LENGTH, MIN_EMAIL_LENGTH, + MIN_PHONE_NUMBER_LENGTH, MIN_USERNAME_LENGTH, }; use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; diff --git a/src/dto/users.rs b/src/dto/users.rs index 0762501..a7d531e 100644 --- a/src/dto/users.rs +++ b/src/dto/users.rs @@ -25,4 +25,4 @@ pub struct UserResetPasswordPayload { pub id: i32, pub password: String, pub new_password: String, -} \ No newline at end of file +} diff --git a/src/resources/expirations.rs b/src/resources/expirations.rs index b1ca140..2503c69 100644 --- a/src/resources/expirations.rs +++ b/src/resources/expirations.rs @@ -1,2 +1 @@ - -pub const AUTH_TOKEN_EXPIRATION_TIME_MILLIS: i64 = 604800000; // 7 Days \ No newline at end of file +pub const AUTH_TOKEN_EXPIRATION_TIME_MILLIS: i64 = 604800000; // 7 Days diff --git a/src/resources/mod.rs b/src/resources/mod.rs index 0c7b354..1470d34 100644 --- a/src/resources/mod.rs +++ b/src/resources/mod.rs @@ -1,3 +1,3 @@ pub mod error_messages; -pub mod variable_lengths; pub mod expirations; +pub mod variable_lengths; diff --git a/src/service/user.rs b/src/service/user.rs index 7853a55..61b1e99 100644 --- a/src/service/user.rs +++ b/src/service/user.rs @@ -1,7 +1,3 @@ - -use chrono::Utc; -use log::{debug, error}; -use sqlx::{PgConnection, Postgres, Transaction}; use crate::dao::credential::{fetch_user_credentials, get_credential, insert_credential}; use crate::dao::token::{insert_token, update_token, validate_user_token}; use crate::dao::user::{get_user_with_id, insert_user, update_user}; @@ -10,12 +6,24 @@ use crate::domain::token::Token; use crate::domain::user::User; use crate::dto::token::{AuthenticateUserDto, RefreshAuthTokenForUserDto}; use crate::dto::users::{UserLoginPayload, UserRegisterPayload, UserResetPasswordPayload}; -use crate::resources::error_messages::{ERROR_CREDENTIAL_DOES_NOT_EXIST, ERROR_EXPIRED_TOKEN, ERROR_INCORRECT_TOKEN, ERROR_PASSWORD_INCORRECT, ERROR_TOKEN_NOT_CREATED, ERROR_TOO_MANY_CREDENTIALS, ERROR_USER_ALREADY_EXISTS, ERROR_USER_DOES_NOT_EXIST, ErrorResource}; +use crate::resources::error_messages::{ + ErrorResource, ERROR_CREDENTIAL_DOES_NOT_EXIST, ERROR_EXPIRED_TOKEN, ERROR_INCORRECT_TOKEN, + ERROR_PASSWORD_INCORRECT, ERROR_TOKEN_NOT_CREATED, ERROR_TOO_MANY_CREDENTIALS, + ERROR_USER_ALREADY_EXISTS, ERROR_USER_DOES_NOT_EXIST, +}; use crate::resources::expirations::AUTH_TOKEN_EXPIRATION_TIME_MILLIS; -use crate::utils::hasher::{generate_multiple_random_token_with_rng, hash_password, hash_password_with_existing_salt}; +use crate::utils::hasher::{ + generate_multiple_random_token_with_rng, hash_password, hash_password_with_existing_salt, +}; use crate::validation::user_validator::validate_user_for_creation; +use chrono::Utc; +use log::{debug, error}; +use sqlx::{PgConnection, Postgres, Transaction}; -pub async fn register_user<'a>(transaction: &mut PgConnection, user: UserRegisterPayload) -> Result>> { +pub async fn register_user<'a>( + transaction: &mut PgConnection, + user: UserRegisterPayload, +) -> Result>> { let mut error_resources: Vec = Vec::new(); // Validate user validate_user_for_creation(&user, &mut error_resources); @@ -24,21 +32,13 @@ pub async fn register_user<'a>(transaction: &mut PgConnection, user: UserRegiste error_resources.push(ERROR_TOO_MANY_CREDENTIALS); } for credential_dto in user.credentials.iter() { - match get_credential( - transaction, - credential_dto.credential.clone(), - ) - .await - { - Ok(credential_opt) => { - match credential_opt { - None => {} - Some(_) => { - error_resources.push( - ERROR_USER_ALREADY_EXISTS); - } + match get_credential(transaction, credential_dto.credential.clone()).await { + Ok(credential_opt) => match credential_opt { + None => {} + Some(_) => { + error_resources.push(ERROR_USER_ALREADY_EXISTS); } - } + }, Err(e) => { error!("{}", e); error_resources.push(("ERROR.DATABASE_ERROR", "")); @@ -63,15 +63,16 @@ pub async fn register_user<'a>(transaction: &mut PgConnection, user: UserRegiste let persisted_user; // Insert user in DB - match insert_user(transaction, user_to_insert).await{ + match insert_user(transaction, user_to_insert).await { Ok(user) => { persisted_user = user; - }, + } Err(e) => { error!("{}", e); error_resources.push(("ERROR.DATABASE_ERROR", "")); return Err(error_resources); - }}; + } + }; // Insert Credentials for credential in user.credentials { @@ -85,21 +86,26 @@ pub async fn register_user<'a>(transaction: &mut PgConnection, user: UserRegiste }; } - if let Some(persisted_token) = create_token_for_user(transaction, persisted_user.id, &mut error_resources).await { + if let Some(persisted_token) = + create_token_for_user(transaction, persisted_user.id, &mut error_resources).await + { Ok(persisted_token) } else { Err(error_resources) } } -pub async fn authenticate_user<'a>(conn: &mut PgConnection, user: AuthenticateUserDto) -> Result>> { +pub async fn authenticate_user<'a>( + conn: &mut PgConnection, + user: AuthenticateUserDto, +) -> Result>> { let mut error_resources = Vec::new(); let persisted_user = match get_user_with_id(conn, &user.id).await { Ok(persisted_user_opt) => match persisted_user_opt { None => { error_resources.push(ERROR_USER_DOES_NOT_EXIST); return Err(error_resources); - }, - Some(persisted_user) => persisted_user + } + Some(persisted_user) => persisted_user, }, Err(error) => { error!("{:?}", error); @@ -113,10 +119,12 @@ pub async fn authenticate_user<'a>(conn: &mut PgConnection, user: AuthenticateUs None => { error_resources.push(ERROR_INCORRECT_TOKEN); Err(error_resources) - }, + } Some(persisted_token) => { // Check if persisted_token expired - if Utc::now().timestamp_millis() - persisted_token.last_updated.timestamp_millis() > AUTH_TOKEN_EXPIRATION_TIME_MILLIS { + if Utc::now().timestamp_millis() - persisted_token.last_updated.timestamp_millis() + > AUTH_TOKEN_EXPIRATION_TIME_MILLIS + { // Expired debug!("Expired token: {:?}", persisted_token); error_resources.push(ERROR_EXPIRED_TOKEN); @@ -136,15 +144,18 @@ pub async fn authenticate_user<'a>(conn: &mut PgConnection, user: AuthenticateUs } /// -pub async fn refresh_auth_token<'a>(conn: &mut PgConnection, user: RefreshAuthTokenForUserDto) -> Result> { +pub async fn refresh_auth_token<'a>( + conn: &mut PgConnection, + user: RefreshAuthTokenForUserDto, +) -> Result> { let mut error_resources = Vec::new(); let _persisted_user = match get_user_with_id(conn, &user.id).await { Ok(persisted_user_opt) => match persisted_user_opt { None => { error_resources.push(ERROR_USER_DOES_NOT_EXIST); return Err(error_resources); - }, - Some(persisted_user) => persisted_user + } + Some(persisted_user) => persisted_user, }, Err(error) => { error!("{:?}", error); @@ -171,14 +182,17 @@ pub async fn refresh_auth_token<'a>(conn: &mut PgConnection, user: RefreshAuthTo error_resources.push(("ERROR.DATABASE_ERROR", "")); Err(error_resources) } - } + }; } Err(error_resources) } /// reset a user's password by validating the user's own password. -pub async fn reset_password(conn: &mut PgConnection, user: UserResetPasswordPayload) -> Result>{ +pub async fn reset_password( + conn: &mut PgConnection, + user: UserResetPasswordPayload, +) -> Result> { let mut error_resources: Vec = Vec::new(); let password_matches = match validate_user_password(conn, &user.id, user.password).await { @@ -190,7 +204,8 @@ pub async fn reset_password(conn: &mut PgConnection, user: UserResetPasswordPayl } }; - if let Some(persisted_user) = password_matches { // Change pass + if let Some(persisted_user) = password_matches { + // Change pass match change_password(conn, persisted_user, &user.new_password).await { Ok(user_changed) => Ok(user_changed), Err(e) => { @@ -207,17 +222,24 @@ pub async fn reset_password(conn: &mut PgConnection, user: UserResetPasswordPayl /// ## This resets a user's password without any validations! /// Don't expose this to any public endpoint!! -pub async fn force_reset_password<'a>(conn: &mut PgConnection, user_id: &i32, new_password: String) -> Result> { +pub async fn force_reset_password<'a>( + conn: &mut PgConnection, + user_id: &i32, + new_password: String, +) -> Result> { let persisted_user = match get_user_with_id(conn, user_id).await { - Ok(persisted_user_opt) => match persisted_user_opt { - None => { - error!("Serious error. User doesn't exist but credentials pointing to the user do."); - return Err(("ERROR.DATABASE_ERROR", "Critical. User doesn't exist but credentials pointing to the user do.")); - }, - Some(persisted_user) => { - persisted_user + Ok(persisted_user_opt) => { + match persisted_user_opt { + None => { + error!("Serious error. User doesn't exist but credentials pointing to the user do."); + return Err(( + "ERROR.DATABASE_ERROR", + "Critical. User doesn't exist but credentials pointing to the user do.", + )); + } + Some(persisted_user) => persisted_user, } - }, + } Err(e) => { error!("{}", e); return Err(("ERROR.DATABASE_ERROR", "")); @@ -227,7 +249,10 @@ pub async fn force_reset_password<'a>(conn: &mut PgConnection, user_id: &i32, ne } /// -pub async fn password_login<'a>(conn: &mut Transaction<'a, Postgres>, user: UserLoginPayload) -> Result>>{ +pub async fn password_login<'a>( + conn: &mut Transaction<'a, Postgres>, + user: UserLoginPayload, +) -> Result>> { let mut error_resources = Vec::new(); let persisted_user_credential = match get_credential(conn, user.credential).await { Ok(credential_opt) => match credential_opt { @@ -235,8 +260,8 @@ pub async fn password_login<'a>(conn: &mut Transaction<'a, Postgres>, user: User error!("Credential not found for password login."); error_resources.push(ERROR_CREDENTIAL_DOES_NOT_EXIST); return Err(error_resources); - }, - Some(persisted_credential) => persisted_credential + } + Some(persisted_credential) => persisted_credential, }, Err(e) => { error!("{}", e); @@ -244,27 +269,38 @@ pub async fn password_login<'a>(conn: &mut Transaction<'a, Postgres>, user: User return Err(error_resources); } }; - let persisted_user_opt = match validate_user_password(conn, &persisted_user_credential.user_id, user.password).await { - Ok(matches) => matches, - Err(e) => { - error!("{:?}", e); - error_resources.push(e); - return Err(error_resources); - } - }; + let persisted_user_opt = + match validate_user_password(conn, &persisted_user_credential.user_id, user.password).await + { + Ok(matches) => matches, + Err(e) => { + error!("{:?}", e); + error_resources.push(e); + return Err(error_resources); + } + }; if let Some(_) = persisted_user_opt { - return if let Some(persisted_token) = create_token_for_user(conn, persisted_user_credential.user_id, &mut error_resources).await { + return if let Some(persisted_token) = create_token_for_user( + conn, + persisted_user_credential.user_id, + &mut error_resources, + ) + .await + { Ok(persisted_token) } else { Err(error_resources) - } + }; } Err(error_resources) } /// -pub async fn get_user_credentials<'a>(transaction: &mut Transaction<'a, Postgres>, user: AuthenticateUserDto) -> Result, Vec>> { +pub async fn get_user_credentials<'a>( + transaction: &mut Transaction<'a, Postgres>, + user: AuthenticateUserDto, +) -> Result, Vec>> { let mut error_resources = Vec::new(); let persisted_user = authenticate_user(transaction, user).await?; match fetch_user_credentials(transaction, &persisted_user.id).await { @@ -277,7 +313,11 @@ pub async fn get_user_credentials<'a>(transaction: &mut Transaction<'a, Postgres } } -async fn create_token_for_user<'a>(transaction: &mut PgConnection, user_id: i32, error_resources: &mut Vec>) -> Option { +async fn create_token_for_user<'a>( + transaction: &mut PgConnection, + user_id: i32, + error_resources: &mut Vec>, +) -> Option { // Create token and send it back. let tokens: Vec = match generate_multiple_random_token_with_rng(2).await { Ok(tokens) => tokens, @@ -287,35 +327,32 @@ async fn create_token_for_user<'a>(transaction: &mut PgConnection, user_id: i32, return None; } }; - let token_to_insert = - Token { - id: 0, - user_id, - auth_token: match tokens.get(0) { - None => { - error!("Tokens were not created.", ); - error_resources.push(ERROR_TOKEN_NOT_CREATED); - return None; - } - Some(token) => token.clone() - }, - refresh_token: match tokens.get(1) { - None => { - error!("Tokens were not created.", ); - error_resources.push(ERROR_TOKEN_NOT_CREATED); - return None; - } - Some(token) => token.clone() - }, - time_created: Utc::now(), - last_updated: Utc::now(), - }; + let token_to_insert = Token { + id: 0, + user_id, + auth_token: match tokens.get(0) { + None => { + error!("Tokens were not created.",); + error_resources.push(ERROR_TOKEN_NOT_CREATED); + return None; + } + Some(token) => token.clone(), + }, + refresh_token: match tokens.get(1) { + None => { + error!("Tokens were not created.",); + error_resources.push(ERROR_TOKEN_NOT_CREATED); + return None; + } + Some(token) => token.clone(), + }, + time_created: Utc::now(), + last_updated: Utc::now(), + }; // Insert token in DB match insert_token(transaction, token_to_insert).await { - Ok(persisted_token) => { - Some(persisted_token) - }, + Ok(persisted_token) => Some(persisted_token), Err(e) => { error!("{}", e); error_resources.push(("ERROR.DATABASE_ERROR", "")); @@ -324,17 +361,24 @@ async fn create_token_for_user<'a>(transaction: &mut PgConnection, user_id: i32, } } -async fn validate_user_password<'a>(conn: &mut PgConnection, user_id: &i32, password: String) -> Result, ErrorResource<'a>> { +async fn validate_user_password<'a>( + conn: &mut PgConnection, + user_id: &i32, + password: String, +) -> Result, ErrorResource<'a>> { let persisted_user = match get_user_with_id(conn, user_id).await { - Ok(persisted_user_opt) => match persisted_user_opt { - None => { - error!("Serious error. User doesn't exist but credentials pointing to the user do."); - return Err(("ERROR.DATABASE_ERROR", "Critical. User doesn't exist but credentials pointing to the user do.")); - }, - Some(persisted_user) => { - persisted_user + Ok(persisted_user_opt) => { + match persisted_user_opt { + None => { + error!("Serious error. User doesn't exist but credentials pointing to the user do."); + return Err(( + "ERROR.DATABASE_ERROR", + "Critical. User doesn't exist but credentials pointing to the user do.", + )); + } + Some(persisted_user) => persisted_user, } - }, + } Err(e) => { error!("{}", e); return Err(("ERROR.DATABASE_ERROR", "")); @@ -348,7 +392,11 @@ async fn validate_user_password<'a>(conn: &mut PgConnection, user_id: &i32, pass } } -async fn change_password<'a>(conn: &mut PgConnection, mut persisted_user: User, new_password: &String) -> Result> { +async fn change_password<'a>( + conn: &mut PgConnection, + mut persisted_user: User, + new_password: &String, +) -> Result> { let hash_result = hash_password(&new_password); persisted_user.password = hash_result.hash; persisted_user.salt = hash_result.salt; @@ -359,4 +407,4 @@ async fn change_password<'a>(conn: &mut PgConnection, mut persisted_user: User, return Err(("ERROR.DATABASE_ERROR", "")); } } -} \ No newline at end of file +} diff --git a/src/validation/user_validator.rs b/src/validation/user_validator.rs index 73e14b1..1c39d3e 100644 --- a/src/validation/user_validator.rs +++ b/src/validation/user_validator.rs @@ -38,7 +38,11 @@ pub(crate) fn validate_user_for_creation( error_resources: &mut Vec, ) { for credential_dto in user.credentials.iter() { - validate_credential(error_resources, &credential_dto.credential, &credential_dto.credential_type); + validate_credential( + error_resources, + &credential_dto.credential, + &credential_dto.credential_type, + ); } if !validate_user_name(&user.name) { @@ -58,7 +62,11 @@ pub(crate) fn validate_user_for_password_authentication( } } -fn validate_credential(error_resources: &mut Vec, credential: &String, credential_type: &CredentialType) { +fn validate_credential( + error_resources: &mut Vec, + credential: &String, + credential_type: &CredentialType, +) { match credential_type { CredentialType::Email => { if !validate_user_email(credential) { @@ -76,4 +84,4 @@ fn validate_credential(error_resources: &mut Vec, credential: &St } } } -} \ No newline at end of file +}