philipp/hacky-ruadat
1
0
Fork 0
forked from Ruderverein-Donau-Linz/rowt
Code Issues Pull Requests Actions Activity

rename planned_event to event

Browse Source
This commit is contained in:
philipp
2024-05-28 09:08:48 +02:00
parent e325e0478a
commit 82aa94c024
9 changed files with 149 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
src/model/planned_event.rs → src/model/event.rs
View File

@ -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,7 +11,7 @@ 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,
@ -27,9 +27,9 @@ pub struct PlannedEvent {
}
#[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>,
@ -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(
db: &SqlitePool,
day: NaiveDate,
) -> Vec<PlannedEventWithUserAndTriptype> {
pub async fn get_for_day(db: &SqlitePool, day: NaiveDate) -> Vec<EventWithUserAndTriptype> {
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: 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",
@ -328,7 +325,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 +333,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 +361,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 +369,7 @@ mod test {
fn test_get_day() {
let pool = testdb!();
let res =
PlannedEvent::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
let res = Event::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
assert_eq!(res.len(), 1);
}
@ -382,22 +379,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 =
PlannedEvent::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
let res = Event::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 =
PlannedEvent::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
let res = Event::get_for_day(&pool, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()).await;
assert_eq!(res.len(), 0);
}
@ -405,7 +400,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);
}
}

12
src/model/mod.rs
View File

@ -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

28
src/model/trip.rs
View File

@ -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();

14
src/model/user.rs
View File

@ -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 {
fn from(val: PlannedEventUser) -> Self {
impl From<EventUser> for User {
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))
}

6
src/model/usertrip.rs
View File

@ -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();
Trip::new_join(&pool, &cox, &planned_event).await.unwrap();
let event = Event::find_by_id(&pool, 1).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)

42
src/tera/admin/planned_event.rs
View File

@ -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<'_>>,
_admin: PlannedEventUser,
data: Form<AddEventForm<'_>>,
_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<'_>>,
_admin: PlannedEventUser,
data: Form<UpdateEventForm<'_>>,
_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> {
let Some(event) = PlannedEvent::find_by_id(db, id).await else {
return Flash::error(Redirect::to("/planned"), "PlannedEvent does not exist");
async fn delete(db: &State<SqlitePool>, id: i64, _admin: EventUser) -> Flash<Redirect> {
let Some(event) = Event::find_by_id(db, id).await else {
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");
}
}

6
src/tera/cox.rs
View File

@ -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(

4
src/tera/misc.rs
View File

@ -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> {