itsc/db/db.go

package db

import (
	"database/sql"
	"log"
	"os"
	"time"

	_ "github.com/lib/pq"
)

type Timetable struct {
	ID      int64     `json:"id"`
	Name    string    `json:"name"`
	Status  bool      `json:"status"`
	Limit   int64     `json:"limit"`
	Created time.Time `json:"created"`
}

type TimeSlot struct {
	ID       int64     `json:"id"`
	TTID     int64     `json:"ttid"`
	Name     string    `json:"name"`
	Time     string    `json:"time"`
	Capacity int64     `json:"capacity"`
	Take     int64     `json:"take"`
	Created  time.Time `json:"Created"`
	Success  bool      `json:"success"`
}

type Take struct {
	Username string    `json:"username"`
	TTID     int64     `json:"ttid"`
	Created  time.Time `json:"created"`
}

var (
	DB                    *sql.DB
	GetAllTimetables      *sql.Stmt
	CreateNewTimetable    *sql.Stmt
	DeleteTimetable       *sql.Stmt
	UpdateTimetableStatus *sql.Stmt

	GetTimeSlotsByTimetable *sql.Stmt
	CreateNewTimeslot       *sql.Stmt
	DeleteTimeslot          *sql.Stmt

	GetTakesByTimeslot *sql.Stmt
	DeleteTake         *sql.Stmt
	UserTakeTimeslot   *sql.Stmt
	UserUntakeTimeslot *sql.Stmt
	UpdateTakeCount    *sql.Stmt

	CheckTableStatus *sql.Stmt
	CheckLimit *sql.Stmt
)

func init() {
	var err error
	DB, err = sql.Open("postgres", os.Getenv("POSTGRES_CONNSTR"))
	if err != nil {
		log.Fatal(err)
	}

	if len(os.Args) > 1 {
		if os.Args[1] == "install" {
			install()
			os.Exit(0)
		}
	}

	GetAllTimetables, err = DB.Prepare(`
select id, name, status, "limit"
from timetables 
order by status desc, created desc

	`)
	if err != nil {
		log.Fatal(err)
	}
	CreateNewTimetable, err = DB.Prepare(`
insert into timetables (name, "limit")
values ($1, $2)
returning id
	`)
	if err != nil {
		log.Fatal(err)
	}
	DeleteTimetable, err = DB.Prepare(`
delete from timetables
where id = $1
	`)
	if err != nil {
		log.Fatal(err)
	}
	GetTimeSlotsByTimetable, err = DB.Prepare(`
select t.id, t."name" ,t."time" ,t.take, t.capacity, t2."name", t2.status,
	case sub.username when $2 then true else false end as success,
	t2."limit"
from timeslots t
join timetables t2 on t.ttid = t2.id 
left outer join (
	select username, tsid from takes t3 where username = $2
) sub on t.id = sub.tsid
where t2.id = $1
order by t."name", t."time"
	`)
	if err != nil {
		log.Fatal(err)
	}
	CreateNewTimeslot, err = DB.Prepare(`
insert into timeslots (ttid, name, time, capacity)
values ($1, $2, $3, $4)
returning id
	`)
	if err != nil {
		log.Fatal(err)
	}
	DeleteTimeslot, err = DB.Prepare(`
delete from timeslots 
where id = $1
	`)
	if err != nil {
		log.Fatal(err)
	}
	GetTakesByTimeslot, err = DB.Prepare(`
select username, created
from takes
where tsid = $1
	`)
	if err != nil {
		log.Fatal(err)
	}
	DeleteTake, err = DB.Prepare(`
delete from takes
where tsid = $1 and username = $2
	`)
	if err != nil {
		log.Fatal(err)
	}
	UpdateTimetableStatus, err = DB.Prepare(`
update timetables
set status = $1, "limit" = $2
where id = $3
	`)
	if err != nil {
		log.Fatal(err)
	}
	UserTakeTimeslot, err = DB.Prepare(`
insert into takes (username, tsid)
values ($1, $2)
	`)
	if err != nil {
		log.Fatal(err)
	}
	UserUntakeTimeslot, err = DB.Prepare(`
delete from takes
where username = $1 and tsid = $2
	`)
	if err != nil {
		log.Fatal(err)
	}
	UpdateTakeCount, err = DB.Prepare(`
update timeslots
set take = take + $1
where id = $2
	`)
	if err != nil {
		log.Fatal(err)
	}
	CheckTableStatus, err = DB.Prepare(`
select status from timetables where id = $1
	`)
	if err != nil {
		log.Fatal(err)
	}
	CheckLimit, err = DB.Prepare(`
select count(t1.username) < t3."limit" as c
from takes t1
join timeslots t2 on t1.tsid = t2.id
join timetables t3 on t2.ttid = t3.id
where t1.username = $1 and t3.id = $2
group by t1.username, t3."limit"
	`)
	if err != nil {
		log.Fatal(err)
	}
}