clean code with clippy

src/model/logbook.rs

@@ -1,6 +1,7 @@
 use chrono::NaiveDateTime;
+use rocket::FromForm;
 use serde::Serialize;
-use sqlx::{FromRow, SqlitePool};
+use sqlx::{FromRow, Sqlite, SqlitePool, Transaction};
 
 use super::{boat::Boat, rower::Rower, user::User};
 
@@ -19,6 +20,29 @@ pub struct Logbook {
     pub logtype: Option<i64>,
 }
 
+#[derive(FromForm)]
+pub struct LogToAdd {
+    pub boat_id: i32,
+    pub shipmaster: i64,
+    pub shipmaster_only_steering: bool,
+    pub departure: String,
+    pub arrival: Option<String>,
+    pub destination: Option<String>,
+    pub distance_in_km: Option<i64>,
+    pub comments: Option<String>,
+    pub logtype: Option<i64>,
+    pub rower: Vec<i64>,
+}
+
+#[derive(FromForm)]
+pub struct LogToFinalize {
+    pub destination: String,
+    pub distance_in_km: i64,
+    pub comments: Option<String>,
+    pub logtype: Option<i64>,
+    pub rower: Vec<i64>,
+}
+
 #[derive(Serialize)]
 pub struct LogbookWithBoatAndRowers {
     #[serde(flatten)]
@@ -56,21 +80,6 @@ impl Logbook {
         .ok()
     }
 
-    //    pub async fn find_by_name(db: &SqlitePool, name: &str) -> Option<Self> {
-    //        sqlx::query_as!(
-    //            User,
-    //            "
-    //SELECT id, name, pw, is_cox, is_admin, is_guest, deleted, last_access
-    //FROM user
-    //WHERE name like ?
-    //        ",
-    //            name
-    //        )
-    //        .fetch_one(db)
-    //        .await
-    //        .ok()
-    //    }
-    //
     pub async fn on_water(db: &SqlitePool) -> Vec<LogbookWithBoatAndRowers> {
         let logs = sqlx::query_as!(
                 Logbook,
@@ -123,20 +132,8 @@ impl Logbook {
         ret
     }
 
-    pub async fn create(
-        db: &SqlitePool,
-        boat_id: i32,
-        shipmaster: i64,
-        shipmaster_only_steering: bool,
-        departure: NaiveDateTime,
-        arrival: Option<NaiveDateTime>,
-        destination: Option<String>,
-        distance_in_km: Option<i64>,
-        comments: Option<String>,
-        logtype: Option<i64>,
-        rower: Vec<i64>,
-    ) -> Result<(), LogbookCreateError> {
-        let boat = match Boat::find_by_id(db, boat_id).await {
+    pub async fn create(db: &SqlitePool, log: LogToAdd) -> Result<(), LogbookCreateError> {
+        let boat = match Boat::find_by_id(db, log.boat_id).await {
             Some(b) => b,
             None => {
                 return Err(LogbookCreateError::BoatNotFound);
@@ -151,27 +148,44 @@ impl Logbook {
             return Err(LogbookCreateError::BoatAlreadyOnWater);
         }
 
-        if rower.len() > boat.amount_seats as usize - 1 {
+        if log.rower.len() > boat.amount_seats as usize - 1 {
             return Err(LogbookCreateError::TooManyRowers(
                 boat.amount_seats as usize,
-                rower.len() + 1,
+                log.rower.len() + 1,
             ));
         }
 
+        let mut tx = db.begin().await.unwrap();
+
+        let departure = NaiveDateTime::parse_from_str(&log.departure, "%Y-%m-%dT%H:%M").unwrap();
+        let arrival = log
+            .arrival
+            .map(|a| NaiveDateTime::parse_from_str(&a, "%Y-%m-%dT%H:%M").unwrap());
         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",
-                boat_id, shipmaster, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype
+                log.boat_id,
+                log.shipmaster,
+                log.shipmaster_only_steering,
+                departure,
+                arrival,
+                log.destination,
+                log.distance_in_km,
+                log.comments,
+                log.logtype
             )
-            .fetch_one(db)
+            .fetch_one(&mut tx)
             .await.unwrap();
 
-        for rower in &rower {
-            Rower::create(db, inserted_row.id, *rower).await;
+        for rower in &log.rower {
+            Rower::create(&mut tx, inserted_row.id, *rower).await;
         }
+
+        tx.commit().await.unwrap();
+
         Ok(())
     }
 
-    async fn remove_rowers(&self, db: &SqlitePool) {
+    async fn remove_rowers(&self, db: &mut Transaction<'_, Sqlite>) {
         sqlx::query!("DELETE FROM rower WHERE logbook_id=?", self.id)
             .execute(db)
             .await
@@ -182,11 +196,7 @@ impl Logbook {
         &self,
         db: &SqlitePool,
         user: &User,
-        destination: String,
-        distance_in_km: i64,
-        comments: Option<String>,
-        logtype: Option<i64>,
-        rower: Vec<i64>,
+        log: LogToFinalize,
     ) -> Result<(), LogbookUpdateError> {
         if user.id != self.shipmaster {
             return Err(LogbookUpdateError::NotYourEntry);
@@ -194,35 +204,37 @@ impl Logbook {
 
         let boat = Boat::find_by_id(db, self.boat_id as i32).await.unwrap(); //ok
 
-        if rower.len() > boat.amount_seats as usize - 1 {
+        if log.rower.len() > boat.amount_seats as usize - 1 {
             return Err(LogbookUpdateError::TooManyRowers(
                 boat.amount_seats as usize,
-                rower.len() + 1,
+                log.rower.len() + 1,
             ));
         }
 
-        //TODO: check current date
-
         let arrival = format!("{}", chrono::offset::Local::now().format("%Y-%m-%d %H:%M"));
 
+        let mut tx = db.begin().await.unwrap();
+
         sqlx::query!(
             "UPDATE logbook SET destination=?, distance_in_km=?, comments=?, logtype=?, arrival=? WHERE id=?",
-            destination,
-            distance_in_km,
-            comments,
-            logtype,
+            log.destination,
+            log.distance_in_km,
+            log.comments,
+            log.logtype,
             arrival,
             self.id
         )
-        .execute(db)
+        .execute(&mut tx)
         .await.unwrap(); //TODO: fixme
 
-        self.remove_rowers(db).await;
+        self.remove_rowers(&mut tx).await;
 
-        for rower in &rower {
-            Rower::create(db, self.id, *rower).await;
+        for rower in &log.rower {
+            Rower::create(&mut tx, self.id, *rower).await;
         }
 
+        tx.commit().await.unwrap();
+
         Ok(())
     }