Remove unused import

Fixed bug related to new Vote struct, id and submit date can be None
(useful for posting new votes, ie without id and submit date)
2024-10-05 15:52:59 +02:00 · 2024-10-05 15:09:51 +02:00 · 2024-10-05 15:08:41 +02:00 · 2024-10-04 22:49:51 +02:00 · 2024-10-04 22:49:00 +02:00 · 2024-10-04 21:00:53 +02:00
7 changed files with 478 additions and 112 deletions
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,12 +3,12 @@ use argon2::{
    Argon2,
 };
 use bytes::{Buf, Bytes};
-use chrono::{DateTime, Days, Utc};
+use chrono::{DateTime, Days, NaiveTime, Utc};
 #[cfg(target_os = "linux")]
 use daemonize::Daemonize;
 use http_body_util::{BodyExt, Full};
 use hyper::{
-    body::{Body as HyperBody, Incoming, Frame},
+    body::{Body as HyperBody, Frame, Incoming},
    header::{COOKIE, SET_COOKIE},
    server::conn::http1,
    service::service_fn,
@@ -66,8 +66,10 @@ struct Player {
    name: String,
 }

-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 struct Vote {
+    id: Option<i64>,
+    submit_date: Option<String>,
    plus_player_id: i64,
    plus_nickname: String,
    plus_reason: String,
@@ -99,9 +101,9 @@ async fn service(
    req: Request<Incoming>,
    db: Arc<Mutex<SqlitePool>>,
 ) -> Result<Response<Body>, Error> {
-    match req.method() {
-        &Method::GET => get(req, db).await,
-        &Method::POST => post(req, db).await,
+    match *req.method() {
+        Method::GET => get(req, db).await,
+        Method::POST => post(req, db).await,
        _ => Ok(Response::builder()
            .status(StatusCode::IM_A_TEAPOT)
            .body(Body::Empty)
@@ -134,7 +136,12 @@ async fn get_page(
    let map: Value = from_reader(file).expect("Could not parse routes, please verify syntax.");
    match map.get(path) {
        Some(Value::Object(s)) => {
-            let authorised = is_authorised(req, db, s.get("permission").unwrap().as_u64().unwrap() as u8).await;
+            let authorised = is_authorised(
+                req,
+                db,
+                s.get("permission").unwrap().as_u64().unwrap() as u8,
+            )
+            .await;
            if authorised {
                get_file(s.get("file").unwrap().as_str().unwrap()).await
            } else {
@@ -218,17 +225,13 @@ async fn get_data(
            let mut plus_results: HashMap<i64, i64> = HashMap::new();
            let mut minus_results: HashMap<i64, i64> = HashMap::new();

-            let _ = ids.iter().for_each(|x| {
+            ids.iter().for_each(|x| {
                let plus_id = x.0;
-                if !plus_results.contains_key(&plus_id) {
-                    plus_results.insert(plus_id, 0);
-                }
+                plus_results.entry(plus_id).or_insert(0);
                *plus_results.get_mut(&plus_id).unwrap() += 1;

                let minus_id = x.1;
-                if !minus_results.contains_key(&minus_id) {
-                    minus_results.insert(minus_id, 0);
-                }
+                minus_results.entry(minus_id).or_insert(0);
                *minus_results.get_mut(&minus_id).unwrap() += 1;
            });

@@ -254,11 +257,10 @@ async fn get_votes(req: &Request<Incoming>, db: Arc<Mutex<SqlitePool>>) -> Vec<V
    let date = match headers.get("Date-to-fetch") {
        Some(date) => {
            let date = date.to_str().unwrap();
-            let parsed_date = date.parse::<i64>();
-            if parsed_date.is_err() {
-                None
+            if let Ok(parsed_date) = date.parse::<i64>() {
+                DateTime::from_timestamp_millis(parsed_date)
            } else {
-                DateTime::from_timestamp_millis(parsed_date.unwrap())
+                None
            }
        }
        None => Some(DateTime::from(SystemTime::now())),
@@ -267,24 +269,14 @@ async fn get_votes(req: &Request<Incoming>, db: Arc<Mutex<SqlitePool>>) -> Vec<V
        return Vec::new();
    }
    let formatted_date = format!("{}", date.unwrap().format("%d/%m/%Y"));
-    let items = sqlx::query!(
+    sqlx::query_as!(
+        Vote,
        r#"SELECT * FROM votes WHERE submit_date = ?1 ORDER BY id"#,
        formatted_date
    )
    .fetch_all(&pool)
    .await
-    .unwrap();
-    items
-        .iter()
-        .map(|x| Vote {
-            plus_player_id: x.plus_player_id,
-            plus_nickname: x.plus_nickname.clone(),
-            plus_reason: x.plus_reason.clone(),
-            minus_player_id: x.minus_player_id,
-            minus_nickname: x.minus_nickname.clone(),
-            minus_reason: x.minus_reason.clone(),
-        })
-        .collect()
+    .unwrap()
 }

 async fn get_admin(
@@ -293,26 +285,44 @@ async fn get_admin(
    db: Arc<Mutex<SqlitePool>>,
 ) -> Result<Response<Body>, Error> {
    let authorised = is_authorised(req, db.clone(), 3).await;
-    if authorised {
-        return not_found().await;
+    if !authorised {
+        return get_page(req, "/unauthorised", db).await;
    }
-    if path == "/admin" {
-        return get_page(req, path, db).await;
-    }
-    if path == "/admin/users" {
+    match path {
+        "/admin" => get_page(req, path, db).await,
+        "/admin/users" => {
            let pool = db.clone().lock().unwrap().clone();
-        let users = sqlx::query!(r#"SELECT username, permissions FROM users"#)
+            let users = sqlx::query!(r#"SELECT id, username, permissions FROM users"#)
                .fetch_all(&pool)
                .await
                .unwrap();
-        let users: Vec<(String, i64)> = users
+            let users: Vec<(i64, String, i64)> = users
                .iter()
-            .map(|x| (x.username.clone(), x.permissions))
+                .map(|x| (x.id, x.username.clone(), x.permissions))
                .collect();
            let stringed = serde_json::to_string(&users).unwrap_or("".to_string());
-        return Ok(Response::builder().body(Body::new(stringed)).unwrap());
+            Ok(Response::builder().body(Body::new(stringed)).unwrap())
+        }
+        "/admin/players" => {
+            let pool = db.clone().lock().unwrap().clone();
+            let players = sqlx::query_as!(Player, r#"SELECT id, name FROM players"#)
+                .fetch_all(&pool)
+                .await
+                .unwrap();
+            let stringed = serde_json::to_string(&players).unwrap_or("".to_string());
+            Ok(Response::builder().body(Body::new(stringed)).unwrap())
+        }
+        "/admin/votes" => {
+            let pool = db.clone().lock().unwrap().clone();
+            let votes = sqlx::query_as!(Vote, r#"SELECT * FROM votes"#)
+                .fetch_all(&pool)
+                .await
+                .unwrap();
+            let stringed = serde_json::to_string(&votes).unwrap_or("".to_string());
+            Ok(Response::builder().body(Body::new(stringed)).unwrap())
+        }
+        _ => not_found().await,
    }
-    not_found().await
 }

 async fn post(req: Request<Incoming>, db: Arc<Mutex<SqlitePool>>) -> Result<Response<Body>, Error> {
@@ -325,6 +335,7 @@ async fn post(req: Request<Incoming>, db: Arc<Mutex<SqlitePool>>) -> Result<Resp
        "/login" => login(req, db).await,
        "/register" => register(req, db).await,
        "/logout" => logout().await,
+        "/player" => post_player(req, db).await,
        _ => not_found().await,
    }
 }
@@ -333,13 +344,9 @@ async fn post_vote(
    req: Request<Incoming>,
    db: Arc<Mutex<SqlitePool>>,
 ) -> Result<Response<Body>, Error> {
-    let body = req.into_body().collect().await?;
-    let data: Result<Vote, serde_json::Error> = from_reader(body.aggregate().reader());
-    if data.is_err() {
-        return Ok(Response::builder()
-            .status(StatusCode::BAD_REQUEST)
-            .body(Body::Empty)
-            .unwrap());
+    let data = req_json::<Vote>(req).await;
+    if data.is_none() {
+        return bad_request().await;
    }
    let vote = data.unwrap();
    let timestamp: DateTime<Utc> = DateTime::from(SystemTime::now());
@@ -361,7 +368,66 @@ async fn post_vote(
            .body(Body::Empty)
            .unwrap());
    }
-    Ok(Response::builder().body(Body::Empty).unwrap())
+    let date: DateTime<Utc> = DateTime::from(SystemTime::now());
+    let date = date.checked_add_days(Days::new(1)).unwrap();
+    let date = date
+        .with_time(NaiveTime::from_hms_opt(0, 0, 0).unwrap())
+        .unwrap();
+    Ok(Response::builder()
+        .header(
+            SET_COOKIE,
+            format!(
+                "hasvoted=true; Expires={}; Secure; SameSite=Strict",
+                date.to_rfc2822()
+            ),
+        )
+        .body(Body::Empty)
+        .unwrap())
+}
+
+async fn post_player(
+    req: Request<Incoming>,
+    db: Arc<Mutex<SqlitePool>>,
+) -> Result<Response<Body>, Error> {
+    let data = req_json::<Value>(req).await;
+    if data.is_none() {
+        return bad_request().await;
+    }
+    let data = data.unwrap();
+    let name = data.get("name").unwrap().as_str().unwrap();
+    let pool = db.clone().lock().unwrap().clone();
+    let mut conn = pool.acquire().await.unwrap();
+    if let Ok(Some(player)) = sqlx::query!(r#"SELECT * FROM players WHERE name = ?1"#, name)
+        .fetch_optional(&pool)
+        .await
+    {
+        let player = Player {
+            id: player.id,
+            name: player.name,
+        };
+        return Ok(Response::builder()
+            .body(Body::new(serde_json::to_string(&player).unwrap()))
+            .unwrap());
+    }
+    let r = sqlx::query!(
+        r#"INSERT INTO players (name) VALUES (?1) RETURNING id"#,
+        name
+    )
+    .fetch_one(&mut *conn)
+    .await;
+    if r.is_err() {
+        return Ok(Response::builder()
+            .status(StatusCode::INTERNAL_SERVER_ERROR)
+            .body(Body::Empty)
+            .unwrap());
+    }
+    let player = Player {
+        id: r.unwrap().id,
+        name: name.to_string(),
+    };
+    Ok(Response::builder()
+        .body(Body::new(serde_json::to_string(&player).unwrap()))
+        .unwrap())
 }

 async fn post_admin(
@@ -369,19 +435,148 @@ async fn post_admin(
    db: Arc<Mutex<SqlitePool>>,
 ) -> Result<Response<Body>, Error> {
    let authorised = is_authorised(&req, db.clone(), 3).await;
-    if authorised {
+    if !authorised {
        return get_page(&req, "/unauthorised", db).await;
    }
    let path = req.uri().path();
    match path {
-        "/admin/post/user" => {
-            req_json::<User>(req).await;
+        "/admin/edit/user" => match req_json::<Value>(req).await {
+            Some(Value::Object(user)) => {
+                let username = user.get("username");
+                let permissions = user.get("permissions");
+                let id = user.get("id");
+                if username.is_none() || permissions.is_none() || id.is_none() {
+                    return bad_request().await;
                }
-        "/admin/post/vote" => {}
-        "/admin/post/player" => {}
-        _ => {}
+                let pool = db.clone().lock().unwrap().clone();
+                let mut conn = pool.acquire().await.unwrap();
+                let username = username.unwrap().as_str().unwrap();
+                let permissions = permissions.unwrap();
+                let id = id.unwrap();
+                let _ = sqlx::query!(
+                    r#"UPDATE users SET username = ?1, permissions = ?2 WHERE id = ?3"#,
+                    username,
+                    permissions,
+                    id
+                )
+                .execute(&mut *conn)
+                .await;
+                ok().await
+            }
+            _ => bad_request().await,
+        },
+        "/admin/delete/user" => match req_json::<Value>(req).await {
+            Some(Value::Object(user)) => {
+                let id = user.get("id");
+                if id.is_none() {
+                    return bad_request().await;
+                }
+                let pool = db.clone().lock().unwrap().clone();
+                let mut conn = pool.acquire().await.unwrap();
+                let id = id.unwrap().as_i64().unwrap();
+                let _ = sqlx::query!(r#"DELETE FROM users WHERE id = ?1"#, id)
+                    .execute(&mut *conn)
+                    .await;
+                ok().await
+            }
+            _ => bad_request().await,
+        },
+        "/admin/edit/player" => match req_json::<Player>(req).await {
+            Some(player) => {
+                let pool = db.clone().lock().unwrap().clone();
+                let mut conn = pool.acquire().await.unwrap();
+                let _ = sqlx::query!(
+                    r#"UPDATE players SET name = ?1 WHERE id = ?2"#,
+                    player.name,
+                    player.id
+                )
+                .execute(&mut *conn)
+                .await;
+                ok().await
+            }
+            _ => bad_request().await,
+        },
+        "/admin/new/player" => match req_json::<Value>(req).await {
+            Some(Value::Object(player)) => {
+                let name = player.get("name");
+                if name.is_none() {
+                    return bad_request().await;
+                }
+                let pool = db.clone().lock().unwrap().clone();
+                let mut conn = pool.acquire().await.unwrap();
+                let name = name.unwrap().as_str().unwrap();
+                let _ = sqlx::query!(r#"INSERT INTO players (name) VALUES (?1)"#, name)
+                    .execute(&mut *conn)
+                    .await;
+                ok().await
+            }
+            _ => bad_request().await,
+        },
+        "/admin/delete/player" => match req_json::<Value>(req).await {
+            Some(Value::Object(player)) => {
+                let id = player.get("id");
+                if id.is_none() {
+                    return bad_request().await;
+                }
+                let pool = db.clone().lock().unwrap().clone();
+                let mut conn = pool.acquire().await.unwrap();
+                let id = id.unwrap().as_i64().unwrap();
+                let _ = sqlx::query!(r#"DELETE FROM players WHERE id = ?1"#, id)
+                    .execute(&mut *conn)
+                    .await;
+                ok().await
+            }
+            _ => bad_request().await,
+        },
+        "/admin/edit/vote" => match req_json::<Vote>(req).await {
+            Some(vote) => {
+                if vote.id.is_none() || vote.submit_date.is_none() {
+                    return bad_request().await;
+                }
+                let pool = db.clone().lock().unwrap().clone();
+                let _ = sqlx::query!(
+                    r#"UPDATE votes
+                    SET submit_date = ?1,
+                    plus_player_id = ?2,
+                    plus_nickname = ?3,
+                    plus_reason = ?4,
+                    minus_player_id = ?5,
+                    minus_nickname = ?6,
+                    minus_reason = ?7
+                    WHERE id = ?8"#,
+                    vote.submit_date,
+                    vote.plus_player_id,
+                    vote.plus_nickname,
+                    vote.plus_reason,
+                    vote.minus_player_id,
+                    vote.minus_nickname,
+                    vote.minus_reason,
+                    vote.id
+                )
+                .execute(&pool)
+                .await;
+                ok().await
+            }
+            _ => bad_request().await,
+        },
+        "/admin/delete/vote" => match req_json::<Value>(req).await {
+            Some(Value::Object(vote)) => {
+                let id = vote.get("id");
+                if id.is_none() {
+                    return bad_request().await;
+                }
+                let pool = db.clone().lock().unwrap().clone();
+                let mut conn = pool.acquire().await.unwrap();
+                let id = id.unwrap().as_i64().unwrap();
+                let _ = sqlx::query!(r#"DELETE FROM votes WHERE id = ?1"#, id)
+                    .execute(&mut *conn)
+                    .await;
+                ok().await
+            }
+            _ => bad_request().await,
+        },
+        _ => bad_request().await,
    }
-    not_found().await
 }

 async fn login(
@@ -391,17 +586,11 @@ async fn login(
    let body = req.into_body().collect().await;
    let data: Result<Login, serde_json::Error> = from_reader(body?.aggregate().reader());
    if data.is_err() {
-        return Ok(Response::builder()
-            .status(StatusCode::BAD_REQUEST)
-            .body(Body::Empty)
-            .unwrap());
+        return bad_request().await;
    }
    let data = data.unwrap();
    if !check_username(&data.username) {
-        return Ok(Response::builder()
-            .status(StatusCode::BAD_REQUEST)
-            .body(Body::Empty)
-            .unwrap());
+        return bad_request().await;
    }
    let pool = db.clone().lock().unwrap().clone();
    let result = sqlx::query!(r#"SELECT * FROM users WHERE username=?1"#, data.username)
@@ -415,7 +604,6 @@ async fn login(
                Ok(()) => {
                    let date: DateTime<Utc> = DateTime::from(SystemTime::now());
                    let date = date.checked_add_days(Days::new(7)).unwrap();
-                    // With server side rendering, redirect here to "/"
                    Ok(Response::builder()
                        .header(
                            SET_COOKIE,
@@ -435,16 +623,10 @@ async fn login(
                        .body(Body::Empty)
                        .unwrap())
                }
-                Err(_) => Ok(Response::builder()
-                    .status(StatusCode::BAD_REQUEST)
-                    .body(Body::Empty)
-                    .unwrap()),
+                Err(_) => bad_request().await,
            }
        }
-        Ok(None) => Ok(Response::builder()
-            .status(StatusCode::BAD_REQUEST)
-            .body(Body::Empty)
-            .unwrap()),
+        Ok(None) => bad_request().await,
        Err(_) => Ok(Response::builder()
            .status(StatusCode::INTERNAL_SERVER_ERROR)
            .body(Body::Empty)
@@ -490,7 +672,13 @@ async fn register(
                .hash_password(login.password.as_bytes(), &SaltString::generate(&mut OsRng))
                .unwrap()
                .to_string();
-            let token = Alphanumeric.sample_string(&mut OsRng, 256);
+            let mut token = Alphanumeric.sample_string(&mut OsRng, 256);
+            while let Ok(Some(_)) = sqlx::query!(r#"SELECT id FROM users WHERE token=?1"#, token)
+                .fetch_optional(&mut *conn)
+                .await
+            {
+                token = Alphanumeric.sample_string(&mut OsRng, 256);
+            }
            let result = sqlx::query!(r#"INSERT INTO users ( username, saltyhash, permissions, token) VALUES ( ?1, ?2, ?3, ?4 )"#, login.username, hash, 0, token).execute(&mut *conn).await;
            match result {
                Ok(_) => Ok(Response::builder().body(Body::Empty).unwrap()),
@@ -545,15 +733,12 @@ async fn is_authorised(req: &Request<Incoming>, db: Arc<Mutex<SqlitePool>>, leve
        Ok(Some(user)) => {
            let perm = user.permissions as u8;
            perm >= level
-        },
-        _ => match level {
-            0 => true,
-            _ => false
-        },
+        }
+        _ => matches!(level, 0),
    }
 }

-fn check_username(username: &String) -> bool {
+fn check_username(username: &str) -> bool {
    if username.len() > 21 {
        return false;
    }
@@ -565,7 +750,7 @@ fn check_username(username: &String) -> bool {
    true
 }

-fn check_password(password: &String) -> bool {
+fn check_password(password: &str) -> bool {
    // one symbol, 10 chars min, one capital letter, one number
    if password.len() < 10 {
        return false;
@@ -599,6 +784,16 @@ async fn not_found() -> Result<Response<Body>, Error> {
        .unwrap())
 }

+async fn bad_request() -> Result<Response<Body>, Error> {
+    Ok(Response::builder()
+        .status(StatusCode::BAD_REQUEST)
+        .body(Body::Empty)
+        .unwrap())
+}
+
+async fn ok() -> Result<Response<Body>, Error> {
+    Ok(Response::builder().body(Body::Empty).unwrap())
+}
 async fn req_json<T>(req: Request<Incoming>) -> Option<T>
 where
    T: DeserializeOwned,
--- a/static/css/results.css
+++ b/static/css/results.css
@@ -26,9 +26,8 @@ body {
 }

 .app {
-    margin: auto;
-    margin-bottom: 60px;
-    height: calc(100dvh + 60px);
+    margin: auto auto 60px;
+    height: calc(100% + 60px);
    width: 100%;
    max-width: 500px;
 }
--- a/static/html/admin.html
+++ b/static/html/admin.html
@@ -12,10 +12,18 @@
 <body>
    <div>
        <h1>Users</h1>
+        <p>id, username, permission</p>
        <div id="users"></div>
    </div>
+    <div>
+        <h1>Players</h1>
+        <p>id, name</p>
+        <div id="players"></div>
+    </div>
    <div>
        <h1>Votes</h1>
+        <h3 id="votes_number"></h3>
+        <p>id, submit_date, plus_id, plus_nickname, plus_reason, minus_id, minus_nickname, minus_reason</p>
        <div id="votes"></div>
    </div>
 </body>
--- a/static/html/index.html
+++ b/static/html/index.html
@@ -11,11 +11,12 @@
    <link rel="stylesheet" href="static/css/index.css">
 </head>
 <body>
-    <a href="/login" class="login" id="login">Se connecter</a>
    <div id="app" class="app">
        <h1 id="app_title">Vote +</h1>
        <label for="player_id">Pour qui votes tu?</label>
        <select id="player_id"></select>
+        <label id="other_label" for="other" hidden="hidden">Autre:</label>
+        <input id="other" hidden="hidden">
        <label for="nickname">As-tu un surnom à lui donner?</label>
        <input type="text" id="nickname">
        <label for="reason">Pourquoi votes-tu pour lui?</label>
@@ -35,5 +36,6 @@
        <a href="/results">Résultats</a>
        <a href="/archives">Archives</a>
    </div>
+    <a href="/login" class="login" id="login">Se connecter</a>
 </body>
 </html>
--- a/static/js/admin.js
+++ b/static/js/admin.js
@@ -4,19 +4,120 @@ async function run() {
    let usersDiv = document.getElementById("users");
    for (let i = 0; i < users.length; i++) {
        let item = document.createElement("div");
+        let id = document.createElement("p");
        let username = document.createElement("input");
        let permissions = document.createElement("input");
        let edit = document.createElement("button");
+        let del = document.createElement("button");
        edit.textContent = "Edit";
-        username.value = users[i][0];
-        permissions.value = users[i][1];
+        del.textContent = "Delete";
+        id.textContent = users[i][0];
+        username.value = users[i][1];
+        permissions.value = users[i][2];
        item.style.display = "flex";
-        item.append(username, permissions, edit);
+        item.append(id, username, permissions, edit, del);
        usersDiv.appendChild(item);
+        edit.addEventListener("click", async () => {
+            await fetch("/admin/edit/user", {method: "POST", body: JSON.stringify({"id": users[i][0], "username": username.value, "permissions": parseInt(permissions.value)})});
+            window.location.reload();
+        })
+        del.addEventListener("click", async () => {
+            await fetch("/admin/delete/user", {method:"POST", body: JSON.stringify({"id": users[i][0]})});
+            window.location.reload();
+        })
    }

-// let votes = await fetch("/admin/votes").then(r => r.json());
+    let players = await fetch("/admin/players").then(r => r.json());

+    let playersDiv = document.getElementById("players");
+    for (let i=0; i<players.length; i++) {
+        let item = document.createElement("div");
+        let id = document.createElement("p");
+        let name = document.createElement("input");
+        let edit = document.createElement("button");
+        let del = document.createElement("button");
+        edit.textContent = "Edit";
+        del.textContent = "Delete";
+        id.textContent = players[i]["id"];
+        name.value = players[i]["name"];
+        item.style.display = "flex";
+        item.append(id, name, edit, del);
+        playersDiv.appendChild(item);
+        edit.addEventListener("click", async () => {
+            await fetch("/admin/edit/player", {method: "POST", body: JSON.stringify({"id": players[i]["id"], "name": name.value})});
+            window.location.reload();
+        })
+        del.addEventListener("click", async () => {
+            await fetch("/admin/delete/player", {method:"POST", body: JSON.stringify({"id": players[i]["id"]})});
+            window.location.reload();
+        })
+    }
+    let newPlayer = document.createElement("button");
+    newPlayer.textContent = "Add Player";
+    newPlayer.addEventListener("click", () => {
+        let item = document.createElement("div");
+        let name = document.createElement("input");
+        let save = document.createElement("button");
+        save.textContent = "Save";
+        item.append(name, save);
+        playersDiv.appendChild(item);
+        save.addEventListener("click", async () => {
+            await fetch("/admin/new/player", {method:"POST", body: JSON.stringify({"name": name.value})})
+            window.location.reload();
+        })
+    })
+    playersDiv.parentNode.append(newPlayer);
+
+    let votes = await fetch("/admin/votes").then(r => r.json());
+    let today = document.getElementById("votes_number");
+    let count = await fetch("/data/votes").then(r => r.json());
+    today.textContent = `Aujourd'hui il y a ${count.length} votes`;
+    let votesDiv = document.getElementById("votes");
+
+    for (let i=0; i<votes.length; i++) {
+        let vote = votes[i];
+        let item = document.createElement("div");
+        item.style.display = "flex";
+        let id = document.createElement("p");
+        id.textContent = vote["id"];
+        let submit_date = document.createElement("input");
+        submit_date.value = vote["submit_date"];
+        let plus_id = document.createElement("input");
+        plus_id.type = "number";
+        plus_id.value = vote["plus_player_id"];
+        let plus_nickname = document.createElement("input");
+        plus_nickname.value = vote["plus_nickname"];
+        let plus_reason = document.createElement("input");
+        plus_reason.value = vote["plus_reason"];
+        let minus_id = document.createElement("input");
+        minus_id.type = "number";
+        minus_id.value = vote["minus_player_id"];
+        let minus_nickname = document.createElement("input");
+        minus_nickname.value = vote["minus_nickname"];
+        let minus_reason = document.createElement("input");
+        minus_reason.value = vote["minus_reason"];
+        let edit = document.createElement("button");
+        edit.textContent = "Edit";
+        let del = document.createElement("button");
+        del.textContent = "Delete";
+        item.append(id,submit_date,plus_id,plus_nickname,plus_reason,minus_id,minus_nickname,minus_reason, edit, del);
+        votesDiv.append(item);
+        edit.addEventListener("click", async () => {
+            await fetch("/admin/edit/vote", {method: "POST", body: JSON.stringify({"id": votes[i]["id"],
+                    "submit_date": submit_date.value,
+                    "plus_player_id": parseInt(plus_id.value),
+                    "plus_nickname": plus_nickname.value,
+                    "plus_reason": plus_reason.value,
+                    "minus_player_id": parseInt(minus_id.value),
+                    "minus_nickname": minus_nickname.value,
+                    "minus_reason": minus_reason.value})});
+            window.location.reload();
+        })
+        del.addEventListener("click", async () => {
+            await fetch("/admin/delete/vote", {method:"POST", body: JSON.stringify({"id": votes[i]["id"]})});
+            window.location.reload();
+        })
+    }
 }

 let _ = run();
--- a/static/js/index.js
+++ b/static/js/index.js
@@ -1,4 +1,5 @@
 let vote = {
+    submit_date: null,
    plus_player_id: null,
    plus_nickname: "",
    plus_reason: "",
@@ -11,7 +12,7 @@ let current_page = 0;

 async function main() {
    if (read_cookie()) {
-        showMessage("Merci pour ton vote!", "Ton vote a bien été prit en compte.", false, "info");
+        showMessage("Merci pour ton vote!", "Ton vote a bien été pris en compte.", false, "info");
        return;
    }
    let players = await fetch("/data/players").then(r => r.json());
@@ -24,10 +25,25 @@ async function main() {
        option.textContent = x["name"];
        select.append(option);
    })
+    let other = document.createElement("option");
+    other.value = "other";
+    other.textContent = "Autre";
+    select.append(other);
    select.value = null;
    nickname.value = "";
    reason.value = "";
    select.addEventListener("change", () => {
+        if (select.value === "other") {
+            let other = document.getElementById("other");
+            other.hidden = false;
+            let otherLabel = document.getElementById("other_label");
+            otherLabel.hidden = false;
+        } else {
+            let other = document.getElementById("other");
+            other.hidden = true;
+            let otherLabel = document.getElementById("other_label");
+            otherLabel.hidden = true;
+        }
        if (current_page) {
            vote.minus_player_id = parseInt(select.value);
        } else {
@@ -59,11 +75,27 @@ async function main() {
                    true, "warning");
                return;
            }
+            if (select.value === "other") {
+                let otherInput = document.getElementById("other");
+                if (otherInput.value === "") {
+                    showMessage("Tu as sélectionné autre mais tu n'as pas donné de nom", "N'oublie pas de soit sélectioner une personne ou de mettre un nom dans ''Autre:''.", true, "warning");
+                    return;
+                }
+                let otherInputLabel = document.getElementById("other_label");
+                let player = await fetch("/player", {method: "post", body: JSON.stringify({"name": otherInput.value})}).then(r => r.json());
+                let option = document.createElement("option");
+                option.value = player["id"];
+                option.textContent = player["name"];
+                select.insertBefore(option, other);
+                vote.minus_player_id = parseInt(player["id"]);
+                otherInput.value = "";
+                otherInput.hidden = true;
+                otherInputLabel.hidden = true;
+            }
            if (await fetch("/vote", {
                method: "post", body: JSON.stringify(vote)
            })
                .then(r => r.status) === 200) {
-                set_cookie();
                showMessage("Merci pour ton vote!", "Ton vote a bien été pris en compte.", false, "info");
            }
            console.log(vote);
@@ -76,6 +108,23 @@ async function main() {
            }
            rightButton.textContent = "À voté!";
            title.textContent = "Vote -";
+            if (select.value === "other") {
+                let otherInput = document.getElementById("other");
+                if (otherInput.value === "") {
+                    showMessage("Tu as sélectionné autre mais tu n'as pas donné de nom", "N'oublie pas de soit sélectioner une personne ou de mettre un nom dans ''Autre:''.", true, "warning");
+                    return;
+                }
+                let otherInputLabel = document.getElementById("other_label");
+                let player = await fetch("/player", {method: "post", body: JSON.stringify({"name": otherInput.value})}).then(r => r.json());
+                let option = document.createElement("option");
+                option.value = player["id"];
+                option.textContent = player["name"];
+                select.insertBefore(option, other);
+                vote.plus_player_id = parseInt(player["id"]);
+                otherInput.value = "";
+                otherInput.hidden = true;
+                otherInputLabel.hidden = true;
+            }
            current_page = 1;
            leftButton.hidden = false;
            select.value = vote.minus_player_id;
@@ -111,14 +160,6 @@ function showMessage(title, description, canBeDismissed, type) {
    })
 }

-function set_cookie() {
-    let date = new Date(Date.now());
-    date.setDate(date.getDate() + 1);
-    date.setHours(0, 0,0);
-    console.log(date);
-    document.cookie = `hasvoted=true; expires=${date.toUTCString()}; path=/`;
-}
-
 function read_cookie() {
    return document.cookie.includes("hasvoted=true");
 }
--- a/static/js/results.js
+++ b/static/js/results.js
@@ -23,7 +23,12 @@ function show_plus(id, votes, players) {
    const app = document.getElementById("app");
    app.innerHTML = "";
    let vote = votes[id];
-    let player = players[vote["plus_player_id"] - 1]["name"];
+    let player = "?";
+    for (let i = 0; i < players.length; i++) {
+        if (players[i].id === vote["plus_player_id"]) {
+            player = players[i]["name"];
+        }
+    }
    let nickname = vote["plus_nickname"];
    let reason = vote["plus_reason"];
    let minus = document.createElement("button");
@@ -58,7 +63,12 @@ function show_minus(id, votes, players) {
    let vote = votes[id];
    let nickname = vote["minus_nickname"];
    let reason = vote["minus_reason"];
-    let player = players[vote["minus_player_id"] - 1]["name"];
+    let player = "?";
+    for (let i = 0; i < players.length; i++) {
+        if (players[i].id === vote["minus_player_id"]) {
+            player = players[i]["name"];
+        }
+    }
    let next = document.createElement("button");
    if (id === votes.length - 1) {
        next.textContent = "Résultats";
@@ -112,7 +122,12 @@ async function show_results(players) {
    let counter = 0;
    for (let i = 0; i < plus.length; i++) {
        let p = plus[i];
-        let player = players[p[0] - 1]["name"];
+        let player = "?";
+        for (let i = 0; i < players.length; i++) {
+            if (players[i].id === p[0]) {
+                player = players[i]["name"];
+            }
+        }
        let score = p[1];
        if (prev_score == null || score < prev_score) {
            counter += 1;
@@ -134,7 +149,12 @@ async function show_results(players) {
    counter = 0;
    for (let i = 0; i < minus.length; i++) {
        let p = minus[i];
-        let player = players[p[0] - 1]["name"];
+        let player = "?";
+        for (let i = 0; i < players.length; i++) {
+            if (players[i].id === p[0]) {
+                player = players[i]["name"];
+            }
+        }
        let score = p[1];
        if (prev_score == null || score < prev_score) {
            counter += 1;
Author	SHA1	Message	Date
AINDUSTRIES	cbaf52256d	Remove unused import	2024-10-05 15:52:59 +02:00
AINDUSTRIES	8a7c321044	Fixed bug related to new Vote struct, id and submit date can be None (useful for posting new votes, ie without id and submit date)	2024-10-05 15:09:51 +02:00
AINDUSTRIES	98dbcd11f1	Added submit date to votes	2024-10-05 15:08:41 +02:00
AINDUSTRIES	c07a304562	Votes div remains to have date displayed per vote	2024-10-04 22:49:51 +02:00
AINDUSTRIES	92c067c9ed	small fixes (if player not exsits show ?)	2024-10-04 22:49:00 +02:00
AINDUSTRIES	164184e5e9	user can add player while voting	2024-10-04 21:00:53 +02:00
AINDUSTRIES	9c8e8beaa6	user can add player while voting	2024-10-04 21:00:43 +02:00
AINDUSTRIES	28b2411ceb	user can add player	2024-10-04 17:28:20 +02:00
AINDUSTRIES	fb28221875	added check for token generation (look if exists) (better)	2024-10-04 17:17:46 +02:00
AINDUSTRIES	cd1632b533	added check for token generation (look if exists)	2024-10-04 17:15:59 +02:00
AINDUSTRIES	01c8248313	bug fix: ids can be wrong if players added/deleted	2024-10-04 17:05:39 +02:00
AINDUSTRIES	5a13cf9214	administration done (minimalistic)	2024-10-04 17:05:10 +02:00