--- /dev/null
+use std::collections::HashMap;
+
+use actix_web::{http::{header, header::ContentType, StatusCode}, get, post, web, Responder, HttpRequest, HttpResponse, cookie::Cookie};
+use askama_actix::{Template, TemplateToResponse};
+use chrono::Duration;
+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::model;
+use crate::data::{db, asynchronous};
+
+///// 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 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> {
+ 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
+ }
+}
+
+type Result<T> = std::result::Result<T, ServiceError>;
+
+///// ERROR /////
+
+#[derive(Debug)]
+pub struct ServiceError {
+ status_code: StatusCode,
+ message: Option<String>,
+}
+
+impl From<asynchronous::DBAsyncError> for ServiceError {
+ fn from(error: asynchronous::DBAsyncError) -> Self {
+ ServiceError {
+ status_code: StatusCode::INTERNAL_SERVER_ERROR,
+ message: Some(format!("{:?}", error)),
+ }
+ }
+}
+
+impl From<email::Error> for ServiceError {
+ fn from(error: email::Error) -> Self {
+ ServiceError {
+ status_code: StatusCode::INTERNAL_SERVER_ERROR,
+ message: Some(format!("{:?}", error)),
+ }
+ }
+}
+
+impl From<actix_web::error::BlockingError> for ServiceError {
+ fn from(error: actix_web::error::BlockingError) -> Self {
+ ServiceError {
+ status_code: StatusCode::INTERNAL_SERVER_ERROR,
+ message: Some(format!("{:?}", error)),
+ }
+ }
+}
+
+impl std::fmt::Display for ServiceError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+ if let Some(ref m) = self.message {
+ write!(f, "**{}**\n\n", m)?;
+ }
+ write!(f, "Code: {}", self.status_code)
+ }
+}
+
+impl actix_web::error::ResponseError for ServiceError {
+ fn error_response(&self) -> HttpResponse {
+ MessageBaseTemplate {
+ message: &self.to_string(),
+ }.to_response()
+ }
+
+ fn status_code(&self) -> StatusCode {
+ self.status_code
+ }
+}
+
+///// HOME /////
+
+#[derive(Template)]
+#[template(path = "home.html")]
+struct HomeTemplate {
+ user: Option<User>,
+ recipes: Vec<(i32, String)>,
+ current_recipe_id: Option<i32>,
+}
+
+#[get("/")]
+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())
+}
+
+///// VIEW RECIPE /////
+
+#[derive(Template)]
+#[template(path = "view_recipe.html")]
+struct ViewRecipeTemplate {
+ user: Option<User>,
+ recipes: Vec<(i32, String)>,
+ current_recipe_id: Option<i32>,
+ current_recipe: model::Recipe,
+}
+
+#[get("/recipe/view/{id}")]
+pub async fn view_recipe(req: HttpRequest, path: web::Path<(i32,)>, 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?;
+
+ Ok(ViewRecipeTemplate {
+ user,
+ current_recipe_id: Some(recipe.id),
+ recipes,
+ current_recipe: recipe,
+ }.to_response())
+}
+
+///// MESSAGE /////
+
+#[derive(Template)]
+#[template(path = "message_base.html")]
+struct MessageBaseTemplate<'a> {
+ message: &'a str,
+}
+
+#[derive(Template)]
+#[template(path = "message.html")]
+struct MessageTemplate<'a> {
+ user: Option<User>,
+ message: &'a str,
+}
+
+//// SIGN UP /////
+
+#[derive(Template)]
+#[template(path = "sign_up_form.html")]
+struct SignUpFormTemplate {
+ user: Option<User>,
+ email: String,
+ message: String,
+ message_email: String,
+ message_password: String,
+}
+
+#[get("/signup")]
+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() }
+}
+
+#[derive(Deserialize)]
+pub struct SignUpFormData {
+ email: String,
+ password_1: String,
+ password_2: String,
+}
+
+enum SignUpError {
+ InvalidEmail,
+ PasswordsNotEqual,
+ InvalidPassword,
+ UserAlreadyExists,
+ DatabaseError,
+ UnableSendEmail,
+}
+
+#[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> {
+ 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())
+ }
+
+ let user = get_current_user(&req, connection.clone()).await;
+
+ // Validation of email and password.
+ if let common::utils::EmailValidation::NotValid = common::utils::validate_email(&form.email) {
+ return error_response(SignUpError::InvalidEmail, &form, user);
+ }
+
+ if form.password_1 != form.password_2 {
+ return error_response(SignUpError::PasswordsNotEqual, &form, user);
+ }
+
+ 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 {
+ 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 port: Option<i32> = 'p: {
+ let split_port: Vec<&str> = host.split(':').collect();
+ if split_port.len() == 2 {
+ if let Ok(p) = split_port[1].parse::<i32>() {
+ break 'p Some(p)
+ }
+ }
+ None
+ };
+ 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()),
+ 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 {
+ let user = get_current_user(&req, connection.clone()).await;
+ MessageTemplate {
+ user,
+ message: "An email has been sent, follow the link to validate your account.",
+ }
+}
+
+#[get("/validation")]
+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? {
+ 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();
+
+ 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()),
+ }
+ },
+ None => {
+ Ok(MessageTemplate {
+ user,
+ message: &format!("No token provided"),
+ }.to_response())
+ },
+ }
+}
+
+///// SIGN IN /////
+
+#[derive(Template)]
+#[template(path = "sign_in_form.html")]
+struct SignInFormTemplate {
+ user: Option<User>,
+ email: String,
+ message: String,
+}
+
+#[get("/signin")]
+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,
+ email: String::new(),
+ message: String::new(),
+ }
+}
+
+#[derive(Deserialize)]
+pub struct SignInFormData {
+ email: String,
+ password: String,
+}
+
+enum SignInError {
+ AccountNotValidated,
+ AuthenticationFailed,
+}
+
+#[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> {
+ 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())
+ }
+
+ 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),
+ 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();
+ 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();
+
+ 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, "")) {
+ error!("Unable to set a removal cookie after sign out: {}", error);
+ };
+ };
+ response
+}
+
+pub async fn not_found(req: HttpRequest, connection: web::Data<db::Connection>) -> impl Responder {
+ let user = get_current_user(&req, connection.clone()).await;
+ MessageTemplate {
+ user,
+ message: "404: Not found",
+ }
+}
projects / recipes.git / blobdiff