Insert dummy user

This commit is contained in:
2024-04-14 01:25:46 +02:00
parent 92d6bc8db5
commit 3928c520e8

350
timer.go
View File

@ -1,221 +1,253 @@
package main package main
import ( import (
"context" "context"
"database/sql" "database/sql"
"log" "log"
"net/http" "net/http"
"strconv" "strconv"
"strings" "strings"
"time" "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/model"
"stevenlr.com/timer/view" "stevenlr.com/timer/view"
) )
func insertTimer(tx *sql.Tx, name string, seconds int) error { func insertTimer(tx *sql.Tx, name string, seconds int) error {
now := model.MakeTimeNow() now := model.MakeTimeNow()
end := model.Time(time.Time(now).Add(time.Duration(seconds) * time.Second)) end := model.Time(time.Time(now).Add(time.Duration(seconds) * time.Second))
id := model.MakeUUID() id := model.MakeUUID()
_, err := tx.Exec(` _, 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 return err
} }
func initializeDatabase(db *sql.DB) error { func initializeDatabase(db *sql.DB) error {
tx, err := db.Begin() tx, err := db.Begin()
if err != nil { return err } if err != nil {
defer tx.Rollback() return err
}
defer tx.Rollback()
_, err = tx.Exec(`PRAGMA user_version = 1`) _, err = tx.Exec(`PRAGMA user_version = 1`)
if err != nil { return err } if err != nil {
return err
}
_, err = tx.Exec(` _, err = tx.Exec(`
CREATE TABLE Timer ( CREATE TABLE Timer (
Id BLOB NOT NULL UNIQUE, Id BLOB NOT NULL UNIQUE,
Name TEXT NOT NULL, Name TEXT NOT NULL,
StartTime TEXT NOT NULL, StartTime TEXT NOT NULL,
EndTime TEXT NOT NULL, EndTime TEXT NOT NULL,
PRIMARY KEY (id) PRIMARY KEY (id)
) )`)
`) if err != nil {
if err != nil { return err } return err
}
err = insertTimer(tx, "My timer", 600) err = insertTimer(tx, "My timer", 600)
if err != nil { return err } if err != nil {
return err
}
err = insertTimer(tx, "My timer2", 600) err = insertTimer(tx, "My timer2", 600)
if err != nil { return err } if err != nil {
return err
}
_, err = tx.Exec(` _, err = tx.Exec(`
CREATE TABLE User ( CREATE TABLE User (
Id BLOB NOT NULL UNIQUE, Id BLOB NOT NULL UNIQUE,
Name TEXT NOT NULL, Name TEXT NOT NULL,
StartTime TEXT NOT NULL, Salt TEXT NOT NULL,
EndTime TEXT NOT NULL, Password BLOB NOT NULL,
PRIMARY KEY (id) PRIMARY KEY (id)
) )`)
`) if err != nil {
if err != nil { return err } return err
}
return tx.Commit() 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 { func queryAllTimers(db *sql.DB) []model.Timer {
rows, err := db.Query("SELECT Id, Name FROM 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{} timers := []model.Timer{}
for rows.Next() { for rows.Next() {
var t model.Timer var t model.Timer
if err := rows.Scan(&t.Id, &t.Name); err == nil { if err := rows.Scan(&t.Id, &t.Name); err == nil {
timers = append(timers, t) timers = append(timers, t)
} }
} }
return timers return timers
} }
func queryTimer(db *sql.DB, idStr string) *model.Timer { func queryTimer(db *sql.DB, idStr string) *model.Timer {
var id model.UUID 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) row := db.QueryRow("SELECT Id, Name, StartTime, EndTime FROM Timer WHERE Id=$1", id)
var t model.Timer var t model.Timer
if err := row.Scan(&t.Id, &t.Name, &t.StartTime, &t.EndTime); err == nil { if err := row.Scan(&t.Id, &t.Name, &t.StartTime, &t.EndTime); err == nil {
return &t return &t
} }
return nil return nil
} }
func deleteTimer(db *sql.DB, idStr string) bool { func deleteTimer(db *sql.DB, idStr string) bool {
var id model.UUID 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) 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() affected, err := res.RowsAffected()
return err == nil && affected > 0 return err == nil && affected > 0
}
type Session struct {
UserId []byte
} }
type MyServer struct { type MyServer struct {
db *sql.DB db *sql.DB
sessions map[string]Session
} }
func (server *MyServer) handleNotFound(w http.ResponseWriter, _ *http.Request) { func (server *MyServer) handleNotFound(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusNotFound) w.WriteHeader(http.StatusNotFound)
view.Main(view.Error404()).Render(context.Background(), w) view.Main(view.Error404()).Render(context.Background(), w)
} }
func (server *MyServer) handleMain(w http.ResponseWriter, r *http.Request) { func (server *MyServer) handleMain(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/" { if r.URL.Path == "/" {
timers := queryAllTimers(server.db) timers := queryAllTimers(server.db)
view.Main(view.TimersList(timers)).Render(context.Background(), w) view.Main(view.TimersList(timers)).Render(context.Background(), w)
} else { } else {
server.handleNotFound(w, r) server.handleNotFound(w, r)
} }
} }
func (server *MyServer) handleTimer(w http.ResponseWriter, r *http.Request) { func (server *MyServer) handleTimer(w http.ResponseWriter, r *http.Request) {
timer := queryTimer(server.db, r.PathValue("timerId")) timer := queryTimer(server.db, r.PathValue("timerId"))
if timer != nil { if timer != nil {
view.Main(view.TimerView(*timer)).Render(context.Background(), w) view.Main(view.TimerView(*timer)).Render(context.Background(), w)
} else { } else {
server.handleNotFound(w, r) server.handleNotFound(w, r)
} }
} }
func (server *MyServer) handleDeleteTimer(w http.ResponseWriter, r *http.Request) { func (server *MyServer) handleDeleteTimer(w http.ResponseWriter, r *http.Request) {
success := deleteTimer(server.db, r.PathValue("timerId")) success := deleteTimer(server.db, r.PathValue("timerId"))
if !success { if !success {
w.WriteHeader(http.StatusNotFound) w.WriteHeader(http.StatusNotFound)
} }
} }
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")) timerName := strings.TrimSpace(r.FormValue("timerName"))
days, err := strconv.ParseInt(strings.TrimSpace(r.FormValue("days")), 10, 32) days, err := strconv.ParseInt(strings.TrimSpace(r.FormValue("days")), 10, 32)
if err != nil { if err != nil {
w.WriteHeader(http.StatusBadRequest) w.WriteHeader(http.StatusBadRequest)
view.TimerCreateForm(timerName, "Error parsing days").Render(context.Background(), w) view.TimerCreateForm(timerName, "Error parsing days").Render(context.Background(), w)
return return
} }
hours, err := strconv.ParseInt(strings.TrimSpace(r.FormValue("hours")), 10, 32) hours, err := strconv.ParseInt(strings.TrimSpace(r.FormValue("hours")), 10, 32)
if err != nil { if err != nil {
w.WriteHeader(http.StatusBadRequest) w.WriteHeader(http.StatusBadRequest)
view.TimerCreateForm(timerName, "Error parsing hours").Render(context.Background(), w) view.TimerCreateForm(timerName, "Error parsing hours").Render(context.Background(), w)
return return
} }
tx, err := server.db.Begin() tx, err := server.db.Begin()
if err != nil { if err != nil {
w.WriteHeader(http.StatusInternalServerError) w.WriteHeader(http.StatusInternalServerError)
view.TimerCreateForm(timerName, "Internal server error").Render(context.Background(), w) view.TimerCreateForm(timerName, "Internal server error").Render(context.Background(), w)
return return
} }
defer tx.Rollback() defer tx.Rollback()
if timerName == "" { if timerName == "" {
w.WriteHeader(http.StatusBadRequest) w.WriteHeader(http.StatusBadRequest)
view.TimerCreateForm("", "Timer name cannot be empty").Render(context.Background(), w) view.TimerCreateForm("", "Timer name cannot be empty").Render(context.Background(), w)
return 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 { if err != nil {
w.WriteHeader(http.StatusInternalServerError) w.WriteHeader(http.StatusInternalServerError)
view.TimerCreateForm(timerName, "Internal server error").Render(context.Background(), w) view.TimerCreateForm(timerName, "Internal server error").Render(context.Background(), w)
return return
} }
tx.Commit() tx.Commit()
timers := queryAllTimers(server.db) timers := queryAllTimers(server.db)
view.TimersList(timers).Render(context.Background(), w) view.TimersList(timers).Render(context.Background(), w)
} }
func main() { func main() {
saltUuid, _ := uuid.NewRandom() log.Println("Starting...")
salt := saltUuid.String()
log.Println(salt) db, err := sql.Open("sqlite3", ":memory:")
bytes, _ := bcrypt.GenerateFromPassword([]byte(salt + "Hello, world!"), 12) if err != nil {
log.Println(bytes) log.Fatalln(err)
}
defer db.Close()
if err := initializeDatabase(db); err != nil {
log.Fatalln(err)
}
myServer := MyServer{db: db, sessions: make(map[string]Session)}
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)
log.Println("Started!")
http.ListenAndServe("0.0.0.0:80", nil)
} }
func main2() {
log.Println("Starting...")
db, err := sql.Open("sqlite3", ":memory:")
if err != nil {
log.Fatalln(err)
}
defer db.Close()
if err := initializeDatabase(db); err != nil {
log.Fatalln(err)
}
myServer := MyServer{ db: db }
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)
log.Println("Started!")
http.ListenAndServe("0.0.0.0:80", nil)
}