Replace gin

.golangci.yml

@@ -7,8 +7,6 @@ linters:
     - depguard
     - err113
     - exhaustruct
-    - forbidigo
-    - forcetypeassert
     - gochecknoglobals
     - gochecknoinits
     - mnd
@@ -22,14 +20,17 @@ linters:
     - wsl
     - wsl_v5
   settings:
+    cyclop:
+      max-complexity: 11
     gosmopolitan:
       allow-time-local: true
     varnamelen:
       max-distance: 15
       ignore-decls:
-        - c *gin.Context
         - db *bbolt.DB
         - w *httptest.ResponseRecorder
+        - w http.ResponseWriter
+        - r *http.Request
   exclusions:
     generated: lax
     paths:
@@ -39,13 +40,14 @@ linters:
       - examples$
 formatters:
   enable:
-    - gci
-    - gofmt
     - gofumpt
-    - goimports
+    - golines
   exclusions:
     generated: lax
     paths:
       - third_party$
       - builtin$
       - examples$
+issues:
+  max-same-issues: 0
+  max-issues-per-linter: 0

config.go

@@ -1,28 +1,37 @@
 package main
 
 import (
-	"log"
 	"net/http"
+	"strconv"
 
 	"github.com/devilcove/timetraced/models"
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-gonic/gin"
 )
 
-func config(c *gin.Context) {
+func configOld(w http.ResponseWriter, _ *http.Request) {
 	page := models.GetPage()
-	c.HTML(http.StatusOK, "config", page)
+	_ = templates.ExecuteTemplate(w, "config", page)
 }
 
-func setConfig(c *gin.Context) {
-	session := sessions.Default(c)
-	user := session.Get("user").(string)
-	config := models.Config{}
-	if err := c.Bind(&config); err != nil {
-		log.Println("failed to read config", err)
+func setConfig(w http.ResponseWriter, r *http.Request) {
+	session := sessionData(r)
+	user := session.User
+	if err := r.ParseForm(); err != nil {
+		processError(w, http.StatusBadRequest, "invalid data")
+		return
+	}
+	refresh, err := strconv.Atoi(r.FormValue("refresh"))
+	if err != nil {
+		refresh = 5
+	}
+	config := models.Config{
+		Theme:   r.FormValue("theme"),
+		Font:    r.FormValue("font"),
+		Refresh: refresh,
 	}
 	models.SetTheme(user, config.Theme)
 	models.SetFont(user, config.Font)
 	models.SetRefresh(user, config.Refresh)
-	displayMain(c)
+	page := models.GetUserPage(user)
+	w.Header().Set("Hx-Refresh", "true")
+	_ = templates.ExecuteTemplate(w, "layout", page)
 }

config_test.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/Kairum-Labs/should"
+)
+
+func TestConfig(t *testing.T) {
+	createAdmin()
+	c := adminLogin()
+	if c == nil {
+		t.FailNow()
+	}
+	t.Run("get", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		r := httptest.NewRequest(http.MethodGet, "/config/", nil)
+		r.AddCookie(adminLogin())
+		router.ServeHTTP(w, r)
+		should.BeEqual(t, w.Result().StatusCode, http.StatusOK)
+	})
+	t.Run("update", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		body := bodyParams("theme", "red", "font", "tangerine", "refesh", "10")
+		r := httptest.NewRequest(http.MethodPost, "/config/", body)
+		r.AddCookie(adminLogin())
+		router.ServeHTTP(w, r)
+		should.BeEqual(t, w.Result().StatusCode, http.StatusOK)
+	})
+	t.Run("invalid refresh", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		body := bodyParams("theme", "red", "font", "tangerine", "refesh", "junk")
+		r := httptest.NewRequest(http.MethodPost, "/config/", body)
+		r.AddCookie(adminLogin())
+		router.ServeHTTP(w, r)
+		should.BeEqual(t, w.Result().StatusCode, http.StatusOK)
+	})
+}

database/project_test.go

@@ -38,3 +38,42 @@ func TestGetProject(t *testing.T) {
 		should.BeEqual(t, project, models.Project{})
 	})
 }
+
+func TestGetAllProjects(t *testing.T) {
+	projects, err := GetAllProjects()
+	t.Log(projects, err)
+	should.BeNil(t, err)
+	should.NotBeEmpty(t, projects)
+}
+
+func TestDeleteProject(t *testing.T) {
+	err := SaveProject(&models.Project{
+		ID:      uuid.New(),
+		Name:    "toBeDeleted",
+		Active:  true,
+		Updated: time.Now(),
+	})
+	should.BeNil(t, err)
+	err = DeleteProject("tobeDeleted")
+	should.BeNil(t, err)
+}
+
+func TestGetActiveProject(t *testing.T) {
+	err := SaveProject(&models.Project{
+		ID:      uuid.New(),
+		Name:    "one",
+		Active:  true,
+		Updated: time.Now(),
+	})
+	should.BeNil(t, err)
+	should.BeNil(t, deleteAllRecords())
+	should.BeNil(t, createTestRecords())
+	t.Run("ok", func(t *testing.T) {
+		project := GetActiveProject("testUser")
+		should.BeEqual(t, project.Name, "one")
+	})
+	t.Run("none", func(t *testing.T) {
+		project := GetActiveProject("user1")
+		should.BeNil(t, project)
+	})
+}

database/records_test.go

@@ -3,6 +3,10 @@ package database
 import (
 	"testing"
 	"time"
+
+	"github.com/Kairum-Labs/should"
+	"github.com/devilcove/timetraced/models"
+	"github.com/google/uuid"
 )
 
 func Test_truncateToStart(t *testing.T) {
@@ -56,3 +60,131 @@ func Test_truncateToEnd(t *testing.T) {
 		})
 	}
 }
+
+func TestSaveRecord(t *testing.T) {
+	should.BeNil(t, deleteAllRecords())
+	err := SaveRecord(&models.Record{
+		ID:      uuid.New(),
+		Project: "one",
+		User:    "testUser",
+		Start:   time.Now().Add(time.Hour * -1),
+		End:     time.Now(),
+	})
+	should.BeNil(t, err)
+}
+
+func TestGetRecord(t *testing.T) {
+	should.BeNil(t, deleteAllRecords())
+	should.BeNil(t, createTestRecords())
+	records, err := GetAllRecords()
+	should.BeNil(t, err)
+	should.BeEqual(t, len(records), 3)
+	record, err := GetRecord(records[0].ID)
+	should.BeNil(t, err)
+	should.BeEqual(t, record.User, records[0].User)
+}
+
+func TestGetTodaysRecords(t *testing.T) {
+	should.BeNil(t, deleteAllRecords())
+	should.BeNil(t, createTestRecords())
+	t.Run("all", func(t *testing.T) {
+		records, err := GetTodaysRecords()
+		should.BeNil(t, err)
+		should.BeEqual(t, len(records), 3)
+	})
+	t.Run("forUser", func(t *testing.T) {
+		records, err := GetTodaysRecordsForUser("testUser")
+		should.BeNil(t, err)
+		should.BeEqual(t, len(records), 2)
+	})
+}
+
+func TestGetReportRecords(t *testing.T) {
+	should.BeNil(t, deleteAllRecords())
+	should.BeNil(t, createTestRecords())
+	t.Run("today", func(t *testing.T) {
+		records, err := GetReportRecords(models.DatabaseReportRequest{
+			Start:   time.Now(),
+			End:     time.Now(),
+			Project: "one",
+			User:    "testUser",
+		})
+		should.BeNil(t, err)
+		should.BeEqual(t, len(records), 2)
+	})
+	t.Run("yesterday", func(t *testing.T) {
+		records, err := GetReportRecords(models.DatabaseReportRequest{
+			Start:   time.Now().Add(time.Hour * -24 * 7),
+			End:     time.Now().Add(time.Hour * -24),
+			Project: "one",
+			User:    "testUser",
+		})
+		should.BeNil(t, err)
+		should.BeEqual(t, len(records), 0)
+	})
+}
+
+func TestDeleteRecords(t *testing.T) {
+	should.BeNil(t, deleteAllRecords())
+	should.BeNil(t, createTestRecords())
+	records, err := GetAllRecords()
+	should.BeNil(t, err)
+	err = DeleteRecord(records[0].ID)
+	should.BeNil(t, err)
+	remainder, err := GetAllRecords()
+	should.BeNil(t, err)
+	should.BeLessThan(t, len(remainder), len(records))
+}
+
+func TestGetAllRecordsForUser(t *testing.T) {
+	should.BeNil(t, deleteAllRecords())
+	should.BeNil(t, createTestRecords())
+	records, err := GetAllRecordsForUser("testUser")
+	should.BeNil(t, err)
+	should.BeEqual(t, len(records), 2)
+}
+
+func createTestRecords() error {
+	records := []models.Record{
+		{
+			ID:      uuid.New(),
+			Project: "one",
+			User:    "testUser",
+			Start:   time.Now().Add(time.Hour * -1),
+			// End:     time.Now(),
+		},
+		{
+			ID:      uuid.New(),
+			Project: "one",
+			User:    "testUser",
+			Start:   time.Now().Add(time.Hour * -2),
+			End:     time.Now().Add(time.Hour * -1),
+		},
+		{
+			ID:      uuid.New(),
+			Project: "two",
+			User:    "user1",
+			Start:   time.Now().Add(time.Hour * -2),
+			End:     time.Now().Add(time.Hour * -1),
+		},
+	}
+	for _, record := range records {
+		if err := SaveRecord(&record); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func deleteAllRecords() error {
+	records, err := GetAllRecords()
+	if err != nil {
+		return err
+	}
+	for _, record := range records {
+		if err := DeleteRecord(record.ID); err != nil {
+			return err
+		}
+	}
+	return nil
+}