Merge pull request 'reanme-to-event' (#554) from reanme-to-event into main

Reviewed-on: #554

src/model/event.rs

@@ -3,7 +3,7 @@ use std::io::Write;
 use chrono::NaiveDate;
 use ics::{
     properties::{DtStart, Summary},
-    Event, ICalendar,
+    ICalendar,
 };
 use serde::Serialize;
 use sqlx::{FromRow, Row, SqlitePool};
@@ -11,10 +11,10 @@ use sqlx::{FromRow, Row, SqlitePool};
 use super::{notification::Notification, tripdetails::TripDetails, triptype::TripType, user::User};
 
 #[derive(Serialize, Clone, FromRow, Debug, PartialEq)]
-pub struct PlannedEvent {
+pub struct Event {
     pub id: i64,
     pub name: String,
-    planned_amount_cox: i64,
+    pub(crate) planned_amount_cox: i64,
     trip_details_id: i64,
     pub planned_starting_time: String,
     pub(crate) max_people: i64,
@@ -22,14 +22,14 @@ pub struct PlannedEvent {
     pub notes: Option<String>,
     pub allow_guests: bool,
     trip_type_id: Option<i64>,
-    always_show: bool,
+    pub(crate) always_show: bool,
-    is_locked: bool,
+    pub(crate) is_locked: bool,
 }
 
 #[derive(Serialize, Debug)]
-pub struct PlannedEventWithUserAndTriptype {
+pub struct EventWithUserAndTriptype {
     #[serde(flatten)]
-    pub planned_event: PlannedEvent,
+    pub event: Event,
     trip_type: Option<TripType>,
     cox_needed: bool,
     cox: Vec<Registration>,
@@ -73,7 +73,7 @@ FROM user_trip WHERE trip_details_id = {}
         .collect()
     }
 
-    pub async fn all_cox(db: &SqlitePool, trip_details_id: i64) -> Vec<Registration> {
+    pub async fn all_cox(db: &SqlitePool, event_id: i64) -> Vec<Registration> {
         //TODO: switch to join
         sqlx::query!(
             "
@@ -82,7 +82,7 @@ SELECT
     (SELECT created_at FROM user WHERE cox_id = id) as registered_at
 FROM trip WHERE planned_event_id = ?
         ",
-            trip_details_id
+            event_id
         )
         .fetch_all(db)
         .await
@@ -94,7 +94,7 @@ FROM trip WHERE planned_event_id = ?
             is_guest: false,
             is_real_guest: false,
         })
-        .collect() //Okay, as PlannedEvent can only be created with proper DB backing
+        .collect() //Okay, as Event can only be created with proper DB backing
     }
 }
 
@@ -107,7 +107,7 @@ pub struct EventUpdate<'a> {
     pub is_locked: bool,
 }
 
-impl PlannedEvent {
+impl Event {
     pub async fn find_by_id(db: &SqlitePool, id: i64) -> Option<Self> {
         sqlx::query_as!(
             Self,
@@ -128,19 +128,16 @@ WHERE planned_event.id like ?
     pub async fn get_pinned_for_day(
         db: &SqlitePool,
         day: NaiveDate,
-    ) -> Vec<PlannedEventWithUserAndTriptype> {
+    ) -> Vec<EventWithUserAndTriptype> {
         let mut events = Self::get_for_day(db, day).await;
-        events.retain(|e| e.planned_event.always_show);
+        events.retain(|e| e.event.always_show);
         events
     }
 
-    pub async fn get_for_day(
+    pub async fn get_for_day(db: &SqlitePool, day: NaiveDate) -> Vec<EventWithUserAndTriptype> {
-        db: &SqlitePool,
-        day: NaiveDate,
-    ) -> Vec<PlannedEventWithUserAndTriptype> {
         let day = format!("{day}");
         let events = sqlx::query_as!(
-            PlannedEvent,
+            Event,
             "SELECT planned_event.id, planned_event.name, planned_amount_cox, trip_details_id, planned_starting_time, always_show, max_people, day, notes, allow_guests, trip_type_id, is_locked
 FROM planned_event
 INNER JOIN trip_details ON planned_event.trip_details_id = trip_details.id
@@ -158,20 +155,20 @@ WHERE day=?",
             if let Some(trip_type_id) = event.trip_type_id {
                 trip_type = TripType::find_by_id(db, trip_type_id).await;
             }
-            ret.push(PlannedEventWithUserAndTriptype {
+            ret.push(EventWithUserAndTriptype {
                 cox_needed: event.planned_amount_cox > cox.len() as i64,
                 cox,
                 rower: Registration::all_rower(db, event.trip_details_id).await,
-                planned_event: event,
+                event,
                 trip_type,
             });
         }
         ret
     }
 
-    pub async fn all(db: &SqlitePool) -> Vec<PlannedEvent> {
+    pub async fn all(db: &SqlitePool) -> Vec<Event> {
         sqlx::query_as!(
-            PlannedEvent,
+            Event,
             "SELECT planned_event.id, planned_event.name, planned_amount_cox, trip_details_id, planned_starting_time, always_show, max_people, day, notes, allow_guests, trip_type_id, is_locked
 FROM planned_event
 INNER JOIN trip_details ON planned_event.trip_details_id = trip_details.id",
@@ -198,11 +195,27 @@ INNER JOIN trip_details ON planned_event.trip_details_id = trip_details.id",
         is_rower.amount > 0
     }
 
+    pub async fn find_by_trip_details(db: &SqlitePool, tripdetails_id: i64) -> Option<Self> {
+        sqlx::query_as!(
+            Self,
+            "
+SELECT planned_event.id, planned_event.name, planned_amount_cox, trip_details_id, planned_starting_time, always_show, max_people, day, notes, allow_guests, trip_type_id, is_locked
+FROM planned_event 
+INNER JOIN trip_details ON planned_event.trip_details_id = trip_details.id
+WHERE trip_details.id=?
+        ",
+            tripdetails_id
+        )
+        .fetch_one(db)
+        .await
+        .ok()
+    }
+
     pub async fn create(
         db: &SqlitePool,
         name: &str,
         planned_amount_cox: i32,
-        trip_details: TripDetails,
+        trip_details: &TripDetails,
     ) {
         sqlx::query!(
             "INSERT INTO planned_event(name, planned_amount_cox, trip_details_id) VALUES(?, ?, ?)",
@@ -260,7 +273,7 @@ INNER JOIN trip_details ON planned_event.trip_details_id = trip_details.id",
                         ),
                         "Absage Ausfahrt",
                         None,
-                        Some(&format!("remove_trip_by_planned_event:{}", self.id)),
+                        Some(&format!("remove_trip_by_event:{}", self.id)),
                     )
                     .await;
                 }
@@ -298,11 +311,7 @@ INNER JOIN trip_details ON planned_event.trip_details_id = trip_details.id",
                 &format!("remove_user_trip_with_trip_details_id:{}", tripdetails.id),
             )
             .await;
-            Notification::delete_by_action(
+            Notification::delete_by_action(db, &format!("remove_trip_by_event:{}", self.id)).await;
-                db,
-                &format!("remove_trip_by_planned_event:{}", self.id),
-            )
-            .await;
         }
     }
 
@@ -328,7 +337,7 @@ INNER JOIN trip_details ON planned_event.trip_details_id = trip_details.id",
         sqlx::query!("DELETE FROM planned_event WHERE id = ?", self.id)
             .execute(db)
             .await
-            .unwrap(); //Okay, as PlannedEvent can only be created with proper DB backing
+            .unwrap(); //Okay, as Event can only be created with proper DB backing
 
         Ok(())
     }
@@ -336,9 +345,10 @@ INNER JOIN trip_details ON planned_event.trip_details_id = trip_details.id",
     pub async fn get_ics_feed(db: &SqlitePool) -> String {
         let mut calendar = ICalendar::new("2.0", "ics-rs");
 
-        let events = PlannedEvent::all(db).await;
+        let events = Event::all(db).await;
         for event in events {
-            let mut vevent = Event::new(format!("{}@rudernlinz.at", event.id), "19900101T180000");
+            let mut vevent =
+                ics::Event::new(format!("{}@rudernlinz.at", event.id), "19900101T180000");
             vevent.push(DtStart::new(format!(
                 "{}T{}00",
                 event.day.replace('-', ""),
@@ -363,7 +373,7 @@ INNER JOIN trip_details ON planned_event.trip_details_id = trip_details.id",
 mod test {
     use crate::{model::tripdetails::TripDetails, testdb};
 
-    use super::PlannedEvent;
+    use super::Event;
     use chrono::NaiveDate;
     use sqlx::SqlitePool;
 
@@ -371,8 +381,7 @@ mod test {
     fn test_get_day() {
         let pool = testdb!();
 
-        let res =
+        let res = Event::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
-            PlannedEvent::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
         assert_eq!(res.len(), 1);
     }
 
@@ -382,22 +391,20 @@ mod test {
 
         let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
 
-        PlannedEvent::create(&pool, "new-event".into(), 2, trip_details).await;
+        Event::create(&pool, "new-event".into(), 2, &trip_details).await;
 
-        let res =
+        let res = Event::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
-            PlannedEvent::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
         assert_eq!(res.len(), 2);
     }
 
     #[sqlx::test]
     fn test_delete() {
         let pool = testdb!();
-        let planned_event = PlannedEvent::find_by_id(&pool, 1).await.unwrap();
+        let planned_event = Event::find_by_id(&pool, 1).await.unwrap();
 
         planned_event.delete(&pool).await.unwrap();
 
-        let res =
+        let res = Event::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
-            PlannedEvent::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
         assert_eq!(res.len(), 0);
     }
 
@@ -405,7 +412,7 @@ mod test {
     fn test_ics() {
         let pool = testdb!();
 
-        let actual = PlannedEvent::get_ics_feed(&pool).await;
+        let actual = Event::get_ics_feed(&pool).await;
         assert_eq!("BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:ics-rs\r\nBEGIN:VEVENT\r\nUID:1@rudernlinz.at\r\nDTSTAMP:19900101T180000\r\nDTSTART:19700101T100000\r\nSUMMARY:test-planned-event\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n", actual);
     }
 }

src/model/mod.rs

@@ -3,7 +3,7 @@ use serde::Serialize;
 use sqlx::SqlitePool;
 
 use self::{
-    planned_event::{PlannedEvent, PlannedEventWithUserAndTriptype},
+    event::{Event, EventWithUserAndTriptype},
     trip::{Trip, TripWithUserAndType},
     waterlevel::Waterlevel,
     weather::Weather,
@@ -13,6 +13,7 @@ pub mod boat;
 pub mod boatdamage;
 pub mod boathouse;
 pub mod boatreservation;
+pub mod event;
 pub mod family;
 pub mod location;
 pub mod log;
@@ -20,7 +21,6 @@ pub mod logbook;
 pub mod logtype;
 pub mod mail;
 pub mod notification;
-pub mod planned_event;
 pub mod role;
 pub mod rower;
 pub mod stat;
@@ -35,7 +35,7 @@ pub mod weather;
 #[derive(Serialize, Debug)]
 pub struct Day {
     day: NaiveDate,
-    planned_events: Vec<PlannedEventWithUserAndTriptype>,
+    events: Vec<EventWithUserAndTriptype>,
     trips: Vec<TripWithUserAndType>,
     is_pinned: bool,
     max_waterlevel: Option<i64>,
@@ -47,7 +47,7 @@ impl Day {
         if is_pinned {
             Self {
                 day,
-                planned_events: PlannedEvent::get_pinned_for_day(db, day).await,
+                events: Event::get_pinned_for_day(db, day).await,
                 trips: Trip::get_pinned_for_day(db, day).await,
                 is_pinned,
                 max_waterlevel: Waterlevel::max_waterlevel_for_day(db, day).await,
@@ -56,7 +56,7 @@ impl Day {
         } else {
             Self {
                 day,
-                planned_events: PlannedEvent::get_for_day(db, day).await,
+                events: Event::get_for_day(db, day).await,
                 trips: Trip::get_for_day(db, day).await,
                 is_pinned,
                 max_waterlevel: Waterlevel::max_waterlevel_for_day(db, day).await,
@@ -67,7 +67,7 @@ impl Day {
     pub async fn new_guest(db: &SqlitePool, day: NaiveDate, is_pinned: bool) -> Self {
         let mut day = Self::new(db, day, is_pinned).await;
 
-        day.planned_events.retain(|e| e.planned_event.allow_guests);
+        day.events.retain(|e| e.event.allow_guests);
         day.trips.retain(|t| t.trip.allow_guests);
 
         day

src/model/notification.rs

@@ -7,7 +7,7 @@ use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
 
 use super::{role::Role, user::User};
 
-#[derive(FromRow, Debug, Serialize, Deserialize)]
+#[derive(FromRow, Debug, Serialize, Deserialize, Clone)]
 pub struct Notification {
     pub id: i64,
     pub user_id: i64,
@@ -153,7 +153,7 @@ ORDER BY read_at DESC, created_at DESC;
                 }
             }
             // Cox read notification about cancelled event
-            let re = Regex::new(r"^remove_trip_by_planned_event:(\d+)$").unwrap();
+            let re = Regex::new(r"^remove_trip_by_event:(\d+)$").unwrap();
             if let Some(caps) = re.captures(action) {
                 if let Some(matched) = caps.get(1) {
                     if let Ok(number) = matched.as_str().parse::<i32>() {
@@ -180,3 +180,114 @@ ORDER BY read_at DESC, created_at DESC;
         .unwrap();
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{
+        model::{
+            event::{Event, EventUpdate, Registration},
+            notification::Notification,
+            trip::Trip,
+            tripdetails::{TripDetails, TripDetailsToAdd},
+            user::{CoxUser, User},
+            usertrip::UserTrip,
+        },
+        testdb,
+    };
+
+    use sqlx::SqlitePool;
+
+    #[sqlx::test]
+    fn event_canceled() {
+        let pool = testdb!();
+
+        // Create event
+        let add_tripdetails = TripDetailsToAdd {
+            planned_starting_time: "10:00",
+            max_people: 4,
+            day: "1970-02-01".into(),
+            notes: None,
+            trip_type: None,
+            allow_guests: false,
+            always_show: false,
+        };
+        let tripdetails_id = TripDetails::create(&pool, add_tripdetails).await;
+        let trip_details = TripDetails::find_by_id(&pool, tripdetails_id)
+            .await
+            .unwrap();
+        Event::create(&pool, "new-event".into(), 2, &trip_details).await;
+        let event = Event::find_by_trip_details(&pool, trip_details.id)
+            .await
+            .unwrap();
+
+        // Rower + Cox joins
+        let rower = User::find_by_name(&pool, "rower").await.unwrap();
+        UserTrip::create(&pool, &rower, &trip_details, None)
+            .await
+            .unwrap();
+        let cox = CoxUser::new(&pool, User::find_by_name(&pool, "cox").await.unwrap())
+            .await
+            .unwrap();
+        Trip::new_join(&pool, &cox, &event).await.unwrap();
+
+        // Cancel Event
+        let cancel_update = EventUpdate {
+            name: &event.name,
+            planned_amount_cox: event.planned_amount_cox as i32,
+            max_people: 0,
+            notes: event.notes.as_deref(),
+            always_show: event.always_show,
+            is_locked: event.is_locked,
+        };
+        event.update(&pool, &cancel_update).await;
+
+        // Rower received notification
+        let notifications = Notification::for_user(&pool, &rower).await;
+        let rower_notification = notifications[0].clone();
+        assert_eq!(rower_notification.category, "Absage Ausfahrt");
+        assert_eq!(
+            rower_notification.action_after_reading.as_deref(),
+            Some("remove_user_trip_with_trip_details_id:3")
+        );
+
+        // Cox received notification
+        let notifications = Notification::for_user(&pool, &cox.user).await;
+        let cox_notification = notifications[0].clone();
+        assert_eq!(cox_notification.category, "Absage Ausfahrt");
+        assert_eq!(
+            cox_notification.action_after_reading.as_deref(),
+            Some("remove_trip_by_event:2")
+        );
+
+        // Notification removed if cancellation is cancelled
+        let update = EventUpdate {
+            name: &event.name,
+            planned_amount_cox: event.planned_amount_cox as i32,
+            max_people: 3,
+            notes: event.notes.as_deref(),
+            always_show: event.always_show,
+            is_locked: event.is_locked,
+        };
+        event.update(&pool, &update).await;
+        assert!(Notification::for_user(&pool, &rower).await.is_empty());
+        assert!(Notification::for_user(&pool, &cox.user).await.is_empty());
+
+        // Cancel event again
+        event.update(&pool, &cancel_update).await;
+
+        // Rower is removed if notification is accepted
+        assert!(event.is_rower_registered(&pool, &rower).await);
+        rower_notification.mark_read(&pool).await;
+        assert!(!event.is_rower_registered(&pool, &rower).await);
+
+        // Cox is removed if notification is accepted
+        let registration = Registration::all_cox(&pool, event.id).await;
+        assert_eq!(registration.len(), 1);
+        assert_eq!(registration[0].name, "cox");
+
+        cox_notification.mark_read(&pool).await;
+
+        let registration = Registration::all_cox(&pool, event.id).await;
+        assert!(registration.is_empty());
+    }
+}

src/model/trip.rs

@@ -3,8 +3,8 @@ use serde::Serialize;
 use sqlx::SqlitePool;
 
 use super::{
+    event::{Event, Registration},
     notification::Notification,
-    planned_event::{PlannedEvent, Registration},
     tripdetails::TripDetails,
     triptype::TripType,
     user::{CoxUser, User},
@@ -133,28 +133,28 @@ WHERE trip.id=?
         .ok()
     }
 
-    /// Cox decides to help in a planned event.
+    /// Cox decides to help in a event.
     pub async fn new_join(
         db: &SqlitePool,
         cox: &CoxUser,
-        planned_event: &PlannedEvent,
+        event: &Event,
     ) -> Result<(), CoxHelpError> {
-        if planned_event.is_rower_registered(db, cox).await {
+        if event.is_rower_registered(db, cox).await {
             return Err(CoxHelpError::AlreadyRegisteredAsRower);
         }
 
-        if planned_event.trip_details(db).await.is_locked {
+        if event.trip_details(db).await.is_locked {
             return Err(CoxHelpError::DetailsLocked);
         }
 
-        if planned_event.max_people == 0 {
+        if event.max_people == 0 {
             return Err(CoxHelpError::CanceledEvent);
         }
 
         match sqlx::query!(
             "INSERT INTO trip (cox_id, planned_event_id) VALUES(?, ?)",
             cox.id,
-            planned_event.id
+            event.id
         )
         .execute(db)
         .await
@@ -281,16 +281,16 @@ WHERE day=?
     pub async fn delete_by_planned_event(
         db: &SqlitePool,
         cox: &CoxUser,
-        planned_event: &PlannedEvent,
+        event: &Event,
     ) -> Result<(), TripHelpDeleteError> {
-        if planned_event.trip_details(db).await.is_locked {
+        if event.trip_details(db).await.is_locked {
             return Err(TripHelpDeleteError::DetailsLocked);
         }
 
         let affected_rows = sqlx::query!(
             "DELETE FROM trip WHERE cox_id = ? AND planned_event_id = ?",
             cox.id,
-            planned_event.id
+            event.id
         )
         .execute(db)
         .await
@@ -374,7 +374,7 @@ pub enum TripUpdateError {
 mod test {
     use crate::{
         model::{
-            planned_event::PlannedEvent,
+            event::Event,
             trip::{self, TripDeleteError},
             tripdetails::TripDetails,
             user::{CoxUser, User},
@@ -425,7 +425,7 @@ mod test {
         .await
         .unwrap();
 
-        let planned_event = PlannedEvent::find_by_id(&pool, 1).await.unwrap();
+        let planned_event = Event::find_by_id(&pool, 1).await.unwrap();
 
         assert!(Trip::new_join(&pool, &cox, &planned_event).await.is_ok());
     }
@@ -441,7 +441,7 @@ mod test {
         .await
         .unwrap();
 
-        let planned_event = PlannedEvent::find_by_id(&pool, 1).await.unwrap();
+        let planned_event = Event::find_by_id(&pool, 1).await.unwrap();
 
         Trip::new_join(&pool, &cox, &planned_event).await.unwrap();
         assert!(Trip::new_join(&pool, &cox, &planned_event).await.is_err());
@@ -542,7 +542,7 @@ mod test {
         .await
         .unwrap();
 
-        let planned_event = PlannedEvent::find_by_id(&pool, 1).await.unwrap();
+        let planned_event = Event::find_by_id(&pool, 1).await.unwrap();
 
         Trip::new_join(&pool, &cox, &planned_event).await.unwrap();
 

src/model/user.rs

@@ -823,7 +823,7 @@ ORDER BY last_access DESC
         for date in TripDetails::pinned_days(db, self.amount_days_to_show(db).await - 1).await {
             if self.has_role(db, "scheckbuch").await {
                 let day = Day::new_guest(db, date, true).await;
-                if !day.planned_events.is_empty() {
+                if !day.events.is_empty() {
                     days.push(day);
                 }
             } else {
@@ -1124,15 +1124,15 @@ impl<'r> FromRequest<'r> for VorstandUser {
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct PlannedEventUser(pub(crate) User);
+pub struct EventUser(pub(crate) User);
 
-impl From<PlannedEventUser> for User {
+impl From<EventUser> for User {
-    fn from(val: PlannedEventUser) -> Self {
+    fn from(val: EventUser) -> Self {
         val.0
     }
 }
 
-impl Deref for PlannedEventUser {
+impl Deref for EventUser {
     type Target = User;
 
     fn deref(&self) -> &Self::Target {
@@ -1183,7 +1183,7 @@ impl UserWithMembershipPdf {
 }
 
 #[async_trait]
-impl<'r> FromRequest<'r> for PlannedEventUser {
+impl<'r> FromRequest<'r> for EventUser {
     type Error = LoginError;
 
     async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
@@ -1191,7 +1191,7 @@ impl<'r> FromRequest<'r> for PlannedEventUser {
         match User::from_request(req).await {
             Outcome::Success(user) => {
                 if user.has_role(db, "planned_event").await {
-                    Outcome::Success(PlannedEventUser(user))
+                    Outcome::Success(EventUser(user))
                 } else {
                     Outcome::Error((Status::Forbidden, LoginError::NotACox))
                 }

src/model/usertrip.rs

@@ -150,7 +150,7 @@ pub enum UserTripDeleteError {
 mod test {
     use crate::{
         model::{
-            planned_event::PlannedEvent, trip::Trip, tripdetails::TripDetails, user::CoxUser,
+            event::Event, trip::Trip, tripdetails::TripDetails, user::CoxUser,
             usertrip::UserTripError,
         },
         testdb,
@@ -240,8 +240,8 @@ mod test {
         .await
         .unwrap();
 
-        let planned_event = PlannedEvent::find_by_id(&pool, 1).await.unwrap();
+        let event = Event::find_by_id(&pool, 1).await.unwrap();
-        Trip::new_join(&pool, &cox, &planned_event).await.unwrap();
+        Trip::new_join(&pool, &cox, &event).await.unwrap();
 
         let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
         let result = UserTrip::create(&pool, &cox, &trip_details, None)

src/tera/admin/planned_event.rs

@@ -8,14 +8,14 @@ use serde::Serialize;
 use sqlx::SqlitePool;
 
 use crate::model::{
-    planned_event::{self, PlannedEvent},
+    event::{self, Event},
     tripdetails::{TripDetails, TripDetailsToAdd},
-    user::PlannedEventUser,
+    user::EventUser,
 };
 
 //TODO: add constraints (e.g. planned_amount_cox > 0)
 #[derive(FromForm, Serialize)]
-struct AddPlannedEventForm<'r> {
+struct AddEventForm<'r> {
     name: &'r str,
     planned_amount_cox: i32,
     tripdetails: TripDetailsToAdd<'r>,
@@ -24,8 +24,8 @@ struct AddPlannedEventForm<'r> {
 #[post("/planned-event", data = "<data>")]
 async fn create(
     db: &State<SqlitePool>,
-    data: Form<AddPlannedEventForm<'_>>,
+    data: Form<AddEventForm<'_>>,
-    _admin: PlannedEventUser,
+    _admin: EventUser,
 ) -> Flash<Redirect> {
     let data = data.into_inner();
 
@@ -34,14 +34,14 @@ async fn create(
                                                                                     //just created
                                                                                     //the object
 
-    PlannedEvent::create(db, data.name, data.planned_amount_cox, trip_details).await;
+    Event::create(db, data.name, data.planned_amount_cox, &trip_details).await;
 
     Flash::success(Redirect::to("/planned"), "Event hinzugefügt")
 }
 
 //TODO: add constraints (e.g. planned_amount_cox > 0)
 #[derive(FromForm)]
-struct UpdatePlannedEventForm<'r> {
+struct UpdateEventForm<'r> {
     id: i64,
     name: &'r str,
     planned_amount_cox: i32,
@@ -54,10 +54,10 @@ struct UpdatePlannedEventForm<'r> {
 #[put("/planned-event", data = "<data>")]
 async fn update(
     db: &State<SqlitePool>,
-    data: Form<UpdatePlannedEventForm<'_>>,
+    data: Form<UpdateEventForm<'_>>,
-    _admin: PlannedEventUser,
+    _admin: EventUser,
 ) -> Flash<Redirect> {
-    let update = planned_event::EventUpdate {
+    let update = event::EventUpdate {
         name: data.name,
         planned_amount_cox: data.planned_amount_cox,
         max_people: data.max_people,
@@ -65,7 +65,7 @@ async fn update(
         always_show: data.always_show,
         is_locked: data.is_locked,
     };
-    match PlannedEvent::find_by_id(db, data.id).await {
+    match Event::find_by_id(db, data.id).await {
         Some(planned_event) => {
             planned_event.update(db, &update).await;
             Flash::success(Redirect::to("/planned"), "Event erfolgreich bearbeitet")
@@ -75,9 +75,9 @@ async fn update(
 }
 
 #[get("/planned-event/<id>/delete")]
-async fn delete(db: &State<SqlitePool>, id: i64, _admin: PlannedEventUser) -> Flash<Redirect> {
+async fn delete(db: &State<SqlitePool>, id: i64, _admin: EventUser) -> Flash<Redirect> {
-    let Some(event) = PlannedEvent::find_by_id(db, id).await else {
+    let Some(event) = Event::find_by_id(db, id).await else {
-        return Flash::error(Redirect::to("/planned"), "PlannedEvent does not exist");
+        return Flash::error(Redirect::to("/planned"), "Event does not exist");
     };
 
     match event.delete(db).await {
@@ -105,7 +105,7 @@ mod test {
     fn test_delete() {
         let db = testdb!();
 
-        let _ = PlannedEvent::find_by_id(&db, 1).await.unwrap();
+        let _ = Event::find_by_id(&db, 1).await.unwrap();
 
         let rocket = rocket::build().manage(db.clone());
         let rocket = crate::tera::config(rocket);
@@ -130,7 +130,7 @@ mod test {
 
         assert_eq!(flash_cookie.value(), "7:successEvent gelöscht");
 
-        let event = PlannedEvent::find_by_id(&db, 1).await;
+        let event = Event::find_by_id(&db, 1).await;
         assert_eq!(event, None);
     }
 
@@ -159,16 +159,16 @@ mod test {
             .get("_flash")
             .expect("Expected flash cookie");
 
-        assert_eq!(flash_cookie.value(), "5:errorPlannedEvent does not exist");
+        assert_eq!(flash_cookie.value(), "5:errorEvent does not exist");
 
-        let _ = PlannedEvent::find_by_id(&db, 1).await.unwrap();
+        let _ = Event::find_by_id(&db, 1).await.unwrap();
     }
 
     #[sqlx::test]
     fn test_update() {
         let db = testdb!();
 
-        let event = PlannedEvent::find_by_id(&db, 1).await.unwrap();
+        let event = Event::find_by_id(&db, 1).await.unwrap();
         assert_eq!(event.notes, Some("trip_details for a planned event".into()));
 
         let rocket = rocket::build().manage(db.clone());
@@ -200,7 +200,7 @@ mod test {
             "7:successEvent erfolgreich bearbeitet"
         );
 
-        let event = PlannedEvent::find_by_id(&db, 1).await.unwrap();
+        let event = Event::find_by_id(&db, 1).await.unwrap();
         assert_eq!(event.notes, Some("new-planned-event-text".into()));
     }
 
@@ -267,7 +267,7 @@ mod test {
 
         assert_eq!(flash_cookie.value(), "7:successEvent hinzugefügt");
 
-        let event = PlannedEvent::find_by_id(&db, 2).await.unwrap();
+        let event = Event::find_by_id(&db, 2).await.unwrap();
         assert_eq!(event.name, "my-cool-new-event");
     }
 }

src/tera/cox.rs

@@ -7,8 +7,8 @@ use rocket::{
 use sqlx::SqlitePool;
 
 use crate::model::{
+    event::Event,
     log::Log,
-    planned_event::PlannedEvent,
     trip::{self, CoxHelpError, Trip, TripDeleteError, TripHelpDeleteError, TripUpdateError},
     tripdetails::{TripDetails, TripDetailsToAdd},
     user::CoxUser,
@@ -82,7 +82,7 @@ async fn update(
 
 #[get("/join/<planned_event_id>")]
 async fn join(db: &State<SqlitePool>, planned_event_id: i64, cox: CoxUser) -> Flash<Redirect> {
-    if let Some(planned_event) = PlannedEvent::find_by_id(db, planned_event_id).await {
+    if let Some(planned_event) = Event::find_by_id(db, planned_event_id).await {
         match Trip::new_join(db, &cox, &planned_event).await {
             Ok(_) => {
                 Log::create(
@@ -137,7 +137,7 @@ async fn remove_trip(db: &State<SqlitePool>, trip_id: i64, cox: CoxUser) -> Flas
 
 #[get("/remove/<planned_event_id>")]
 async fn remove(db: &State<SqlitePool>, planned_event_id: i64, cox: CoxUser) -> Flash<Redirect> {
-    if let Some(planned_event) = PlannedEvent::find_by_id(db, planned_event_id).await {
+    if let Some(planned_event) = Event::find_by_id(db, planned_event_id).await {
         match Trip::delete_by_planned_event(db, &cox, &planned_event).await {
             Ok(_) => {
                 Log::create(

src/tera/misc.rs

@@ -1,12 +1,12 @@
 use rocket::{get, http::ContentType, routes, Route, State};
 use sqlx::SqlitePool;
 
-use crate::model::planned_event::PlannedEvent;
+use crate::model::event::Event;
 
 #[get("/cal")]
 async fn cal(db: &State<SqlitePool>) -> (ContentType, String) {
     //TODO: add unit test once proper functionality is there
-    (ContentType::Calendar, PlannedEvent::get_ics_feed(db).await)
+    (ContentType::Calendar, Event::get_ics_feed(db).await)
 }
 
 pub fn routes() -> Vec<Route> {

templates/planned.html.tera

@@ -58,11 +58,11 @@
         <h1 class="h1 sm:col-span-2 lg:col-span-3">Ausfahrten</h1>
         {% include "includes/buttons" %}
         {% for day in days %}
-            {% set amount_trips = day.planned_events | length + day.trips | length %}
+            {% set amount_trips = day.events | length + day.trips | length %}
             {% set_global day_cox_needed = false %}
-            {% if day.planned_events | length > 0 %}
+            {% if day.events | length > 0 %}
-                {% for planned_event in day.planned_events %}
+                {% for event in day.events %}
-                    {% if planned_event.cox_needed %}
+                    {% if event.cox_needed %}
                         {% set_global day_cox_needed = true %}
                     {% endif %}
                 {% endfor %}
@@ -88,82 +88,82 @@
                             </small>
                         {% endif %}
                     </h2>
-                    {% if day.planned_events | length > 0 or  day.trips | length > 0 %}
+                    {% if day.events | length > 0 or  day.trips | length > 0 %}
                         <div class="grid grid-cols-1 gap-3 mb-3">
                             {# --- START Events --- #}
-                            {% if day.planned_events | length > 0 %}
+                            {% if day.events | length > 0 %}
-                                {% for planned_event in day.planned_events | sort(attribute="planned_starting_time") %}
+                                {% for event in day.events | sort(attribute="planned_starting_time") %}
-                                    {% set amount_cur_cox = planned_event.cox | length %}
+                                    {% set amount_cur_cox = event.cox | length %}
-                                    {% set amount_cox_missing = planned_event.planned_amount_cox - amount_cur_cox %}
+                                    {% set amount_cox_missing = event.planned_amount_cox - amount_cur_cox %}
                                     <div class="pt-2 px-3 border-t border-gray-200"
-                                         style="order: {{ planned_event.planned_starting_time | replace(from=":", to="") }}">
+                                         style="order: {{ event.planned_starting_time | replace(from=":", to="") }}">
                                         <div class="flex justify-between items-center">
                                             <div class="mr-1">
-                                                {% if planned_event.max_people == 0 %}
+                                                {% if event.max_people == 0 %}
                                                     <strong class="text-[#f43f5e]">&#9888; Absage
-                                                        {{ planned_event.planned_starting_time }}
+                                                        {{ event.planned_starting_time }}
                                                         Uhr
                                                     </strong>
-                                                    <small class="text-[#f43f5e]">({{ planned_event.name }}
+                                                    <small class="text-[#f43f5e]">({{ event.name }}
-                                                        {%- if planned_event.trip_type %}
+                                                        {%- if event.trip_type %}
-                                                            - {{ planned_event.trip_type.icon | safe }}&nbsp;{{ planned_event.trip_type.name }}
+                                                            - {{ event.trip_type.icon | safe }}&nbsp;{{ event.trip_type.name }}
                                                         {%- endif -%}
                                                     )</small>
                                                 {% else %}
                                                     <strong class="text-primary-900 dark:text-white">
-                                                        {{ planned_event.planned_starting_time }}
+                                                        {{ event.planned_starting_time }}
                                                         Uhr
                                                     </strong>
-                                                    <small class="text-gray-600 dark:text-gray-100">({{ planned_event.name }}
+                                                    <small class="text-gray-600 dark:text-gray-100">({{ event.name }}
-                                                        {%- if planned_event.trip_type %}
+                                                        {%- if event.trip_type %}
-                                                            - {{ planned_event.trip_type.icon | safe }}&nbsp;{{ planned_event.trip_type.name }}
+                                                            - {{ event.trip_type.icon | safe }}&nbsp;{{ event.trip_type.name }}
                                                         {%- endif -%}
                                                     )</small>
                                                 {% endif %}
                                                 <br />
-                                                <a href="#" data-sidebar="true" data-trigger="sidebar" data-header="<strong>{{ planned_event.planned_starting_time }} Uhr</strong> ({{ planned_event.name }})
+                                                <a href="#" data-sidebar="true" data-trigger="sidebar" data-header="<strong>{{ event.planned_starting_time }} Uhr</strong> ({{ event.name }})
-                                                    {% if planned_event.trip_type %}<small class='block'>{{ planned_event.trip_type.desc }}</small>{% endif %}
+                                                    {% if event.trip_type %}<small class='block'>{{ event.trip_type.desc }}</small>{% endif %}
-                                                    {% if planned_event.notes %}<small class='block'>{{ planned_event.notes }}</small>{% endif %}
+                                                    {% if event.notes %}<small class='block'>{{ event.notes }}</small>{% endif %}
-                                                    " data-body="#event{{ planned_event.trip_details_id }}" class="inline-block link-primary mr-3">
+                                                    " data-body="#event{{ event.trip_details_id }}" class="inline-block link-primary mr-3">
                                                     Details
                                                 </a>
                                             </div>
                                             <div class="text-right grid gap-2">
                                                 {# --- START Row Buttons --- #}
                                                 {% set_global cur_user_participates = false %}
-                                                {% for rower in planned_event.rower %}
+                                                {% for rower in event.rower %}
                                                     {% if rower.name == loggedin_user.name %}
                                                         {% set_global cur_user_participates = true %}
                                                     {% endif %}
                                                 {% endfor %}
                                                 {% if cur_user_participates %}
-                                                    <a href="/planned/remove/{{ planned_event.trip_details_id }}"
+                                                    <a href="/planned/remove/{{ event.trip_details_id }}"
                                                        class="btn btn-attention btn-fw">Abmelden</a>
                                                 {% endif %}
-                                                {% if planned_event.max_people > planned_event.rower | length and cur_user_participates == false %}
+                                                {% if event.max_people > event.rower | length and cur_user_participates == false %}
-                                                    <a href="/planned/join/{{ planned_event.trip_details_id }}"
+                                                    <a href="/planned/join/{{ event.trip_details_id }}"
                                                        class="btn btn-primary btn-fw"
-                                                       {% if planned_event.trip_type %}onclick="return confirm('{{ planned_event.trip_type.question }}');"{% endif %}>Mitrudern</a>
+                                                       {% if event.trip_type %}onclick="return confirm('{{ event.trip_type.question }}');"{% endif %}>Mitrudern</a>
                                                 {% endif %}
                                                 {# --- END Row Buttons --- #}
                                                 {# --- START Cox Buttons --- #}
                                                 {% if "cox" in loggedin_user.roles %}
                                                     {% set_global cur_user_participates = false %}
-                                                    {% for cox in planned_event.cox %}
+                                                    {% for cox in event.cox %}
                                                         {% if cox.name == loggedin_user.name %}
                                                             {% set_global cur_user_participates = true %}
                                                         {% endif %}
                                                     {% endfor %}
                                                     {% if cur_user_participates %}
-                                                        <a href="/cox/remove/{{ planned_event.id }}"
+                                                        <a href="/cox/remove/{{ event.id }}"
                                                            class="block btn btn-attention btn-fw">
                                                             {% include "includes/cox-icon" %}
                                                             Abmelden
                                                         </a>
-                                                    {% elif planned_event.planned_amount_cox > 0 %}
+                                                    {% elif event.planned_amount_cox > 0 %}
-                                                        <a href="/cox/join/{{ planned_event.id }}"
+                                                        <a href="/cox/join/{{ event.id }}"
                                                            class="block btn {% if amount_cox_missing > 0 %} btn-dark {% else %} btn-gray {% endif %} btn-fw"
-                                                           {% if planned_event.trip_type %}onclick="return confirm('{{ planned_event.trip_type.question }}');"{% endif %}>
+                                                           {% if event.trip_type %}onclick="return confirm('{{ event.trip_type.question }}');"{% endif %}>
                                                             {% include "includes/cox-icon" %}
                                                             Steuern
                                                         </a>
@@ -174,30 +174,30 @@
                                         </div>
                                         {# --- START Sidebar Content --- #}
                                         <div class="hidden">
-                                            <div id="event{{ planned_event.trip_details_id }}">
+                                            <div id="event{{ event.trip_details_id }}">
                                                 {# --- START List Coxes --- #}
-                                                {% if planned_event.planned_amount_cox > 0 %}
+                                                {% if event.planned_amount_cox > 0 %}
-                                                    {% if planned_event.max_people == 0 %}
+                                                    {% if event.max_people == 0 %}
-                                                        {{ macros::box(participants=planned_event.cox, empty_seats="", header='Absage', bg='[#f43f5e]') }}
+                                                        {{ macros::box(participants=event.cox, empty_seats="", header='Absage', bg='[#f43f5e]') }}
                                                     {% else %}
                                                         {% if amount_cox_missing > 0 %}
-                                                            {{ macros::box(participants=planned_event.cox, empty_seats=planned_event.planned_amount_cox - amount_cur_cox, header='Noch benötigte Steuerleute:', text='Keine Steuerleute angemeldet') }}
+                                                            {{ macros::box(participants=event.cox, empty_seats=event.planned_amount_cox - amount_cur_cox, header='Noch benötigte Steuerleute:', text='Keine Steuerleute angemeldet') }}
                                                         {% else %}
-                                                            {{ macros::box(participants=planned_event.cox, empty_seats="", header='Genügend Steuerleute haben sich angemeldet :-)', text='Keine Steuerleute angemeldet') }}
+                                                            {{ macros::box(participants=event.cox, empty_seats="", header='Genügend Steuerleute haben sich angemeldet :-)', text='Keine Steuerleute angemeldet') }}
                                                         {% endif %}
                                                     {% endif %}
                                                 {% endif %}
                                                 {# --- END List Coxes --- #}
                                                 {# --- START List Rowers --- #}
-                                                {% set amount_cur_rower = planned_event.rower | length %}
+                                                {% set amount_cur_rower = event.rower | length %}
-                                                {% if planned_event.max_people == 0 %}
+                                                {% if event.max_people == 0 %}
-                                                    {{ macros::box(header='Absage', bg='[#f43f5e]', participants=planned_event.rower, trip_details_id=planned_event.trip_details_id, allow_removing="planned_event" in loggedin_user.roles) }}
+                                                    {{ macros::box(header='Absage', bg='[#f43f5e]', participants=event.rower, trip_details_id=event.trip_details_id, allow_removing="event" in loggedin_user.roles) }}
                                                 {% else %}
-                                                    {{ macros::box(participants=planned_event.rower, empty_seats=planned_event.max_people - amount_cur_rower, bg='primary-100', color='black', trip_details_id=planned_event.trip_details_id, allow_removing="planned_event" in loggedin_user.roles) }}
+                                                    {{ macros::box(participants=event.rower, empty_seats=event.max_people - amount_cur_rower, bg='primary-100', color='black', trip_details_id=event.trip_details_id, allow_removing="event" in loggedin_user.roles) }}
                                                 {% endif %}
                                                 {# --- END List Rowers --- #}
-                                                {% if "planned_event" in loggedin_user.roles %}
+                                                {% if "event" in loggedin_user.roles %}
-                                                    <form action="/planned/join/{{ planned_event.trip_details_id }}"
+                                                    <form action="/planned/join/{{ event.trip_details_id }}"
                                                           method="get" />
                                                     {{ macros::input(label='Gast', class="input rounded-t", name='user_note', type='text', required=true) }}
                                                     <input value="Gast hinzufügen"
@@ -205,51 +205,51 @@
                                                            type="submit" />
                                                 </form>
                                             {% endif %}
-                                            {% if planned_event.allow_guests %}
+                                            {% if event.allow_guests %}
                                                 <div class="text-primary-900 bg-primary-50 text-center p-1 mb-4">Gäste willkommen!</div>
                                             {% endif %}
-                                            {% if "planned_event" in loggedin_user.roles %}
+                                            {% if "event" in loggedin_user.roles %}
                                                 {# --- START Edit Form --- #}
                                                 <div class="bg-gray-100 dark:bg-primary-900 p-3 mt-4 rounded-md">
                                                     <h3 class="text-primary-950 dark:text-white font-bold uppercase tracking-wide mb-2">Ausfahrt bearbeiten</h3>
                                                     <form action="/admin/planned-event" method="post" class="grid gap-3">
                                                         <input type="hidden" name="_method" value="put" />
-                                                        <input type="hidden" name="id" value="{{ planned_event.id }}" />
+                                                        <input type="hidden" name="id" value="{{ event.id }}" />
-                                                        {{ macros::input(label='Titel', name='name', type='input', value=planned_event.name) }}
+                                                        {{ macros::input(label='Titel', name='name', type='input', value=event.name) }}
-                                                        {{ macros::input(label='Anzahl Ruderer', name='max_people', type='number', required=true, value=planned_event.max_people, min='1') }}
+                                                        {{ macros::input(label='Anzahl Ruderer', name='max_people', type='number', required=true, value=event.max_people, min='1') }}
-                                                        {{ macros::input(label='Anzahl Steuerleute', name='planned_amount_cox', type='number', value=planned_event.planned_amount_cox, required=true, min='0') }}
+                                                        {{ 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=planned_event.id,checked=planned_event.always_show) }}
+                                                        {{ macros::checkbox(label='Immer anzeigen', name='always_show', id=event.id,checked=event.always_show) }}
-                                                        {{ macros::checkbox(label='Gesperrt', name='is_locked', id=planned_event.id,checked=planned_event.is_locked) }}
+                                                        {{ macros::checkbox(label='Gesperrt', name='is_locked', id=event.id,checked=event.is_locked) }}
-                                                        {{ macros::input(label='Anmerkungen', name='notes', type='input', value=planned_event.notes) }}
+                                                        {{ macros::input(label='Anmerkungen', name='notes', type='input', value=event.notes) }}
                                                         <input value="Speichern" class="btn btn-primary" type="submit" />
                                                     </form>
                                                 </div>
                                                 {# --- END Edit Form --- #}
                                                 {# --- START Delete Btn --- #}
-                                                {% if planned_event.rower | length == 0 and amount_cur_cox == 0 %}
+                                                {% if event.rower | length == 0 and amount_cur_cox == 0 %}
                                                     <div class="text-right mt-6">
-                                                        <a href="/admin/planned-event/{{ planned_event.id }}/delete"
+                                                        <a href="/admin/planned-event/{{ event.id }}/delete"
                                                            class="inline-block btn btn-alert">
                                                             {% include "includes/delete-icon" %}
                                                             Termin löschen
                                                         </a>
                                                     </div>
                                                 {% else %}
-                                                    {% if planned_event.max_people == 0 %}
+                                                    {% if event.max_people == 0 %}
                                                         Wenn du deine Absage absagen (:^)) willst, einfach entsprechende Anzahl an Ruderer oben eintragen.
                                                     {% else %}
                                                         <div class="bg-gray-100 dark:bg-primary-900 p-3 mt-4 rounded-md">
                                                             <h3 class="text-primary-950 dark:text-white font-bold uppercase tracking-wide mb-2">Event absagen</h3>
                                                             <form action="/admin/planned-event" method="post" class="grid">
                                                                 <input type="hidden" name="_method" value="put" />
-                                                                <input type="hidden" name="id" value="{{ planned_event.id }}" />
+                                                                <input type="hidden" name="id" value="{{ event.id }}" />
                                                         	{{ macros::input(label='Grund der Absage', name='notes', type='input', value='') }}
                                                                 {{ macros::input(label='', name='max_people', type='hidden', value=0) }}
-                                                                {{ macros::input(label='', name='name', type='hidden', value=planned_event.name) }}
+                                                                {{ macros::input(label='', name='name', type='hidden', value=event.name) }}
-                                                                {{ macros::input(label='', name='max_people', type='hidden', value=planned_event.max_people) }}
+                                                                {{ macros::input(label='', name='max_people', type='hidden', value=event.max_people) }}
-                                                                {{ macros::input(label='', name='planned_amount_cox', type='hidden', value=planned_event.planned_amount_cox) }}
+                                                                {{ macros::input(label='', name='planned_amount_cox', type='hidden', value=event.planned_amount_cox) }}
-                                                                {{ macros::input(label='', name='always_show', type='hidden', value=planned_event.always_show) }}
+                                                                {{ macros::input(label='', name='always_show', type='hidden', value=event.always_show) }}
-                                                                {{ macros::input(label='', name='is_locked', type='hidden', value=planned_event.is_locked) }}
+                                                                {{ macros::input(label='', name='is_locked', type='hidden', value=event.is_locked) }}
                                                                 <input value="Ausfahrt absagen" class="btn btn-alert" type="submit" />
                                                             </form>
                                                         </div>
@@ -389,9 +389,9 @@
             {% endif %}
         </div>
         {# --- START Add Buttons --- #}
-        {% if "planned_event" in loggedin_user.roles or "cox" in loggedin_user.roles %}
+        {% if "event" in loggedin_user.roles or "cox" in loggedin_user.roles %}
-            <div class="grid {% if "planned_event" in loggedin_user.roles %}grid-cols-2{% endif %} text-center">
+            <div class="grid {% if "event" in loggedin_user.roles %}grid-cols-2{% endif %} text-center">
-                {% if "planned_event" in loggedin_user.roles %}
+                {% if "event" in loggedin_user.roles %}
                     <a href="#"
                        data-sidebar="true"
                        data-trigger="sidebar"
@@ -405,7 +405,7 @@
                 {% endif %}
                 {% if "cox" in loggedin_user.roles %}
                     <a href="#" data-sidebar="true" data-trigger="sidebar" data-header="<strong>Ausfahrt</strong> am {{ day.day| date(format='%d.%m.%Y') }} erstellen" data-day="{{ day.day }}" data-body="#sidebarForm" class="relative inline-block w-full py-2 text-primary-900 hover:text-primary-950 dark:bg-primary-600 dark:text-white dark:hover:bg-primary-500 dark:hover:text-white focus:text-primary-950 text-sm font-semibold bg-gray-100 hover:bg-gray-200 focus:bg-gray-200
-                        {% if "planned_event" in loggedin_user.roles %}
+                        {% if "event" in loggedin_user.roles %}
                             rounded-br-md
                         {% else %}
                             rounded-b-md
@@ -425,7 +425,7 @@
 {% if "cox" in loggedin_user.roles %}
     {% include "forms/trip" %}
 {% endif %}
-{% if "planned_event" in loggedin_user.roles %}
+{% if "event" in loggedin_user.roles %}
     {% include "forms/event" %}
 {% endif %}
 {% endblock content %}