Some work

timer.go

@@ -2,38 +2,119 @@ package main
 
 import (
     "log"
-    "fmt"
     "net/http"
-    "html/template"
+    "database/sql"
+    "context"
+
+    _ "github.com/mattn/go-sqlite3"
+
+    "stevenlr.com/timer/view"
+    "stevenlr.com/timer/model"
 )
 
+func initializeDatabase(db *sql.DB) error {
+    tx, err := db.Begin()
+    if err != nil { return err }
+    defer tx.Rollback()
+
+    _, err = tx.Exec(`
+        CREATE TABLE Timer (
+            id BLOB NOT NULL UNIQUE,
+            name TEXT NOT NULL,
+            PRIMARY KEY (id)
+        )
+    `)
+    if err != nil { return err }
+
+    id := model.NewUUID()
+    _, err = tx.Exec(`
+        INSERT INTO Timer VALUES ($1, $2)`, id, "My timer");
+    if err != nil { return err }
+
+    id = model.NewUUID()
+    _, err = tx.Exec(`
+        INSERT INTO Timer VALUES ($1, $2)`, id, "My timer 2");
+    if err != nil { return err }
+
+    return tx.Commit()
+}
+
+func queryAllTimers(db *sql.DB) []model.Timer {
+    rows, err := db.Query("SELECT id, name FROM Timer")
+    if err != nil { log.Fatalln(err) }
+
+    timers := []model.Timer{}
+    for rows.Next() {
+        var t model.Timer
+        if err := rows.Scan(&t.Id, &t.Name); err == nil {
+            timers = append(timers, t)
+        }
+    }
+
+    return timers
+}
+
+func queryTimer(db *sql.DB, idStr string) *model.Timer {
+    var id model.UUID
+    if err := id.Scan(idStr); err != nil { return nil }
+
+    row := db.QueryRow("SELECT id, name FROM Timer WHERE id=$1", id)
+
+    var t model.Timer
+    if err := row.Scan(&t.Id, &t.Name); err == nil {
+        return &t
+    }
+
+    return nil
+}
+
 type myServer struct {
-    mainTemplate *template.Template
+    db *sql.DB
 }
 
-func (server *myServer) HandleMain(w http.ResponseWriter, r *http.Request) {
-    server.mainTemplate.Execute(w, template.HTML(`<h1><a href="/timer/test">Hello, world!</a></h1>`))
+func (server *myServer) handleNotFound(w http.ResponseWriter, _ *http.Request) {
+    w.WriteHeader(http.StatusNotFound)
+    view.Main(view.Error404()).Render(context.Background(), w)
 }
 
-func (server *myServer) HandleTimer(w http.ResponseWriter, r *http.Request) {
-    fmt.Fprintf(w, "<p>Timer %s</p>", r.PathValue("timer_id"))
+func (server *myServer) handleMain(w http.ResponseWriter, r *http.Request) {
+    if r.URL.Path == "/" {
+        timers := queryAllTimers(server.db)
+        view.Main(view.TimersList(timers)).Render(context.Background(), w)
+    } else {
+        server.handleNotFound(w, r)
+    }
+}
+
+func (server *myServer) handleTimer(w http.ResponseWriter, r *http.Request) {
+    timer := queryTimer(server.db, r.PathValue("timerId"))
+    if timer != nil {
+        view.Main(view.TimerView(*timer)).Render(context.Background(), w)
+    } else {
+        server.handleNotFound(w, r)
+    }
 }
 
 func main() {
     log.Println("Hello")
 
-    tpl, err := template.ParseFiles("template/main.tpl.html")
+    db, err := sql.Open("sqlite3", ":memory:")
     if err != nil {
         log.Fatalln(err)
     }
+    defer db.Close()
 
-    myServer := myServer{ mainTemplate: tpl }
+    if err := initializeDatabase(db); err != nil {
+        log.Fatalln(err)
+    }
+
+    myServer := myServer{ db: db }
 
     fs := http.FileServer(http.Dir("static/"))
     http.Handle("/static/", http.StripPrefix("/static/", fs))
 
-    http.HandleFunc("/", myServer.HandleMain)
-    http.HandleFunc("/timer/{timer_id}", myServer.HandleTimer)
+    http.HandleFunc("/timer/{timerId}", myServer.handleTimer)
+    http.HandleFunc("/", myServer.handleMain)
 
     http.ListenAndServe("0.0.0.0:80", nil)
 }