rename subfolder

src/tera/admin/mod.rs

@@ -0,0 +1,23 @@
+use rocket::{get, routes, Route, State};
+use sqlx::SqlitePool;
+
+use crate::{model::log::Log, tera::Config};
+
+pub mod planned_event;
+pub mod user;
+
+#[get("/rss?<key>")]
+async fn rss(db: &State<SqlitePool>, key: Option<&str>, config: &State<Config>) -> String {
+    match key {
+        Some(key) if key.eq(&config.rss_key) => Log::generate_feed(db).await,
+        _ => "Not allowed".to_string(),
+    }
+}
+
+pub fn routes() -> Vec<Route> {
+    let mut ret = Vec::new();
+    ret.append(&mut user::routes());
+    ret.append(&mut planned_event::routes());
+    ret.append(&mut routes![rss]);
+    ret
+}

src/tera/admin/planned_event.rs

@@ -0,0 +1,104 @@
+use rocket::{
+    form::Form,
+    get, post, put,
+    response::{Flash, Redirect},
+    routes, FromForm, Route, State,
+};
+use sqlx::SqlitePool;
+
+use crate::model::{planned_event::PlannedEvent, tripdetails::TripDetails, user::AdminUser};
+
+//TODO: add constraints (e.g. planned_amount_cox > 0)
+#[derive(FromForm)]
+struct AddPlannedEventForm<'r> {
+    day: &'r str,
+    name: &'r str,
+    planned_amount_cox: i32,
+    allow_guests: bool,
+    planned_starting_time: &'r str,
+    max_people: i32,
+    always_show: bool,
+    notes: Option<&'r str>,
+    trip_type: Option<i64>,
+}
+
+#[post("/planned-event", data = "<data>")]
+async fn create(
+    db: &State<SqlitePool>,
+    data: Form<AddPlannedEventForm<'_>>,
+    _admin: AdminUser,
+) -> Flash<Redirect> {
+    let trip_details_id = TripDetails::create(
+        db,
+        data.planned_starting_time,
+        data.max_people,
+        data.day,
+        data.notes,
+        data.allow_guests,
+        data.trip_type,
+    )
+    .await;
+
+    let trip_details = TripDetails::find_by_id(db, trip_details_id).await.unwrap(); //Okay, bc. we
+                                                                                    //just created
+                                                                                    //the object
+
+    PlannedEvent::create(
+        db,
+        data.name,
+        data.planned_amount_cox,
+        data.always_show,
+        trip_details,
+    )
+    .await;
+
+    Flash::success(Redirect::to("/"), "Successfully planned the event")
+}
+
+//TODO: add constraints (e.g. planned_amount_cox > 0)
+#[derive(FromForm)]
+struct UpdatePlannedEventForm<'r> {
+    id: i64,
+    planned_amount_cox: i32,
+    max_people: i32,
+    notes: Option<&'r str>,
+    always_show: bool,
+}
+
+#[put("/planned-event", data = "<data>")]
+async fn update(
+    db: &State<SqlitePool>,
+    data: Form<UpdatePlannedEventForm<'_>>,
+    _admin: AdminUser,
+) -> Flash<Redirect> {
+    match PlannedEvent::find_by_id(db, data.id).await {
+        Some(planned_event) => {
+            planned_event
+                .update(
+                    db,
+                    data.planned_amount_cox,
+                    data.max_people,
+                    data.notes,
+                    data.always_show,
+                )
+                .await;
+            Flash::success(Redirect::to("/"), "Successfully edited the event")
+        }
+        None => Flash::error(Redirect::to("/"), "Planned event id not found"),
+    }
+}
+
+#[get("/planned-event/<id>/delete")]
+async fn delete(db: &State<SqlitePool>, id: i64, _admin: AdminUser) -> Flash<Redirect> {
+    match PlannedEvent::find_by_id(db, id).await {
+        Some(planned_event) => {
+            planned_event.delete(db).await;
+            Flash::success(Redirect::to("/"), "Successfully deleted the event")
+        }
+        None => Flash::error(Redirect::to("/"), "PlannedEvent does not exist"),
+    }
+}
+
+pub fn routes() -> Vec<Route> {
+    routes![create, delete, update]
+}

src/tera/admin/user.rs

@@ -0,0 +1,112 @@
+use crate::model::user::{AdminUser, User};
+use rocket::{
+    form::Form,
+    get, post,
+    request::FlashMessage,
+    response::{Flash, Redirect},
+    routes, FromForm, Route, State,
+};
+use rocket_dyn_templates::{tera::Context, Template};
+use sqlx::SqlitePool;
+
+#[get("/user")]
+async fn index(
+    db: &State<SqlitePool>,
+    admin: AdminUser,
+    flash: Option<FlashMessage<'_>>,
+) -> Template {
+    let users = User::all(db).await;
+
+    let mut context = Context::new();
+    if let Some(msg) = flash {
+        context.insert("flash", &msg.into_inner());
+    }
+    context.insert("users", &users);
+    context.insert("loggedin_user", &admin.user);
+
+    Template::render("admin/user/index", context.into_json())
+}
+
+#[get("/user/<user>/reset-pw")]
+async fn resetpw(db: &State<SqlitePool>, _admin: AdminUser, user: i32) -> Flash<Redirect> {
+    let user = User::find_by_id(db, user).await;
+    match user {
+        Some(user) => {
+            user.reset_pw(db).await;
+            Flash::success(
+                Redirect::to("/admin/user"),
+                format!("Successfully reset pw of {}", user.name),
+            )
+        }
+        None => Flash::error(Redirect::to("/admin/user"), "User does not exist"),
+    }
+}
+
+#[get("/user/<user>/delete")]
+async fn delete(db: &State<SqlitePool>, _admin: AdminUser, user: i32) -> Flash<Redirect> {
+    let user = User::find_by_id(db, user).await;
+    match user {
+        Some(user) => {
+            user.delete(db).await;
+            Flash::success(
+                Redirect::to("/admin/user"),
+                format!("Sucessfully deleted user {}", user.name),
+            )
+        }
+        None => Flash::error(Redirect::to("/admin/user"), "User does not exist"),
+    }
+}
+
+#[derive(FromForm)]
+struct UserEditForm {
+    id: i32,
+    is_guest: bool,
+    is_cox: bool,
+    is_admin: bool,
+}
+
+#[post("/user", data = "<data>")]
+async fn update(
+    db: &State<SqlitePool>,
+    data: Form<UserEditForm>,
+    _admin: AdminUser,
+) -> Flash<Redirect> {
+    let user = User::find_by_id(db, data.id).await;
+    let Some(user) = user else {
+            return Flash::error(
+                Redirect::to("/admin/user"),
+                format!("User with ID {} does not exist!", data.id),
+            )
+    };
+
+    user.update(db, data.is_cox, data.is_admin, data.is_guest)
+        .await;
+
+    Flash::success(Redirect::to("/admin/user"), "Successfully updated user")
+}
+
+#[derive(FromForm)]
+struct UserAddForm<'r> {
+    name: &'r str,
+    is_guest: bool,
+}
+
+#[post("/user/new", data = "<data>")]
+async fn create(
+    db: &State<SqlitePool>,
+    data: Form<UserAddForm<'_>>,
+    _admin: AdminUser,
+) -> Flash<Redirect> {
+    if User::create(db, data.name, data.is_guest).await {
+        Flash::success(Redirect::to("/admin/user"), "Successfully created user")
+    } else {
+        Flash::error(
+            Redirect::to("/admin/user"),
+            format!("User {} already exists", data.name),
+        )
+    }
+}
+
+pub fn routes() -> Vec<Route> {
+    routes![index, resetpw, update, create, delete]
+}