Ruderverein-Donau-Linz/rowt
1
1
Fork 1
Code Issues 49 Pull Requests Actions Packages Projects Wiki Activity

Allow to add real guests

Browse Source
This commit is contained in:
PhilippHofer
2023-08-09 20:30:37 +00:00
parent 723ada09b0
commit 590b41aa33
8 changed files with 308 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
src/model/planned_event.rs
View File

@ -37,11 +37,12 @@ pub struct PlannedEventWithUserAndTriptype {
}
//TODO: move to appropriate place
#[derive(Serialize)]
#[derive(Serialize, Debug)]
pub struct Registration {
pub name: String,
pub registered_at: String,
pub is_guest: bool,
pub is_real_guest: bool,
}
impl PlannedEvent {
@ -120,29 +121,40 @@ INNER JOIN trip_details ON planned_event.trip_details_id = trip_details.id",
async fn get_all_cox(&self, db: &SqlitePool) -> Vec<Registration> {
//TODO: switch to join
sqlx::query_as!(
Registration,
sqlx::query!(
"
SELECT
(SELECT name FROM user WHERE cox_id = id) as name,
(SELECT created_at FROM user WHERE cox_id = id) as registered_at,
(SELECT is_guest FROM user WHERE cox_id = id) as is_guest
(SELECT is_guest FROM user WHERE cox_id = id) as is_guest,
0 as is_real_guest
FROM trip WHERE planned_event_id = ?
",
self.id
)
.fetch_all(db)
.await
.unwrap() //Okay, as PlannedEvent can only be created with proper DB backing
.unwrap()
.into_iter()
.map(|r| Registration {
name: r.name,
registered_at: r.registered_at,
is_guest: r.is_guest,
is_real_guest: r.is_real_guest == 1,
})
.collect() //Okay, as PlannedEvent can only be created with proper DB backing
}
async fn get_all_rower(&self, db: &SqlitePool) -> Vec<Registration> {
//TODO: switch to join
sqlx::query_as!(
Registration,
sqlx::query!(
"
SELECT
(SELECT name FROM user WHERE user_trip.user_id = user.id) as name,
CASE
WHEN user_id IS NOT NULL THEN (SELECT name FROM user WHERE user_trip.user_id = user.id)
ELSE user_note
END as name,
user_id IS NULL as is_real_guest,
(SELECT created_at FROM user WHERE user_trip.user_id = user.id) as registered_at,
(SELECT is_guest FROM user WHERE user_trip.user_id = user.id) as is_guest
FROM user_trip WHERE trip_details_id = (SELECT trip_details_id FROM planned_event WHERE id = ?)
@ -151,7 +163,15 @@ FROM user_trip WHERE trip_details_id = (SELECT trip_details_id FROM planned_even
)
.fetch_all(db)
.await
.unwrap() //Okay, as PlannedEvent can only be created with proper DB backing
.unwrap()
.into_iter()
.map(|r| Registration {
name: r.name.unwrap(),
registered_at: r.registered_at,
is_guest: r.is_guest,
is_real_guest: r.is_real_guest == 1,
})
.collect()
}
//TODO: add tests

23
src/model/trip.rs
View File

@ -126,11 +126,14 @@ WHERE day=?
}
async fn get_all_rower(&self, db: &SqlitePool) -> Vec<Registration> {
sqlx::query_as!(
Registration,
sqlx::query!(
"
SELECT
(SELECT name FROM user WHERE user_trip.user_id = user.id) as name,
CASE
WHEN user_id IS NOT NULL THEN (SELECT name FROM user WHERE user_trip.user_id = user.id)
ELSE user_note
END as name,
user_id IS NULL as is_real_guest,
(SELECT created_at FROM user WHERE user_trip.user_id = user.id) as registered_at,
(SELECT is_guest FROM user WHERE user_trip.user_id = user.id) as is_guest
FROM user_trip WHERE trip_details_id = (SELECT trip_details_id FROM trip WHERE id = ?)",
@ -138,7 +141,15 @@ FROM user_trip WHERE trip_details_id = (SELECT trip_details_id FROM trip WHERE i
)
.fetch_all(db)
.await
.unwrap() //Okay, as Trip can only be created with proper DB backing
.unwrap()
.into_iter()
.map(|r| Registration {
name: r.name.unwrap(),
registered_at: r.registered_at,
is_guest: r.is_guest,
is_real_guest: r.is_real_guest == 1,
})
.collect()
}
/// Cox decides to update own trip.
@ -497,7 +508,9 @@ mod test {
.unwrap();
let user = User::find_by_name(&pool, "rower".into()).await.unwrap();
UserTrip::create(&pool, &user, &trip_details).await.unwrap();
UserTrip::create(&pool, &user, &trip_details, None)
.await
.unwrap();
let result = trip
.delete(&pool, &cox)

86
src/model/tripdetails.rs
View File

@ -1,3 +1,4 @@
use crate::model::user::User;
use chrono::NaiveDate;
use rocket::FromForm;
use serde::{Deserialize, Serialize};
@ -89,6 +90,91 @@ ORDER BY day;",
.map(|a| NaiveDate::parse_from_str(&a, "%Y-%m-%d").unwrap())
.collect()
}
pub(crate) async fn user_is_rower(&self, db: &SqlitePool, user: &User) -> bool {
//check if cox if planned_event
let is_rower = sqlx::query!(
"SELECT count(*) as amount
FROM user_trip
WHERE trip_details_id = ? AND user_id = ?",
self.id,
user.id
)
.fetch_one(db)
.await
.unwrap();
is_rower.amount > 0
}
async fn belongs_to_event(&self, db: &SqlitePool) -> bool {
let amount = sqlx::query!(
"SELECT count(*) as amount
FROM planned_event
WHERE trip_details_id = ?",
self.id,
)
.fetch_one(db)
.await
.unwrap();
amount.amount > 0
}
pub(crate) async fn user_allowed_to_change(&self, db: &SqlitePool, user: &User) -> bool {
if self.belongs_to_event(db).await {
return user.is_admin;
} else {
return self.user_is_cox(db, user).await != CoxAtTrip::No;
}
}
pub(crate) async fn user_is_cox(&self, db: &SqlitePool, user: &User) -> CoxAtTrip {
//check if cox if planned_event
let is_cox = sqlx::query!(
"SELECT count(*) as amount
FROM trip
WHERE planned_event_id = (
SELECT id FROM planned_event WHERE trip_details_id = ?
)
AND cox_id = ?",
self.id,
user.id
)
.fetch_one(db)
.await
.unwrap();
if is_cox.amount > 0 {
return CoxAtTrip::Yes(Action::Helping);
}
//check if cox if own event
let is_cox = sqlx::query!(
"SELECT count(*) as amount
FROM trip
WHERE trip_details_id = ?
AND cox_id = ?",
self.id,
user.id
)
.fetch_one(db)
.await
.unwrap();
if is_cox.amount > 0 {
return CoxAtTrip::Yes(Action::Own);
}
CoxAtTrip::No
}
}
#[derive(PartialEq, Debug)]
pub(crate) enum CoxAtTrip {
No,
Yes(Action),
}
#[derive(PartialEq, Debug)]
pub(crate) enum Action {
Helping,
Own,
}
#[cfg(test)]

148
src/model/usertrip.rs
View File

@ -1,6 +1,7 @@
use sqlx::SqlitePool;
use super::{tripdetails::TripDetails, user::User};
use crate::model::tripdetails::{Action, CoxAtTrip::Yes};
pub struct UserTrip {}
@ -9,6 +10,7 @@ impl UserTrip {
db: &SqlitePool,
user: &User,
trip_details: &TripDetails,
user_note: Option<String>,
) -> Result<(), UserTripError> {
if trip_details.is_full(db).await {
return Err(UserTripError::EventAlreadyFull);
@ -22,74 +24,84 @@ impl UserTrip {
return Err(UserTripError::GuestNotAllowedForThisEvent);
}
//TODO: Check if user sees the event (otherwise she could forge trip_details_id
//TODO: Check if user sees the event (otherwise she could forge trip_details_id)
//check if cox if own event
let is_cox = sqlx::query!(
"SELECT count(*) as amount
FROM trip
WHERE trip_details_id = ?
AND cox_id = ?",
trip_details.id,
user.id
)
.fetch_one(db)
.await
.unwrap();
if is_cox.amount > 0 {
return Err(UserTripError::CantRegisterAtOwnEvent);
let is_cox = trip_details.user_is_cox(db, user).await;
if user_note.is_none() {
if let Yes(action) = is_cox {
match action {
Action::Helping => return Err(UserTripError::AlreadyRegisteredAsCox),
Action::Own => return Err(UserTripError::CantRegisterAtOwnEvent),
};
}
if trip_details.user_is_rower(db, user).await {
return Err(UserTripError::AlreadyRegistered);
}
sqlx::query!(
"INSERT INTO user_trip (user_id, trip_details_id) VALUES(?, ?)",
user.id,
trip_details.id,
)
.execute(db)
.await
.unwrap();
} else {
if !trip_details.user_allowed_to_change(db, user).await {
return Err(UserTripError::NotAllowedToAddGuest);
}
sqlx::query!(
"INSERT INTO user_trip (user_note, trip_details_id) VALUES(?, ?)",
user_note,
trip_details.id,
)
.execute(db)
.await
.unwrap();
}
//TODO: can probably move to trip.rs?
//check if cox if planned_event
let is_cox = sqlx::query!(
"SELECT count(*) as amount
FROM trip
WHERE planned_event_id = (
SELECT id FROM planned_event WHERE trip_details_id = ?
)
AND cox_id = ?",
trip_details.id,
user.id
)
.fetch_one(db)
.await
.unwrap();
if is_cox.amount > 0 {
return Err(UserTripError::AlreadyRegisteredAsCox);
}
match sqlx::query!(
"INSERT INTO user_trip (user_id, trip_details_id) VALUES(?, ?)",
user.id,
trip_details.id
)
.execute(db)
.await
{
Ok(_) => Ok(()),
Err(_) => Err(UserTripError::AlreadyRegistered),
}
Ok(())
}
pub async fn delete(
db: &SqlitePool,
user: &User,
trip_details: &TripDetails,
name: Option<String>,
) -> Result<(), UserTripDeleteError> {
if trip_details.is_locked {
return Err(UserTripDeleteError::DetailsLocked);
}
let _ = sqlx::query!(
"DELETE FROM user_trip WHERE user_id = ? AND trip_details_id = ?",
user.id,
trip_details.id
)
.execute(db)
.await
.unwrap();
if let Some(name) = name {
if !trip_details.user_allowed_to_change(db, user).await {
return Err(UserTripDeleteError::NotAllowedToDeleteGuest);
}
if sqlx::query!(
"DELETE FROM user_trip WHERE user_note = ? AND trip_details_id = ?",
name,
trip_details.id
)
.execute(db)
.await
.unwrap()
.rows_affected()
== 0
{
return Err(UserTripDeleteError::GuestNotParticipating);
}
} else {
let _ = sqlx::query!(
"DELETE FROM user_trip WHERE user_id = ? AND trip_details_id = ?",
user.id,
trip_details.id
)
.execute(db)
.await
.unwrap();
}
Ok(())
}
}
@ -102,11 +114,14 @@ pub enum UserTripError {
DetailsLocked,
CantRegisterAtOwnEvent,
GuestNotAllowedForThisEvent,
NotAllowedToAddGuest,
}
#[derive(Debug, PartialEq)]
pub enum UserTripDeleteError {
DetailsLocked,
GuestNotParticipating,
NotAllowedToDeleteGuest,
}
#[cfg(test)]
@ -130,7 +145,9 @@ mod test {
let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
UserTrip::create(&pool, &user, &trip_details).await.unwrap();
UserTrip::create(&pool, &user, &trip_details, None)
.await
.unwrap();
}
#[sqlx::test]
@ -143,12 +160,14 @@ mod test {
let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
UserTrip::create(&pool, &user, &trip_details).await.unwrap();
UserTrip::create(&pool, &user2, &trip_details)
UserTrip::create(&pool, &user, &trip_details, None)
.await
.unwrap();
UserTrip::create(&pool, &user2, &trip_details, None)
.await
.unwrap();
let result = UserTrip::create(&pool, &user3, &trip_details)
let result = UserTrip::create(&pool, &user3, &trip_details, None)
.await
.expect_err("Expect registration to fail because trip is already full");
@ -162,9 +181,11 @@ mod test {
let user = User::find_by_name(&pool, "cox".into()).await.unwrap();
let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
UserTrip::create(&pool, &user, &trip_details).await.unwrap();
UserTrip::create(&pool, &user, &trip_details, None)
.await
.unwrap();
let result = UserTrip::create(&pool, &user, &trip_details)
let result = UserTrip::create(&pool, &user, &trip_details, None)
.await
.expect_err("Expect registration to fail because user is same as responsible cox");
@ -179,7 +200,7 @@ mod test {
let trip_details = TripDetails::find_by_id(&pool, 2).await.unwrap();
let result = UserTrip::create(&pool, &user, &trip_details)
let result = UserTrip::create(&pool, &user, &trip_details, None)
.await
.expect_err("Expect registration to fail because user is same as responsible cox");
@ -196,12 +217,11 @@ mod test {
.try_into()
.unwrap();
let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
let planned_event = PlannedEvent::find_by_id(&pool, 1).await.unwrap();
Trip::new_join(&pool, &cox, &planned_event).await.unwrap();
let result = UserTrip::create(&pool, &cox, &trip_details)
let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
let result = UserTrip::create(&pool, &cox, &trip_details, None)
.await
.expect_err("Expect registration to fail because user is already registered as cox");
@ -216,7 +236,7 @@ mod test {
let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
let result = UserTrip::create(&pool, &user, &trip_details)
let result = UserTrip::create(&pool, &user, &trip_details, None)
.await
.expect_err("Not allowed for guests");