From 0a1631e66c861de2799cd98fc93686ff121c9fce Mon Sep 17 00:00:00 2001 From: Greg Burri Date: Tue, 13 Dec 2022 22:36:20 +0100 Subject: [PATCH] rustfmt --- backend/build.rs | 32 ++- backend/src/config.rs | 15 +- backend/src/consts.rs | 1 - backend/src/data/asynchronous.rs | 117 +++++++-- backend/src/data/db.rs | 423 +++++++++++++++++++++---------- backend/src/data/mod.rs | 2 +- backend/src/email.rs | 20 +- backend/src/hash.rs | 25 +- backend/src/main.rs | 67 ++--- backend/src/services.rs | 400 ++++++++++++++++++----------- backend/src/services/api.rs | 41 ++- backend/src/user.rs | 2 +- backend/src/utils.rs | 4 +- 13 files changed, 767 insertions(+), 382 deletions(-) diff --git a/backend/build.rs b/backend/build.rs index 9ae79de..45ca9a5 100644 --- a/backend/build.rs +++ b/backend/build.rs @@ -5,13 +5,21 @@ What is build here: - Compile the SASS file to CSS file. */ -use std::{ env, process::{ Command, Output }, path::Path }; +use std::{ + env, + path::Path, + process::{Command, Output}, +}; fn exists_in_path

(filename: P) -> bool - where P: AsRef { - for path in env::split_paths(&env::var_os("PATH").unwrap()) { - if path.join(&filename).is_file() { return true; } +where + P: AsRef, +{ + for path in env::split_paths(&env::var_os("PATH").unwrap()) { + if path.join(&filename).is_file() { + return true; } + } false } @@ -26,16 +34,16 @@ fn main() { .expect("Unable to compile SASS file, install SASS, see https://sass-lang.com/") } - let output = - if exists_in_path("sass.bat") { - run_sass(Command::new("cmd").args(&["/C", "sass.bat"])) - } else { - run_sass(&mut Command::new("sass")) - }; + let output = if exists_in_path("sass.bat") { + run_sass(Command::new("cmd").args(&["/C", "sass.bat"])) + } else { + run_sass(&mut Command::new("sass")) + }; if !output.status.success() { // SASS will put the error in the file. - let error = std::fs::read_to_string("./static/style.css").expect("unable to read style.css"); + let error = + std::fs::read_to_string("./static/style.css").expect("unable to read style.css"); panic!("{}", error); } -} \ No newline at end of file +} diff --git a/backend/src/config.rs b/backend/src/config.rs index 393a03b..24af485 100644 --- a/backend/src/config.rs +++ b/backend/src/config.rs @@ -16,17 +16,18 @@ pub struct Config { impl fmt::Debug for Config { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("Config") - .field("port", &self.port) - .field("smtp_login", &self.smtp_login) - .field("smtp_password", &"*****") - .finish() + .field("port", &self.port) + .field("smtp_login", &self.smtp_login) + .field("smtp_password", &"*****") + .finish() } } pub fn load() -> Config { - let f = File::open(consts::FILE_CONF).unwrap_or_else(|_| panic!("Failed to open configuration file {}", consts::FILE_CONF)); + let f = File::open(consts::FILE_CONF) + .unwrap_or_else(|_| panic!("Failed to open configuration file {}", consts::FILE_CONF)); match from_reader(f) { Ok(c) => c, - Err(e) => panic!("Failed to load config: {}", e) + Err(e) => panic!("Failed to load config: {}", e), } -} \ No newline at end of file +} diff --git a/backend/src/consts.rs b/backend/src/consts.rs index 754b964..45167a3 100644 --- a/backend/src/consts.rs +++ b/backend/src/consts.rs @@ -1,4 +1,3 @@ - use std::time::Duration; pub const FILE_CONF: &str = "conf.ron"; diff --git a/backend/src/data/asynchronous.rs b/backend/src/data/asynchronous.rs index 186dad6..7ef77b8 100644 --- a/backend/src/data/asynchronous.rs +++ b/backend/src/data/asynchronous.rs @@ -2,8 +2,8 @@ use std::fmt; +use actix_web::{error::BlockingError, web}; use chrono::{prelude::*, Duration}; -use actix_web::{web, error::BlockingError}; use super::db::*; use crate::model; @@ -22,15 +22,15 @@ impl fmt::Display for DBAsyncError { } } -impl std::error::Error for DBAsyncError { } +impl std::error::Error for DBAsyncError {} -impl From for DBAsyncError { +impl From for DBAsyncError { fn from(error: DBError) -> Self { DBAsyncError::DBError(error) } } -impl From for DBAsyncError { +impl From for DBAsyncError { fn from(error: BlockingError) -> Self { DBAsyncError::ActixError(error) } @@ -42,7 +42,9 @@ impl DBAsyncError { } } -fn combine_errors(error: std::result::Result, BlockingError>) -> Result { +fn combine_errors( + error: std::result::Result, BlockingError>, +) -> Result { error? } @@ -51,71 +53,144 @@ type Result = std::result::Result; impl Connection { pub async fn get_all_recipe_titles_async(&self) -> Result> { let self_copy = self.clone(); - web::block(move || { self_copy.get_all_recipe_titles().unwrap_or_default() }).await.map_err(DBAsyncError::from) + web::block(move || self_copy.get_all_recipe_titles().unwrap_or_default()) + .await + .map_err(DBAsyncError::from) } pub async fn get_recipe_async(&self, id: i64) -> Result { let self_copy = self.clone(); - combine_errors(web::block(move || { self_copy.get_recipe(id).map_err(DBAsyncError::from) }).await) + combine_errors( + web::block(move || self_copy.get_recipe(id).map_err(DBAsyncError::from)).await, + ) } pub async fn load_user_async(&self, user_id: i64) -> Result { let self_copy = self.clone(); - combine_errors(web::block(move || { self_copy.load_user(user_id).map_err(DBAsyncError::from) }).await) + combine_errors( + web::block(move || self_copy.load_user(user_id).map_err(DBAsyncError::from)).await, + ) } pub async fn sign_up_async(&self, email: &str, password: &str) -> Result { let self_copy = self.clone(); let email_copy = email.to_string(); let password_copy = password.to_string(); - combine_errors(web::block(move || { self_copy.sign_up(&email_copy, &password_copy).map_err(DBAsyncError::from) }).await) + combine_errors( + web::block(move || { + self_copy + .sign_up(&email_copy, &password_copy) + .map_err(DBAsyncError::from) + }) + .await, + ) } - pub async fn validation_async(&self, token: &str, validation_time: Duration, ip: &str, user_agent: &str) -> Result { + pub async fn validation_async( + &self, + token: &str, + validation_time: Duration, + ip: &str, + user_agent: &str, + ) -> Result { let self_copy = self.clone(); let token_copy = token.to_string(); let ip_copy = ip.to_string(); let user_agent_copy = user_agent.to_string(); - combine_errors(web::block(move || { self_copy.validation(&token_copy, validation_time, &ip_copy, &user_agent_copy).map_err(DBAsyncError::from) }).await) + combine_errors( + web::block(move || { + self_copy + .validation(&token_copy, validation_time, &ip_copy, &user_agent_copy) + .map_err(DBAsyncError::from) + }) + .await, + ) } - pub async fn sign_in_async(&self, email: &str, password: &str, ip: &str, user_agent: &str) -> Result { + pub async fn sign_in_async( + &self, + email: &str, + password: &str, + ip: &str, + user_agent: &str, + ) -> Result { let self_copy = self.clone(); let email_copy = email.to_string(); let password_copy = password.to_string(); let ip_copy = ip.to_string(); let user_agent_copy = user_agent.to_string(); - combine_errors(web::block(move || { self_copy.sign_in(&email_copy, &password_copy, &ip_copy, &user_agent_copy).map_err(DBAsyncError::from) }).await) + combine_errors( + web::block(move || { + self_copy + .sign_in(&email_copy, &password_copy, &ip_copy, &user_agent_copy) + .map_err(DBAsyncError::from) + }) + .await, + ) } - pub async fn authentication_async(&self, token: &str, ip: &str, user_agent: &str) -> Result { + pub async fn authentication_async( + &self, + token: &str, + ip: &str, + user_agent: &str, + ) -> Result { let self_copy = self.clone(); let token_copy = token.to_string(); let ip_copy = ip.to_string(); let user_agent_copy = user_agent.to_string(); - combine_errors(web::block(move || { self_copy.authentication(&token_copy, &ip_copy, &user_agent_copy).map_err(DBAsyncError::from) }).await) + combine_errors( + web::block(move || { + self_copy + .authentication(&token_copy, &ip_copy, &user_agent_copy) + .map_err(DBAsyncError::from) + }) + .await, + ) } pub async fn sign_out_async(&self, token: &str) -> Result<()> { let self_copy = self.clone(); let token_copy = token.to_string(); - combine_errors(web::block(move || { self_copy.sign_out(&token_copy).map_err(DBAsyncError::from) }).await) + combine_errors( + web::block(move || self_copy.sign_out(&token_copy).map_err(DBAsyncError::from)).await, + ) } pub async fn create_recipe_async(&self, user_id: i64) -> Result { let self_copy = self.clone(); - combine_errors(web::block(move || { self_copy.create_recipe(user_id).map_err(DBAsyncError::from) }).await) + combine_errors( + web::block(move || self_copy.create_recipe(user_id).map_err(DBAsyncError::from)).await, + ) } pub async fn set_recipe_title_async(&self, recipe_id: i64, title: &str) -> Result<()> { let self_copy = self.clone(); let title_copy = title.to_string(); - combine_errors(web::block(move || { self_copy.set_recipe_title(recipe_id, &title_copy).map_err(DBAsyncError::from) }).await) + combine_errors( + web::block(move || { + self_copy + .set_recipe_title(recipe_id, &title_copy) + .map_err(DBAsyncError::from) + }) + .await, + ) } - pub async fn set_recipe_description_async(&self, recipe_id: i64, description: &str) -> Result<()> { + pub async fn set_recipe_description_async( + &self, + recipe_id: i64, + description: &str, + ) -> Result<()> { let self_copy = self.clone(); let description_copy = description.to_string(); - combine_errors(web::block(move || { self_copy.set_recipe_description(recipe_id, &description_copy).map_err(DBAsyncError::from) }).await) + combine_errors( + web::block(move || { + self_copy + .set_recipe_description(recipe_id, &description_copy) + .map_err(DBAsyncError::from) + }) + .await, + ) } -} \ No newline at end of file +} diff --git a/backend/src/data/db.rs b/backend/src/data/db.rs index 5652ff3..10b6f31 100644 --- a/backend/src/data/db.rs +++ b/backend/src/data/db.rs @@ -1,16 +1,21 @@ -use std::{fmt, fs::{self, File}, path::Path, io::Read}; +use std::{ + fmt, + fs::{self, File}, + io::Read, + path::Path, +}; -use itertools::Itertools; use chrono::{prelude::*, Duration}; -use rusqlite::{named_params, OptionalExtension, params, Params}; +use itertools::Itertools; use r2d2::{Pool, PooledConnection}; use r2d2_sqlite::SqliteConnectionManager; use rand::distributions::{Alphanumeric, DistString}; +use rusqlite::{named_params, params, OptionalExtension, Params}; -use crate::{consts, user}; use crate::hash::{hash, verify_password}; use crate::model; use crate::user::*; +use crate::{consts, user}; const CURRENT_DB_VERSION: u32 = 1; @@ -28,15 +33,15 @@ impl fmt::Display for DBError { } } -impl std::error::Error for DBError { } +impl std::error::Error for DBError {} -impl From for DBError { +impl From for DBError { fn from(error: rusqlite::Error) -> Self { DBError::SqliteError(error) } } -impl From for DBError { +impl From for DBError { fn from(error: r2d2::Error) -> Self { DBError::R2d2Error(error) } @@ -79,7 +84,7 @@ pub enum AuthenticationResult { #[derive(Clone)] pub struct Connection { - pool: Pool + pool: Pool, } impl Connection { @@ -127,12 +132,18 @@ impl Connection { // Version 0 corresponds to an empty database. let mut version = { match tx.query_row( - "SELECT [name] FROM [sqlite_master] WHERE [type] = 'table' AND [name] = 'Version'", + "SELECT [name] FROM [sqlite_master] WHERE [type] = 'table' AND [name] = 'Version'", + [], + |row| row.get::(0), + ) { + Ok(_) => tx + .query_row( + "SELECT [version] FROM [Version] ORDER BY [id] DESC", [], - |row| row.get::(0) - ) { - Ok(_) => tx.query_row("SELECT [version] FROM [Version] ORDER BY [id] DESC", [], |row| row.get(0)).unwrap_or_default(), - Err(_) => 0 + |row| row.get(0), + ) + .unwrap_or_default(), + Err(_) => 0, } }; @@ -153,7 +164,12 @@ impl Connection { } fn update_version(to_version: u32, tx: &rusqlite::Transaction) -> Result<()> { - tx.execute("INSERT INTO [Version] ([version], [datetime]) VALUES (?1, datetime('now'))", [to_version]).map(|_| ()).map_err(DBError::from) + tx.execute( + "INSERT INTO [Version] ([version], [datetime]) VALUES (?1, datetime('now'))", + [to_version], + ) + .map(|_| ()) + .map_err(DBError::from) } fn ok(updated: bool) -> Result { @@ -173,11 +189,9 @@ impl Connection { } // Version 1 doesn't exist yet. - 2 => - ok(false), + 2 => ok(false), - v => - Err(DBError::UnsupportedVersion(v)), + v => Err(DBError::UnsupportedVersion(v)), } } @@ -186,10 +200,9 @@ impl Connection { let mut stmt = con.prepare("SELECT [id], [title] FROM [Recipe] ORDER BY [title]")?; - let titles: std::result::Result, rusqlite::Error> = - stmt.query_map([], |row| { - Ok((row.get("id")?, row.get("title")?)) - })?.collect(); + let titles: std::result::Result, rusqlite::Error> = stmt + .query_map([], |row| Ok((row.get("id")?, row.get("title")?)))? + .collect(); titles.map_err(DBError::from) } @@ -207,9 +220,18 @@ impl Connection { pub fn get_recipe(&self, id: i64) -> Result { let con = self.get()?; - con.query_row("SELECT [id], [title], [description] FROM [Recipe] WHERE [id] = ?1", [id], |row| { - Ok(model::Recipe::new(row.get("id")?, row.get("title")?, row.get("description")?)) - }).map_err(DBError::from) + con.query_row( + "SELECT [id], [title], [description] FROM [Recipe] WHERE [id] = ?1", + [id], + |row| { + Ok(model::Recipe::new( + row.get("id")?, + row.get("title")?, + row.get("description")?, + )) + }, + ) + .map_err(DBError::from) } pub fn get_user_login_info(&self, token: &str) -> Result { @@ -225,116 +247,185 @@ impl Connection { pub fn load_user(&self, user_id: i64) -> Result { let con = self.get()?; - con.query_row("SELECT [email] FROM [User] WHERE [id] = ?1", [user_id], |r| { - Ok(User { - email: r.get("email")?, - }) - }).map_err(DBError::from) + con.query_row( + "SELECT [email] FROM [User] WHERE [id] = ?1", + [user_id], + |r| { + Ok(User { + email: r.get("email")?, + }) + }, + ) + .map_err(DBError::from) } pub fn sign_up(&self, email: &str, password: &str) -> Result { self.sign_up_with_given_time(email, password, Utc::now()) } - fn sign_up_with_given_time(&self, email: &str, password: &str, datetime: DateTime) -> Result { + fn sign_up_with_given_time( + &self, + email: &str, + password: &str, + datetime: DateTime, + ) -> Result { let mut con = self.get()?; let tx = con.transaction()?; - let token = - match tx.query_row("SELECT [id], [validation_token] FROM [User] WHERE [email] = ?1", [email], |r| { - Ok((r.get::<&str, i64>("id")?, r.get::<&str, Option>("validation_token")?)) - }).optional()? { - Some((id, validation_token)) => { - if validation_token.is_none() { - return Ok(SignUpResult::UserAlreadyExists) - } - let token = generate_token(); - let hashed_password = hash(password).map_err(|e| DBError::from_dyn_error(e))?; - tx.execute("UPDATE [User] SET [validation_token] = ?2, [creation_datetime] = ?3, [password] = ?4 WHERE [id] = ?1", params![id, token, datetime, hashed_password])?; - token + let token = match tx + .query_row( + "SELECT [id], [validation_token] FROM [User] WHERE [email] = ?1", + [email], + |r| { + Ok(( + r.get::<&str, i64>("id")?, + r.get::<&str, Option>("validation_token")?, + )) }, - None => { - let token = generate_token(); - let hashed_password = hash(password).map_err(|e| DBError::from_dyn_error(e))?; - tx.execute("INSERT INTO [User] ([email], [validation_token], [creation_datetime], [password]) VALUES (?1, ?2, ?3, ?4)", params![email, token, datetime, hashed_password])?; - token - }, - }; + ) + .optional()? + { + Some((id, validation_token)) => { + if validation_token.is_none() { + return Ok(SignUpResult::UserAlreadyExists); + } + let token = generate_token(); + let hashed_password = hash(password).map_err(|e| DBError::from_dyn_error(e))?; + tx.execute("UPDATE [User] SET [validation_token] = ?2, [creation_datetime] = ?3, [password] = ?4 WHERE [id] = ?1", params![id, token, datetime, hashed_password])?; + token + } + None => { + let token = generate_token(); + let hashed_password = hash(password).map_err(|e| DBError::from_dyn_error(e))?; + tx.execute("INSERT INTO [User] ([email], [validation_token], [creation_datetime], [password]) VALUES (?1, ?2, ?3, ?4)", params![email, token, datetime, hashed_password])?; + token + } + }; tx.commit()?; Ok(SignUpResult::UserCreatedWaitingForValidation(token)) } - pub fn validation(&self, token: &str, validation_time: Duration, ip: &str, user_agent: &str) -> Result { + pub fn validation( + &self, + token: &str, + validation_time: Duration, + ip: &str, + user_agent: &str, + ) -> Result { let mut con = self.get()?; let tx = con.transaction()?; - let user_id = - match tx.query_row("SELECT [id], [creation_datetime] FROM [User] WHERE [validation_token] = ?1", [token], |r| { - Ok((r.get::<&str, i64>("id")?, r.get::<&str, DateTime>("creation_datetime")?)) - }).optional()? { - Some((id, creation_datetime)) => { - if Utc::now() - creation_datetime > validation_time { - return Ok(ValidationResult::ValidationExpired) - } - tx.execute("UPDATE [User] SET [validation_token] = NULL WHERE [id] = ?1", [id])?; - id - }, - None => { - return Ok(ValidationResult::UnknownUser) + let user_id = match tx + .query_row( + "SELECT [id], [creation_datetime] FROM [User] WHERE [validation_token] = ?1", + [token], + |r| { + Ok(( + r.get::<&str, i64>("id")?, + r.get::<&str, DateTime>("creation_datetime")?, + )) }, - }; + ) + .optional()? + { + Some((id, creation_datetime)) => { + if Utc::now() - creation_datetime > validation_time { + return Ok(ValidationResult::ValidationExpired); + } + tx.execute( + "UPDATE [User] SET [validation_token] = NULL WHERE [id] = ?1", + [id], + )?; + id + } + None => return Ok(ValidationResult::UnknownUser), + }; let token = Connection::create_login_token(&tx, user_id, ip, user_agent)?; tx.commit()?; Ok(ValidationResult::Ok(token, user_id)) } - pub fn sign_in(&self, email: &str, password: &str, ip: &str, user_agent: &str) -> Result { + pub fn sign_in( + &self, + email: &str, + password: &str, + ip: &str, + user_agent: &str, + ) -> Result { let mut con = self.get()?; let tx = con.transaction()?; - match tx.query_row("SELECT [id], [password], [validation_token] FROM [User] WHERE [email] = ?1", [email], |r| { - Ok((r.get::<&str, i64>("id")?, r.get::<&str, String>("password")?, r.get::<&str, Option>("validation_token")?)) - }).optional()? { + match tx + .query_row( + "SELECT [id], [password], [validation_token] FROM [User] WHERE [email] = ?1", + [email], + |r| { + Ok(( + r.get::<&str, i64>("id")?, + r.get::<&str, String>("password")?, + r.get::<&str, Option>("validation_token")?, + )) + }, + ) + .optional()? + { Some((id, stored_password, validation_token)) => { if validation_token.is_some() { Ok(SignInResult::AccountNotValidated) - } else if verify_password(password, &stored_password).map_err(DBError::from_dyn_error)? { + } else if verify_password(password, &stored_password) + .map_err(DBError::from_dyn_error)? + { let token = Connection::create_login_token(&tx, id, ip, user_agent)?; tx.commit()?; Ok(SignInResult::Ok(token, id)) } else { Ok(SignInResult::WrongPassword) } - }, - None => { - Ok(SignInResult::UserNotFound) - }, + } + None => Ok(SignInResult::UserNotFound), } } - pub fn authentication(&self, token: &str, ip: &str, user_agent: &str) -> Result { + pub fn authentication( + &self, + token: &str, + ip: &str, + user_agent: &str, + ) -> Result { let mut con = self.get()?; let tx = con.transaction()?; - match tx.query_row("SELECT [id], [user_id] FROM [UserLoginToken] WHERE [token] = ?1", [token], |r| { - Ok((r.get::<&str, i64>("id")?, r.get::<&str, i64>("user_id")?)) - }).optional()? { + match tx + .query_row( + "SELECT [id], [user_id] FROM [UserLoginToken] WHERE [token] = ?1", + [token], + |r| Ok((r.get::<&str, i64>("id")?, r.get::<&str, i64>("user_id")?)), + ) + .optional()? + { Some((login_id, user_id)) => { tx.execute("UPDATE [UserLoginToken] SET [last_login_datetime] = ?2, [ip] = ?3, [user_agent] = ?4 WHERE [id] = ?1", params![login_id, Utc::now(), ip, user_agent])?; tx.commit()?; Ok(AuthenticationResult::Ok(user_id)) - }, - None => - Ok(AuthenticationResult::NotValidToken) + } + None => Ok(AuthenticationResult::NotValidToken), } } pub fn sign_out(&self, token: &str) -> Result<()> { let mut con = self.get()?; let tx = con.transaction()?; - match tx.query_row("SELECT [id] FROM [UserLoginToken] WHERE [token] = ?1", [token], |r| { - Ok(r.get::<&str, i64>("id")?) - }).optional()? { + match tx + .query_row( + "SELECT [id] FROM [UserLoginToken] WHERE [token] = ?1", + [token], + |r| Ok(r.get::<&str, i64>("id")?), + ) + .optional()? + { Some(login_id) => { - tx.execute("DELETE FROM [UserLoginToken] WHERE [id] = ?1", params![login_id])?; + tx.execute( + "DELETE FROM [UserLoginToken] WHERE [id] = ?1", + params![login_id], + )?; tx.commit()? - }, + } None => (), } Ok(()) @@ -364,12 +455,22 @@ impl Connection { pub fn set_recipe_title(&self, recipe_id: i64, title: &str) -> Result<()> { let con = self.get()?; - con.execute("UPDATE [Recipe] SET [title] = ?2 WHERE [id] = ?1", params![recipe_id, title]).map(|_n| ()).map_err(DBError::from) + con.execute( + "UPDATE [Recipe] SET [title] = ?2 WHERE [id] = ?1", + params![recipe_id, title], + ) + .map(|_n| ()) + .map_err(DBError::from) } pub fn set_recipe_description(&self, recipe_id: i64, description: &str) -> Result<()> { let con = self.get()?; - con.execute("UPDATE [Recipe] SET [description] = ?2 WHERE [id] = ?1", params![recipe_id, description]).map(|_n| ()).map_err(DBError::from) + con.execute( + "UPDATE [Recipe] SET [description] = ?2 WHERE [id] = ?1", + params![recipe_id, description], + ) + .map(|_n| ()) + .map_err(DBError::from) } /// Execute a given SQL file. @@ -387,7 +488,12 @@ impl Connection { } // Return the token. - fn create_login_token(tx: &rusqlite::Transaction, user_id: i64, ip: &str, user_agent: &str) -> Result { + fn create_login_token( + tx: &rusqlite::Transaction, + user_id: i64, + ip: &str, + user_agent: &str, + ) -> Result { let token = generate_token(); tx.execute("INSERT INTO [UserLoginToken] ([user_id], [last_login_datetime], [token], [ip], [user_agent]) VALUES (?1, ?2, ?3, ?4, ?5)", params![user_id, Utc::now(), token, ip, user_agent])?; Ok(token) @@ -395,9 +501,21 @@ impl Connection { } fn load_sql_file + fmt::Display>(sql_file: P) -> Result { - let mut file = File::open(&sql_file).map_err(|err| DBError::Other(format!("Cannot open SQL file ({}): {}", &sql_file, err.to_string())))?; + let mut file = File::open(&sql_file).map_err(|err| { + DBError::Other(format!( + "Cannot open SQL file ({}): {}", + &sql_file, + err.to_string() + )) + })?; let mut sql = String::new(); - file.read_to_string(&mut sql).map_err(|err| DBError::Other(format!("Cannot read SQL file ({}) : {}", &sql_file, err.to_string())))?; + file.read_to_string(&mut sql).map_err(|err| { + DBError::Other(format!( + "Cannot read SQL file ({}) : {}", + &sql_file, + err.to_string() + )) + })?; Ok(sql) } @@ -408,7 +526,7 @@ fn generate_token() -> String { #[cfg(test)] mod tests { use super::*; - use rusqlite::{Error, ErrorCode, ffi, types::Value}; + use rusqlite::{ffi, types::Value, Error, ErrorCode}; #[test] fn sign_up() -> Result<()> { @@ -484,12 +602,16 @@ mod tests { #[test] fn sign_up_then_send_validation_at_time() -> Result<()> { let connection = Connection::new_in_memory()?; - let validation_token = - match connection.sign_up("paul@atreides.com", "12345")? { - SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. - other => panic!("{:?}", other), - }; - match connection.validation(&validation_token, Duration::hours(1), "127.0.0.1", "Mozilla/5.0")? { + let validation_token = match connection.sign_up("paul@atreides.com", "12345")? { + SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. + other => panic!("{:?}", other), + }; + match connection.validation( + &validation_token, + Duration::hours(1), + "127.0.0.1", + "Mozilla/5.0", + )? { ValidationResult::Ok(_, _) => (), // Nominal case. other => panic!("{:?}", other), } @@ -499,12 +621,20 @@ mod tests { #[test] fn sign_up_then_send_validation_too_late() -> Result<()> { let connection = Connection::new_in_memory()?; - let validation_token = - match connection.sign_up_with_given_time("paul@atreides.com", "12345", Utc::now() - Duration::days(1))? { - SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. - other => panic!("{:?}", other), - }; - match connection.validation(&validation_token, Duration::hours(1), "127.0.0.1", "Mozilla/5.0")? { + let validation_token = match connection.sign_up_with_given_time( + "paul@atreides.com", + "12345", + Utc::now() - Duration::days(1), + )? { + SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. + other => panic!("{:?}", other), + }; + match connection.validation( + &validation_token, + Duration::hours(1), + "127.0.0.1", + "Mozilla/5.0", + )? { ValidationResult::ValidationExpired => (), // Nominal case. other => panic!("{:?}", other), } @@ -514,13 +644,17 @@ mod tests { #[test] fn sign_up_then_send_validation_with_bad_token() -> Result<()> { let connection = Connection::new_in_memory()?; - let _validation_token = - match connection.sign_up("paul@atreides.com", "12345")? { - SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. - other => panic!("{:?}", other), - }; + let _validation_token = match connection.sign_up("paul@atreides.com", "12345")? { + SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. + other => panic!("{:?}", other), + }; let random_token = generate_token(); - match connection.validation(&random_token, Duration::hours(1), "127.0.0.1", "Mozilla/5.0")? { + match connection.validation( + &random_token, + Duration::hours(1), + "127.0.0.1", + "Mozilla/5.0", + )? { ValidationResult::UnknownUser => (), // Nominal case. other => panic!("{:?}", other), } @@ -535,14 +669,18 @@ mod tests { let password = "12345"; // Sign up. - let validation_token = - match connection.sign_up(email, password)? { - SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. - other => panic!("{:?}", other), - }; + let validation_token = match connection.sign_up(email, password)? { + SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. + other => panic!("{:?}", other), + }; // Validation. - match connection.validation(&validation_token, Duration::hours(1), "127.0.0.1", "Mozilla/5.0")? { + match connection.validation( + &validation_token, + Duration::hours(1), + "127.0.0.1", + "Mozilla/5.0", + )? { ValidationResult::Ok(_, _) => (), other => panic!("{:?}", other), }; @@ -564,14 +702,18 @@ mod tests { let password = "12345"; // Sign up. - let validation_token = - match connection.sign_up(email, password)? { - SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. - other => panic!("{:?}", other), - }; + let validation_token = match connection.sign_up(email, password)? { + SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. + other => panic!("{:?}", other), + }; // Validation. - let (authentication_token, user_id) = match connection.validation(&validation_token, Duration::hours(1), "127.0.0.1", "Mozilla")? { + let (authentication_token, user_id) = match connection.validation( + &validation_token, + Duration::hours(1), + "127.0.0.1", + "Mozilla", + )? { ValidationResult::Ok(token, user_id) => (token, user_id), other => panic!("{:?}", other), }; @@ -604,18 +746,21 @@ mod tests { let password = "12345"; // Sign up. - let validation_token = - match connection.sign_up(email, password)? { - SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. - other => panic!("{:?}", other), - }; + let validation_token = match connection.sign_up(email, password)? { + SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case. + other => panic!("{:?}", other), + }; // Validation. - let (authentication_token_1, user_id_1) = - match connection.validation(&validation_token, Duration::hours(1), "127.0.0.1", "Mozilla")? { - ValidationResult::Ok(token, user_id) => (token, user_id), - other => panic!("{:?}", other), - }; + let (authentication_token_1, user_id_1) = match connection.validation( + &validation_token, + Duration::hours(1), + "127.0.0.1", + "Mozilla", + )? { + ValidationResult::Ok(token, user_id) => (token, user_id), + other => panic!("{:?}", other), + }; // Check user login information. let user_login_info_1 = connection.get_user_login_info(&authentication_token_1)?; @@ -644,7 +789,6 @@ mod tests { Ok(()) } - #[test] fn create_a_new_recipe_then_update_its_title() -> Result<()> { let connection = Connection::new_in_memory()?; @@ -662,8 +806,17 @@ mod tests { )?; match connection.create_recipe(2) { - Err(DBError::SqliteError(Error::SqliteFailure(ffi::Error { code: ErrorCode::ConstraintViolation, extended_code: _ }, Some(_)))) => (), // Nominal case. - other => panic!("Creating a recipe with an inexistant user must fail: {:?}", other), + Err(DBError::SqliteError(Error::SqliteFailure( + ffi::Error { + code: ErrorCode::ConstraintViolation, + extended_code: _, + }, + Some(_), + ))) => (), // Nominal case. + other => panic!( + "Creating a recipe with an inexistant user must fail: {:?}", + other + ), } let recipe_id = connection.create_recipe(1)?; diff --git a/backend/src/data/mod.rs b/backend/src/data/mod.rs index 37bc498..edc9cb9 100644 --- a/backend/src/data/mod.rs +++ b/backend/src/data/mod.rs @@ -1,2 +1,2 @@ pub mod asynchronous; -pub mod db; \ No newline at end of file +pub mod db; diff --git a/backend/src/email.rs b/backend/src/email.rs index b571a29..4d906ff 100644 --- a/backend/src/email.rs +++ b/backend/src/email.rs @@ -1,6 +1,6 @@ -use std::time::Duration; use derive_more::Display; use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport}; +use std::time::Duration; use crate::consts; @@ -29,17 +29,29 @@ impl From for Error { } } -pub fn send_validation(site_url: &str, email: &str, token: &str, smtp_login: &str, smtp_password: &str) -> Result<(), Error> { +pub fn send_validation( + site_url: &str, + email: &str, + token: &str, + smtp_login: &str, + smtp_password: &str, +) -> Result<(), Error> { let email = Message::builder() .message_id(None) .from("recipes@gburri.org".parse()?) .to(email.parse()?) .subject("Recipes.gburri.org account validation") - .body(format!("Follow this link to confirm your inscription: {}/validation?token={}", site_url, token))?; + .body(format!( + "Follow this link to confirm your inscription: {}/validation?token={}", + site_url, token + ))?; let credentials = Credentials::new(smtp_login.to_string(), smtp_password.to_string()); - let mailer = SmtpTransport::relay("mail.gandi.net")?.credentials(credentials).timeout(Some(consts::SEND_EMAIL_TIMEOUT)).build(); + let mailer = SmtpTransport::relay("mail.gandi.net")? + .credentials(credentials) + .timeout(Some(consts::SEND_EMAIL_TIMEOUT)) + .build(); if let Err(error) = mailer.send(&email) { eprintln!("Error when sending E-mail:\n{:?}", &error); diff --git a/backend/src/hash.rs b/backend/src/hash.rs index 8002ac7..04b5623 100644 --- a/backend/src/hash.rs +++ b/backend/src/hash.rs @@ -1,23 +1,28 @@ -use std::{string::String}; +use std::string::String; use argon2::{ - password_hash::{ - rand_core::OsRng, - PasswordHash, PasswordHasher, PasswordVerifier, SaltString - }, - Argon2 + password_hash::{rand_core::OsRng, PasswordHash, PasswordHasher, PasswordVerifier, SaltString}, + Argon2, }; pub fn hash(password: &str) -> Result> { let salt = SaltString::generate(&mut OsRng); let argon2 = Argon2::default(); - argon2.hash_password(password.as_bytes(), &salt).map(|h| h.to_string()).map_err(|e| e.into()) + argon2 + .hash_password(password.as_bytes(), &salt) + .map(|h| h.to_string()) + .map_err(|e| e.into()) } -pub fn verify_password(password: &str, hashed_password: &str) -> Result> { +pub fn verify_password( + password: &str, + hashed_password: &str, +) -> Result> { let argon2 = Argon2::default(); let parsed_hash = PasswordHash::new(hashed_password)?; - Ok(argon2.verify_password(password.as_bytes(), &parsed_hash).is_ok()) + Ok(argon2 + .verify_password(password.as_bytes(), &parsed_hash) + .is_ok()) } #[cfg(test)] @@ -42,4 +47,4 @@ mod test { assert!(verify_password(password, &hash)?); Ok(()) } -} \ No newline at end of file +} diff --git a/backend/src/main.rs b/backend/src/main.rs index df7c44b..0d34341 100644 --- a/backend/src/main.rs +++ b/backend/src/main.rs @@ -1,24 +1,26 @@ use actix_files as fs; -use actix_web::{web, middleware, App, HttpServer}; +use actix_web::{middleware, web, App, HttpServer}; use chrono::prelude::*; use clap::Parser; use log::error; use data::db; +mod config; mod consts; -mod utils; mod data; +mod email; mod hash; mod model; -mod user; -mod email; -mod config; mod services; +mod user; +mod utils; #[actix_web::main] async fn main() -> std::io::Result<()> { - if process_args() { return Ok(()) } + if process_args() { + return Ok(()); + } std::env::set_var("RUST_LOG", "info,actix_web=info"); env_logger::init(); @@ -32,27 +34,26 @@ async fn main() -> std::io::Result<()> { let db_connection = web::Data::new(db::Connection::new().unwrap()); - let server = - HttpServer::new(move || { - App::new() - .wrap(middleware::Logger::default()) - .wrap(middleware::Compress::default()) - .app_data(db_connection.clone()) - .app_data(config.clone()) - .service(services::home_page) - .service(services::sign_up_get) - .service(services::sign_up_post) - .service(services::sign_up_check_email) - .service(services::sign_up_validation) - .service(services::sign_in_get) - .service(services::sign_in_post) - .service(services::sign_out) - .service(services::view_recipe) - .service(services::edit_recipe) - .service(fs::Files::new("/static", "static")) - .default_service(web::to(services::not_found)) - }); - //.workers(1); + let server = HttpServer::new(move || { + App::new() + .wrap(middleware::Logger::default()) + .wrap(middleware::Compress::default()) + .app_data(db_connection.clone()) + .app_data(config.clone()) + .service(services::home_page) + .service(services::sign_up_get) + .service(services::sign_up_post) + .service(services::sign_up_check_email) + .service(services::sign_up_validation) + .service(services::sign_in_get) + .service(services::sign_in_post) + .service(services::sign_out) + .service(services::view_recipe) + .service(services::edit_recipe) + .service(fs::Files::new("/static", "static")) + .default_service(web::to(services::not_found)) + }); + //.workers(1); server.bind(&format!("0.0.0.0:{}", port))?.run().await } @@ -60,7 +61,7 @@ async fn main() -> std::io::Result<()> { #[derive(Parser, Debug)] struct Args { #[arg(long)] - dbtest: bool + dbtest: bool, } fn process_args() -> bool { @@ -73,11 +74,15 @@ fn process_args() -> bool { eprintln!("{}", error); } // Set the creation datetime to 'now'. - con.execute_sql("UPDATE [User] SET [creation_datetime] = ?1 WHERE [email] = 'paul@test.org'", [Utc::now()]).unwrap(); - }, + con.execute_sql( + "UPDATE [User] SET [creation_datetime] = ?1 WHERE [email] = 'paul@test.org'", + [Utc::now()], + ) + .unwrap(); + } Err(error) => { eprintln!("{}", error); - }, + } } return true; diff --git a/backend/src/services.rs b/backend/src/services.rs index b4d39f9..afa20a0 100644 --- a/backend/src/services.rs +++ b/backend/src/services.rs @@ -1,59 +1,78 @@ use std::collections::HashMap; -use actix_web::{http::{header, header::ContentType, StatusCode}, get, post, web, Responder, HttpRequest, HttpResponse, cookie::Cookie}; +use actix_web::{ + cookie::Cookie, + get, + http::{header, header::ContentType, StatusCode}, + post, web, HttpRequest, HttpResponse, Responder, +}; use askama_actix::{Template, TemplateToResponse}; use chrono::Duration; +use log::{debug, error, info, log_enabled, Level}; use serde::Deserialize; -use log::{debug, error, log_enabled, info, Level}; -use crate::utils; -use crate::email; -use crate::consts; use crate::config::Config; -use crate::user::User; +use crate::consts; +use crate::data::{asynchronous, db}; +use crate::email; use crate::model; -use crate::data::{db, asynchronous}; +use crate::user::User; +use crate::utils; mod api; ///// UTILS ///// fn get_ip_and_user_agent(req: &HttpRequest) -> (String, String) { - let ip = - match req.headers().get(consts::REVERSE_PROXY_IP_HTTP_FIELD) { - Some(v) => v.to_str().unwrap_or_default().to_string(), - None => req.peer_addr().map(|addr| addr.ip().to_string()).unwrap_or_default() - }; + let ip = match req.headers().get(consts::REVERSE_PROXY_IP_HTTP_FIELD) { + Some(v) => v.to_str().unwrap_or_default().to_string(), + None => req + .peer_addr() + .map(|addr| addr.ip().to_string()) + .unwrap_or_default(), + }; - let user_agent = req.headers().get(header::USER_AGENT).map(|v| v.to_str().unwrap_or_default()).unwrap_or_default().to_string(); + let user_agent = req + .headers() + .get(header::USER_AGENT) + .map(|v| v.to_str().unwrap_or_default()) + .unwrap_or_default() + .to_string(); (ip, user_agent) } -async fn get_current_user(req: &HttpRequest, connection: web::Data) -> Option { +async fn get_current_user( + req: &HttpRequest, + connection: web::Data, +) -> Option { let (client_ip, client_user_agent) = get_ip_and_user_agent(req); match req.cookie(consts::COOKIE_AUTH_TOKEN_NAME) { - Some(token_cookie) => - match connection.authentication_async(token_cookie.value(), &client_ip, &client_user_agent).await { - Ok(db::AuthenticationResult::NotValidToken) => - // TODO: remove cookie? - None, - Ok(db::AuthenticationResult::Ok(user_id)) => - match connection.load_user_async(user_id).await { - Ok(user) => - Some(user), - Err(error) => { - error!("Error during authentication: {}", error); - None - } - }, - Err(error) => { - error!("Error during authentication: {}", error); - None - }, - }, - None => None + Some(token_cookie) => match connection + .authentication_async(token_cookie.value(), &client_ip, &client_user_agent) + .await + { + Ok(db::AuthenticationResult::NotValidToken) => + // TODO: remove cookie? + { + None + } + Ok(db::AuthenticationResult::Ok(user_id)) => { + match connection.load_user_async(user_id).await { + Ok(user) => Some(user), + Err(error) => { + error!("Error during authentication: {}", error); + None + } + } + } + Err(error) => { + error!("Error during authentication: {}", error); + None + } + }, + None => None, } } @@ -67,7 +86,7 @@ pub struct ServiceError { message: Option, } -impl From for ServiceError { +impl From for ServiceError { fn from(error: asynchronous::DBAsyncError) -> Self { ServiceError { status_code: StatusCode::INTERNAL_SERVER_ERROR, @@ -76,7 +95,7 @@ impl From for ServiceError { } } -impl From for ServiceError { +impl From for ServiceError { fn from(error: email::Error) -> Self { ServiceError { status_code: StatusCode::INTERNAL_SERVER_ERROR, @@ -85,7 +104,7 @@ impl From for ServiceError { } } -impl From for ServiceError { +impl From for ServiceError { fn from(error: actix_web::error::BlockingError) -> Self { ServiceError { status_code: StatusCode::INTERNAL_SERVER_ERROR, @@ -94,7 +113,7 @@ impl From for ServiceError { } } -impl From for ServiceError { +impl From for ServiceError { fn from(error: ron::error::SpannedError) -> Self { ServiceError { status_code: StatusCode::INTERNAL_SERVER_ERROR, @@ -116,7 +135,8 @@ impl actix_web::error::ResponseError for ServiceError { fn error_response(&self) -> HttpResponse { MessageBaseTemplate { message: &self.to_string(), - }.to_response() + } + .to_response() } fn status_code(&self) -> StatusCode { @@ -135,11 +155,19 @@ struct HomeTemplate { } #[get("/")] -pub async fn home_page(req: HttpRequest, connection: web::Data) -> Result { +pub async fn home_page( + req: HttpRequest, + connection: web::Data, +) -> Result { let user = get_current_user(&req, connection.clone()).await; let recipes = connection.get_all_recipe_titles_async().await?; - Ok(HomeTemplate { user, current_recipe_id: None, recipes }.to_response()) + Ok(HomeTemplate { + user, + current_recipe_id: None, + recipes, + } + .to_response()) } ///// VIEW RECIPE ///// @@ -154,8 +182,12 @@ struct ViewRecipeTemplate { } #[get("/recipe/view/{id}")] -pub async fn view_recipe(req: HttpRequest, path: web::Path<(i64,)>, connection: web::Data) -> Result { - let (id,)= path.into_inner(); +pub async fn view_recipe( + req: HttpRequest, + path: web::Path<(i64,)>, + connection: web::Data, +) -> Result { + let (id,) = path.into_inner(); let user = get_current_user(&req, connection.clone()).await; let recipes = connection.get_all_recipe_titles_async().await?; let recipe = connection.get_recipe_async(id).await?; @@ -165,7 +197,8 @@ pub async fn view_recipe(req: HttpRequest, path: web::Path<(i64,)>, connection: current_recipe_id: Some(recipe.id), recipes, current_recipe: recipe, - }.to_response()) + } + .to_response()) } ///// EDIT RECIPE ///// @@ -180,8 +213,12 @@ struct EditRecipeTemplate { } #[get("/recipe/edit/{id}")] -pub async fn edit_recipe(req: HttpRequest, path: web::Path<(i64,)>, connection: web::Data) -> Result { - let (id,)= path.into_inner(); +pub async fn edit_recipe( + req: HttpRequest, + path: web::Path<(i64,)>, + connection: web::Data, +) -> Result { + let (id,) = path.into_inner(); let user = get_current_user(&req, connection.clone()).await; let recipes = connection.get_all_recipe_titles_async().await?; let recipe = connection.get_recipe_async(id).await?; @@ -191,7 +228,8 @@ pub async fn edit_recipe(req: HttpRequest, path: web::Path<(i64,)>, connection: current_recipe_id: Some(recipe.id), recipes, current_recipe: recipe, - }.to_response()) + } + .to_response()) } ///// MESSAGE ///// @@ -222,9 +260,18 @@ struct SignUpFormTemplate { } #[get("/signup")] -pub async fn sign_up_get(req: HttpRequest, connection: web::Data) -> impl Responder { +pub async fn sign_up_get( + req: HttpRequest, + connection: web::Data, +) -> impl Responder { let user = get_current_user(&req, connection.clone()).await; - SignUpFormTemplate { user, email: String::new(), message: String::new(), message_email: String::new(), message_password: String::new() } + SignUpFormTemplate { + user, + email: String::new(), + message: String::new(), + message_email: String::new(), + message_password: String::new(), + } } #[derive(Deserialize)] @@ -244,30 +291,40 @@ enum SignUpError { } #[post("/signup")] -pub async fn sign_up_post(req: HttpRequest, form: web::Form, connection: web::Data, config: web::Data) -> Result { - fn error_response(error: SignUpError, form: &web::Form, user: Option) -> Result { +pub async fn sign_up_post( + req: HttpRequest, + form: web::Form, + connection: web::Data, + config: web::Data, +) -> Result { + fn error_response( + error: SignUpError, + form: &web::Form, + user: Option, + ) -> Result { Ok(SignUpFormTemplate { user, email: form.email.clone(), - message_email: - match error { - SignUpError::InvalidEmail => "Invalid email", - _ => "", - }.to_string(), - message_password: - match error { - SignUpError::PasswordsNotEqual => "Passwords don't match", - SignUpError::InvalidPassword => "Password must have at least eight characters", - _ => "", - }.to_string(), - message: - match error { - SignUpError::UserAlreadyExists => "This email is already taken", - SignUpError::DatabaseError => "Database error", - SignUpError::UnableSendEmail => "Unable to send the validation email", - _ => "", - }.to_string(), - }.to_response()) + message_email: match error { + SignUpError::InvalidEmail => "Invalid email", + _ => "", + } + .to_string(), + message_password: match error { + SignUpError::PasswordsNotEqual => "Passwords don't match", + SignUpError::InvalidPassword => "Password must have at least eight characters", + _ => "", + } + .to_string(), + message: match error { + SignUpError::UserAlreadyExists => "This email is already taken", + SignUpError::DatabaseError => "Database error", + SignUpError::UnableSendEmail => "Unable to send the validation email", + _ => "", + } + .to_string(), + } + .to_response()) } let user = get_current_user(&req, connection.clone()).await; @@ -281,51 +338,80 @@ pub async fn sign_up_post(req: HttpRequest, form: web::Form, con return error_response(SignUpError::PasswordsNotEqual, &form, user); } - if let common::utils::PasswordValidation::TooShort = common::utils::validate_password(&form.password_1) { + if let common::utils::PasswordValidation::TooShort = + common::utils::validate_password(&form.password_1) + { return error_response(SignUpError::InvalidPassword, &form, user); } - match connection.sign_up_async(&form.email, &form.password_1).await { + match connection + .sign_up_async(&form.email, &form.password_1) + .await + { Ok(db::SignUpResult::UserAlreadyExists) => { error_response(SignUpError::UserAlreadyExists, &form, user) - }, + } Ok(db::SignUpResult::UserCreatedWaitingForValidation(token)) => { let url = { - let host = req.headers().get(header::HOST).map(|v| v.to_str().unwrap_or_default()).unwrap_or_default(); + let host = req + .headers() + .get(header::HOST) + .map(|v| v.to_str().unwrap_or_default()) + .unwrap_or_default(); let port: Option = 'p: { let split_port: Vec<&str> = host.split(':').collect(); if split_port.len() == 2 { if let Ok(p) = split_port[1].parse::() { - break 'p Some(p) + break 'p Some(p); } } None }; - format!("http{}://{}", if port.is_some() && port.unwrap() != 443 { "" } else { "s" }, host) + format!( + "http{}://{}", + if port.is_some() && port.unwrap() != 443 { + "" + } else { + "s" + }, + host + ) }; let email = form.email.clone(); - match web::block(move || { email::send_validation(&url, &email, &token, &config.smtp_login, &config.smtp_password) }).await? { - Ok(()) => - Ok(HttpResponse::Found() - .insert_header((header::LOCATION, "/signup_check_email")) - .finish()), + match web::block(move || { + email::send_validation( + &url, + &email, + &token, + &config.smtp_login, + &config.smtp_password, + ) + }) + .await? + { + Ok(()) => Ok(HttpResponse::Found() + .insert_header((header::LOCATION, "/signup_check_email")) + .finish()), Err(error) => { error!("Email validation error: {}", error); error_response(SignUpError::UnableSendEmail, &form, user) - }, + } } - }, + } Err(error) => { error!("Signup database error: {}", error); error_response(SignUpError::DatabaseError, &form, user) - }, + } } } #[get("/signup_check_email")] -pub async fn sign_up_check_email(req: HttpRequest, connection: web::Data) -> impl Responder { +pub async fn sign_up_check_email( + req: HttpRequest, + connection: web::Data, +) -> impl Responder { let user = get_current_user(&req, connection.clone()).await; MessageTemplate { user, @@ -334,55 +420,64 @@ pub async fn sign_up_check_email(req: HttpRequest, connection: web::Data>, connection: web::Data) -> Result { +pub async fn sign_up_validation( + req: HttpRequest, + query: web::Query>, + connection: web::Data, +) -> Result { let (client_ip, client_user_agent) = get_ip_and_user_agent(&req); let user = get_current_user(&req, connection.clone()).await; match query.get("token") { Some(token) => { - match connection.validation_async(token, Duration::seconds(consts::VALIDATION_TOKEN_DURATION), &client_ip, &client_user_agent).await? { + match connection + .validation_async( + token, + Duration::seconds(consts::VALIDATION_TOKEN_DURATION), + &client_ip, + &client_user_agent, + ) + .await? + { db::ValidationResult::Ok(token, user_id) => { let cookie = Cookie::new(consts::COOKIE_AUTH_TOKEN_NAME, token); - let user = - match connection.load_user(user_id) { - Ok(user) => - Some(user), - Err(error) => { - error!("Error retrieving user by id: {}", error); - None - } - }; - - let mut response = - MessageTemplate { - user, - message: "Email validation successful, your account has been created", - }.to_response(); + let user = match connection.load_user(user_id) { + Ok(user) => Some(user), + Err(error) => { + error!("Error retrieving user by id: {}", error); + None + } + }; + + let mut response = MessageTemplate { + user, + message: "Email validation successful, your account has been created", + } + .to_response(); if let Err(error) = response.add_cookie(&cookie) { error!("Unable to set cookie after validation: {}", error); }; Ok(response) - }, - db::ValidationResult::ValidationExpired => - Ok(MessageTemplate { - user, - message: "The validation has expired. Try to sign up again.", - }.to_response()), - db::ValidationResult::UnknownUser => - Ok(MessageTemplate { - user, - message: "Validation error.", - }.to_response()), + } + db::ValidationResult::ValidationExpired => Ok(MessageTemplate { + user, + message: "The validation has expired. Try to sign up again.", + } + .to_response()), + db::ValidationResult::UnknownUser => Ok(MessageTemplate { + user, + message: "Validation error.", + } + .to_response()), } - }, - None => { - Ok(MessageTemplate { - user, - message: &format!("No token provided"), - }.to_response()) - }, + } + None => Ok(MessageTemplate { + user, + message: &format!("No token provided"), + } + .to_response()), } } @@ -397,7 +492,10 @@ struct SignInFormTemplate { } #[get("/signin")] -pub async fn sign_in_get(req: HttpRequest, connection: web::Data) -> impl Responder { +pub async fn sign_in_get( + req: HttpRequest, + connection: web::Data, +) -> impl Responder { let user = get_current_user(&req, connection.clone()).await; SignInFormTemplate { user, @@ -418,62 +516,74 @@ enum SignInError { } #[post("/signin")] -pub async fn sign_in_post(req: HttpRequest, form: web::Form, connection: web::Data) -> Result { - fn error_response(error: SignInError, form: &web::Form, user: Option) -> Result { +pub async fn sign_in_post( + req: HttpRequest, + form: web::Form, + connection: web::Data, +) -> Result { + fn error_response( + error: SignInError, + form: &web::Form, + user: Option, + ) -> Result { Ok(SignInFormTemplate { user, email: form.email.clone(), - message: - match error { - SignInError::AccountNotValidated => "This account must be validated first", - SignInError::AuthenticationFailed => "Wrong email or password", - }.to_string(), - }.to_response()) + message: match error { + SignInError::AccountNotValidated => "This account must be validated first", + SignInError::AuthenticationFailed => "Wrong email or password", + } + .to_string(), + } + .to_response()) } let user = get_current_user(&req, connection.clone()).await; let (client_ip, client_user_agent) = get_ip_and_user_agent(&req); - match connection.sign_in_async(&form.email, &form.password, &client_ip, &client_user_agent).await { - Ok(db::SignInResult::AccountNotValidated) => - error_response(SignInError::AccountNotValidated, &form, user), + match connection + .sign_in_async(&form.email, &form.password, &client_ip, &client_user_agent) + .await + { + Ok(db::SignInResult::AccountNotValidated) => { + error_response(SignInError::AccountNotValidated, &form, user) + } Ok(db::SignInResult::UserNotFound) | Ok(db::SignInResult::WrongPassword) => { error_response(SignInError::AuthenticationFailed, &form, user) - }, + } Ok(db::SignInResult::Ok(token, user_id)) => { let cookie = Cookie::new(consts::COOKIE_AUTH_TOKEN_NAME, token); - let mut response = - HttpResponse::Found() - .insert_header((header::LOCATION, "/")) - .finish(); + let mut response = HttpResponse::Found() + .insert_header((header::LOCATION, "/")) + .finish(); if let Err(error) = response.add_cookie(&cookie) { error!("Unable to set cookie after sign in: {}", error); }; Ok(response) - }, + } Err(error) => { error!("Signin error: {}", error); error_response(SignInError::AuthenticationFailed, &form, user) - }, + } } } - ///// SIGN OUT ///// #[get("/signout")] pub async fn sign_out(req: HttpRequest, connection: web::Data) -> impl Responder { - let mut response = - HttpResponse::Found() - .insert_header((header::LOCATION, "/")) - .finish(); + let mut response = HttpResponse::Found() + .insert_header((header::LOCATION, "/")) + .finish(); if let Some(token_cookie) = req.cookie(consts::COOKIE_AUTH_TOKEN_NAME) { if let Err(error) = connection.sign_out_async(token_cookie.value()).await { error!("Unable to sign out: {}", error); }; - if let Err(error) = response.add_removal_cookie(&Cookie::new(consts::COOKIE_AUTH_TOKEN_NAME, "")) { + if let Err(error) = + response.add_removal_cookie(&Cookie::new(consts::COOKIE_AUTH_TOKEN_NAME, "")) + { error!("Unable to set a removal cookie after sign out: {}", error); }; }; diff --git a/backend/src/services/api.rs b/backend/src/services/api.rs index fa126c5..88dc048 100644 --- a/backend/src/services/api.rs +++ b/backend/src/services/api.rs @@ -1,28 +1,45 @@ -use actix_web::{http::{header, header::ContentType, StatusCode}, get, post, put, web, Responder, HttpRequest, HttpResponse, cookie::Cookie, HttpMessage}; +use actix_web::{ + cookie::Cookie, + get, + http::{header, header::ContentType, StatusCode}, + post, put, web, HttpMessage, HttpRequest, HttpResponse, Responder, +}; use chrono::Duration; use futures::TryFutureExt; -use serde::Deserialize; +use log::{debug, error, info, log_enabled, Level}; use ron::de::from_bytes; -use log::{debug, error, log_enabled, info, Level}; +use serde::Deserialize; use super::Result; -use crate::utils; -use crate::consts; use crate::config::Config; -use crate::user::User; +use crate::consts; +use crate::data::{asynchronous, db}; use crate::model; -use crate::data::{db, asynchronous}; +use crate::user::User; +use crate::utils; #[put("/ron-api/recipe/set-title")] -pub async fn set_recipe_title(req: HttpRequest, body: web::Bytes, connection: web::Data) -> Result { +pub async fn set_recipe_title( + req: HttpRequest, + body: web::Bytes, + connection: web::Data, +) -> Result { let ron_req: common::ron_api::SetRecipeTitle = from_bytes(&body)?; - connection.set_recipe_title_async(ron_req.recipe_id, &ron_req.title).await?; + connection + .set_recipe_title_async(ron_req.recipe_id, &ron_req.title) + .await?; Ok(HttpResponse::Ok().finish()) } #[put("/ron-api/recipe/set-description")] -pub async fn set_recipe_description(req: HttpRequest, body: web::Bytes, connection: web::Data) -> Result { +pub async fn set_recipe_description( + req: HttpRequest, + body: web::Bytes, + connection: web::Data, +) -> Result { let ron_req: common::ron_api::SetRecipeDescription = from_bytes(&body)?; - connection.set_recipe_description_async(ron_req.recipe_id, &ron_req.description).await?; + connection + .set_recipe_description_async(ron_req.recipe_id, &ron_req.description) + .await?; Ok(HttpResponse::Ok().finish()) -} \ No newline at end of file +} diff --git a/backend/src/user.rs b/backend/src/user.rs index d9825ae..753d714 100644 --- a/backend/src/user.rs +++ b/backend/src/user.rs @@ -8,4 +8,4 @@ pub struct UserLoginInfo { pub last_login_datetime: DateTime, pub ip: String, pub user_agent: String, -} \ No newline at end of file +} diff --git a/backend/src/utils.rs b/backend/src/utils.rs index d39a970..f8d41af 100644 --- a/backend/src/utils.rs +++ b/backend/src/utils.rs @@ -2,10 +2,10 @@ use log::error; pub fn unwrap_print_err(r: Result) -> T where - E: std::fmt::Debug + E: std::fmt::Debug, { if let Err(ref error) = r { error!("{:?}", error); } r.unwrap() -} \ No newline at end of file +} -- 2.45.2