149 lines
3.6 KiB
Go
149 lines
3.6 KiB
Go
package dbrepo
|
|
|
|
import (
|
|
"context"
|
|
"go-udemy-web-1/internal/models"
|
|
"time"
|
|
)
|
|
|
|
func (m *postgresDBRepo) AllUsers() bool {
|
|
return true
|
|
}
|
|
|
|
// InsertReservation inserts a reservation into the database
|
|
func (m *postgresDBRepo) InsertReservation(res models.Reservation) (int, error) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
|
|
var newId int
|
|
// statement
|
|
stmt := `insert into reservations (first_name, last_name, email, phone,
|
|
start_date, end_date, room_id, created_at, updated_at)
|
|
values ($1, $2, $3, $4, $5, $6, $7, $8, $9) returning id`
|
|
|
|
row := m.DB.QueryRowContext(ctx, stmt,
|
|
res.FirstName,
|
|
res.LastName,
|
|
res.Email,
|
|
res.Phone,
|
|
res.StartDate,
|
|
res.EndDate,
|
|
res.RoomID,
|
|
time.Now(),
|
|
time.Now())
|
|
|
|
err := row.Scan(&newId)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return newId, nil
|
|
}
|
|
|
|
// InsertRoomRestriction inserts a room restriction into the database
|
|
func (m *postgresDBRepo) InsertRoomRestriction(r models.RoomRestriction) error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
|
|
stmt := `insert into room_restrictions (
|
|
start_date, end_date, room_id, reservation_id, restriction_id,
|
|
created_at, updated_at)
|
|
values ($1, $2, $3, $4, $5, $6, $7)`
|
|
|
|
_, err := m.DB.ExecContext(ctx, stmt,
|
|
r.StartDate,
|
|
r.EndDate,
|
|
r.RoomID,
|
|
r.ReservationID,
|
|
r.RestrictionID,
|
|
time.Now(),
|
|
time.Now())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SearchAvailabilityByDatesByRoomID returns true if availability exists for roomID, and false if no availability
|
|
func (m *postgresDBRepo) SearchAvailabilityByDatesByRoomID(start, end time.Time, roomID int) (bool, error) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
|
|
var numRows int
|
|
stmt := `select count(id) from room_restrictions
|
|
where room_id = $1 and
|
|
$2 < end_date and $3> start_date`
|
|
|
|
row := m.DB.QueryRowContext(ctx, stmt, roomID, start, end)
|
|
err := row.Scan(&numRows)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
if numRows == 0 {
|
|
return true, nil
|
|
}
|
|
|
|
return false, nil
|
|
}
|
|
|
|
// SearchAvailabilityForAllRooms returns a slice of rooms, if any, for given date range
|
|
func (m *postgresDBRepo) SearchAvailabilityForAllRooms(start, end time.Time) ([]models.Room, error) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
|
|
var rooms []models.Room
|
|
stmt := `select
|
|
r.id, r.room_name
|
|
from
|
|
rooms r
|
|
where r.id not in
|
|
(select
|
|
room_id
|
|
from
|
|
room_restrictions rr
|
|
where
|
|
$1 < rr.end_date and $2> rr.start_date)`
|
|
|
|
rows, err := m.DB.QueryContext(ctx, stmt, start, end)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for rows.Next() {
|
|
var room models.Room
|
|
|
|
err := rows.Scan(&room.ID, &room.RoomName)
|
|
if err != nil {
|
|
return rooms, err
|
|
}
|
|
rooms = append(rooms, room)
|
|
}
|
|
|
|
if err = rows.Err(); err != nil {
|
|
return rooms, err
|
|
}
|
|
|
|
return rooms, nil
|
|
}
|
|
|
|
// GetRoomById gets a room by id
|
|
func (m *postgresDBRepo) GetRoomById(id int) (models.Room, error) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
|
|
var room models.Room
|
|
stmt := `select
|
|
id, room_name, created_at, updated_at
|
|
from
|
|
rooms
|
|
where id = $1`
|
|
|
|
row := m.DB.QueryRowContext(ctx, stmt, id)
|
|
err := row.Scan(&room.ID, &room.RoomName, &room.CreatedAt, &room.UpdatedAt)
|
|
if err != nil {
|
|
return room, err
|
|
}
|
|
return room, nil
|
|
}
|