Merge pull request 'single-user-edit-page' (#992) from single-user-edit-page into main

Reviewed-on: #992

frontend/main.ts

@@ -24,6 +24,7 @@ document.addEventListener("DOMContentLoaded", function () {
   reloadPage();
   setCurrentdate(<HTMLInputElement>document.querySelector("#departure"));
   initDropdown();
+  editReadOnlyField();
 });
 
 function changeTheme() {
@@ -40,6 +41,30 @@ function changeTheme() {
   }
 }
 
+
+function editReadOnlyField() {
+    const editBtns = document.querySelectorAll(
+      '.edit-js'
+    );
+    if (editBtns) {
+      Array.prototype.forEach.call(editBtns, (btn: HTMLButtonElement) => {
+        btn.addEventListener("click", function () {
+          let wrapper = btn.parentElement;
+          let input = <HTMLInputElement> wrapper?.querySelector('input.input'),
+              select = <HTMLSelectElement> wrapper?.querySelector('select.input'),
+              attribute = 'readonly';
+          
+          if(select) attribute = 'disabled';
+          let element = input ? input : select;
+
+          element?.toggleAttribute(attribute);
+          if(!element?.hasAttribute(attribute)) element?.focus();
+          wrapper?.classList.toggle('editable');
+        });
+      });
+    }
+}
+
 /***
  * init javascript
  * 1) detect native color scheme or use set theme in local storage

frontend/scss/components/_btns.scss

@@ -28,4 +28,8 @@
   &[aria-pressed='true'] {
     @apply outline outline-2 outline-offset-2 outline-primary-600 bg-primary-100 text-primary-950;
   }
+
+  &-hidden {
+    @apply hidden;
+  }
 }

frontend/scss/components/_headlines.scss

@@ -4,4 +4,8 @@
 
 .h2 {
   @apply font-bold uppercase tracking-wide text-center rounded-t-md text-primary-950 dark:text-white bg-gray-200 dark:bg-primary-950 bg-opacity-80 text-lg px-3 py-3;
+}
+
+.h3 {
+  @apply text-center text-xl uppercase tracking-wide font-bold text-primary-900 dark:text-white;
 }

frontend/scss/components/_important.scss

@@ -2,3 +2,12 @@
     border-top-left-radius: 0px !important;
     border-top-right-radius: 0px !important;
 }
+
+.rounded-l-none-important {
+  border-bottom-left-radius: 0px !important;
+  border-top-left-radius: 0px !important;
+}
+
+.rounded-none-important {
+  border-radius: 0px !important;
+}

frontend/scss/components/_input.scss

@@ -2,6 +2,26 @@
   @apply relative block w-full bg-white dark:bg-black border-0 py-1.5 px-2 text-gray-900 dark:text-white ring-1 ring-inset ring-gray-300 dark:ring-black placeholder:text-gray-400 focus:z-10 focus:ring-2 focus:ring-inset focus:ring-primary-600 sm:text-sm sm:leading-6;
 }
 
+.input-group {
+  @apply flex;
+
+  input[readonly], 
+  select[disabled] {
+    opacity: .7;
+  }
+
+  &.editable {
+      input[type="reset"],
+      input[type="submit"] {
+          @apply block;
+      }
+
+      button[type="button"] {
+          @apply hidden;
+      }
+  }
+}
+
 select {
   background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3e%3cpath fill='none' stroke='%23343a40' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M2 5l6 6 6-6'/%3e%3c/svg%3e");
   background-repeat: no-repeat;

frontend/scss/components/_links.scss

@@ -10,4 +10,12 @@
   &-white {
     @apply text-white hover:text-primary-100 underline;
   }
+
+  &-black {
+    @apply text-black hover:text-primary-950 dark:text-white hover:dark:text-primary-300 underline;
+  }
+
+  &-no-underline {
+    @apply no-underline;
+  }
 }

frontend/tests/log.spec.ts

@@ -115,7 +115,7 @@ test("Cox can start and finish trip", async ({ page }, testInfo) => {
   await page.getByPlaceholder("Passwort").press("Enter");
 
   await page.goto("/log/show");
-  await page.getByText('(cox2)').click();
+  await page.getByRole('link', { name: 'Joe' }).nth(1).click();
   page.once("dialog", (dialog) => {
     dialog.accept().catch(() => {});
   });
@@ -208,7 +208,6 @@ test("Kiosk can start and finish trip", async ({ page }, testInfo) => {
 
   await page.getByRole('link', { name: 'Logbuch' }).click();
   await expect(page.locator('body')).toContainText('Joe');
-  await expect(page.locator('body')).toContainText('(cox2)');
   await expect(page.locator('body')).toContainText('Ottensheim (25 km)');
   await expect(page.locator('body')).toContainText('Ruderer: cox2, rower2');
   
@@ -225,7 +224,7 @@ test("Kiosk can start and finish trip", async ({ page }, testInfo) => {
   await page.getByPlaceholder("Passwort").press("Enter");
 
   await page.goto("/log/show");
-  await page.getByText('(cox2)').click();
+  await page.getByRole('link', { name: 'Joe' }).nth(1).click();
   page.once("dialog", (dialog) => {
     dialog.accept().catch(() => {});
   });
@@ -286,7 +285,6 @@ test("Cox can start and finish trip with cox steering only", async ({ page }, te
 
   await page.goto('/log/show');
   await expect(page.locator('body')).toContainText('cox_only_steering_boat');
-  await expect(page.locator('body')).toContainText('(cox2 - handgesteuert)');
   await expect(page.locator('body')).toContainText('Ottensheim (25 km)');
   
 
@@ -302,7 +300,7 @@ test("Cox can start and finish trip with cox steering only", async ({ page }, te
   await page.getByPlaceholder("Passwort").press("Enter");
 
   await page.goto("/log/show");
-  await page.getByText('(cox2 - handgesteuert)').click();
+  await page.getByRole("link", { name: "cox_only_steering_boat" }).click();
   page.once("dialog", (dialog) => {
     dialog.accept().catch(() => {});
   });
@@ -371,7 +369,7 @@ test("Kiosk can start and finish trip in one stop", async ({ page }, testInfo) =
   await page.getByPlaceholder("Passwort").press("Enter");
 
   await page.goto("/log/show");
-  await page.getByText('(cox2)').click();
+  await page.getByRole('link', { name: 'Joe' }).nth(1).click();
   page.once("dialog", (dialog) => {
     dialog.accept().catch(() => {});
   });

migration.sql

@@ -28,7 +28,10 @@ CREATE TABLE IF NOT EXISTS "family" (
 CREATE TABLE IF NOT EXISTS "role" (
 	"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
 	"name" text NOT NULL UNIQUE,
-	"cluster" text
+	"formatted_name" text,
+	"desc" text,
+	"cluster" text,
+	"hide_in_lists" BOOLEAN NOT NULL DEFAULT false
 );
 
 CREATE TABLE IF NOT EXISTS "user_role" (
@@ -222,6 +225,15 @@ CREATE TABLE IF NOT EXISTS "distance" (
 );
 
 
+CREATE TABLE IF NOT EXISTS "activity" (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    text TEXT NOT NULL,
+    relevant_for TEXT NOT NULL,  -- e.g. user_id=123;trip_id=456
+    keep_until DATETIME
+);
+
+
 CREATE TRIGGER IF NOT EXISTS prevent_multiple_roles_same_cluster
 BEFORE INSERT ON user_role
 BEGIN

src/lib.rs

@@ -1,5 +1,7 @@
 #![allow(clippy::blocks_in_conditions)]
 
+use std::ops::Deref;
+
 pub mod model;
 
 #[cfg(feature = "rowing-tera")]
@@ -22,6 +24,74 @@ pub(crate) const FOERDERND: i64 = 8500;
 pub(crate) const SCHECKBUCH: i64 = 3000;
 pub(crate) const EINSCHREIBGEBUEHR: i64 = 3000;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct NonEmptyString(String);
+
+impl NonEmptyString {
+    pub fn new(s: String) -> Option<Self> {
+        if s.is_empty() {
+            None
+        } else {
+            Some(NonEmptyString(s))
+        }
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+
+    pub fn into_string(self) -> String {
+        self.0
+    }
+}
+
+// Implement Deref to allow automatic dereferencing to &str
+impl Deref for NonEmptyString {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+// This allows &NonEmptyString to be converted to &str
+impl AsRef<str> for NonEmptyString {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+// This allows NonEmptyString to be converted to String with .into()
+impl From<NonEmptyString> for String {
+    fn from(s: NonEmptyString) -> Self {
+        s.0
+    }
+}
+
+impl TryFrom<&str> for NonEmptyString {
+    type Error = &'static str;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        if s.is_empty() {
+            Err("String cannot be empty")
+        } else {
+            Ok(NonEmptyString(s.to_string()))
+        }
+    }
+}
+
+impl TryFrom<String> for NonEmptyString {
+    type Error = &'static str;
+
+    fn try_from(s: String) -> Result<Self, Self::Error> {
+        if s.is_empty() {
+            Err("String cannot be empty")
+        } else {
+            Ok(NonEmptyString(s))
+        }
+    }
+}
+
 #[cfg(test)]
 #[macro_export]
 macro_rules! testdb {

src/main.rs

@@ -8,7 +8,7 @@ use rot::rest;
 use rot::tera;
 use rot::{scheduled, tera::Config};
 
-use sqlx::{pool::PoolOptions, sqlite::SqliteConnectOptions, ConnectOptions};
+use sqlx::{ConnectOptions, pool::PoolOptions, sqlite::SqliteConnectOptions};
 
 #[macro_use]
 extern crate rocket;

src/model/activity.rs

@@ -0,0 +1,113 @@
+use std::ops::DerefMut;
+
+use super::{role::Role, user::User};
+use chrono::NaiveDateTime;
+use serde::{Deserialize, Serialize};
+use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
+
+#[derive(FromRow, Debug, Serialize, Deserialize, Clone)]
+pub struct Activity {
+    pub id: i64,
+    pub created_at: NaiveDateTime,
+    pub text: String,
+    pub relevant_for: String,
+    pub keep_until: Option<NaiveDateTime>,
+}
+
+pub struct ActivityBuilder {
+    text: String,
+    relevant_for: String,
+    keep_until: Option<NaiveDateTime>,
+}
+
+impl ActivityBuilder {
+    #[must_use]
+    pub fn new(text: &str) -> Self {
+        Self {
+            text: text.into(),
+            relevant_for: String::new(),
+            keep_until: None,
+        }
+    }
+
+    #[must_use]
+    pub fn relevant_for_user(self, user: &User) -> Self {
+        Self {
+            relevant_for: format!("{}user-{};", self.relevant_for, user.id),
+            ..self
+        }
+    }
+
+    #[must_use]
+    pub fn relevant_for_role(self, role: &Role) -> Self {
+        Self {
+            relevant_for: format!("{}role-{};", self.relevant_for, role.id),
+            ..self
+        }
+    }
+
+    pub async fn save(self, db: &SqlitePool) {
+        Activity::create(db, &self.text, &self.relevant_for, self.keep_until).await;
+    }
+
+    pub async fn save_tx(self, db: &mut Transaction<'_, Sqlite>) {
+        Activity::create_with_tx(db, &self.text, &self.relevant_for, self.keep_until).await;
+    }
+}
+
+impl Activity {
+    pub async fn find_by_id(db: &SqlitePool, id: i64) -> Option<Self> {
+        sqlx::query_as!(
+            Self,
+            "SELECT id, created_at, text, relevant_for, keep_until FROM activity WHERE id like ?",
+            id
+        )
+        .fetch_one(db)
+        .await
+        .ok()
+    }
+    pub(super) async fn create_with_tx(
+        db: &mut Transaction<'_, Sqlite>,
+        text: &str,
+        relevant_for: &str,
+        keep_until: Option<NaiveDateTime>,
+    ) {
+        sqlx::query!(
+            "INSERT INTO activity(text, relevant_for, keep_until) VALUES (?, ?, ?)",
+            text,
+            relevant_for,
+            keep_until
+        )
+        .execute(db.deref_mut())
+        .await
+        .unwrap();
+    }
+
+    pub(super) async fn create(
+        db: &SqlitePool,
+        text: &str,
+        relevant_for: &str,
+        keep_until: Option<NaiveDateTime>,
+    ) {
+        let mut tx = db.begin().await.unwrap();
+        Self::create_with_tx(&mut tx, text, relevant_for, keep_until).await;
+        tx.commit().await.unwrap();
+    }
+
+    pub async fn for_user(db: &SqlitePool, user: &User) -> Vec<Activity> {
+        let user_str = format!("user-{};", user.id);
+        sqlx::query_as!(
+            Self,
+            "
+SELECT id, created_at, text, relevant_for, keep_until FROM activity
+WHERE 
+  relevant_for like CONCAT('%', ?, '%')
+ORDER BY created_at DESC;
+            ",
+            user_str
+        )
+        .fetch_all(db)
+        .await
+        .unwrap()
+    }
+}

src/model/boat.rs

@@ -2,8 +2,8 @@ use std::ops::DerefMut;
 
 use chrono::NaiveDateTime;
 use itertools::Itertools;
-use rocket::serde::{Deserialize, Serialize};
 use rocket::FromForm;
+use rocket::serde::{Deserialize, Serialize};
 use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
 
 use crate::model::boathouse::Boathouse;

src/model/boatdamage.rs

@@ -1,7 +1,7 @@
 use crate::model::{boat::Boat, user::User};
 use chrono::NaiveDateTime;
-use rocket::serde::{Deserialize, Serialize};
 use rocket::FromForm;
+use rocket::serde::{Deserialize, Serialize};
 use sqlx::{FromRow, SqlitePool};
 
 use super::log::Log;

src/model/event.rs

@@ -2,8 +2,8 @@ use std::io::Write;
 
 use chrono::{Duration, NaiveDate, NaiveTime};
 use ics::{
-    properties::{DtEnd, DtStart, Summary},
     ICalendar,
+    properties::{DtEnd, DtStart, Summary},
 };
 use serde::Serialize;
 use sqlx::{FromRow, Row, SqlitePool};
@@ -578,6 +578,11 @@ mod test {
 
         let today = Local::now().date_naive().format("%Y%m%d").to_string();
         let actual = Event::get_ics_feed(&pool).await;
-        assert_eq!(format!("BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:ics-rs\r\nBEGIN:VEVENT\r\nUID:event-1@rudernlinz.at\r\nDTSTAMP:19900101T180000\r\nDTSTART:{today}T100000\r\nDTEND:{today}T130000\r\nSUMMARY:test-planned-event \r\nEND:VEVENT\r\nEND:VCALENDAR\r\n"), actual);
+        assert_eq!(
+            format!(
+                "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:ics-rs\r\nBEGIN:VEVENT\r\nUID:event-1@rudernlinz.at\r\nDTSTAMP:19900101T180000\r\nDTSTART:{today}T100000\r\nDTEND:{today}T130000\r\nSUMMARY:test-planned-event \r\nEND:VEVENT\r\nEND:VCALENDAR\r\n"
+            ),
+            actual
+        );
     }
 }

src/model/family.rs

@@ -1,13 +1,13 @@
 use std::ops::DerefMut;
 
 use serde::Serialize;
-use sqlx::{sqlite::SqliteQueryResult, FromRow, Sqlite, SqlitePool, Transaction};
+use sqlx::{FromRow, Sqlite, SqlitePool, Transaction, sqlite::SqliteQueryResult};
 
 use super::user::User;
 
 #[derive(FromRow, Serialize, Clone)]
 pub struct Family {
-    id: i64,
+    pub(crate) id: i64,
 }
 
 #[derive(Serialize, Clone)]
@@ -91,4 +91,18 @@ GROUP BY family.id;"
             .await
             .unwrap()
     }
+
+    pub async fn clean_families_without_members(db: &SqlitePool) {
+        sqlx::query(
+            "DELETE FROM family
+WHERE id NOT IN (
+    SELECT DISTINCT family_id 
+    FROM user 
+    WHERE family_id IS NOT NULL
+);",
+        )
+        .execute(db)
+        .await
+        .unwrap();
+    }
 }

src/model/logbook.rs

@@ -2,14 +2,14 @@ use std::ops::DerefMut;
 
 use chrono::{Datelike, Duration, Local, NaiveDateTime};
 use rocket::FromForm;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
 
 use super::{
     boat::Boat, log::Log, notification::Notification, role::Role, rower::Rower, user::User,
 };
 
-#[derive(FromRow, Serialize, Clone, Debug)]
+#[derive(FromRow, Serialize, Deserialize, Clone, Debug)]
 pub struct Logbook {
     pub id: i64,
     pub boat_id: i64,
@@ -105,7 +105,7 @@ impl TryFrom<LogToAdd> for LogToFinalize {
     }
 }
 
-#[derive(Serialize, Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct LogbookWithBoatAndRowers {
     #[serde(flatten)]
     pub logbook: Logbook,
@@ -823,7 +823,13 @@ ORDER BY departure DESC
                 if difference > Duration::hours(1) {
                     let vorstand = Role::find_by_name(db, "Vorstand").await.unwrap();
                     let logbook = LogbookWithBoatAndRowers::from(db, self.clone()).await;
-                    let mut msg = format!("{} hat folgenden Logbuch-Eintrag jetzt gelöscht, welcher bereits vor über einer Stunde begonnen wurde: Schiffsführer: {}, Steuerperson: {}, Abfahrt: {}", user.name, logbook.steering_user.name, logbook.steering_user.name, logbook.logbook.departure.format("%Y-%m-%d %H:%M"));
+                    let mut msg = format!(
+                        "{} hat folgenden Logbuch-Eintrag jetzt gelöscht, welcher bereits vor über einer Stunde begonnen wurde: Schiffsführer: {}, Steuerperson: {}, Abfahrt: {}",
+                        user.name,
+                        logbook.steering_user.name,
+                        logbook.steering_user.name,
+                        logbook.logbook.departure.format("%Y-%m-%d %H:%M")
+                    );
                     if let Some(destination) = logbook.logbook.destination {
                         msg.push_str(&format!(", Ziel: {}", destination));
                     } else {

src/model/mail.rs

@@ -1,15 +1,15 @@
 use std::{error::Error, fs};
 
 use lettre::{
-    message::{header::ContentType, Attachment, MultiPart, SinglePart},
+    Address, Message, SmtpTransport, Transport,
+    message::{Attachment, MultiPart, SinglePart, header::ContentType},
     transport::smtp::authentication::Credentials,
-    Message, SmtpTransport, Transport,
 };
 use sqlx::{Sqlite, SqlitePool, Transaction};
 
 use crate::tera::admin::mail::MailToSend;
 
-use super::{family::Family, log::Log, role::Role, user::User};
+use super::{activity::ActivityBuilder, family::Family, log::Log, role::Role, user::User};
 
 pub struct Mail {}
 
@@ -79,7 +79,9 @@ impl Mail {
             .build();
 
         // Send the email
-        mailer.send(&email).unwrap();
+        if let Err(e) = mailer.send(&email) {
+            Log::create_with_tx(db, format!("Mail nicht versandt: {e:?}")).await;
+        }
 
         Ok(())
     }
@@ -251,6 +253,12 @@ Der Vorstand");
 
                         // Send the email
                         mailer.send(&email).unwrap();
+                        ActivityBuilder::new(&format!(
+                            "{user} hat die Info-Mail bzgl. Gebühren gesendet bekommen."
+                        ))
+                        .relevant_for_user(&user)
+                        .save(db)
+                        .await;
                     }
                 }
             }
@@ -367,6 +375,12 @@ Der Vorstand");
 
                             // Send the email
                             mailer.send(&email).unwrap();
+                            ActivityBuilder::new(&format!(
+                                "{user} hat die Mahn-Mail bzgl. Gebühren gesendet bekommen."
+                            ))
+                            .relevant_for_user(&user)
+                            .save(db)
+                            .await;
                         }
                     }
                 }
@@ -374,3 +388,13 @@ Der Vorstand");
         }
     }
 }
+
+pub(crate) fn valid_mails(mails: &str) -> bool {
+    let splitted = mails.split(',');
+    for single_rec in splitted {
+        if single_rec.parse::<Address>().is_err() {
+            return false;
+        }
+    }
+    true
+}

src/model/mod.rs

@@ -14,6 +14,7 @@ use self::{
 use boatreservation::{BoatReservation, BoatReservationWithDetails};
 use std::collections::HashMap;
 
+pub mod activity;
 pub mod boat;
 pub mod boatdamage;
 pub mod boathouse;

src/model/personal/cal.rs

@@ -1,6 +1,6 @@
 use std::io::Write;
 
-use ics::{components::Property, ICalendar};
+use ics::{ICalendar, components::Property};
 use sqlx::SqlitePool;
 
 use crate::model::{event::Event, trip::Trip, user::User};

src/model/role.rs

@@ -1,5 +1,6 @@
-use std::ops::DerefMut;
+use std::{cmp::Ordering, fmt::Display, ops::DerefMut};
 
+use super::{activity::ActivityBuilder, user::AdminUser};
 use serde::{Deserialize, Serialize};
 use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
 
@@ -7,22 +8,79 @@ use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
 pub struct Role {
     pub(crate) id: i64,
     pub(crate) name: String,
+    pub(crate) formatted_name: Option<String>,
+    pub(crate) desc: Option<String>,
+    pub(crate) hide_in_lists: bool,
     pub(crate) cluster: Option<String>,
 }
 
+// Implement PartialEq to compare roles based only on id
+impl PartialEq for Role {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+// Implement Eq to indicate that equality is reflexive
+impl Eq for Role {}
+
+// Implement PartialOrd if you need to sort or compare roles
+impl PartialOrd for Role {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.id.cmp(&other.id))
+    }
+}
+
+// Implement Ord if you need total ordering (for sorting)
+impl Ord for Role {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.id.cmp(&other.id)
+    }
+}
+
+impl Display for Role {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.name)
+    }
+}
+
 impl Role {
     pub async fn all(db: &SqlitePool) -> Vec<Role> {
-        sqlx::query_as!(Role, "SELECT id, name, cluster FROM role")
-            .fetch_all(db)
-            .await
-            .unwrap()
+        sqlx::query_as!(
+            Role,
+            "SELECT id, name, formatted_name, desc, hide_in_lists, cluster FROM role"
+        )
+        .fetch_all(db)
+        .await
+        .unwrap()
+    }
+
+    pub async fn all_cluster(db: &SqlitePool, cluster: &str) -> Vec<Role> {
+        sqlx::query_as!(
+            Role,
+            r#"SELECT id, 
+       CASE WHEN formatted_name IS NOT NULL AND formatted_name != '' 
+            THEN formatted_name 
+            ELSE name 
+       END AS "name!: String", 
+       '' as formatted_name,
+       desc, 
+       hide_in_lists, 
+       cluster 
+    FROM role 
+    WHERE cluster = ?"#,
+            cluster
+        )
+        .fetch_all(db)
+        .await
+        .unwrap()
     }
 
     pub async fn find_by_id(db: &SqlitePool, name: i32) -> Option<Self> {
         sqlx::query_as!(
             Self,
             "
-SELECT id, name, cluster
+SELECT id, name, formatted_name, desc, hide_in_lists, cluster
 FROM role 
 WHERE id like ?
         ",
@@ -36,7 +94,7 @@ WHERE id like ?
         sqlx::query_as!(
             Self,
             "
-SELECT id, name, cluster
+SELECT id, name, formatted_name, desc, hide_in_lists, cluster
 FROM role 
 WHERE id like ?
         ",
@@ -47,26 +105,11 @@ WHERE id like ?
         .ok()
     }
 
-    pub async fn find_by_cluster_tx(db: &mut Transaction<'_, Sqlite>, name: i32) -> Option<Self> {
-        sqlx::query_as!(
-            Self,
-            "
-SELECT id, name, cluster
-FROM role 
-WHERE cluster = ?
-        ",
-            name
-        )
-        .fetch_one(db.deref_mut())
-        .await
-        .ok()
-    }
-
     pub async fn find_by_name(db: &SqlitePool, name: &str) -> Option<Self> {
         sqlx::query_as!(
             Self,
             "
-SELECT id, name, cluster
+SELECT id, name, formatted_name, desc, hide_in_lists, cluster
 FROM role 
 WHERE name like ?
         ",
@@ -81,7 +124,7 @@ WHERE name like ?
         sqlx::query_as!(
             Self,
             "
-SELECT id, name, cluster
+SELECT id, name, formatted_name, desc, hide_in_lists, cluster
 FROM role 
 WHERE name like ?
         ",
@@ -92,6 +135,30 @@ WHERE name like ?
         .ok()
     }
 
+    pub async fn update(
+        &self,
+        db: &SqlitePool,
+        updated_by: &AdminUser,
+        formatted_name: &str,
+        desc: &str,
+    ) -> Result<(), String> {
+        sqlx::query!(
+            "UPDATE role SET formatted_name=?, desc=? WHERE id=?",
+            formatted_name,
+            desc,
+            self.id
+        )
+        .execute(db)
+        .await
+        .map_err(|e| e.to_string())?;
+
+        ActivityBuilder::new(&format!(
+            "{updated_by} hat Rolle {self} von {self:#?} auf FORMATTED_NAME={formatted_name}, DESC={desc} aktualisiert."
+        )).relevant_for_role(self).save(db).await;
+
+        Ok(())
+    }
+
     pub async fn names_from_role(&self, db: &SqlitePool) -> Vec<String> {
         let query = format!(
             "SELECT u.name

src/model/trip.rs

@@ -47,7 +47,7 @@ pub struct TripUpdate<'a> {
     pub is_locked: bool,
 }
 
-impl<'a> TripUpdate<'a> {
+impl TripUpdate<'_> {
     fn cancelled(&self) -> bool {
         self.max_people == -1
     }
@@ -567,9 +567,11 @@ mod test {
 
         let last_notification = &Notification::for_user(&pool, &cox).await[0];
 
-        assert!(last_notification
-            .message
-            .starts_with("cox2 hat eine Ausfahrt zur selben Zeit"));
+        assert!(
+            last_notification
+                .message
+                .starts_with("cox2 hat eine Ausfahrt zur selben Zeit")
+        );
     }
 
     #[sqlx::test]

src/model/user/basic.rs

@@ -0,0 +1,550 @@
+// TODO: put back in `src/model/user/mod.rs` once that is cleaned up
+
+use super::{AllowedToEditPaymentStatusUser, ManageUserUser, User};
+use crate::model::{
+    activity::ActivityBuilder, family::Family, mail::valid_mails, notification::Notification,
+    role::Role,
+};
+use chrono::NaiveDate;
+use rocket::{fs::TempFile, tokio::io::AsyncReadExt};
+use sqlx::SqlitePool;
+
+impl User {
+    pub(crate) async fn add_note(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        user: &User,
+        note: &str,
+    ) -> Result<(), String> {
+        let note = note.trim();
+
+        ActivityBuilder::new(&format!("({updated_by}) {note}"))
+            .relevant_for_user(user)
+            .save(db)
+            .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn update_mail(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        new_mail: &str,
+    ) -> Result<(), String> {
+        let new_mail = new_mail.trim();
+
+        if !valid_mails(new_mail) {
+            return Err(format!(
+                "{new_mail} ist kein gültiges Format für eine Mailadresse"
+            ));
+        }
+
+        sqlx::query!("UPDATE user SET mail = ? where id = ?", new_mail, self.id)
+            .execute(db)
+            .await
+            .unwrap(); //Okay, because we can only create a User of a valid id
+
+        let msg = match &self.mail {
+            Some(old_mail) => {
+                format!(
+                    "{updated_by} hat die Mail-Adresse von {self} von {old_mail} auf {new_mail} geändert."
+                )
+            }
+            None => {
+                format!("{updated_by} eine neue Mail-Adresse für {self} hinzugefügt: {new_mail}")
+            }
+        };
+
+        ActivityBuilder::new(&msg)
+            .relevant_for_user(self)
+            .save(db)
+            .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn update_phone(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        new_phone: &str,
+    ) {
+        let new_phone = new_phone.trim();
+
+        let query = if new_phone.is_empty() {
+            if self.phone.is_none() {
+                return; // nothing to do
+            }
+            sqlx::query!("UPDATE user SET phone = NULL where id = ?", self.id)
+        } else {
+            if let Some(old_phone) = &self.phone {
+                if old_phone == new_phone {
+                    return; //nothing to do
+                }
+            }
+            sqlx::query!("UPDATE user SET phone = ? where id = ?", new_phone, self.id)
+        };
+        query.execute(db).await.unwrap(); //Okay, because we can only create a User of a valid id
+
+        let msg = match &self.phone {
+            Some(old_phone) if new_phone.is_empty() => format!(
+                "{updated_by} hat die Telefonnummer von {self} entfernt (alte Nummer: {old_phone})"
+            ),
+            Some(old_phone) => format!(
+                "{updated_by} hat die Telefonnummer von {self} von {old_phone} auf {new_phone} geändert."
+            ),
+            None => format!(
+                "{updated_by} hat eine neue Telefonnummer für {self} hinzugefügt: {new_phone}"
+            ),
+        };
+
+        ActivityBuilder::new(&msg)
+            .relevant_for_user(self)
+            .save(db)
+            .await;
+    }
+
+    pub(crate) async fn update_address(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        new_address: &str,
+    ) {
+        let new_address = new_address.trim();
+
+        let query = if new_address.is_empty() {
+            if self.address.is_none() {
+                return; // nothing to do
+            }
+            sqlx::query!("UPDATE user SET address = NULL where id = ?", self.id)
+        } else {
+            if let Some(old_address) = &self.address {
+                if old_address == new_address {
+                    return; //nothing to do
+                }
+            }
+            sqlx::query!(
+                "UPDATE user SET address = ? where id = ?",
+                new_address,
+                self.id
+            )
+        };
+        query.execute(db).await.unwrap(); //Okay, because we can only create a User of a valid id
+
+        let msg = match &self.address {
+            Some(old_address) if new_address.is_empty() => format!(
+                "{updated_by} hat die Adresse von {self} entfernt (alte Adresse: {old_address})"
+            ),
+            Some(old_address) => format!(
+                "{updated_by} hat die Adresse von {self} von {old_address} auf {new_address} geändert."
+            ),
+            None => format!("{updated_by} hat eine Adresse für {self} hinzugefügt: {new_address}"),
+        };
+
+        ActivityBuilder::new(&msg)
+            .relevant_for_user(self)
+            .save(db)
+            .await;
+    }
+
+    pub(crate) async fn update_nickname(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        new_nickname: &str,
+    ) -> Result<(), String> {
+        let new_nickname = new_nickname.trim();
+
+        let query = if new_nickname.is_empty() {
+            sqlx::query!("UPDATE user SET nickname = NULL where id = ?", self.id)
+        } else {
+            sqlx::query!(
+                "UPDATE user SET nickname = ? where id = ?",
+                new_nickname,
+                self.id
+            )
+        };
+        query.execute(db).await.unwrap(); //Okay, because we can only create a User of a valid id
+
+        let msg = match &self.nickname {
+            Some(old_nickname) if new_nickname.is_empty() => format!(
+                "{updated_by} hat den Sitznamen von {self} entfernt (alter Spitzname: {old_nickname})"
+            ),
+            Some(old_nickname) => format!(
+                "{updated_by} hat den Spitznamen von {self} von {old_nickname} auf {new_nickname} geändert."
+            ),
+            None => format!(
+                "{updated_by} hat einen neuen Spitznamen für {self} hinzugefügt: {new_nickname}"
+            ),
+        };
+        ActivityBuilder::new(&msg)
+            .relevant_for_user(self)
+            .save(db)
+            .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn update_member_since(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        new_member_since_date: &NaiveDate,
+    ) {
+        sqlx::query!(
+            "UPDATE user SET member_since_date = ? where id = ?",
+            new_member_since_date,
+            self.id
+        )
+        .execute(db)
+        .await
+        .unwrap(); //Okay, because we can only create a User of a valid id
+
+        let msg = match &self.member_since_date {
+            Some(old_member_since_date) => format!(
+                "{updated_by} hat das Beitrittsdatum von {self} von {old_member_since_date} auf {new_member_since_date} geändert."
+            ),
+            None => format!(
+                "{updated_by} hat ein neues Beitrittsdatum für {self} hinzugefügt: {new_member_since_date}"
+            ),
+        };
+
+        ActivityBuilder::new(&msg)
+            .relevant_for_user(self)
+            .save(db)
+            .await;
+    }
+
+    pub(crate) async fn update_birthdate(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        new_birthdate: &NaiveDate,
+    ) {
+        sqlx::query!(
+            "UPDATE user SET birthdate = ? where id = ?",
+            new_birthdate,
+            self.id
+        )
+        .execute(db)
+        .await
+        .unwrap(); //Okay, because we can only create a User of a valid id
+
+        let msg = match &self.birthdate {
+            Some(old_birthdate) => format!(
+                "{updated_by} hat das Geburtsdatum von {self} von {old_birthdate} auf {new_birthdate} geändert."
+            ),
+            None => {
+                format!("{updated_by} hat ein Geburtsdatum für {self} hinzugefügt: {new_birthdate}")
+            }
+        };
+
+        ActivityBuilder::new(&msg)
+            .relevant_for_user(self)
+            .save(db)
+            .await;
+    }
+
+    pub(crate) async fn update_family(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        family: Option<Family>,
+    ) {
+        if let Some(family) = family {
+            let family_id = family.id;
+            sqlx::query!(
+                "UPDATE user SET family_id = ? where id = ?",
+                family_id,
+                self.id
+            )
+            .execute(db)
+            .await
+            .unwrap();
+            ActivityBuilder::new(&format!(
+                "{updated_by} hat {self} zu einer Familie hinzugefügt."
+            ))
+            .relevant_for_user(self)
+            .save(db)
+            .await;
+        } else {
+            sqlx::query!("UPDATE user SET family_id = NULL where id = ?", self.id)
+                .execute(db)
+                .await
+                .unwrap();
+            ActivityBuilder::new(&format!(
+                "{updated_by} hat die Familienzugehörigkeit von {self} gelöscht."
+            ))
+            .relevant_for_user(self)
+            .save(db)
+            .await;
+        };
+
+        Family::clean_families_without_members(db).await;
+    }
+
+    pub(crate) async fn change_skill(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        skill: Option<Role>,
+    ) -> Result<(), String> {
+        let old_skill = self.skill(db).await;
+
+        let member = Role::find_by_name(db, "Donau Linz").await.unwrap();
+        let cox = Role::find_by_name(db, "cox").await.unwrap();
+        let bootsfuehrer = Role::find_by_name(db, "Bootsführer").await.unwrap();
+
+        match (old_skill, skill) {
+            (None, new) if new == Some(cox.clone()) => {
+                self.add_role(db, updated_by, &cox).await?;
+                Notification::create_for_role(
+                    db,
+                    &member,
+                    &format!(
+                        "Liebes Vereinsmitglied, {self} ist ab sofort Steuerperson 🎉 Hip hip ...!"
+                    ),
+                    "Neue Steuerperson",
+                    None,
+                    None,
+                )
+                .await;
+                ActivityBuilder::new(&format!("{updated_by} hat {self} zur Steuerperson gemacht"))
+                    .relevant_for_user(self)
+                    .save(db)
+                    .await;
+            }
+            (old, new) if old == Some(cox.clone()) && new == Some(bootsfuehrer.clone()) => {
+                self.remove_role(db, updated_by, &cox).await?;
+                self.add_role(db, updated_by, &bootsfuehrer).await?;
+                Notification::create_for_role(
+                    db,
+                    &member,
+                    &format!(
+                        "Liebes Vereinsmitglied, {self} ist ab sofort Bootsführer:in 🎉 Hip hip ...!"
+                    ),
+                    "Neue:r Bootsführer:in",
+                    None,
+                    None,
+                )
+                .await;
+                ActivityBuilder::new(&format!("{updated_by} hat {self} zum Bootsführer gemacht"))
+                    .relevant_for_user(self)
+                    .save(db)
+                    .await;
+            }
+            (old, None) => {
+                if let Some(old) = old {
+                    self.remove_role(db, updated_by, &old).await?;
+                    let vorstand = Role::find_by_name(db, "Vorstand").await.unwrap();
+                    Notification::create_for_role(
+                        db,
+                        &vorstand,
+                        &format!("Lieber Vorstand, {self} ist ab kein {old} mehr."),
+                        "Steuerperson --",
+                        None,
+                        None,
+                    )
+                    .await;
+                    ActivityBuilder::new(&format!("{updated_by} hat {self} zum normalen Mitlgied gemacht (keine Steuerperson/Schiffsführer mehr)"))
+                    .relevant_for_user(self)
+                    .save(db)
+                    .await;
+                }
+            }
+            (old, new) => return Err(format!("Not allowed to change from {old:?} to {new:?}")),
+        };
+
+        Ok(())
+    }
+
+    pub(crate) async fn change_financial(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        financial: Option<Role>,
+    ) -> Result<(), String> {
+        let mut new = String::new();
+        let mut old = String::new();
+
+        if let Some(old_financial) = self.financial(db).await {
+            self.remove_role(db, updated_by, &old_financial).await?;
+            old.push_str(&old_financial.name);
+        } else {
+            old.push_str("Keine Ermäßigung");
+        }
+
+        if let Some(new_financial) = financial {
+            self.add_role(db, updated_by, &new_financial).await?;
+            new.push_str(&new_financial.name);
+        } else {
+            new.push_str("Keine Ermäßigung");
+        }
+
+        ActivityBuilder::new(&format!(
+            "{updated_by} hat die Ermäßigung von {self} von {old} auf {new} geändert"
+        ))
+        .relevant_for_user(self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn remove_role(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        role: &Role,
+    ) -> Result<(), String> {
+        if !self.has_role(db, &role.name).await {
+            return Err(format!(
+                "Kann Rolle {role} von User {self} nicht entfernen, da der User die Rolle gar nicht hat"
+            ));
+        }
+
+        sqlx::query!(
+            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
+            self.id,
+            role.id
+        )
+        .execute(db)
+        .await
+        .unwrap();
+
+        if !role.hide_in_lists && role.cluster.is_none() {
+            ActivityBuilder::new(&format!(
+                "{updated_by} hat die Rolle {role} von {self} entfernt."
+            ))
+            .relevant_for_user(self)
+            .save(db)
+            .await;
+        }
+
+        Ok(())
+    }
+
+    pub(crate) async fn has_not_paid(
+        &self,
+        db: &SqlitePool,
+        updated_by: &AllowedToEditPaymentStatusUser,
+    ) {
+        let paid = Role::find_by_name(db, "paid").await.unwrap();
+
+        sqlx::query!(
+            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
+            self.id,
+            paid.id
+        )
+        .execute(db)
+        .await
+        .unwrap();
+
+        ActivityBuilder::new(&format!(
+            "{updated_by} hat den Bezahlstatus von {self} auf 'nicht bezahlt' gesetzt."
+        ))
+        .relevant_for_user(self)
+        .save(db)
+        .await;
+    }
+    pub(crate) async fn has_paid(
+        &self,
+        db: &SqlitePool,
+        updated_by: &AllowedToEditPaymentStatusUser,
+    ) {
+        let paid = Role::find_by_name(db, "paid").await.unwrap();
+
+        sqlx::query!(
+            "INSERT INTO user_role(user_id, role_id) VALUES (?, ?)",
+            self.id,
+            paid.id
+        )
+        .execute(db)
+        .await
+        .expect("paid role has no group");
+
+        ActivityBuilder::new(&format!(
+            "{updated_by} hat den Bezahlstatus von {self} auf 'bezahlt' gesetzt."
+        ))
+        .relevant_for_user(self)
+        .save(db)
+        .await;
+    }
+
+    pub(crate) async fn add_role(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        role: &Role,
+    ) -> Result<(), String> {
+        if self.has_role(db, &role.name).await {
+            return Err(format!(
+                "Kann Rolle {role} von User {self} nicht hinzufügen, da der User die Rolle schon hat"
+            ));
+        }
+
+        sqlx::query!(
+            "INSERT INTO user_role(user_id, role_id) VALUES (?, ?)",
+            self.id,
+            role.id
+        )
+        .execute(db)
+        .await
+        .map_err(|_| {
+            format!(
+                "User already has a role in the cluster '{}'",
+                role.cluster
+                    .clone()
+                    .expect("db trigger can't activate on empty string")
+            )
+        })?;
+
+        if !role.hide_in_lists && role.cluster.is_none() {
+            ActivityBuilder::new(&format!(
+                "{updated_by} hat die Rolle '{role}' dem Benutzer {self} hinzugefügt."
+            ))
+            .relevant_for_user(self)
+            .save(db)
+            .await;
+        }
+
+        Ok(())
+    }
+
+    pub(crate) async fn add_membership_pdf(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        if self.has_membership_pdf(db).await {
+            return Err(format!("User {self} hat bereits eine Beitrittserklärung."));
+        }
+        if membership_pdf.len() == 0 {
+            return Err("Keine Beitrittserklärung mitgeschickt.".to_string());
+        }
+
+        let mut stream = membership_pdf.open().await.unwrap();
+        let mut buffer = Vec::new();
+        stream.read_to_end(&mut buffer).await.unwrap();
+        sqlx::query!(
+            "UPDATE user SET membership_pdf = ? where id = ?",
+            buffer,
+            self.id
+        )
+        .execute(db)
+        .await
+        .unwrap(); //Okay, because we can only create a User of a valid id
+
+        ActivityBuilder::new(&format!(
+            "{updated_by} hat die Mitgliedserklärung (PDF) für user {self} hinzugefügt."
+        ))
+        .relevant_for_user(self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+}

src/model/user/clubmember.rs

@@ -0,0 +1,167 @@
+use super::User;
+use crate::{
+    model::{
+        activity::ActivityBuilder, notification::Notification, role::Role, user::ManageUserUser,
+    },
+    special_user,
+};
+use rocket::async_trait;
+use sqlx::SqlitePool;
+
+special_user!(ClubMemberUser, +"Donau Linz", +"Förderndes Mitglied", +"Unterstützend");
+
+impl ClubMemberUser {
+    async fn add_membership_role(&self, db: &SqlitePool, role: &Role) {
+        sqlx::query!(
+            "INSERT INTO user_role(user_id, role_id) VALUES (?, ?)",
+            self.id,
+            role.id
+        )
+        .execute(db)
+        .await
+        .unwrap();
+    }
+
+    async fn remove_membership_role(&self, db: &SqlitePool) {
+        let role = Role::find_by_name(db, "Förderndes Mitglied").await.unwrap();
+        sqlx::query!(
+            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
+            self.id,
+            role.id
+        )
+        .execute(db)
+        .await
+        .unwrap();
+
+        let role = Role::find_by_name(db, "Unterstützend").await.unwrap();
+        sqlx::query!(
+            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
+            self.id,
+            role.id
+        )
+        .execute(db)
+        .await
+        .unwrap();
+
+        let role = Role::find_by_name(db, "Donau Linz").await.unwrap();
+        sqlx::query!(
+            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
+            self.id,
+            role.id
+        )
+        .execute(db)
+        .await
+        .unwrap();
+    }
+    async fn new_membership_role(&self, db: &SqlitePool, role: &str) -> Result<(), String> {
+        let role = Role::find_by_name(db, role).await.unwrap();
+        self.remove_membership_role(db).await;
+        self.add_membership_role(db, &role).await;
+        Ok(())
+    }
+
+    pub(crate) async fn move_to_regular(
+        self,
+        db: &SqlitePool,
+        modified_by: &ManageUserUser,
+    ) -> Result<(), String> {
+        if self.has_role(db, "Donau Linz").await {
+            return Err(format!("User {self} ist bereits reguläres Mitglied."));
+        }
+
+        self.new_membership_role(db, "Donau Linz").await?;
+
+        Notification::create_for_steering_people(
+            db,
+            &format!(
+                "Liebe Steuerberechtigte, {} hat upgegraded und ist nun ein neues reguläres Mitglied. 🎉",
+                self.name,
+            ),
+            "Neues Vereinsmitglied",
+            None,
+            None,
+        )
+        .await;
+
+        ActivityBuilder::new(&format!(
+            "{modified_by} hat {self} zu einem regulären hochgestuft."
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn move_to_unterstuetzend(
+        self,
+        db: &SqlitePool,
+        modified_by: &ManageUserUser,
+    ) -> Result<(), String> {
+        if self.has_role(db, "Unterstützend").await {
+            return Err(format!("User {self} ist bereits unterstützendes Mitglied."));
+        }
+
+        self.new_membership_role(db, "Unterstützend").await?;
+
+        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
+            Notification::create_for_role(
+                db,
+                &vorstand,
+                &format!(
+                    "Lieber Vorstand, der Mitgliedstatus von {} hat sich geändert auf 'Unterstützendes Mitglied'.",
+                    self.name,
+                ),
+                "Neues unterstützendes Vereinsmitglied",
+                None,
+                None,
+            )
+            .await;
+        }
+
+        ActivityBuilder::new(&format!(
+            "{modified_by} hat {self} zu einem unterstützenden Mitglied gemacht."
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn move_to_foerdernd(
+        self,
+        db: &SqlitePool,
+        modified_by: &ManageUserUser,
+    ) -> Result<(), String> {
+        if self.has_role(db, "Förderndes Mitglied").await {
+            return Err(format!("User {self} ist bereits förderndes Mitglied."));
+        }
+
+        self.new_membership_role(db, "Förderndes Mitglied").await?;
+
+        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
+            Notification::create_for_role(
+                db,
+                &vorstand,
+                &format!(
+                    "Lieber Vorstand, der Mitgliedstatus von {} hat sich geändert auf 'Förderndes Mitglied'.",
+                    self.name,
+                ),
+                "Neues förderndes Vereinsmitglied",
+                None,
+                None,
+            )
+            .await;
+        }
+
+        ActivityBuilder::new(&format!(
+            "{modified_by} hat {self} zu ein förderndes Mitglied gemacht."
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+}

src/model/user/fee.rs

@@ -1,7 +1,7 @@
 use super::User;
 use crate::{
-    model::family::Family, BOAT_STORAGE, EINSCHREIBGEBUEHR, FAMILY_THREE_OR_MORE, FAMILY_TWO,
-    FOERDERND, REGULAR, RENNRUDERBEITRAG, STUDENT_OR_PUPIL, UNTERSTUETZEND,
+    BOAT_STORAGE, EINSCHREIBGEBUEHR, FAMILY_THREE_OR_MORE, FAMILY_TWO, FOERDERND, REGULAR,
+    RENNRUDERBEITRAG, STUDENT_OR_PUPIL, UNTERSTUETZEND, model::family::Family,
 };
 use chrono::{Datelike, Local, NaiveDate};
 use serde::Serialize;

src/model/user/foerdernd.rs

@@ -0,0 +1,101 @@
+use super::{ManageUserUser, User, regular::ClubMember};
+use crate::{
+    NonEmptyString,
+    model::{activity::ActivityBuilder, mail::Mail, notification::Notification, role::Role},
+    special_user,
+};
+use chrono::NaiveDate;
+use rocket::{async_trait, fs::TempFile};
+use sqlx::SqlitePool;
+
+special_user!(FoerderndUser, +"Förderndes Mitglied");
+
+impl ClubMember for FoerderndUser {}
+
+impl FoerderndUser {
+    pub(crate) async fn send_welcome_mail_to_user(
+        &self,
+        db: &SqlitePool,
+        smtp_pw: &str,
+    ) -> Result<(), String> {
+        let Some(mail) = &self.mail else {
+            return Err(format!(
+                "Couldn't send welcome mail, as the user {self} has no mail..."
+            ));
+        };
+
+        Mail::send_single(
+            db,
+            mail,
+            "Willkommen im ASKÖ Ruderverein Donau Linz!",
+            format!(
+"Hallo {0},
+
+herzlich willkommen im ASKÖ Ruderverein Donau Linz! Wir freuen uns sehr, dich als neues Mitglied in unserem Verein begrüßen zu dürfen. 
+
+Um dir den Einstieg zu erleichtern, findest du in unserem Handbuch alle wichtigen Informationen über unseren Verein: https://rudernlinz.at/book. Bei weiteren Fragen stehen dir die Adressen info@rudernlinz.at (für allgemeine Fragen) und it@rudernlinz.at (bei technischen Fragen) jederzeit zur Verfügung.
+
+Damit du dich noch mehr verbunden fühlst (:-)), haben wir im Bootshaus ein WLAN für Vereinsmitglieder 'ASKÖ Ruderverein Donau Linz' eingerichtet. Das Passwort dafür lautet 'donau1921' (ohne Anführungszeichen). Bitte gib das Passwort an keine vereinsfremden Personen weiter.
+
+Riemen- & Dollenbruch
+ASKÖ Ruderverein Donau Linz", self.name),
+            smtp_pw,
+        ).await?;
+
+        ActivityBuilder::new(&format!(
+            "User {self} hat die Info-Mail bzgl. neues förderndes Mitglied (Handbuch und WLAN Infos) an {mail} gesendet bekommen"
+        ))
+        .relevant_for_user(self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn create(
+        db: &SqlitePool,
+        created_by: &ManageUserUser,
+        smtp_pw: &str,
+        name: NonEmptyString,
+        mail: &str,
+        financial: Option<Role>,
+        birthdate: &NaiveDate,
+        member_since: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        let role = Role::find_by_name(db, "Förderndes Mitglied").await.unwrap();
+        let user = Self::create_member(
+            db,
+            created_by,
+            &role,
+            name,
+            mail,
+            financial,
+            birthdate,
+            member_since,
+            phone,
+            address,
+            membership_pdf,
+        )
+        .await?;
+
+        let user = Self::new(db, &user).await.unwrap();
+        user.send_welcome_mail_to_user(db, smtp_pw).await?;
+
+        if let Some(vorstand) = Role::find_by_name(db, "Vorstand").await {
+            Notification::create_for_role(
+                db,
+                &vorstand,
+                &format!("Lieber Vorstand, es gibt ein neues förderndes Mitglied: {user}"),
+                "Neues unterstützendes Vereinsmitglied",
+                None,
+                None,
+            )
+            .await;
+        }
+
+        Ok(())
+    }
+}

src/model/user/member.rs

@@ -0,0 +1,54 @@
+use super::ScheckbuchUser;
+use crate::model::{
+    logbook::{Logbook, LogbookWithBoatAndRowers},
+    user::User,
+};
+use serde::{Deserialize, Serialize};
+use sqlx::SqlitePool;
+
+#[derive(Serialize, Deserialize)]
+pub(crate) enum Member {
+    SchnupperInterest(User),
+    Schnupperant(User),
+    Scheckbuch(Vec<LogbookWithBoatAndRowers>),
+    Regular(User),
+    Foerdernd(User),
+    Unterstuetzend(User),
+}
+
+impl Member {
+    pub(crate) async fn from(db: &SqlitePool, user: User) -> Self {
+        if ScheckbuchUser::new(db, &user).await.is_some() {
+            Self::Scheckbuch(Logbook::completed_with_user(db, &user).await)
+        } else if user.has_role(db, "schnupper-interessierte").await {
+            Self::SchnupperInterest(user)
+        } else if user.has_role(db, "schnupperant").await {
+            Self::Schnupperant(user)
+        } else if user.has_role(db, "Donau Linz").await {
+            Self::Regular(user)
+        } else if user.has_role(db, "Förderndes Mitglied").await {
+            Self::Foerdernd(user)
+        } else if user.has_role(db, "Unterstützend").await {
+            Self::Unterstuetzend(user)
+        } else {
+            panic!("User {user} has no membership_type!!");
+        }
+    }
+
+    pub(crate) fn is_club_member(&self) -> bool {
+        matches!(
+            self,
+            Member::Regular(_) | Member::Foerdernd(_) | Member::Unterstuetzend(_)
+        )
+    }
+    pub(crate) fn supposed_to_pay(&self) -> bool {
+        matches!(
+            self,
+            Member::Schnupperant(_)
+                | Member::Scheckbuch(_)
+                | Member::Regular(_)
+                | Member::Foerdernd(_)
+                | Member::Unterstuetzend(_)
+        )
+    }
+}

src/model/user/mod.rs

@@ -1,21 +1,21 @@
-use std::ops::{Deref, DerefMut};
+use std::{fmt::Display, ops::DerefMut};
 
-use argon2::{password_hash::SaltString, Argon2, PasswordHasher};
+use argon2::{Argon2, PasswordHasher, password_hash::SaltString};
 use chrono::{Datelike, Local, NaiveDate};
 use log::info;
+use rocket::async_trait;
 use rocket::{
-    async_trait,
-    http::{Cookie, Status},
-    request::{self, FromRequest, Outcome},
-    time::{Duration, OffsetDateTime},
-    tokio::io::AsyncReadExt,
     Request,
+    http::{Cookie, Status},
+    request::{FromRequest, Outcome},
+    time::{Duration, OffsetDateTime},
 };
 use serde::{Deserialize, Serialize};
 use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
 
+use super::activity::ActivityBuilder;
 use super::{
-    family::Family,
+    Day,
     log::Log,
     logbook::Logbook,
     mail::Mail,
@@ -24,13 +24,20 @@ use super::{
     role::Role,
     stat::Stat,
     tripdetails::TripDetails,
-    Day,
 };
-use crate::{tera::admin::user::UserEditForm, AMOUNT_DAYS_TO_SHOW_TRIPS_AHEAD};
+use crate::AMOUNT_DAYS_TO_SHOW_TRIPS_AHEAD;
 use scheckbuch::ScheckbuchUser;
 
+mod basic;
+pub(crate) mod clubmember;
 mod fee;
-mod scheckbuch;
+pub(crate) mod foerdernd;
+pub(crate) mod member;
+pub(crate) mod regular;
+pub(crate) mod scheckbuch;
+pub(crate) mod schnupperant;
+pub(crate) mod schnupperinterest;
+pub(crate) mod unterstuetzend;
 
 #[derive(FromRow, Serialize, Deserialize, Clone, Debug, Eq, Hash, PartialEq)]
 pub struct User {
@@ -53,6 +60,12 @@ pub struct User {
     pub user_token: String,
 }
 
+impl Display for User {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.name)
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct UserWithDetails {
     #[serde(flatten)]
@@ -100,128 +113,6 @@ impl User {
         self.has_role_tx(db, "cox").await || self.has_role_tx(db, "Bootsführer").await
     }
 
-    pub async fn send_welcome_email(&self, db: &SqlitePool, smtp_pw: &str) -> Result<(), String> {
-        let Some(mail) = &self.mail else {
-            return Err(format!(
-                "Could not send welcome mail, because user {} has no email address",
-                self.name
-            ));
-        };
-
-        if self.has_role(db, "Donau Linz").await {
-            self.send_welcome_mail_full_member(db, mail, smtp_pw)
-                .await?;
-        } else if self.has_role(db, "schnupperant").await {
-            self.send_welcome_mail_schnupper(db, mail, smtp_pw).await?;
-        } else if let Some(scheckbuch) = ScheckbuchUser::new(db, &self).await {
-            scheckbuch.notify(db, mail, smtp_pw).await?;
-        } else {
-            return Err(format!(
-                "Could not send welcome mail, because user {} is not in Donau Linz or scheckbuch or schnupperant group",
-                self.name
-            ));
-        }
-
-        Log::create(
-            db,
-            format!("Willkommensemail wurde an {} versandt", self.name),
-        )
-        .await;
-
-        Ok(())
-    }
-
-    async fn send_welcome_mail_schnupper(
-        &self,
-        db: &SqlitePool,
-        mail: &str,
-        smtp_pw: &str,
-    ) -> Result<(), String> {
-        // 2 things to do:
-        // 1. Send mail to user
-        Mail::send_single(
-            db,
-            mail,
-            "Schnupperrudern beim ASKÖ Ruderverein Donau Linz",
-            format!(
-"Hallo {0},
-
-es freut uns sehr, dich bei unserem Schnupperkurs willkommen heißen zu dürfen. Detaillierte Informationen folgen noch, ich werde sie dir ein paar Tage vor dem Termin zusenden.
-
-Riemen- & Dollenbruch,
-ASKÖ Ruderverein Donau Linz", self.name),
-            smtp_pw,
-        ).await?;
-
-        // 2. Notify all coxes
-        let coxes = Role::find_by_name(db, "schnupper-betreuer").await.unwrap();
-        Notification::create_for_role(
-            db,
-            &coxes,
-            &format!(
-                "Liebe Schnupper-Betreuer, {} nimmt am Schnupperkurs teil.",
-                self.name
-            ),
-            "Neue(r) Schnupperteilnehmer:in ",
-            None,
-            None,
-        )
-        .await;
-
-        Ok(())
-    }
-
-    async fn send_welcome_mail_full_member(
-        &self,
-        db: &SqlitePool,
-        mail: &str,
-        smtp_pw: &str,
-    ) -> Result<(), String> {
-        // 2 things to do:
-        // 1. Send mail to user
-        Mail::send_single(
-            db,
-            mail,
-            "Willkommen im ASKÖ Ruderverein Donau Linz!",
-            format!(
-"Hallo {0},
-
-herzlich willkommen im ASKÖ Ruderverein Donau Linz! Wir freuen uns sehr, dich als neues Mitglied in unserem Verein begrüßen zu dürfen. 
-
-Um dir den Einstieg zu erleichtern, findest du in unserem Handbuch alle wichtigen Informationen über unseren Verein: https://rudernlinz.at/book. Bei weiteren Fragen stehen dir die Adressen info@rudernlinz.at (für allgemeine Fragen) und it@rudernlinz.at (bei technischen Fragen) jederzeit zur Verfügung.
-
-Du kannst auch gerne unserer Signal-Gruppe beitreten, um auf dem Laufenden zu bleiben und dich mit anderen Mitgliedern auszutauschen: https://signal.group/#CjQKICFrq6zSsRHxrucS3jEcQn6lknEXacAykwwLV3vNLKxPEhA17jxz7cpjfu3JZokLq1TH
-
-Für die Organisation unserer Ausfahrten nutzen wir app.rudernlinz.at. Logge dich einfach mit deinem Namen ('{0}' ohne Anführungszeichen) ein, beim ersten Mal kannst du das Passwortfeld leer lassen. Unter 'Geplante Ausfahrten' kannst du dich jederzeit zu den Ausfahrten anmelden.
-
-Beim nächsten Treffen im Verein, erinnere jemand vom Vorstand (https://rudernlinz.at/unser-verein/vorstand/) bitte daran, deinen Fingerabdruck zu registrieren, damit du Zugang zum Bootshaus erhältst.
-
-Damit du dich noch mehr verbunden fühlst (:-)), haben wir im Bootshaus ein WLAN für Vereinsmitglieder 'ASKÖ Ruderverein Donau Linz' eingerichtet. Das Passwort dafür lautet 'donau1921' (ohne Anführungszeichen). Bitte gib das Passwort an keine vereinsfremden Personen weiter.
-
-Wir freuen uns darauf, dich bald am Wasser zu sehen und gemeinsam tolle Erfahrungen zu sammeln!
-
-Riemen- & Dollenbruch
-ASKÖ Ruderverein Donau Linz", self.name),
-            smtp_pw,
-        ).await?;
-
-        // 2. Notify all coxes
-        Notification::create_for_steering_people(
-            db,
-            &format!(
-                "Liebe Steuerberechtigte, seit {} gibt es ein neues Mitglied: {}",
-                self.member_since_date.clone().unwrap(),
-                self.name
-            ),
-            "Neues Vereinsmitglied",
-            None,
-            None,
-        )
-        .await;
-
-        Ok(())
-    }
-
     pub async fn amount_boats(&self, db: &SqlitePool) -> i64 {
         sqlx::query!(
             "SELECT COUNT(*) as count FROM boat WHERE owner = ?",
@@ -262,7 +153,7 @@ ASKÖ Ruderverein Donau Linz", self.name),
     }
 
     pub async fn allowed_to_update_always_show_trip(&self, db: &SqlitePool) -> bool {
-        AllowedToUpdateTripToAlwaysBeShownUser::new(db, &self)
+        AllowedToUpdateTripToAlwaysBeShownUser::new(db, self)
             .await
             .is_some()
     }
@@ -301,10 +192,44 @@ ASKÖ Ruderverein Donau Linz", self.name),
         .into_iter().map(|r| r.name).collect()
     }
 
+    pub async fn financial(&self, db: &SqlitePool) -> Option<Role> {
+        sqlx::query_as!(
+            Role,
+            "
+            SELECT r.id, r.name, r.formatted_name, r.desc, r.hide_in_lists, r.cluster
+FROM role r
+JOIN user_role ur ON r.id = ur.role_id
+WHERE ur.user_id = ?
+AND r.cluster = 'financial';
+        ",
+            self.id
+        )
+        .fetch_optional(db)
+        .await
+        .unwrap()
+    }
+
+    pub async fn skill(&self, db: &SqlitePool) -> Option<Role> {
+        sqlx::query_as!(
+            Role,
+            "
+            SELECT r.id, r.name, r.formatted_name, r.desc, r.hide_in_lists, r.cluster
+FROM role r
+JOIN user_role ur ON r.id = ur.role_id
+WHERE ur.user_id = ?
+AND r.cluster = 'skill';
+        ",
+            self.id
+        )
+        .fetch_optional(db)
+        .await
+        .unwrap()
+    }
+
     pub async fn real_roles(&self, db: &SqlitePool) -> Vec<Role> {
         sqlx::query_as!(
             Role,
-            "SELECT r.id, r.name, r.cluster 
+            "SELECT r.id, r.name, r.cluster, r.formatted_name, r.desc, r.hide_in_lists
          FROM role r 
          JOIN user_role ur ON r.id = ur.role_id 
          JOIN user u ON u.id = ur.user_id 
@@ -494,22 +419,6 @@ ORDER BY last_access DESC
         .unwrap()
     }
 
-    pub async fn create(db: &SqlitePool, name: &str) -> bool {
-        let name = name.trim();
-        sqlx::query!("INSERT INTO USER(name) VALUES (?)", name)
-            .execute(db)
-            .await
-            .is_ok()
-    }
-
-    pub async fn create_with_mail(db: &SqlitePool, name: &str, mail: &str) -> bool {
-        let name = name.trim();
-        sqlx::query!("INSERT INTO USER(name, mail) VALUES (?, ?)", name, mail)
-            .execute(db)
-            .await
-            .is_ok()
-    }
-
     pub async fn update_ergo(&self, db: &SqlitePool, dob: i32, weight: i64, sex: &str) {
         sqlx::query!(
             "UPDATE user SET dob = ?, weight = ?, sex = ? where id = ?",
@@ -523,88 +432,6 @@ ORDER BY last_access DESC
         .unwrap(); //Okay, because we can only create a User of a valid id
     }
 
-    pub async fn update(&self, db: &SqlitePool, data: UserEditForm<'_>) -> Result<(), String> {
-        let mut db = db.begin().await.map_err(|e| e.to_string())?;
-
-        let mut family_id = data.family_id;
-
-        if family_id.is_some_and(|x| x == -1) {
-            family_id = Some(Family::insert_tx(&mut db).await)
-        }
-
-        if !self.has_membership_pdf_tx(&mut db).await {
-            if let Some(membership_pdf) = data.membership_pdf {
-                let mut stream = membership_pdf.open().await.unwrap();
-                let mut buffer = Vec::new();
-                stream.read_to_end(&mut buffer).await.unwrap();
-                sqlx::query!(
-                    "UPDATE user SET membership_pdf = ? where id = ?",
-                    buffer,
-                    self.id
-                )
-                .execute(db.deref_mut())
-                .await
-                .unwrap(); //Okay, because we can only create a User of a valid id
-            }
-        }
-
-        sqlx::query!(
-            "UPDATE user SET dob = ?, weight = ?, sex = ?, member_since_date=?, birthdate=?, mail=?, nickname=?, notes=?, phone=?, address=?, family_id = ? where id = ?",
-            data.dob,
-            data.weight,
-            data.sex,
-            data.member_since_date,
-            data.birthdate,
-            data.mail,
-            data.nickname,
-            data.notes,
-            data.phone,
-            data.address,
-            family_id,
-            self.id
-        )
-        .execute(db.deref_mut())
-        .await
-        .unwrap(); //Okay, because we can only create a User of a valid id
-
-        // handle roles
-        sqlx::query!("DELETE FROM user_role WHERE user_id = ?", self.id)
-            .execute(db.deref_mut())
-            .await
-            .unwrap();
-
-        for role_id in data.roles.into_keys() {
-            let role = Role::find_by_id_tx(&mut db, role_id.parse::<i32>().unwrap())
-                .await
-                .unwrap();
-            self.add_role_tx(&mut db, &role).await?;
-        }
-
-        db.commit().await.map_err(|e| e.to_string())?;
-
-        Ok(())
-    }
-
-    pub async fn add_role(&self, db: &SqlitePool, role: &Role) -> Result<(), String> {
-        sqlx::query!(
-            "INSERT INTO user_role(user_id, role_id) VALUES (?, ?)",
-            self.id,
-            role.id
-        )
-        .execute(db)
-        .await
-        .map_err(|_| {
-            format!(
-                "User already has a role in the cluster '{}'",
-                role.cluster
-                    .clone()
-                    .expect("db trigger can't activate on empty string")
-            )
-        })?;
-
-        Ok(())
-    }
-
     async fn send_end_mail_scheckbuch(
         &self,
         db: &mut Transaction<'_, Sqlite>,
@@ -631,44 +458,11 @@ ASKÖ Ruderverein Donau Linz", self.name),
             smtp_pw,
         ).await?;
 
-        Ok(())
-    }
-
-    pub async fn add_role_tx(
-        &self,
-        db: &mut Transaction<'_, Sqlite>,
-        role: &Role,
-    ) -> Result<(), String> {
-        sqlx::query!(
-            "INSERT INTO user_role(user_id, role_id) VALUES (?, ?)",
-            self.id,
-            role.id
-        )
-        .execute(db.deref_mut())
-        .await
-        .map_err(|_| {
-            format!(
-                "User already has a role in the cluster '{}'",
-                role.cluster
-                    .clone()
-                    .expect("db trigger can't activate on empty string")
-            )
-        })?;
+        ActivityBuilder::new(&format!("User {self} hat eine Mail bekommen, dass seine 5 Ausfahrten mit der heutigen Ausfahrt aufgebraucht sind, und dass der nächste Schritt eine Vereinsmitgliedschaft wäre (inkl. Links zu Beitrittserklärung + Info, dass sie an info@ geschickt werden soll.")).relevant_for_user(self).save_tx(db).await;
 
         Ok(())
     }
 
-    pub async fn remove_role(&self, db: &SqlitePool, role: &Role) {
-        sqlx::query!(
-            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
-            self.id,
-            role.id
-        )
-        .execute(db)
-        .await
-        .unwrap();
-    }
-
     pub async fn login(db: &SqlitePool, name: &str, pw: &str) -> Result<Self, LoginError> {
         let name = name.trim().to_lowercase(); // just to make sure...
         let Some(user) = User::find_by_name(db, &name).await else {
@@ -711,13 +505,14 @@ ASKÖ Ruderverein Donau Linz", self.name),
         };
 
         if user.deleted {
-            Log::create(
-                db,
-                format!("User ({name}) already deleted (tried to login)."),
-            )
+            ActivityBuilder::new(&format!(
+                "User {user} wollte sich einloggen, klappte jedoch nicht weil er gelöscht wurde."
+            ))
+            .relevant_for_user(&user)
+            .save(db)
             .await;
             return Err(LoginError::InvalidAuthenticationCombo); //User existed sometime ago; has
-                                                                //been deleted
+            //been deleted
         }
 
         if let Some(user_pw) = user.pw.as_ref() {
@@ -725,7 +520,12 @@ ASKÖ Ruderverein Donau Linz", self.name),
             if password_hash == user_pw {
                 return Ok(user);
             }
-            Log::create(db, format!("User {name} supplied the wrong PW")).await;
+            ActivityBuilder::new(&format!(
+                "User {user} wollte sich einloggen, hat jedoch das falsche Passwort angegeben."
+            ))
+            .relevant_for_user(&user)
+            .save(db)
+            .await;
             Err(LoginError::InvalidAuthenticationCombo)
         } else {
             info!("User {name} has no PW set");
@@ -738,6 +538,12 @@ ASKÖ Ruderverein Donau Linz", self.name),
             .execute(db)
             .await
             .unwrap(); //Okay, because we can only create a User of a valid id
+
+        // TODO: add responsible person
+        ActivityBuilder::new(&format!("Passwort von User {self} wurde zurückgesetzt."))
+            .relevant_for_user(self)
+            .save(db)
+            .await;
     }
 
     pub async fn update_pw(&self, db: &SqlitePool, pw: &str) {
@@ -746,6 +552,12 @@ ASKÖ Ruderverein Donau Linz", self.name),
             .execute(db)
             .await
             .unwrap(); //Okay, because we can only create a User of a valid id
+        ActivityBuilder::new(&format!(
+            "Passwort von User {self} wurde erfolgreich geändert."
+        ))
+        .relevant_for_user(self)
+        .save(db)
+        .await;
     }
 
     fn get_hashed_pw(pw: &str) -> String {
@@ -767,11 +579,15 @@ ASKÖ Ruderverein Donau Linz", self.name),
         .unwrap(); //Okay, because we can only create a User of a valid id
     }
 
-    pub async fn delete(&self, db: &SqlitePool) {
+    pub async fn delete(&self, db: &SqlitePool, deleted_by: &ManageUserUser) {
         sqlx::query!("UPDATE user SET deleted=1 WHERE id=?", self.id)
             .execute(db)
             .await
             .unwrap(); //Okay, because we can only create a User of a valid id
+        ActivityBuilder::new(&format!("User {self} wurde von {deleted_by} gelöscht."))
+            .relevant_for_user(self)
+            .save(db)
+            .await;
     }
 
     pub async fn get_days(&self, db: &SqlitePool) -> Vec<Day> {
@@ -802,9 +618,9 @@ ASKÖ Ruderverein Donau Linz", self.name),
     pub(crate) async fn amount_days_to_show(&self, db: &SqlitePool) -> i64 {
         if self.allowed_to_steer(db).await {
             let end_of_year = NaiveDate::from_ymd_opt(Local::now().year(), 12, 31).unwrap(); //Ok,
-                                                                                             //december
-                                                                                             //has 31
-                                                                                             //days
+            //december
+            //has 31
+            //days
             let days_left_in_year = end_of_year
                 .signed_duration_since(Local::now().date_naive())
                 .num_days()
@@ -813,9 +629,9 @@ ASKÖ Ruderverein Donau Linz", self.name),
             if days_left_in_year <= 31 {
                 let end_of_next_year =
                     NaiveDate::from_ymd_opt(Local::now().year() + 1, 12, 31).unwrap(); //Ok,
-                                                                                       //december
-                                                                                       //has 31
-                                                                                       //days
+                //december
+                //has 31
+                //days
                 end_of_next_year
                     .signed_duration_since(Local::now().date_naive())
                     .num_days()
@@ -863,6 +679,10 @@ ASKÖ Ruderverein Donau Linz", self.name),
                         None,None
                     )
                     .await;
+                    ActivityBuilder::new(&format!("5 Scheckbuchausfahrten von {self} wurden mit der heutigen Ausfahrt aufgebraucht. Info-Mail wurde an {self} geschickt + alle Steuerberechtigten informiert, dass wir pot. ein neues Mitglied haben"))
+                        .relevant_for_user(self)
+                        .save_tx(db)
+                        .await;
                 }
                 a if a > 5 => {
                     let board = Role::find_by_name_tx(db, "Vorstand").await.unwrap();
@@ -877,6 +697,10 @@ ASKÖ Ruderverein Donau Linz", self.name),
                         None,None
                     )
                     .await;
+                    ActivityBuilder::new(&format!("{self} hat nun bereits die {amount_trips}. seiner 5 Scheckbuchausfahrten absolviert. Vorstand wurde via Notification informiert."))
+                        .relevant_for_user(self)
+                        .save_tx(db)
+                        .await;
                 }
                 _ => {}
             }
@@ -896,6 +720,12 @@ ASKÖ Ruderverein Donau Linz", self.name),
             None,None
         )
         .await;
+            ActivityBuilder::new(&format!(
+                "{self} hat das heurige Fahrtenabzeichen geschafft! Der Vorstand + {self} wurde via Notification informiert."
+            ))
+            .relevant_for_user(self)
+            .save_tx(db)
+            .await;
 
             Notification::create_with_tx(db, self, "Mit deiner letzten Ausfahrt hast du nun alle Anforderungen für das heurige Fahrtenzeichen erfüllt. Gratuliere! 🎉", "Fahrtenabzeichen geschafft", None, None).await;
         }
@@ -914,6 +744,10 @@ ASKÖ Ruderverein Donau Linz", self.name),
             None,None
         )
         .await;
+            ActivityBuilder::new(&format!("{self} hat den Äquatorpreis in {level} geschafft! Der Vorstand + {self} wurde via Notification informiert."))
+                .relevant_for_user(self)
+                .save_tx(db)
+                .await;
 
             Notification::create_with_tx(db, self, &format!("Mit deiner letzten Ausfahrt erfüllst du nun alle Anforderungen für den Äquatorpreis in {level}. Gratuliere! 🎉"), "Äquatorpreis", None, None).await;
         }
@@ -924,7 +758,7 @@ ASKÖ Ruderverein Donau Linz", self.name),
 impl<'r> FromRequest<'r> for User {
     type Error = LoginError;
 
-    async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
+    async fn from_request(req: &'r Request<'_>) -> rocket::request::Outcome<Self, Self::Error> {
         match req.cookies().get_private("loggedin_user") {
             Some(user_id) => match user_id.value().parse::<i32>() {
                 Ok(user_id) => {
@@ -954,12 +788,12 @@ impl<'r> FromRequest<'r> for User {
 #[macro_export]
 macro_rules! special_user {
     ($name:ident, $($role:tt)*) => {
-        #[derive(Debug)]
+        #[derive(Debug, serde::Serialize, serde::Deserialize)]
         pub struct $name {
             pub(crate) user: User,
         }
 
-        impl Deref for $name {
+        impl std::ops::Deref for $name {
             type Target = User;
             fn deref(&self) -> &Self::Target {
                 &self.user
@@ -973,20 +807,20 @@ macro_rules! special_user {
         }
 
         #[async_trait]
-        impl<'r> FromRequest<'r> for $name {
-            type Error = LoginError;
-            async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
+        impl<'r> rocket::request::FromRequest<'r> for $name {
+            type Error = $crate::model::user::LoginError;
+            async fn from_request(req: &'r rocket::request::Request<'_>) -> rocket::request::Outcome<Self, Self::Error> {
                 let db = req.rocket().state::<SqlitePool>().unwrap();
                 match User::from_request(req).await {
-                    Outcome::Success(user) => {
+                    rocket::request::Outcome::Success(user) => {
                         if special_user!(@check_roles user, db, $($role)*) {
-                            Outcome::Success($name { user })
+                            rocket::request::Outcome::Success($name { user })
                         } else {
-                            Outcome::Forward(Status::Forbidden)
+                            rocket::request::Outcome::Forward(rocket::http::Status::Forbidden)
                         }
                     }
-                    Outcome::Error(f) => Outcome::Error(f),
-                    Outcome::Forward(f) => Outcome::Forward(f),
+                    rocket::request::Outcome::Error(f) => rocket::request::Outcome::Error(f),
+                    rocket::request::Outcome::Forward(f) => rocket::request::Outcome::Forward(f),
                 }
             }
         }
@@ -1000,6 +834,12 @@ macro_rules! special_user {
                 }
             }
         }
+
+        impl std::fmt::Display for $name {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(f, "{}", self.name)
+            }
+        }
     };
     (@check_roles $user:ident, $db:ident, $(+$role:expr),* $(,-$neg_role:expr)*) => {
         {
@@ -1021,8 +861,10 @@ special_user!(TechUser, +"tech");
 special_user!(ErgoUser, +"ergo");
 special_user!(SteeringUser, +"cox", +"Bootsführer");
 special_user!(AdminUser, +"admin");
-special_user!(AllowedForPlannedTripsUser, +"Donau Linz", +"scheckbuch");
-special_user!(DonauLinzUser, +"Donau Linz", -"Unterstützend", -"Förderndes Mitglied");
+special_user!(AllowedForPlannedTripsUser, +"Donau Linz", +"scheckbuch", +"Förderndes Mitglied");
+special_user!(DonauLinzUser, +"Donau Linz", -"Unterstützend", -"Förderndes Mitglied"); // TODO:
+// remove ->
+// RegularUser
 special_user!(SchnupperBetreuerUser, +"schnupper-betreuer");
 special_user!(VorstandUser, +"admin", +"Vorstand");
 special_user!(EventUser, +"manage_events");
@@ -1036,7 +878,8 @@ pub struct UserWithRolesAndMembershipPdf {
     #[serde(flatten)]
     pub user: User,
     pub membership_pdf: bool,
-    pub roles: Vec<String>,
+    pub roles: Vec<String>, // TODO: remove
+    pub proper_roles: Vec<Role>,
 }
 
 impl UserWithRolesAndMembershipPdf {
@@ -1045,6 +888,7 @@ impl UserWithRolesAndMembershipPdf {
 
         Self {
             roles: user.roles(db).await,
+            proper_roles: user.real_roles(db).await,
             user,
             membership_pdf,
         }
@@ -1076,9 +920,7 @@ impl UserWithMembershipPdf {
 
 #[cfg(test)]
 mod test {
-    use std::collections::HashMap;
-
-    use crate::{tera::admin::user::UserEditForm, testdb};
+    use crate::testdb;
 
     use super::User;
     use sqlx::SqlitePool;
@@ -1125,52 +967,6 @@ mod test {
         assert_eq!(res.len(), 4);
     }
 
-    #[sqlx::test]
-    fn test_succ_create() {
-        let pool = testdb!();
-
-        assert_eq!(User::create(&pool, "new-user-name".into()).await, true);
-    }
-
-    #[sqlx::test]
-    fn test_duplicate_name_create() {
-        let pool = testdb!();
-
-        assert_eq!(User::create(&pool, "admin".into()).await, false);
-    }
-
-    #[sqlx::test]
-    fn test_update() {
-        let pool = testdb!();
-
-        let user = User::find_by_id(&pool, 1).await.unwrap();
-        user.update(
-            &pool,
-            UserEditForm {
-                id: 1,
-                dob: None,
-                weight: None,
-                sex: Some("m".into()),
-                roles: HashMap::new(),
-                member_since_date: None,
-                birthdate: None,
-                mail: None,
-                nickname: None,
-                notes: None,
-                phone: None,
-                address: None,
-                family_id: None,
-                membership_pdf: None,
-            },
-        )
-        .await
-        .unwrap();
-
-        let user = User::find_by_id(&pool, 1).await.unwrap();
-
-        assert_eq!(user.sex, Some("m".into()));
-    }
-
     #[sqlx::test]
     fn succ_login_with_test_db() {
         let pool = testdb!();
@@ -1182,17 +978,21 @@ mod test {
     #[sqlx::test]
     fn wrong_pw() {
         let pool = testdb!();
-        assert!(User::login(&pool, "admin".into(), "admi".into())
-            .await
-            .is_err());
+        assert!(
+            User::login(&pool, "admin".into(), "admi".into())
+                .await
+                .is_err()
+        );
     }
 
     #[sqlx::test]
     fn wrong_username() {
         let pool = testdb!();
-        assert!(User::login(&pool, "admi".into(), "admin".into())
-            .await
-            .is_err());
+        assert!(
+            User::login(&pool, "admi".into(), "admin".into())
+                .await
+                .is_err()
+        );
     }
 
     #[sqlx::test]
@@ -1211,9 +1011,11 @@ mod test {
         let pool = testdb!();
         let user = User::find_by_id(&pool, 1).await.unwrap();
 
-        assert!(User::login(&pool, "admin".into(), "abc".into())
-            .await
-            .is_err());
+        assert!(
+            User::login(&pool, "admin".into(), "abc".into())
+                .await
+                .is_err()
+        );
 
         user.update_pw(&pool, "abc".into()).await;
 

src/model/user/regular.rs

@@ -0,0 +1,154 @@
+use super::{ManageUserUser, User};
+use crate::{
+    NonEmptyString,
+    model::{activity::ActivityBuilder, mail::Mail, notification::Notification, role::Role},
+    special_user,
+};
+use chrono::NaiveDate;
+use rocket::{async_trait, fs::TempFile, tokio::io::AsyncReadExt};
+use sqlx::SqlitePool;
+
+special_user!(RegularUser, +"Donau Linz");
+
+pub trait ClubMember {
+    async fn create_member(
+        db: &SqlitePool,
+        created_by: &ManageUserUser,
+        role: &Role,
+        name: NonEmptyString,
+        mail: &str,
+        financial: Option<Role>,
+        birthdate: &NaiveDate,
+        member_since: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<User, String> {
+        if membership_pdf.len() == 0 {
+            return Err("Keine Beitrittserklärung mitgeschickt.".to_string());
+        }
+
+        let mut stream = membership_pdf.open().await.unwrap();
+        let mut buffer = Vec::new();
+        stream.read_to_end(&mut buffer).await.unwrap();
+
+        let name = name.as_str();
+        let phone = phone.as_str();
+        let address = address.as_str();
+
+        sqlx::query!(
+            "INSERT INTO user(name, member_since_date, birthdate, mail, phone, address, membership_pdf)
+            VALUES (?,?,?,?,?,?,?)",
+            name, member_since, birthdate, mail, phone, address,buffer
+        )
+        .execute(db)
+        .await
+        .map_err(|e| e.to_string())?;
+
+        let user = User::find_by_name(db, name).await.unwrap();
+        user.change_financial(db, created_by, financial).await?;
+        user.add_role(db, created_by, role).await?;
+
+        ActivityBuilder::new(&format!(
+            "{created_by} hat Mitglied {user} mit der Rolle {role} angelegt."
+        ))
+        .relevant_for_user(&user)
+        .save(db)
+        .await;
+
+        Ok(user)
+    }
+}
+
+impl ClubMember for RegularUser {}
+
+impl RegularUser {
+    pub(crate) async fn send_welcome_mail_to_user(
+        &self,
+        db: &SqlitePool,
+        smtp_pw: &str,
+    ) -> Result<(), String> {
+        let Some(mail) = &self.mail else {
+            return Err(format!(
+                "Couldn't send welcome mail, as the user {self} has no mail..."
+            ));
+        };
+
+        Mail::send_single(
+            db,
+            mail,
+            "Willkommen im ASKÖ Ruderverein Donau Linz!",
+            format!(
+"Hallo {0},
+
+herzlich willkommen im ASKÖ Ruderverein Donau Linz! Wir freuen uns sehr, dich als neues Mitglied in unserem Verein begrüßen zu dürfen. 
+
+Um dir den Einstieg zu erleichtern, findest du in unserem Handbuch alle wichtigen Informationen über unseren Verein: https://rudernlinz.at/book. Bei weiteren Fragen stehen dir die Adressen info@rudernlinz.at (für allgemeine Fragen) und it@rudernlinz.at (bei technischen Fragen) jederzeit zur Verfügung.
+
+Du kannst auch gerne unserer Signal-Gruppe beitreten, um auf dem Laufenden zu bleiben und dich mit anderen Mitgliedern auszutauschen: https://signal.group/#CjQKICFrq6zSsRHxrucS3jEcQn6lknEXacAykwwLV3vNLKxPEhA17jxz7cpjfu3JZokLq1TH
+
+Für die Organisation unserer Ausfahrten nutzen wir app.rudernlinz.at. Logge dich einfach mit deinem Namen ('{0}' ohne Anführungszeichen) ein, beim ersten Mal kannst du das Passwortfeld leer lassen. Unter 'Geplante Ausfahrten' kannst du dich jederzeit zu den Ausfahrten anmelden.
+
+Beim nächsten Treffen im Verein, erinnere jemand vom Vorstand (https://rudernlinz.at/unser-verein/vorstand/) bitte daran, deinen Fingerabdruck zu registrieren, damit du Zugang zum Bootshaus erhältst.
+
+Damit du dich noch mehr verbunden fühlst (:-)), haben wir im Bootshaus ein WLAN für Vereinsmitglieder 'ASKÖ Ruderverein Donau Linz' eingerichtet. Das Passwort dafür lautet 'donau1921' (ohne Anführungszeichen). Bitte gib das Passwort an keine vereinsfremden Personen weiter.
+
+Wir freuen uns darauf, dich bald am Wasser zu sehen und gemeinsam tolle Erfahrungen zu sammeln!
+
+Riemen- & Dollenbruch
+ASKÖ Ruderverein Donau Linz", self.name),
+            smtp_pw,
+        ).await?;
+
+        ActivityBuilder::new(&format!("Willkommensmail für {self} wurde an {mail} verschickt (Handbuch, Signal-Gruppe, App-Info, Fingerprint, WLAN)."))
+                .relevant_for_user(self)
+                .save(db)
+                .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn create(
+        db: &SqlitePool,
+        created_by: &ManageUserUser,
+        smtp_pw: &str,
+        name: NonEmptyString,
+        mail: &str,
+        financial: Option<Role>,
+        birthdate: &NaiveDate,
+        member_since: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        let role = Role::find_by_name(db, "Donau Linz").await.unwrap();
+        let user = Self::create_member(
+            db,
+            created_by,
+            &role,
+            name,
+            mail,
+            financial,
+            birthdate,
+            member_since,
+            phone,
+            address,
+            membership_pdf,
+        )
+        .await?;
+
+        let user = Self::new(db, &user).await.unwrap();
+        user.send_welcome_mail_to_user(db, smtp_pw).await?;
+
+        Notification::create_for_steering_people(
+            db,
+            &format!("Liebe Steuerberechtigte, es gibt ein neues Mitglied: {user} 🎉"),
+            "Neues Vereinsmitglied",
+            None,
+            None,
+        )
+        .await;
+
+        Ok(())
+    }
+}

src/model/user/scheckbuch.rs

@@ -1,58 +1,237 @@
-use super::User;
-use crate::model::user::LoginError;
+use super::foerdernd::FoerderndUser;
+use super::regular::RegularUser;
+use super::unterstuetzend::UnterstuetzendUser;
+use super::{ManageUserUser, User};
+use crate::NonEmptyString;
+use crate::model::activity::ActivityBuilder;
+use crate::model::role::Role;
 use crate::{
-    model::{mail::Mail, notification::Notification, role::Role},
-    special_user, SCHECKBUCH,
+    SCHECKBUCH,
+    model::{mail::Mail, notification::Notification},
+    special_user,
 };
+use chrono::NaiveDate;
 use rocket::async_trait;
-use rocket::http::Status;
-use rocket::request;
-use rocket::request::FromRequest;
-use rocket::request::Outcome;
-use rocket::Request;
+use rocket::fs::TempFile;
 use sqlx::SqlitePool;
-use std::ops::Deref;
 
 special_user!(ScheckbuchUser, +"scheckbuch");
 
 impl ScheckbuchUser {
-    async fn from(user: User, db: &SqlitePool, mail: &str, smtp_pw: &str) -> Result<(), String> {
-        // TODO: see when/how to invoke this function (explicit `Neue Person hinzufügen` button?
-        // Button to transition existing users to scheckbuch? Automatically called when
-        // `scheckbuch` is newly selected as role?
-        if user.has_role(db, "scheckbuch").await {
-            return Err("User is already a scheckbuch".into());
-        }
-
-        // TODO: do we allow e.g. DonauLinz to scheckbuch?
-
-        let scheckbuch = Role::find_by_name(db, "scheckbuch").await.unwrap();
-        user.add_role(db, &scheckbuch).await.unwrap();
-
-        // TODO: remove all other `membership_type` roles
-        let new_user = Self::new(db, &user).await.unwrap();
-
-        new_user.notify(db, mail, smtp_pw).await
-    }
-
-    pub(crate) async fn notify(
+    async fn set_data_for_clubmember(
         &self,
         db: &SqlitePool,
-        mail: &str,
-        smtp_pw: &str,
+        changed_by: &ManageUserUser,
+        member_since: &NaiveDate,
+        birthdate: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
     ) -> Result<(), String> {
-        self.send_welcome_mail_to_user(db, mail, smtp_pw).await?;
-        self.notify_coxes_about_new_scheckbuch(db).await;
+        self.user.update_birthdate(db, changed_by, birthdate).await;
+        self.user
+            .update_member_since(db, changed_by, member_since)
+            .await;
+
+        self.user.update_phone(db, changed_by, &phone).await;
+        self.user.update_address(db, changed_by, &address).await;
+        self.user
+            .add_membership_pdf(db, changed_by, membership_pdf)
+            .await?;
+
+        Ok(())
+    }
+    pub(crate) async fn convert_to_regular_user(
+        self,
+        db: &SqlitePool,
+        smtp_pw: &str,
+        changed_by: &ManageUserUser,
+        member_since: &NaiveDate,
+        birthdate: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        self.set_data_for_clubmember(
+            db,
+            changed_by,
+            member_since,
+            birthdate,
+            phone,
+            address,
+            membership_pdf,
+        )
+        .await?;
+
+        // Change roles
+        let regular = Role::find_by_name(db, "Donau Linz").await.unwrap();
+        let scheckbook = Role::find_by_name(db, "scheckbuch").await.unwrap();
+        self.user.remove_role(db, changed_by, &scheckbook).await?;
+        self.user.add_role(db, changed_by, &regular).await?;
+
+        // Notify
+        let regular = RegularUser::new(db, &self.user).await.unwrap();
+        regular.send_welcome_mail_to_user(db, smtp_pw).await?;
+        Notification::create_for_steering_people(
+            db,
+            &format!(
+                "Liebe Steuerberechtigte, {} hatte ein Scheckbuch und ist nun seit {} es ein neues reguläres Mitglied. 🎉",
+                self.name,
+                self.member_since_date.clone().unwrap()
+            ),
+            "Neues Vereinsmitglied",
+            None,
+            None,
+        )
+        .await;
+
+        ActivityBuilder::new(&format!(
+            "{changed_by} hat den Scheckbuch-User {self} auf ein reguläres Mitglied upgegraded! Die Steuerpersonen wurden via Notification informiert."
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
 
         Ok(())
     }
 
-    async fn send_welcome_mail_to_user(
+    pub(crate) async fn convert_to_unterstuetzend_user(
+        self,
+        db: &SqlitePool,
+        smtp_pw: &str,
+        changed_by: &ManageUserUser,
+        member_since: &NaiveDate,
+        birthdate: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        // Set data
+        self.set_data_for_clubmember(
+            db,
+            changed_by,
+            member_since,
+            birthdate,
+            phone,
+            address,
+            membership_pdf,
+        )
+        .await?;
+
+        // Change roles
+        let unterstuetzend = Role::find_by_name(db, "Unterstützend").await.unwrap();
+        let scheckbook = Role::find_by_name(db, "scheckbuch").await.unwrap();
+        self.user.remove_role(db, changed_by, &scheckbook).await?;
+        self.user.add_role(db, changed_by, &unterstuetzend).await?;
+
+        let unterstuetzend = UnterstuetzendUser::new(db, &self.user).await.unwrap();
+        unterstuetzend
+            .send_welcome_mail_to_user(db, smtp_pw)
+            .await?;
+        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
+            Notification::create_for_role(
+                db,
+                &vorstand,
+                &format!(
+                    "Lieber Vorstand, {} hatte ein Scheckbuch und ist nun seit {} es ein neues unterstützendes Mitglied.",
+                    self.name,
+                    self.member_since_date.clone().unwrap()
+                ),
+                "Neues unterstützendes Vereinsmitglied",
+                None,
+                None,
+            )
+            .await;
+        }
+        ActivityBuilder::new(&format!("{changed_by} hat den Scheckbuch-User {self} auf ein unterstützendes Mitglied upgegraded!"))
+                .relevant_for_user(&self)
+                .save(db)
+                .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn convert_to_foerdernd_user(
+        self,
+        db: &SqlitePool,
+        smtp_pw: &str,
+        changed_by: &ManageUserUser,
+        member_since: &NaiveDate,
+        birthdate: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        // Set data
+        self.set_data_for_clubmember(
+            db,
+            changed_by,
+            member_since,
+            birthdate,
+            phone,
+            address,
+            membership_pdf,
+        )
+        .await?;
+
+        // Change roles
+        let unterstuetzend = Role::find_by_name(db, "Förderndes Mitglied").await.unwrap();
+        let scheckbook = Role::find_by_name(db, "scheckbuch").await.unwrap();
+        self.user.remove_role(db, changed_by, &scheckbook).await?;
+        self.user.add_role(db, changed_by, &unterstuetzend).await?;
+
+        let foerdernd = FoerderndUser::new(db, &self.user).await.unwrap();
+        foerdernd.send_welcome_mail_to_user(db, smtp_pw).await?;
+        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
+            Notification::create_for_role(
+                db,
+                &vorstand,
+                &format!(
+                    "Lieber Vorstand, {} hatte ein Scheckbuch und ist nun seit {} es ein neues förderndes Mitglied.",
+                    self.name,
+                    self.member_since_date.clone().unwrap()
+                ),
+                "Neues förderndes Vereinsmitglied",
+                None,
+                None,
+            )
+            .await;
+        }
+        ActivityBuilder::new(&format!(
+            "{changed_by} hat den Scheckbuch-User {self} auf ein förderndes Mitglied upgegraded!"
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    // TODO: make private
+    pub(crate) async fn notify(&self, db: &SqlitePool, smtp_pw: &str) -> Result<(), String> {
+        self.notify_coxes_about_new_scheckbuch(db).await;
+        self.send_welcome_mail_to_user(db, smtp_pw).await?;
+
+        ActivityBuilder::new(&format!(
+            "{self} hat eine Info-Mail bekommen (Erklärung Scheckbuch, Ruderapp) und alle Steuerberechtigten wurden informiert."
+        ))
+        .relevant_for_user(self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn send_welcome_mail_to_user(
         &self,
         db: &SqlitePool,
-        mail: &str,
         smtp_pw: &str,
     ) -> Result<(), String> {
+        let Some(mail) = &self.mail else {
+            return Err(
+                "Kann Mail nicht versenden, weil der User keine Mailadresse hinterlegt hat.".into(),
+            );
+        };
         Mail::send_single(
             db,
             mail,
@@ -88,4 +267,38 @@ ASKÖ Ruderverein Donau Linz", self.name, SCHECKBUCH/100),
         )
         .await;
     }
+
+    pub(crate) async fn create(
+        db: &SqlitePool,
+        created_by: &ManageUserUser,
+        smtp_pw: &str,
+        name: NonEmptyString,
+        mail: &str,
+    ) -> Result<(), String> {
+        let role = Role::find_by_name(db, "scheckbuch").await.unwrap();
+
+        let name = name.as_str();
+        sqlx::query!(
+            "INSERT INTO user(name, mail)
+            VALUES (?,?)",
+            name,
+            mail
+        )
+        .execute(db)
+        .await
+        .map_err(|e| e.to_string())?;
+
+        let user = User::find_by_name(db, name).await.unwrap();
+        user.add_role(db, created_by, &role).await?;
+
+        let user = Self::new(db, &user).await.unwrap();
+        user.notify(db, smtp_pw).await?;
+
+        ActivityBuilder::new(&format!("{created_by} hat Scheckbuch {user} angelegt."))
+            .relevant_for_user(&user)
+            .save(db)
+            .await;
+
+        Ok(())
+    }
 }

src/model/user/schnupperant.rs

@@ -0,0 +1,402 @@
+use super::foerdernd::FoerderndUser;
+use super::regular::RegularUser;
+use super::scheckbuch::ScheckbuchUser;
+use super::schnupperinterest::SchnupperInterestUser;
+use super::unterstuetzend::UnterstuetzendUser;
+use super::{ManageUserUser, User};
+use crate::NonEmptyString;
+use crate::model::activity::ActivityBuilder;
+use crate::model::role::Role;
+use crate::{
+    model::{mail::Mail, notification::Notification},
+    special_user,
+};
+use chrono::NaiveDate;
+use rocket::async_trait;
+use rocket::fs::TempFile;
+use sqlx::SqlitePool;
+
+special_user!(SchnupperantUser, +"schnupperant");
+
+impl SchnupperantUser {
+    async fn set_data_for_clubmember(
+        &self,
+        db: &SqlitePool,
+        changed_by: &ManageUserUser,
+        member_since: &NaiveDate,
+        birthdate: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        self.user.update_birthdate(db, changed_by, birthdate).await;
+        self.user
+            .update_member_since(db, changed_by, member_since)
+            .await;
+
+        self.user.update_phone(db, changed_by, &phone).await;
+        self.user.update_address(db, changed_by, &address).await;
+        self.user
+            .add_membership_pdf(db, changed_by, membership_pdf)
+            .await?;
+
+        Ok(())
+    }
+    pub(crate) async fn convert_to_regular_user(
+        self,
+        db: &SqlitePool,
+        smtp_pw: &str,
+        changed_by: &ManageUserUser,
+        member_since: &NaiveDate,
+        birthdate: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        self.set_data_for_clubmember(
+            db,
+            changed_by,
+            member_since,
+            birthdate,
+            phone,
+            address,
+            membership_pdf,
+        )
+        .await?;
+
+        // Change roles
+        let regular = Role::find_by_name(db, "Donau Linz").await.unwrap();
+        let scheckbook = Role::find_by_name(db, "schnupperant").await.unwrap();
+        self.user.remove_role(db, changed_by, &scheckbook).await?;
+        self.user.add_role(db, changed_by, &regular).await?;
+
+        // Notify
+        let regular = RegularUser::new(db, &self.user).await.unwrap();
+        regular.send_welcome_mail_to_user(db, smtp_pw).await?;
+        Notification::create_for_steering_people(
+            db,
+            &format!(
+                "Liebe Steuerberechtigte, {} nahm an unserem Schnupperkurs teil und ist nun seit {} ein neues reguläres Mitglied. 🎉",
+                self.name,
+                self.member_since_date.clone().unwrap()
+            ),
+            "Neues Vereinsmitglied",
+            None,
+            None,
+        )
+        .await;
+
+        ActivityBuilder::new(&format!(
+            "{changed_by} hat den Schnupperant {self} auf ein reguläres Mitglied upgegraded!"
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn move_to_scheckbook(
+        self,
+        db: &SqlitePool,
+        changed_by: &ManageUserUser,
+        smtp_pw: &str,
+    ) -> Result<(), String> {
+        let schnupperant = Role::find_by_name(db, "schnupperant").await.unwrap();
+        let scheckbook = Role::find_by_name(db, "scheckbuch").await.unwrap();
+        self.user.remove_role(db, changed_by, &schnupperant).await?;
+        self.user.add_role(db, changed_by, &scheckbook).await?;
+
+        if let Some(no_einschreibgebuehr) = Role::find_by_name(db, "no-einschreibgebuehr").await {
+            self.add_role(db, changed_by, &no_einschreibgebuehr)
+                .await
+                .expect("role doesn't have a group");
+        }
+
+        let scheckbook = ScheckbuchUser::new(db, &self.user).await.unwrap();
+        scheckbook.notify(db, smtp_pw).await?;
+
+        Notification::create_for_steering_people(
+            db,
+            &format!(
+                "Liebe Steuerberechtigte, {} hat unseren Schnupperkurs absolviert und nun ein Scheckbuch. Wie immer, freuen wir uns wenn du uns beim A+F Rudern unterstützt oder selber Ausfahrten ausschreibst. Bitte beachte, dass Scheckbuch-Personen nur Ausfahrten sehen, bei denen 'Scheckbuch-Anmeldungen erlauben' ausgewählt wurde.",
+                self.name
+            ),
+            "Neues Scheckbuch",
+            None,None
+        )
+        .await;
+
+        ActivityBuilder::new(&format!(
+            "{changed_by} hat dem ehemaligen Schnupperant {self} nun ein Scheckbuch gegeben"
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn move_to_schnupperinterest(
+        self,
+        db: &SqlitePool,
+        changed_by: &ManageUserUser,
+    ) -> Result<(), String> {
+        let schnupperinterest = Role::find_by_name(db, "schnupper-interessierte")
+            .await
+            .unwrap();
+        let schnupperant = Role::find_by_name(db, "schnupperant").await.unwrap();
+        self.user.remove_role(db, changed_by, &schnupperant).await?;
+        self.user
+            .add_role(db, changed_by, &schnupperinterest)
+            .await?;
+
+        let schnupperinterest = SchnupperInterestUser::new(db, &self.user).await.unwrap();
+        schnupperinterest.notify(db).await?;
+
+        if let Some(role) = Role::find_by_name(db, "schnupper-betreuer").await {
+            Notification::create_for_role(
+                db,
+                &role,
+                &format!(
+                    "Lieber Schnupperbetreuer, {} hat sich vom Schnupperkurs abgemeldet.",
+                    self.name
+                ),
+                "Schnupperkurs Abmeldung",
+                None,
+                None,
+            )
+            .await;
+        }
+
+        ActivityBuilder::new(&format!(
+            "{changed_by} hat dem eigentlichen Schnupperanten {self} wieder auf die 'Interessierten'-Liste zurückgegeben."
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn convert_to_unterstuetzend_user(
+        self,
+        db: &SqlitePool,
+        smtp_pw: &str,
+        changed_by: &ManageUserUser,
+        member_since: &NaiveDate,
+        birthdate: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        // Set data
+        self.set_data_for_clubmember(
+            db,
+            changed_by,
+            member_since,
+            birthdate,
+            phone,
+            address,
+            membership_pdf,
+        )
+        .await?;
+
+        // Change roles
+        let unterstuetzend = Role::find_by_name(db, "Unterstützend").await.unwrap();
+        let scheckbook = Role::find_by_name(db, "schnupperant").await.unwrap();
+        self.user.remove_role(db, changed_by, &scheckbook).await?;
+        self.user.add_role(db, changed_by, &unterstuetzend).await?;
+        if let Some(no_einschreibgebuehr) = Role::find_by_name(db, "no-einschreibgebuehr").await {
+            self.add_role(db, changed_by, &no_einschreibgebuehr)
+                .await
+                .expect("role doesn't have a group");
+        }
+
+        let unterstuetzend = UnterstuetzendUser::new(db, &self.user).await.unwrap();
+        unterstuetzend
+            .send_welcome_mail_to_user(db, smtp_pw)
+            .await?;
+        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
+            Notification::create_for_role(
+                db,
+                &vorstand,
+                &format!(
+                    "Lieber Vorstand, {} nahm am Schnupperkurs teil und ist nun seit {} es ein neues unterstützendes Mitglied.",
+                    self.name,
+                    self.member_since_date.clone().unwrap()
+                ),
+                "Neues unterstützendes Vereinsmitglied",
+                None,
+                None,
+            )
+            .await;
+        }
+
+        ActivityBuilder::new(&format!(
+            "{changed_by} hat den Schnupperant {self} auf ein unterstützendes Mitglied upgegraded!"
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn convert_to_foerdernd_user(
+        self,
+        db: &SqlitePool,
+        smtp_pw: &str,
+        changed_by: &ManageUserUser,
+        member_since: &NaiveDate,
+        birthdate: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        // Set data
+        self.set_data_for_clubmember(
+            db,
+            changed_by,
+            member_since,
+            birthdate,
+            phone,
+            address,
+            membership_pdf,
+        )
+        .await?;
+
+        // Change roles
+        let unterstuetzend = Role::find_by_name(db, "Förderndes Mitglied").await.unwrap();
+        let scheckbook = Role::find_by_name(db, "schnupperant").await.unwrap();
+        self.user.remove_role(db, changed_by, &scheckbook).await?;
+        self.user.add_role(db, changed_by, &unterstuetzend).await?;
+        if let Some(no_einschreibgebuehr) = Role::find_by_name(db, "no-einschreibgebuehr").await {
+            self.add_role(db, changed_by, &no_einschreibgebuehr)
+                .await
+                .expect("role doesn't have a group");
+        }
+
+        let foerdernd = FoerderndUser::new(db, &self.user).await.unwrap();
+        foerdernd.send_welcome_mail_to_user(db, smtp_pw).await?;
+        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
+            Notification::create_for_role(
+                db,
+                &vorstand,
+                &format!(
+                    "Lieber Vorstand, {} nahm am Schnupperkurs teil und ist nun seit {} es ein neues förderndes Mitglied.",
+                    self.name,
+                    self.member_since_date.clone().unwrap()
+                ),
+                "Neues förderndes Vereinsmitglied",
+                None,
+                None,
+            )
+            .await;
+        }
+
+        ActivityBuilder::new(&format!(
+            "{changed_by} hat den Schnupperant {self} auf ein förderndes Mitglied upgegraded!"
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    // TODO: make private
+    pub(crate) async fn notify(&self, db: &SqlitePool, smtp_pw: &str) -> Result<(), String> {
+        self.notify_coxes_about_new_scheckbuch(db).await;
+        self.send_welcome_mail_to_user(db, smtp_pw).await?;
+
+        ActivityBuilder::new(&format!(
+            "{self} hat eine Mail bekommen (Inhalt: wir freuen uns auf ihn + senden detailliertere Infos später zu) und die Schnupperbetreuer wurden via Notification informiert."
+        ))
+        .relevant_for_user(self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    async fn send_welcome_mail_to_user(
+        &self,
+        db: &SqlitePool,
+        smtp_pw: &str,
+    ) -> Result<(), String> {
+        let Some(mail) = &self.mail else {
+            return Err(format!(
+                "Couldn't send mail, because user {self} has no mail"
+            ));
+        };
+        Mail::send_single(
+            db,
+            mail,
+            "ASKÖ Ruderverein Donau Linz | Anmeldung Schnupperkurs",
+            format!(
+"Hallo {0},
+
+es freut uns sehr, dich bei unserem Schnupperkurs willkommen heißen zu dürfen. Detaillierte Informationen folgen noch, ich werde sie dir ein paar Tage vor dem Termin zusenden.
+
+Riemen- & Dollenbruch,
+ASKÖ Ruderverein Donau Linz", self.name),
+            smtp_pw,
+        ).await?;
+
+        Ok(())
+    }
+
+    async fn notify_coxes_about_new_scheckbuch(&self, db: &SqlitePool) {
+        if let Some(role) = Role::find_by_name(db, "schnupper-betreuer").await {
+            Notification::create_for_role(
+                db,
+                &role,
+                &format!(
+                    "Lieber Schnupperbetreuer, {} hat sich zum Schnupperkurs angemeldet.",
+                    self.name
+                ),
+                "Neuer Schnupperant",
+                None,
+                None,
+            )
+            .await;
+        }
+    }
+
+    pub(crate) async fn create(
+        db: &SqlitePool,
+        created_by: &ManageUserUser,
+        smtp_pw: &str,
+        name: NonEmptyString,
+        mail: &str,
+    ) -> Result<(), String> {
+        let role = Role::find_by_name(db, "schnupperant").await.unwrap();
+
+        let name = name.as_str();
+        sqlx::query!(
+            "INSERT INTO user(name, mail)
+            VALUES (?,?)",
+            name,
+            mail
+        )
+        .execute(db)
+        .await
+        .map_err(|e| e.to_string())?;
+
+        let user = User::find_by_name(db, name).await.unwrap();
+        user.add_role(db, created_by, &role).await?;
+
+        let user = Self::new(db, &user).await.unwrap();
+        user.notify(db, smtp_pw).await?;
+
+        ActivityBuilder::new(&format!(
+            "{created_by} hat {user} zur fixen Schnupperkurs-Anmeldung hinzugefügt."
+        ))
+        .relevant_for_user(&user)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+}

src/model/user/schnupperinterest.rs

@@ -0,0 +1,162 @@
+use super::scheckbuch::ScheckbuchUser;
+use super::schnupperant::SchnupperantUser;
+use super::{ManageUserUser, User};
+use crate::NonEmptyString;
+use crate::model::activity::ActivityBuilder;
+use crate::model::role::Role;
+use crate::{model::notification::Notification, special_user};
+use rocket::async_trait;
+use sqlx::SqlitePool;
+
+special_user!(SchnupperInterestUser, +"schnupper-interessierte");
+
+impl SchnupperInterestUser {
+    pub(crate) async fn move_to_scheckbook(
+        self,
+        db: &SqlitePool,
+        changed_by: &ManageUserUser,
+        smtp_pw: &str,
+    ) -> Result<(), String> {
+        let schnupperinterest = Role::find_by_name(db, "schnupper-interessierte")
+            .await
+            .unwrap();
+        let scheckbook = Role::find_by_name(db, "scheckbuch").await.unwrap();
+        self.user
+            .remove_role(db, changed_by, &schnupperinterest)
+            .await?;
+        self.user.add_role(db, changed_by, &scheckbook).await?;
+
+        let scheckbook = ScheckbuchUser::new(db, &self.user).await.unwrap();
+        scheckbook.notify(db, smtp_pw).await?;
+
+        Notification::create_for_steering_people(
+            db,
+            &format!(
+                "Liebe Steuerberechtigte, {} wollte unseren Schnupperkurs absolviert und nun ein Scheckbuch. Wie immer, freuen wir uns wenn du uns beim A+F Rudern unterstützt oder selber Ausfahrten ausschreibst. Bitte beachte, dass Scheckbuch-Personen nur Ausfahrten sehen, bei denen 'Scheckbuch-Anmeldungen erlauben' ausgewählt wurde.",
+                self.name
+            ),
+            "Neues Scheckbuch",
+            None,
+            None
+        )
+        .await;
+
+        ActivityBuilder::new(&format!(
+            "Der Schnupperinteressierte {self} hat sich (ohne Schnupperkurs) doch gleich direkt für ein Scheckbuch entschieden. {changed_by} hat dieses eingerichtet."
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn move_to_schnupperant(
+        self,
+        db: &SqlitePool,
+        changed_by: &ManageUserUser,
+        smtp_pw: &str,
+    ) -> Result<(), String> {
+        let schnupperinterest = Role::find_by_name(db, "schnupper-interessierte")
+            .await
+            .unwrap();
+        let schnupperant = Role::find_by_name(db, "schnupperant").await.unwrap();
+        self.user
+            .remove_role(db, changed_by, &schnupperinterest)
+            .await?;
+        self.user.add_role(db, changed_by, &schnupperant).await?;
+
+        let schnupperant = SchnupperantUser::new(db, &self.user).await.unwrap();
+        schnupperant.notify(db, smtp_pw).await?;
+
+        if let Some(role) = Role::find_by_name(db, "schnupper-betreuer").await {
+            Notification::create_for_role(
+                db,
+                &role,
+                &format!(
+                    "Lieber Schnupperbetreuer, {} hat sich zum Schnupperkurs angemeldet.",
+                    self.name
+                ),
+                "Neuer Schnupper-Interessierte:r",
+                None,
+                None,
+            )
+            .await;
+        }
+        ActivityBuilder::new(&format!(
+            "Der Schnupperinteressierte {self} hat sich zum Schnupperkurs angemeldet."
+        ))
+        .relevant_for_user(&self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn notify(&self, db: &SqlitePool) -> Result<(), String> {
+        self.notify_schnupperbetreuer_about_new_interest(db).await;
+
+        ActivityBuilder::new(&format!(
+            "Der Schnupperbetreuer hat eine Info via Notification bekommen, dass {self} Interesse an einen Schnupperkurs hat."
+        ))
+        .relevant_for_user(self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    async fn notify_schnupperbetreuer_about_new_interest(&self, db: &SqlitePool) {
+        if let Some(role) = Role::find_by_name(db, "schnupper-betreuer").await {
+            Notification::create_for_role(
+                db,
+                &role,
+                &format!(
+                    "Lieber Schnupperbetreuer, {} hat Interesse zum Schnupperkurs bekundet.",
+                    self.name
+                ),
+                "Neuer Schnupper-Interessierte:r",
+                None,
+                None,
+            )
+            .await;
+        }
+    }
+
+    pub(crate) async fn create(
+        db: &SqlitePool,
+        created_by: &ManageUserUser,
+        name: NonEmptyString,
+        mail: &str,
+    ) -> Result<(), String> {
+        let role = Role::find_by_name(db, "schnupper-interessierte")
+            .await
+            .unwrap();
+
+        let name = name.as_str();
+        sqlx::query!(
+            "INSERT INTO user(name, mail)
+            VALUES (?,?)",
+            name,
+            mail
+        )
+        .execute(db)
+        .await
+        .map_err(|e| e.to_string())?;
+
+        let user = User::find_by_name(db, name).await.unwrap();
+        user.add_role(db, created_by, &role).await?;
+
+        let user = Self::new(db, &user).await.unwrap();
+        user.notify(db).await?;
+
+        ActivityBuilder::new(&format!(
+            "{created_by} hat Schnupper-Interessierten {user} angelegt."
+        ))
+        .relevant_for_user(&user)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+}

src/model/user/unterstuetzend.rs

@@ -0,0 +1,101 @@
+use super::{ManageUserUser, User, regular::ClubMember};
+use crate::{
+    NonEmptyString,
+    model::{activity::ActivityBuilder, mail::Mail, notification::Notification, role::Role},
+    special_user,
+};
+use chrono::NaiveDate;
+use rocket::{async_trait, fs::TempFile};
+use sqlx::SqlitePool;
+
+special_user!(UnterstuetzendUser, +"Unterstützend");
+
+impl ClubMember for UnterstuetzendUser {}
+
+impl UnterstuetzendUser {
+    pub(crate) async fn send_welcome_mail_to_user(
+        &self,
+        db: &SqlitePool,
+        smtp_pw: &str,
+    ) -> Result<(), String> {
+        let Some(mail) = &self.mail else {
+            return Err(format!(
+                "Couldn't send welcome mail, as the user {self} has no mail..."
+            ));
+        };
+
+        Mail::send_single(
+            db,
+            mail,
+            "Willkommen im ASKÖ Ruderverein Donau Linz!",
+            format!(
+"Hallo {0},
+
+herzlich willkommen im ASKÖ Ruderverein Donau Linz! Wir freuen uns sehr, dich als neues Mitglied in unserem Verein begrüßen zu dürfen. 
+
+Um dir den Einstieg zu erleichtern, findest du in unserem Handbuch alle wichtigen Informationen über unseren Verein: https://rudernlinz.at/book. Bei weiteren Fragen stehen dir die Adressen info@rudernlinz.at (für allgemeine Fragen) und it@rudernlinz.at (bei technischen Fragen) jederzeit zur Verfügung.
+
+Damit du dich noch mehr verbunden fühlst (:-)), haben wir im Bootshaus ein WLAN für Vereinsmitglieder 'ASKÖ Ruderverein Donau Linz' eingerichtet. Das Passwort dafür lautet 'donau1921' (ohne Anführungszeichen). Bitte gib das Passwort an keine vereinsfremden Personen weiter.
+
+Riemen- & Dollenbruch
+ASKÖ Ruderverein Donau Linz", self.name),
+            smtp_pw,
+        ).await?;
+
+        ActivityBuilder::new(&format!(
+            "{self} hat eine Mail an {mail} bekommen, mit Infos dass er/sie nun ein unterstützendes Mitglied ist (Handbuch, WLAN)."
+        ))
+        .relevant_for_user(self)
+        .save(db)
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn create(
+        db: &SqlitePool,
+        created_by: &ManageUserUser,
+        smtp_pw: &str,
+        name: NonEmptyString,
+        mail: &str,
+        financial: Option<Role>,
+        birthdate: &NaiveDate,
+        member_since: &NaiveDate,
+        phone: NonEmptyString,
+        address: NonEmptyString,
+        membership_pdf: &TempFile<'_>,
+    ) -> Result<(), String> {
+        let role = Role::find_by_name(db, "Unterstützend").await.unwrap();
+        let user = Self::create_member(
+            db,
+            created_by,
+            &role,
+            name,
+            mail,
+            financial,
+            birthdate,
+            member_since,
+            phone,
+            address,
+            membership_pdf,
+        )
+        .await?;
+
+        let user = Self::new(db, &user).await.unwrap();
+        user.send_welcome_mail_to_user(db, smtp_pw).await?;
+
+        if let Some(vorstand) = Role::find_by_name(db, "Vorstand").await {
+            Notification::create_for_role(
+                db,
+                &vorstand,
+                &format!("Lieber Vorstand, es gibt ein neues unterstützendes Mitglied: {user}"),
+                "Neues unterstützendes Vereinsmitglied",
+                None,
+                None,
+            )
+            .await;
+        }
+
+        Ok(())
+    }
+}

src/rest/mod.rs

@@ -1,4 +1,4 @@
-use rocket::{form::Form, post, routes, Build, FromForm, Rocket, State};
+use rocket::{Build, FromForm, Rocket, State, form::Form, post, routes};
 use serde_json::json;
 use sqlx::SqlitePool;
 

src/scheduled/weather.rs

@@ -96,7 +96,9 @@ struct DailyWeather {
 }
 
 fn fetch(api_key: &str) -> Result<Data, String> {
-    let url = format!("https://api.openweathermap.org/data/3.0/onecall?lat=48.31970&lon=14.29451&units=metric&exclude=current,minutely,hourly,alert&appid={api_key}");
+    let url = format!(
+        "https://api.openweathermap.org/data/3.0/onecall?lat=48.31970&lon=14.29451&units=metric&exclude=current,minutely,hourly,alert&appid={api_key}"
+    );
 
     match ureq::get(&url).call() {
         Ok(mut response) => {

src/tera/admin/boat.rs

@@ -5,13 +5,14 @@ use crate::model::{
     user::{User, UserWithDetails, VorstandUser},
 };
 use rocket::{
+    Route, State,
     form::Form,
     get, post,
     request::FlashMessage,
     response::{Flash, Redirect},
-    routes, Route, State,
+    routes,
 };
-use rocket_dyn_templates::{tera::Context, Template};
+use rocket_dyn_templates::{Template, tera::Context};
 use sqlx::SqlitePool;
 
 #[get("/boat")]
@@ -245,9 +246,11 @@ mod test {
 
         let rocket = rocket::build().manage(db.clone());
         let rocket = crate::tera::config(rocket);
-        assert!(Boat::find_by_name(&db, "completely-new-boat".into())
-            .await
-            .is_none());
+        assert!(
+            Boat::find_by_name(&db, "completely-new-boat".into())
+                .await
+                .is_none()
+        );
 
         let client = Client::tracked(rocket).await.unwrap();
         let login = client

src/tera/admin/event.rs

@@ -1,8 +1,9 @@
 use rocket::{
+    FromForm, Route, State,
     form::Form,
     get, post, put,
     response::{Flash, Redirect},
-    routes, FromForm, Route, State,
+    routes,
 };
 use serde::Serialize;
 use sqlx::SqlitePool;
@@ -32,8 +33,8 @@ async fn create(
 
     let trip_details_id = TripDetails::create(db, data.tripdetails).await;
     let trip_details = TripDetails::find_by_id(db, trip_details_id).await.unwrap(); //Okay, bc. we
-                                                                                    //just created
-                                                                                    //the object
+    //just created
+    //the object
 
     Event::create(
         db,

src/tera/admin/mail.rs

@@ -1,9 +1,9 @@
 use rocket::form::Form;
 use rocket::fs::TempFile;
 use rocket::response::{Flash, Redirect};
-use rocket::{get, request::FlashMessage, routes, Route, State};
-use rocket::{post, FromForm};
-use rocket_dyn_templates::{tera::Context, Template};
+use rocket::{FromForm, post};
+use rocket::{Route, State, get, request::FlashMessage, routes};
+use rocket_dyn_templates::{Template, tera::Context};
 use sqlx::SqlitePool;
 
 use crate::model::log::Log;

src/tera/admin/mod.rs

@@ -1,6 +1,6 @@
 use csv::ReaderBuilder;
-use rocket::{form::Form, get, post, routes, FromForm, Route, State};
-use rocket_dyn_templates::{context, Template};
+use rocket::{FromForm, Route, State, form::Form, get, post, routes};
+use rocket_dyn_templates::{Template, context};
 use sqlx::SqlitePool;
 
 use crate::{
@@ -12,6 +12,7 @@ pub mod boat;
 pub mod event;
 pub mod mail;
 pub mod notification;
+pub mod role;
 pub mod schnupper;
 pub mod user;
 
@@ -81,6 +82,7 @@ pub fn routes() -> Vec<Route> {
     ret.append(&mut notification::routes());
     ret.append(&mut mail::routes());
     ret.append(&mut event::routes());
+    ret.append(&mut role::routes());
     ret.append(&mut routes![rss, show_rss, show_list, list]);
     ret
 }

src/tera/admin/notification.rs

@@ -6,13 +6,14 @@ use crate::model::{
 };
 use itertools::Itertools;
 use rocket::{
+    FromForm, Route, State,
     form::Form,
     get, post,
     request::FlashMessage,
     response::{Flash, Redirect},
-    routes, FromForm, Route, State,
+    routes,
 };
-use rocket_dyn_templates::{tera::Context, Template};
+use rocket_dyn_templates::{Template, tera::Context};
 use sqlx::SqlitePool;
 
 #[get("/notification")]

src/tera/admin/role.rs

@@ -0,0 +1,65 @@
+use crate::model::{
+    role::Role,
+    user::{AdminUser, UserWithDetails, VorstandUser},
+};
+use rocket::{
+    FromForm, Route, State,
+    form::Form,
+    get, post,
+    request::FlashMessage,
+    response::{Flash, Redirect},
+    routes,
+};
+use rocket_dyn_templates::{Template, tera::Context};
+use sqlx::SqlitePool;
+
+#[get("/role")]
+async fn index(
+    db: &State<SqlitePool>,
+    admin: VorstandUser,
+    flash: Option<FlashMessage<'_>>,
+) -> Template {
+    let roles = Role::all(db).await;
+
+    let mut context = Context::new();
+    if let Some(msg) = flash {
+        context.insert("flash", &msg.into_inner());
+    }
+    context.insert("roles", &roles);
+    context.insert(
+        "loggedin_user",
+        &UserWithDetails::from_user(admin.user, db).await,
+    );
+
+    Template::render("admin/role", context.into_json())
+}
+#[derive(FromForm)]
+pub struct RoleToUpdate<'r> {
+    pub formatted_name: &'r str,
+    pub desc: &'r str,
+}
+
+#[post("/role/<role_id>", data = "<data>")]
+async fn update(
+    db: &State<SqlitePool>,
+    data: Form<RoleToUpdate<'_>>,
+    role_id: i32,
+    admin: AdminUser,
+) -> Flash<Redirect> {
+    let role = Role::find_by_id(db, role_id).await;
+    let Some(role) = role else {
+        return Flash::error(Redirect::to("/admin/role"), "Role does not exist!");
+    };
+
+    match role
+        .update(db, &admin, &data.formatted_name, &data.desc)
+        .await
+    {
+        Ok(_) => Flash::success(Redirect::to("/admin/role"), "Rolle bearbeitet"),
+        Err(e) => Flash::error(Redirect::to("/admin/role"), e),
+    }
+}
+
+pub fn routes() -> Vec<Route> {
+    routes![index, update]
+}

src/tera/admin/schnupper.rs

@@ -3,8 +3,8 @@ use crate::model::{
     user::{SchnupperBetreuerUser, User, UserWithDetails},
 };
 use futures::future::join_all;
-use rocket::{get, request::FlashMessage, routes, Route, State};
-use rocket_dyn_templates::{tera::Context, Template};
+use rocket::{Route, State, get, request::FlashMessage, routes};
+use rocket_dyn_templates::{Template, tera::Context};
 use sqlx::SqlitePool;
 
 #[get("/schnupper")]

src/tera/auth.rs

@@ -1,4 +1,5 @@
 use rocket::{
+    FromForm, Request, Route, State,
     form::Form,
     get,
     http::{Cookie, CookieJar},
@@ -8,12 +9,12 @@ use rocket::{
     response::{Flash, Redirect},
     routes,
     time::{Duration, OffsetDateTime},
-    FromForm, Request, Route, State,
 };
-use rocket_dyn_templates::{context, tera, Template};
+use rocket_dyn_templates::{Template, context, tera};
 use sqlx::SqlitePool;
 
 use crate::model::{
+    activity::ActivityBuilder,
     log::Log,
     user::{LoginError, User},
 };
@@ -73,19 +74,21 @@ async fn login(
             );
         }
         Err(_) => {
-            return Flash::error(Redirect::to("/auth"), "Falscher Benutzername/Passwort. Du bist Vereinsmitglied und der Login klappt nicht? Kontaktiere unseren Schriftführer oder schreibe eine Mail an info@rudernlinz.at!");
+            return Flash::error(
+                Redirect::to("/auth"),
+                "Falscher Benutzername/Passwort. Du bist Vereinsmitglied und der Login klappt nicht? Kontaktiere unseren Schriftführer oder schreibe eine Mail an info@rudernlinz.at!",
+            );
         }
     };
 
     cookies.add_private(Cookie::new("loggedin_user", format!("{}", user.id)));
 
-    Log::create(
-        db,
-        format!(
-            "Succ login of {} with this useragent: {}",
-            login.name, agent.0
-        ),
-    )
+    ActivityBuilder::new(&format!(
+        "{user} hat sich eingeloggt (User-Agent: {})",
+        agent.0
+    ))
+    .relevant_for_user(&user)
+    .save(db)
     .await;
 
     // Check for redirect_url cookie and redirect accordingly

src/tera/board/achievement.rs

@@ -3,8 +3,8 @@ use crate::model::{
     role::Role,
     user::{User, UserWithDetails, VorstandUser},
 };
-use rocket::{get, request::FlashMessage, routes, Route, State};
-use rocket_dyn_templates::{tera::Context, Template};
+use rocket::{Route, State, get, request::FlashMessage, routes};
+use rocket_dyn_templates::{Template, tera::Context};
 use sqlx::SqlitePool;
 
 #[get("/achievement")]

src/tera/board/boathouse.rs

@@ -4,13 +4,14 @@ use crate::model::{
     user::{AdminUser, UserWithDetails, VorstandUser},
 };
 use rocket::{
+    FromForm, Route, State,
     form::Form,
     get, post,
     request::FlashMessage,
     response::{Flash, Redirect},
-    routes, FromForm, Route, State,
+    routes,
 };
-use rocket_dyn_templates::{tera::Context, Template};
+use rocket_dyn_templates::{Template, tera::Context};
 use sqlx::SqlitePool;
 
 #[get("/boathouse")]

src/tera/boatdamage.rs

@@ -1,9 +1,10 @@
 use rocket::{
+    FromForm, Route, State,
     form::Form,
     get, post,
     request::FlashMessage,
     response::{Flash, Redirect},
-    routes, FromForm, Route, State,
+    routes,
 };
 use rocket_dyn_templates::Template;
 use sqlx::SqlitePool;

src/tera/boatreservation.rs

@@ -1,10 +1,11 @@
 use chrono::NaiveDate;
 use rocket::{
+    FromForm, Route, State,
     form::Form,
     get, post,
     request::FlashMessage,
     response::{Flash, Redirect},
-    routes, FromForm, Route, State,
+    routes,
 };
 use rocket_dyn_templates::Template;
 use sqlx::SqlitePool;

src/tera/cox.rs

@@ -1,8 +1,9 @@
 use rocket::{
+    FromForm, Route, State,
     form::Form,
     get, post,
     response::{Flash, Redirect},
-    routes, FromForm, Route, State,
+    routes,
 };
 use sqlx::SqlitePool;
 
@@ -22,7 +23,7 @@ async fn create_ergo(
 ) -> Flash<Redirect> {
     let trip_details_id = TripDetails::create(db, data.into_inner()).await;
     let trip_details = TripDetails::find_by_id(db, trip_details_id).await.unwrap(); //Okay, bc just
-                                                                                    //created
+    //created
     Trip::new_own_ergo(db, &cox, trip_details).await; //TODO: fix
 
     //Log::create(
@@ -45,7 +46,7 @@ async fn create(
 ) -> Flash<Redirect> {
     let trip_details_id = TripDetails::create(db, data.into_inner()).await;
     let trip_details = TripDetails::find_by_id(db, trip_details_id).await.unwrap(); //Okay, bc just
-                                                                                    //created
+    //created
     Trip::new_own(db, &cox, trip_details).await; //TODO: fix
 
     //Log::create(
@@ -137,9 +138,10 @@ async fn join(db: &State<SqlitePool>, planned_event_id: i64, cox: SteeringUser)
                 .await;
                 Flash::success(Redirect::to("/planned"), "Danke für's helfen!")
             }
-            Err(CoxHelpError::CanceledEvent) => {
-                Flash::error(Redirect::to("/planned"), "Die Ausfahrt wurde leider abgesagt...")
-            }
+            Err(CoxHelpError::CanceledEvent) => Flash::error(
+                Redirect::to("/planned"),
+                "Die Ausfahrt wurde leider abgesagt...",
+            ),
             Err(CoxHelpError::AlreadyRegisteredAsCox) => {
                 Flash::error(Redirect::to("/planned"), "Du hilfst bereits aus!")
             }
@@ -147,9 +149,10 @@ async fn join(db: &State<SqlitePool>, planned_event_id: i64, cox: SteeringUser)
                 Redirect::to("/planned"),
                 "Du hast dich bereits als Ruderer angemeldet!",
             ),
-            Err(CoxHelpError::DetailsLocked) => {
-                Flash::error(Redirect::to("/planned"), "Die Bootseinteilung wurde bereits gemacht. Wenn du noch steuern möchtest, frag bitte bei einer bereits angemeldeten Steuerperson nach, ob das noch möglich ist.")
-            }
+            Err(CoxHelpError::DetailsLocked) => Flash::error(
+                Redirect::to("/planned"),
+                "Die Bootseinteilung wurde bereits gemacht. Wenn du noch steuern möchtest, frag bitte bei einer bereits angemeldeten Steuerperson nach, ob das noch möglich ist.",
+            ),
         }
     } else {
         Flash::error(Redirect::to("/planned"), "Event gibt's nicht")
@@ -197,9 +200,10 @@ async fn remove(
 
                 Flash::success(Redirect::to("/planned"), "Erfolgreich abgemeldet!")
             }
-            Err(TripHelpDeleteError::DetailsLocked) => {
-                Flash::error(Redirect::to("/planned"), "Die Bootseinteilung wurde bereits gemacht. Wenn du doch nicht steuern kannst, melde dich bitte unbedingt schnellstmöglich bei einer anderen Steuerperson!")
-            }
+            Err(TripHelpDeleteError::DetailsLocked) => Flash::error(
+                Redirect::to("/planned"),
+                "Die Bootseinteilung wurde bereits gemacht. Wenn du doch nicht steuern kannst, melde dich bitte unbedingt schnellstmöglich bei einer anderen Steuerperson!",
+            ),
             Err(TripHelpDeleteError::CoxNotHelping) => {
                 Flash::error(Redirect::to("/planned"), "Steuermann hilft nicht aus...")
             }

src/tera/ergo.rs

@@ -1,7 +1,8 @@
 use std::env;
 
-use chrono::{Datelike, Utc};
+use chrono::Utc;
 use rocket::{
+    FromForm, Route, State,
     form::Form,
     fs::TempFile,
     get,
@@ -9,9 +10,9 @@ use rocket::{
     post,
     request::FlashMessage,
     response::{Flash, Redirect},
-    routes, FromForm, Route, State,
+    routes,
 };
-use rocket_dyn_templates::{context, Template};
+use rocket_dyn_templates::{Template, context};
 use serde::Serialize;
 use sqlx::SqlitePool;
 use tera::Context;
@@ -145,47 +146,47 @@ pub struct UserAdd {
     sex: String,
 }
 
-#[post("/set-data", data = "<data>")]
-async fn new_user(db: &State<SqlitePool>, data: Form<UserAdd>, user: User) -> Flash<Redirect> {
-    if user.has_role(db, "ergo").await {
-        return Flash::error(Redirect::to("/ergo"), "Du hast deine Daten schon eingegeben. Wenn du sie updaten willst, melde dich bitte bei it@rudernlinz.at");
-    }
-
-    // check data
-    if data.birthyear < 1900 || data.birthyear > chrono::Utc::now().year() - 5 {
-        return Flash::error(Redirect::to("/ergo"), "Bitte überprüfe dein Geburtsjahr...");
-    }
-    if data.weight < 20 || data.weight > 200 {
-        return Flash::error(Redirect::to("/ergo"), "Bitte überprüfe dein Gewicht...");
-    }
-    if &data.sex != "f" && &data.sex != "m" {
-        return Flash::error(Redirect::to("/ergo"), "Bitte überprüfe dein Geschlecht...");
-    }
-
-    // set data
-    user.update_ergo(db, data.birthyear, data.weight, &data.sex)
-        .await;
-
-    // inform all other `ergo` users
-    let ergo = Role::find_by_name(db, "ergo").await.unwrap();
-    Notification::create_for_role(
-        db,
-        &ergo,
-        &format!("{} nimmt heuer an der Ergochallenge teil 💪", user.name),
-        "Ergo Challenge",
-        None,
-        None,
-    )
-    .await;
-
-    // add to `ergo`  group
-    user.add_role(db, &ergo).await.unwrap();
-
-    Flash::success(
-        Redirect::to("/ergo"),
-        "Du hast deine Daten erfolgreich eingegeben. Viel Spaß beim Schwitzen :-)",
-    )
-}
+//#[post("/set-data", data = "<data>")]
+//async fn new_user(db: &State<SqlitePool>, data: Form<UserAdd>, user: User) -> Flash<Redirect> {
+//    if user.has_role(db, "ergo").await {
+//        return Flash::error(Redirect::to("/ergo"), "Du hast deine Daten schon eingegeben. Wenn du sie updaten willst, melde dich bitte bei it@rudernlinz.at");
+//    }
+//
+//    // check data
+//    if data.birthyear < 1900 || data.birthyear > chrono::Utc::now().year() - 5 {
+//        return Flash::error(Redirect::to("/ergo"), "Bitte überprüfe dein Geburtsjahr...");
+//    }
+//    if data.weight < 20 || data.weight > 200 {
+//        return Flash::error(Redirect::to("/ergo"), "Bitte überprüfe dein Gewicht...");
+//    }
+//    if &data.sex != "f" && &data.sex != "m" {
+//        return Flash::error(Redirect::to("/ergo"), "Bitte überprüfe dein Geschlecht...");
+//    }
+//
+//    // set data
+//    user.update_ergo(db, data.birthyear, data.weight, &data.sex)
+//        .await;
+//
+//    // inform all other `ergo` users
+//    let ergo = Role::find_by_name(db, "ergo").await.unwrap();
+//    Notification::create_for_role(
+//        db,
+//        &ergo,
+//        &format!("{} nimmt heuer an der Ergochallenge teil 💪", user.name),
+//        "Ergo Challenge",
+//        None,
+//        None,
+//    )
+//    .await;
+//
+//    // add to `ergo`  group
+//    user.add_role(db, &ergo).await.unwrap();
+//
+//    Flash::success(
+//        Redirect::to("/ergo"),
+//        "Du hast deine Daten erfolgreich eingegeben. Viel Spaß beim Schwitzen :-)",
+//    )
+//}
 
 #[derive(FromForm, Debug)]
 pub struct ErgoToAdd<'a> {
@@ -358,7 +359,10 @@ async fn new_dozen(
 }
 
 pub fn routes() -> Vec<Route> {
-    routes![index, new_thirty, new_dozen, send, reset, update, new_user]
+    routes![
+        index, new_thirty, new_dozen, send, reset, update,
+        // new_user
+    ]
 }
 
 #[cfg(test)]

src/tera/log.rs

@@ -1,6 +1,7 @@
 use std::net::IpAddr;
 
 use rocket::{
+    Request, Route, State,
     form::Form,
     get,
     http::{Cookie, CookieJar},
@@ -9,9 +10,8 @@ use rocket::{
     response::{Flash, Redirect},
     routes,
     time::{Duration, OffsetDateTime},
-    Request, Route, State,
 };
-use rocket_dyn_templates::{context, Template};
+use rocket_dyn_templates::{Template, context};
 use sqlx::SqlitePool;
 use tera::Context;
 
@@ -110,10 +110,13 @@ async fn index(
 #[get("/show", rank = 3)]
 async fn show(db: &State<SqlitePool>, user: DonauLinzUser) -> Template {
     let logs = Logbook::completed(db).await;
+    let boats = Boat::all(db).await;
+    let users = User::all(db).await;
+    let logtypes = LogType::all(db).await;
 
     Template::render(
         "log.completed",
-        context!(logs, loggedin_user: &UserWithDetails::from_user(user.into_inner(), db).await),
+        context!(logs, boats, users, logtypes, loggedin_user: &UserWithDetails::from_user(user.into_inner(), db).await),
     )
 }
 
@@ -215,31 +218,77 @@ async fn create_logbook(
     user: &DonauLinzUser,
     smtp_pw: &str,
 ) -> Flash<Redirect> {
-    match Logbook::create(
-        db,
-        data.into_inner(),
-        user, smtp_pw
-    )
-    .await
-    {
-        Ok(msg) => Flash::success(Redirect::to("/log"), format!("Ausfahrt erfolgreich hinzugefügt{msg}")),
-        Err(LogbookCreateError::BoatAlreadyOnWater) => Flash::error(Redirect::to("/log"), "Boot schon am Wasser"),
-        Err(LogbookCreateError::RowerAlreadyOnWater(rower)) => Flash::error(Redirect::to("/log"), format!("Ruderer {} schon am Wasser", rower.name)),
-        Err(LogbookCreateError::BoatLocked) => Flash::error(Redirect::to("/log"),"Boot gesperrt"),
-        Err(LogbookCreateError::BoatNotFound) => Flash::error(Redirect::to("/log"), "Boot gibt's ned"),
-        Err(LogbookCreateError::TooManyRowers(expected, actual)) => Flash::error(Redirect::to("/log"), format!("Zu viele Ruderer (Boot fasst maximal {expected}, es wurden jedoch {actual} Ruderer ausgewählt)")),
-        Err(LogbookCreateError::RowerCreateError(rower, e)) => Flash::error(Redirect::to("/log"), format!("Fehler bei Ruderer {rower}: {e}")),
-        Err(LogbookCreateError::ArrivalNotAfterDeparture) => Flash::error(Redirect::to("/log"), "Ankunftszeit kann nicht vor der Abfahrtszeit sein"),
-        Err(LogbookCreateError::UserNotAllowedToUseBoat) => Flash::error(Redirect::to("/log"), "Schiffsführer darf dieses Boot nicht verwenden"),
-        Err(LogbookCreateError::SteeringPersonNotInRowers) => Flash::error(Redirect::to("/log"), "Steuerperson nicht in Liste der Ruderer!"),
-        Err(LogbookCreateError::ShipmasterNotInRowers) => Flash::error(Redirect::to("/log"), "Schiffsführer nicht in Liste der Ruderer!"),
-        Err(LogbookCreateError::NotYourEntry) => Flash::error(Redirect::to("/log"), "Nicht deine Ausfahrt!"),
-        Err(LogbookCreateError::ArrivalSetButNotRemainingTwo) => Flash::error(Redirect::to("/log"), "Ankunftszeit gesetzt aber nicht Distanz + Strecke"),
-        Err(LogbookCreateError::OnlyAllowedToEndTripsEndingToday) => Flash::error(Redirect::to("/log"), "Nur Ausfahrten, die in der letzten Woche enden dürfen eingetragen werden. Für einen Nachtrag schreibe alle Daten an den Vorstand (info@rudernlinz.at)."),
-        Err(LogbookCreateError::CantChangeHandoperatableStatusForThisBoat) => Flash::error(Redirect::to("/log"), "Handsteuer-Status dieses Boots kann nicht verändert werden."),
-        Err(LogbookCreateError::TooFast(km, min)) => Flash::error(Redirect::to("/log"), format!("KM zu groß für die eingegebene Dauer ({km} km in {min} Minuten). Bitte überprüfe deine Start- und Endzeit und versuche es erneut.")),
-        Err(LogbookCreateError::AlreadyFinalized) => Flash::error(Redirect::to("/log"), "Logbucheintrag wurde bereits abgeschlossen."),
-        Err(LogbookCreateError::ExternalSteeringPersonMustSteerOrShipmaster) => Flash::error(Redirect::to("/log"), "Wenn du eine 'Externe Steuerperson' hinzufügst, muss diese steuern oder Schiffsführer sein!"),
+    match Logbook::create(db, data.into_inner(), user, smtp_pw).await {
+        Ok(msg) => Flash::success(
+            Redirect::to("/log"),
+            format!("Ausfahrt erfolgreich hinzugefügt{msg}"),
+        ),
+        Err(LogbookCreateError::BoatAlreadyOnWater) => {
+            Flash::error(Redirect::to("/log"), "Boot schon am Wasser")
+        }
+        Err(LogbookCreateError::RowerAlreadyOnWater(rower)) => Flash::error(
+            Redirect::to("/log"),
+            format!("Ruderer {} schon am Wasser", rower.name),
+        ),
+        Err(LogbookCreateError::BoatLocked) => Flash::error(Redirect::to("/log"), "Boot gesperrt"),
+        Err(LogbookCreateError::BoatNotFound) => {
+            Flash::error(Redirect::to("/log"), "Boot gibt's ned")
+        }
+        Err(LogbookCreateError::TooManyRowers(expected, actual)) => Flash::error(
+            Redirect::to("/log"),
+            format!(
+                "Zu viele Ruderer (Boot fasst maximal {expected}, es wurden jedoch {actual} Ruderer ausgewählt)"
+            ),
+        ),
+        Err(LogbookCreateError::RowerCreateError(rower, e)) => Flash::error(
+            Redirect::to("/log"),
+            format!("Fehler bei Ruderer {rower}: {e}"),
+        ),
+        Err(LogbookCreateError::ArrivalNotAfterDeparture) => Flash::error(
+            Redirect::to("/log"),
+            "Ankunftszeit kann nicht vor der Abfahrtszeit sein",
+        ),
+        Err(LogbookCreateError::UserNotAllowedToUseBoat) => Flash::error(
+            Redirect::to("/log"),
+            "Schiffsführer darf dieses Boot nicht verwenden",
+        ),
+        Err(LogbookCreateError::SteeringPersonNotInRowers) => Flash::error(
+            Redirect::to("/log"),
+            "Steuerperson nicht in Liste der Ruderer!",
+        ),
+        Err(LogbookCreateError::ShipmasterNotInRowers) => Flash::error(
+            Redirect::to("/log"),
+            "Schiffsführer nicht in Liste der Ruderer!",
+        ),
+        Err(LogbookCreateError::NotYourEntry) => {
+            Flash::error(Redirect::to("/log"), "Nicht deine Ausfahrt!")
+        }
+        Err(LogbookCreateError::ArrivalSetButNotRemainingTwo) => Flash::error(
+            Redirect::to("/log"),
+            "Ankunftszeit gesetzt aber nicht Distanz + Strecke",
+        ),
+        Err(LogbookCreateError::OnlyAllowedToEndTripsEndingToday) => Flash::error(
+            Redirect::to("/log"),
+            "Nur Ausfahrten, die in der letzten Woche enden dürfen eingetragen werden. Für einen Nachtrag schreibe alle Daten an den Vorstand (info@rudernlinz.at).",
+        ),
+        Err(LogbookCreateError::CantChangeHandoperatableStatusForThisBoat) => Flash::error(
+            Redirect::to("/log"),
+            "Handsteuer-Status dieses Boots kann nicht verändert werden.",
+        ),
+        Err(LogbookCreateError::TooFast(km, min)) => Flash::error(
+            Redirect::to("/log"),
+            format!(
+                "KM zu groß für die eingegebene Dauer ({km} km in {min} Minuten). Bitte überprüfe deine Start- und Endzeit und versuche es erneut."
+            ),
+        ),
+        Err(LogbookCreateError::AlreadyFinalized) => Flash::error(
+            Redirect::to("/log"),
+            "Logbucheintrag wurde bereits abgeschlossen.",
+        ),
+        Err(LogbookCreateError::ExternalSteeringPersonMustSteerOrShipmaster) => Flash::error(
+            Redirect::to("/log"),
+            "Wenn du eine 'Externe Steuerperson' hinzufügst, muss diese steuern oder Schiffsführer sein!",
+        ),
     }
 }
 
@@ -312,7 +361,13 @@ async fn update(
     let data = data.into_inner();
 
     let Some(logbook) = Logbook::find_by_id(db, data.id).await else {
-        return Flash::error(Redirect::to("/log"), format!("Logbucheintrag kann nicht bearbeitet werden, da es einen Logbuch-Eintrag mit ID={} nicht gibt", data.id));
+        return Flash::error(
+            Redirect::to("/log"),
+            format!(
+                "Logbucheintrag kann nicht bearbeitet werden, da es einen Logbuch-Eintrag mit ID={} nicht gibt",
+                data.id
+            ),
+        );
     };
 
     match logbook.update(db, data.clone(), &user.user).await {
@@ -353,14 +408,36 @@ async fn home_logbook(
         );
     };
 
-    match logbook.home(db,user, data.into_inner(), smtp_pw).await {
+    match logbook.home(db, user, data.into_inner(), smtp_pw).await {
         Ok(_) => Flash::success(Redirect::to("/log"), "Ausfahrt korrekt eingetragen"),
-        Err(LogbookUpdateError::TooManyRowers(expected, actual)) => Flash::error(Redirect::to("/log"), format!("Zu viele Ruderer (Boot fasst maximal {expected}, es wurden jedoch {actual} Ruderer ausgewählt)")),
-        Err(LogbookUpdateError::OnlyAllowedToEndTripsEndingToday) => Flash::error(Redirect::to("/log"), "Nur Ausfahrten, die heute enden dürfen eingetragen werden. Für einen Nachtrag schreibe alle Daten dem Vorstand an info@rudernlinz.at."),
-        Err(LogbookUpdateError::TooFast(km, min)) => Flash::error(Redirect::to("/log"), format!("KM zu groß für die eingegebene Dauer ({km} km in {min} Minuten). Bitte überprüfe deine Start- und Endzeit und versuche es erneut.")),
-        Err(LogbookUpdateError::AlreadyFinalized) => Flash::error(Redirect::to("/log"), "Logbucheintrag wurde bereits abgeschlossen."),
-        Err(LogbookUpdateError::ExternalSteeringPersonMustSteerOrShipmaster) => Flash::error(Redirect::to("/log"), "Wenn du eine 'Externe Steuerperson' hinzufügst, muss diese steuern oder Schiffsführer sein!"),
-        Err(LogbookUpdateError::BoatAlreadyOnWater) => Flash::error(Redirect::to("/log"), "Das Boot war in diesem Zeitraum schon am Wasser. Bitte überprüfe das Datum und die Zeit."),
+        Err(LogbookUpdateError::TooManyRowers(expected, actual)) => Flash::error(
+            Redirect::to("/log"),
+            format!(
+                "Zu viele Ruderer (Boot fasst maximal {expected}, es wurden jedoch {actual} Ruderer ausgewählt)"
+            ),
+        ),
+        Err(LogbookUpdateError::OnlyAllowedToEndTripsEndingToday) => Flash::error(
+            Redirect::to("/log"),
+            "Nur Ausfahrten, die heute enden dürfen eingetragen werden. Für einen Nachtrag schreibe alle Daten dem Vorstand an info@rudernlinz.at.",
+        ),
+        Err(LogbookUpdateError::TooFast(km, min)) => Flash::error(
+            Redirect::to("/log"),
+            format!(
+                "KM zu groß für die eingegebene Dauer ({km} km in {min} Minuten). Bitte überprüfe deine Start- und Endzeit und versuche es erneut."
+            ),
+        ),
+        Err(LogbookUpdateError::AlreadyFinalized) => Flash::error(
+            Redirect::to("/log"),
+            "Logbucheintrag wurde bereits abgeschlossen.",
+        ),
+        Err(LogbookUpdateError::ExternalSteeringPersonMustSteerOrShipmaster) => Flash::error(
+            Redirect::to("/log"),
+            "Wenn du eine 'Externe Steuerperson' hinzufügst, muss diese steuern oder Schiffsführer sein!",
+        ),
+        Err(LogbookUpdateError::BoatAlreadyOnWater) => Flash::error(
+            Redirect::to("/log"),
+            "Das Boot war in diesem Zeitraum schon am Wasser. Bitte überprüfe das Datum und die Zeit.",
+        ),
         Err(e) => Flash::error(
             Redirect::to("/log"),
             format!("Eintrag {logbook_id} konnte nicht abgesendet werden (Fehler: {e:?})!"),
@@ -508,7 +585,7 @@ mod test {
     use sqlx::SqlitePool;
 
     use crate::model::logbook::Logbook;
-    use crate::tera::{log::Boat, User};
+    use crate::tera::{User, log::Boat};
     use crate::testdb;
 
     #[sqlx::test]

src/tera/misc.rs

@@ -1,4 +1,4 @@
-use rocket::{get, http::ContentType, routes, Route, State};
+use rocket::{Route, State, get, http::ContentType, routes};
 use sqlx::SqlitePool;
 
 use crate::model::{event::Event, personal::cal::get_personal_cal, user::User};

src/tera/mod.rs

@@ -2,7 +2,7 @@ use std::{fs::OpenOptions, io::Write};
 
 use chrono::{Datelike, Local};
 use rocket::{
-    catch, catchers,
+    Build, Data, FromForm, Request, Rocket, State, catch, catchers,
     fairing::{AdHoc, Fairing, Info, Kind},
     form::Form,
     fs::FileServer,
@@ -13,7 +13,6 @@ use rocket::{
     response::{Flash, Redirect},
     routes,
     time::{Duration, OffsetDateTime},
-    Build, Data, FromForm, Request, Rocket, State,
 };
 use rocket_dyn_templates::Template;
 use serde::Deserialize;
@@ -21,6 +20,7 @@ use sqlx::SqlitePool;
 use tera::Context;
 
 use crate::{
+    SCHECKBUCH,
     model::{
         logbook::Logbook,
         notification::Notification,
@@ -28,7 +28,6 @@ use crate::{
         role::Role,
         user::{User, UserWithDetails},
     },
-    SCHECKBUCH,
 };
 
 pub(crate) mod admin;
@@ -202,7 +201,10 @@ async fn blogpost_unpublished(
 
 #[catch(403)] //forbidden
 fn forbidden_error() -> Flash<Redirect> {
-    Flash::error(Redirect::to("/"), "Keine Berechtigung für diese Aktion. Wenn du der Meinung bist, dass du das machen darfst, melde dich bitte bei it@rudernlinz.at.")
+    Flash::error(
+        Redirect::to("/"),
+        "Keine Berechtigung für diese Aktion. Wenn du der Meinung bist, dass du das machen darfst, melde dich bitte bei it@rudernlinz.at.",
+    )
 }
 
 struct Usage {}
@@ -328,11 +330,13 @@ mod test {
 
         assert_eq!(response.status(), Status::Ok);
 
-        assert!(response
-            .into_string()
-            .await
-            .unwrap()
-            .contains("Ruderassistent"));
+        assert!(
+            response
+                .into_string()
+                .await
+                .unwrap()
+                .contains("Ruderassistent")
+        );
     }
 
     #[sqlx::test]

src/tera/notification.rs

@@ -1,7 +1,7 @@
 use rocket::{
-    get,
+    Route, State, get,
     response::{Flash, Redirect},
-    routes, Route, State,
+    routes,
 };
 use sqlx::SqlitePool;
 

src/tera/planned.rs

@@ -1,14 +1,15 @@
 use rocket::{
-    get,
+    Route, State, get,
     request::FlashMessage,
     response::{Flash, Redirect},
-    routes, Route, State,
+    routes,
 };
 use rocket_dyn_templates::Template;
 use sqlx::SqlitePool;
 use tera::Context;
 
 use crate::{
+    AMOUNT_DAYS_TO_SHOW_TRIPS_AHEAD,
     model::{
         log::Log,
         tripdetails::TripDetails,
@@ -16,7 +17,6 @@ use crate::{
         user::{AllowedForPlannedTripsUser, User, UserWithDetails},
         usertrip::{UserTrip, UserTripDeleteError, UserTripError},
     },
-    AMOUNT_DAYS_TO_SHOW_TRIPS_AHEAD,
 };
 
 #[get("/")]
@@ -81,14 +81,15 @@ async fn join(
                     ),
                 )
                 .await;
-            }else{
+            } else {
                 Log::create(
                     db,
                     format!(
                         "User {} registered the guest '{}' for trip_details.id={}",
                         user.name, registered_user, trip_details_id
                     ),
-                ).await;
+                )
+                .await;
             }
             Flash::success(Redirect::to("/planned"), "Erfolgreich angemeldet!")
         }
@@ -98,9 +99,10 @@ async fn join(
         Err(UserTripError::AlreadyRegistered) => {
             Flash::error(Redirect::to("/planned"), "Du nimmst bereits teil!")
         }
-        Err(UserTripError::AlreadyRegisteredAsCox) => {
-            Flash::error(Redirect::to("/planned"), "Du hilfst bereits als Steuerperson aus!")
-        }
+        Err(UserTripError::AlreadyRegisteredAsCox) => Flash::error(
+            Redirect::to("/planned"),
+            "Du hilfst bereits als Steuerperson aus!",
+        ),
         Err(UserTripError::CantRegisterAtOwnEvent) => Flash::error(
             Redirect::to("/planned"),
             "Du kannst bei einer selbst ausgeschriebenen Fahrt nicht mitrudern ;)",
@@ -160,7 +162,10 @@ async fn remove_guest(
             )
             .await;
 
-            Flash::error(Redirect::to("/planned"), "Die Bootseinteilung wurde bereits gemacht. Wenn du doch nicht mitrudern kannst, melde dich bitte unbedingt schnellstmöglich bei einer angemeldeten Steuerperson!")
+            Flash::error(
+                Redirect::to("/planned"),
+                "Die Bootseinteilung wurde bereits gemacht. Wenn du doch nicht mitrudern kannst, melde dich bitte unbedingt schnellstmöglich bei einer angemeldeten Steuerperson!",
+            )
         }
         Err(UserTripDeleteError::GuestNotParticipating) => {
             Flash::error(Redirect::to("/planned"), "Gast nicht angemeldet.")
@@ -211,7 +216,10 @@ async fn remove(
             )
             .await;
 
-            Flash::error(Redirect::to("/planned"), "Das Boot ist bereits eingeteilt. Bitte kontaktiere den Schiffsführer (Nummern siehe Signalgruppe) falls du dich doch abmelden willst.")
+            Flash::error(
+                Redirect::to("/planned"),
+                "Das Boot ist bereits eingeteilt. Bitte kontaktiere den Schiffsführer (Nummern siehe Signalgruppe) falls du dich doch abmelden willst.",
+            )
         }
         Err(UserTripDeleteError::NotVisibleToUser) => {
             Log::create(
@@ -223,7 +231,10 @@ async fn remove(
             )
             .await;
 
-            Flash::error(Redirect::to("/planned"), "Abmeldung nicht möglich, da du dieses Event eigentlich gar nicht sehen solltest...")
+            Flash::error(
+                Redirect::to("/planned"),
+                "Abmeldung nicht möglich, da du dieses Event eigentlich gar nicht sehen solltest...",
+            )
         }
         Err(_) => {
             panic!("Not possible to be here");

src/tera/stat.rs

@@ -1,5 +1,5 @@
-use rocket::{get, routes, Route, State};
-use rocket_dyn_templates::{context, Template};
+use rocket::{Route, State, get, routes};
+use rocket_dyn_templates::{Template, context};
 use sqlx::SqlitePool;
 
 use crate::model::{

src/tera/trailerreservation.rs

@@ -1,10 +1,11 @@
 use chrono::NaiveDate;
 use rocket::{
+    FromForm, Route, State,
     form::Form,
     get, post,
     request::FlashMessage,
     response::{Flash, Redirect},
-    routes, FromForm, Route, State,
+    routes,
 };
 use rocket_dyn_templates::Template;
 use sqlx::SqlitePool;

templates/admin/mail.html.tera

@@ -26,26 +26,24 @@
                  role="alert">
                 <h2 class="h2">Mitglieds-Beitrags-Info</h2>
                 <div class="p-3 grid gap-3">
-                  <a class="btn btn-primary" href="/admin/mail/fee/test">
-                    Test-Mail an mich versenden
-                  </a>
-                  <a class="btn btn-alert" href="/admin/mail/fee" 
-                    onclick="return confirm('Hast du die Gebührenauflistung geprüft und willst du die Mail an alle ausschicken?');">
-                    An ALLE Mitglieder versenden
-                  </a>
+                    <a class="btn btn-primary" href="/admin/mail/fee/test">Test-Mail an mich versenden</a>
+                    <a class="btn btn-alert"
+                       href="/admin/mail/fee"
+                       onclick="return confirm('Hast du die Gebührenauflistung geprüft und willst du die Mail an alle ausschicken?');">
+                        An ALLE Mitglieder versenden
+                    </a>
                 </div>
             </div>
             <div class="bg-white dark:bg-primary-900 text-black dark:text-white rounded-md block shadow mt-5"
                  role="alert">
                 <h2 class="h2">Unfreundliche Zahlungsaufforderung</h2>
                 <div class="p-3 grid gap-3">
-                  <a class="btn btn-primary" href="/admin/mail/fee-final/test">
-                    Test-Mail an mich versenden
-                  </a>
-                  <a class="btn btn-alert" href="/admin/mail/fee-final" 
-                    onclick="return confirm('Hast du die Gebührenauflistung geprüft, gecheckt ob alle die bereits bezahlt haben auch eingetragen wurden und willst du die Mail an alle, die noch nicht bezahlt haben ausschicken?');">
-                    An ALLE Mitglieder versenden, die noch nicht bezahlt haben
-                  </a>
+                    <a class="btn btn-primary" href="/admin/mail/fee-final/test">Test-Mail an mich versenden</a>
+                    <a class="btn btn-alert"
+                       href="/admin/mail/fee-final"
+                       onclick="return confirm('Hast du die Gebührenauflistung geprüft, gecheckt ob alle die bereits bezahlt haben auch eingetragen wurden und willst du die Mail an alle, die noch nicht bezahlt haben ausschicken?');">
+                        An ALLE Mitglieder versenden, die noch nicht bezahlt haben
+                    </a>
                 </div>
             </div>
         </div>

templates/admin/role.html.tera

@@ -0,0 +1,37 @@
+{% import "includes/macros" as macros %}
+{% import "includes/forms/boat" as boat %}
+{% extends "base" %}
+{% block content %}
+    <div class="max-w-screen-lg w-full dark:text-white">
+        <h1 class="h1">Rolle</h1>
+        <div class="grid ">
+            <div class="bg-white dark:bg-primary-900 text-black dark:text-white rounded-md block shadow mt-5"
+                 role="alert">
+                <h2 class="h2">Rolle</h2>
+                {% for role in roles %}
+                    <div data-filterable="true"
+                         data-filter="{{ role.name }}"
+                         class="w-full border-t">
+                        <form action="/admin/role/{{ role.id }}"
+                              data-filterable="true"
+                              method="post"
+                              class="bg-white dark:bg-primary-900 p-4 w-full">
+                            <div class="w-full">
+                                <input type="hidden" name="id" value="{{ role.id }}" />
+                                <div class="font-bold mb-1 text-black dark:text-white">
+                                    {{ role.name }}
+                                    <br />
+                                </div>
+                                <div class="grid md:grid-cols-3 gap-3">
+                                    {{ macros::input(label='Formatierter Name', name='formatted_name', type='text', value=role.formatted_name) }}
+                                    {{ macros::input(label='Beschreibung', name='desc', type='text', value=role.desc) }}
+                                    <input value="Ändern" type="submit" class="w-28 btn btn-primary" />
+                                </div>
+                            </div>
+                        </form>
+                    </div>
+                {% endfor %}
+            </div>
+        </div>
+    </div>
+{% endblock content %}

templates/admin/user/index.html.tera

@@ -5,28 +5,134 @@
         <h1 class="h1">Users</h1>
         {% if allowed_to_edit %}
             <details class="mt-5 bg-gray-200 dark:bg-primary-600 p-3 rounded-md">
-                <summary class="px-3 cursor-pointer text-md font-bold text-primary-950 dark:text-white">Neue Person hinzufügen</summary>
-                <form action="/admin/user/new"
-		  onsubmit="return confirm('Willst du wirklich einen neuen Benutzer anlegen?');"
-                  method="post"
-                  class="flex mt-4 rounded-md sm:flex items-end justify-between">
-                <div class="w-full">
-                    <div>
-                        <label for="name" class="sr-only">Name</label>
-                        <input type="text"
-                                name="name"
-                                class="input rounded-md w-100"
-                                placeholder="Name" />
+                <summary class="px-3 cursor-pointer text-md font-bold text-primary-950 dark:text-white">
+                    Neue Person hinzufügen
+                </summary>
+                <div class="grid sm:grid-cols-3 gap-3 mt-3">
+                    <button type="button"
+                            onclick="document.getElementById('add-clubuser').showModal()"
+                            class="btn btn-primary">🥳 Vereinsmitglied</button>
+                    <button type="button"
+                            onclick="document.getElementById('add-scheckbuch').showModal()"
+                            class="btn btn-dark">🧑‍🏫 Scheckbuch</button>
+                    <button type="button"
+                            onclick="document.getElementById('add-schnupperkurs').showModal()"
+                            class="btn btn-dark">👨‍🎓 Schnupperkurs</button>
+                </div>
+                <dialog id="add-clubuser"
+                        class="max-w-screen-sm w-full dark:bg-primary-900 dark:text-white rounded-md"
+                        onclick="document.getElementById('add-clubuser').close()">
+                    <div onclick="event.stopPropagation();" class="p-3">
+                        <button type="button"
+                                onclick="document.getElementById('add-clubuser').close()"
+                                title="Schließen"
+                                class="sidebar-close border-0 bg-primary-100 focus:bg-primary-50 text-black flex items-center justify-center transform rotate-45 absolute right-0 mr-3">
+                            <svg class="inline h-5 w-5"
+                                 width="16"
+                                 height="16"
+                                 fill="currentColor"
+                                 viewBox="0 0 16 16">
+                                <path d="M8 4a.5.5 0 0 1 .5.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3A.5.5 0 0 1 8 4z"></path>
+                            </svg>
+                        </button>
+                        <div class="mt-8">
+                            <h2 class="h3 mb-3">Neues Vereinsmitglied</h2>
+                            <form action="/admin/user/new/clubmember"
+                                  method="post"
+                                  enctype="multipart/form-data"
+                                  class="grid gap-3">
+                                <div>
+                                    <label for="membertype" class="text-sm text-gray-600 dark:text-gray-100">Mitgliedstyp</label>
+                                    <select name="membertype" id="membertype" class="input rounded-md ">
+                                        <option selected="" value="regular">Reguläres Vereinsmitglied</option>
+                                        <option value="unterstuetzend">Unterstützendes Vereinsmitglied</option>
+                                        <option value="foerdernd">Förderndes Vereinsmitglied</option>
+                                    </select>
+                                </div>
+                                {{ macros::input(label='Name', name='name', type="text", required=true) }}
+                                {{ macros::input(label='Mailadresse', name='mail', type="email", required=true, placeholder='user@mail.at') }}
+                                {{ macros::select(label="Finanzielles", data=financial, name='financial_id', display=['name'], default="Keine Ermäßigung") }}
+                                {{ macros::input(label='Mitglied seit', name='member_since', type="date", value=now() | date(), required=true) }}
+                                {{ macros::input(label='Geburtsdatum', name='birthdate', type="date", required=true) }}
+                                {{ macros::input(label='Telefonnummer', name='phone', type="text", required=true) }}
+                                {{ macros::input(label='Adresse', name='address', type="text", required=true) }}
+                                {{ macros::input(label='Beitrittserklärung', name='membership_pdf', type="file", accept='application/pdf', required=true) }}
+                                <input value="Neues Vereinsmitglied anlegen"
+                                       type="submit"
+                                       class="btn btn-primary" />
+                            </form>
+                        </div>
                     </div>
-                </div>
-                <div class="text-right ml-3">
-                    <input value="Hinzufügen"
-                           type="submit"
-                           class="w-28 mt-2 sm:mt-0 rounded-md bg-primary-500 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" />
-                </div>
-            </form>
+                </dialog>
+                <dialog id="add-scheckbuch"
+                        class="max-w-screen-sm w-full dark:bg-primary-900 dark:text-white rounded-md"
+                        onclick="document.getElementById('add-scheckbuch').close()">
+                    <div onclick="event.stopPropagation();" class="p-3">
+                        <button type="button"
+                                onclick="document.getElementById('add-scheckbuch').close()"
+                                title="Schließen"
+                                class="sidebar-close border-0 bg-primary-100 focus:bg-primary-50 text-black flex items-center justify-center transform rotate-45 absolute right-0 mr-3">
+                            <svg class="inline h-5 w-5"
+                                 width="16"
+                                 height="16"
+                                 fill="currentColor"
+                                 viewBox="0 0 16 16">
+                                <path d="M8 4a.5.5 0 0 1 .5.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3A.5.5 0 0 1 8 4z"></path>
+                            </svg>
+                        </button>
+                        <div class="mt-8">
+                            <h2 class="h3 mb-3">Neues Scheckbuch</h2>
+                            <form action="/admin/user/new/scheckbuch"
+                                  method="post"
+                                  enctype="multipart/form-data"
+                                  class="grid gap-3">
+                                {{ macros::input(label='Name', name='name', type="text", required=true) }}
+                                {{ macros::input(label='Mailadresse', name='mail', type="email", required=true, placeholder='user@mail.at') }}
+                                <input value="Neues Scheckbuch anlegen"
+                                       type="submit"
+                                       class="btn btn-primary" />
+                            </form>
+                        </div>
+                    </div>
+                </dialog>
+                <dialog id="add-schnupperkurs"
+                        class="max-w-screen-sm w-full dark:bg-primary-900 dark:text-white rounded-md"
+                        onclick="document.getElementById('add-schnupperkurs').close()">
+                    <div onclick="event.stopPropagation();" class="p-3">
+                        <button type="button"
+                                onclick="document.getElementById('add-schnupperkurs').close()"
+                                title="Schließen"
+                                class="sidebar-close border-0 bg-primary-100 focus:bg-primary-50 text-black flex items-center justify-center transform rotate-45 absolute right-0 mr-3">
+                            <svg class="inline h-5 w-5"
+                                 width="16"
+                                 height="16"
+                                 fill="currentColor"
+                                 viewBox="0 0 16 16">
+                                <path d="M8 4a.5.5 0 0 1 .5.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3A.5.5 0 0 1 8 4z"></path>
+                            </svg>
+                        </button>
+                        <div class="mt-8">
+                            <form action="/admin/user/new/schnupper"
+                                  method="post"
+                                  enctype="multipart/form-data"
+                                  class="grid gap-3">
+                                <h2 class="h3 mb-3">Neuer Schnupperant</h2>
+                                <div>
+                                    <label for="schnupper_type" class="text-sm text-gray-600 dark:text-gray-100">Typ</label>
+                                    <select name="schnupper_type" id="schnupper_type" class="input rounded-md ">
+                                        <option value="schnupperInterested">Interessiert am Schnupperkurs</option>
+                                        <option value="schnupperant">Fixe Schnupperkurs-Anmeldung</option>
+                                    </select>
+                                </div>
+                                {{ macros::input(label='Name', name='name', type="text", required=true) }}
+                                {{ macros::input(label='Mailadresse', name='mail', type="email", required=true, placeholder='user@mail.at') }}
+                                {{ macros::select(label="Finanzielles", data=financial, name='financial_id', display=['name'], default="Keine Ermäßigung") }}
+                                <input value="Hinzufügen" type="submit" class="btn btn-primary" />
+                            </form>
+                        </div>
+                    </div>
+                </dialog>
             </details>
-            
         {% endif %}
         <!-- START filterBar -->
         <div class="search-wrapper flex">
@@ -36,26 +142,29 @@
                    id="filter-js"
                    class="search-bar"
                    placeholder="Suchen nach (Name, [yes|no]-role:<name>, has-[no-]membership-pdf)" />
-
             <div class="relative">
-              <button id="dropdownbtn" data-dropdown="dropdown" class="btn btn-dark ml-3" type="button">
-                Sortieren 
-              </button>
-
-              <!-- Dropdown menu -->
-              <div id="dropdown" class="z-10 hidden bg-white divide-y divide-gray-100 text-secondary-900 rounded-lg shadow-sm w-44 absolute right-0">
-                  <ul class="py-2 text-sm" aria-labelledby="dropdownbtn">
-                    <li>
-                      <a href="./user" class="block px-4 py-2 hover:bg-gray-100 hover:text-secondary-950">Zuletzt eingeloggt</a>
-                    </li>
-                    <li>
-                      <a href="?sort=name&asc" class="block px-4 py-2 hover:bg-gray-100 hover:text-secondary-950">Name A-Z</a>
-                    </li>
-                    <li>
-                      <a href="?sort=name" class="block px-4 py-2 hover:bg-gray-100 hover:text-secondary-950">Name Z-A</a>
-                    </li>
-                  </ul>
-              </div> 
+                <button id="dropdownbtn"
+                        data-dropdown="dropdown"
+                        class="btn btn-dark ml-3"
+                        type="button">Sortieren</button>
+                <!-- Dropdown menu -->
+                <div id="dropdown"
+                     class="z-10 hidden bg-white divide-y divide-gray-100 text-secondary-900 rounded-lg shadow-sm w-44 absolute right-0">
+                    <ul class="py-2 text-sm" aria-labelledby="dropdownbtn">
+                        <li>
+                            <a href="./user"
+                               class="block px-4 py-2 hover:bg-gray-100 hover:text-secondary-950">Zuletzt eingeloggt</a>
+                        </li>
+                        <li>
+                            <a href="?sort=name&asc"
+                               class="block px-4 py-2 hover:bg-gray-100 hover:text-secondary-950">Name A-Z</a>
+                        </li>
+                        <li>
+                            <a href="?sort=name"
+                               class="block px-4 py-2 hover:bg-gray-100 hover:text-secondary-950">Name Z-A</a>
+                        </li>
+                    </ul>
+                </div>
             </div>
         </div>
         <!-- END filterBar -->
@@ -63,113 +172,21 @@
         {% for user in users %}
             <div data-filterable="true"
                  data-filter="{{ user.name }} {% for role in roles %} {% if role.name in user.roles %} yes-role:{{ role.name }} {% else %} no-role:{{ role.name }} {% endif %} role-{{ role }} {% endfor %} {% if user.membership_pdf %}has-membership-pdf{% else %}has-no-membership-pdf{% endif %}"
-                 class="border-t bg-white dark:bg-primary-900 py-3 px-4 relative">
-                <details class="block dark:text-white w-full">
-                    <summary>
-                        <span class="text-black dark:text-white cursor-pointer">
-                            <span class="font-bold">
-                                {{ user.name }}
-                                {% if not user.last_access and allowed_to_edit and user.mail %}
-                                    <form action="/admin/user"
-                                          method="post"
-                                          enctype="multipart/form-data"
-                                          class="inline">
-                                        &bullet; <a class="font-normal text-primary-600 dark:text-primary-200 hover:text-primary-900 dark:hover:text-primary-300 underline"
-    href="/admin/user/{{ user.id }}/send-welcome-mail"
-    onclick="return confirm('Willst du wirklich das Willkommensmail an {{ user.name }} ausschicken?');">Willkommensmail verschicken</a>
-                                    </form>
-                                {% endif %}
-                                {% if user.last_access %}&bullet; ⏳&nbsp;{{ user.last_access | date }}{% endif %}
-                            </span>
-                            <small class="block text-gray-600 dark:text-gray-100">
-                                {% for role in user.roles -%}
-                                    {{ role }}
-                                    {%- if not loop.last %},
-                                    {% endif -%}
-                                {% endfor %}
-                            </small>
-                        </span>
-                    </summary>
-                    <form action="/admin/user"
-                          method="post"
-                          enctype="multipart/form-data"
-                          class="w-full mt-2">
-                        {% if user.pw %}
-                            <a class="block my-1 font-normal text-[#f43f5e] dark:text-primary-200 hover:text-primary-900 dark:hover:text-primary-300 underline"
-                               href="/admin/user/{{ user.id }}/reset-pw"
-                               onclick="return confirm('Willst du wirklich das Passwort zurücksetzen?');">Passwort zurücksetzen</a>
-                        {% endif %}
-                        <div class="w-full grid gap-3 mt-3">
-                            <input type="hidden" name="id" value="{{ user.id }}" />
-                            <div class="grid sm:grid-cols-2 lg:grid-cols-4 gap-3">
-                                {% for cluster, cluster_roles in roles | group_by(attribute="cluster") %}
-                                    <label for="cluster_{{ loop.index }}">{{ cluster }}</label>
-                                    {# Determine the initially selected role within the cluster #}
-                                    {% set_global selected_role_id = "none" %}
-                                    {% for role in cluster_roles %}
-                                        {% if selected_role_id == "none" and role.name in user.roles %}
-                                            {% set_global selected_role_id = role.id %}
-                                        {% endif %}
-                                    {% endfor %}
-                                    {# Set default name to the selected role ID or first role if none selected #}
-                                    <select id="cluster_{{ loop.index }}"
-                                            {% if selected_role_id == 'none' %} {% else %} name="roles[{{ selected_role_id }}]" {% endif %}
-                                            {% if allowed_to_edit == false %}disabled{% endif %}
-                                            onchange=" if (this.value === '') { this.removeAttribute('name'); } else { this.name = 'roles[' + this.options[this.selectedIndex].getAttribute('data-role-id') + ']'; }">
-                                        <option value=""
-                                                data-role-id="none"
-                                                {% if selected_role_id == 'none' %}selected="selected"{% endif %}>
-                                            None
-                                        </option>
-                                        {% for role in cluster_roles %}
-                                            <option value="on"
-                                                    data-role-id="{{ role.id }}"
-                                                    {% if role.id == selected_role_id %}selected="selected"{% endif %}>
-                                                {{ role.name }}
-                                            </option>
-                                        {% endfor %}
-                                    </select>
-                                {% endfor %}
-                                {% for role in roles %}
-                                    {% if not role.cluster %}
-                                        {{ macros::checkbox(label=role.name, name="roles[" ~ role.id ~ "]", id=loop.index , checked=role.name in user.roles, disabled=allowed_to_edit == false) }}
-                                    {% endif %}
-                                {% endfor %}
-                                <hr class="sm:col-span-2 lg:col-span-4 my-3" />
-                                {% if user.membership_pdf %}
-                                    <a href="/admin/user/{{ user.id }}/membership"
-                                       class="text-black dark:text-white">Beitrittserklärung herunterladen</a>
-                                {% else %}
-                                    {{ macros::input(label='Beitrittserklärung', name='membership_pdf', id=loop.index, type="file", readonly=allowed_to_edit == false, accept='application/pdf') }}
-                                {% endif %}
-                                {{ macros::input(label='DOB', name='dob', id=loop.index, type="text", value=user.dob, readonly=allowed_to_edit == false) }}
-                                {{ macros::input(label='Weight (kg)', name='weight', id=loop.index, type="text", value=user.weight, readonly=allowed_to_edit == false) }}
-                                {{ macros::input(label='Sex', name='sex', id=loop.index, type="text", value=user.sex, readonly=allowed_to_edit == false) }}
-                                {{ macros::input(label='Mitglied seit', name='member_since_date', id=loop.index, type="text", value=user.member_since_date, readonly=allowed_to_edit == false) }}
-                                {{ macros::input(label='Geburtsdatum', name='birthdate', id=loop.index, type="text", value=user.birthdate, readonly=allowed_to_edit == false) }}
-                                {{ macros::input(label='Mail', name='mail', id=loop.index, type="text", value=user.mail, readonly=allowed_to_edit == false) }}
-                                {{ macros::input(label='Nickname', name='nickname', id=loop.index, type="text", value=user.nickname, readonly=allowed_to_edit == false) }}
-                                {{ macros::input(label='Notizen', name='notes', id=loop.index, type="text", value=user.notes, readonly=allowed_to_edit == false) }}
-                                {{ macros::input(label='Telefon', name='phone', id=loop.index, type="text", value=user.phone, readonly=allowed_to_edit == false) }}
-                                {{ macros::input(label='Adresse', name='address', id=loop.index, type="text", value=user.address, readonly=allowed_to_edit == false) }}
-                                {% if allowed_to_edit %}
-                                    {{ macros::select(label="Familie", data=families, name='family_id', selected_id=user.family_id, display=['names'], default="Keine Familie", new_last_entry='Neue Familie anlegen') }}
-                                {% endif %}
-                            </div>
-                        </div>
-                        {% if allowed_to_edit %}
-                            <div class="mt-3 text-right">
-                                <a href="/admin/user/{{ user.id }}/delete"
-                                   class="w-28 btn btn-alert"
-                                   onclick="return confirm('Wirklich löschen?');">
-                                    {% include "includes/delete-icon" %}
-                                    Löschen
-                                </a>
-                                <input value="Ändern" type="submit" class="w-28 btn btn-primary ml-1" />
-                            </div>
-                        {% endif %}
-                    </form>
-                </details>
+                 class="border-t bg-white dark:bg-primary-900 py-3 px-4 relative flex justify-between items-center">
+                <span class="text-black dark:text-white">
+                    <span class="font-bold">
+                        {{ user.name }}
+                        {% if user.last_access %}&bullet; ⏳&nbsp;{{ user.last_access | date }}{% endif %}
+                    </span>
+                    <small class="block text-gray-600 dark:text-gray-100">
+                        {% for role in user.roles -%}
+                            {{ role }}
+                            {%- if not loop.last %},
+                            {% endif -%}
+                        {% endfor %}
+                    </small>
+                </span>
+                <a href="/admin/user/{{ user.id }}" class="btn btn-dark ml-3">{% include "includes/pencil" %}</a>
             </div>
         {% endfor %}
     </div>

templates/admin/user/scheckbuch.html.tera

@@ -56,9 +56,9 @@
                         <div style="width: 100%" class="col-span-2">
                             <b>{{ user.name }} - Ausfahrten: {{ trips | length }}</b>
                             <ul class="list-disc ms-4">
-                            {% for trip in trips %}
-                                <li>{{ log::show_old(log=trip, state="completed", only_ones=false, index=loop.index) }}</li>
-                            {% endfor %}
+                                {% for trip in trips %}
+                                    <li>{{ log::show_old(log=trip, state="completed", only_ones=false, index=loop.index) }}</li>
+                                {% endfor %}
                             </ul>
                         </div>
                         {% if "admin" in loggedin_user.roles  or "kassier" in loggedin_user.roles %}

templates/admin/user/view.html.tera

@@ -0,0 +1,435 @@
+{% import "includes/macros" as macros %}
+{% import "includes/forms/log" as log %}
+{% extends "base" %}
+{% block content %}
+    <div class="max-w-screen-lg w-full">
+        {% if "admin" in loggedin_user.roles or "Vorstand" in loggedin_user.roles %}
+            <div class="mb-5 lg:mb-0">
+                <a href="/admin/user" class="link link-primary link-no-underline">&larr; Userverwaltung</a>
+            </div>
+        {% endif %}
+        <h1 class="h1">{{ user.name }}</h1>
+        <div class="grid sm:grid-cols-2 gap-8 my-8">
+            <div class="bg-white dark:bg-primary-900 text-black dark:text-white rounded-md block shadow">
+                <h2 class="h2">
+                    Grunddaten
+                    <br />
+                    <small class="inline-block text-xs  text-gray-500 dark:text-gray-100 ">
+                        {% if user.last_access %}
+                            Zuletzt eingeloggt am {{ user.last_access | date(format="%d. %m. %Y") }}
+                        {% else %}
+                            App-Boykott 😢
+                        {% endif %}
+                    </small>
+                </h2>
+                <div class="mx-3 divide-y divide-gray-200 dark:divide-primary-600">
+                    <div class="py-3 grid gap-3">
+                        <form action="/admin/user/{{ user.id }}/change-mail" method="post">
+                            {{ macros::inputgroup(label='Mailadresse', name='mail', type="text", value=user.mail, readonly=not allowed_to_edit) }}
+                        </form>
+                        <form action="/admin/user/{{ user.id }}/change-phone" method="post">
+                            {{ macros::inputgroup(label='Telefonnummer', name='phone', type="text", value=user.phone, readonly=not allowed_to_edit) }}
+                        </form>
+                        <form action="/admin/user/{{ user.id }}/change-nickname" method="post">
+                            {{ macros::inputgroup(label='Spitzname', name='nickname', type="text", value=user.nickname, readonly=not allowed_to_edit) }}
+                        </form>
+                        <form action="/admin/user/{{ user.id }}/change-financial" method="post">
+                            {% if user_financial %}
+                                {{ macros::selectgroup(label="Finanzielles", data=financial, selected_id=user_financial.id, name='financial_id', display=['name'], default="Keine Ermäßigung", readonly=not allowed_to_edit) }}
+                            {% else %}
+                                {{ macros::selectgroup(label="Finanzielles", data=financial, name='financial_id', display=['name'], default="Keine Ermäßigung", readonly=not allowed_to_edit) }}
+                            {% endif %}
+                        </form>
+                        {% if allowed_to_edit %}
+                            <form action="/admin/user/{{ user.id }}/new-note" method="post">
+                                {{ macros::inputgroup(label='Neue Notiz', name='note', type="text") }}
+                            </form>
+                        {% endif %}
+                        {% if user.pw and allowed_to_edit %}
+                            <div>
+                                <a class="block my-1 font-normal text-[#f43f5e] dark:text-primary-200 hover:text-primary-900 dark:hover:text-primary-300 underline"
+                                   href="/admin/user/{{ user.id }}/reset-pw"
+                                   onclick="return confirm('Willst du wirklich das Passwort zurücksetzen?');">Passwort zurücksetzen</a>
+                            </div>
+                        {% endif %}
+                    </div>
+                </div>
+            </div>
+            <div class="bg-white dark:bg-primary-900 text-black dark:text-white rounded-md block shadow">
+                <h2 class="h2">
+                    Mitgliedschaft
+                    <br />
+                    <small class="inline-block text-xs  text-gray-500 dark:text-gray-100 ">
+                        {% if "SchnupperInterest" in member %}
+                            Interessiert am Schnupperkurs
+                        {% elif "Schnupperant" in member %}
+                            Beim nächsten Schnupperkurs angemeldet
+                        {% elif "Scheckbuch" in member %}
+                            {% set logbook = member["Scheckbuch"] %}
+                            Scheckbuch (Ausfahrten: {{ logbook | length }})
+                        {% elif "Regular" in member %}
+                            Reguläres Vereinsmitglied
+                        {% elif "Foerdernd" in member %}
+                            Förderndes Vereinsmitglied
+                        {% elif "Unterstuetzend" in member %}
+                            Unterstützendes Vereinsmitglied
+                        {% endif %}
+                    </small>
+                </h2>
+                <div class="mx-3">
+                    {% if is_clubmember %}
+                        <div class="py-3 grid gap-3">
+                            <form action="/admin/user/{{ user.id }}/change-member-since" method="post">
+                                {{ macros::inputgroup(label='Mitglied seit', name='member_since', type="date", value=user.member_since_date, readonly=not allowed_to_edit) }}
+                            </form>
+                            <form action="/admin/user/{{ user.id }}/change-birthdate" method="post">
+                                {{ macros::inputgroup(label='Geburtsdatum', name='birthdate', type="date", value=user.birthdate, readonly=not allowed_to_edit) }}
+                            </form>
+                            <form action="/admin/user/{{ user.id }}/change-address" method="post">
+                                {{ macros::inputgroup(label='Adresse', name='address', type="text", value=user.address, readonly=not allowed_to_edit) }}
+                            </form>
+                            <form action="/admin/user/{{ user.id }}/change-skill" method="post">
+                                {% if user_skill %}
+                                    {{ macros::selectgroup(label="Steuererlaubnis", data=skill, selected_id=user_skill.id, name='skill_id', display=['name'], default="Keine Steuerberechtigung", readonly=not allowed_to_edit) }}
+                                {% else %}
+                                    {{ macros::selectgroup(label="Steuererlaubnis", data=skill, name='skill_id', display=['name'], default="Keine Steuerberechtigung", readonly=not allowed_to_edit) }}
+                                {% endif %}
+                            </form>
+                            <form action="/admin/user/{{ user.id }}/change-family" method="post">
+                                {{ macros::selectgroup(label="Familie", data=families, name='family_id', selected_id=user.family_id, display=['names'], default="Keine Familie", new_last_entry='Neue Familie anlegen', readonly=not allowed_to_edit) }}
+                            </form>
+                        </div>
+                        <div class="py-3">
+                            {% if user.membership_pdf %}
+                                <a href="/admin/user/{{ user.id }}/membership"
+                                   class="link link-primary link-no-underline">Beitrittserklärung herunterladen &darr;</a>
+                            {% else %}
+                                ⚠️ Aktuell gibt's keine Beitrittserklärung 😢
+                                {% if allowed_to_edit %}
+                                    Das kannst du hier ändern ⤵️
+                                    <form action="/admin/user/{{ user.id }}/add-membership-pdf"
+                                          method="post"
+                                          enctype="multipart/form-data"
+                                          class="grid gap-3">
+                                        <fieldset>
+                                            {{ macros::input(label='Neue Beitrittserklärung hochladen', name='membership_pdf', type="file", accept='application/pdf') }}
+                                        </fieldset>
+                                        <input value="Hochladen" type="submit" class="btn btn-primary" />
+                                    </form>
+                                {% endif %}
+                            {% endif %}
+                        </div>
+                        {% if allowed_to_edit %}
+                            <div class="py-3">
+                                <div class="text-right">
+                                    <button type="button"
+                                            onclick="document.getElementById('change-member-type').showModal()"
+                                            class="btn btn-dark">Mitgliedsstatus ändern</button>
+                                    <a href="/admin/user/{{ user.id }}/delete"
+                                       class="btn btn-alert mt-3"
+                                       onclick="return confirm('Ist {{ user.name }} wirklich aus dem Verein ausgetreten?');">
+                                        {% include "includes/delete-icon" %}
+                                        Mitglied ist ausgetreten
+                                    </a>
+                                </div>
+                            </div>
+                            <dialog id="change-member-type"
+                                    class="max-w-screen-sm w-full dark:bg-primary-900 dark:text-white rounded-md"
+                                    onclick="document.getElementById('change-member-type').close()">
+                                <div onclick="event.stopPropagation();" class="p-3">
+                                    <button type="button"
+                                            onclick="document.getElementById('change-member-type').close()"
+                                            title="Schließen"
+                                            class="sidebar-close border-0 bg-primary-100 focus:bg-primary-50 text-black flex items-center justify-center transform rotate-45 absolute right-0 mr-3">
+                                        <svg class="inline h-5 w-5"
+                                             width="16"
+                                             height="16"
+                                             fill="currentColor"
+                                             viewBox="0 0 16 16">
+                                            <path d="M8 4a.5.5 0 0 1 .5.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3A.5.5 0 0 1 8 4z"></path>
+                                        </svg>
+                                    </button>
+                                    <div class="mt-8">
+                                        <form action="/admin/user/{{ user.id }}/change-membertype"
+                                              method="post"
+                                              enctype="multipart/form-data"
+                                              class="grid gap-3">
+                                            <div>
+                                                <label for="membertype" class="text-sm text-gray-600 dark:text-gray-100">Mitgliedsstatus</label>
+                                                <select name="membertype" id="membertype" class="input rounded-md ">
+                                                    <option selected="" value="regular">Reguläres Vereinsmitglied</option>
+                                                    <option value="unterstuetzend">Unterstützendes Vereinsmitglied</option>
+                                                    <option value="foerdernd">Förderndes Vereinsmitglied</option>
+                                                </select>
+                                            </div>
+                                            <input value="Ändern" type="submit" class="btn btn-primary" />
+                                        </form>
+                                    </div>
+                                </div>
+                            </dialog>
+                        {% endif %}
+                    {% elif "Scheckbuch" in member %}
+                        {% if allowed_to_edit %}
+                            <div class="grid gap-3 pb-3">
+                                <div class="max-h-60 overflow-y-scroll">
+                                    {% for log in logbook %}
+                                        {{ log::show_old(log=log, state="completed", only_ones=false, index=loop.index, allowed_to_edit=false) }}
+                                    {% endfor %}
+                                </div>
+                            </div>
+                            <div class="grid pt-3">
+                                <a href="/admin/user/{{ user.id }}/delete"
+                                   class="btn btn-alert"
+                                   onclick="return confirm('Willst du die Daten von {{ user.name }} wirklich? Seine restlichen Scheckbuch-Ausfahrten entfallen damit...');">
+                                    {% include "includes/delete-icon" %}
+                                    Daten löschen
+                                </a>
+                            </div>
+                        {% endif %}
+                    {% elif "SchnupperInterest" in member %}
+                        {% if allowed_to_edit %}
+                            <div class="grid pt-3">
+                                <a href="/admin/user/{{ user.id }}/schnupperinterest-to-schnupperant"
+                                   class="btn btn-dark"
+                                   onclick="return confirm('Hat sich \'{{ user.name }}\' wirklich zum Kurs angemeldet?');">Zum Schnupperkurs angemeldet</a>
+                            </div>
+                            <div class="grid pt-3">
+                                <a href="/admin/user/{{ user.id }}/schnupperinterest-to-scheckbuch"
+                                   class="btn btn-dark"
+                                   onclick="return confirm('Willst du \'{{ user.name }}\' wirklich auf ein Scheckbuch umwandeln?');">In Scheckbuch umwandeln</a>
+                            </div>
+                            <div class="grid pt-3">
+                                <a href="/admin/user/{{ user.id }}/delete"
+                                   class="btn btn-alert"
+                                   onclick="return confirm('Ist {{ user.name }} wirklich nicht mehr am Schnupperkurs interessiert?');">
+                                    {% include "includes/delete-icon" %}
+                                    Daten löschen
+                                </a>
+                            </div>
+                        {% endif %}
+                    {% elif "Schnupperant" in member %}
+                        {% if allowed_to_edit %}
+                            <div class="grid pt-3">
+                                <a href="/admin/user/{{ user.id }}/schnupperant-to-schnupperinterest"
+                                   class="btn btn-dark"
+                                   onclick="return confirm('Hat sich \'{{ user.name }}\' wirklich vom Schnupperkurs abgemeldet?');">Vom Kurs abgemeldet</a>
+                            </div>
+                            <div class="grid pt-3">
+                                <a href="/admin/user/{{ user.id }}/schnupperant-to-scheckbuch"
+                                   class="btn btn-dark"
+                                   onclick="return confirm('Willst du \'{{ user.name }}\' wirklich auf ein Scheckbuch umwandeln?');">In Scheckbuch umwandeln</a>
+                            </div>
+                            <div class="grid pt-3">
+                                <a href="/admin/user/{{ user.id }}/delete"
+                                   class="btn btn-alert"
+                                   onclick="return confirm('Ist {{ user.name }} wirklich nicht mehr am Schnupperkurs interessiert?');">
+                                    {% include "includes/delete-icon" %}
+                                    Daten löschen
+                                </a>
+                            </div>
+                        {% endif %}
+                    {% endif %}
+                    {% if "Scheckbuch" in member or "Schnupperant" in member %}
+                        {% if allowed_to_edit %}
+                            <div class="grid gap-3 pb-3 mt-3">
+                                <button type="button"
+                                        onclick="document.getElementById('call-for-action').showModal()"
+                                        class="btn btn-primary">Zu Vereinsmitglied umwandeln</button>
+                            </div>
+                            <dialog id="call-for-action"
+                                    class="max-w-screen-sm w-full dark:bg-primary-900 dark:text-white rounded-md"
+                                    onclick="document.getElementById('call-for-action').close()">
+                                <div onclick="event.stopPropagation();" class="p-3">
+                                    <button type="button"
+                                            onclick="document.getElementById('call-for-action').close()"
+                                            title="Schließen"
+                                            class="sidebar-close border-0 bg-primary-100 focus:bg-primary-50 text-black flex items-center justify-center transform rotate-45 absolute right-0 mr-3">
+                                        <svg class="inline h-5 w-5"
+                                             width="16"
+                                             height="16"
+                                             fill="currentColor"
+                                             viewBox="0 0 16 16">
+                                            <path d="M8 4a.5.5 0 0 1 .5.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3A.5.5 0 0 1 8 4z"></path>
+                                        </svg>
+                                    </button>
+                                    <div class="mt-8">
+                                        {% if "Scheckbuch" in member %}
+                                            {% set action = "scheckbook-to-regular" %}
+                                        {% elif "Schnupperant" in member %}
+                                            {% set action = "schnupperant-to-regular" %}
+                                        {% endif %}
+                                        <form action="/admin/user/{{ user.id }}/{{ action }}"
+                                              method="post"
+                                              enctype="multipart/form-data"
+                                              class="grid gap-3">
+                                            <div>
+                                                <label for="membertype" class="text-sm text-gray-600 dark:text-gray-100">Mitgliedstyp</label>
+                                                <select name="membertype" id="membertype" class="input rounded-md ">
+                                                    <option selected="" value="regular">Reguläres Vereinsmitglied</option>
+                                                    <option value="unterstuetzend">Unterstützendes Vereinsmitglied</option>
+                                                    <option value="foerdernd">Förderndes Vereinsmitglied</option>
+                                                </select>
+                                            </div>
+                                            {{ macros::input(label='Mitglied seit', name='member_since', type="date", value=now() | date(), required=true) }}
+                                            {{ macros::input(label='Geburtsdatum', name='birthdate', type="date", value=user.birthdate, required=true) }}
+                                            {{ macros::input(label='Telefonnummer', name='phone', type="text", value=user.phone, required=true) }}
+                                            {{ macros::input(label='Adresse', name='address', type="text", value=user.address, required=true) }}
+                                            {{ macros::input(label='Beitrittserklärung', name='membership_pdf', type="file", accept='application/pdf', required=true) }}
+                                            <input value="Als neues, reguläres Mitglied anlegen"
+                                                   type="submit"
+                                                   class="btn btn-primary" />
+                                        </form>
+                                    </div>
+                                </div>
+                            </dialog>
+                        {% endif %}
+                    {% endif %}
+                </div>
+            </div>
+            {% if is_clubmember %}
+                <div class="bg-white dark:bg-primary-900 text-black dark:text-white rounded-md block shadow">
+                    <h2 class="h2">Rollen</h2>
+                    <div>
+                        <ul class="divide-y divide-gray-200 dark:divide-primary-60 w-full">
+                            {% for role in user.proper_roles -%}
+                                {% if not role.cluster and not role.hide_in_lists %}
+                                    <li class="flex w-full justify-between items-center p-3 {% if allowed_to_edit %}hover:bg-gray-100 dark:hover:bg-primary-950{% endif %}">
+                                        <span>
+                                            <strong>
+                                                {% if role.formatted_name %}
+                                                    {{ role.formatted_name }}
+                                                {% else %}
+                                                    {{ role.name }}
+                                                {% endif %}
+                                            </strong>
+                                            <br />
+                                            <small>{{ role.desc }}</small>
+                                        </span>
+                                        {% if allowed_to_edit %}
+                                            <a href="/admin/user/{{ user.id }}/remove-role/{{ role.id }}"
+                                               onclick="return confirm('Willst du die Rolle \'{{ role.name }}\' von {{ user.name }} wirklich entfernen?');">🗑️</a>
+                                        {% endif %}
+                                    </li>
+                                {% endif %}
+                            {% endfor %}
+                        </ul>
+                        {% if allowed_to_edit %}
+                            <div class="m-3">
+                                <button type="button"
+                                        onclick="document.getElementById('role-modal').showModal()"
+                                        class="btn btn-primary w-full">Rolle hinzufügen</button>
+                            </div>
+                            <dialog id="role-modal"
+                                    class="max-w-screen-sm w-full dark:bg-primary-900 dark:text-white rounded-md"
+                                    onclick="document.getElementById('role-modal').close()">
+                                <div onclick="event.stopPropagation();" class="p-3">
+                                    <button type="button"
+                                            onclick="document.getElementById('role-modal').close()"
+                                            title="Schließen"
+                                            class="sidebar-close border-0 bg-primary-100 focus:bg-primary-50 text-black flex items-center justify-center transform rotate-45 absolute right-0 mr-3">
+                                        <svg class="inline h-5 w-5"
+                                             width="16"
+                                             height="16"
+                                             fill="currentColor"
+                                             viewBox="0 0 16 16">
+                                            <path d="M8 4a.5.5 0 0 1 .5.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3A.5.5 0 0 1 8 4z"></path>
+                                        </svg>
+                                    </button>
+                                    <div class="mt-8">
+                                        <form action="/admin/user/{{ user.id }}/add-role"
+                                              method="post"
+                                              class="grid gap-3">
+                                            <div>
+                                                <label for="role_id" class="text-sm text-gray-600 dark:text-gray-100">Rollen</label>
+                                                <select name="role_id" id="role_id"  class="input rounded-md ">
+                                                    {% for role in roles %}
+                                                        {% if not role.cluster and role not in user.proper_roles and not role.hide_in_lists %}
+                                                            <option value="{{ role.id }}">
+                                                                {% if role.formatted_name %}
+                                                                    {{ role.formatted_name }}
+                                                                {% else %}
+                                                                    {{ role.name }}
+                                                                {% endif %}
+                                                            </option>
+                                                        {% endif %}
+                                                    {% endfor %}
+                                                </select>
+                                            </div>
+                                            <input value="Rolle hinzufügen" type="submit" class="btn btn-primary" />
+                                        </form>
+                                    </div>
+                                </div>
+                            </dialog>
+                        {% endif %}
+                    </div>
+                </div>
+            {% endif %}
+            {% if supposed_to_pay %}
+                <div class="bg-white dark:bg-primary-900 text-black dark:text-white rounded-md block shadow">
+                    <h2 class="h2">💸-Beitrag</h2>
+                    <div class="mx-3 divide-y divide-gray-200 dark:divide-primary-600">
+                        <div class="py-3">
+                            {% if fee %}
+                                <div>
+                                    <strong>{{ fee.name }}</strong>
+                                    <span class="block">{{ fee.sum_in_cents / 100 }}€</span>
+                                </div>
+                                <div>
+                                    {% for p in fee.parts %}
+                                        {{ p.0 }} ({{ p.1 / 100 }}€)
+                                        {% if not loop.last %}+{% endif %}
+                                    {% endfor %}
+                                </div>
+                                {% if "paid" in user.roles %}
+                                    ✅ bezahlt
+                                {% else %}
+                                    ❌ Zahlung ausständig
+                                {% endif %}
+                            {% else %}
+                                {% if "paid" in user.roles %}
+                                    ✅
+                                    {% for key, value in member %}
+                                        {% if loop.first %}{{ key }}{% endif %}
+                                    {% endfor %}
+                                    hat schon bezahlt
+                                {% else %}
+                                    ❌
+                                    {% for key, value in member %}
+                                        {% if loop.first %}{{ key }}{% endif %}
+                                    {% endfor %}
+                                    hat noch nicht bezahlt
+                                {% endif %}
+                            {% endif %}
+                        </div>
+                    </div>
+                </div>
+            {% endif %}
+            <div class="bg-white dark:bg-primary-900 text-black dark:text-white rounded-md block shadow">
+                <h2 class="h2">Aktivitäten</h2>
+                <div class="mx-3 max-h-60 overflow-y-scroll">
+                    <div class="py-3">
+                        <ul class="list-disc ms-4">
+                            {% for activity in activities %}
+                                <li>
+                                    <strong>{{ activity.created_at | date(format="%d. %m. %Y") }}:</strong> <small>{{ activity.text }}</small>
+                                </li>
+                            {% else %}
+                                <li>Noch keine Aktivität... Stay tuned 😆</li>
+                            {% endfor %}
+                        </ul>
+                    </div>
+                </div>
+            </div>
+            <div class="bg-white dark:bg-primary-900 text-black dark:text-white rounded-md block shadow">
+                <h2 class="h2">Ergo-Challenge</h2>
+                <div class="mx-3">
+                    <div class="grid gap-3 pb-3 mt-3">
+                        {{ macros::inputgroup(label='DOB', name='dob', type="text", value=user.dob, readonly=allowed_to_edit == false) }}
+                        {{ macros::inputgroup(label='Weight (kg)', name='weight', type="text", value=user.weight, readonly=allowed_to_edit == false) }}
+                        {{ macros::inputgroup(label='Sex', name='sex', type="text", value=user.sex, readonly=allowed_to_edit == false) }}
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+{% endblock content %}

templates/ergo/final.html.tera

@@ -7,7 +7,7 @@
             <summary>Dirty Thirty</summary>
             <p>
                 <div class="border-r border-l">
-		<textarea style="width: 100%; height: 300px;">
+                    <textarea style="width: 100%; height: 300px;">
                     {%- for stat in thirty %}
                         {%- set names = stat.name | split(pat=" ") %}{% set lastname_index = names | length - 1 %}{% set lastname = names[lastname_index] %}{{ lastname }}&#9;
                         {%- for name in names -%}
@@ -23,7 +23,7 @@
             <summary>Dirty Dozen</summary>
             <p>
                 <div class="border-r border-l">
-		<textarea style="width: 100%; height: 300px;">
+                    <textarea style="width: 100%; height: 300px;">
                     {%- for stat in dozen -%}
                         {%- set names = stat.name | split(pat=" ") %}{% set lastname_index = names | length - 1 %}{% set lastname = names[lastname_index] %}{{ lastname }}&#9;
                         {%- for name in names -%}

templates/ergo/index.html.tera

@@ -21,8 +21,8 @@
                             </li>
                             <li class="py-1">
                                 <a href="https://data.ergochallenge.at"
-    target="_blank"
-    style="text-decoration: underline">Offizielle Ergebnisse</a>, bei Fehlern direkt mit <a href="mailto:office@ergochallenge.at"
+                                   target="_blank"
+                                   style="text-decoration: underline">Offizielle Ergebnisse</a>, bei Fehlern direkt mit <a href="mailto:office@ergochallenge.at"
     style="text-decoration: underline">Christian (Ister)</a> Kontakt aufnehmen
                             </li>
                         </ul>
@@ -75,8 +75,8 @@
                             <div class="pt-3">
                                 <p>
                                     Folgende Daten hat der Ruderassistent von dir. Wenn diese nicht mehr aktuell sind, bitte gewünschte Änderungen an unseren Schriftführer melden (<a href="mailto:info@rudernlinz.at"
-    class="text-primary-600 dark:text-primary-200 hover:text-primary-950 hover:dark:text-primary-300 underline"
-    target="_blank">it@rudernlinz.at</a>).
+   class="text-primary-600 dark:text-primary-200 hover:text-primary-950 hover:dark:text-primary-300 underline"
+   target="_blank">it@rudernlinz.at</a>).
                                     <br />
                                     <br />
                                     <ul>

templates/forms/trip.html.tera

@@ -6,11 +6,11 @@
         {{ macros::input(label='Anzahl Ruderer (ohne Steuerperson)', name='max_people', type='number', required=true, min='0') }}
         {{ macros::checkbox(label='Scheckbuch-Anmeldungen erlauben', name='allow_guests') }}
         {{ macros::input(label='Anmerkungen', name='notes', type='input') }}
-	{% if loggedin_user.allowed_to_steer %}
-	        {{ macros::select(label='Typ', data=trip_types, name='trip_type', default='Reguläre Ausfahrt') }}
-	{% else %}
-	        {{ macros::select(label='Typ', data=trip_types, name='trip_type', only_ergo=true) }}
-	{% endif %}
+        {% if loggedin_user.allowed_to_steer %}
+            {{ macros::select(label='Typ', data=trip_types, name='trip_type', default='Reguläre Ausfahrt') }}
+        {% else %}
+            {{ macros::select(label='Typ', data=trip_types, name='trip_type', only_ergo=true) }}
+        {% endif %}
         <input value="Erstellen" class="w-full btn btn-primary" type="submit" />
     </form>
 </div>

templates/includes/forms/log.html.tera

@@ -82,7 +82,13 @@
         <label for="{{ id }}" class="text-sm text-gray-600 dark:text-gray-100">
             Ruderer (inkl. Schiffsführer und Steuerperson)
         </label>
-        <select style="width: 100%;" multiple name="rowers[]" id="{{ id }}" class="w-full" data-seats="{{ amount_seats }}" data-init={{ init }}>
+        <select style="width: 100%"
+                multiple
+                name="rowers[]"
+                id="{{ id }}"
+                class="w-full"
+                data-seats="{{ amount_seats }}"
+                data-init="{{ init }}">
             {% for user in users %}
                 {% set_global sel = false %}
                 {% for rower in selected %}
@@ -177,104 +183,131 @@
     <div class="border-t bg-white dark:bg-primary-900 py-3 px-4 relative"
          data-filterable="true"
          data-filter="{{ log.boat.name }} {% for rower in log.rowers %}{{ rower.name }}{% endfor %}">
-        <details>
-            <summary style="list-style: none;">
-                {% if log.logtype and not hide_type %}
-                    <div class="absolute top-0 right-0 bg-primary-100 rounded-bl-md text-primary-950 text-xs w-32 px-2 py-1 text-center font-bold">
-                        {% if log.logtype == 1 %}
-                            Wanderfahrt
-                        {% else %}
-                            {% if log.logtype == 2 %}
-                                Regatta
-                            {% else %}
-                                {{ log.logtype }}
-                            {% endif %}
-                        {% endif %}
-                    </div>
-                {% endif %}
-                <div {% if log.logtype %}class="mt-4 sm:mt-0"{% endif %}>
-                    <strong class="text-black dark:text-white">{{ log.boat.name }}</strong>
-                    <small class="text-gray-600 dark:text-gray-100">({{ log.shipmaster_user.name -}}
-                        {% if log.shipmaster_only_steering %}
-                            - handgesteuert
-                        {%- endif -%}
-                    )</small>
-                    <small class="block text-gray-600 dark:text-gray-100">
-                        {% if state == "completed" and log.departure | date(format='%d.%m.%Y') == log.arrival | date(format='%d.%m.%Y') %}
-                            {{ log.departure | date(format='%d.%m.%Y') }}
-                            ({{ log.departure | date(format='%H:%M') }}
-                            -
-                            {{ log.arrival | date(format='%H:%M') }})
-                        {% else %}
-                            {{ log.departure | date(format='%d.%m.%Y (%H:%M)') }}
-                            {% if state == "completed" %}
-                                -
-                                {{ log.arrival | date(format='%d.%m.%Y (%H:%M)') }}
-                            {% endif %}
-                        {% endif %}
-                    </small>
-                    {% set amount_rowers = log.rowers | length %}
-                    {% set amount_guests = log.boat.amount_seats - amount_rowers %}
-                    {% if allowed_to_close and state == "on_water" %}
-                        {{ log::home(log=log) }}
+        {% if log.logtype and not hide_type %}
+            <div class="absolute top-0 right-0 bg-primary-100 rounded-bl-md text-primary-950 text-xs w-32 px-2 py-1 text-center font-bold">
+                {% if log.logtype == 1 %}
+                    Wanderfahrt
+                {% else %}
+                    {% if log.logtype == 2 %}
+                        Regatta
                     {% else %}
-                        <div class="text-black dark:text-white">
-                            {{ log.destination }}
-                            {% if state == "completed" %}
-                                <small class="text-gray-600 dark:text-gray-100">({{ log.distance_in_km }}
-                                km)</small>
-                            {% endif %}
-                            {% if log.comments %}<span class="text-sm italic">- "{{ log.comments }}"</span>{% endif %}
-                        </div>
-                        {% if amount_guests > 0 or log.rowers | length > 0 %}
-                            {% if not log.boat.amount_seats == 1 %}
-                                <div class="text-sm text-gray-600 dark:text-gray-100">
-                                    Ruderer:
-                                    {% for rower in log.rowers -%}
-                                        {{ rower.name }}
-                                        {%- if rower.id == log.steering_user.id and rower.id != log.shipmaster_user.id %}
-                                            (Steuerperson){%- endif -%}
-                                            {%- if not loop.last or amount_guests > 0 and not log.boat.external %},{% endif %}
-                                        {% endfor -%}
-                                        {% if amount_guests > 0 and not log.boat.external %}
-                                            Gäste
-                                            <small class="text-gray-600 dark:text-gray-100">(ohne Account)</small>:
-                                            {{ amount_guests }}
-                                        {% endif %}
-                                    </div>
-                                {% endif %}
-                            {% endif %}
-                        {% endif %}
-                    </div>
-                </summary>
-                {% if allowed_to_edit %}
-                    <form action="/log/update" method="post">
-                        <input type="hidden" name="id" value="{{ log.id }}" />
-                        <input type="hidden" name="boat_id" value="{{ log.boat_id }}" />
-                        <input type="hidden" name="shipmaster" value="{{ log.shipmaster }}" />
-                        <input type="hidden"
-                               name="steering_person"
-                               value="{{ log.steering_person }}" />
-                        Handgesteuert:
-                        <input type="checkbox"
-                               name="shipmaster_only_steering"
-                               {% if log.shipmaster_only_steering %}checked="checked"{% endif %} />
-                        <input type="datetime-local" name="departure" value="{{ log.departure }}" />
-                        <input type="datetime-local" name="arrival" value="{{ log.arrival }}" />
-                        <input type="hidden" name="destination" value="{{ log.destination }}" />
-                        <input type="hidden" name="distance_in_km" value="{{ log.distance_in_km }}" />
-                        <input type="hidden" name="comments" value="{{ log.comments }}" />
-                        <input type="hidden" name="logtype" value="{{ log.logtype }}" />
-                        <input type="submit" value="Updaten" />
-                    </form>
-                    <a href="/log/{{ log.id }}/delete"
-                       class="w-28 btn btn-alert"
-                       onclick="return confirm('Willst du diesen Logbucheintrag wirklich löschen?');">
-                        {% include "includes/delete-icon" %}
-                        Löschen
-                    </a>
+                        {{ log.logtype }}
+                    {% endif %}
                 {% endif %}
-            </details>
+            </div>
+        {% endif %}
+        <div {% if log.logtype %}class="mt-4 sm:mt-0"{% endif %}>
+            {% if allowed_to_edit %}
+                <a href="#"
+                   onclick="document.getElementById('change-{{ log.id }}').showModal()"
+                   class="link link-black font-bold">{{ log.boat.name }}</a>
+            {% else %}
+                <strong class="text-black dark:text-white">{{ log.boat.name }}</strong>
+            {% endif %}
+            <small class="text-gray-600 dark:text-gray-100">({{ log.shipmaster_user.name -}}
+                {% if log.shipmaster_only_steering %}
+                    - handgesteuert
+                {%- endif -%}
+            )</small>
+            <small class="block text-gray-600 dark:text-gray-100">
+                {% if state == "completed" and log.departure | date(format='%d.%m.%Y') == log.arrival | date(format='%d.%m.%Y') %}
+                    {{ log.departure | date(format='%d.%m.%Y') }}
+                    ({{ log.departure | date(format='%H:%M') }}
+                    -
+                    {{ log.arrival | date(format='%H:%M') }})
+                {% else %}
+                    {{ log.departure | date(format='%d.%m.%Y (%H:%M)') }}
+                    {% if state == "completed" %}
+                        -
+                        {{ log.arrival | date(format='%d.%m.%Y (%H:%M)') }}
+                    {% endif %}
+                {% endif %}
+            </small>
+            {% set amount_rowers = log.rowers | length %}
+            {% set amount_guests = log.boat.amount_seats - amount_rowers %}
+            {% if allowed_to_close and state == "on_water" %}
+                {{ log::home(log=log) }}
+            {% else %}
+                <div class="text-black dark:text-white">
+                    {{ log.destination }}
+                    {% if state == "completed" %}
+                        <small class="text-gray-600 dark:text-gray-100">({{ log.distance_in_km }}
+                        km)</small>
+                    {% endif %}
+                    {% if log.comments %}<span class="text-sm italic">- "{{ log.comments }}"</span>{% endif %}
+                </div>
+                {% if amount_guests > 0 or log.rowers | length > 0 %}
+                    {% if not log.boat.amount_seats == 1 %}
+                        <div class="text-sm text-gray-600 dark:text-gray-100">
+                            Ruderer:
+                            {% for rower in log.rowers -%}
+                                {{ rower.name }}
+                                {%- if rower.id == log.steering_user.id and rower.id != log.shipmaster_user.id %}
+                                    (Steuerperson){%- endif -%}
+                                    {%- if not loop.last or amount_guests > 0 and not log.boat.external %},{% endif %}
+                                {% endfor -%}
+                                {% if amount_guests > 0 and not log.boat.external %}
+                                    Gäste
+                                    <small class="text-gray-600 dark:text-gray-100">(ohne Account)</small>:
+                                    {{ amount_guests }}
+                                {% endif %}
+                            </div>
+                        {% endif %}
+                    {% endif %}
+                {% endif %}
+            </div>
+            {% if allowed_to_edit %}
+                <dialog id="change-{{ log.id }}"
+                        class="max-w-screen-sm w-full dark:bg-primary-900 dark:text-white rounded-md"
+                        onclick="document.getElementById('change-{{ log.id }}').close()">
+                    <div onclick="event.stopPropagation();" class="p-3">
+                        <button type="button"
+                                onclick="document.getElementById('change-{{ log.id }}').close()"
+                                title="Schließen"
+                                class="sidebar-close border-0 bg-primary-100 focus:bg-primary-50 text-black flex items-center justify-center transform rotate-45 absolute right-0 mr-3">
+                            <svg class="inline h-5 w-5"
+                                 width="16"
+                                 height="16"
+                                 fill="currentColor"
+                                 viewBox="0 0 16 16">
+                                <path d="M8 4a.5.5 0 0 1 .5.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3A.5.5 0 0 1 8 4z"></path>
+                            </svg>
+                        </button>
+                        <div class="mt-8">
+                            <h2 class="h3">Eintrag '{{ log.boat.name }}' ändern</h2>
+                            <p class="text-center mb-3">{{ log.id }}</p>
+                            <form action="/log/update" method="post" class="grid gap-3">
+                                <input type="hidden" name="id" value="{{ log.id }}" />
+                                <input type="hidden" name="boat_id" value="{{ log.boat_id }}" />
+                                <input type="hidden" name="shipmaster" value="{{ log.shipmaster }}" />
+                                <input type="hidden"
+                                       name="steering_person"
+                                       value="{{ log.steering_person }}" />
+                                {{ macros::checkbox(label='Handgesteuert', name='shipmaster_only_steering', id=log.shipmaster_only_steering,checked=log.shipmaster_only_steering) }}
+                                <input type="datetime-local"
+                                       class="input rounded-md"
+                                       name="departure"
+                                       value="{{ log.departure }}" />
+                                <input type="datetime-local"
+                                       class="input rounded-md"
+                                       name="arrival"
+                                       value="{{ log.arrival }}" />
+                                <input type="hidden" name="destination" value="{{ log.destination }}" />
+                                <input type="hidden" name="distance_in_km" value="{{ log.distance_in_km }}" />
+                                <input type="hidden" name="comments" value="{{ log.comments }}" />
+                                <input type="hidden" name="logtype" value="{{ log.logtype }}" />
+                                <input type="submit" class="btn btn-primary" value="Updaten" />
+                            </form>
+                            <a href="/log/{{ log.id }}/delete"
+                               class="w-28 btn btn-alert mt-3"
+                               onclick="return confirm('Willst du diesen Logbucheintrag wirklich löschen?');">
+                                {% include "includes/delete-icon" %}
+                                Löschen
+                            </a>
+                        </div>
+                    </div>
+                </dialog>
+            {% endif %}
         </div>
     {% endmacro show_old %}
     {% macro home(log) %}

templates/includes/macros.html.tera

@@ -156,7 +156,7 @@ function setChoiceByLabel(choicesInstance, label) {
     </header>
     <div class="h-8"></div>
 {% endmacro header %}
-{% macro input(label, name, type, required=false, class='rounded-md', value='', min='', hide_label=false, id='', autofocus=false, wrapper_class='', pattern='', readonly=false, accept='') %}
+{% macro input(label, name, type, required=false, class='rounded-md', value='', min='', hide_label=false, id='', autofocus=false, wrapper_class='', pattern='', readonly=false, accept='', placeholder='') %}
     <div class="{{ wrapper_class }}">
         <label for="{{ name }}"
                class="{% if hide_label %} sr-only {% else %} text-sm text-gray-600 dark:text-white {% endif %}">
@@ -169,14 +169,98 @@ function setChoiceByLabel(choicesInstance, label) {
                {% if required %}required{% endif %}
                value="{{ value }}"
                class="input {{ class }}"
-               placeholder="{% if hide_label %}{{ label }}{% endif %}"
+               placeholder="{% if hide_label %}{{ label }}{% endif %}{% if placeholder %}{{ placeholder }}{% endif %}"
                {% if min is defined %}min="{{ min }}"{% endif %}
                {% if autofocus %}autofocus{% endif %}
                {% if accept %}accept="{{ accept }}"{% endif %}
                {% if pattern %}pattern="{{ pattern }}"{% endif %}
-               {% if readonly %}readonly{% endif %}>
+               {% if readonly %}readonly{% endif %} />
     </div>
 {% endmacro input %}
+{% macro inputgroup(label, name, type, required=false, class='', value='', min='', hide_label=false, id='', autofocus=false, wrapper_class='', pattern='', readonly=false, accept='') %}
+    <div class="{{ wrapper_class }}">
+        <label for="{{ name }}"
+               class="{% if hide_label %} sr-only {% else %} text-sm text-gray-600 dark:text-white {% endif %}">
+            {{ label }}
+        </label>
+        <div class="input-group">
+            <input {% if type=='datetime-local' %}onclick='if (!this.value) setCurrentdate(this)'{% endif %}
+                   {% if id %} id="{{ id }}" {% else %} id="{{ name }}" {% endif %}
+                   name="{{ name }}"
+                   type="{{ type }}"
+                   {% if required %}required{% endif %}
+                   value="{{ value }}"
+                   class="input {% if readonly %}rounded-md{% else %}rounded-l-md{% endif %} {{ class }}"
+                   placeholder="{% if hide_label %}{{ label }}{% endif %}"
+                   {% if min is defined %}min="{{ min }}"{% endif %}
+                   {% if autofocus %}autofocus{% endif %}
+                   {% if accept %}accept="{{ accept }}"{% endif %}
+                   {% if pattern %}pattern="{{ pattern }}"{% endif %}
+                   readonly />
+            {% if allowed_to_edit %}
+                <button type="button" class="btn btn-dark rounded-l-none-important edit-js">
+                    {% include "includes/pencil" %}
+                    <span class="sr-only">Bearbeiten</span>
+                </button>
+                <input value="x"
+                       type="reset"
+                       class="edit-js btn btn-alert btn-hidden rounded-none-important" />
+                <input value="💾"
+                       type="submit"
+                       class="btn btn-primary btn-hidden rounded-l-none-important" />
+            {% endif %}
+        </div>
+    </div>
+{% endmacro inputgroup %}
+{% macro selectgroup(label, data, name='trip_type', default='', id='', selected_id='', display='', extras='', class='', wrapper_class='', required=false, show_seats=false, new_last_entry='', nonSelectableDefault=false, only_ergo=false, readonly=false) %}
+    <div class="{{ wrapper_class }}">
+        <label for="{{ name }}" class="text-sm text-gray-600 dark:text-gray-100">{{ label }}</label>
+        {% if display == '' %}
+            {% set display = ["name"] %}
+        {% endif %}
+        <div class="input-group">
+            <select name="{{ name }}"
+                    {% if id %} id="{{ id }}" {% else %} id="{{ name }}" {% endif %}
+                    class="input {% if readonly %}rounded-md{% else %}rounded-l-md{% endif %} {{ class }}"
+                    {% if required %}required="required"{% endif %}
+                    disabled>
+                {% if default %}<option selected value>{{ default }}</option>{% endif %}
+                {% if nonSelectableDefault %}<option disabled selected value>{{ nonSelectableDefault }}</option>{% endif %}
+                {% for d in data %}
+                    <option value="{{ d.id }}"
+                            {% if only_ergo and d.id!=4 %}disabled{% endif %}
+                            {% 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"] }}, "convert_handoperated_possible": {{ d["convert_handoperated_possible"] }}, "default_handoperated": {{ d["default_shipmaster_only_steering"] }}}' {% endif %}>
+                        {% for displa in display -%}
+                            {%- if d[displa] -%}
+                                {{- d[displa] -}}
+                            {%- else -%}
+                                {{- displa -}}
+                            {%- endif -%}
+                        {%- endfor %}
+                    </option>
+                {% endfor %}
+                {% if new_last_entry %}<option value="-1">{{ new_last_entry }}</option>{% endif %}
+            </select>
+            {% if allowed_to_edit %}
+                <button type="button" class="btn btn-dark rounded-l-none-important edit-js">
+                    {% include "includes/pencil" %}
+                    <span class="sr-only">Bearbeiten</span>
+                </button>
+                <input value="x"
+                       type="reset"
+                       class="edit-js btn btn-alert btn-hidden rounded-none-important" />
+                <input value="💾"
+                       type="submit"
+                       class="btn btn-primary btn-hidden rounded-l-none-important" />
+            {% endif %}
+        </div>
+    </div>
+{% endmacro selectgroup %}
 {% macro checkbox(label, name, id='', checked=false, class='', disabled=false, readonly=false) %}
     <label for="{{ name }}{{ id }}"
            class="flex items-center cursor-pointer text-black dark:text-white hover:text-gray-900 dark:hover:text-gray-100 {{ class }}">
@@ -203,7 +287,14 @@ function setChoiceByLabel(choicesInstance, label) {
             {% if default %}<option selected value>{{ default }}</option>{% endif %}
             {% if nonSelectableDefault %}<option disabled selected value>{{ nonSelectableDefault }}</option>{% endif %}
             {% for d in data %}
-                <option value="{{ d.id }}" {% if only_ergo and d.id!=4 %} disabled {% endif %}{% 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"] }}, "convert_handoperated_possible": {{ d["convert_handoperated_possible"] }}, "default_handoperated": {{ d["default_shipmaster_only_steering"] }}}' {% endif %}>
+                <option value="{{ d.id }}"
+                        {% if only_ergo and d.id!=4 %}disabled{% endif %}
+                        {% 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"] }}, "convert_handoperated_possible": {{ d["convert_handoperated_possible"] }}, "default_handoperated": {{ d["default_shipmaster_only_steering"] }}}' {% endif %}>
                     {% for displa in display -%}
                         {%- if d[displa] -%}
                             {{- d[displa] -}}

templates/index.html.tera

@@ -32,7 +32,9 @@
                     <h2 class="h2">Nachrichten</h2>
                     {% if loggedin_user.amount_unread_notifications > 10 %}
                         <div class="text-primary-950 dark:text-white bg-gray-200 dark:bg-primary-950 bg-opacity-80 text-center pb-3 px-3">
-                            Du hast viele ungelesene Benachrichtigungen. Um deine Oberfläche übersichtlich zu halten und wichtige Updates nicht zu verpassen, nimm dir bitte in Zukunft einen kurzen Moment Zeit sie zu überprüfen und als gelesen zu markieren (&#10003;).<br /><a href="/notification/read/all" class="underline">Du kannst hier ausnahmsweise alle als gelesen markieren.</a>
+                            Du hast viele ungelesene Benachrichtigungen. Um deine Oberfläche übersichtlich zu halten und wichtige Updates nicht zu verpassen, nimm dir bitte in Zukunft einen kurzen Moment Zeit sie zu überprüfen und als gelesen zu markieren (&#10003;).
+                            <br />
+                            <a href="/notification/read/all" class="underline">Du kannst hier ausnahmsweise alle als gelesen markieren.</a>
                         </div>
                     {% endif %}
                     <div class="divide-y">
@@ -234,93 +236,88 @@
                      role="alert">
                     <h2 class="h2">Vereinsmitglied</h2>
                     <ul class="list-none ms-2 divide-y divide-gray-200 dark:divide-primary-600">
-            {% if "Unterstützend" not in loggedin_user.roles and "Förderndes Mitglied" not in loggedin_user.roles %}
-                        <li class="py-1">
-                            <a href="/planned" class="block w-100 py-2 hover:text-primary-600">Geplante Ausfahrten</a>
-                        </li>
-                        <li class="py-1">
-                            <a href="/log" class="block w-100 py-2 hover:text-primary-600">Ausfahrt eintragen</a>
-                        </li>
-                        <li class="py-1">
-                            <a href="/log/show" class="block w-100 py-2 hover:text-primary-600">Logbuch</a>
-                        </li>
-                        <li class="py-1">
-                            <a href="/stat" class="block w-100 py-2 hover:text-primary-600">Statistik</a>
-                        </li>
-                        <li class="py-1">
-                            <a href="/stat/boats" class="block w-100 py-2 hover:text-primary-600">Bootsauswertung</a>
-                        </li>
-                        <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>
-                        <li class="py-1">
-                            <a href="/trailerreservation"
-                               class="block w-100 py-2 hover:text-primary-600">Hängerreservierung</a>
-                        </li>
-                        <li class="py-1">
-                            <a href="/steering" class="block w-100 py-2 hover:text-primary-600">Steuerleute & Co</a>
-                        </li>
-                        <div class="py-3">
-                            <p>
-                                <details>
-                                    <summary>
-                                        Kalender
-                                    </summary>
-                                    <p class="mt-3">
-                                        Du möchtest immer up-to-date mit den Events und Ausfahrten bleiben? Wir bieten 3 verschiedene Arten von Kalender an:
-                                    </p>
-                                    <ol class="list-decimal ml-5 my-3">
-                                        <li>
-                                            <strong>Alle Events und Ausfahrten</strong>, zu denen du dich angemeldet hast: <a class="underline break-all"
+                        {% if "Unterstützend" not in loggedin_user.roles and "Förderndes Mitglied" not in loggedin_user.roles %}
+                            <li class="py-1">
+                                <a href="/planned" class="block w-100 py-2 hover:text-primary-600">Geplante Ausfahrten</a>
+                            </li>
+                            <li class="py-1">
+                                <a href="/log" class="block w-100 py-2 hover:text-primary-600">Ausfahrt eintragen</a>
+                            </li>
+                            <li class="py-1">
+                                <a href="/log/show" class="block w-100 py-2 hover:text-primary-600">Logbuch</a>
+                            </li>
+                            <li class="py-1">
+                                <a href="/stat" class="block w-100 py-2 hover:text-primary-600">Statistik</a>
+                            </li>
+                            <li class="py-1">
+                                <a href="/stat/boats" class="block w-100 py-2 hover:text-primary-600">Bootsauswertung</a>
+                            </li>
+                            <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>
+                            <li class="py-1">
+                                <a href="/trailerreservation"
+                                   class="block w-100 py-2 hover:text-primary-600">Hängerreservierung</a>
+                            </li>
+                            <li class="py-1">
+                                <a href="/steering" class="block w-100 py-2 hover:text-primary-600">Steuerleute & Co</a>
+                            </li>
+                            <div class="py-3">
+                                <p>
+                                    <details>
+                                        <summary>Kalender</summary>
+                                        <p class="mt-3">
+                                            Du möchtest immer up-to-date mit den Events und Ausfahrten bleiben? Wir bieten 3 verschiedene Arten von Kalender an:
+                                        </p>
+                                        <ol class="list-decimal ml-5 my-3">
+                                            <li>
+                                                <strong>Alle Events und Ausfahrten</strong>, zu denen du dich angemeldet hast: <a class="underline break-all"
     href="https://app.rudernlinz.at/cal/personal/{{ loggedin_user.id }}/{{ loggedin_user.user_token }}">https://app.rudernlinz.at/cal/personal/{{ loggedin_user.id }}/{{ loggedin_user.user_token }}</a>
-                                            <br />
-                                            <small>Dieser Link enthält einen zufällig generierten Teil, damit nur du (und jene, denen du diesen Link weitergibst) Zugang zu diesen Daten hast.</small>
-                                        </li>
-                                        <li>
-                                            <strong>Allgemeiner Kalender</strong>, zB save-the-dates (Wanderfahrten, ...): <a href="https://rudernlinz.at/cal" class="break-all	underline">https://rudernlinz.at/cal</a>
-                                        </li>
-                                        <li>
-                                            <strong>Alle Events</strong>: <a class="break-all	underline" href="https://app.rudernlinz.at/cal">https://app.rudernlinz.at/cal</a>
-                                            <br />
-                                            <small>Beachte, dass dieser Kalender keine Ausfahrten enthält, die von einzelnen Steuerpersonen augeschrieben werden. Dieser Kalender wird zB auf <a href="https://rudernlinz.at/termine" class="underline">https://rudernlinz.at/termine</a> verwendet und wir möchten keine persönlichen Daten (Namen etc.) leaken.</small>
-                                        </li>
-                                    </ol>
-                                    Du kannst die Kalender einfach in deinen Kalender als "externen Kalender" synchronisieren. Die genauen Schritte hängen von deiner verwendeten Software ab.
-                                </details>
-                            </p>
-                        </div>
+                                                <br />
+                                                <small>Dieser Link enthält einen zufällig generierten Teil, damit nur du (und jene, denen du diesen Link weitergibst) Zugang zu diesen Daten hast.</small>
+                                            </li>
+                                            <li>
+                                                <strong>Allgemeiner Kalender</strong>, zB save-the-dates (Wanderfahrten, ...): <a href="https://rudernlinz.at/cal" class="break-all	underline">https://rudernlinz.at/cal</a>
+                                            </li>
+                                            <li>
+                                                <strong>Alle Events</strong>: <a class="break-all	underline" href="https://app.rudernlinz.at/cal">https://app.rudernlinz.at/cal</a>
+                                                <br />
+                                                <small>Beachte, dass dieser Kalender keine Ausfahrten enthält, die von einzelnen Steuerpersonen augeschrieben werden. Dieser Kalender wird zB auf <a href="https://rudernlinz.at/termine" class="underline">https://rudernlinz.at/termine</a> verwendet und wir möchten keine persönlichen Daten (Namen etc.) leaken.</small>
+                                            </li>
+                                        </ol>
+                                        Du kannst die Kalender einfach in deinen Kalender als "externen Kalender" synchronisieren. Die genauen Schritte hängen von deiner verwendeten Software ab.
+                                    </details>
+                                </p>
+                            </div>
+                            <div class="py-3">
+                                <p>
+                                    <details>
+                                        <summary>Signal-Gruppenchat Donau Linz</summary>
+                                        <p class="mt-3">
+                                            Mit diesem Link kannst du unserer Signal Gruppe beitreten: <a class="break-all underline"
+    href="https://signal.group/#CjQKICFrq6zSsRHxrucS3jEcQn6lknEXacAykwwLV3vNLKxPEhA17jxz7cpjfu3JZokLq1TH">https://signal.group/#CjQKICFrq6zSsRHxrucS3jEcQn6lknEXacAykwwLV3vNLKxPEhA17jxz7cpjfu3JZokLq1TH</a>
+                                        </p>
+                                    </details>
+                                </p>
+                            </div>
+                        {% endif %}
                         <div class="py-3">
                             <p>
                                 <details>
-                                    <summary>
-                                        Signal-Gruppenchat Donau Linz
-                                    </summary>
+                                    <summary>WLAN-Passwort</summary>
                                     <p class="mt-3">
-				    Mit diesem Link kannst du unserer Signal Gruppe beitreten: <a class="break-all underline" href="https://signal.group/#CjQKICFrq6zSsRHxrucS3jEcQn6lknEXacAykwwLV3vNLKxPEhA17jxz7cpjfu3JZokLq1TH">https://signal.group/#CjQKICFrq6zSsRHxrucS3jEcQn6lknEXacAykwwLV3vNLKxPEhA17jxz7cpjfu3JZokLq1TH</a>
-                                    </p>
-                                </details>
-                            </p>
-                        </div>
-			{% endif %}
-                        <div class="py-3">
-                            <p>
-                                <details>
-                                    <summary>
-                                        WLAN-Passwort
-                                    </summary>
-                                    <p class="mt-3">
-					Das Passwort für unser "ASKÖ Ruderverein Donau Linz" WLAN ist <q>donau1921</q> (ohne Anführungszeichen). Bitte an keine vereinsfremden Personen weitergeben.
+                                        Das Passwort für unser "ASKÖ Ruderverein Donau Linz" WLAN ist <q>donau1921</q> (ohne Anführungszeichen). Bitte an keine vereinsfremden Personen weitergeben.
                                     </p>
                                 </details>
                             </p>
                         </div>
                     </ul>
                 </div>
-		{% endif %}
+            {% endif %}
             {% if "cox" in loggedin_user.roles or "Bootsführer" in loggedin_user.roles %}
                 <div class="bg-white dark:bg-primary-900 text-black dark:text-white rounded-md block shadow mt-5"
                      role="alert">
@@ -329,11 +326,10 @@
                         <div class="py-3">
                             <p>
                                 <details>
-                                    <summary>
-                                        Signal-Gruppenchat Steuerpersonen Donau Linz
-                                    </summary>
+                                    <summary>Signal-Gruppenchat Steuerpersonen Donau Linz</summary>
                                     <p class="mt-3">
-				    Mit diesem Link kannst du unserer Signal Gruppe beitreten: <a class="break-all underline" href="https://signal.group/#CjQKIHJInNb3zSVW7ipLo7_ygIqVxhxUaaNYx4sy2jdklLsIEhBHJNM2KZM1UnBdQxWy_Gdp">https://signal.group/#CjQKIHJInNb3zSVW7ipLo7_ygIqVxhxUaaNYx4sy2jdklLsIEhBHJNM2KZM1UnBdQxWy_Gdp</a>
+                                        Mit diesem Link kannst du unserer Signal Gruppe beitreten: <a class="break-all underline"
+    href="https://signal.group/#CjQKIHJInNb3zSVW7ipLo7_ygIqVxhxUaaNYx4sy2jdklLsIEhBHJNM2KZM1UnBdQxWy_Gdp">https://signal.group/#CjQKIHJInNb3zSVW7ipLo7_ygIqVxhxUaaNYx4sy2jdklLsIEhBHJNM2KZM1UnBdQxWy_Gdp</a>
                                     </p>
                                 </details>
                             </p>
@@ -435,6 +431,9 @@
                         <li class="py-1">
                             <a href="/admin/rss" class="block w-100 py-2 hover:text-primary-600">Logs</a>
                         </li>
+                        <li class="py-1">
+                            <a href="/admin/role" class="block w-100 py-2 hover:text-primary-600">Rollen</a>
+                        </li>
                         <li class="py-1">
                             <a href="/admin/list" class="block w-100 py-2 hover:text-primary-600">Fingerabdruck-Liste überprüfen</a>
                         </li>

templates/log.completed.html.tera

@@ -26,7 +26,7 @@
             {% for log in logs %}
                 {% set_global allowed_to_edit = false %}
                 {% if loggedin_user %}
-                    {% if "Vorstand" in loggedin_user.roles %}
+                    {% if "Vorstand" in loggedin_user.roles or "admin" in loggedin_user.roles %}
                         {% set_global allowed_to_edit = true %}
                     {% endif %}
                 {% endif %}

templates/planned.html.tera

@@ -67,7 +67,7 @@
                     {% endif %}
                 {% endfor %}
             {% endif %}
-            <div id="{{ day.day| date(format="%Y-%m-%d") }}"
+            <div id="{{ day.day| date(format='%Y-%m-%d') }}"
                  class="bg-white dark:bg-primary-900 rounded-md flex justify-between flex-col shadow reset-js"
                  style="min-height: 10rem"
                  data-trips="{{ amount_trips }}"
@@ -93,20 +93,22 @@
                         <div class="grid grid-cols-1 gap-3 mb-3">
                             {# --- START Boatreservations--- #}
                             {% for _, reservations_for_event in day.boat_reservations %}
-                            {% set reservation = reservations_for_event[0] %}
+                                {% set reservation = reservations_for_event[0] %}
                                 <div class="pt-2 px-3 border-gray-200">
                                     <div class="flex justify-between items-center">
                                         <div class="mr-1">
                                             <span class="text-primary-900 dark:text-white">
-                                                ⏳ {{ reservation.time_desc }} <small class="text-gray-600 dark:text-gray-100">({{ reservation.user_applicant.name }})</small><br/>
+                                                ⏳ {{ reservation.time_desc }} <small class="text-gray-600 dark:text-gray-100">({{ reservation.user_applicant.name }})</small>
+                                                <br />
                                                 <strong>
-                                                {% for reservation in reservations_for_event -%}
-                                                    {{ reservation.boat.name }}
-                                                    {%- if not loop.last %} + {% endif -%}
-                                                {% endfor -%}
+                                                    {% for reservation in reservations_for_event -%}
+                                                        {{ reservation.boat.name }}
+                                                        {%- if not loop.last %} +
+                                                        {% endif -%}
+                                                    {% endfor -%}
                                                 </strong>
                                             </span>
-                                            <small class="text-gray-600 dark:text-gray-100">(Reservierung - {{ reservation.usage}})</small>
+                                            <small class="text-gray-600 dark:text-gray-100">(Reservierung - {{ reservation.usage }})</small>
                                         </div>
                                     </div>
                                 </div>
@@ -241,9 +243,9 @@
                                                         <input type="hidden" name="id" value="{{ event.id }}" />
                                                         {{ macros::input(label='Titel', name='name', type='input', value=event.name) }}
                                                         {% if event.cancelled %}
-                                                          <input type="hidden" name="max_people" value="-1" />
+                                                            <input type="hidden" name="max_people" value="-1" />
                                                         {% else %}
-                                                          {{ macros::input(label='Anzahl Ruderer', name='max_people', type='number', required=true, value=event.max_people, min='0') }}
+                                                            {{ macros::input(label='Anzahl Ruderer', name='max_people', type='number', required=true, value=event.max_people, min='0') }}
                                                         {% endif %}
                                                         {{ macros::input(label='Anzahl Steuerleute', name='planned_amount_cox', type='number', value=event.planned_amount_cox, required=true, min='0') }}
                                                         {{ macros::checkbox(label='Immer anzeigen', name='always_show', id=event.id,checked=event.always_show) }}
@@ -378,11 +380,11 @@
                                                     {{ macros::input(label='Anzahl Ruderer', name='max_people', type='number', required=true, value=trip.max_people, min=trip.rower | length) }}
                                                     {{ macros::input(label='Anmerkungen', name='notes', type='input', value=trip.notes) }}
                                                     {{ macros::checkbox(label='Gesperrt', name='is_locked', id=trip.id,checked=trip.is_locked) }}
-						    {% if loggedin_user.allowed_to_steer %}
-                                                    {{ macros::select(label='Typ', name='trip_type', data=trip_types, default='Reguläre Ausfahrt', selected_id=trip.trip_type_id, only_ergo=not loggedin_user.allowed_to_steer) }}
-						    {% else %}
-                                                    {{ macros::select(label='Typ', name='trip_type', data=trip_types, selected_id=trip.trip_type_id, only_ergo=not loggedin_user.allowed_to_steer, only_ergos=true) }}
-						    {% endif %}
+                                                    {% if loggedin_user.allowed_to_steer %}
+                                                        {{ macros::select(label='Typ', name='trip_type', data=trip_types, default='Reguläre Ausfahrt', selected_id=trip.trip_type_id, only_ergo=not loggedin_user.allowed_to_steer) }}
+                                                    {% else %}
+                                                        {{ macros::select(label='Typ', name='trip_type', data=trip_types, selected_id=trip.trip_type_id, only_ergo=not loggedin_user.allowed_to_steer, only_ergos=true) }}
+                                                    {% endif %}
                                                     <input value="Speichern" class="btn btn-primary" type="submit" />
                                                 </form>
                                             </div>
@@ -472,9 +474,11 @@
                         {% endif %}
                         ">
                         <span class="absolute inset-y-0 left-0 flex items-center pl-3">{% include "includes/plus-icon" %}</span>
-			{% if not loggedin_user.allowed_to_steer %}Ergo-Session
-			{%- else -%}
-                        Ausfahrt{%endif%}
+                        {% if not loggedin_user.allowed_to_steer %}
+                            Ergo-Session
+                        {%- else -%}
+                            Ausfahrt
+                        {% endif %}
                     </a>
                 {% endif %}
             </div>
@@ -484,7 +488,7 @@
 {% endfor %}
 </div>
 </div>
-{% if loggedin_user.allowed_to_steer or "ergo" in loggedin_user.roles  %}
+{% if loggedin_user.allowed_to_steer or "ergo" in loggedin_user.roles %}
     {% include "forms/trip" %}
 {% endif %}
 {% if "manage_events" in loggedin_user.roles %}