X-Git-Url: http://git.euphorik.ch/?a=blobdiff_plain;f=backend%2Fsrc%2Fmain.rs;h=df7c44b85e033695c12a663a679c10600d3cab64;hb=cbe276fc0601041b13087a6ffd80c5b126dfbe59;hp=141c87fef46ff6b8e16d30eaa53ce638e34f20d4;hpb=45d4867cb37ce8d7007c4d98de70d81d0b705b92;p=recipes.git diff --git a/backend/src/main.rs b/backend/src/main.rs index 141c87f..df7c44b 100644 --- a/backend/src/main.rs +++ b/backend/src/main.rs @@ -1,266 +1,26 @@ -use std::{collections::HashMap, net::ToSocketAddrs}; - use actix_files as fs; -use actix_web::{http::header, get, post, web, Responder, middleware, App, HttpServer, HttpRequest, HttpResponse}; -use askama_actix::{Template, TemplateToResponse}; -use chrono::{prelude::*, Duration}; +use actix_web::{web, middleware, App, HttpServer}; +use chrono::prelude::*; use clap::Parser; -use serde::Deserialize; +use log::error; -use config::Config; +use data::db; mod consts; -mod db; +mod utils; +mod data; mod hash; mod model; mod user; mod email; mod config; - -#[derive(Template)] -#[template(path = "home.html")] -struct HomeTemplate { - recipes: Vec<(i32, String)>, -} - -#[derive(Template)] -#[template(path = "sign_in_form.html")] -struct SignInFormTemplate { -} - -#[derive(Template)] -#[template(path = "view_recipe.html")] -struct ViewRecipeTemplate { - recipes: Vec<(i32, String)>, - current_recipe: model::Recipe, -} - -#[derive(Template)] -#[template(path = "message.html")] -struct MessageTemplate { - recipes: Vec<(i32, String)>, - message: String, -} - -#[get("/")] -async fn home_page(req: HttpRequest, connection: web::Data) -> impl Responder { - HomeTemplate { recipes: connection.get_all_recipe_titles().unwrap_or_default() } -} - -//// SIGN UP ///// - -#[derive(Template)] -#[template(path = "sign_up_form.html")] -struct SignUpFormTemplate { - email: String, - message: String, - message_email: String, - message_password: String, -} - -impl SignUpFormTemplate { - fn new() -> Self { - SignUpFormTemplate { email: String::new(), message: String::new(), message_email: String::new(), message_password: String::new() } - } -} - -enum SignUpError { - InvalidEmail, - PasswordsNotEqual, - InvalidPassword, - UserAlreadyExists, - DatabaseError, - UnableSendEmail, -} - -#[get("/signup")] -async fn sign_up_get(req: HttpRequest, query: web::Query>, connection: web::Data) -> impl Responder { - SignUpFormTemplate::new() -} - -#[derive(Deserialize)] -struct SignUpFormData { - email: String, - password_1: String, - password_2: String, -} - -#[post("/signup")] -async fn sign_up_post(req: HttpRequest, form: web::Form, connection: web::Data, config: web::Data) -> impl Responder { - println!("Sign Up, email: {}, passwords: {}/{}", form.email, form.password_1, form.password_2); - - fn error_response(error: SignUpError, form: &web::Form) -> HttpResponse { - SignUpFormTemplate { - 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() - } - - // Validation of email and password. - if let common::utils::EmailValidation::NotValid = common::utils::validate_email(&form.email) { - return error_response(SignUpError::InvalidEmail, &form); - } - - if form.password_1 != form.password_2 { - return error_response(SignUpError::PasswordsNotEqual, &form); - } - - if let common::utils::PasswordValidation::TooShort = common::utils::validate_password(&form.password_1) { - return error_response(SignUpError::InvalidPassword, &form); - } - - match connection.sign_up(&form.email, &form.password_1) { - Ok(db::SignUpResult::UserAlreadyExists) => { - error_response(SignUpError::UserAlreadyExists, &form) - }, - 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 = '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) - } - } - None - }; - format!("http{}://{}", if port.is_some() && port.unwrap() != 443 { "" } else { "s" }, host) - }; - match email::send_validation(&url, &form.email, &token, &config.smtp_login, &config.smtp_password) { - Ok(()) => - HttpResponse::Found() - .insert_header((header::LOCATION, "/signup_check_email")) - .finish(), - Err(error) => { - eprintln!("Email validation error: {:?}", error); - error_response(SignUpError::UnableSendEmail, &form) - }, - } - }, - Err(error) => { - eprintln!("Signup database error: {:?}", error); - error_response(SignUpError::DatabaseError, &form) - }, - } -} - -#[get("/signup_check_email")] -async fn sign_up_check_email(connection: web::Data) -> impl Responder { - let recipes = connection.get_all_recipe_titles().unwrap_or_default(); - MessageTemplate { - recipes, - message: "An email has been sent, follow the link to validate your account.".to_string(), - } -} - -#[get("/validation")] -async fn sign_up_validation(req: HttpRequest, query: web::Query>, connection: web::Data) -> impl Responder { - - println!("req:\n{:#?}", req); - - let client_user_agent = req.headers().get(header::USER_AGENT).map(|v| v.to_str().unwrap_or_default()).unwrap_or_default(); - let client_ip = req.peer_addr().map(|addr| addr.ip().to_string()).unwrap_or_default(); - - let recipes = connection.get_all_recipe_titles().unwrap_or_default(); - match query.get("token") { - Some(token) => { - match connection.validation(token, Duration::seconds(consts::VALIDATION_TOKEN_DURATION), &client_ip, client_user_agent).unwrap() { - db::ValidationResult::Ok(token, user_id) => - // TODO: set token to cookie. - MessageTemplate { - recipes, - message: "Email validation successful, your account has been created".to_string(), - }, - db::ValidationResult::ValidationExpired => - MessageTemplate { - recipes, - message: "The validation has expired. Try to sign up again.".to_string(), - }, - db::ValidationResult::UnknownUser => - MessageTemplate { - recipes, - message: "Validation error.".to_string(), - }, - } - }, - None => { - MessageTemplate { - recipes, - message: format!("No token provided"), - } - }, - } -} - -///// SIGN IN ///// - -#[get("/signinform")] -async fn sign_in_form(req: HttpRequest, connection: web::Data) -> impl Responder { - SignInFormTemplate { - } -} - -#[post("/signin")] -async fn sign_in(req: HttpRequest) -> impl Responder { - "todo" -} - -#[get("/recipe/view/{id}")] -async fn view_recipe(req: HttpRequest, path: web::Path<(i32,)>, connection: web::Data) -> impl Responder { - let (id,)= path.into_inner(); - let recipes = connection.get_all_recipe_titles().unwrap_or_default(); - println!("{:?}", recipes); - match connection.get_recipe(id) { - Ok(recipe) => - ViewRecipeTemplate { - recipes, - current_recipe: recipe, - }.to_response(), - Err(_error) => - MessageTemplate { - recipes, - message: format!("Unable to get recipe #{}", id), - }.to_response(), - } -} - -async fn not_found(req: HttpRequest, connection: web::Data) -> impl Responder { - let recipes = connection.get_all_recipe_titles().unwrap_or_default(); - MessageTemplate { - recipes, - message: "404: Not found".to_string(), - } -} - -fn get_exe_name() -> String { - let first_arg = std::env::args().nth(0).unwrap(); - let sep: &[_] = &['\\', '/']; - first_arg[first_arg.rfind(sep).unwrap()+1..].to_string() -} +mod services; #[actix_web::main] async fn main() -> std::io::Result<()> { if process_args() { return Ok(()) } - std::env::set_var("RUST_LOG", "actix_web=debug"); + std::env::set_var("RUST_LOG", "info,actix_web=info"); env_logger::init(); println!("Starting Recipes as web server..."); @@ -272,8 +32,6 @@ async fn main() -> std::io::Result<()> { let db_connection = web::Data::new(db::Connection::new().unwrap()); - std::env::set_var("RUST_LOG", "actix_web=info"); - let server = HttpServer::new(move || { App::new() @@ -281,18 +39,20 @@ async fn main() -> std::io::Result<()> { .wrap(middleware::Compress::default()) .app_data(db_connection.clone()) .app_data(config.clone()) - .service(home_page) - .service(sign_up_get) - .service(sign_up_post) - .service(sign_up_check_email) - .service(sign_up_validation) - .service(sign_in_form) - .service(sign_in) - .service(view_recipe) + .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(not_found)) - //.default_service(not_found) + .default_service(web::to(services::not_found)) }); + //.workers(1); server.bind(&format!("0.0.0.0:{}", port))?.run().await } @@ -310,13 +70,13 @@ fn process_args() -> bool { match db::Connection::new() { Ok(con) => { if let Err(error) = con.execute_file("sql/data_test.sql") { - println!("Error: {:?}", error); + 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(); }, Err(error) => { - println!("Error: {:?}", error) + eprintln!("{}", error); }, } @@ -324,27 +84,4 @@ fn process_args() -> bool { } false - - /* - - - fn print_usage() { - println!("Usage:"); - println!(" {} [--help] [--test]", get_exe_name()); - } - - let args: Vec = args().collect(); - - if args.iter().any(|arg| arg == "--help") { - print_usage(); - return true - } else if args.iter().any(|arg| arg == "--test") { - match db::Connection::new() { - Ok(_) => (), - Err(error) => println!("Error: {:?}", error) - } - return true - } - false - */ }