rowt/src/rest/mod.rs

use chrono::{Duration, Local};
use rocket::{
    catch, catchers, get,
    request::FlashMessage,
    response::{Flash, Redirect},
    routes, Build, Rocket, State,
};
use rocket_dyn_templates::{context, tera::Context, Template};
use sqlx::SqlitePool;

use crate::model::{planned_event::PlannedEvent, user::User, usertrip::UserTrip, Day};

mod admin;
mod auth;
mod cox;

#[get("/")]
async fn index(db: &State<SqlitePool>, user: User, flash: Option<FlashMessage<'_>>) -> Template {
    let mut days = Vec::new();
    for i in 0..6 {
        let date = (Local::now() + Duration::days(i)).date_naive();
        days.push(Day::new(db, date).await);
    }

    let mut context = Context::new();

    if let Some(msg) = flash {
        context.insert("flash", &msg.into_inner());
    }
    context.insert("loggedin_user", &user);
    context.insert("days", &days);
    Template::render("index", context.into_json())
}

#[get("/join/<trip_details_id>")]
async fn join(db: &State<SqlitePool>, trip_details_id: i64, user: User) -> Flash<Redirect> {
    if !PlannedEvent::rower_can_register(db, trip_details_id).await {
        return Flash::error(Redirect::to("/"), "Bereits ausgebucht!");
    }

    if UserTrip::new(db, user.id, trip_details_id).await {
        Flash::success(Redirect::to("/"), "Erfolgreich angemeldet!")
    } else {
        Flash::error(Redirect::to("/"), "Du nimmst bereits teil!")
    }
}

#[get("/remove/<trip_details_id>")]
async fn remove(db: &State<SqlitePool>, trip_details_id: i64, user: User) -> Flash<Redirect> {
    //TODO: Check if > 2 hrs to event

    UserTrip::delete(db, user.id, trip_details_id).await;

    Flash::success(Redirect::to("/"), "Erfolgreich abgemeldet!")
}

#[catch(401)] //unauthorized
fn unauthorized_error() -> Redirect {
    Redirect::to("/auth")
}

pub fn start(db: SqlitePool) -> Rocket<Build> {
    rocket::build()
        .manage(db)
        .mount("/", routes![index, join, remove])
        .mount("/auth", auth::routes())
        .mount("/cox", cox::routes())
        .mount("/admin", admin::routes())
        .register("/", catchers![unauthorized_error])
        .attach(Template::fairing())
}

#[cfg(test)]
mod test {
    use crate::testdb;

    use super::start;
    use rocket::http::Status;
    use rocket::local::asynchronous::Client;
    use rocket::uri;
    use sqlx::SqlitePool;

    #[sqlx::test]
    fn test_not_logged_in() {
        let pool = testdb!();

        let client = Client::tracked(start(pool))
            .await
            .expect("valid rocket instance");
        let response = client.get(uri!(super::index)).dispatch().await;

        assert_eq!(response.status(), Status::SeeOther);
        let location = response.headers().get("Location").next().unwrap();
        assert_eq!(location, "/auth");
    }
}