- 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<P>(filename: P) -> bool
- where P: AsRef<Path> {
- for path in env::split_paths(&env::var_os("PATH").unwrap()) {
- if path.join(&filename).is_file() { return true; }
+where
+ P: AsRef<Path>,
+{
+ for path in env::split_paths(&env::var_os("PATH").unwrap()) {
+ if path.join(&filename).is_file() {
+ return true;
}
+ }
false
}
.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
+}
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
+}
-
use std::time::Duration;
pub const FILE_CONF: &str = "conf.ron";
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;
}
}
-impl std::error::Error for DBAsyncError { }
+impl std::error::Error for DBAsyncError {}
-impl From<DBError> for DBAsyncError {
+impl From<DBError> for DBAsyncError {
fn from(error: DBError) -> Self {
DBAsyncError::DBError(error)
}
}
-impl From<BlockingError> for DBAsyncError {
+impl From<BlockingError> for DBAsyncError {
fn from(error: BlockingError) -> Self {
DBAsyncError::ActixError(error)
}
}
}
-fn combine_errors<T>(error: std::result::Result<std::result::Result<T, DBAsyncError>, BlockingError>) -> Result<T> {
+fn combine_errors<T>(
+ error: std::result::Result<std::result::Result<T, DBAsyncError>, BlockingError>,
+) -> Result<T> {
error?
}
impl Connection {
pub async fn get_all_recipe_titles_async(&self) -> Result<Vec<(i64, String)>> {
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<model::Recipe> {
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<User> {
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<SignUpResult> {
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<ValidationResult> {
+ pub async fn validation_async(
+ &self,
+ token: &str,
+ validation_time: Duration,
+ ip: &str,
+ user_agent: &str,
+ ) -> Result<ValidationResult> {
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<SignInResult> {
+ pub async fn sign_in_async(
+ &self,
+ email: &str,
+ password: &str,
+ ip: &str,
+ user_agent: &str,
+ ) -> Result<SignInResult> {
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<AuthenticationResult> {
+ pub async fn authentication_async(
+ &self,
+ token: &str,
+ ip: &str,
+ user_agent: &str,
+ ) -> Result<AuthenticationResult> {
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<i64> {
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
+}
-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;
}
}
-impl std::error::Error for DBError { }
+impl std::error::Error for DBError {}
-impl From<rusqlite::Error> for DBError {
+impl From<rusqlite::Error> for DBError {
fn from(error: rusqlite::Error) -> Self {
DBError::SqliteError(error)
}
}
-impl From<r2d2::Error> for DBError {
+impl From<r2d2::Error> for DBError {
fn from(error: r2d2::Error) -> Self {
DBError::R2d2Error(error)
}
#[derive(Clone)]
pub struct Connection {
- pool: Pool<SqliteConnectionManager>
+ pool: Pool<SqliteConnectionManager>,
}
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::<usize, String>(0),
+ ) {
+ Ok(_) => tx
+ .query_row(
+ "SELECT [version] FROM [Version] ORDER BY [id] DESC",
[],
- |row| row.get::<usize, String>(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,
}
};
}
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<bool> {
}
// Version 1 doesn't exist yet.
- 2 =>
- ok(false),
+ 2 => ok(false),
- v =>
- Err(DBError::UnsupportedVersion(v)),
+ v => Err(DBError::UnsupportedVersion(v)),
}
}
let mut stmt = con.prepare("SELECT [id], [title] FROM [Recipe] ORDER BY [title]")?;
- let titles: std::result::Result<Vec<(i64, String)>, rusqlite::Error> =
- stmt.query_map([], |row| {
- Ok((row.get("id")?, row.get("title")?))
- })?.collect();
+ let titles: std::result::Result<Vec<(i64, String)>, rusqlite::Error> = stmt
+ .query_map([], |row| Ok((row.get("id")?, row.get("title")?)))?
+ .collect();
titles.map_err(DBError::from)
}
pub fn get_recipe(&self, id: i64) -> Result<model::Recipe> {
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<UserLoginInfo> {
pub fn load_user(&self, user_id: i64) -> Result<User> {
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<SignUpResult> {
self.sign_up_with_given_time(email, password, Utc::now())
}
- fn sign_up_with_given_time(&self, email: &str, password: &str, datetime: DateTime<Utc>) -> Result<SignUpResult> {
+ fn sign_up_with_given_time(
+ &self,
+ email: &str,
+ password: &str,
+ datetime: DateTime<Utc>,
+ ) -> Result<SignUpResult> {
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<String>>("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<String>>("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<ValidationResult> {
+ pub fn validation(
+ &self,
+ token: &str,
+ validation_time: Duration,
+ ip: &str,
+ user_agent: &str,
+ ) -> Result<ValidationResult> {
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<Utc>>("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<Utc>>("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<SignInResult> {
+ pub fn sign_in(
+ &self,
+ email: &str,
+ password: &str,
+ ip: &str,
+ user_agent: &str,
+ ) -> Result<SignInResult> {
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<String>>("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<String>>("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<AuthenticationResult> {
+ pub fn authentication(
+ &self,
+ token: &str,
+ ip: &str,
+ user_agent: &str,
+ ) -> Result<AuthenticationResult> {
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(())
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.
}
// Return the token.
- fn create_login_token(tx: &rusqlite::Transaction, user_id: i64, ip: &str, user_agent: &str) -> Result<String> {
+ fn create_login_token(
+ tx: &rusqlite::Transaction,
+ user_id: i64,
+ ip: &str,
+ user_agent: &str,
+ ) -> Result<String> {
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)
}
fn load_sql_file<P: AsRef<Path> + fmt::Display>(sql_file: P) -> Result<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 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)
}
#[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<()> {
#[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),
}
#[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),
}
#[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),
}
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),
};
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),
};
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)?;
Ok(())
}
-
#[test]
fn create_a_new_recipe_then_update_its_title() -> Result<()> {
let connection = Connection::new_in_memory()?;
)?;
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)?;
pub mod asynchronous;
-pub mod db;
\ No newline at end of file
+pub mod db;
-use std::time::Duration;
use derive_more::Display;
use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport};
+use std::time::Duration;
use crate::consts;
}
}
-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);
-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<String, Box<dyn std::error::Error>> {
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<bool, Box<dyn std::error::Error>> {
+pub fn verify_password(
+ password: &str,
+ hashed_password: &str,
+) -> Result<bool, Box<dyn std::error::Error>> {
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)]
assert!(verify_password(password, &hash)?);
Ok(())
}
-}
\ No newline at end of file
+}
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();
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
}
#[derive(Parser, Debug)]
struct Args {
#[arg(long)]
- dbtest: bool
+ dbtest: bool,
}
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;
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<db::Connection>) -> Option<User> {
+async fn get_current_user(
+ req: &HttpRequest,
+ connection: web::Data<db::Connection>,
+) -> Option<User> {
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,
}
}
message: Option<String>,
}
-impl From<asynchronous::DBAsyncError> for ServiceError {
+impl From<asynchronous::DBAsyncError> for ServiceError {
fn from(error: asynchronous::DBAsyncError) -> Self {
ServiceError {
status_code: StatusCode::INTERNAL_SERVER_ERROR,
}
}
-impl From<email::Error> for ServiceError {
+impl From<email::Error> for ServiceError {
fn from(error: email::Error) -> Self {
ServiceError {
status_code: StatusCode::INTERNAL_SERVER_ERROR,
}
}
-impl From<actix_web::error::BlockingError> for ServiceError {
+impl From<actix_web::error::BlockingError> for ServiceError {
fn from(error: actix_web::error::BlockingError) -> Self {
ServiceError {
status_code: StatusCode::INTERNAL_SERVER_ERROR,
}
}
-impl From<ron::error::SpannedError> for ServiceError {
+impl From<ron::error::SpannedError> for ServiceError {
fn from(error: ron::error::SpannedError) -> Self {
ServiceError {
status_code: StatusCode::INTERNAL_SERVER_ERROR,
fn error_response(&self) -> HttpResponse {
MessageBaseTemplate {
message: &self.to_string(),
- }.to_response()
+ }
+ .to_response()
}
fn status_code(&self) -> StatusCode {
}
#[get("/")]
-pub async fn home_page(req: HttpRequest, connection: web::Data<db::Connection>) -> Result<HttpResponse> {
+pub async fn home_page(
+ req: HttpRequest,
+ connection: web::Data<db::Connection>,
+) -> Result<HttpResponse> {
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 /////
}
#[get("/recipe/view/{id}")]
-pub async fn view_recipe(req: HttpRequest, path: web::Path<(i64,)>, connection: web::Data<db::Connection>) -> Result<HttpResponse> {
- let (id,)= path.into_inner();
+pub async fn view_recipe(
+ req: HttpRequest,
+ path: web::Path<(i64,)>,
+ connection: web::Data<db::Connection>,
+) -> Result<HttpResponse> {
+ 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?;
current_recipe_id: Some(recipe.id),
recipes,
current_recipe: recipe,
- }.to_response())
+ }
+ .to_response())
}
///// EDIT RECIPE /////
}
#[get("/recipe/edit/{id}")]
-pub async fn edit_recipe(req: HttpRequest, path: web::Path<(i64,)>, connection: web::Data<db::Connection>) -> Result<HttpResponse> {
- let (id,)= path.into_inner();
+pub async fn edit_recipe(
+ req: HttpRequest,
+ path: web::Path<(i64,)>,
+ connection: web::Data<db::Connection>,
+) -> Result<HttpResponse> {
+ 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?;
current_recipe_id: Some(recipe.id),
recipes,
current_recipe: recipe,
- }.to_response())
+ }
+ .to_response())
}
///// MESSAGE /////
}
#[get("/signup")]
-pub async fn sign_up_get(req: HttpRequest, connection: web::Data<db::Connection>) -> impl Responder {
+pub async fn sign_up_get(
+ req: HttpRequest,
+ connection: web::Data<db::Connection>,
+) -> 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)]
}
#[post("/signup")]
-pub async fn sign_up_post(req: HttpRequest, form: web::Form<SignUpFormData>, connection: web::Data<db::Connection>, config: web::Data<Config>) -> Result<HttpResponse> {
- fn error_response(error: SignUpError, form: &web::Form<SignUpFormData>, user: Option<User>) -> Result<HttpResponse> {
+pub async fn sign_up_post(
+ req: HttpRequest,
+ form: web::Form<SignUpFormData>,
+ connection: web::Data<db::Connection>,
+ config: web::Data<Config>,
+) -> Result<HttpResponse> {
+ fn error_response(
+ error: SignUpError,
+ form: &web::Form<SignUpFormData>,
+ user: Option<User>,
+ ) -> Result<HttpResponse> {
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;
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<u16> = 'p: {
let split_port: Vec<&str> = host.split(':').collect();
if split_port.len() == 2 {
if let Ok(p) = split_port[1].parse::<u16>() {
- 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<db::Connection>) -> impl Responder {
+pub async fn sign_up_check_email(
+ req: HttpRequest,
+ connection: web::Data<db::Connection>,
+) -> impl Responder {
let user = get_current_user(&req, connection.clone()).await;
MessageTemplate {
user,
}
#[get("/validation")]
-pub async fn sign_up_validation(req: HttpRequest, query: web::Query<HashMap<String, String>>, connection: web::Data<db::Connection>) -> Result<HttpResponse> {
+pub async fn sign_up_validation(
+ req: HttpRequest,
+ query: web::Query<HashMap<String, String>>,
+ connection: web::Data<db::Connection>,
+) -> Result<HttpResponse> {
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()),
}
}
}
#[get("/signin")]
-pub async fn sign_in_get(req: HttpRequest, connection: web::Data<db::Connection>) -> impl Responder {
+pub async fn sign_in_get(
+ req: HttpRequest,
+ connection: web::Data<db::Connection>,
+) -> impl Responder {
let user = get_current_user(&req, connection.clone()).await;
SignInFormTemplate {
user,
}
#[post("/signin")]
-pub async fn sign_in_post(req: HttpRequest, form: web::Form<SignInFormData>, connection: web::Data<db::Connection>) -> Result<HttpResponse> {
- fn error_response(error: SignInError, form: &web::Form<SignInFormData>, user: Option<User>) -> Result<HttpResponse> {
+pub async fn sign_in_post(
+ req: HttpRequest,
+ form: web::Form<SignInFormData>,
+ connection: web::Data<db::Connection>,
+) -> Result<HttpResponse> {
+ fn error_response(
+ error: SignInError,
+ form: &web::Form<SignInFormData>,
+ user: Option<User>,
+ ) -> Result<HttpResponse> {
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<db::Connection>) -> 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);
};
};
-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<db::Connection>) -> Result<HttpResponse> {
+pub async fn set_recipe_title(
+ req: HttpRequest,
+ body: web::Bytes,
+ connection: web::Data<db::Connection>,
+) -> Result<HttpResponse> {
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<db::Connection>) -> Result<HttpResponse> {
+pub async fn set_recipe_description(
+ req: HttpRequest,
+ body: web::Bytes,
+ connection: web::Data<db::Connection>,
+) -> Result<HttpResponse> {
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
+}
pub last_login_datetime: DateTime<Utc>,
pub ip: String,
pub user_agent: String,
-}
\ No newline at end of file
+}
pub fn unwrap_print_err<T, E>(r: Result<T, E>) -> 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
+}
projects / recipes.git / commitdiff