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

aaaaah

Browse Source
This commit is contained in:
philipp
2023-10-31 21:02:56 +01:00
parent d9c7c218bc dc4eddc044
commit 2d7c86f323
17 changed files with 606 additions and 368 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/model/boat.rs
View File

@ -1,6 +1,6 @@
use rocket::serde::{Deserialize, Serialize};
use rocket::FromForm;
use sqlx::{FromRow, SqlitePool};
use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
use super::user::User;
@ -70,6 +70,12 @@ impl Boat {
.await
.ok()
}
pub async fn find_by_id_tx(db: &mut Transaction<'_, Sqlite>, id: i32) -> Option<Self> {
sqlx::query_as!(Self, "SELECT * FROM boat WHERE id like ?", id)
.fetch_one(db)
.await
.ok()
}
pub async fn find_by_name(db: &SqlitePool, name: String) -> Option<Self> {
sqlx::query_as!(Self, "SELECT * FROM boat WHERE name like ?", name)

8
src/model/log.rs
View File

@ -1,6 +1,6 @@
use chrono::{DateTime, Local, NaiveDateTime, TimeZone, Utc};
use serde::{Deserialize, Serialize};
use sqlx::{FromRow, SqlitePool};
use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
#[derive(FromRow, Debug, Serialize, Deserialize)]
pub struct Log {
@ -15,6 +15,12 @@ impl Log {
.await
.is_ok()
}
pub async fn create_with_tx(db: &mut Transaction<'_, Sqlite>, msg: String) -> bool {
sqlx::query!("INSERT INTO log(msg) VALUES (?)", msg,)
.execute(db)
.await
.is_ok()
}
async fn last(db: &SqlitePool) -> Vec<Log> {
sqlx::query_as!(

264
src/model/logbook.rs
View File

@ -1,5 +1,4 @@
use chrono::{NaiveDateTime, TimeZone};
use chrono_tz::Europe::Vienna;
use chrono::NaiveDateTime;
use rocket::FromForm;
use serde::Serialize;
use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
@ -11,6 +10,7 @@ pub struct Logbook {
pub id: i64,
pub boat_id: i64,
pub shipmaster: i64,
pub steering_person: i64,
#[serde(default = "bool::default")]
pub shipmaster_only_steering: bool,
pub departure: NaiveDateTime,
@ -27,10 +27,11 @@ impl PartialEq for Logbook {
}
}
#[derive(FromForm, Debug)]
#[derive(FromForm, Debug, Clone)]
pub struct LogToAdd {
pub boat_id: i32,
pub shipmaster: i64,
pub steering_person: i64,
pub shipmaster_only_steering: bool,
pub departure: String,
pub arrival: Option<String>,
@ -43,6 +44,11 @@ pub struct LogToAdd {
#[derive(FromForm, Debug)]
pub struct LogToFinalize {
pub shipmaster: i64,
pub steering_person: i64,
pub shipmaster_only_steering: bool,
pub departure: String,
pub arrival: String,
pub destination: String,
pub distance_in_km: i64,
pub comments: Option<String>,
@ -50,12 +56,37 @@ pub struct LogToFinalize {
pub rowers: Vec<i64>,
}
impl TryFrom<LogToAdd> for LogToFinalize {
type Error = String;
fn try_from(value: LogToAdd) -> Result<Self, Self::Error> {
if let (Some(arrival), Some(destination), Some(distance_in_km)) =
(value.arrival, value.destination, value.distance_in_km)
{
return Ok(LogToFinalize {
arrival,
destination,
distance_in_km,
shipmaster: value.shipmaster,
steering_person: value.steering_person,
shipmaster_only_steering: value.shipmaster_only_steering,
departure: value.departure,
comments: value.comments,
logtype: value.logtype,
rowers: value.rowers,
});
}
Err("Arrival, destination or distance_in_km not set".into())
}
}
#[derive(Serialize, Debug)]
pub struct LogbookWithBoatAndRowers {
#[serde(flatten)]
pub logbook: Logbook,
pub boat: Boat,
pub shipmaster_user: User,
pub steering_user: User,
pub rowers: Vec<User>,
}
@ -65,6 +96,9 @@ pub enum LogbookUpdateError {
TooManyRowers(usize, usize),
RowerCreateError(i64, String),
ArrivalNotAfterDeparture,
ShipmasterNotInRowers,
SteeringPersonNotInRowers,
UserNotAllowedToUseBoat,
}
#[derive(Debug, PartialEq)]
@ -74,18 +108,40 @@ pub enum LogbookDeleteError {
#[derive(Debug, PartialEq)]
pub enum LogbookCreateError {
ArrivalSetButNoDestination,
UserNotAllowedToUseBoat,
ArrivalSetButNoDistance,
BoatAlreadyOnWater,
BoatLocked,
BoatNotFound,
TooManyRowers(usize, usize),
ShipmasterAlreadyOnWater,
RowerAlreadyOnWater(User),
RowerCreateError(i64, String),
SamePersonShipmasterAndRower,
ArrivalNotAfterDeparture,
SteeringPersonNotInRowers,
ShipmasterNotInRowers,
NotYourEntry,
ArrivalSetButNotRemainingTwo,
}
impl From<LogbookUpdateError> for LogbookCreateError {
fn from(value: LogbookUpdateError) -> Self {
return match value {
LogbookUpdateError::NotYourEntry => LogbookCreateError::NotYourEntry,
LogbookUpdateError::TooManyRowers(a, b) => LogbookCreateError::TooManyRowers(a, b),
LogbookUpdateError::RowerCreateError(a, b) => {
LogbookCreateError::RowerCreateError(a, b)
}
LogbookUpdateError::ArrivalNotAfterDeparture => {
LogbookCreateError::ArrivalNotAfterDeparture
}
LogbookUpdateError::ShipmasterNotInRowers => LogbookCreateError::ShipmasterNotInRowers,
LogbookUpdateError::SteeringPersonNotInRowers => {
LogbookCreateError::SteeringPersonNotInRowers
}
LogbookUpdateError::UserNotAllowedToUseBoat => {
LogbookCreateError::UserNotAllowedToUseBoat
}
};
}
}
impl Logbook {
@ -93,7 +149,7 @@ impl Logbook {
sqlx::query_as!(
Self,
"
SELECT id,boat_id,shipmaster,shipmaster_only_steering,departure,arrival,destination,distance_in_km,comments,logtype
SELECT id,boat_id,shipmaster,steering_person,shipmaster_only_steering,departure,arrival,destination,distance_in_km,comments,logtype
FROM logbook
WHERE id like ?
",
@ -107,7 +163,7 @@ impl Logbook {
pub async fn on_water(db: &SqlitePool) -> Vec<LogbookWithBoatAndRowers> {
let rows = sqlx::query!(
"
SELECT id, boat_id, shipmaster, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype
SELECT id, boat_id, shipmaster, steering_person, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype
FROM logbook
WHERE arrival is null
ORDER BY departure DESC
@ -123,6 +179,7 @@ ORDER BY departure DESC
id: row.id,
boat_id: row.boat_id,
shipmaster: row.shipmaster,
steering_person: row.steering_person,
shipmaster_only_steering: row.shipmaster_only_steering,
departure: row.departure,
arrival: row.arrival,
@ -139,6 +196,9 @@ ORDER BY departure DESC
rowers: Rower::for_log(db, &log).await,
boat: Boat::find_by_id(db, log.boat_id as i32).await.unwrap(),
shipmaster_user: User::find_by_id(db, log.shipmaster as i32).await.unwrap(),
steering_user: User::find_by_id(db, log.steering_person as i32)
.await
.unwrap(),
logbook: log,
});
}
@ -149,7 +209,7 @@ ORDER BY departure DESC
let logs = sqlx::query_as!(
Logbook,
"
SELECT id, boat_id, shipmaster, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype
SELECT id, boat_id, shipmaster, steering_person, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype
FROM logbook
WHERE arrival is not null
ORDER BY departure DESC
@ -165,6 +225,9 @@ ORDER BY departure DESC
rowers: Rower::for_log(db, &log).await,
boat: Boat::find_by_id(db, log.boat_id as i32).await.unwrap(),
shipmaster_user: User::find_by_id(db, log.shipmaster as i32).await.unwrap(),
steering_user: User::find_by_id(db, log.steering_person as i32)
.await
.unwrap(),
logbook: log,
});
}
@ -230,39 +293,22 @@ ORDER BY departure DESC
return Err(LogbookCreateError::BoatAlreadyOnWater);
}
let shipmaster = User::find_by_id(db, log.shipmaster as i32).await.unwrap();
if shipmaster.on_water(db).await {
return Err(LogbookCreateError::ShipmasterAlreadyOnWater);
if !log.rowers.contains(&log.shipmaster) {
return Err(LogbookCreateError::ShipmasterNotInRowers);
}
if !log.rowers.contains(&log.steering_person) {
return Err(LogbookCreateError::SteeringPersonNotInRowers);
}
if let Some(arrival) = &log.arrival {
let dep = NaiveDateTime::parse_from_str(&log.departure, "%Y-%m-%dT%H:%M").unwrap();
let arr = NaiveDateTime::parse_from_str(arrival, "%Y-%m-%dT%H:%M").unwrap();
if arr <= dep {
return Err(LogbookCreateError::ArrivalNotAfterDeparture);
}
if log.destination.is_none() {
return Err(LogbookCreateError::ArrivalSetButNoDestination);
}
if log.distance_in_km.is_none() {
return Err(LogbookCreateError::ArrivalSetButNoDistance);
}
}
if log.rowers.len() > boat.amount_seats as usize - 1 {
if log.rowers.len() > boat.amount_seats as usize {
return Err(LogbookCreateError::TooManyRowers(
boat.amount_seats as usize,
log.rowers.len() + 1,
log.rowers.len(),
));
}
for rower in &log.rowers {
let user = User::find_by_id(db, *rower as i32).await.unwrap();
if *rower == log.shipmaster {
return Err(LogbookCreateError::SamePersonShipmasterAndRower);
}
if user.on_water(db).await {
return Err(LogbookCreateError::RowerAlreadyOnWater(user));
@ -278,25 +324,11 @@ ORDER BY departure DESC
let mut tx = db.begin().await.unwrap();
//let departure = NaiveDateTime::parse_from_str(&log.departure, "%Y-%m-%dT%H:%M").unwrap();
//let departure_vienna = chrono::Utc
// .from_local_datetime(&departure)
// .single()
// .unwrap();
//let departure_utc = departure_vienna.with_timezone(&Vienna);
//let arrival = log.arrival.map(|a| {
// let arr = NaiveDateTime::parse_from_str(&a, "%Y-%m-%dT%H:%M").unwrap();
// let arr_vienna = Vienna.from_local_datetime(&arr).single().unwrap();
// arr_vienna
// .with_timezone(&chrono::Utc)
// .format("%Y-%m-%d %H:%M")
//});
//let arrival = log.arrival.map(|a| format!("{}+02:00", a));
let inserted_row = sqlx::query!(
"INSERT INTO logbook(boat_id, shipmaster, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype) VALUES (?,?,?,?,?,?,?,?,?) RETURNING id",
"INSERT INTO logbook(boat_id, shipmaster, steering_person, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype) VALUES (?,?,?,?,?,?,?,?,?,?) RETURNING id",
log.boat_id,
log.shipmaster,
log.steering_person,
log.shipmaster_only_steering,
log.departure,
log.arrival,
@ -361,51 +393,80 @@ ORDER BY departure DESC
user: &User,
log: LogToFinalize,
) -> Result<(), LogbookUpdateError> {
let mut tx = db.begin().await.unwrap();
self.home_with_transaction(&mut tx, user, log).await?;
tx.commit().await.unwrap();
Ok(())
}
async fn home_with_transaction(
&self,
db: &mut Transaction<'_, Sqlite>,
user: &User,
log: LogToFinalize,
) -> Result<(), LogbookUpdateError> {
//TODO: extract common tests with `create()`
if user.id != self.shipmaster {
return Err(LogbookUpdateError::NotYourEntry);
}
let boat = Boat::find_by_id(db, self.boat_id as i32).await.unwrap(); //ok
if !log.rowers.contains(&log.shipmaster) {
return Err(LogbookUpdateError::ShipmasterNotInRowers);
}
if !log.rowers.contains(&log.steering_person) {
return Err(LogbookUpdateError::SteeringPersonNotInRowers);
}
if log.rowers.len() > boat.amount_seats as usize - 1 {
let boat = Boat::find_by_id_tx(db, self.boat_id as i32).await.unwrap(); //ok
if !boat.shipmaster_allowed(&user).await && self.shipmaster != user.id {
//second part:
//shipmaster has
//entered a
//different user,
//then the user
//should be able
//to `home` it
return Err(LogbookUpdateError::UserNotAllowedToUseBoat);
}
if log.rowers.len() > boat.amount_seats as usize {
return Err(LogbookUpdateError::TooManyRowers(
boat.amount_seats as usize,
log.rowers.len() + 1,
log.rowers.len(),
));
}
let arrival = chrono::offset::Utc::now().naive_utc();
let arrival = Vienna.from_utc_datetime(&arrival);
if arrival.timestamp() + 60 * 60 * 2 <= self.departure.timestamp() {
//TODO: fixme
let dep = NaiveDateTime::parse_from_str(&log.departure, "%Y-%m-%dT%H:%M").unwrap();
let arr = NaiveDateTime::parse_from_str(&log.arrival, "%Y-%m-%dT%H:%M").unwrap();
if arr.timestamp() <= dep.timestamp() {
return Err(LogbookUpdateError::ArrivalNotAfterDeparture);
}
Log::create(db, format!("New trip: {log:?}")).await;
let mut tx = db.begin().await.unwrap();
sqlx::query!(
"UPDATE logbook SET destination=?, distance_in_km=?, comments=?, logtype=?, arrival=? WHERE id=?",
log.destination,
log.distance_in_km,
log.comments,
log.logtype,
arrival,
self.id
)
.execute(&mut tx)
.await.unwrap(); //TODO: fixme
self.remove_rowers(&mut tx).await;
Log::create_with_tx(db, format!("New trip: {log:?}")).await;
self.remove_rowers(db).await;
for rower in &log.rowers {
Rower::create(&mut tx, self.id, *rower)
Rower::create(db, self.id, *rower)
.await
.map_err(|e| LogbookUpdateError::RowerCreateError(*rower, e.to_string()))?;
}
tx.commit().await.unwrap();
sqlx::query!(
"UPDATE logbook SET shipmaster=?, steering_person=?, shipmaster_only_steering=?, departure=?, destination=?, distance_in_km=?, comments=?, logtype=?, arrival=? WHERE id=?",
log.shipmaster,
log.steering_person,
log.shipmaster_only_steering,
log.departure,
log.destination,
log.distance_in_km,
log.comments,
log.logtype,
log.arrival,
self.id
)
.execute(db)
.await.unwrap(); //TODO: fixme
Ok(())
}
@ -486,6 +547,7 @@ mod test {
LogToAdd {
boat_id: 3,
shipmaster: 4,
steering_person: 4,
shipmaster_only_steering: false,
departure: "2128-05-20T12:00".into(),
arrival: None,
@ -493,7 +555,7 @@ mod test {
distance_in_km: None,
comments: None,
logtype: None,
rowers: Vec::new(),
rowers: vec![4],
},
&User::find_by_id(&pool, 4).await.unwrap(),
)
@ -510,6 +572,7 @@ mod test {
LogToAdd {
boat_id: 999,
shipmaster: 5,
steering_person: 5,
shipmaster_only_steering: false,
departure: "2128-05-20T12:00".into(),
arrival: None,
@ -517,7 +580,7 @@ mod test {
distance_in_km: None,
comments: None,
logtype: None,
rowers: Vec::new(),
rowers: vec![5],
},
&User::find_by_id(&pool, 4).await.unwrap(),
)
@ -535,6 +598,7 @@ mod test {
LogToAdd {
boat_id: 5,
shipmaster: 5,
steering_person: 5,
shipmaster_only_steering: false,
departure: "2128-05-20T12:00".into(),
arrival: None,
@ -542,7 +606,7 @@ mod test {
distance_in_km: None,
comments: None,
logtype: None,
rowers: Vec::new(),
rowers: vec![5],
},
&User::find_by_id(&pool, 4).await.unwrap(),
)
@ -560,6 +624,7 @@ mod test {
LogToAdd {
boat_id: 2,
shipmaster: 5,
steering_person: 5,
shipmaster_only_steering: false,
departure: "2128-05-20T12:00".into(),
arrival: None,
@ -567,7 +632,7 @@ mod test {
distance_in_km: None,
comments: None,
logtype: None,
rowers: Vec::new(),
rowers: vec![5],
},
&User::find_by_id(&pool, 5).await.unwrap(),
)
@ -585,6 +650,7 @@ mod test {
LogToAdd {
boat_id: 3,
shipmaster: 5,
steering_person: 5,
shipmaster_only_steering: false,
departure: "2128-05-20T12:00".into(),
arrival: Some("2128-05-20T11:00".into()),
@ -592,17 +658,17 @@ mod test {
distance_in_km: None,
comments: None,
logtype: None,
rowers: Vec::new(),
rowers: vec![5],
},
&User::find_by_id(&pool, 5).await.unwrap(),
)
.await;
assert_eq!(res, Err(LogbookCreateError::ArrivalNotAfterDeparture));
assert_eq!(res, Err(LogbookCreateError::ArrivalSetButNotRemainingTwo));
}
#[sqlx::test]
fn test_create_shipmaster_on_water() {
fn test_create_shipmaster_not_in_rowers() {
let pool = testdb!();
let res = Logbook::create(
@ -610,6 +676,7 @@ mod test {
LogToAdd {
boat_id: 3,
shipmaster: 2,
steering_person: 2,
shipmaster_only_steering: false,
departure: "2128-05-20T12:00".into(),
arrival: None,
@ -623,11 +690,11 @@ mod test {
)
.await;
assert_eq!(res, Err(LogbookCreateError::ShipmasterAlreadyOnWater));
assert_eq!(res, Err(LogbookCreateError::ShipmasterNotInRowers));
}
#[sqlx::test]
fn test_create_same_person_cox_and_rower() {
fn test_create_steering_person_not_in_rowers() {
let pool = testdb!();
let res = Logbook::create(
@ -635,6 +702,7 @@ mod test {
LogToAdd {
boat_id: 3,
shipmaster: 5,
steering_person: 1,
shipmaster_only_steering: false,
departure: "2128-05-20T12:00".into(),
arrival: None,
@ -648,7 +716,7 @@ mod test {
)
.await;
assert_eq!(res, Err(LogbookCreateError::SamePersonShipmasterAndRower));
assert_eq!(res, Err(LogbookCreateError::SteeringPersonNotInRowers));
}
#[sqlx::test]
@ -660,6 +728,7 @@ mod test {
LogToAdd {
boat_id: 1,
shipmaster: 5,
steering_person: 5,
shipmaster_only_steering: false,
departure: "2128-05-20T12:00".into(),
arrival: None,
@ -667,7 +736,7 @@ mod test {
distance_in_km: None,
comments: None,
logtype: None,
rowers: vec![1],
rowers: vec![1, 5],
},
&User::find_by_id(&pool, 5).await.unwrap(),
)
@ -707,7 +776,12 @@ mod test {
distance_in_km: 42,
comments: Some("Perfect water".into()),
logtype: None,
rowers: vec![],
rowers: vec![2],
shipmaster: 2,
steering_person: 2,
shipmaster_only_steering: false,
departure: "1990-01-01T10:00".into(),
arrival: "1990-01-01T12:00".into(),
},
)
.await
@ -730,7 +804,12 @@ mod test {
distance_in_km: 42,
comments: Some("Perfect water".into()),
logtype: None,
rowers: vec![],
rowers: vec![1],
shipmaster: 1,
steering_person: 1,
shipmaster_only_steering: false,
departure: "1990-01-01T10:00".into(),
arrival: "1990-01-01T12:00".into(),
},
)
.await;
@ -754,7 +833,12 @@ mod test {
distance_in_km: 42,
comments: Some("Perfect water".into()),
logtype: None,
rowers: vec![1],
rowers: vec![1, 2],
shipmaster: 2,
steering_person: 2,
shipmaster_only_steering: false,
departure: "1990-01-01T10:00".into(),
arrival: "1990-01-01T12:00".into(),
},
)
.await;

41
src/model/stat.rs
View File

@ -9,25 +9,36 @@ pub struct Stat {
}
impl Stat {
pub async fn get_rowed_km(db: &SqlitePool) -> Vec<Stat> {
pub async fn boats(db: &SqlitePool) -> Vec<Stat> {
//TODO: switch to query! macro again (once upgraded to sqlite 3.42 on server)
sqlx::query(
"
SELECT u.name, CAST(SUM(sub.distance_in_km) AS INTEGER) AS rowed_km
SELECT (SELECT name FROM boat WHERE id=logbook.boat_id) as name, CAST(SUM(distance_in_km) AS INTEGER) AS rowed_km
FROM logbook
GROUP BY boat_id
ORDER BY rowed_km DESC;
",
)
.fetch_all(db)
.await
.unwrap()
.into_iter()
.map(|row| Stat {
name: row.get("name"),
rowed_km: row.get("rowed_km"),
})
.collect()
}
pub async fn people(db: &SqlitePool) -> Vec<Stat> {
//TODO: switch to query! macro again (once upgraded to sqlite 3.42 on server)
sqlx::query(
"
SELECT u.name, CAST(SUM(l.distance_in_km) AS INTEGER) AS rowed_km
FROM user u
INNER JOIN (
SELECT r.rower_id AS user_id, l.distance_in_km
FROM logbook l
INNER JOIN rower r ON l.id = r.logbook_id
WHERE l.distance_in_km IS NOT NULL
UNION ALL
SELECT l.shipmaster AS user_id, l.distance_in_km
FROM logbook l
WHERE l.distance_in_km IS NOT NULL
) sub ON u.id = sub.user_id
WHERE u.is_guest = false
INNER JOIN rower r ON u.id = r.rower_id
INNER JOIN logbook l ON r.logbook_id = l.id
WHERE u.is_guest = 0 AND l.distance_in_km IS NOT NULL
GROUP BY u.name
ORDER BY rowed_km DESC;
",

17
src/model/user.rs
View File

@ -11,7 +11,7 @@ use rocket::{
Request,
};
use serde::{Deserialize, Serialize};
use sqlx::{FromRow, SqlitePool};
use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
use super::{log::Log, tripdetails::TripDetails, Day};
@ -103,6 +103,21 @@ WHERE id like ?
.ok()
}
pub async fn find_by_id_tx(db: &mut Transaction<'_, Sqlite>, id: i32) -> Option<Self> {
sqlx::query_as!(
Self,
"
SELECT id, name, pw, is_cox, is_admin, is_guest, deleted, last_access, is_tech
FROM user
WHERE id like ?
",
id
)
.fetch_one(db)
.await
.ok()
}
pub async fn find_by_name(db: &SqlitePool, name: &str) -> Option<Self> {
sqlx::query_as!(
Self,