gburri/recipes
1
0
Fork 0
Code Issues 6 Pull requests Projects Releases Packages Wiki Activity Actions

Sign up form and other stuff

Browse source
This commit is contained in:
Greg Burri 2022-11-26 12:26:05 +01:00
parent b1ffd1a04a
commit 45d4867cb3
18 changed files with 817 additions and 107 deletions
Download patch file Download diff file Expand all files Collapse all files

6
backend/Cargo.toml
View file

@ -5,7 +5,7 @@ authors = ["Grégory Burri <greg.burri@gmail.com>"]
edition = "2021"
[dependencies]
#common = {path = "../common"}
common = {path = "../common"}
actix-web = "4"
actix-files = "0.6"
@ -31,4 +31,6 @@ askama_actix = "0.13"
argon2 = {version = "0.4", features = ["default", "std"]}
rand_core = {version = "0.6", features = ["std"]}
rand = "0.8"
rand = "0.8"
lettre = "0.10"

2
backend/launch_debug.ps1 → backend/launch_debug.nu
View file

@ -1,2 +1,2 @@
# To launch RUP and watching source. See https://actix.rs/docs/autoreload/.
cargo watch -x run
cargo [watch -x run]

24
backend/sql/version_1.sql
View file

@ -14,7 +14,9 @@ CREATE TABLE [User] (
[password] TEXT NOT NULL, -- argon2(password_plain, salt).
[creation_datetime] DATETIME NOT NULL, -- Updated when the validation email is sent.
[validation_token] TEXT -- If not null then the user has not validated his account yet.
[validation_token] TEXT, -- If not null then the user has not validated his account yet.
[is_admin] INTEGER NOT NULL DEFAULT FALSE
);
CREATE UNIQUE INDEX [User_email_index] ON [User] ([email]);
@ -28,20 +30,20 @@ CREATE TABLE [UserLoginToken] (
[ip] TEXT, -- Can be ipv4 or ipv6
[user_agent] TEXT,
FOREIGN KEY([user_id]) REFERENCES [User]([id])
FOREIGN KEY([user_id]) REFERENCES [User]([id]) ON DELETE CASCADE
);
CREATE INDEX [UserLoginToken_token_index] ON [UserLoginToken] ([token]);
CREATE TABLE [Recipe] (
[id] INTEGER PRIMARY KEY,
[user_id] INTEGER NOT NULL,
[user_id] INTEGER, -- Can be null if a user is deleted.
[title] TEXT NOT NULL,
[estimate_time] INTEGER,
[description] TEXT,
[servings] INTEGER DEFAULT 4,
FOREIGN KEY([user_id]) REFERENCES [User]([id])
FOREIGN KEY([user_id]) REFERENCES [User]([id]) ON DELETE SET NULL
);
CREATE TABLE [Quantity] (
@ -56,8 +58,8 @@ CREATE TABLE [Ingredient] (
[quantity_id] INTEGER,
[input_step_id] INTEGER NOT NULL,
FOREIGN KEY([quantity_id]) REFERENCES Quantity([id]),
FOREIGN KEY([input_step_id]) REFERENCES Step([id])
FOREIGN KEY([quantity_id]) REFERENCES Quantity([id]) ON DELETE CASCADE,
FOREIGN KEY([input_step_id]) REFERENCES Step([id]) ON DELETE CASCADE
);
CREATE TABLE [Group] (
@ -66,7 +68,7 @@ CREATE TABLE [Group] (
[recipe_id] INTEGER,
name TEXT,
FOREIGN KEY([recipe_id]) REFERENCES [Recipe]([id])
FOREIGN KEY([recipe_id]) REFERENCES [Recipe]([id]) ON DELETE CASCADE
);
CREATE INDEX [Group_order_index] ON [Group] ([order]);
@ -77,7 +79,7 @@ CREATE TABLE [Step] (
[action] TEXT NOT NULL,
[group_id] INTEGER NOT NULL,
FOREIGN KEY(group_id) REFERENCES [Group](id)
FOREIGN KEY(group_id) REFERENCES [Group](id) ON DELETE CASCADE
);
CREATE INDEX [Step_order_index] ON [Group] ([order]);
@ -89,7 +91,7 @@ CREATE TABLE [IntermediateSubstance] (
[output_step_id] INTEGER NOT NULL,
[input_step_id] INTEGER NOT NULL,
FOREIGN KEY([quantity_id]) REFERENCES [Quantity]([id]),
FOREIGN KEY([output_step_id]) REFERENCES [Step]([id]),
FOREIGN KEY([input_step_id]) REFERENCES [Step]([id])
FOREIGN KEY([quantity_id]) REFERENCES [Quantity]([id]) ON DELETE CASCADE,
FOREIGN KEY([output_step_id]) REFERENCES [Step]([id]) ON DELETE CASCADE,
FOREIGN KEY([input_step_id]) REFERENCES [Step]([id]) ON DELETE CASCADE
);

32
backend/src/config.rs Normal file
View file

@ -0,0 +1,32 @@
use std::{fmt, fs::File};
use ron::de::from_reader;
use serde::Deserialize;
use crate::consts;
#[derive(Deserialize, Clone)]
pub struct Config {
pub port: u16,
pub smtp_login: String,
pub smtp_password: String,
}
// Avoid to print passwords.
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()
}
}
pub fn load() -> Config {
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)
}
}

6
backend/src/consts.rs
View file

@ -1,4 +1,6 @@
pub const FILE_CONF: &str = "conf.ron";
pub const DB_DIRECTORY: &str = "data";
pub const DB_FILENAME: &str = "data/recipes.sqlite";
pub const SQL_FILENAME: &str = "sql/version_{VERSION}.sql";
pub const DB_FILENAME: &str = "recipes.sqlite";
pub const SQL_FILENAME: &str = "sql/version_{VERSION}.sql";
pub const VALIDATION_TOKEN_DURATION: i64 = 1 * 60 * 60; // 1 hour. [s].

46
backend/src/db.rs
View file

@ -1,4 +1,4 @@
use std::{fmt::Display, fs::{self, File}, path::Path, io::Read};
use std::{fmt, fs::{self, File}, path::Path, io::Read};
use itertools::Itertools;
use chrono::{prelude::*, Duration};
@ -22,6 +22,14 @@ pub enum DBError {
Other(String),
}
impl fmt::Display for DBError {
fn fmt(&self, f: &mut fmt::Formatter) -> std::result::Result<(), fmt::Error> {
write!(f, "{:?}", self)
}
}
impl std::error::Error for DBError { }
impl From<rusqlite::Error> for DBError {
fn from(error: rusqlite::Error) -> Self {
DBError::SqliteError(error)
@ -95,7 +103,7 @@ impl Connection {
Self::create_connection(SqliteConnectionManager::file(file))
}
fn create_connection(manager: SqliteConnectionManager) -> Result<Connection> {;
fn create_connection(manager: SqliteConnectionManager) -> Result<Connection> {
let pool = r2d2::Pool::new(manager).unwrap();
let connection = Connection { pool };
connection.create_or_update()?;
@ -206,11 +214,11 @@ impl Connection {
}
///
pub fn sign_up(&self, password: &str, email: &str) -> Result<SignUpResult> {
self.sign_up_with_given_time(password, email, Utc::now())
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, password: &str, email: &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.pool.get()?;
let tx = con.transaction()?;
let token =
@ -313,7 +321,7 @@ impl Connection {
}
/// Execute a given SQL file.
pub fn execute_file<P: AsRef<Path> + Display>(&self, file: P) -> Result<()> {
pub fn execute_file<P: AsRef<Path> + fmt::Display>(&self, file: P) -> Result<()> {
let con = self.pool.get()?;
let sql = load_sql_file(file)?;
con.execute_batch(&sql).map_err(DBError::from)
@ -334,7 +342,7 @@ impl Connection {
}
}
fn load_sql_file<P: AsRef<Path> + Display>(sql_file: P) -> Result<String> {
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 sql = String::new();
file.read_to_string(&mut sql).map_err(|err| DBError::Other(format!("Cannot read SQL file ({}) : {}", &sql_file, err.to_string())))?;
@ -352,7 +360,7 @@ mod tests {
#[test]
fn sign_up() -> Result<()> {
let connection = Connection::new_in_memory()?;
match connection.sign_up("12345", "paul@test.org")? {
match connection.sign_up("paul@test.org", "12345")? {
SignUpResult::UserCreatedWaitingForValidation(_) => (), // Nominal case.
other => panic!("{:?}", other),
}
@ -372,7 +380,7 @@ mod tests {
0,
NULL
);", [])?;
match connection.sign_up("12345", "paul@test.org")? {
match connection.sign_up("paul@test.org", "12345")? {
SignUpResult::UserAlreadyExists => (), // Nominal case.
other => panic!("{:?}", other),
}
@ -393,7 +401,7 @@ mod tests {
0,
:token
);", named_params! { ":token": token })?;
match connection.sign_up("12345", "paul@test.org")? {
match connection.sign_up("paul@test.org", "12345")? {
SignUpResult::UserCreatedWaitingForValidation(_) => (), // Nominal case.
other => panic!("{:?}", other),
}
@ -404,7 +412,7 @@ mod tests {
fn sign_up_then_send_validation_at_time() -> Result<()> {
let connection = Connection::new_in_memory()?;
let validation_token =
match connection.sign_up("12345", "paul@test.org")? {
match connection.sign_up("paul@test.org", "12345")? {
SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
other => panic!("{:?}", other),
};
@ -419,7 +427,7 @@ mod tests {
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("12345", "paul@test.org", Utc::now() - Duration::days(1))? {
match connection.sign_up_with_given_time("paul@test.org", "12345", Utc::now() - Duration::days(1))? {
SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
other => panic!("{:?}", other),
};
@ -434,7 +442,7 @@ mod tests {
fn sign_up_then_send_validation_with_bad_token() -> Result<()> {
let connection = Connection::new_in_memory()?;
let _validation_token =
match connection.sign_up("12345", "paul@test.org")? {
match connection.sign_up("paul@test.org", "12345")? {
SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
other => panic!("{:?}", other),
};
@ -450,12 +458,12 @@ mod tests {
fn sign_up_then_send_validation_then_sign_in() -> Result<()> {
let connection = Connection::new_in_memory()?;
let password = "12345";
let email = "paul@test.org";
let password = "12345";
// Sign up.
let validation_token =
match connection.sign_up(password, email)? {
match connection.sign_up(email, password)? {
SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
other => panic!("{:?}", other),
};
@ -479,12 +487,12 @@ mod tests {
fn sign_up_then_send_validation_then_authentication() -> Result<()> {
let connection = Connection::new_in_memory()?;
let password = "12345";
let email = "paul@test.org";
let password = "12345";
// Sign up.
let validation_token =
match connection.sign_up(password, email)? {
match connection.sign_up(email, password)? {
SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
other => panic!("{:?}", other),
};
@ -519,12 +527,12 @@ mod tests {
fn sign_up_then_send_validation_then_sign_out_then_sign_in() -> Result<()> {
let connection = Connection::new_in_memory()?;
let password = "12345";
let email = "paul@test.org";
let password = "12345";
// Sign up.
let validation_token =
match connection.sign_up(password, email)? {
match connection.sign_up(email, password)? {
SignUpResult::UserCreatedWaitingForValidation(token) => token, // Nominal case.
other => panic!("{:?}", other),
};

22
backend/src/email.rs Normal file
View file

@ -0,0 +1,22 @@
use lettre::{transport::smtp::{authentication::Credentials}, Message, SmtpTransport, Transport};
///
pub fn send_validation(site_url: &str, email: &str, token: &str, smtp_login: &str, smtp_password: &str) -> Result<(), Box<dyn std::error::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))?;
let credentials = Credentials::new(smtp_login.to_string(), smtp_password.to_string());
let mailer = SmtpTransport::relay("mail.gandi.net")?.credentials(credentials).build();
if let Err(error) = mailer.send(&email) {
println!("Error when sending E-mail:\n{:?}", &error);
}
Ok(())
}

277
backend/src/main.rs
View file

@ -1,19 +1,21 @@
use std::fs::File;
use std::sync::Mutex;
use std::{collections::HashMap, net::ToSocketAddrs};
use actix_files as fs;
use actix_web::{get, web, Responder, middleware, App, HttpServer, HttpRequest};
use askama_actix::Template;
use chrono::prelude::*;
use actix_web::{http::header, get, post, web, Responder, middleware, App, HttpServer, HttpRequest, HttpResponse};
use askama_actix::{Template, TemplateToResponse};
use chrono::{prelude::*, Duration};
use clap::Parser;
use ron::de::from_reader;
use serde::Deserialize;
use config::Config;
mod consts;
mod db;
mod hash;
mod model;
mod user;
mod email;
mod config;
#[derive(Template)]
#[template(path = "home.html")]
@ -21,6 +23,11 @@ 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 {
@ -28,27 +35,219 @@ struct ViewRecipeTemplate {
current_recipe: model::Recipe,
}
#[derive(Deserialize)]
pub struct Request {
m: Option<String>
#[derive(Template)]
#[template(path = "message.html")]
struct MessageTemplate {
recipes: Vec<(i32, String)>,
message: String,
}
#[get("/")]
async fn home_page(req: HttpRequest, connection: web::Data<db::Connection>) -> impl Responder {
HomeTemplate { recipes: connection.get_all_recipe_titles().unwrap() } // TODO: unwrap.
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<HashMap<String, String>>, connection: web::Data<db::Connection>) -> 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<SignUpFormData>, connection: web::Data<db::Connection>, config: web::Data<Config>) -> impl Responder {
println!("Sign Up, email: {}, passwords: {}/{}", form.email, form.password_1, form.password_2);
fn error_response(error: SignUpError, form: &web::Form<SignUpFormData>) -> 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<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)
};
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<db::Connection>) -> 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<HashMap<String, String>>, connection: web::Data<db::Connection>) -> 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<db::Connection>) -> 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<db::Connection>) -> impl Responder {
ViewRecipeTemplate {
recipes: connection.get_all_recipe_titles().unwrap(),
current_recipe: connection.get_recipe(path.0).unwrap(),
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(),
}
}
#[derive(Debug, Deserialize)]
struct Config {
port: u16
async fn not_found(req: HttpRequest, connection: web::Data<db::Connection>) -> 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 {
@ -66,36 +265,36 @@ async fn main() -> std::io::Result<()> {
println!("Starting Recipes as web server...");
let config: Config = {
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)
}
};
let config = web::Data::new(config::load());
let port = config.as_ref().port;
println!("Configuration: {:?}", config);
let db_connection = web::Data::new(db::Connection::new().unwrap()); // TODO: remove unwrap.
let db_connection = web::Data::new(db::Connection::new().unwrap());
std::env::set_var("RUST_LOG", "actix_web=info");
let mut server =
HttpServer::new(
move || {
App::new()
.wrap(middleware::Logger::default())
.wrap(middleware::Compress::default())
.app_data(db_connection.clone())
.service(home_page)
.service(view_recipe)
.service(fs::Files::new("/static", "static").show_files_listing())
}
);
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(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(fs::Files::new("/static", "static"))
.default_service(web::to(not_found))
//.default_service(not_found)
});
server = server.bind(&format!("0.0.0.0:{}", config.port)).unwrap();
server.run().await
server.bind(&format!("0.0.0.0:{}", port))?.run().await
}
#[derive(Parser, Debug)]

2
backend/templates/base.html
View file

@ -8,7 +8,7 @@
</head>
<body>
<div class="header-container"><h1><a href="/">~ RECIPES ~</a></h1></div>
<div class="header-container"><h1><a href="/">~~ Recettes de cuisine ~~</a></h1><div><a href="/signinform" >Sign in</a> / <a href="/signup">Sign Up</a></div></div>
<div class="main-container">
{% block main_container %}{% endblock %}
</div>

7
backend/templates/message.html Normal file
View file

@ -0,0 +1,7 @@
{% extends "base_with_list.html" %}
{% block content %}
{{ message }}
{% endblock %}

15
backend/templates/sign_in_form.html Normal file
View file

@ -0,0 +1,15 @@
{% extends "base.html" %}
{% block main_container %}
<div class="content">
<form action="/signin" method="post">
<label for="email_field">Email address</label>
<input id="email_field" type="text" name="email" autocapitalize="none" autocomplete="email" autofocus="autofocus" />
<label for="password_field">Password</label>
<input id="password_field" type="password" name="password" autocomplete="current-password" />
<input type="submit" name="commit" value="Sign in" />
</form>
</div>
{% endblock %}

22
backend/templates/sign_up_form.html Normal file
View file

@ -0,0 +1,22 @@
{% extends "base.html" %}
{% block main_container %}
<div class="content">
<form action="/signup" method="post">
<label for="email_field">Your email address</label>
<input id="email_field" type="text" name="email" value="{{ email }}" autocapitalize="none" autocomplete="email" autofocus="autofocus" />
{{ message_email }}
<label for="password_field_1">Choose a password (minimum 8 characters)</label>
<input id="password_field_1" type="password" name="password_1" />
<label for="password_field_1">Re-enter password</label>
<input id="password_field_2" type="password" name="password_2" />
{{ message_password }}
<input type="submit" name="commit" value="Sign up" />
</form>
{{ message }}
</div>
{% endblock %}