hacky-ruadat/src/model/tripdetails.rs

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

#[derive(FromRow, Debug, Serialize, Deserialize)]
pub struct TripDetails {
    pub id: i64,
    planned_starting_time: String,
    max_people: i64,
    day: String,
    notes: Option<String>,
    pub allow_guests: bool,
    trip_type_id: Option<i64>,
}

impl TripDetails {
    pub async fn find_by_id(db: &SqlitePool, id: i64) -> Option<Self> {
        sqlx::query_as!(
            TripDetails,
            "
SELECT id, planned_starting_time, max_people, day, notes, allow_guests, trip_type_id
FROM trip_details 
WHERE id like ?
        ",
            id
        )
        .fetch_one(db)
        .await
        .ok()
    }

    /// Creates a new entry in `trip_details` and returns its id.
    pub async fn create(
        db: &SqlitePool,
        planned_starting_time: &str,
        max_people: i32,
        day: &str,
        notes: Option<&str>,
        allow_guests: bool,
        trip_type_id: Option<i64>,
    ) -> i64 {
        let query = sqlx::query!(
            "INSERT INTO trip_details(planned_starting_time, max_people, day, notes, allow_guests, trip_type_id) VALUES(?, ?, ?, ?, ?, ?)" ,
            planned_starting_time,
            max_people,
            day,
            notes,
            allow_guests,
            trip_type_id
        )
        .execute(db)
        .await
        .unwrap(); //Okay, TripDetails can only be created if self.id exists
        query.last_insert_rowid()
    }

    pub async fn is_full(&self, db: &SqlitePool) -> bool {
        let amount_currently_registered = sqlx::query!(
            "SELECT COUNT(*) as count FROM user_trip WHERE trip_details_id = ?",
            self.id
        )
        .fetch_one(db)
        .await
        .unwrap(); //TODO: fixme
        let amount_currently_registered = i64::from(amount_currently_registered.count);

        amount_currently_registered >= self.max_people
    }
}

#[cfg(test)]
mod test {
    use crate::testdb;

    use super::TripDetails;
    use sqlx::SqlitePool;

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

        assert!(TripDetails::find_by_id(&pool, 1).await.is_some());
    }

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

        assert!(TripDetails::find_by_id(&pool, 1337).await.is_none());
    }

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

        assert_eq!(
            TripDetails::create(
                &pool,
                "10:00".into(),
                2,
                "1970-01-01".into(),
                None,
                false,
                None
            )
            .await,
            3,
        );
        assert_eq!(
            TripDetails::create(
                &pool,
                "10:00".into(),
                2,
                "1970-01-01".into(),
                None,
                false,
                None
            )
            .await,
            4,
        );
    }

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

        let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
        assert_eq!(trip_details.is_full(&pool).await, false);
    }

    #[sqlx::test]
    fn test_true_full() {
        //TODO: register user for trip_details = 1; check if is_full returns true
    }

    //TODO: add new tripdetails test with trip_type != None
}