Insert dummy user

timer.go

@@ -11,7 +11,6 @@ import (
 
 	"golang.org/x/crypto/bcrypt"
 
-    "github.com/google/uuid"
 	_ "github.com/mattn/go-sqlite3"
 
 	"stevenlr.com/timer/model"
@@ -23,17 +22,21 @@ func insertTimer(tx *sql.Tx, name string, seconds int) error {
 	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);
+		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 }
+	if err != nil {
+		return err
+	}
 	defer tx.Rollback()
 
 	_, err = tx.Exec(`PRAGMA user_version = 1`)
-    if err != nil { return err }
+	if err != nil {
+		return err
+	}
 
 	_, err = tx.Exec(`
 		CREATE TABLE Timer (
@@ -42,33 +45,60 @@ func initializeDatabase(db *sql.DB) error {
 			StartTime	TEXT	NOT NULL,
 			EndTime		TEXT	NOT NULL,
 			PRIMARY KEY (id)
-        )
+		)`)
-    `)
+	if err != nil {
-    if err != nil { return err }
+		return err
+	}
 
 	err = insertTimer(tx, "My timer", 600)
-    if err != nil { return err }
+	if err != nil {
+		return err
+	}
 
 	err = insertTimer(tx, "My timer2", 600)
-    if err != nil { return err }
+	if err != nil {
+		return err
+	}
 
 	_, err = tx.Exec(`
 		CREATE TABLE User (
 			Id			BLOB	NOT NULL UNIQUE,
 			Name		TEXT	NOT NULL,
-            StartTime   TEXT    NOT NULL,
+			Salt		TEXT	NOT NULL,
-            EndTime     TEXT    NOT NULL,
+			Password	BLOB	NOT NULL,
 			PRIMARY KEY (id)
-        )
+		)`)
-    `)
+	if err != nil {
-    if err != nil { return err }
+		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) }
+	if err != nil {
+		log.Fatalln(err)
+	}
 
 	timers := []model.Timer{}
 	for rows.Next() {
@@ -83,7 +113,9 @@ func queryAllTimers(db *sql.DB) []model.Timer {
 
 func queryTimer(db *sql.DB, idStr string) *model.Timer {
 	var id model.UUID
-    if err := id.Scan(idStr); err != nil { return nil }
+	if err := id.Scan(idStr); err != nil {
+		return nil
+	}
 
 	row := db.QueryRow("SELECT Id, Name, StartTime, EndTime FROM Timer WHERE Id=$1", id)
 
@@ -97,17 +129,26 @@ func queryTimer(db *sql.DB, idStr string) *model.Timer {
 
 func deleteTimer(db *sql.DB, idStr string) bool {
 	var id model.UUID
-    if err := id.Scan(idStr); err != nil { return false }
+	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 }
+	if err != nil {
+		return false
+	}
 
 	affected, err := res.RowsAffected()
 	return err == nil && affected > 0
 }
 
+type Session struct {
+	UserId []byte
+}
+
 type MyServer struct {
 	db       *sql.DB
+	sessions map[string]Session
 }
 
 func (server *MyServer) handleNotFound(w http.ResponseWriter, _ *http.Request) {
@@ -140,7 +181,7 @@ func (server *MyServer) handleDeleteTimer(w http.ResponseWriter, r *http.Request
 	}
 }
 
-func (server* MyServer) handlePutTimer(w http.ResponseWriter, r *http.Request) {
+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)
@@ -171,7 +212,7 @@ func (server* MyServer) handlePutTimer(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-    err = insertTimer(tx, timerName, int(((max(days, 0) * 24) + max(hours, 0)) * 3600))
+	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)
@@ -185,14 +226,6 @@ func (server* MyServer) handlePutTimer(w http.ResponseWriter, r *http.Request) {
 }
 
 func main() {
-    saltUuid, _ := uuid.NewRandom()
-    salt := saltUuid.String()
-    log.Println(salt)
-    bytes, _ := bcrypt.GenerateFromPassword([]byte(salt + "Hello, world!"), 12)
-    log.Println(bytes)
-}
-
-func main2() {
 	log.Println("Starting...")
 
 	db, err := sql.Open("sqlite3", ":memory:")
@@ -205,7 +238,7 @@ func main2() {
 		log.Fatalln(err)
 	}
 
-    myServer := MyServer{ db: db }
+	myServer := MyServer{db: db, sessions: make(map[string]Session)}
 
 	fs := http.FileServer(http.Dir("static/"))
 	http.Handle("GET /static/", http.StripPrefix("/static/", fs))
@@ -218,4 +251,3 @@ func main2() {
 	log.Println("Started!")
 	http.ListenAndServe("0.0.0.0:80", nil)
 }
-