Cargo.lock

@@ -578,7 +578,7 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
 
 [[package]]
 name = "fabula_votes_server"
-version = "1.4.1"
+version = "1.1.0"
 dependencies = [
  "argon2",
  "blake2",

Cargo.toml

@@ -3,7 +3,7 @@ name = "fabula_votes_server"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["trotFunky"]
-version = "1.4.1"
+version = "1.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

README.md

@@ -7,32 +7,25 @@ vote and who we think wrote them and see some stats !
 
 A list of things that could be implemented/added to the application, some of them are needed for "feature completeness" !
 
- - [x] Being able to change from one week to the next
-   - [x] Create new weeks for the admin
-   - [x] Proper week redirection
-     - [ ] Correctly handle non-existing week number
- - [x] Add introduction to the weekly truths
+ - [ ] Being able to change from one week to the next
+   - [ ] Create new weeks for the admin
+   - [ ] Proper week redirection
+ - [ ] Add introduction to the weekly truths
  - [ ] Bundle static assets in the binary
- - [ ] Move the database queries to their own functions
+ - [ ] Move the databse queries to their own functions
    - [ ] Cache those results
  - [ ] Centralize Markdown parsing ?
- - [x] Use fairings for the different elements
- - [ ] Use guards for User calls ?
- - [ ] Use SQLite Row ID for User IDs rather than regular IDs, for randomness ?
- - [x] Split user from vote data
+ - [ ] Use fairings for the different elements ?
 
 # Dependencies
 
-This project currently uses, for the backend :
+This project currently uses :
  - [Rocket](https://docs.rs/rocket/0.5.1/rocket/), for the web application backend
  - [SQLX](https://docs.rs/sqlx/0.7.4/sqlx/), for database access (this is only expeceted to be used with SQLite)
  - [Tera](https://docs.rs/tera/latest/tera/), for templating
  - [Argon2](https://docs.rs/argon2/latest/argon2/), for password hashing
  - [Pull_down CMark](https://docs.rs/pulldown-cmark/0.11.0/pulldown_cmark/), for markdown rendering
 
-For the frontend :
- - [Chart.js](https://www.chartjs.org/), for rendering the vote graph.
-
 # License
 
 The code present in this repository is licensed under the Mozilla Public License 2.0.

db/04_create-tags-tables.sql

@@ -1,13 +0,0 @@
-CREATE TABLE IF NOT EXISTS Tags (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    name VARCHAR NOT NULL UNIQUE,
-    color VARCHAR NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS TaggedTruths (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    truth_id INTEGER NOT NULL,
-    tag_id INTEGER NOT NULL,
-    FOREIGN KEY (truth_id) REFERENCES Truths(id) ON DELETE CASCADE,
-    FOREIGN KEY (tag_id) REFERENCES Tags(id) ON DELETE CASCADE
- );

src/auth.rs

@@ -8,9 +8,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use argon2::{Argon2, PasswordHash, PasswordVerifier};
 use blake2::{Blake2b512, Digest};
 use blake2::digest::FixedOutput;
-use rocket::fairing::AdHoc;
-use crate::database_records::{AuthTokens, PlayerLoginInfo};
-use crate::{database, week};
+use crate::database_records::{AuthTokens, PlayerLoginInfo, Vote};
+use crate::database;
 use database::Db;
 
 // TODO: Make FromRequest guard https://api.rocket.rs/v0.5/rocket/request/trait.FromRequest and split admin
@@ -21,9 +20,11 @@ pub struct User {
     pub is_admin: bool,
     pub id: u16,
     pub name: String,
+    pub has_week_vote: bool,
+    pub votes: Vec<Vote>
 }
 
-pub async fn get_user(db: &mut Connection<Db>, cookies: &CookieJar<'_>) -> User {
+pub async fn get_user(week: u8, db: &mut Connection<Db>, cookies: &CookieJar<'_>) -> User {
     let auth_token: Option<String> = match cookies.get_private("auth_token") {
         Some(cookie) => Some(cookie.value().to_string()),
         None => None
@@ -55,7 +56,7 @@ pub async fn get_user(db: &mut Connection<Db>, cookies: &CookieJar<'_>) -> User
                     Vec::<AuthTokens>::new()
                 }
             };
-        tokens.iter().find(|auth_token| {auth_token.token.eq(&token_str)}).is_some()
+        tokens.iter().find(|auth_token| {println!("Token : {:?}\nCookie : {:?}", auth_token.token, token_str); auth_token.token.eq(&token_str)}).is_some()
     } else {
         id_str = String::new();
         false
@@ -85,12 +86,26 @@ pub async fn get_user(db: &mut Connection<Db>, cookies: &CookieJar<'_>) -> User
         (String::new(), false)
     };
 
+    let votes: Vec<Vote> = if logged_in {
+        sqlx::query_as("SELECT Votes.* FROM Votes JOIN Truths ON Votes.truth_id == Truths.id AND Truths.week == $1 WHERE voter_id == $2 ORDER BY Truths.number;")
+            .bind(week)
+            .bind(&id_str)
+            .fetch_all(&mut ***db).await.unwrap_or_else(|error| {
+            error!("Error while getting votes : {error}");
+            Vec::<Vote>::new()
+        })
+    } else {
+        Vec::<Vote>::new()
+    };
+
     if logged_in {
         User {
             logged_in,
             is_admin,
             id: id_str.parse::<u16>().unwrap(),
             name,
+            has_week_vote: if votes.is_empty() { false } else { true },
+            votes
         }
     } else {
         User {
@@ -98,6 +113,8 @@ pub async fn get_user(db: &mut Connection<Db>, cookies: &CookieJar<'_>) -> User
             is_admin: false,
             id: 0,
             name,
+            has_week_vote: false,
+            votes
         }
     }
 }
@@ -108,8 +125,8 @@ pub struct AuthForm {
     password: String
 }
 
-#[post("/<week>/login", data="<form>")]
-pub async fn login(week: u8, form: Form<AuthForm>, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
+#[post("/login", data="<form>")]
+pub async fn login(form: Form<AuthForm>, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
     let user_search: Result<PlayerLoginInfo, _> = sqlx::query_as("SELECT id, is_admin, name, pwd_hash FROM Players WHERE name == $1")
         .bind(&form.name)
         .fetch_one(&mut **db)
@@ -118,7 +135,7 @@ pub async fn login(week: u8, form: Form<AuthForm>, mut db: Connection<Db>, cooki
     if user_search.is_err() {
         error!("Login failed : invalid user {:?}, err: {:?}", form.name, user_search.err());
         cookies.add(("toast_error", "Impossible de se connecter !"));
-        return Redirect::to(uri!(week::week(week)));
+        return Redirect::to(uri!("/"));
     }
     let new_user = user_search.unwrap();
 
@@ -126,7 +143,7 @@ pub async fn login(week: u8, form: Form<AuthForm>, mut db: Connection<Db>, cooki
     if password_hash_parse.is_err() {
         error!("Login failed : could not parse password hash {:?}", password_hash_parse.err());
         cookies.add(("toast_error", "Impossible de se connecter !"));
-        return Redirect::to(uri!(week::week(week)));
+        return Redirect::to(uri!("/"));
     }
     let password_hash = password_hash_parse.unwrap();
 
@@ -150,7 +167,7 @@ pub async fn login(week: u8, form: Form<AuthForm>, mut db: Connection<Db>, cooki
                 Err(error) => {
                     error!("Login failed : coult not store auth token in database : {error}");
                     cookies.add(("toast_error", "Impossible de se connecter !"));
-                    return Redirect::to(uri!(week::week(week)));
+                    return Redirect::to(uri!("/"));
                 }
             }
 
@@ -160,41 +177,24 @@ pub async fn login(week: u8, form: Form<AuthForm>, mut db: Connection<Db>, cooki
         Err(err) => {
             error!("Login failed : invalid password for {:?}\nError : {err}", new_user.name);
             cookies.add(("toast_error", "Impossible de se connecter !"));
-            return Redirect::to(uri!(week::week(week)));
+            return Redirect::to(uri!("/"));
         }
     }
 
-    Redirect::to(uri!(week::week(week)))
+    Redirect::to(uri!("/"))
 }
 
-#[post("/<week>/logout")]
-pub async fn logout(week: u8, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let auth_token: Option<String> = match cookies.get_private("auth_token") {
-        Some(cookie) => Some(cookie.value().to_string()),
-        None => None
-    };
-
-    // Should not be able to log out ?
-    if auth_token.is_none() {
-        return Redirect::to(uri!(week::week(week)))
+pub fn bypass_auth_debug(cookies: &CookieJar<'_>) {
+    if cookies.get_private("auth_token").is_some() {
+        return
     }
+    let mut hasher = Blake2b512::new();
+    hasher.update(b"8");
+    hasher.update(SystemTime::now().duration_since(UNIX_EPOCH).expect("Non monotonous time event").as_secs().to_le_bytes());
+    let hash = hasher.finalize_fixed().to_ascii_lowercase();
+    let hash_str = String::from_utf8_lossy(hash.as_slice()).to_ascii_lowercase();
+    cookies.add_private(("auth_token", hash_str.clone()));
+    cookies.add_private(("auth_id", 8.to_string()));
 
-    match sqlx::query("DELETE FROM AuthTokens WHERE token == $1;")
-        .bind(auth_token)
-        .execute(&mut **db)
-        .await {
-        Ok(_) => debug!("Auth token deletion successful"),
-        Err(error) => debug!("Auth token could not be removed ({error}), proceeding anyway.")
-    }
-
-    cookies.remove_private("auth_token");
-    cookies.remove_private("auth_id");
-
-    Redirect::to(uri!(week::week(week)))
-}
-
-pub fn stage() -> AdHoc {
-    AdHoc::on_ignite("Auth stage", |rocket| async {
-        rocket.mount("/", routes![login, logout])
-    })
+    println!("Generated hash string : {hash_str}");
 }

src/database_records.rs

@@ -19,26 +19,21 @@ pub struct PlayerLoginInfo {
 #[derive(sqlx::FromRow, Deserialize, Serialize)]
 #[serde(crate = "rocket::serde")]
 pub struct Truth {
-    pub id: u32,
+    id: u32,
     week: u8,
     number: u8,
     author_id: u16,
     rendered_text: String,
     raw_text: String,
-    #[sqlx(skip)]
-    pub tags: Vec<Tag>,
 }
 
 #[derive(sqlx::FromRow, Deserialize, Serialize)]
 #[serde(crate = "rocket::serde")]
 pub struct DisplayTruth {
-    pub id: u32,
-    week: u8,
+    id: u32,
     number: u8,
     author_id: u16,
     rendered_text: String,
-    #[sqlx(skip)]
-    pub tags: Vec<Tag>,
 }
 
 #[derive(sqlx::FromRow, Deserialize, Serialize)]
@@ -72,11 +67,3 @@ pub struct Week {
     pub rendered_text: String,
     pub raw_text: String,
 }
-
-#[derive(FromForm)]
-#[derive(sqlx::FromRow, Deserialize, Serialize)]
-#[serde(crate = "rocket::serde")]
-pub struct Tag {
-    pub name: String,
-    pub color: String
-}

src/main.rs

@@ -1,14 +1,17 @@
 #[macro_use] extern crate rocket;
 
+use rocket::{Rocket, Build, futures};
 use rocket::fs::{FileServer, relative};
+use rocket::http::CookieJar;
 use rocket::response::Redirect;
+use rocket::serde::{Serialize, Deserialize, json::Json};
 
-use rocket_dyn_templates::Template;
+use rocket_dyn_templates::{Template, context};
 
-use rocket_db_pools::Connection;
+use rocket_db_pools::{sqlx, sqlx::Row, Database, Connection};
+use sqlx::Error;
 
 mod auth;
-mod tag;
 mod truth;
 mod vote;
 mod week;
@@ -17,10 +20,19 @@ mod week;
 mod database;
 mod database_records;
 use database::Db;
+use database_records::*;
+use auth::User;
 
 #[get("/")]
 async fn index(mut db: Connection<Db>) -> Redirect {
-    let current_week: u8 = week::get_last_week(&mut db).await;
+    let current_week: u8 = match sqlx::query("SELECT number FROM Weeks WHERE is_last_week == 1;")
+        .fetch_one(&mut **db).await {
+        Ok(v) => v.try_get(0).ok().unwrap_or_else(|| 1), // If error, go back to 1
+        Err(error) => {
+            error!("Error while getting current week : {error:?}");
+            1
+        }
+    };
 
     Redirect::to(uri!(week::week(week_number = if current_week == 0 {1} else {current_week})))
 }
@@ -28,13 +40,10 @@ async fn index(mut db: Connection<Db>) -> Redirect {
 #[launch]
 fn rocket() -> _ {
     rocket::build()
-        .mount("/static/", FileServer::from(relative!("static_files")))
-        .attach(auth::stage())
-        .attach(week::stage())
-        .attach(truth::stage())
-        .attach(vote::stage())
-        .attach(tag::stage())
-        .mount("/", routes![index])
+        .mount("/", FileServer::from(relative!("static_files")))
+        .mount("/", routes![index, vote::fetch_vote_data, vote::vote, truth::create_truth, truth::edit_truth, week::week, week::update_week, auth::login])
         .attach(database::stage())
         .attach(Template::fairing())
 }
+
+// TODO: Random Row ID

src/tag.rs

@@ -1,295 +0,0 @@
-use rocket::fairing::AdHoc;
-use rocket::form::Form;
-use rocket::http::CookieJar;
-use rocket::response::Redirect;
-use rocket_db_pools::Connection;
-use rocket_dyn_templates::{context, Template};
-use sqlx::{Sqlite, QueryBuilder};
-use crate::database::Db;
-use crate::database_records::{DisplayTruth, Tag};
-
-use crate::auth;
-use crate::week;
-
-pub async fn get_all_tags(db: &mut Connection<Db>, cookies: &CookieJar<'_>) -> Vec<Tag> {
-    match sqlx::query_as("SELECT name, color FROM Tags")
-        .fetch_all(&mut ***db)
-        .await {
-        Ok(tags) => tags,
-        Err(error) => {
-            error!("Database error while fetching tags : {error}");
-            cookies.add(("toast_error", "Erreur lors du chargement des tags."));
-            Vec::<Tag>::new()
-        }
-    }
-}
-
-pub async fn get_truth_tags(truth_id: u32, db: &mut Connection<Db>) -> Vec<Tag> {
-    match sqlx::query_as("
-                SELECT Tags.name, Tags.color FROM Tags
-                JOIN TaggedTruths ON TaggedTruths.tag_id == Tags.id AND TaggedTruths.truth_id == $1
-                ORDER BY Tags.id;")
-        .bind(truth_id)
-        .fetch_all(&mut ***db)
-        .await {
-        Ok(tags) => tags,
-        Err(error) => {
-            error!("Could not fetch tags for truth {:?} : {error}", truth_id);
-            Vec::<Tag>::new()
-        }
-    }
-}
-
-#[get("/")]
-pub async fn tag_index(mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Template {
-    let user = auth::get_user(&mut db, cookies).await;
-
-    let tags: Vec<Tag> = get_all_tags(&mut db, cookies).await;
-
-    Template::render("tags/index", context!{
-        user: user,
-        tags: tags
-    })
-}
-
-#[get("/filter?<tags>")]
-pub async fn filtered_by_tags(tags: Vec<String>, mut db: Connection<Db>) -> Template {
-    let last_week = week::get_last_week(&mut db).await;
-    let filtered_truths: Vec<DisplayTruth> = if tags.len() == 0 {
-        match sqlx::query_as("SELECT id, week, number, author_id, rendered_text FROM Truths WHERE week <= $1 ORDER BY week, number;")
-            .bind(last_week)
-            .fetch_all(&mut **db)
-            .await {
-                Ok(all_truths) => all_truths,
-                Err(error) => {
-                    error!("Error while fetching all truths for the filter : {error}");
-                    Vec::<DisplayTruth>::new()
-                }
-        }
-    } else {
-        let mut query_builder: QueryBuilder<Sqlite> = QueryBuilder::new("
-            SELECT Truths.id, Truths.week, Truths.number, Truths.author_id, Truths.rendered_text FROM Truths
-            JOIN TaggedTruths ON Truths.id == TaggedTruths.truth_id
-            JOIN Tags ON Tags.id == TaggedTruths.tag_id AND Tags.name IN (
-        ");
-        let mut separated_args = query_builder.separated(", ");
-        for tag in &tags {
-            separated_args.push_bind(tag);
-        }
-
-        // Now that the comma separated list of strings is built, finish the query normally.
-        query_builder.push(") WHERE Truths.week <= ");
-        query_builder.push_bind(last_week);
-        query_builder.push("GROUP BY Truths.id ORDER BY Truths.week, Truths.number;");
-        match query_builder.build_query_as::<DisplayTruth>().fetch_all(&mut **db).await {
-            Ok(truths) => {
-                debug!("Got filtered truths by tags");
-                truths
-            },
-            Err(error) => {
-                error!("Error while fetching filtered truths : {error}");
-                Vec::<DisplayTruth>::new()
-            }
-        }
-    };
-
-    let filter_tags: Vec::<Tag> = match sqlx::query_as("SELECT name, color FROM Tags;")
-        .fetch_all(&mut **db)
-        .await {
-            Ok(all_tags) => {
-                all_tags.into_iter().filter(|tag: &Tag| tags.contains(&tag.name)).collect()
-            },
-            Err(error) => {
-                error!("Error getting tags to show on filter list : {error}");
-                Vec::<Tag>::new()
-            }
-    };
-
-    Template::render("tags/filtered_truths", context!{
-        tags: filter_tags,
-        truths: filtered_truths
-    })
-}
-
-
-#[post("/create", data="<new_tag>")]
-pub async fn create_tag(new_tag: Form<Tag>, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
-    if !user.is_admin {
-        cookies.add(("toast_error", "Vous n'avez pas la permission de créer une étiquette"));
-        return Redirect::to(uri!("/tags", tag_index));
-    }
-
-    match sqlx::query("INSERT INTO Tags (name, color) VALUES ($1, $2);")
-        .bind(&new_tag.name)
-        .bind(&new_tag.color)
-        .execute(&mut **db)
-        .await {
-            Ok(affected_lines) => if affected_lines.rows_affected() != 1 {
-                error!("Did not create tag : {:?}", &new_tag.name);
-                cookies.add(("toast_error", "L'étiquette n'a pas pû être créer"));
-            } else {
-                debug!("Successfully created new tag {:?}", &new_tag.name);
-            },
-            Err(error) => {
-                error!("Error whilea adding tag {:?} : {error}", &new_tag.name);
-                cookies.add(("toast_error", "Erreur à la création de l'étiquette"));
-        }
-    };
-
-    Redirect::to(uri!("/tags", tag_index))
-}
-
-#[post("/delete/<tag_name>")]
-pub async fn delete_tag(tag_name: &str, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
-    if !user.is_admin {
-        cookies.add(("toast_error", "Vous n'avez pas la permission de supprimer une étiquette"));
-        return Redirect::to(uri!("/tags", tag_index));
-    }
-
-    match sqlx::query("DELETE FROM Tags WHERE name == $1;")
-        .bind(&tag_name)
-        .execute(&mut **db)
-        .await {
-            Ok(affected_lines) => if affected_lines.rows_affected() != 1 {
-                error!("Did not remove {tag_name}");
-                cookies.add(("toast_error", "L'étiquette n'a pas pû être supprimée."));
-            }
-            else {
-                debug!("Tag {tag_name} successfully removed.")
-            },
-            Err(error) => {
-                error!("Error trying to remove {tag_name} : {error}");
-                cookies.add(("toast_error", "Erreur lors de la suppression de l'étiquette"));
-            }
-    };
-
-    Redirect::to(uri!("/tags", tag_index))
-}
-
-#[post("/update/<tag_name>", data="<updated_tag>")]
-pub async fn update_tag(tag_name: &str, updated_tag: Form<Tag>, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
-    if !user.is_admin {
-        cookies.add(("toast_error", "Vous n'avez pas la permission de modifier une étiquette"));
-        return Redirect::to(uri!("/tags", tag_index));
-    }
-
-    match sqlx::query("UPDATE Tags SET name = $1, color = $2 WHERE name == $3;")
-        .bind(&updated_tag.name)
-        .bind(&updated_tag.color)
-        .bind(&tag_name)
-        .execute(&mut **db)
-        .await {
-            Ok(affected_lines) => if affected_lines.rows_affected() != 1 {
-                error!("Did not update tag {tag_name}");
-                cookies.add(("toast_error", "L'étiquette n'a pas pû être modifiée."));
-            } else {
-                debug!("Updated {tag_name} successfully.");
-            }
-            Err(error) => {
-                error!("Error while updating {tag_name} : {error}");
-                cookies.add(("toast_error", "Erreur lors de la modification de l'étiquette."));
-            }
-    };
-
-    Redirect::to(uri!("/tags", tag_index))
-}
-
-#[derive(FromForm)]
-pub struct TagForm {
-    name: String,
-}
-
-#[post("/<week>/tag/<truth_id>", data="<tag_form>")]
-pub async fn tag_truth(week: u8, truth_id: u32, tag_form: Form<TagForm>, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
-    if !user.is_admin {
-        cookies.add(("toast_error", "Vous n'avez pas la permission d'ajouter une étiquette"));
-        return Redirect::to(uri!("/tags", tag_index));
-    }
-
-    let error_cookie = ||
-        cookies.add(("toast_error", "Erreur lors de l'ajout de l'étiquette."));
-
-    let tag_id: u32 = sqlx::query_scalar("SELECT id FROM Tags WHERE name == $1;")
-        .bind(&tag_form.name)
-        .fetch_one(&mut **db)
-        .await.unwrap_or(0);
-
-    if tag_id == 0 {
-        error_cookie();
-        error!("Error while trying to figure tag ID of {:?} to create the relation with {:?}.", &tag_form.name, &truth_id);
-        return Redirect::to(uri!(week::week(week)));
-    }
-
-    match sqlx::query("INSERT INTO TaggedTruths (truth_id, tag_id) VALUES ($1, $2);")
-        .bind(&truth_id)
-        .bind(&tag_id)
-        .execute(&mut **db)
-        .await {
-            Ok(affected_lines) => if affected_lines.rows_affected() != 1 {
-                error_cookie();
-                error!("Tag relation not added.");
-            } else {
-                debug!("Created tag relation with truth {truth_id} and tag {tag_id}");
-            }
-            Err(error) => {
-                error_cookie();
-                error!("Error while trying to add tag relation : {error}");
-            }
-    }
-
-    Redirect::to(uri!(week::week(week)))
-}
-
-#[post("/<week>/untag/<truth_id>", data="<tag_form>")]
-pub async fn untag_truth(week: u8, truth_id: u32, tag_form: Form<TagForm>, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
-    if !user.is_admin {
-        cookies.add(("toast_error", "Vous n'avez pas la permission de retirer une étiquette"));
-        return Redirect::to(uri!("/tags", tag_index));
-    }
-
-    let error_cookie = ||
-        cookies.add(("toast_error", "Erreur lors de la suppression de l'étiquette."));
-
-    let tag_id: u32 = sqlx::query_scalar("SELECT id FROM Tags WHERE name == $1;")
-        .bind(&tag_form.name)
-        .fetch_one(&mut **db)
-        .await.unwrap_or(0);
-
-    if tag_id == 0 {
-        error_cookie();
-        error!("Error while trying to figure tag ({:?}) ID to remove the relation with {:?}.", &tag_id, &truth_id);
-        return Redirect::to(uri!(week::week(week)));
-    }
-
-    match sqlx::query("DELETE FROM TaggedTruths WHERE truth_id == $1 AND tag_id == $2;")
-        .bind(&truth_id)
-        .bind(&tag_id)
-        .execute(&mut **db)
-        .await {
-            Ok(affected_lines) => if affected_lines.rows_affected() != 1 {
-                error_cookie();
-                error!("Tag relation not deleted.");
-            } else {
-                debug!("Removed tag relation with truth {truth_id} and tag {tag_id}");
-            }
-            Err(error) => {
-                error_cookie();
-                error!("Error while trying to remove tag relation : {error}");
-            }
-    }
-
-    Redirect::to(uri!(week::week(week)))
-}
-
-pub fn stage() -> AdHoc {
-    AdHoc::on_ignite("Tag stage", |rocket| async {
-        rocket
-            .mount("/tags", routes![tag_index, filtered_by_tags, create_tag, update_tag, delete_tag])
-            .mount("/", routes![tag_truth, untag_truth])
-    })
-}

src/truth.rs

@@ -5,9 +5,8 @@ use rocket::response::Redirect;
 use rocket_db_pools::{sqlx, Connection};
 
 use pulldown_cmark::{Parser, Options};
-use rocket::fairing::AdHoc;
 use sqlx::Row;
-use crate::{auth, database, week};
+use crate::{auth, database};
 
 #[derive(FromForm)]
 pub struct TruthUpdateForm {
@@ -18,10 +17,10 @@ pub struct TruthUpdateForm {
 #[post("/<week>/edit/<truth_number>", data="<form>")]
 pub async fn edit_truth(week: u8, truth_number: u8, form: Form<TruthUpdateForm>,
                         mut db: Connection<database::Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
+    let user = auth::get_user(week, &mut db, cookies).await;
     if !user.is_admin {
         cookies.add(("toast_error", "Vous n'avez pas la permission de changer la vérité."));
-        return Redirect::to(uri!(week::week(week)));
+        return Redirect::to(uri!("/"));
     }
 
     let mut options = Options::empty();
@@ -51,16 +50,16 @@ pub async fn edit_truth(week: u8, truth_number: u8, form: Form<TruthUpdateForm>,
         }
     };
 
-    Redirect::to(uri!(week::week(week)))
+    Redirect::to(uri!("/"))
 }
 
-#[post("/<week>/new_truth", data="<form>")]
+#[post("/<week>/new", data="<form>")]
 pub async fn create_truth(week: u8, form: Form<TruthUpdateForm>,
                           mut db: Connection<database::Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
+    let user = auth::get_user(week, &mut db, cookies).await;
     if !user.is_admin {
         cookies.add(("toast_error", "Vous n'avez pas la permission d'ajouter de vérité."));
-        return Redirect::to(uri!(week::week(week)));
+        return Redirect::to(uri!("/"));
     }
 
     let truth_number: u8 = match sqlx::query("SELECT max(number) from Truths WHERE week == $1;")
@@ -77,7 +76,7 @@ pub async fn create_truth(week: u8, form: Form<TruthUpdateForm>,
     if truth_number == 0 {
         error!("Error while getting max truth number.");
         cookies.add(("toast_error", "Erreur lors de l'ajout de la vérité..."));
-        return Redirect::to(uri!(week::week(week)));
+        return Redirect::to(uri!("/"));
     }
 
     let mut options = Options::empty();
@@ -109,11 +108,5 @@ pub async fn create_truth(week: u8, form: Form<TruthUpdateForm>,
 
     debug!("Truth was successfully added");
 
-    Redirect::to(uri!(week::week(week)))
-}
-
-pub fn stage() -> AdHoc {
-    AdHoc::on_ignite("Truth stage", |rocket| async {
-        rocket.mount("/", routes![create_truth, edit_truth])
-    })
+    Redirect::to(uri!("/"))
 }

src/vote.rs

@@ -9,32 +9,9 @@ use rocket::serde::json::Json;
 
 use rocket_db_pools::{sqlx, Connection};
 
-use crate::{auth, database, week};
+use crate::{auth, database};
 use crate::database_records::{Vote, VotingData};
 
-#[derive(Serialize, Deserialize)]
-#[serde(crate = "rocket::serde")]
-pub struct WeeklyUserVotes {
-    pub has_week_vote: bool,
-    pub votes: Vec<Vote>
-}
-
-pub async fn get_weekly_user_votes(week: u8, user: &auth::User, db: &mut Connection<database::Db>) -> WeeklyUserVotes {
-    let votes: Vec<Vote> = if user.logged_in && !user.is_admin {
-        sqlx::query_as("SELECT Votes.* FROM Votes JOIN Truths ON Votes.truth_id == Truths.id AND Truths.week == $1 WHERE voter_id == $2 ORDER BY Truths.number;")
-            .bind(week)
-            .bind(user.id)
-            .fetch_all(&mut ***db).await.unwrap_or_else(|error| {
-            error!("Error while getting votes : {error}");
-            Vec::<Vote>::new()
-        })
-    } else {
-        Vec::<Vote>::new()
-    };
-
-    WeeklyUserVotes {has_week_vote: if votes.is_empty() { false } else { true }, votes}
-}
-
 #[derive(FromForm)]
 pub struct VoteForm {
     truth_votes: HashMap<u32, u16>
@@ -43,11 +20,11 @@ pub struct VoteForm {
 #[post("/<week>/vote", data="<form>")]
 pub async fn vote(week: u8, form: Form<VoteForm>,
                   mut db: Connection<database::Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
+    let user = auth::get_user(week, &mut db, cookies).await;
 
     if !user.logged_in {
         cookies.add(("toast_error", "Vous n'avez pas la permission de changer de vote."));
-        return Redirect::to(uri!(week::week(week)));
+        return Redirect::to(uri!("/"));
     }
 
     let filtered_votes = form.truth_votes.iter().filter_map(
@@ -60,11 +37,9 @@ pub async fn vote(week: u8, form: Form<VoteForm>,
         }
     );
 
-    let existing_votes = get_weekly_user_votes(week, &user, &mut db).await;
-
     let mut had_error = false;
     for (truth_id, voted_id) in filtered_votes {
-        match existing_votes.votes.iter().find(|vote: &&Vote| {vote.truth_id == *truth_id}) {
+        match user.votes.iter().find(|vote: &&Vote| {vote.truth_id == *truth_id}) {
             Some(vote) => {
                 if *voted_id == vote.voted_id {
                     continue;
@@ -86,7 +61,7 @@ pub async fn vote(week: u8, form: Form<VoteForm>,
             }
             None => {
                 debug!("Player {:?} voting {voted_id} for truth {truth_id}", user.id);
-                // TODO: Find a way to use only one statement ? --> query_many
+                // TODO: Find a way to use only one statement ?
                 // Cannot all launch and await because all connect to DB
                 match sqlx::query("INSERT INTO Votes (truth_id, voter_id, voted_id) VALUES ($1, $2, $3);")
                     .bind(truth_id)
@@ -109,20 +84,18 @@ pub async fn vote(week: u8, form: Form<VoteForm>,
         debug!("Vote successful")
     }
 
-    Redirect::to(uri!(week::week(week)))
+    Redirect::to(uri!("/"))
 }
 
 #[derive(Serialize, Deserialize)]
 #[serde(crate = "rocket::serde")]
 pub struct VoteData {
-    truth_count: u8,
     votes: HashMap<String, Vec<u8>>,
 }
 
 // TODO: Cache vote count ? Maintain in state ?
 #[get("/<week>/votes", format = "application/json")]
-pub async fn fetch_vote_data(week: u8, mut db: Connection<database::Db>, cookies: &CookieJar<'_>) -> Option<Json<VoteData>> {
-    let user = auth::get_user(&mut db, cookies).await;
+pub async fn fetch_vote_data(week: u8, mut db: Connection<database::Db>) -> Option<Json<VoteData>> {
     let raw_votes: Vec<VotingData> = sqlx::query_as("
         SELECT Players.name as votes_for, Truths.number as truth_number, count(*) as votes FROM Votes
             JOIN Players ON Votes.voted_id == Players.id
@@ -136,31 +109,12 @@ pub async fn fetch_vote_data(week: u8, mut db: Connection<database::Db>, cookies
             Vec::<VotingData>::new()
     });
 
-    let truth_count: u8 = sqlx::query_scalar("SELECT count(id) from Truths WHERE week == $1;")
-        .bind(week)
-        .fetch_one(&mut **db)
-        .await.unwrap_or(0);
-
-    let player_count: u8 = sqlx::query_scalar("SELECT count(id) from Players WHERE is_admin == 0;")
-        .fetch_one(&mut **db)
-        .await.unwrap_or(0);
-
-    // Each player should have a truth assigned to them which they cannot vote on.
-    let max_vote_count = truth_count * (player_count - 1);
-
     let vote_count = raw_votes.iter().fold(0, |count, votes| {count + votes.votes});
-    // Only show the graph if we have all the votes and this is not the last week.
-    if !user.is_admin && (max_vote_count == 0
-        || vote_count < max_vote_count
-        || week == sqlx::query_scalar("SELECT number from Weeks WHERE is_last_week == 1;")
-            .fetch_optional(&mut **db)
-            .await.unwrap_or(Some(0)).unwrap_or(0)) {
+    if vote_count < 17 {
         return None;
     }
 
 
-    // The hash map makes storing and retrieving the data really easy, *but*
-    // it does lose the order of the original array (which is sorted via the SQL).
     let mut vote_data = HashMap::<String, Vec<u8>>::new();
     let mut next_truth_number = 1;
     for raw_vote in raw_votes {
@@ -172,9 +126,7 @@ pub async fn fetch_vote_data(week: u8, mut db: Connection<database::Db>, cookies
 
         let votes_for_player: &mut Vec<u8> = match vote_data.entry(raw_vote.votes_for) {
             Entry::Occupied(existing) => {existing.into_mut()}
-            Entry::Vacant(vacant) => {
-                next_truth_number = 1; // We changed user, reset to 1.
-                vacant.insert(Vec::<u8>::new())}
+            Entry::Vacant(vacant) => {vacant.insert(Vec::<u8>::new())}
         };
 
         // Fill up missing spaces if we are missing any.
@@ -186,11 +138,12 @@ pub async fn fetch_vote_data(week: u8, mut db: Connection<database::Db>, cookies
         next_truth_number = raw_vote.truth_number + 1;
     }
 
-    Some(Json(VoteData{truth_count: truth_count, votes: vote_data}))
+    Some(Json(VoteData{votes: vote_data}))
 }
 
+// FIXME:
 pub fn stage() -> AdHoc {
-    AdHoc::on_ignite("Vote stage", |rocket| async {
+    AdHoc::on_ignite("SQLx Stage", |rocket| async {
         rocket.mount("/", routes![vote, fetch_vote_data])
     })
 }

src/week.rs

@@ -4,30 +4,16 @@ use rocket::form::Form;
 use rocket::http::CookieJar;
 use rocket::response::Redirect;
 
-use rocket_db_pools::{sqlx, sqlx::Row, Connection};
+use rocket_db_pools::{sqlx, Connection};
 use rocket_dyn_templates::{context, Template};
-use sqlx::{Acquire, Executor};
-use crate::{auth, vote};
+use crate::auth;
 use crate::auth::User;
 use crate::database::Db;
-use crate::database_records::{DisplayTruth, Player, Tag, Truth, Week};
-use crate::tag;
-use crate::vote::WeeklyUserVotes;
-
-pub async fn get_last_week(db: &mut Connection<Db>) -> u8 {
-    match sqlx::query("SELECT number FROM Weeks WHERE is_last_week == 1;")
-        .fetch_one(&mut ***db).await {
-        Ok(row) => row.try_get(0).ok().unwrap_or_else(|| 1), // If error, go back to 1
-        Err(error) => {
-            error!("Error while getting current week : {error:?}");
-            1
-        }
-    }
-}
+use crate::database_records::{DisplayTruth, Player, Truth, Week};
 
 #[get("/<week_number>")]
 pub async fn week(week_number: u8, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Template {
-    let user: User = auth::get_user(&mut db, cookies).await;
+    let user: User = auth::get_user(week_number, &mut db, cookies).await;
 
     let other_players = if user.logged_in {
         match sqlx::query_as("SELECT id, name FROM Players WHERE id <> $1 AND is_admin == 0 ORDER BY name")
@@ -35,7 +21,7 @@ pub async fn week(week_number: u8, mut db: Connection<Db>, cookies: &CookieJar<'
             .fetch_all(&mut **db).await {
             Ok(v) => v,
             Err(error) => {
-                error!("Some error while getting players : {error}");
+                println!("Some error while getting players : {error}");
                 Vec::<Player>::new()
             }
         }
@@ -54,11 +40,9 @@ pub async fn week(week_number: u8, mut db: Connection<Db>, cookies: &CookieJar<'
         }
     };
 
-    let vote_data: WeeklyUserVotes = vote::get_weekly_user_votes(week_number,&user, &mut db).await;
-
     // FIXME : This is fucking *trash* but fucking hell mate
     if user.is_admin {
-        let mut truths: Vec<Truth> = match sqlx::query_as("SELECT * FROM Truths WHERE week == $1 ORDER BY number")
+        let truths: Vec<Truth> = match sqlx::query_as("SELECT * FROM Truths WHERE week == $1 ORDER BY number")
             .bind(week_number)
             .fetch_all(&mut **db).await {
             Ok(v) => v,
@@ -68,22 +52,14 @@ pub async fn week(week_number: u8, mut db: Connection<Db>, cookies: &CookieJar<'
             }
         };
 
-        for truth in &mut truths {
-            truth.tags = tag::get_truth_tags(truth.id, &mut db).await;
-        }
-
-        let tags: Vec<Tag> = tag::get_all_tags(&mut db, cookies).await;
-
-        Template::render("weeks/index", context! {
+        Template::render("index", context! {
             week_data: week_data,
             truths: truths,
             user: user,
             other_players: other_players,
-            vote_data: vote_data,
-            tags: tags
         })
     } else {
-        let mut truths: Vec<DisplayTruth> = match sqlx::query_as("SELECT id, week, number, author_id, rendered_text FROM Truths WHERE week == $1 ORDER BY number")
+        let truths: Vec<DisplayTruth> = match sqlx::query_as("SELECT id, number, author_id, rendered_text FROM Truths WHERE week == $1 ORDER BY number")
             .bind(week_number)
             .fetch_all(&mut **db).await {
             Ok(v) => v,
@@ -93,16 +69,11 @@ pub async fn week(week_number: u8, mut db: Connection<Db>, cookies: &CookieJar<'
             }
         };
 
-        for truth in &mut truths {
-            truth.tags = tag::get_truth_tags(truth.id, &mut db).await;
-        }
-
-        Template::render("weeks/index", context! {
+        Template::render("index", context! {
             week_data: week_data,
             truths: truths,
             user: user,
             other_players: other_players,
-            vote_data: vote_data
         })
     }
 }
@@ -110,10 +81,10 @@ pub async fn week(week_number: u8, mut db: Connection<Db>, cookies: &CookieJar<'
 #[post("/<week>/edit", data="<raw_intro>")]
 pub async fn update_week(week: u8, raw_intro: Form<String>,
                               mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
+    let user = auth::get_user(week, &mut db, cookies).await;
     if !user.is_admin {
         cookies.add(("toast_error", "Vous n'avez pas la permission de changer la semaine."));
-        return Redirect::to(uri!(week(week)));
+        return Redirect::to(uri!("/"));
     }
 
     let mut options = Options::empty();
@@ -141,106 +112,5 @@ pub async fn update_week(week: u8, raw_intro: Form<String>,
         }
     };
 
-    Redirect::to(uri!(week(week)))
-}
-
-#[post("/<week>/set_last")]
-pub async fn set_last_week(week: u8, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
-    if !user.is_admin {
-        cookies.add(("toast_error", "Vous n'avez pas la permission de changer la semaine."));
-        return Redirect::to(uri!(week(week)));
-    }
-
-    let add_error_cookie = ||
-        cookies.add(("toast_error", "Erreur lors du changement d'état de la semaine."));
-
-    let db_transaction_connection = db.begin().await;
-    if db_transaction_connection.is_err() {
-        error!("Could not start database transaction for last week change : {:?}", db_transaction_connection.unwrap_err());
-        add_error_cookie();
-        return Redirect::to(uri!(week(week)));
-    }
-    let mut db_transaction = db_transaction_connection.unwrap();
-
-    // Remove the last flag from other weeks, if set.
-    match db_transaction.execute("UPDATE Weeks SET is_last_week = 0 WHERE is_last_week == 1;")
-        .await {
-        Ok(_) => debug!("Succesfully cleared is_last_week"),
-        Err(error) => {
-            error!("Failed to clear last week status : {error}");
-            add_error_cookie();
-            return Redirect::to(uri!(week(week)));
-        }
-    };
-
-    // We should set one week, if not there's something wrong : rollback.
-    if match sqlx::query("UPDATE Weeks SET is_last_week = 1 WHERE number == $1;")
-        .bind(week)
-        .execute(&mut *db_transaction)
-        .await {
-            Ok(result) => result.rows_affected(),
-            Err(error) => {
-                error!("Error while setting last week status : {error}");
-                0
-            }
-    } == 1 {
-        db_transaction.commit().await.unwrap_or_else(|error| {
-            error!("Error while committing week is last transaction : {error}");
-            add_error_cookie();
-        })
-    } else {
-        db_transaction.rollback().await.unwrap_or_else(|error| {
-            error!("Error while rolling back week is last transaction : {error}");
-            add_error_cookie();
-        })
-    }
-
-    Redirect::to(uri!(week(week)))
-}
-
-#[get("/<week>/create")]
-pub async fn create_week(week: u8, mut db: Connection<Db>, cookies: &CookieJar<'_>) -> Redirect {
-    let user = auth::get_user(&mut db, cookies).await;
-    if !user.is_admin {
-        cookies.add(("toast_error", "Vous n'avez pas la permission de changer la semaine."));
-        return Redirect::to(uri!(week(week - 1)));
-    }
-
-    let week_check: Result<Option<u8>, sqlx::Error> = sqlx::query_scalar("SELECT number from Weeks WHERE number == $1;")
-        .bind(week)
-        .fetch_optional(&mut **db)
-        .await;
-
-    if week_check.is_err() {
-        error!("Error while checking week existence : {:?}", week_check.unwrap_err());
-        cookies.add(("toast_error", "Erreur en vérifiant que la semaine n'existe pas déjà"));
-        return Redirect::to(uri!(week(week - 1)));
-    }
-
-    if week_check.unwrap().is_some() {
-        debug!("Week {week} already exists, not creating.");
-        return Redirect::to(uri!(week(week)));
-    }
-
-    match sqlx::query("INSERT INTO Weeks (number, is_last_week, rendered_text, raw_text) VALUES ($1, 0, \"\", \"\");")
-        .bind(week)
-        .execute(&mut **db)
-        .await {
-            Ok(_) => {
-                debug!("Succesfully created new week {week}");
-                Redirect::to(uri!(week(week)))
-            },
-            Err(error) => {
-                error!("Error while creating new week {week} : {error}");
-                cookies.add(("toast_error", "Erreur en créant la nouvelle selmaine."));
-                Redirect::to(uri!(week(week - 1)))
-            }
-    }
-}
-
-pub fn stage() -> AdHoc {
-    AdHoc::on_ignite("Week stage", |rocket| async {
-        rocket.mount("/", routes![week, create_week, update_week, set_last_week])
-    })
+    Redirect::to(uri!("/"))
 }

static_files/style.css

@@ -2,22 +2,10 @@
     display: flex;
     flex-direction: row;
     justify-content: space-between;
-    align-items: center;
     margin-right: 2em;
 }
 
-.top_bar_side {
-    display: flex;
-    flex-direction: row;
-    justify-content: space-between;
-    align-items: baseline;
-}
-
-.top_bar_side > * {
-    padding: 0 0.5em;
-}
-
-.truth_page_body {
+.page_body {
     display: flex;
     flex-direction: row;
     justify-content: space-between;
@@ -35,28 +23,14 @@
     padding-bottom: 2em;
 }
 
-.individual_truth h3 {
-    text-align: center;
-    padding-bottom: 4px;
-    border-bottom: slategray solid 0.15em;
-}
-
-.individual_truth p {
-    padding: 0 0.5em;
-}
-
 .editor {
-    width: calc(100% - 1.25em); /* The width is calculated *inside* the padding, so adjust for it. */
+    width: 100%;
     height: 6eM;
     font-size: large;
     padding: 0.5em;
     margin-bottom: 1em;
 }
 
-.truth_edit_form {
-    margin-bottom: 1em;
-}
-
 .graph {
     display: flex;
     flex-direction: column;
@@ -73,131 +47,10 @@
     top: 25%;
 }
 
-.week_change:link, .week_change:visited,
-.individual_truth > a, .individual_truth > a:link, .individual_truth > a:visited,
-nav > a, nav > a:link, nav > a:visited,
-h1 > a, h1 > a:link, h1 > a:visited {
-    color: black;
-    text-decoration: none;
-    transition: all .2s ease-in-out;
-}
-
-.week_change:hover, .week_change:focus,
-.individual_truth > a:hover, .individual_truth > a:focus,
-nav > a:hover, nav > a:focus,
-h1 > a:hover, h1 > a:focus {
-    color: mediumpurple;
-    text-shadow: 0 2px 2px slategray;
-}
-
-.week_change_hidden {
-    padding-left: 0.5eM;
-    padding-right: 0.5eM;
-}
-
-@media (orientation: portrait) {
-    .truth_list {
-        width: 60vw;
-    }
-
-    .graph {
-        width: 35vw;
-    }
-}
-
-.tag_list {
-    display: flex;
-    flex-flow: column wrap;
-    align-content: flex-start;
-    max-height: 40vh;
-    margin-bottom: 1em;
-}
-
-@media (orientation: portrait) {
-    .tag_list {
-        max-height: none;
-    }
-}
-
-.new_tag {
-    display: flex;
-    flex-direction: column;
-    border: black dashed 1px;
-    padding: 0.5em;
-    margin-top: 0.5em;
-    width: fit-content;
-}
-
-.new_tag > button {
-    margin-top: 1em;
-}
-
-.tag {
-    display: flex;
-    justify-content: center;
-    margin: 0.25em;
-    width: fit-content;
-    text-decoration: none;
-    text-shadow:
-            -1px 0 3px black,
-             1px 0 3px black,
-            0 -1px 3px black,
-             0 1px 3px black;
-    color: white;
-    padding: 0.25em 0.75em 0.25em 0.25em;
-    border-bottom-left-radius: 0.4em;
-    border-top-left-radius: 0.4em;
-    border-bottom-right-radius: 1.5em 0.8em;
-    border-top-right-radius: 1.5em 0.8em;
-
-    transition: all .2s ease-in-out;
-}
-
-.tag:hover, .tag:focus {
-    color: mediumpurple;
-}
-
-.truth_tags {
-    display: flex;
-    flex-flow: wrap;
-}
-
-.truth_tags > .tag { /* We want smaller tags, the shadows must follow as well */
-    font-size: smaller;
-    text-shadow:
-            -1px 0 2px black,
-            1px 0 2px black,
-            0 -1px 2px black,
-            0 1px 2px black;
-}
-
-.truth_tags > form {
-    display: contents;
-}
-
-.login {
-    display: flex;
-    flex-direction: column;
-}
-
-.login > * {
-    padding-bottom: 0.1em;
-}
-
-.login > label {
-    align-self: flex-end;
-}
-
-.login > b {
-    align-self: center;
-}
-
-/* Global styling */
-
 hr {
     border: none;
-    border-top: 2px dotted slategray;
-    color: slategray;
+    border-top: 2px solid #9ec5fe;
+    color: #9ec5fe;
     overflow: visible;
     text-align: center;
     height: 5px;
@@ -222,9 +75,12 @@ body > h2 {
     padding-left: 0.25eM;
 }
 
-nav {
-    height: fit-content;
-    margin: 0 0.25em;
-    border-left: 0.15em solid slategray;
-    border-right: 0.15em solid slategray;
+@media (orientation: portrait) {
+    .truth_list {
+        width: 60vw;
+    }
+
+    .graph {
+        width: 35vw;
+    }
 }

static_files/vote_chart.js

@@ -1,67 +1,51 @@
-const limit_ratio = 1.3
-const colors = ['#b6b8fc', '#b6f4fc', '#fcb6cc', '#e0fcb6', '#fcdcb6', '#b6fcc8', '#f0b6fc']
+
+// const names = ["Bystus", "Dory", "Fen", "Lucky", "Nico", "Peran", "trot"]
+//
+//
+// let data = [];
+// for (let i = 0; i < 7; i++) {
+//     data.push({
+//         parsing: true,
+//         label: names[i],
+//         data: Array.from(keys, () => Math.round(Math.random()*1.33))})
+// }
 async function main() {
-    let current_url = new URL(document.URL)
-    current_url.hash = '' // Strip the local part of the URL, for example if we select a Truth
-    const vote_response = await fetch(current_url.toString()+"/votes");
+    const vote_response = await fetch(document.URL+"/votes");
     if (!vote_response.ok) {
         return;
     }
 
-    let keys = []
+    const keys = ["Vérité 1", "Vérité 2", "Vérité 3", "Vérité 4", "Vérité 5", "Vérité 6", "Vérité 7"]
     let datasets = []
+
     try {
-        const vote_data = (await vote_response.json());
-        for (let player in vote_data.votes) {
+        const vote_data = (await vote_response.json()).votes;
+        for (let player in vote_data) {
             datasets.push({
                 parsing: true,
                 label: player,
-                data: vote_data.votes[player],
+                data: vote_data[player],
             })
         }
-        for (let i = 1; i <= vote_data.truth_count; i++) {
-            keys.push("Vérité " + i)
-        }
+        console.log(datasets)
     } catch (error) {
         console.error("Failed to parse vote data : \n\t" + error.message);
         return;
     }
 
-
-    // Sort by label to maintain the same graph order, as it goes through a hash map in the backend.
-    datasets.sort((a, b) => a.label > b.label)
-    for (let i = 0; i < datasets.length; i++) {
-        datasets[i].backgroundColor = colors[i % colors.length]
-    }
-
     const chart_canvas = document.getElementById("vote_chart")
     let chart
-    let previous_orientation
     function create_chart(keys, data) {
         let main_axis;
         let aspect_ratio;
-        let orientation
-
-        if (window.innerWidth / window.innerHeight > limit_ratio) {
-            orientation = "landscape"
+        if (window.innerWidth > window.innerHeight) {
             main_axis = 'x'
             aspect_ratio = 2
         } else {
-            orientation = "portrait"
             main_axis = 'y'
             aspect_ratio = 0.5
         }
 
-        // Don't re-create the chart for no reason.
-        if (orientation === previous_orientation) {
-            console.log("bijour")
-            return;
-        } else {
-            console.log("badour")
-        }
-
-        previous_orientation = orientation
-
         if ( chart ) {
             chart.destroy()
         }
@@ -83,13 +67,6 @@ async function main() {
                     y: {
                         stacked: true
                     }
-                },
-                plugins: {
-                    title: {
-                        display: true,
-                        position: 'bottom',
-                        text: 'Répartition des suppositions'
-                    }
                 }
             }
         })
@@ -99,7 +76,7 @@ async function main() {
         create_chart(keys, datasets)
     }
 
-    const orientation_query = matchMedia(`(aspect-ratio < ${limit_ratio})`);
+    const orientation_query = matchMedia("screen and (orientation:portrait)");
     orientation_query.onchange = update_chart_ratio
 
     create_chart(keys, datasets)

templates/base_page.html.tera

@@ -1,50 +0,0 @@
-<!DOCTYPE html>
-<html lang="fr">
-{% set title = "Vérités Nova Borealis" %}
-<head>
-    <meta charset="UTF-8">
-    <title>{{ title }}</title>
-    <link href="/static/style.css" rel="stylesheet"/>
-    <link href="/static/favicon.ico" rel="icon"/>
-    {% block scripts %}
-    {% endblock %}
-</head>
-
-<body>
-{% block top_bar %}
-<div class="top_bar">
-    <div class="top_bar_side">
-        <h1><a href="/">{{ title }}</a></h1>
-        <nav>
-            Aller à :
-            <a href="/">Vérités</a>
-            -
-            <a href="/tags">Thèmes</a>
-        </nav>
-    </div>
-    <div class="top_bar_side">
-    {% block top_bar_side %}
-        <div>
-        {% if user.logged_in == true %}
-            <form class="login" id="logout" action="/{{ week_data.number }}/logout" method="POST">
-                Connecté en tant que <b>{{ user.name }}</b>
-                <button form="logout">Déconnecter</button>
-            </form>
-        {% else %}
-            <form class="login" id="login" action="/{{ week_data.number }}/login" method="POST">
-                <label>Pseudo <input form="login" type="text" name="name"/></label>
-                <label>Mot de passe <input form="login" type="password" name="password"/></label>
-                <button form="login">Se connecter</button>
-            </form>
-        {% endif %}
-        </div>
-    {% endblock %}
-    </div>
-</div>
-{% endblock %}
-
-{% block body %}
-{% endblock %}
-
-</body>
-</html>

templates/editable_truth.tera

@@ -0,0 +1,8 @@
+<div class="individual_truth">
+    <h3>Vérité {{ truth.number }}</h3>
+    <p>{{ truth.rendered_text | safe }}</p>
+    <hr/>
+    <form action="/{{ week_data.number }}/edit/{{ truth.number }}" method="POST">
+        {% include "truth_editor" %}
+    </form>
+</div>

templates/index.html.tera

@@ -0,0 +1,109 @@
+<!DOCTYPE html>
+<html lang="en">
+{% set title = "Vérités Fabula Ultima" %}
+<head>
+    <meta charset="UTF-8">
+    <title>{{ title }}</title>
+    <link href="/style.css" rel="stylesheet"/>
+    {% if user.logged_in == true and not user.is_admin %}
+        <script defer="defer" type="text/javascript" src="/vote_handler.js"></script>
+    {% endif %}
+    <script defer="defer" type="application/javascript" src="https://cdn.jsdelivr.net/npm/chart.js@4.4.3/dist/chart.umd.min.js"></script>
+    <script defer="defer" type="text/javascript" src="/vote_chart.js"></script>
+</head>
+
+{# Check if the user has a vote in advance, for readability #}
+{% if user.logged_in == true and user.has_week_vote == true%}
+    {% set has_vote = true %}
+{% else %}
+    {% set has_vote = false %}
+{% endif -%}
+
+<body>
+<div class="top_bar">
+    <h1>{{ title }}</h1>
+    {% if user.logged_in == true %}
+        <p>Connecté en tant que <b>{{ user.name }}</b></p>
+    {% else %}
+        <form class="login" id="login" action="/login" method="POST">
+            <label>Pseudo <input form="login" type="text" name="name"/></label>
+            <label>Mot de passe <input form="login" type="password" name="password"/></label>
+            <button form="login">Se connecter</button>
+        </form>
+    {% endif %}
+</div>
+
+<h2>Semaine {{ week_data.number }}</h2>
+<div class="page_body">
+    <div class="truth_list">
+        <div class="week_intro">
+            {{ week_data.rendered_text | safe }}
+            {%- if user.is_admin == true -%}
+                <hr/>
+                <form action="/{{ week_data.number }}/edit" method="post">
+                    <textarea class="editor" name="raw_intro">
+                        {{- week_data.raw_text -}}
+                    </textarea>
+                    <button>
+                        Modifier l'introduction
+                    </button>
+                </form>
+            {% endif %}
+        </div>
+        {% if user.logged_in == true and user.is_admin == false %}
+        <form id="truths" action="/{{ week_data.number }}/vote" method="POST">
+        {% endif %}
+
+            {# Truths start at 1 but the array starts at 0 #}
+            {% set index_delta = 1 %}
+            {% for truth in truths %}
+                {#
+                    The truths are in an ordered array, but one of them might be the user's.
+                    In this case, we need to stop the array index from incrementing if the current
+                    truth is the user's, as they cannot have voted for themselves, leading to one
+                    less votes than there are truths.
+                #}
+                {%- if truth.author_id == user.id -%}
+                    {%- set_global index_delta = 2 -%}
+                {% endif %}
+                {% set truth_index = truth.number - index_delta %}
+
+                {% if user.is_admin == true %}
+                    {% include "editable_truth" %}
+                {% else %}
+                    {% include "truth" %}
+                {% endif %}
+            {% endfor %}
+
+        {% if user.logged_in == true and user.is_admin == false %}
+            <br/>
+            <button form="truths">
+                {%- if has_vote == true -%}
+                    Changer de vote
+                {% else %}
+                    À voter !
+                {% endif %}
+            </button>
+        </form>
+        {% endif %}
+
+        {# If admin, show an additional box for creating a new Truth. #}
+        {% if user.is_admin == true %}
+            <div class="individual_truth">
+                <h3>Nouvelle vérité</h3>
+                <form action="/{{ week_data.number }}/new" method="POST">
+                    {% include "truth_editor" %}
+                </form>
+            </div>
+        {% endif %}
+    </div>
+
+    <div class="graph">
+        <div>
+            <canvas id="vote_chart"></canvas>
+        </div>
+    </div>
+</div>
+
+</body>
+</html>

templates/tags/filtered_truths.html.tera

@@ -1,28 +0,0 @@
-{% extends "base_page" %}
-
-{% block top_bar_side %}
-{% endblock %}
-
-{% block body %}
-    {% if tags | length == 0 %}
-        <h2>Ensemble des vérités à ce jour</h2>
-    {% elif tags | length == 1 %}
-        <h2>Vérités correponsdantes au thème</h2>
-    {% else %}
-        <h2>Vérités correponsdantes aux thèmes</h2>
-    {% endif %}
-
-    <div class="truth_tags">
-        {% for tag in tags %}
-            <a class="tag" href="/tags/filter?tags={{ tag.name }}"
-               style="background-color: {{ tag.color }}">{{ tag.name }}</a>
-        {% endfor %}
-    </div>
-
-    {% for truth in truths %}
-        <div class="individual_truth">
-            <a href="/{{ truth.week }}#{{ truth.number }}"><h3 id="{{ truth.number }}">Semaine {{ truth.week }} - Vérité {{ truth.number }}</h3></a>
-            <p>{{ truth.rendered_text | safe }}</p>
-        </div>
-    {% endfor %}
-{% endblock %}

templates/tags/index.html.tera

@@ -1,42 +0,0 @@
-{% extends "base_page" %}
-
-{% block top_bar_side %}
-{% endblock %}
-
-{% block body %}
-    <h2>Liste des thèmes de Vérité</h2>
-
-    <form class="tag_list" id="filter_by_tags" action="/tags/filter">
-        {% for tag in tags %}
-            <div class="tag" style="background-color: {{ tag.color }}">
-                <label><input type="checkbox" form="filter_by_tags" name="tags" value="{{ tag.name }}">{{ tag.name }}</label>
-            </div>
-        {% endfor %}
-    </form>
-    <button form="filter_by_tags">Voir les vérités correspondantes</button>
-
-    {% if user.is_admin %}
-        <hr>
-
-        <h2>Éditer les thèmes</h2>
-
-        <div class="tag_list">
-            {% for tag in tags %}
-                <form class="tag" style="background-color: {{ tag.color }}" id="edit_tag[{{ tag.name }}]" method="post" action="/tags/update/{{ tag.name }}">
-                    <input type="text" form="edit_tag[{{ tag.name }}]" name="name" value="{{ tag.name }}">
-                    <input type="color" form="edit_tag[{{ tag.name }}]" name="color" value="{{ tag.color }}">
-                    <button>Mettre à jour</button>
-                    <button formaction="/tags/delete/{{ tag.name }}">Supprimer</button>
-                </form>
-            {% endfor %}
-        </div>
-
-        <form class="new_tag" id="new_tag" action="/tags/create" method="post">
-            <div>
-                <label>Nom de l'étiquette: <input type="text" form="new_tag" name="name"/></label>
-                <label>Couleur: <input type="color" form="new_tag" name="color"></label>
-            </div>
-            <button>Ajouter une étiquette</button>
-        </form>
-    {% endif %}
-{% endblock %}

templates/truth.html.tera

@@ -0,0 +1,26 @@
+<div class="individual_truth">
+    <h3>Vérité {{ truth.number }}</h3>
+    <p>{{ truth.rendered_text | safe }}</p>
+    {% if user.logged_in %}
+    <hr/>
+    <label>
+        {%- if truth.author_id == user.id -%}
+        Tu l'as fait :)
+        {%- else -%}
+        Qui l'a fait ?
+        <select form="truths" name="truth_votes[{{ truth.id }}]">
+                <option value="0">---</option>
+            {% for  player in other_players %}
+                {# Check if we should pre-select an existing vote #}
+                {% if has_vote == true and player.id == user.votes[truth_index].voted_id %}
+                    {% set is_selected = "selected" %}
+                {% else %}
+                    {% set is_selected = "" %}
+                {% endif %}
+                <option value="{{ player.id }}" {{- is_selected -}}>{{ player.name }}</option>
+            {% endfor %}
+        </select>
+        {%- endif -%}
+    </label>
+    {% endif %}
+</div>

templates/weeks/editable_truth.tera

@@ -1,32 +0,0 @@
-<div class="individual_truth">
-    <a href="/{{ truth.week }}#{{ truth.number }}"><h3 id="{{ truth.number }}">Vérité {{ truth.number }}</h3></a>
-    <p>{{ truth.rendered_text | safe }}</p>
-    <div class="truth_tags">
-        {% for tag in truth.tags %}
-            <form action="/{{ week_data.number }}/untag/{{ truth.id }}" method="post">
-                <button name="name" value="{{ tag.name }}">❌</button>
-            </form>
-            <a class="tag" href="/tags/filter?tags={{ tag.name }}" style="background-color: {{ tag.color }}">
-                {{ tag.name }}
-            </a>
-        {% endfor %}
-    </div>
-    <hr/>
-    <form class="truth_edit_form" action="/{{ week_data.number }}/edit/{{ truth.number }}" method="POST">
-        {% include "weeks/truth_editor" %}
-    </form>
-    {% if tags | length > 0 and tags | length > truth.tags | length %}
-        <form class="truth_edit_form" action="/{{ week_data.number }}/tag/{{ truth.id }}" method="post">
-            <label>Thème supplémentaire:
-                <select name="name">
-                    {% for tag in tags %}
-                        {% if not truth.tags is containing(tag) %}
-                            <option value="{{ tag.name }}" style="background-color: {{ tag.color }}">{{ tag.name }}</option>
-                        {% endif %}
-                    {% endfor %}
-                </select>
-            </label>
-            <button>Ajouter un thème</button>
-        </form>
-    {% endif %}
-</div>

templates/weeks/index.html.tera

@@ -1,120 +0,0 @@
-{% extends "base_page" %}
-
-{% block scripts %}
-    {% if user.logged_in == true and not user.is_admin %}
-        <script defer="defer" type="text/javascript" src="/static/vote_handler.js"></script>
-    {% endif %}
-    <script defer="defer" type="application/javascript" src="https://cdn.jsdelivr.net/npm/chart.js@4.4.3/dist/chart.umd.min.js"></script>
-    <script defer="defer" type="text/javascript" src="/static/vote_chart.js"></script>
-{% endblock %}
-
-{#{% import "week_change_arrows" as week_macro %}#}
-{# For some reason the import does not work ? Figure it out at some point... #}
-{%- macro display(display_character, to, enabled) -%}
-    {%- set class = "week_change" -%}
-    {%- if enabled == true %}
-        {% set target = ("href=/" ~ to) %}
-    {%- else -%}
-        {% set class = class ~ " week_change_hidden" -%}
-        {% set target = "" %}
-    {%- endif -%}
-    <a {{ target }} class="{{ class }}">{%- if enabled == true -%}{{- display_character -}}{%- endif -%}</a>
-{%- endmacro display -%}
-
-{# Remove the form if all votes are locked, to reduce confusion. #}
-{% set lock_truth_form = vote_data.votes | length + 1 == truths | length and week_data.is_last_week != true %}
-
-{% block body %}
-
-    {# Apparently needs to be inside the block ? #}
-    {% set back_arrow_enabled = week_data.number > 1 %}
-    {% set next_arrow_enabled = (week_data.is_last_week != true or user.is_admin == true) %}
-    {% set next_arrow_href = (week_data.number + 1) %}
-    {% if user.is_admin == true %}
-        {% set next_arrow_href = next_arrow_href ~ "/create" %}
-        {% set next_arrow_chara = '⥅' %}
-    {% else %}
-        {% set next_arrow_chara = '⟹' %}
-    {% endif %}
-
-    <h2>{{- self::display(display_character='⟸', to=(week_data.number - 1), enabled=back_arrow_enabled) }}
-        Semaine {{ week_data.number }}
-        {{- self::display(display_character=next_arrow_chara, to=next_arrow_href, enabled=next_arrow_enabled) -}}</h2>
-    <div class="truth_page_body">
-        <div class="truth_list">
-            {% if user.is_admin == true and week_data.is_last_week != true %}
-                <form action="/{{ week_data.number }}/set_last" method="post">
-                    <button>
-                        Définir comme dernière semaine active
-                    </button>
-                </form>
-            {% endif %}
-            <div class="week_intro">
-                {{ week_data.rendered_text | safe }}
-                {%- if user.is_admin == true -%}
-                    <hr/>
-                    <form action="/{{ week_data.number }}/edit" method="post">
-                        <textarea class="editor" name="raw_intro">
-                            {{- week_data.raw_text -}}
-                        </textarea>
-                        <button>
-                            Modifier l'introduction
-                        </button>
-                    </form>
-                {% endif %}
-            </div>
-            {% if user.logged_in == true and user.is_admin == false and not lock_truth_form %}
-            <form id="truths" action="/{{ week_data.number }}/vote" method="POST">
-            {% endif %}
-
-                {# Truths start at 1 but the array starts at 0 #}
-                {% set index_delta = 1 %}
-                {% for truth in truths %}
-                    {#
-                        The truths are in an ordered array, but one of them might be the user's.
-                        In this case, we need to stop the array index from incrementing if the current
-                        truth is the user's, as they cannot have voted for themselves, leading to one
-                        less votes than there are truths.
-                    #}
-                    {%- if truth.author_id == user.id -%}
-                        {%- set_global index_delta = 2 -%}
-                    {% endif %}
-                    {% set truth_index = truth.number - index_delta %}
-
-                    {% if user.is_admin == true %}
-                        {% include "weeks/editable_truth" %}
-                    {% else %}
-                        {% include "weeks/truth" %}
-                    {% endif %}
-                {% endfor %}
-
-            {% if user.logged_in == true and user.is_admin == false and not lock_truth_form %}
-                <br/>
-                <button form="truths">
-                    {%- if user.logged_in == true and vote_data.has_week_vote == true -%}
-                        Changer de vote
-                    {% else %}
-                        À voter !
-                    {% endif %}
-                </button>
-            </form>
-            {% endif %}
-
-            {# If admin, show an additional box for creating a new Truth. #}
-            {% if user.is_admin == true %}
-                <div class="individual_truth">
-                    <h3>Nouvelle vérité</h3>
-                    <form action="/{{ week_data.number }}/new_truth" method="POST">
-                        {% include "weeks/truth_editor" %}
-                    </form>
-                </div>
-            {% endif %}
-        </div>
-
-        <div class="graph">
-            <div>
-                <canvas id="vote_chart"></canvas>
-            </div>
-        </div>
-    </div>
-{% endblock %}

templates/weeks/truth.html.tera

@@ -1,40 +0,0 @@
-{%- set is_disabled = "" -%}
-{# If we are not during the active week, prevent changing vote but not sending a missing one. #}
-{%- if week_data.is_last_week != true and vote_data.votes | filter(attribute="truth_id", value=truth.id) -%}
-    {%- set is_disabled = "disabled" -%}
-{%- endif -%}
-
-<div class="individual_truth">
-    <a href="/{{ truth.week }}#{{ truth.number }}"><h3 id="{{ truth.number }}">Vérité {{ truth.number }}</h3></a>
-    <p>{{ truth.rendered_text | safe }}</p>
-    <hr>
-    <div class="truth_tags">
-        {% for tag in truth.tags %}
-            <a class="tag" href="/tags/filter?tags={{ tag.name }}" style="background-color: {{ tag.color }}">{{ tag.name }}</a>
-        {% endfor %}
-    </div>
-    {% if user.logged_in %}
-    <hr/>
-    <label>
-        {%- if truth.author_id == user.id -%}
-        Tu l'as fait :)
-        {%- else -%}
-        Qui l'a fait ?
-        <select form="truths" name="truth_votes[{{ truth.id }}]" {{ is_disabled }}>
-                <option value="0">---</option>
-            {% for  player in other_players %}
-                {# Check if we should pre-select an existing vote. #}
-                {% set_global is_selected = "" %}
-                {% for vote in vote_data.votes %}
-                    {% if truth.id == vote.truth_id and player.id == vote.voted_id %}
-                        {% set_global is_selected = "selected" %}
-                        {% break %}
-                    {% endif %}
-                {% endfor %}
-                <option value="{{ player.id }}" {{- is_selected -}}>{{ player.name }}</option>
-            {% endfor %}
-        </select>
-        {%- endif -%}
-    </label>
-    {% endif %}
-</div>