frontend/main.ts

@@ -7,6 +7,7 @@ export interface choiceMap {
 
 let choiceObjects: choiceMap = {};
 let boat_in_ottensheim = true;
+let boat_reserved_today= true;
 
 document.addEventListener("DOMContentLoaded", function () {
   changeTheme();
@@ -116,6 +117,7 @@ interface ChoiceBoatEvent extends Event {
       owner: number;
       default_destination: string;
       boat_in_ottensheim: boolean;
+      boat_reserved_today: boolean;
     };
   };
 }
@@ -134,7 +136,13 @@ function selectBoatChange() {
     boatSelect.addEventListener(
       "addItem",
       function (e) {
+	
         const event = e as ChoiceBoatEvent;
+        boat_reserved_today = event.detail.customProperties.boat_reserved_today;
+	console.log(event.detail.customProperties);
+	if (boat_reserved_today){
+		alert(event.detail.label+' wurde heute reserviert. Bitte kontrolliere, dass du die Reservierung nicht störst.');
+	}
         boat_in_ottensheim = event.detail.customProperties.boat_in_ottensheim;
 
         const amount_seats = event.detail.customProperties.amount_seats;

migration.sql

@@ -160,3 +160,16 @@ CREATE TABLE IF NOT EXISTS "notification" (
 	"category" TEXT NOT NULL,
 	"link" TEXT
 );
+
+CREATE TABLE IF NOT EXISTS "boat_reservation" (
+	"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
+	"boat_id" INTEGER NOT NULL REFERENCES boat(id), 
+	"start_date" DATE NOT NULL,
+	"end_date" DATE NOT NULL,
+	"time_desc" TEXT NOT NULL,
+	"usage" TEXT NOT NULL,
+	"user_id_applicant" INTEGER NOT NULL REFERENCES user(id), 
+	"user_id_confirmation" INTEGER REFERENCES user(id), 
+	"created_at" datetime not null default CURRENT_TIMESTAMP
+);
+

src/model/boat.rs

@@ -36,9 +36,10 @@ pub enum BoatDamage {
 #[derive(Serialize, Deserialize, Debug)]
 pub struct BoatWithDetails {
     #[serde(flatten)]
-    boat: Boat,
+    pub(crate) boat: Boat,
     damage: BoatDamage,
     on_water: bool,
+    reserved_today: bool,
 }
 
 #[derive(FromForm)]
@@ -135,6 +136,20 @@ impl Boat {
         sqlx::query!("SELECT * FROM boat_damage WHERE boat_id=? AND lock_boat=false AND user_id_verified is null", self.id).fetch_optional(db).await.unwrap().is_some()
     }
 
+    pub async fn reserved_today(&self, db: &SqlitePool) -> bool {
+        sqlx::query!(
+            "SELECT * 
+FROM boat_reservation
+WHERE boat_id =? 
+AND date('now') BETWEEN start_date AND end_date;",
+            self.id
+        )
+        .fetch_optional(db)
+        .await
+        .unwrap()
+        .is_some()
+    }
+
     pub async fn on_water(&self, db: &SqlitePool) -> bool {
         sqlx::query!(
             "SELECT * FROM logbook WHERE boat_id=? AND arrival is null",
@@ -159,6 +174,7 @@ impl Boat {
             res.push(BoatWithDetails {
                 damage,
                 on_water: boat.on_water(db).await,
+                reserved_today: boat.reserved_today(db).await,
                 boat,
             });
         }

src/model/boatreservation.rs

@@ -0,0 +1,179 @@
+use crate::model::{boat::Boat, user::User};
+use chrono::NaiveDate;
+use chrono::NaiveDateTime;
+use rocket::serde::{Deserialize, Serialize};
+use rocket::FromForm;
+use sqlx::{FromRow, SqlitePool};
+
+use super::log::Log;
+use super::notification::Notification;
+use super::role::Role;
+
+#[derive(FromRow, Debug, Serialize, Deserialize)]
+pub struct BoatReservation {
+    pub id: i64,
+    pub boat_id: i64,
+    pub start_date: NaiveDate,
+    pub end_date: NaiveDate,
+    pub time_desc: String,
+    pub usage: String,
+    pub user_id_applicant: i64,
+    pub user_id_confirmation: Option<i64>,
+    pub created_at: NaiveDateTime,
+}
+
+#[derive(FromRow, Debug, Serialize, Deserialize)]
+pub struct BoatReservationWithDetails {
+    #[serde(flatten)]
+    boat_reservation: BoatReservation,
+    boat: Boat,
+    user_applicant: User,
+    user_confirmation: Option<User>,
+}
+
+#[derive(Debug)]
+pub struct BoatReservationToAdd<'r> {
+    pub boat: &'r Boat,
+    pub start_date: NaiveDate,
+    pub end_date: NaiveDate,
+    pub time_desc: &'r str,
+    pub usage: &'r str,
+    pub user_applicant: &'r User,
+}
+
+impl BoatReservation {
+    pub async fn find_by_id(db: &SqlitePool, id: i32) -> Option<Self> {
+        sqlx::query_as!(
+            Self,
+            "SELECT id, boat_id, start_date, end_date, time_desc, usage, user_id_applicant, user_id_confirmation, created_at
+             FROM boat_reservation
+             WHERE id like ?",
+            id
+        )
+        .fetch_one(db)
+        .await
+        .ok()
+    }
+
+    pub async fn all_future(db: &SqlitePool) -> Vec<BoatReservationWithDetails> {
+        let boatreservations = sqlx::query_as!(
+            Self,
+            "
+SELECT id, boat_id, start_date, end_date, time_desc, usage, user_id_applicant, user_id_confirmation, created_at
+FROM boat_reservation
+WHERE end_date >= CURRENT_DATE ORDER BY end_date 
+        "
+        )
+        .fetch_all(db)
+        .await
+        .unwrap(); //TODO: fixme
+
+        let mut res = Vec::new();
+        for reservation in boatreservations {
+            let user_confirmation = match reservation.user_id_confirmation {
+                Some(id) => {
+                    let user = User::find_by_id(db, id as i32).await;
+                    Some(user.unwrap())
+                }
+                None => None,
+            };
+            let user_applicant = User::find_by_id(db, reservation.user_id_applicant as i32)
+                .await
+                .unwrap();
+            let boat = Boat::find_by_id(db, reservation.boat_id as i32)
+                .await
+                .unwrap();
+
+            res.push(BoatReservationWithDetails {
+                boat_reservation: reservation,
+                boat,
+                user_applicant,
+                user_confirmation,
+            });
+        }
+        res
+    }
+
+    pub async fn create(
+        db: &SqlitePool,
+        boatreservation: BoatReservationToAdd<'_>,
+    ) -> Result<(), String> {
+        if Self::boat_reserved_between_dates(
+            db,
+            boatreservation.boat,
+            &boatreservation.start_date,
+            &boatreservation.end_date,
+        )
+        .await
+        {
+            return Err("Boot in diesem Zeitraum bereits reserviert.".into());
+        }
+
+        Log::create(db, format!("New boat reservation: {boatreservation:?}")).await;
+
+        sqlx::query!(
+            "INSERT INTO boat_reservation(boat_id, start_date, end_date, time_desc, usage, user_id_applicant) VALUES (?,?,?,?,?,?)",
+            boatreservation.boat.id,
+            boatreservation.start_date,
+            boatreservation.end_date,
+            boatreservation.time_desc,
+            boatreservation.usage,
+            boatreservation.user_applicant.id,
+        )
+        .execute(db)
+        .await
+        .map_err(|e| e.to_string())?;
+
+        let board =
+            User::all_with_role(db, &Role::find_by_name(db, "Vorstand").await.unwrap()).await;
+        for user in board {
+            Notification::create(
+                    db,
+                    &user,
+                    &format!(
+                        "{} hat eine neue Bootsreservierung für Boot '{}' angelegt: Von {} bis {} um {} wegen {}",
+                        boatreservation.user_applicant.name,
+                       boatreservation.boat.name,
+                        boatreservation.start_date,
+                        boatreservation.end_date,
+                        boatreservation.time_desc,
+                        boatreservation.usage
+                    ),
+                    "Neue Bootsreservierung",
+                    None,
+                )
+                .await;
+        }
+
+        Ok(())
+    }
+
+    pub async fn boat_reserved_between_dates(
+        db: &SqlitePool,
+        boat: &Boat,
+        start_date: &NaiveDate,
+        end_date: &NaiveDate,
+    ) -> bool {
+        sqlx::query!(
+            "SELECT COUNT(*) AS reservation_count
+FROM boat_reservation
+WHERE boat_id = ? 
+AND start_date <= ? AND end_date >= ?;",
+            boat.id,
+            end_date,
+            start_date
+        )
+        .fetch_one(db)
+        .await
+        .unwrap()
+        .reservation_count
+            > 0
+    }
+
+    pub async fn delete(&self, db: &SqlitePool) {
+        sqlx::query!("DELETE FROM boat_reservation WHERE id=?", self.id)
+            .execute(db)
+            .await
+            .unwrap(); //Okay, because we can only create a Boat of a valid id
+    }
+}

src/model/mod.rs

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

src/model/planned_event.rs

@@ -6,7 +6,7 @@ use ics::{
     Event, ICalendar,
 };
 use serde::Serialize;
-use sqlx::{FromRow, SqlitePool, Row};
+use sqlx::{FromRow, Row, SqlitePool};
 
 use super::{tripdetails::TripDetails, triptype::TripType, user::User};
 

src/tera/boatreservation.rs

@@ -0,0 +1,172 @@
+use chrono::NaiveDate;
+use rocket::{
+    form::Form,
+    get, post,
+    request::FlashMessage,
+    response::{Flash, Redirect},
+    routes, FromForm, Route, State,
+};
+use rocket_dyn_templates::Template;
+use sqlx::SqlitePool;
+use tera::Context;
+
+use crate::{
+    model::{
+        boat::Boat,
+        boatdamage::{BoatDamage, BoatDamageFixed, BoatDamageToAdd, BoatDamageVerified},
+        boatreservation::{BoatReservation, BoatReservationToAdd},
+        user::{AdminUser, CoxUser, DonauLinzUser, TechUser, User, UserWithRoles},
+    },
+    tera::log::KioskCookie,
+};
+
+#[get("/")]
+async fn index_kiosk(
+    db: &State<SqlitePool>,
+    flash: Option<FlashMessage<'_>>,
+    _kiosk: KioskCookie,
+) -> Template {
+    let boatreservations = BoatReservation::all_future(db).await;
+
+    let mut context = Context::new();
+    if let Some(msg) = flash {
+        context.insert("flash", &msg.into_inner());
+    }
+
+    let linz_boats = Boat::all_for_boatshouse(db).await;
+    let mut boats = Vec::new();
+    for boat in linz_boats {
+        if boat.boat.owner.is_none() {
+            boats.push(boat);
+        }
+    }
+
+    context.insert("boatreservations", &boatreservations);
+    context.insert("boats", &boats);
+    context.insert("user", &User::all(db).await);
+    context.insert("show_kiosk_header", &true);
+
+    Template::render("boatreservations", context.into_json())
+}
+
+#[get("/", rank = 2)]
+async fn index(
+    db: &State<SqlitePool>,
+    flash: Option<FlashMessage<'_>>,
+    user: DonauLinzUser,
+) -> Template {
+    let boatreservations = BoatReservation::all_future(db).await;
+
+    let mut context = Context::new();
+    if let Some(msg) = flash {
+        context.insert("flash", &msg.into_inner());
+    }
+
+    let linz_boats = Boat::all_for_boatshouse(db).await;
+    let mut boats = Vec::new();
+    for boat in linz_boats {
+        if boat.boat.owner.is_none() {
+            boats.push(boat);
+        }
+    }
+
+    context.insert("boatreservations", &boatreservations);
+    context.insert("boats", &boats);
+    context.insert("user", &User::all(db).await);
+    context.insert(
+        "loggedin_user",
+        &UserWithRoles::from_user(user.into(), db).await,
+    );
+
+    Template::render("boatreservations", context.into_json())
+}
+
+#[derive(Debug, FromForm)]
+pub struct FormBoatReservationToAdd<'r> {
+    pub boat_id: i64,
+    pub start_date: &'r str,
+    pub end_date: &'r str,
+    pub time_desc: &'r str,
+    pub usage: &'r str,
+    pub user_id_applicant: Option<i64>,
+}
+
+#[post("/", data = "<data>", rank = 2)]
+async fn create<'r>(
+    db: &State<SqlitePool>,
+    data: Form<FormBoatReservationToAdd<'r>>,
+    user: DonauLinzUser,
+) -> Flash<Redirect> {
+    let user_applicant: User = user.into();
+    let boat = Boat::find_by_id(db, data.boat_id as i32).await.unwrap();
+    let boatreservation_to_add = BoatReservationToAdd {
+        boat: &boat,
+        start_date: NaiveDate::parse_from_str(data.start_date, "%Y-%m-%d").unwrap(),
+        end_date: NaiveDate::parse_from_str(data.end_date, "%Y-%m-%d").unwrap(),
+        time_desc: data.time_desc,
+        usage: data.usage,
+        user_applicant: &user_applicant,
+    };
+    match BoatReservation::create(db, boatreservation_to_add).await {
+        Ok(_) => Flash::success(
+            Redirect::to("/boatreservation"),
+            "Reservierung erfolgreich hinzugefügt",
+        ),
+        Err(e) => Flash::error(Redirect::to("/boatreservation"), format!("Fehler: {e}")),
+    }
+}
+
+#[post("/", data = "<data>")]
+async fn create_from_kiosk<'r>(
+    db: &State<SqlitePool>,
+    data: Form<FormBoatReservationToAdd<'r>>,
+    _kiosk: KioskCookie,
+) -> Flash<Redirect> {
+    let user_applicant: User = User::find_by_id(db, data.user_id_applicant.unwrap() as i32)
+        .await
+        .unwrap();
+    let boat = Boat::find_by_id(db, data.boat_id as i32).await.unwrap();
+    let boatreservation_to_add = BoatReservationToAdd {
+        boat: &boat,
+        start_date: NaiveDate::parse_from_str(data.start_date, "%Y-%m-%d").unwrap(),
+        end_date: NaiveDate::parse_from_str(data.end_date, "%Y-%m-%d").unwrap(),
+        time_desc: data.time_desc,
+        usage: data.usage,
+        user_applicant: &user_applicant,
+    };
+    match BoatReservation::create(db, boatreservation_to_add).await {
+        Ok(_) => Flash::success(
+            Redirect::to("/boatreservation"),
+            "Reservierung erfolgreich hinzugefügt",
+        ),
+        Err(e) => Flash::error(Redirect::to("/boatreservation"), format!("Fehler: {e}")),
+    }
+}
+
+#[get("/<reservation_id>/delete")]
+async fn delete<'r>(
+    db: &State<SqlitePool>,
+    reservation_id: i32,
+    user: DonauLinzUser,
+) -> Flash<Redirect> {
+    let reservation = BoatReservation::find_by_id(db, reservation_id)
+        .await
+        .unwrap();
+
+    if user.id == reservation.user_id_applicant || user.has_role(db, "admin").await {
+        reservation.delete(db).await;
+        Flash::success(
+            Redirect::to("/boatreservation"),
+            "Reservierung erfolgreich gelöscht",
+        )
+    } else {
+        Flash::error(
+            Redirect::to("/boatreservation"),
+            format!("Nur der Reservierer darf die Reservierung löschen."),
+        )
+    }
+}
+
+pub fn routes() -> Vec<Route> {
+    routes![index, index_kiosk, create, create_from_kiosk, delete]
+}

src/tera/log.rs

@@ -17,6 +17,7 @@ use tera::Context;
 
 use crate::model::{
     boat::Boat,
+    boatreservation::BoatReservation,
     log::Log,
     logbook::{
         LogToAdd, LogToFinalize, Logbook, LogbookCreateError, LogbookDeleteError,
@@ -73,6 +74,7 @@ async fn index(
     }
 
     context.insert("boats", &boats);
+    context.insert("reservations", &BoatReservation::all_future(db).await);
     context.insert("coxes", &coxes);
     context.insert("users", &users);
     context.insert("logtypes", &logtypes);
@@ -163,6 +165,7 @@ async fn kiosk(
     }
 
     context.insert("boats", &boats);
+    context.insert("reservations", &BoatReservation::all_future(db).await);
     context.insert("coxes", &coxes);
     context.insert("users", &users);
     context.insert("logtypes", &logtypes);

src/tera/mod.rs

@@ -26,6 +26,7 @@ pub(crate) mod admin;
 mod auth;
 pub(crate) mod board;
 mod boatdamage;
+mod boatreservation;
 mod cox;
 mod ergo;
 mod log;
@@ -94,6 +95,7 @@ pub fn config(rocket: Rocket<Build>) -> Rocket<Build> {
         .mount("/notification", notification::routes())
         .mount("/stat", stat::routes())
         .mount("/boatdamage", boatdamage::routes())
+        .mount("/boatreservation", boatreservation::routes())
         .mount("/cox", cox::routes())
         .mount("/admin", admin::routes())
         .mount("/board", board::routes())

staging-diff.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS "boat_reservation" (
+	"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
+	"boat_id" INTEGER NOT NULL REFERENCES boat(id), 
+	"start_date" DATE NOT NULL,
+	"end_date" DATE NOT NULL,
+	"time_desc" TEXT NOT NULL,
+	"usage" TEXT NOT NULL,
+	"user_id_applicant" INTEGER NOT NULL REFERENCES user(id), 
+	"user_id_confirmation" INTEGER REFERENCES user(id), 
+	"created_at" datetime not null default CURRENT_TIMESTAMP
+);

templates/base.html.tera

@@ -22,6 +22,7 @@
                     <a href="/stat" class="px-2">Statistik</a>
                     <a href="/stat/boats" class="px-2">Bootsauswertung</a>
                     <a href="/boatdamage" class="px-2">Bootsschaden</a>
+                    <a href="/boatreservation" class="px-2">Bootsreservierung</a>
                 </div>
             </header>
         {% endif %}

templates/boatreservations.html.tera

@@ -0,0 +1,67 @@
+{% import "includes/macros" as macros %}
+{% import "includes/forms/log" as log %}
+{% extends "base" %}
+{% block content %}
+    <div class="max-w-screen-lg w-full">
+        <h1 class="h1">Bootsreservierungen</h1>
+        <h2 class="text-md font-bold tracking-wide bg-primary-900 mt-3 p-3 text-white flex justify-between items-center rounded-md">
+            Neue Reservierung
+            <a href="#"
+               class="inline-flex justify-center rounded-md bg-primary-600 mx-1 px-3 py-2 text-sm font-semibold text-white hover:bg-primary-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary-600 cursor-pointer"
+               data-sidebar="true"
+               data-trigger="sidebar"
+               data-header="Neue Reservierung anlegen"
+               data-body="#new-reservation">
+                {% include "includes/plus-icon" %}
+                <span class="sr-only">Neue Reservierung eintragen</span>
+            </a>
+        </h2>
+        <div class="hidden">
+            <div id="new-reservation">
+                <form action="/boatreservation" method="post" class="grid gap-3">
+                    {{ log::boat_select(only_ones=false, id='boat') }}
+                    {% if not loggedin_user %}{{ macros::select(label='Reserviert von', data=user, name='user_id_applicant') }}{% endif %}
+                    {{ macros::input(label='Beginn', name='start_date', type='date', required=true, wrapper_class='col-span-4') }}
+                    {{ macros::input(label='Ende', name='end_date', type='date', required=true, wrapper_class='col-span-4') }}
+                    {{ macros::input(label='Uhrzeit (zB ab 14:00 Uhr, ganztägig, ...)', name='time_desc', type='text', required=true, wrapper_class='col-span-4') }}
+                    {{ macros::input(label='Zweck (Wanderfahrt, ...)', name='usage', type='text', required=true, wrapper_class='col-span-4') }}
+                    <input type="submit"
+                           class="btn btn-primary w-full col-span-4"
+                           value="Reservierung eintragen" />
+                </form>
+            </div>
+        </div>
+        <div class="search-wrapper">
+            <label for="name" class="sr-only">Suche</label>
+            <input type="search"
+                   name="name"
+                   id="filter-js"
+                   class="search-bar"
+                   placeholder="Suchen nach Namen...">
+        </div>
+        <div id="filter-result-js" class="search-result"></div>
+        {% for reservation in boatreservations %}
+            <div data-filterable="true"
+                 data-filter="TODO: ADD FILTER"
+                 class="w-full border-t bg-white dark:bg-primary-900 text-black dark:text-white p-3">
+                <div class="w-full">
+                    Boot: {{ reservation.boat.name }}
+                    <br />
+                    Datum: {{ reservation.start_date }}
+                    {% if reservation.end_date != reservation.start_date %}- {{ reservation.end_date }}{% endif %}
+                    <br />
+                    Uhrzeit: {{ reservation.time_desc }}
+                    <br />
+                    Zweck: {{ reservation.usage }}
+                    <br />
+                    Reserviert von {{ reservation.user_applicant.name }}
+                    {% if loggedin_user %}
+                        {% if loggedin_user.id == reservation.user_applicant.id or "admin" in loggedin_user.roles %}
+                            <a href="/boatreservation/{{ reservation.id }}/delete">RESERVIERUNG LÖSCHEN</a>
+                        {% endif %}
+                    {% endif %}
+                </div>
+            </div>
+        {% endfor %}
+    </div>
+{% endblock content %}

templates/includes/macros.html.tera

@@ -2,12 +2,15 @@
     <div class="bg-white dark:bg-primary-900 text-black dark:text-white rounded-md block shadow grid gap-3"
          style="margin-top: 10px">
         <h2 class="h2">Bootsreservierungen</h2>
-        <div class="p2" style="margin-bottom: 10px;">
+        <div class="p2 text-center" style="margin-bottom: 10px;">
-            <ul style="display: flex;
+            <ul style=" justify-content: space-around; padding: 0; list-style: none">
-                       justify-content: space-around;
+                {% for reservation in reservations %}
-                       padding: 0;
+                    <li>
-                       list-style: none">
+                        {{ reservation.boat.name }} &bullet; {{ reservation.start_date }}
-                <li style="display: inline-block;">30.03. | Manuela Firmötz | Boot: Urfahr</li>
+                        {% if reservation.end_date != reservation.start_date %}- {{ reservation.end_date }}{% endif %}
+                        &bullet; Uhrzeit: {{ reservation.time_desc }} &bullet; Zweck: {{ reservation.usage }}
+                    </li>
+                {% endfor %}
             </ul>
         </div>
     </div>
@@ -141,7 +144,7 @@
                 {% if required %}required="required"{% endif %}>
             {% if default %}<option selected value>{{ default }}</option>{% endif %}
             {% for d in data %}
-                <option value="{{ d.id }}" {% if d.id == selected_id %}selected{% endif %} {% if extras != '' %} {% for extra in extras %} {% if extra != 'on_water' and d[extra] %} data-{{ extra }}={{ d[extra] }} {% else %} {% if d[extra] %}disabled{% endif %} {% endif %} {% endfor %} {% endif %} {% if show_seats %} data-custom-properties='{"amount_seats": {{ d["amount_seats"] }}, "owner": "{{ d["owner"] }}", "default_destination": "{{ d["default_destination"] }}", "boat_in_ottensheim": {{ d["location_id"] == 2 }}}'{% endif %}>
+                <option value="{{ d.id }}" {% if d.id == selected_id %}selected{% endif %} {% if extras != '' %} {% for extra in extras %} {% if extra != 'on_water' and d[extra] %} data-{{ extra }}={{ d[extra] }} {% else %} {% if d[extra] %}disabled{% endif %} {% endif %} {% endfor %} {% endif %} {% if show_seats %} data-custom-properties='{"amount_seats": {{ d["amount_seats"] }}, "owner": "{{ d["owner"] }}", "default_destination": "{{ d["default_destination"] }}", "boat_in_ottensheim": {{ d["location_id"] == 2 }}, "boat_reserved_today": {{ d["reserved_today"] }}}'{% endif %}>
                     {% for displa in display -%}
                         {%- if d[displa] -%}
                             {{- d[displa] -}}

templates/index.html.tera

@@ -90,6 +90,10 @@
                         <li class="py-1">
                             <a href="/boatdamage" class="block w-100 py-2 hover:text-primary-600">Bootsschaden</a>
                         </li>
+                        <li class="py-1">
+                            <a href="/boatreservation"
+                               class="block w-100 py-2 hover:text-primary-600">Bootsreservierung</a>
+                        </li>
                     </ul>
                 </div>
             {% endif %}