582 lines
10 KiB
Go
582 lines
10 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.26.0
|
|
// source: query.sql
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const allNewReservations = `-- name: AllNewReservations :many
|
|
SELECT
|
|
r.id,
|
|
r.first_name,
|
|
r.last_name,
|
|
r.email,
|
|
r.phone,
|
|
r.start_date,
|
|
r.end_date,
|
|
r.room_id,
|
|
r.created_at,
|
|
r.updated_at,
|
|
r.processed,
|
|
rm.id,
|
|
rm.room_name
|
|
FROM
|
|
reservations r
|
|
LEFT JOIN rooms rm ON (r.room_id = rm.id)
|
|
WHERE
|
|
r.processed = 0
|
|
ORDER BY
|
|
r.start_date ASC
|
|
`
|
|
|
|
type AllNewReservationsRow struct {
|
|
ID int32
|
|
FirstName string
|
|
LastName string
|
|
Email string
|
|
Phone string
|
|
StartDate pgtype.Date
|
|
EndDate pgtype.Date
|
|
RoomID int32
|
|
CreatedAt pgtype.Timestamp
|
|
UpdatedAt pgtype.Timestamp
|
|
Processed int32
|
|
ID_2 pgtype.Int4
|
|
RoomName pgtype.Text
|
|
}
|
|
|
|
func (q *Queries) AllNewReservations(ctx context.Context) ([]AllNewReservationsRow, error) {
|
|
rows, err := q.db.Query(ctx, allNewReservations)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []AllNewReservationsRow
|
|
for rows.Next() {
|
|
var i AllNewReservationsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.FirstName,
|
|
&i.LastName,
|
|
&i.Email,
|
|
&i.Phone,
|
|
&i.StartDate,
|
|
&i.EndDate,
|
|
&i.RoomID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.Processed,
|
|
&i.ID_2,
|
|
&i.RoomName,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const allReservations = `-- name: AllReservations :many
|
|
SELECT
|
|
r.id,
|
|
r.first_name,
|
|
r.last_name,
|
|
r.email,
|
|
r.phone,
|
|
r.start_date,
|
|
r.end_date,
|
|
r.room_id,
|
|
r.created_at,
|
|
r.updated_at,
|
|
r.processed,
|
|
rm.id,
|
|
rm.room_name
|
|
FROM
|
|
reservations r
|
|
LEFT JOIN rooms rm ON (r.room_id = rm.id)
|
|
ORDER BY
|
|
r.start_date ASC
|
|
`
|
|
|
|
type AllReservationsRow struct {
|
|
ID int32
|
|
FirstName string
|
|
LastName string
|
|
Email string
|
|
Phone string
|
|
StartDate pgtype.Date
|
|
EndDate pgtype.Date
|
|
RoomID int32
|
|
CreatedAt pgtype.Timestamp
|
|
UpdatedAt pgtype.Timestamp
|
|
Processed int32
|
|
ID_2 pgtype.Int4
|
|
RoomName pgtype.Text
|
|
}
|
|
|
|
func (q *Queries) AllReservations(ctx context.Context) ([]AllReservationsRow, error) {
|
|
rows, err := q.db.Query(ctx, allReservations)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []AllReservationsRow
|
|
for rows.Next() {
|
|
var i AllReservationsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.FirstName,
|
|
&i.LastName,
|
|
&i.Email,
|
|
&i.Phone,
|
|
&i.StartDate,
|
|
&i.EndDate,
|
|
&i.RoomID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.Processed,
|
|
&i.ID_2,
|
|
&i.RoomName,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const allRooms = `-- name: AllRooms :many
|
|
SELECT
|
|
id,
|
|
room_name,
|
|
created_at,
|
|
updated_at
|
|
FROM
|
|
rooms
|
|
ORDER BY
|
|
room_name
|
|
`
|
|
|
|
func (q *Queries) AllRooms(ctx context.Context) ([]Room, error) {
|
|
rows, err := q.db.Query(ctx, allRooms)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Room
|
|
for rows.Next() {
|
|
var i Room
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.RoomName,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const deleteReservation = `-- name: DeleteReservation :exec
|
|
DELETE FROM reservations
|
|
WHERE
|
|
id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteReservation(ctx context.Context, id int32) error {
|
|
_, err := q.db.Exec(ctx, deleteReservation, id)
|
|
return err
|
|
}
|
|
|
|
const getReservationByID = `-- name: GetReservationByID :one
|
|
SELECT
|
|
r.id,
|
|
r.first_name,
|
|
r.last_name,
|
|
r.email,
|
|
r.phone,
|
|
r.start_date,
|
|
r.end_date,
|
|
r.room_id,
|
|
r.created_at,
|
|
r.updated_at,
|
|
r.processed,
|
|
rm.id,
|
|
rm.room_name
|
|
FROM
|
|
reservations r
|
|
LEFT JOIN rooms rm ON (r.room_id = rm.id)
|
|
WHERE
|
|
r.id = $1
|
|
`
|
|
|
|
type GetReservationByIDRow struct {
|
|
ID int32
|
|
FirstName string
|
|
LastName string
|
|
Email string
|
|
Phone string
|
|
StartDate pgtype.Date
|
|
EndDate pgtype.Date
|
|
RoomID int32
|
|
CreatedAt pgtype.Timestamp
|
|
UpdatedAt pgtype.Timestamp
|
|
Processed int32
|
|
ID_2 pgtype.Int4
|
|
RoomName pgtype.Text
|
|
}
|
|
|
|
func (q *Queries) GetReservationByID(ctx context.Context, id int32) (GetReservationByIDRow, error) {
|
|
row := q.db.QueryRow(ctx, getReservationByID, id)
|
|
var i GetReservationByIDRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.FirstName,
|
|
&i.LastName,
|
|
&i.Email,
|
|
&i.Phone,
|
|
&i.StartDate,
|
|
&i.EndDate,
|
|
&i.RoomID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.Processed,
|
|
&i.ID_2,
|
|
&i.RoomName,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getRoomById = `-- name: GetRoomById :one
|
|
SELECT
|
|
id,
|
|
room_name,
|
|
created_at,
|
|
updated_at
|
|
FROM
|
|
rooms
|
|
WHERE
|
|
id = $1
|
|
`
|
|
|
|
func (q *Queries) GetRoomById(ctx context.Context, id int32) (Room, error) {
|
|
row := q.db.QueryRow(ctx, getRoomById, id)
|
|
var i Room
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.RoomName,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUserByID = `-- name: GetUserByID :one
|
|
SELECT
|
|
id,
|
|
first_name,
|
|
last_name,
|
|
email,
|
|
password,
|
|
access_level,
|
|
created_at,
|
|
updated_at
|
|
FROM
|
|
users
|
|
WHERE
|
|
id = $1
|
|
`
|
|
|
|
func (q *Queries) GetUserByID(ctx context.Context, id int32) (User, error) {
|
|
row := q.db.QueryRow(ctx, getUserByID, id)
|
|
var i User
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.FirstName,
|
|
&i.LastName,
|
|
&i.Email,
|
|
&i.Password,
|
|
&i.AccessLevel,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUserCred = `-- name: GetUserCred :one
|
|
SELECT
|
|
id,
|
|
password
|
|
FROM
|
|
users
|
|
WHERE
|
|
email = $1
|
|
`
|
|
|
|
type GetUserCredRow struct {
|
|
ID int32
|
|
Password string
|
|
}
|
|
|
|
func (q *Queries) GetUserCred(ctx context.Context, email string) (GetUserCredRow, error) {
|
|
row := q.db.QueryRow(ctx, getUserCred, email)
|
|
var i GetUserCredRow
|
|
err := row.Scan(&i.ID, &i.Password)
|
|
return i, err
|
|
}
|
|
|
|
const insertReservation = `-- name: InsertReservation :one
|
|
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
|
|
`
|
|
|
|
type InsertReservationParams struct {
|
|
FirstName string
|
|
LastName string
|
|
Email string
|
|
Phone string
|
|
StartDate pgtype.Date
|
|
EndDate pgtype.Date
|
|
RoomID int32
|
|
CreatedAt pgtype.Timestamp
|
|
UpdatedAt pgtype.Timestamp
|
|
}
|
|
|
|
func (q *Queries) InsertReservation(ctx context.Context, arg InsertReservationParams) (int32, error) {
|
|
row := q.db.QueryRow(ctx, insertReservation,
|
|
arg.FirstName,
|
|
arg.LastName,
|
|
arg.Email,
|
|
arg.Phone,
|
|
arg.StartDate,
|
|
arg.EndDate,
|
|
arg.RoomID,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
)
|
|
var id int32
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const insertRoomRestriction = `-- name: InsertRoomRestriction :exec
|
|
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)
|
|
`
|
|
|
|
type InsertRoomRestrictionParams struct {
|
|
StartDate pgtype.Date
|
|
EndDate pgtype.Date
|
|
RoomID int32
|
|
ReservationID pgtype.Int4
|
|
RestrictionID int32
|
|
CreatedAt pgtype.Timestamp
|
|
UpdatedAt pgtype.Timestamp
|
|
}
|
|
|
|
func (q *Queries) InsertRoomRestriction(ctx context.Context, arg InsertRoomRestrictionParams) error {
|
|
_, err := q.db.Exec(ctx, insertRoomRestriction,
|
|
arg.StartDate,
|
|
arg.EndDate,
|
|
arg.RoomID,
|
|
arg.ReservationID,
|
|
arg.RestrictionID,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const searchAvailabilityByDatesByRoomID = `-- name: SearchAvailabilityByDatesByRoomID :one
|
|
SELECT
|
|
count(id)
|
|
FROM
|
|
room_restrictions
|
|
WHERE
|
|
room_id = $1
|
|
AND $2 < end_date
|
|
AND $3 > start_date
|
|
`
|
|
|
|
type SearchAvailabilityByDatesByRoomIDParams struct {
|
|
RoomID int32
|
|
EndDate pgtype.Date
|
|
StartDate pgtype.Date
|
|
}
|
|
|
|
func (q *Queries) SearchAvailabilityByDatesByRoomID(ctx context.Context, arg SearchAvailabilityByDatesByRoomIDParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, searchAvailabilityByDatesByRoomID, arg.RoomID, arg.EndDate, arg.StartDate)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const searchAvailabilityForAllRooms = `-- name: SearchAvailabilityForAllRooms :many
|
|
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
|
|
)
|
|
`
|
|
|
|
type SearchAvailabilityForAllRoomsParams struct {
|
|
EndDate pgtype.Date
|
|
StartDate pgtype.Date
|
|
}
|
|
|
|
type SearchAvailabilityForAllRoomsRow struct {
|
|
ID int32
|
|
RoomName string
|
|
}
|
|
|
|
func (q *Queries) SearchAvailabilityForAllRooms(ctx context.Context, arg SearchAvailabilityForAllRoomsParams) ([]SearchAvailabilityForAllRoomsRow, error) {
|
|
rows, err := q.db.Query(ctx, searchAvailabilityForAllRooms, arg.EndDate, arg.StartDate)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []SearchAvailabilityForAllRoomsRow
|
|
for rows.Next() {
|
|
var i SearchAvailabilityForAllRoomsRow
|
|
if err := rows.Scan(&i.ID, &i.RoomName); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const updateProcessedForReservation = `-- name: UpdateProcessedForReservation :exec
|
|
UPDATE reservations
|
|
SET
|
|
processed = $1
|
|
WHERE
|
|
id = $2
|
|
`
|
|
|
|
type UpdateProcessedForReservationParams struct {
|
|
Processed int32
|
|
ID int32
|
|
}
|
|
|
|
func (q *Queries) UpdateProcessedForReservation(ctx context.Context, arg UpdateProcessedForReservationParams) error {
|
|
_, err := q.db.Exec(ctx, updateProcessedForReservation, arg.Processed, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const updateReservation = `-- name: UpdateReservation :exec
|
|
UPDATE reservations
|
|
SET
|
|
first_name = $1,
|
|
last_name = $2,
|
|
email = $3,
|
|
phone = $4,
|
|
updated_at = $5
|
|
WHERE
|
|
id = $6
|
|
`
|
|
|
|
type UpdateReservationParams struct {
|
|
FirstName string
|
|
LastName string
|
|
Email string
|
|
Phone string
|
|
UpdatedAt pgtype.Timestamp
|
|
ID int32
|
|
}
|
|
|
|
func (q *Queries) UpdateReservation(ctx context.Context, arg UpdateReservationParams) error {
|
|
_, err := q.db.Exec(ctx, updateReservation,
|
|
arg.FirstName,
|
|
arg.LastName,
|
|
arg.Email,
|
|
arg.Phone,
|
|
arg.UpdatedAt,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const updateUser = `-- name: UpdateUser :exec
|
|
UPDATE users
|
|
SET
|
|
first_name = $1,
|
|
last_name = $2,
|
|
email = $3,
|
|
access_level = $4,
|
|
updated_at = $5
|
|
`
|
|
|
|
type UpdateUserParams struct {
|
|
FirstName string
|
|
LastName string
|
|
Email string
|
|
AccessLevel int32
|
|
UpdatedAt pgtype.Timestamp
|
|
}
|
|
|
|
func (q *Queries) UpdateUser(ctx context.Context, arg UpdateUserParams) error {
|
|
_, err := q.db.Exec(ctx, updateUser,
|
|
arg.FirstName,
|
|
arg.LastName,
|
|
arg.Email,
|
|
arg.AccessLevel,
|
|
arg.UpdatedAt,
|
|
)
|
|
return err
|
|
}
|