use chrono::{NaiveDateTime, TimeZone}; use chrono_tz::Europe::Vienna; use rocket::FromForm; use serde::Serialize; use sqlx::{FromRow, Sqlite, SqlitePool, Transaction}; use super::{boat::Boat, log::Log, rower::Rower, user::User}; #[derive(FromRow, Serialize, Clone, Debug)] 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, pub arrival: Option, pub destination: Option, pub distance_in_km: Option, pub comments: Option, pub logtype: Option, } impl PartialEq for Logbook { fn eq(&self, other: &Self) -> bool { self.id == other.id } } #[derive(FromForm, Debug)] 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, pub destination: Option, pub distance_in_km: Option, pub comments: Option, pub logtype: Option, pub rowers: Vec, } #[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, pub logtype: Option, pub rowers: Vec, } #[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, } #[derive(Debug, PartialEq)] pub enum LogbookUpdateError { NotYourEntry, TooManyRowers(usize, usize), RowerCreateError(i64, String), ArrivalNotAfterDeparture, } #[derive(Debug, PartialEq)] pub enum LogbookDeleteError { NotYourEntry, } #[derive(Debug, PartialEq)] pub enum LogbookCreateError { ArrivalSetButNoDestination, UserNotAllowedToUseBoat, ArrivalSetButNoDistance, BoatAlreadyOnWater, BoatLocked, BoatNotFound, TooManyRowers(usize, usize), ShipmasterAlreadyOnWater, RowerAlreadyOnWater(User), RowerCreateError(i64, String), SamePersonShipmasterAndRower, ArrivalNotAfterDeparture, } impl Logbook { pub async fn find_by_id(db: &SqlitePool, id: i32) -> Option { sqlx::query_as!( Self, " SELECT id,boat_id,shipmaster,steering_person,shipmaster_only_steering,departure,arrival,destination,distance_in_km,comments,logtype FROM logbook WHERE id like ? ", id ) .fetch_one(db) .await .ok() } pub async fn on_water(db: &SqlitePool) -> Vec { let rows = sqlx::query!( " 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 " ) .fetch_all(db) .await .unwrap(); //TODO: fixme let logs: Vec = rows .into_iter() .map(|row| Logbook { 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, destination: row.destination, distance_in_km: row.distance_in_km, comments: row.comments, logtype: row.logtype, }) .collect(); let mut ret = Vec::new(); for log in logs { ret.push(LogbookWithBoatAndRowers { 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, }); } ret } pub async fn completed(db: &SqlitePool) -> Vec { let logs = sqlx::query_as!( Logbook, " 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 " ) .fetch_all(db) .await .unwrap(); //TODO: fixme let mut ret = Vec::new(); for log in logs { ret.push(LogbookWithBoatAndRowers { 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, }); } ret } pub async fn create( db: &SqlitePool, log: LogToAdd, created_by_user: &User, ) -> Result<(), LogbookCreateError> { let Some(boat) = Boat::find_by_id(db, log.boat_id).await else { return Err(LogbookCreateError::BoatNotFound); }; if boat.is_locked(db).await { return Err(LogbookCreateError::BoatLocked); } if boat.on_water(db).await { 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 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 { return Err(LogbookCreateError::TooManyRowers( boat.amount_seats as usize, log.rowers.len() + 1, )); } 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)); } } if !boat.shipmaster_allowed(created_by_user).await { return Err(LogbookCreateError::UserNotAllowedToUseBoat); } //let departure = format!("{}+02:00", &log.departure); Log::create(db, format!("New trip started: {log:?}")).await; 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, 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, log.destination, log.distance_in_km, log.comments, log.logtype ) .fetch_one(&mut tx) .await.unwrap(); for rower in &log.rowers { Rower::create(&mut tx, inserted_row.id, *rower) .await .map_err(|e| LogbookCreateError::RowerCreateError(*rower, e.to_string()))?; } tx.commit().await.unwrap(); Ok(()) } pub async fn distances(db: &SqlitePool) -> Vec<(String, i64)> { let result = sqlx::query!("SELECT destination, distance_in_km FROM logbook WHERE id IN (SELECT MIN(id) FROM logbook GROUP BY destination) AND destination IS NOT NULL AND distance_in_km IS NOT NULL;") .fetch_all(db) .await .unwrap(); result .into_iter() .filter_map(|r| { if let (Some(destination), Some(distance_in_km)) = (r.destination, r.distance_in_km) { Some((destination, distance_in_km)) } else { None } }) .collect() } async fn remove_rowers(&self, db: &mut Transaction<'_, Sqlite>) { sqlx::query!("DELETE FROM rower WHERE logbook_id=?", self.id) .execute(db) .await .unwrap(); } #[cfg(test)] pub async fn highest_id(db: &SqlitePool) -> i32 { sqlx::query!("SELECT max(id) as id FROM logbook") .fetch_one(db) .await .unwrap() .id .unwrap() } pub async fn home( &self, db: &SqlitePool, user: &User, log: LogToFinalize, ) -> Result<(), LogbookUpdateError> { 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.len() > boat.amount_seats as usize - 1 { return Err(LogbookUpdateError::TooManyRowers( boat.amount_seats as usize, log.rowers.len() + 1, )); } 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 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; for rower in &log.rowers { Rower::create(&mut tx, self.id, *rower) .await .map_err(|e| LogbookUpdateError::RowerCreateError(*rower, e.to_string()))?; } tx.commit().await.unwrap(); Ok(()) } pub async fn delete(&self, db: &SqlitePool, user: &User) -> Result<(), LogbookDeleteError> { Log::create(db, format!("{user:?} deleted trip: {self:?}")).await; if user.is_admin || user.id == self.shipmaster { sqlx::query!("DELETE FROM logbook WHERE id=?", self.id) .execute(db) .await .unwrap(); //Okay, because we can only create a Logbook of a valid id return Ok(()); } Err(LogbookDeleteError::NotYourEntry) } } #[cfg(test)] mod test { use super::{LogToAdd, Logbook, LogbookCreateError, LogbookUpdateError}; use crate::model::user::User; use crate::testdb; use sqlx::SqlitePool; #[sqlx::test] fn test_find_correct_id() { let pool = testdb!(); let logbook = Logbook::find_by_id(&pool, 1).await.unwrap(); assert_eq!(logbook.id, 1); } #[sqlx::test] fn test_find_wrong_id() { let pool = testdb!(); let logbook = Logbook::find_by_id(&pool, 1337).await; assert_eq!(logbook, None); } #[sqlx::test] fn test_on_water() { let pool = testdb!(); let logbook = Logbook::find_by_id(&pool, 1).await.unwrap(); let logbook_with_details = Logbook::on_water(&pool).await; assert_eq!(logbook_with_details[0].logbook, logbook); } #[sqlx::test] fn test_completed() { let pool = testdb!(); let completed = Logbook::completed(&pool).await; assert_eq!( completed[0].logbook, Logbook::find_by_id(&pool, 3).await.unwrap() ); assert_eq!( completed[1].logbook, Logbook::find_by_id(&pool, 2).await.unwrap() ); } //#[sqlx::test] //fn test_all() { // let pool = testdb!(); // let res = Boat::all(&pool).await; // assert!(res.len() > 3); //} #[sqlx::test] fn test_succ_create() { let pool = testdb!(); Logbook::create( &pool, LogToAdd { boat_id: 3, shipmaster: 4, steering_person: 4, shipmaster_only_steering: false, departure: "2128-05-20T12:00".into(), arrival: None, destination: None, distance_in_km: None, comments: None, logtype: None, rowers: Vec::new(), }, &User::find_by_id(&pool, 4).await.unwrap(), ) .await .unwrap() } #[sqlx::test] fn test_create_boat_not_found() { let pool = testdb!(); let res = Logbook::create( &pool, LogToAdd { boat_id: 999, shipmaster: 5, steering_person: 5, shipmaster_only_steering: false, departure: "2128-05-20T12:00".into(), arrival: None, destination: None, distance_in_km: None, comments: None, logtype: None, rowers: Vec::new(), }, &User::find_by_id(&pool, 4).await.unwrap(), ) .await; assert_eq!(res, Err(LogbookCreateError::BoatNotFound)); } #[sqlx::test] fn test_create_boat_locked() { let pool = testdb!(); let res = Logbook::create( &pool, LogToAdd { boat_id: 5, shipmaster: 5, steering_person: 5, shipmaster_only_steering: false, departure: "2128-05-20T12:00".into(), arrival: None, destination: None, distance_in_km: None, comments: None, logtype: None, rowers: Vec::new(), }, &User::find_by_id(&pool, 4).await.unwrap(), ) .await; assert_eq!(res, Err(LogbookCreateError::BoatLocked)); } #[sqlx::test] fn test_create_boat_on_water() { let pool = testdb!(); let res = Logbook::create( &pool, LogToAdd { boat_id: 2, shipmaster: 5, steering_person: 5, shipmaster_only_steering: false, departure: "2128-05-20T12:00".into(), arrival: None, destination: None, distance_in_km: None, comments: None, logtype: None, rowers: Vec::new(), }, &User::find_by_id(&pool, 5).await.unwrap(), ) .await; assert_eq!(res, Err(LogbookCreateError::BoatAlreadyOnWater)); } #[sqlx::test] fn test_create_boat_on_water_wrong_arrival() { let pool = testdb!(); let res = Logbook::create( &pool, 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()), destination: None, distance_in_km: None, comments: None, logtype: None, rowers: Vec::new(), }, &User::find_by_id(&pool, 5).await.unwrap(), ) .await; assert_eq!(res, Err(LogbookCreateError::ArrivalNotAfterDeparture)); } #[sqlx::test] fn test_create_shipmaster_on_water() { let pool = testdb!(); let res = Logbook::create( &pool, LogToAdd { boat_id: 3, shipmaster: 2, steering_person: 2, shipmaster_only_steering: false, departure: "2128-05-20T12:00".into(), arrival: None, destination: None, distance_in_km: None, comments: None, logtype: None, rowers: Vec::new(), }, &User::find_by_id(&pool, 2).await.unwrap(), ) .await; assert_eq!(res, Err(LogbookCreateError::ShipmasterAlreadyOnWater)); } #[sqlx::test] fn test_create_same_person_cox_and_rower() { let pool = testdb!(); let res = Logbook::create( &pool, LogToAdd { boat_id: 3, shipmaster: 5, steering_person: 5, shipmaster_only_steering: false, departure: "2128-05-20T12:00".into(), arrival: None, destination: None, distance_in_km: None, comments: None, logtype: None, rowers: vec![5], }, &User::find_by_id(&pool, 5).await.unwrap(), ) .await; assert_eq!(res, Err(LogbookCreateError::SamePersonShipmasterAndRower)); } #[sqlx::test] fn test_create_too_many_rowers() { let pool = testdb!(); let res = Logbook::create( &pool, LogToAdd { boat_id: 1, shipmaster: 5, steering_person: 5, shipmaster_only_steering: false, departure: "2128-05-20T12:00".into(), arrival: None, destination: None, distance_in_km: None, comments: None, logtype: None, rowers: vec![1], }, &User::find_by_id(&pool, 5).await.unwrap(), ) .await; assert_eq!(res, Err(LogbookCreateError::TooManyRowers(1, 2))); } #[sqlx::test] fn test_distances() { let pool = testdb!(); let res = Logbook::distances(&pool).await; assert_eq!( res, vec![ ("Ottensheim".into(), 25 as i64), ("Ottensheim + Regattastrecke".into(), 29 as i64), ] ); } #[sqlx::test] fn test_succ_home() { let pool = testdb!(); let logbook = Logbook::find_by_id(&pool, 1).await.unwrap(); let user = User::find_by_id(&pool, 2).await.unwrap(); logbook .home( &pool, &user, super::LogToFinalize { destination: "new-destination".into(), distance_in_km: 42, comments: Some("Perfect water".into()), logtype: None, rowers: vec![], shipmaster: 2, steering_person: 2, shipmaster_only_steering: false, departure: "1990-01-01T10:00".into(), arrival: "1990-01-01T12:00".into(), }, ) .await .unwrap(); } #[sqlx::test] fn test_home_wrong_user() { let pool = testdb!(); let logbook = Logbook::find_by_id(&pool, 1).await.unwrap(); let user = User::find_by_id(&pool, 1).await.unwrap(); let res = logbook .home( &pool, &user, super::LogToFinalize { destination: "new-destination".into(), distance_in_km: 42, comments: Some("Perfect water".into()), logtype: None, rowers: vec![], shipmaster: 1, steering_person: 1, shipmaster_only_steering: false, departure: "1990-01-01T10:00".into(), arrival: "1990-01-01T12:00".into(), }, ) .await; assert_eq!(res, Err(LogbookUpdateError::NotYourEntry)); } #[sqlx::test] fn test_home_too_many_rower() { let pool = testdb!(); let logbook = Logbook::find_by_id(&pool, 1).await.unwrap(); let user = User::find_by_id(&pool, 2).await.unwrap(); let res = logbook .home( &pool, &user, super::LogToFinalize { destination: "new-destination".into(), distance_in_km: 42, comments: Some("Perfect water".into()), logtype: None, rowers: vec![1], shipmaster: 2, steering_person: 2, shipmaster_only_steering: false, departure: "1990-01-01T10:00".into(), arrival: "1990-01-01T12:00".into(), }, ) .await; assert_eq!(res, Err(LogbookUpdateError::TooManyRowers(1, 2))); } }