Insert dummy user

1 files changed, 201 insertions, 169 deletions

diff --git a/timer.go b/timer.go
index 7882a11..587d24e 100644
--- a/timer.go
+++ b/timer.go
@@ -1,221 +1,253 @@
 package main
 
 import (
-    "context"
-    "database/sql"
-    "log"
-    "net/http"
-    "strconv"
-    "strings"
-    "time"
+	"context"
+	"database/sql"
+	"log"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
 
-    "golang.org/x/crypto/bcrypt"
+	"golang.org/x/crypto/bcrypt"
 
-    "github.com/google/uuid"
-    _ "github.com/mattn/go-sqlite3"
+	_ "github.com/mattn/go-sqlite3"
 
-    "stevenlr.com/timer/model"
-    "stevenlr.com/timer/view"
+	"stevenlr.com/timer/model"
+	"stevenlr.com/timer/view"
 )
 
 func insertTimer(tx *sql.Tx, name string, seconds int) error {
-    now := model.MakeTimeNow()
-    end := model.Time(time.Time(now).Add(time.Duration(seconds) * time.Second))
-    id := model.MakeUUID()
-    _, err := tx.Exec(`
-        INSERT INTO Timer VALUES ($1, $2, $3, $4)`, id, name, now, end);
-    return err
+	now := model.MakeTimeNow()
+	end := model.Time(time.Time(now).Add(time.Duration(seconds) * time.Second))
+	id := model.MakeUUID()
+	_, err := tx.Exec(`
+		INSERT INTO Timer VALUES ($1, $2, $3, $4)`, id, name, now, end)
+	return err
 }
 
 func initializeDatabase(db *sql.DB) error {
-    tx, err := db.Begin()
-    if err != nil { return err }
-    defer tx.Rollback()
-
-    _, err = tx.Exec(`PRAGMA user_version = 1`)
-    if err != nil { return err }
-
-    _, err = tx.Exec(`
-        CREATE TABLE Timer (
-            Id          BLOB    NOT NULL UNIQUE,
-            Name        TEXT    NOT NULL,
-            StartTime   TEXT    NOT NULL,
-            EndTime     TEXT    NOT NULL,
-            PRIMARY KEY (id)
-        )
-    `)
-    if err != nil { return err }
-
-    err = insertTimer(tx, "My timer", 600)
-    if err != nil { return err }
-
-    err = insertTimer(tx, "My timer2", 600)
-    if err != nil { return err }
-
-    _, err = tx.Exec(`
-        CREATE TABLE User (
-            Id          BLOB    NOT NULL UNIQUE,
-            Name        TEXT    NOT NULL,
-            StartTime   TEXT    NOT NULL,
-            EndTime     TEXT    NOT NULL,
-            PRIMARY KEY (id)
-        )
-    `)
-    if err != nil { return err }
-
-    return tx.Commit()
+	tx, err := db.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	_, err = tx.Exec(`PRAGMA user_version = 1`)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(`
+		CREATE TABLE Timer (
+			Id			BLOB	NOT NULL UNIQUE,
+			Name		TEXT	NOT NULL,
+			StartTime	TEXT	NOT NULL,
+			EndTime		TEXT	NOT NULL,
+			PRIMARY KEY (id)
+		)`)
+	if err != nil {
+		return err
+	}
+
+	err = insertTimer(tx, "My timer", 600)
+	if err != nil {
+		return err
+	}
+
+	err = insertTimer(tx, "My timer2", 600)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(`
+		CREATE TABLE User (
+			Id			BLOB	NOT NULL UNIQUE,
+			Name		TEXT	NOT NULL,
+			Salt		TEXT	NOT NULL,
+			Password	BLOB	NOT NULL,
+			PRIMARY KEY (id)
+		)`)
+	if err != nil {
+		return err
+	}
+
+	userUuidStr := "7015cee7-89a5-4057-b7c9-7e0128ad5086"
+	var userId model.UUID
+	err = userId.Scan(userUuidStr)
+	if err != nil {
+		return err
+	}
+
+	userPasswordClear := "steven"
+
+	password, err := bcrypt.GenerateFromPassword([]byte(userUuidStr+userPasswordClear), bcrypt.MinCost)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(`INSERT INTO Timer VALUES ($1, $2, $3, $4)`, userId, "steven", userUuidStr, password)
+	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
+	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 }
+	var id model.UUID
+	if err := id.Scan(idStr); err != nil {
+		return nil
+	}
 
-    row := db.QueryRow("SELECT Id, Name, StartTime, EndTime FROM Timer WHERE Id=$1", id)
+	row := db.QueryRow("SELECT Id, Name, StartTime, EndTime FROM Timer WHERE Id=$1", id)
 
-    var t model.Timer
-    if err := row.Scan(&t.Id, &t.Name, &t.StartTime, &t.EndTime); err == nil {
-        return &t
-    }
+	var t model.Timer
+	if err := row.Scan(&t.Id, &t.Name, &t.StartTime, &t.EndTime); err == nil {
+		return &t
+	}
 
-    return nil
+	return nil
 }
 
 func deleteTimer(db *sql.DB, idStr string) bool {
-    var id model.UUID
-    if err := id.Scan(idStr); err != nil { return false }
-
-    res, err := db.Exec("DELETE FROM Timer WHERE Id=$1", id)
-    if err != nil { return false }
+	var id model.UUID
+	if err := id.Scan(idStr); err != nil {
+		return false
+	}
+
+	res, err := db.Exec("DELETE FROM Timer WHERE Id=$1", id)
+	if err != nil {
+		return false
+	}
+
+	affected, err := res.RowsAffected()
+	return err == nil && affected > 0
+}
 
-    affected, err := res.RowsAffected()
-    return err == nil && affected > 0
+type Session struct {
+	UserId []byte
 }
 
 type MyServer struct {
-    db *sql.DB
+	db       *sql.DB
+	sessions map[string]Session
 }
 
 func (server *MyServer) handleNotFound(w http.ResponseWriter, _ *http.Request) {
-    w.WriteHeader(http.StatusNotFound)
-    view.Main(view.Error404()).Render(context.Background(), w)
+	w.WriteHeader(http.StatusNotFound)
+	view.Main(view.Error404()).Render(context.Background(), w)
 }
 
 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)
-    }
+	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)
-    }
+	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 (server *MyServer) handleDeleteTimer(w http.ResponseWriter, r *http.Request) {
-    success := deleteTimer(server.db, r.PathValue("timerId"))
-    if !success {
-        w.WriteHeader(http.StatusNotFound)
-    }
+	success := deleteTimer(server.db, r.PathValue("timerId"))
+	if !success {
+		w.WriteHeader(http.StatusNotFound)
+	}
 }
 
-func (server* MyServer) handlePutTimer(w http.ResponseWriter, r *http.Request) {
-    timerName := strings.TrimSpace(r.FormValue("timerName"))
-
-    days, err := strconv.ParseInt(strings.TrimSpace(r.FormValue("days")), 10, 32)
-    if err != nil {
-        w.WriteHeader(http.StatusBadRequest)
-        view.TimerCreateForm(timerName, "Error parsing days").Render(context.Background(), w)
-        return
-    }
-
-    hours, err := strconv.ParseInt(strings.TrimSpace(r.FormValue("hours")), 10, 32)
-    if err != nil {
-        w.WriteHeader(http.StatusBadRequest)
-        view.TimerCreateForm(timerName, "Error parsing hours").Render(context.Background(), w)
-        return
-    }
-
-    tx, err := server.db.Begin()
-    if err != nil {
-        w.WriteHeader(http.StatusInternalServerError)
-        view.TimerCreateForm(timerName, "Internal server error").Render(context.Background(), w)
-        return
-    }
-    defer tx.Rollback()
-
-    if timerName == "" {
-        w.WriteHeader(http.StatusBadRequest)
-        view.TimerCreateForm("", "Timer name cannot be empty").Render(context.Background(), w)
-        return
-    }
-
-    err = insertTimer(tx, timerName, int(((max(days, 0) * 24) + max(hours, 0)) * 3600))
-    if err != nil {
-        w.WriteHeader(http.StatusInternalServerError)
-        view.TimerCreateForm(timerName, "Internal server error").Render(context.Background(), w)
-        return
-    }
-
-    tx.Commit()
-
-    timers := queryAllTimers(server.db)
-    view.TimersList(timers).Render(context.Background(), w)
+func (server *MyServer) handlePutTimer(w http.ResponseWriter, r *http.Request) {
+	timerName := strings.TrimSpace(r.FormValue("timerName"))
+
+	days, err := strconv.ParseInt(strings.TrimSpace(r.FormValue("days")), 10, 32)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		view.TimerCreateForm(timerName, "Error parsing days").Render(context.Background(), w)
+		return
+	}
+
+	hours, err := strconv.ParseInt(strings.TrimSpace(r.FormValue("hours")), 10, 32)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		view.TimerCreateForm(timerName, "Error parsing hours").Render(context.Background(), w)
+		return
+	}
+
+	tx, err := server.db.Begin()
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		view.TimerCreateForm(timerName, "Internal server error").Render(context.Background(), w)
+		return
+	}
+	defer tx.Rollback()
+
+	if timerName == "" {
+		w.WriteHeader(http.StatusBadRequest)
+		view.TimerCreateForm("", "Timer name cannot be empty").Render(context.Background(), w)
+		return
+	}
+
+	err = insertTimer(tx, timerName, int(((max(days, 0)*24)+max(hours, 0))*3600))
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		view.TimerCreateForm(timerName, "Internal server error").Render(context.Background(), w)
+		return
+	}
+
+	tx.Commit()
+
+	timers := queryAllTimers(server.db)
+	view.TimersList(timers).Render(context.Background(), w)
 }
 
 func main() {
-    saltUuid, _ := uuid.NewRandom()
-    salt := saltUuid.String()
-    log.Println(salt)
-    bytes, _ := bcrypt.GenerateFromPassword([]byte(salt + "Hello, world!"), 12)
-    log.Println(bytes)
-}
+	log.Println("Starting...")
 
-func main2() {
-    log.Println("Starting...")
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		log.Fatalln(err)
+	}
+	defer db.Close()
 
-    db, err := sql.Open("sqlite3", ":memory:")
-    if err != nil {
-        log.Fatalln(err)
-    }
-    defer db.Close()
+	if err := initializeDatabase(db); err != nil {
+		log.Fatalln(err)
+	}
 
-    if err := initializeDatabase(db); err != nil {
-        log.Fatalln(err)
-    }
+	myServer := MyServer{db: db, sessions: make(map[string]Session)}
 
-    myServer := MyServer{ db: db }
+	fs := http.FileServer(http.Dir("static/"))
+	http.Handle("GET /static/", http.StripPrefix("/static/", fs))
 
-    fs := http.FileServer(http.Dir("static/"))
-    http.Handle("GET /static/", http.StripPrefix("/static/", fs))
+	http.HandleFunc("GET /timer/{timerId}", myServer.handleTimer)
+	http.HandleFunc("DELETE /timer/{timerId}", myServer.handleDeleteTimer)
+	http.HandleFunc("PUT /timer", myServer.handlePutTimer)
+	http.HandleFunc("GET /", myServer.handleMain)
 
-    http.HandleFunc("GET /timer/{timerId}", myServer.handleTimer)
-    http.HandleFunc("DELETE /timer/{timerId}", myServer.handleDeleteTimer)
-    http.HandleFunc("PUT /timer", myServer.handlePutTimer)
-    http.HandleFunc("GET /", myServer.handleMain)
-
-    log.Println("Started!")
-    http.ListenAndServe("0.0.0.0:80", nil)
+	log.Println("Started!")
+	http.ListenAndServe("0.0.0.0:80", nil)
 }
-