migration.sql

@@ -140,13 +140,3 @@ CREATE TABLE IF NOT EXISTS "boat_damage" (
 	"verified_at" datetime,
 	"lock_boat" boolean not null default false -- if true: noone can use the boat 
 );
-
-CREATE TABLE IF NOT EXISTS "boathouse" (
-    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
-    "boat_id" INTEGER NOT NULL REFERENCES boat(id),
-    "aisle" TEXT NOT NULL CHECK (aisle in ('water', 'middle', 'mountain')),
-    "side" TEXT NOT NULL CHECK(side IN ('mountain', 'water')),
-    "level" INTEGER NOT NULL CHECK(level BETWEEN 0 AND 3),
-    CONSTRAINT unq UNIQUE (aisle, side, level) -- only 1 boat allowed to rest at each space 
-);
-

src/model/boat.rs

@@ -181,41 +181,6 @@ ORDER BY amount_seats DESC
         Self::boats_to_details(db, boats).await
     }
 
-    pub async fn all_for_boatshouse(db: &SqlitePool) -> Vec<BoatWithDetails> {
-        let boats = sqlx::query_as!(
-            Boat,
-            "
-SELECT 
-    b.id, 
-    b.name, 
-    b.amount_seats, 
-    b.location_id, 
-    b.owner, 
-    b.year_built, 
-    b.boatbuilder, 
-    b.default_shipmaster_only_steering, 
-    b.default_destination, 
-    b.skull, 
-    b.external
-FROM 
-    boat AS b
-LEFT JOIN 
-    boathouse AS bh ON b.id = bh.boat_id
-WHERE 
-    b.external = false 
-    AND b.location_id = (SELECT id FROM location WHERE name = 'Linz')
-    AND bh.id IS NULL -- This ensures the boat does not have an entry in the boathouse table
-ORDER BY 
-    b.name DESC;
-        "
-        )
-        .fetch_all(db)
-        .await
-        .unwrap(); //TODO: fixme
-
-        Self::boats_to_details(db, boats).await
-    }
-
     pub async fn for_user(db: &SqlitePool, user: &User) -> Vec<BoatWithDetails> {
         if user.has_role(db, "admin").await {
             return Self::all(db).await;

src/model/boathouse.rs

@@ -1,90 +0,0 @@
-use std::collections::HashMap;
-
-use rocket::serde::{Deserialize, Serialize};
-use sqlx::{FromRow, SqlitePool};
-
-use crate::tera::board::boathouse::FormBoathouseToAdd;
-
-use super::boat::Boat;
-
-#[derive(FromRow, Debug, Serialize, Deserialize)]
-pub struct Boathouse {
-    pub id: i64,
-    pub boat_id: i64,
-    pub aisle: String,
-    pub side: String,
-    pub level: i64,
-}
-
-impl Boathouse {
-    pub async fn get(db: &SqlitePool) -> HashMap<&str, HashMap<&str, [Option<(i64, Boat)>; 4]>> {
-        let mut ret: HashMap<&str, HashMap<&str, [Option<(i64, Boat)>; 4]>> = HashMap::new();
-
-        let mut mountain = HashMap::new();
-        mountain.insert("mountain", [None, None, None, None]);
-        mountain.insert("water", [None, None, None, None]);
-        ret.insert("mountain-aisle", mountain);
-
-        let mut middle = HashMap::new();
-        middle.insert("mountain", [None, None, None, None]);
-        middle.insert("water", [None, None, None, None]);
-        ret.insert("middle-aisle", middle);
-
-        let mut water = HashMap::new();
-        water.insert("mountain", [None, None, None, None]);
-        water.insert("water", [None, None, None, None]);
-        ret.insert("water-aisle", water);
-
-        let boathouses = sqlx::query_as!(
-            Boathouse,
-            "SELECT id, boat_id, aisle, side, level FROM boathouse"
-        )
-        .fetch_all(db)
-        .await
-        .unwrap(); //TODO: fixme
-
-        for boathouse in boathouses {
-            let aisle = ret
-                .get_mut(format!("{}-aisle", boathouse.aisle).as_str())
-                .unwrap();
-            let side = aisle.get_mut(boathouse.side.as_str()).unwrap();
-
-            side[boathouse.level as usize] = Some((
-                boathouse.id,
-                Boat::find_by_id(db, boathouse.boat_id as i32)
-                    .await
-                    .unwrap(),
-            ));
-        }
-
-        ret
-    }
-
-    pub async fn create(db: &SqlitePool, data: FormBoathouseToAdd) -> Result<(), String> {
-        sqlx::query!(
-            "INSERT INTO boathouse(boat_id, aisle, side, level) VALUES (?,?,?,?)",
-            data.boat_id,
-            data.aisle,
-            data.side,
-            data.level
-        )
-        .execute(db)
-        .await
-        .map_err(|e| e.to_string())?;
-        Ok(())
-    }
-
-    pub async fn find_by_id(db: &SqlitePool, id: i32) -> Option<Self> {
-        sqlx::query_as!(Self, "SELECT * FROM boathouse WHERE id like ?", id)
-            .fetch_one(db)
-            .await
-            .ok()
-    }
-
-    pub async fn delete(&self, db: &SqlitePool) {
-        sqlx::query!("DELETE FROM boathouse WHERE id=?", self.id)
-            .execute(db)
-            .await
-            .unwrap(); //Okay, because we can only create a Boat of a valid id
-    }
-}

src/model/mod.rs

@@ -9,7 +9,6 @@ use self::{
 
 pub mod boat;
 pub mod boatdamage;
-pub mod boathouse;
 pub mod family;
 pub mod location;
 pub mod log;

src/tera/board/boathouse.rs

@@ -1,85 +0,0 @@
-use crate::model::{
-    boat::Boat,
-    boathouse::Boathouse,
-    user::{AdminUser, UserWithRoles, VorstandUser},
-};
-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("/boathouse")]
-async fn index(
-    db: &State<SqlitePool>,
-    admin: VorstandUser,
-    flash: Option<FlashMessage<'_>>,
-) -> Template {
-    let mut context = Context::new();
-    if let Some(msg) = flash {
-        context.insert("flash", &msg.into_inner());
-    }
-
-    let boats = Boat::all_for_boatshouse(db).await;
-    context.insert("boats", &boats);
-
-    let boathouse = Boathouse::get(db).await;
-    context.insert("boathouse", &boathouse);
-
-    context.insert(
-        "loggedin_user",
-        &UserWithRoles::from_user(admin.into(), db).await,
-    );
-
-    Template::render("board/boathouse", context.into_json())
-}
-
-#[derive(FromForm)]
-pub struct FormBoathouseToAdd {
-    pub boat_id: i32,
-    pub aisle: String,
-    pub side: String,
-    pub level: i32,
-}
-#[post("/boathouse", data = "<data>")]
-async fn new<'r>(
-    db: &State<SqlitePool>,
-    data: Form<FormBoathouseToAdd>,
-    _admin: AdminUser,
-) -> Flash<Redirect> {
-    match Boathouse::create(db, data.into_inner()).await {
-        Ok(_) => Flash::success(Redirect::to("/board/boathouse"), "Boot hinzugefügt"),
-        Err(e) => Flash::error(Redirect::to("/board/boathouse"), e),
-    }
-}
-
-#[get("/boathouse/<boathouse_id>/delete")]
-async fn delete(db: &State<SqlitePool>, _admin: AdminUser, boathouse_id: i32) -> Flash<Redirect> {
-    let boat = Boathouse::find_by_id(db, boathouse_id).await;
-    match boat {
-        Some(boat) => {
-            boat.delete(db).await;
-            Flash::success(Redirect::to("/board/boathouse"), "Bootsplatz gelöscht")
-        }
-        None => Flash::error(Redirect::to("/board/boathouse"), "Boatplace does not exist"),
-    }
-}
-//#[post("/boat/new", data = "<data>")]
-//async fn create(
-//    db: &State<SqlitePool>,
-//    data: Form<BoatToAdd<'_>>,
-//    _admin: AdminUser,
-//) -> Flash<Redirect> {
-//    match Boat::create(db, data.into_inner()).await {
-//        Ok(_) => Flash::success(Redirect::to("/admin/boat"), "Boot hinzugefügt"),
-//        Err(e) => Flash::error(Redirect::to("/admin/boat"), e),
-//    }
-//}
-
-pub fn routes() -> Vec<Route> {
-    routes![index, new, delete]
-}

src/tera/board/mod.rs

@@ -1,9 +0,0 @@
-use rocket::Route;
-
-pub mod boathouse;
-
-pub fn routes() -> Vec<Route> {
-    let mut ret = Vec::new();
-    ret.append(&mut boathouse::routes());
-    ret
-}

src/tera/mod.rs

@@ -21,7 +21,6 @@ use crate::model::user::{User, UserWithRoles};
 
 pub(crate) mod admin;
 mod auth;
-pub(crate) mod board;
 mod boatdamage;
 mod cox;
 mod ergo;
@@ -90,7 +89,6 @@ pub fn config(rocket: Rocket<Build>) -> Rocket<Build> {
         .mount("/boatdamage", boatdamage::routes())
         .mount("/cox", cox::routes())
         .mount("/admin", admin::routes())
-        .mount("/board", board::routes())
         .mount("/", misc::routes())
         .mount("/public", FileServer::from("static/"))
         .register("/", catchers![unauthorized_error, forbidden_error])

staging-diff.sql

@@ -1,9 +0,0 @@
-CREATE TABLE IF NOT EXISTS "boathouse" (
-    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
-    "boat_id" INTEGER NOT NULL REFERENCES boat(id),
-    "aisle" TEXT NOT NULL CHECK (aisle in ('water', 'middle', 'mountain')),
-    "side" TEXT NOT NULL CHECK(side IN ('mountain', 'water')),
-    "level" INTEGER NOT NULL CHECK(level BETWEEN 0 AND 3),
-    CONSTRAINT unq UNIQUE (aisle, side, level) -- only 1 boat allowed to rest at each space 
-);
-

templates/board/boathouse.html.tera

@@ -1,53 +0,0 @@
-{% import "includes/macros" as macros %}
-{% import "includes/forms/log" as log %}
-{% import "includes/forms/boat" as boat %}
-{% extends "base" %}
-{% macro show_place(aisle_name, side_name, level) %}
-    <li>
-        {% set aisle = aisle_name ~ "-aisle" %}
-        {% set place = boathouse[aisle][side_name] %}
-        {% if place[level] %}
-            {{ place[level].1.name }} <a href="/board/boathouse/{{ place[level].0 }}/delete">X</a>
-        {% elif boats | length > 0 %}
-            <details>
-                <summary>Kein Boot</summary>
-                <form action="/board/boathouse" method="post" class="grid gap-3">
-                    {{ macros::select(label="Boot", data=boats, name="boat_id", id="boat_id", display=["name", " (","amount_seats", " x)"], wrapper_class="col-span-4") }}
-                    <input type="hidden" name="aisle" value="{{ aisle_name }}" />
-                    <input type="hidden" name="side" value="{{ side_name }}" />
-                    <input type="hidden" name="level" value="{{ level }}" />
-                    <input type="submit"
-                           class="btn btn-primary w-full col-span-4"
-                           value="Boot eintragen" />
-                </form>
-            </details>
-        {% else %}
-            Kein Boot
-        {% endif %}
-    </li>
-{% endmacro show_place %}
-{% macro show_side(aisle_name, side_name) %}
-    <div class="{{ side_name }}-side">
-        <ol>
-            {{ self::show_place(aisle_name = aisle_name, side_name = side_name, level = 0) }}
-            {{ self::show_place(aisle_name = aisle_name, side_name = side_name, level = 1) }}
-            {{ self::show_place(aisle_name = aisle_name, side_name = side_name, level = 2) }}
-            {{ self::show_place(aisle_name = aisle_name, side_name = side_name, level = 3) }}
-        </ol>
-    </div>
-{% endmacro show_side %}
-{% macro show_aisle(name) %}
-    <div id="{{ name }}-aisle">
-        {{ self::show_side(aisle_name = name, side_name = "mountain") }}
-        {{ self::show_side(aisle_name = name, side_name = "water") }}
-    </div>
-{% endmacro show_aisle %}
-{% block content %}
-    {% if flash %}{{ macros::alert(message=flash.1, type=flash.0, class="sm:col-span-2 lg:col-span-3") }}{% endif %}
-    <div class="max-w-screen-lg w-full">
-        <h1 class="h1">Bootshaus</h1>
-        {{ self::show_aisle(name = "mountain") }}
-        {{ self::show_aisle(name = "middle") }}
-        {{ self::show_aisle(name = "water") }}
-    </div>
-{% endblock content %}

templates/index.html.tera

@@ -110,9 +110,6 @@
                             <li class="py-1">
                                 <a href="/admin/user" class="link-primary">User</a>
                             </li>
-                            <li class="py-1">
-                                <a href="/board/boathouse" class="link-primary">Bootshaus</a>
-                            </li>
                         </ul>
                     </div>
                 </div>