sgd-praktikum/src/sql/bookings.rs

use hyper::StatusCode;
use sibyl::Row;

use crate::{ServiceInner, model::{Booking, BookingBody, Room, Person}, error::ServiceError};

impl ServiceInner {

    pub async fn get_bookings(&self) -> Result<Vec<Booking>, ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
            SELECT 
                bookingId, 
                TO_CHAR(arrivalDate, 'YYYY-MM-DD'), 
                TO_CHAR(departureDate, 'YYYY-MM-DD'), 
                cost, 
                pensionType,
                clientId
            FROM BOOKING
        ").await?;

        let rows = stmt.query("").await?;

        let mut bookings: Vec<Booking> = vec![];

        while let Some(row) = rows.next().await? {
            bookings.push(Self::map_booking_row(row)?);
        }

        Ok(bookings)
    }

    pub async fn get_last_bookings(&self, months: i32) -> Result<Vec<Booking>, ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
            SELECT 
                bookingId, 
                TO_CHAR(arrivalDate, 'YYYY-MM-DD'), 
                TO_CHAR(departureDate, 'YYYY-MM-DD'), 
                cost, 
                pensionType,
                clientId
            FROM table(getLastBookings(:MONTHS)) bkk 
            INNER JOIN BOOKING bk ON bkk.COLUMN_VALUE = bk.bookingId
        ").await?;

        let rows = stmt.query(months).await?;

        let mut bookings: Vec<Booking> = vec![];

        while let Some(row) = rows.next().await? {
            bookings.push(Self::map_booking_row(row)?);
        }

        Ok(bookings)
    }

    pub async fn get_booking(&self, id: i32) -> Result<Option<Booking>, ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
            SELECT 
                bookingId, 
                TO_CHAR(arrivalDate, 'YYYY-MM-DD'), 
                TO_CHAR(departureDate, 'YYYY-MM-DD'), 
                cost, 
                pensionType,
                clientId
            FROM BOOKING WHERE bookingId = :ID
        ").await?;

        let row = stmt.query_single(id).await?;

        Ok(match row {
            Some(row) => {
                Some(Self::map_booking_row(row)?)
            },
            None => None,
        })
    }

    pub async fn add_booking(&self, booking: BookingBody) -> Result<i32, ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
        INSERT INTO BOOKING 
            (
                bookingId,
                arrivalDate,
                departureDate,
                cost,
                pensionType,
                lateCheckout,
                clientId
            )
        VALUES 
            (
                BOOKING_SEQ.nextval, 
                TO_DATE(:ARRDATE, 'YYYY-MM-DD'), 
                TO_DATE(:DEPDATE, 'YYYY-MM-DD'), 
                :COST, 
                :PENSION, 
                0, 
                :CLIENT
            )
        ").await?;
        stmt.execute((
            (":ARRDATE", booking.arrival_date),
            (":DEPDATE", booking.depature_date),
            (":COST", booking.cost),
            (":PENSION", booking.pension_type),
            (":CLIENT", booking.client_id)
        )).await?;
        let stmt = session.prepare("SELECT BOOKING_SEQ.currval FROM dual").await?;
        let row = stmt.query_single("").await?
        .ok_or_else(|| ServiceError::ErrorResponse(StatusCode::INTERNAL_SERVER_ERROR, None))?;
        let id: i32 = row.get(0)?;
        session.commit().await?;
        Ok(id)
    }

    pub async fn delete_booking(&self, booking: i32) -> Result<(), ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
            DELETE FROM Booking WHERE bookingId = :BOOKING
        ").await?;
        stmt.execute(booking).await?;
        session.commit().await?;
        Ok(())
    }

    pub async fn update_booking(&self, id: i32, booking: BookingBody) -> Result<(), ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
        UPDATE BOOKING SET
            arrivalDate = TO_DATE(:ARRDATE, 'YYYY-MM-DD'),
            departureDate = TO_DATE(:DEPDATE, 'YYYY-MM-DD'),
            cost = :COST,
            pensionType = :PENSION,
            clientId = :CLIENT
        WHERE bookingId = :ID
        ").await?;
        stmt.execute((
            (":ID", id),
            (":ARRDATE", booking.arrival_date),
            (":DEPDATE", booking.depature_date),
            (":COST", booking.cost),
            (":PENSION", booking.pension_type),
            (":CLIENT", booking.client_id)
        )).await?;
        session.commit().await?;
        Ok(())
    }

    pub async fn get_rooms_for_booking(&self, booking: i32) -> Result<Vec<Room>, ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
            SELECT
                r.roomNumber,
                floor,
                roomTyp,
                \"size\",
                accessibility,
                beds
            FROM room r 
            INNER JOIN BookingRoom br ON r.roomNumber = br.roomNumber 
            WHERE br.bookingId = :BOOKING
        ").await?;

        let rows = stmt.query(booking).await?;

        let mut rooms: Vec<Room> = vec![];

        while let Some(row) = rows.next().await? {
            rooms.push(Self::map_room_row(row)?);
        }
        
        Ok(rooms)
    }

    pub async fn get_guests_for_booking(&self, booking: i32) -> Result<Vec<Person>, ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
            SELECT
                p.personId,
                p.name,
                p.lastName,
                p.age,
                ad.street,
                ad.houseNumber,
                ad.postalCode,
                ad.city,
                ad.country
            FROM person p
            INNER JOIN Address ad ON p.addressId = ad.addressId
            INNER JOIN BookingGuest bg ON p.personId = bg.personId 
            WHERE bg.bookingId = :BOOKING
        ").await?;

        let rows = stmt.query(booking).await?;

        let mut persons: Vec<Person> = vec![];

        while let Some(row) = rows.next().await? {
            persons.push(Self::map_person_row(row, 0)?);
        }
        
        Ok(persons)
    }

    pub async fn add_booking_room(&self, booking: i32, room: i32) -> Result<(), ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
            INSERT INTO BookingRoom (bookingId, roomNumber) VALUES (:BOOKING, :ROOM)
        ").await?;
        stmt.execute(((":BOOKING", booking), (":ROOM", room))).await?;
        session.commit().await?;
        Ok(())
    }

    pub async fn add_booking_guest(&self, booking: i32, guest: i32) -> Result<(), ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
            INSERT INTO BookingGuest (bookingId, personId) VALUES (:BOOKING, :GUEST)
        ").await?;
        stmt.execute(((":BOOKING", booking), (":GUEST", guest))).await?;
        session.commit().await?;
        Ok(())
    }

    pub async fn delete_booking_room(&self, booking: i32, room: i32) -> Result<(), ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
            DELETE FROM BookingRoom WHERE bookingId = :BOOKING AND roomNumber = :ROOM
        ").await?;
        stmt.execute(((":BOOKING", booking), (":ROOM", room))).await?;
        session.commit().await?;
        Ok(())
    }

    pub async fn delete_booking_guest(&self, booking: i32, guest: i32) -> Result<(), ServiceError> {
        let session = self.pool.get_session().await?;
        let stmt = session.prepare("
            DELETE FROM BookingGuest WHERE bookingId = :BOOKING AND personId = :GUEST
        ").await?;
        stmt.execute(((":BOOKING", booking), (":GUEST", guest))).await?;
        session.commit().await?;
        Ok(())
    }

    pub fn map_booking_row(row: Row) -> Result<Booking, ServiceError> {
        Ok(Booking {
            id: row.get(0)?,
            arrival_date: row.get(1)?,
            depature_date: row.get(2)?,
            cost: row.get(3)?,
            pension_type: row.get(4)?,
            client_id: row.get(5)?,
        })
    }

}