rowt/src/tera/ergo.rs

use std::env;

use chrono::Utc;
use rocket::{
    form::Form,
    fs::TempFile,
    get,
    http::ContentType,
    post,
    request::FlashMessage,
    response::{Flash, Redirect},
    routes, FromForm, Route, State,
};
use rocket_dyn_templates::{context, Template};
use serde::Serialize;
use sqlx::SqlitePool;
use tera::Context;

use crate::model::{
    log::Log,
    user::{AdminUser, User, UserWithDetails},
};

#[derive(Serialize)]
struct ErgoStat {
    id: i64,
    name: String,
    dob: Option<String>,
    weight: Option<String>,
    sex: Option<String>,
    result: Option<String>,
}

#[get("/final")]
async fn send(db: &State<SqlitePool>, _user: AdminUser) -> Template {
    let thirty = sqlx::query_as!(
        ErgoStat,
        "SELECT id, name, dirty_thirty as result, dob, weight, sex FROM user WHERE deleted = 0 AND dirty_thirty is not null ORDER BY result DESC"
    )
    .fetch_all(db.inner())
    .await
    .unwrap();

    let dozen= sqlx::query_as!(
        ErgoStat,
        "SELECT id, name, dirty_dozen as result, dob, weight, sex FROM user WHERE deleted = 0 AND dirty_dozen is not null ORDER BY result DESC"
    )
    .fetch_all(db.inner())
    .await
    .unwrap();

    Template::render(
        "ergo.final",
        context!(loggedin_user: &UserWithDetails::from_user(_user.user, db).await, thirty, dozen),
    )
}

#[get("/reset")]
async fn reset(db: &State<SqlitePool>, _user: AdminUser) -> Flash<Redirect> {
    sqlx::query!("UPDATE user SET dirty_thirty = NULL, dirty_dozen = NULL;")
        .execute(db.inner())
        .await
        .unwrap();

    Flash::success(
        Redirect::to("/ergo"),
        "Erfolgreich zurückgesetzt (Bilder müssen manuell gelöscht werden!)",
    )
}

#[get("/<challenge>/user/<user_id>/new?<new>")]
async fn update(
    db: &State<SqlitePool>,
    _admin: AdminUser,
    challenge: &str,
    user_id: i64,
    new: &str,
) -> Flash<Redirect> {
    if challenge == "thirty" {
        sqlx::query!("UPDATE user SET dirty_thirty = ? WHERE id=?", new, user_id)
            .execute(db.inner())
            .await
            .unwrap();
        Flash::success(Redirect::to("/ergo"), "Succ")
    } else if challenge == "dozen" {
        sqlx::query!("UPDATE user SET dirty_dozen = ? WHERE id=?", new, user_id)
            .execute(db.inner())
            .await
            .unwrap();
        Flash::success(Redirect::to("/ergo"), "Succ")
    } else {
        Flash::error(
            Redirect::to("/ergo"),
            "Challenge not found (should be thirty or dozen)",
        )
    }
}

#[get("/")]
async fn index(db: &State<SqlitePool>, user: User, flash: Option<FlashMessage<'_>>) -> Template {
    let users = User::ergo(db).await;

    let thirty = sqlx::query_as!(
        ErgoStat,
        "SELECT id, name, dirty_thirty as result, dob, weight, sex  FROM user WHERE deleted = 0 AND dirty_thirty is not null ORDER BY result DESC"
    )
    .fetch_all(db.inner())
    .await
    .unwrap();

    let dozen= sqlx::query_as!(
        ErgoStat,
        "SELECT id, name, dirty_dozen as result, dob, weight, sex  FROM user WHERE deleted = 0 AND dirty_dozen is not null ORDER BY result DESC"
    )
    .fetch_all(db.inner())
    .await
    .unwrap();

    let mut context = Context::new();
    if let Some(msg) = flash {
        context.insert("flash", &msg.into_inner());
    }
    context.insert("loggedin_user", &UserWithDetails::from_user(user, db).await);
    context.insert("users", &users);
    context.insert("thirty", &thirty);
    context.insert("dozen", &dozen);

    Template::render("ergo", context.into_json())
}

#[derive(FromForm, Debug)]
pub struct ErgoToAdd<'a> {
    user: i64,
    result: String,
    proof: TempFile<'a>,
}

#[post("/thirty", data = "<data>", format = "multipart/form-data")]
async fn new_thirty(
    db: &State<SqlitePool>,
    mut data: Form<ErgoToAdd<'_>>,
    created_by: User,
) -> Flash<Redirect> {
    let user = User::find_by_id(db, data.user as i32).await.unwrap();

    let extension = if data.proof.content_type() == Some(&ContentType::JPEG) {
        "jpg"
    } else {
        return Flash::error(Redirect::to("/ergo"), "Es werden nur JPG Bilder akzeptiert");
    };
    let base_dir = env::current_dir().unwrap();
    let file_path = base_dir.join(format!(
        "data-ergo/thirty/{}_{}.{extension}",
        user.name,
        Utc::now()
    ));
    if let Err(e) = data.proof.move_copy_to(file_path).await {
        eprintln!("Failed to persist file: {:?}", e);
    }

    sqlx::query!(
        "UPDATE user SET dirty_thirty = ? where id = ?",
        data.result,
        data.user
    )
    .execute(db.inner())
    .await
    .unwrap(); //Okay, because we can only create a User of a valid id

    Log::create(
        db,
        format!("{} created thirty-ergo entry: {data:?}", created_by.name),
    )
    .await;

    Flash::success(Redirect::to("/ergo"), "Erfolgreich eingetragen")
}

#[post("/dozen", data = "<data>", format = "multipart/form-data")]
async fn new_dozen(
    db: &State<SqlitePool>,
    mut data: Form<ErgoToAdd<'_>>,
    created_by: User,
) -> Flash<Redirect> {
    let user = User::find_by_id(db, data.user as i32).await.unwrap();

    let extension = if data.proof.content_type() == Some(&ContentType::JPEG) {
        "jpg"
    } else {
        return Flash::error(Redirect::to("/ergo"), "Es werden nur JPG Bilder akzeptiert");
    };
    let base_dir = env::current_dir().unwrap();
    let file_path = base_dir.join(format!(
        "data-ergo/dozen/{}_{}.{extension}",
        user.name,
        Utc::now()
    ));
    if let Err(e) = data.proof.move_copy_to(file_path).await {
        eprintln!("Failed to persist file: {:?}", e);
    }

    sqlx::query!(
        "UPDATE user SET dirty_dozen = ? where id = ?",
        data.result,
        data.user
    )
    .execute(db.inner())
    .await
    .unwrap(); //Okay, because we can only create a User of a valid id

    Log::create(
        db,
        format!("{} created dozen-ergo entry: {data:?}", created_by.name),
    )
    .await;

    Flash::success(Redirect::to("/ergo"), "Erfolgreich eingetragen")
}

pub fn routes() -> Vec<Route> {
    routes![index, new_thirty, new_dozen, send, reset, update]
}

#[cfg(test)]
mod test {}