rowt/src/model/boat.rs

use rocket::FromForm;
use serde::{Deserialize, Serialize};
use sqlx::{FromRow, SqlitePool};

#[derive(FromRow, Debug, Serialize, Deserialize)]
pub struct Boat {
    pub id: i64,
    pub name: String,
    pub amount_seats: i64,
    pub location_id: i64,
    pub owner: Option<i64>,
    pub year_built: Option<i64>,
    pub boatbuilder: Option<String>,
    #[serde(default = "bool::default")]
    default_shipmaster_only_steering: bool,
    #[serde(default = "bool::default")]
    skull: bool,
    #[serde(default = "bool::default")]
    external: bool,
}

#[derive(FromForm)]
pub struct BoatToAdd<'r> {
    pub name: &'r str,
    pub amount_seats: i64,
    pub year_built: Option<i64>,
    pub boatbuilder: Option<&'r str>,
    pub default_shipmaster_only_steering: bool,
    pub skull: bool,
    pub external: bool,
    pub location_id: Option<i64>,
    pub owner: Option<i64>,
}

#[derive(FromForm)]
pub struct BoatToUpdate<'r> {
    pub id: i32,
    pub name: &'r str,
    pub amount_seats: i64,
    pub year_built: Option<i64>,
    pub boatbuilder: Option<&'r str>,
    pub default_shipmaster_only_steering: bool,
    pub skull: bool,
    pub external: bool,
    pub location_id: Option<i64>,
    pub owner: Option<i64>,
}

impl Boat {
    pub async fn find_by_id(db: &SqlitePool, id: i32) -> Option<Self> {
        sqlx::query_as!(
            Self,
            "SELECT id, name, amount_seats, location_id, owner, year_built, boatbuilder, default_shipmaster_only_steering, skull, external 
             FROM boat 
             WHERE id like ?",
            id
        )
        .fetch_one(db)
        .await
        .ok()
    }

    pub async fn is_locked(&self, db: &SqlitePool) -> bool {
        sqlx::query!("SELECT * FROM boat_damage WHERE boat_id=? AND lock_boat=true AND user_id_verified is null", self.id).fetch_optional(db).await.unwrap().is_some()
    }

    pub async fn on_water(&self, db: &SqlitePool) -> bool {
        sqlx::query!(
            "SELECT * FROM logbook WHERE boat_id=? AND arrival is null",
            self.id
        )
        .fetch_optional(db)
        .await
        .unwrap()
        .is_some()
    }

    pub async fn all(db: &SqlitePool) -> Vec<Self> {
        sqlx::query_as!(
            Boat,
            "
SELECT id, name, amount_seats, location_id, owner, year_built, boatbuilder, default_shipmaster_only_steering, skull, external 
FROM boat 
ORDER BY amount_seats DESC
        "
        )
        .fetch_all(db)
        .await
        .unwrap() //TODO: fixme
    }

    pub async fn create(db: &SqlitePool, boat: BoatToAdd<'_>) -> bool {
        sqlx::query!(
            "INSERT INTO boat(name, amount_seats, year_built, boatbuilder, default_shipmaster_only_steering, skull, external, location_id, owner) VALUES (?,?,?,?,?,?,?,?,?)",
            boat.name,
            boat.amount_seats,
            boat.year_built,
            boat.boatbuilder,
            boat.default_shipmaster_only_steering,
            boat.skull,
            boat.external,
            boat.location_id,
            boat.owner
        )
        .execute(db)
        .await.is_ok()
    }

    pub async fn update(&self, db: &SqlitePool, boat: BoatToUpdate<'_>) -> bool {
        sqlx::query!(
            "UPDATE boat SET name=?, amount_seats=?, year_built=?, boatbuilder=?, default_shipmaster_only_steering=?, skull=?, external=?, location_id=?, owner=? WHERE id=?",
        boat.name,
        boat.amount_seats,
        boat.year_built,
        boat.boatbuilder,
        boat.default_shipmaster_only_steering,
        boat.skull,
        boat.external,
        boat.location_id,
        boat.owner,
            self.id
        )
        .execute(db)
        .await
        .is_ok()
    }

    pub async fn delete(&self, db: &SqlitePool) {
        sqlx::query!("DELETE FROM boat WHERE id=?", self.id)
            .execute(db)
            .await
            .unwrap(); //Okay, because we can only create a Boat of a valid id
    }
}

#[cfg(test)]
mod test {
    use crate::{
        model::boat::{Boat, BoatToAdd},
        testdb,
    };

    use sqlx::SqlitePool;

    #[sqlx::test]
    fn test_find_correct_id() {
        let pool = testdb!();
        let boat = Boat::find_by_id(&pool, 1).await.unwrap();
        assert_eq!(boat.id, 1);
    }

    #[sqlx::test]
    fn test_find_wrong_id() {
        let pool = testdb!();
        let boat = Boat::find_by_id(&pool, 1337).await;
        assert!(boat.is_none());
    }

    #[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!();

        assert_eq!(
            Boat::create(
                &pool,
                BoatToAdd {
                    name: "new-boat-name".into(),
                    amount_seats: 42,
                    year_built: None,
                    boatbuilder: "Best Boatbuilder".into(),
                    default_shipmaster_only_steering: true,
                    skull: true,
                    external: false,
                    location_id: Some(1),
                    owner: None
                }
            )
            .await,
            true
        );
    }

    #[sqlx::test]
    fn test_duplicate_name_create() {
        let pool = testdb!();

        assert_eq!(
            Boat::create(
                &pool,
                BoatToAdd {
                    name: "Haichenbach".into(),
                    amount_seats: 42,
                    year_built: None,
                    boatbuilder: "Best Boatbuilder".into(),
                    default_shipmaster_only_steering: true,
                    skull: true,
                    external: false,
                    location_id: Some(1),
                    owner: None
                }
            )
            .await,
            false
        );
    }
}