chore: migrate admin general

.golangci.toml

@@ -0,0 +1,6 @@
+#:schema https://golangci-lint.run/jsonschema/golangci.jsonschema.json
+version = "2"
+
+[[linters.exclusions.rules]]
+linters = [ "errcheck" ]
+source = "^\\s*defer\\s+"

api/api.go

@@ -145,30 +145,34 @@ func (api *API) registerWebAppRoutes(router *gin.Engine) {
 	router.GET("/reader/progress/:document", api.authWebAppMiddleware, api.appGetDocumentProgress)
 
 	// Web App - Templates
-	router.GET("/", api.authWebAppMiddleware, api.appGetHomeNew)                        // DONE
-	router.GET("/activity", api.authWebAppMiddleware, api.appGetActivityNew)            // DONE
-	router.GET("/progress", api.authWebAppMiddleware, api.appGetProgressNew)            // DONE
-	router.GET("/documents", api.authWebAppMiddleware, api.appGetDocumentsNew)          // DONE
-	router.GET("/documents/:document", api.authWebAppMiddleware, api.appGetDocumentNew) // DONE
+	router.GET("/", api.authWebAppMiddleware, api.appGetHome)                        // DONE
+	router.GET("/activity", api.authWebAppMiddleware, api.appGetActivity)            // DONE
+	router.GET("/progress", api.authWebAppMiddleware, api.appGetProgress)            // DONE
+	router.GET("/documents", api.authWebAppMiddleware, api.appGetDocuments)          // DONE
+	router.GET("/documents/:document", api.authWebAppMiddleware, api.appGetDocument) // DONE
 
 	// Web App - Other Routes
 	router.GET("/documents/:document/cover", api.authWebAppMiddleware, api.createGetCoverHandler(appErrorPage))        // DONE
 	router.GET("/documents/:document/file", api.authWebAppMiddleware, api.createDownloadDocumentHandler(appErrorPage)) // DONE
-	router.GET("/logout", api.authWebAppMiddleware, api.appAuthLogout)
+	router.GET("/logout", api.authWebAppMiddleware, api.appAuthLogout)                                                 // DONE
 	router.POST("/login", api.appAuthLogin)                                                                            // DONE
 	router.POST("/register", api.appAuthRegister)                                                                      // DONE
+	router.GET("/settings", api.authWebAppMiddleware, api.appGetSettings)                                              // DONE
 
 	// TODO
 	router.GET("/login", api.appGetLogin)
 	router.GET("/register", api.appGetRegister)
-	router.GET("/settings", api.authWebAppMiddleware, api.appGetSettings)
+
+	// DONE
+	router.GET("/admin", api.authWebAppMiddleware, api.authAdminWebAppMiddleware, api.appGetAdmin)
+	router.POST("/admin", api.authWebAppMiddleware, api.authAdminWebAppMiddleware, api.appPerformAdminAction)
+
+	// TODO - WIP
 	router.GET("/admin/logs", api.authWebAppMiddleware, api.authAdminWebAppMiddleware, api.appGetAdminLogs)
 	router.GET("/admin/import", api.authWebAppMiddleware, api.authAdminWebAppMiddleware, api.appGetAdminImport)
 	router.POST("/admin/import", api.authWebAppMiddleware, api.authAdminWebAppMiddleware, api.appPerformAdminImport)
 	router.GET("/admin/users", api.authWebAppMiddleware, api.authAdminWebAppMiddleware, api.appGetAdminUsers)
 	router.POST("/admin/users", api.authWebAppMiddleware, api.authAdminWebAppMiddleware, api.appUpdateAdminUsers)
-	router.GET("/admin", api.authWebAppMiddleware, api.authAdminWebAppMiddleware, api.appGetAdmin)
-	router.POST("/admin", api.authWebAppMiddleware, api.authAdminWebAppMiddleware, api.appPerformAdminAction)
 
 	// Demo mode enabled configuration
 	if api.cfg.DemoMode {
@@ -182,14 +186,13 @@ func (api *API) registerWebAppRoutes(router *gin.Engine) {
 		router.POST("/documents/:document/delete", api.authWebAppMiddleware, api.appDeleteDocument)        // DONE
 		router.POST("/documents/:document/edit", api.authWebAppMiddleware, api.appEditDocument)            // DONE
 		router.POST("/documents/:document/identify", api.authWebAppMiddleware, api.appIdentifyDocumentNew) // DONE
-		router.POST("/settings", api.authWebAppMiddleware, api.appEditSettings)                            // TODO
+		router.POST("/settings", api.authWebAppMiddleware, api.appEditSettings)                            // DONE
+
 	}
 
 	// Search enabled configuration
 	if api.cfg.SearchEnabled {
-		router.GET("/search", api.authWebAppMiddleware, api.appGetSearchNew) // WIP
-
-		router.GET("/search-old", api.authWebAppMiddleware, api.appGetSearch)    // TODO
+		router.GET("/search", api.authWebAppMiddleware, api.appGetSearch)        // DONE
 		router.POST("/search", api.authWebAppMiddleware, api.appSaveNewDocument) // TODO
 	}
 }
@@ -360,13 +363,13 @@ func loggingMiddleware(c *gin.Context) {
 	}
 
 	// Get username
-	var auth authData
+	var auth *authData
 	if data, _ := c.Get("Authorization"); data != nil {
-		auth = data.(authData)
+		auth = data.(*authData)
 	}
 
 	// Log user
-	if auth.UserName != "" {
+	if auth != nil && auth.UserName != "" {
 		logData["user"] = auth.UserName
 	}
 

api/app-admin-routes.go

@@ -27,6 +27,8 @@ import (
 	"reichard.io/antholume/database"
 	"reichard.io/antholume/metadata"
 	"reichard.io/antholume/utils"
+	"reichard.io/antholume/web/models"
+	"reichard.io/antholume/web/pages"
 )
 
 type adminAction string
@@ -96,21 +98,31 @@ type importResult struct {
 	Error  error
 }
 
-func (api *API) appPerformAdminAction(c *gin.Context) {
-	templateVars, _ := api.getBaseTemplateVars("admin", c)
+func (api *API) appGetAdmin(c *gin.Context) {
+	api.renderPage(c, &pages.AdminGeneral{})
+}
 
+func (api *API) appPerformAdminAction(c *gin.Context) {
 	var rAdminAction requestAdminAction
 	if err := c.ShouldBind(&rAdminAction); err != nil {
-		log.Error("Invalid Form Bind: ", err)
+		log.Error("invalid or missing form values")
 		appErrorPage(c, http.StatusBadRequest, "Invalid or missing form values")
 		return
 	}
 
+	var allNotifications []*models.Notification
 	switch rAdminAction.Action {
+	case adminRestore:
+		api.processRestoreFile(rAdminAction, c)
+		return
+	case adminBackup:
+		api.processBackup(c, rAdminAction.BackupTypes)
+		return
 	case adminMetadataMatch:
-		// TODO
-		// 1. Documents xref most recent metadata table?
-		// 2. Select all / deselect?
+		allNotifications = append(allNotifications, &models.Notification{
+			Type:    models.NotificationTypeError,
+			Content: "Metadata match not implemented",
+		})
 	case adminCacheTables:
 		go func() {
 			err := api.db.CacheTempTables(c)
@@ -118,50 +130,14 @@ func (api *API) appPerformAdminAction(c *gin.Context) {
 				log.Error("Unable to cache temp tables: ", err)
 			}
 		}()
-	case adminRestore:
-		api.processRestoreFile(rAdminAction, c)
-		return
-	case adminBackup:
-		// Vacuum
-		_, err := api.db.DB.ExecContext(c, "VACUUM;")
-		if err != nil {
-			log.Error("Unable to vacuum DB: ", err)
-			appErrorPage(c, http.StatusInternalServerError, "Unable to vacuum database")
-			return
-		}
 
-		// Set Headers
-		c.Header("Content-type", "application/octet-stream")
-		c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"AnthoLumeBackup_%s.zip\"", time.Now().Format("20060102150405")))
-
-		// Stream Backup ZIP Archive
-		c.Stream(func(w io.Writer) bool {
-			var directories []string
-			for _, item := range rAdminAction.BackupTypes {
-				switch item {
-				case backupCovers:
-					directories = append(directories, "covers")
-				case backupDocuments:
-					directories = append(directories, "documents")
-				}
-			}
-
-			err := api.createBackup(c, w, directories)
-			if err != nil {
-				log.Error("Backup Error: ", err)
-			}
-			return false
+		allNotifications = append(allNotifications, &models.Notification{
+			Type:    models.NotificationTypeSuccess,
+			Content: "Initiated table cache",
 		})
-
-		return
 	}
 
-	c.HTML(http.StatusOK, "page/admin", templateVars)
-}
-
-func (api *API) appGetAdmin(c *gin.Context) {
-	templateVars, _ := api.getBaseTemplateVars("admin", c)
-	c.HTML(http.StatusOK, "page/admin", templateVars)
+	api.renderPage(c, &pages.AdminGeneral{}, allNotifications...)
 }
 
 func (api *API) appGetAdminLogs(c *gin.Context) {
@@ -534,6 +510,40 @@ func (api *API) appPerformAdminImport(c *gin.Context) {
 	c.HTML(http.StatusOK, "page/admin-import-results", templateVars)
 }
 
+func (api *API) processBackup(c *gin.Context, backupTypes []backupType) {
+	// Vacuum
+	_, err := api.db.DB.ExecContext(c, "VACUUM;")
+	if err != nil {
+		log.Error("Unable to vacuum DB: ", err)
+		appErrorPage(c, http.StatusInternalServerError, "Unable to vacuum database")
+		return
+	}
+
+	// Set Headers
+	c.Header("Content-type", "application/octet-stream")
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"AnthoLumeBackup_%s.zip\"", time.Now().Format("20060102150405")))
+
+	// Stream Backup ZIP Archive
+	c.Stream(func(w io.Writer) bool {
+		var directories []string
+		for _, item := range backupTypes {
+			switch item {
+			case backupCovers:
+				directories = append(directories, "covers")
+			case backupDocuments:
+				directories = append(directories, "documents")
+			}
+		}
+
+		err := api.createBackup(c, w, directories)
+		if err != nil {
+			log.Error("Backup Error: ", err)
+		}
+		return false
+	})
+
+}
+
 func (api *API) processRestoreFile(rAdminAction requestAdminAction, c *gin.Context) {
 	// Validate Type & Derive Extension on MIME
 	uploadedFile, err := rAdminAction.RestoreFile.Open()
@@ -790,7 +800,7 @@ func (api *API) createBackup(ctx context.Context, w io.Writer, directories []str
 		}
 	}
 
-	ar.Close()
+	_ = ar.Close()
 	return nil
 }
 

api/app-routes-new.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"cmp"
+	"crypto/md5"
 	"fmt"
 	"math"
 	"net/http"
@@ -9,6 +10,7 @@ import (
 	"strings"
 	"time"
 
+	argon2 "github.com/alexedwards/argon2id"
 	"github.com/gin-gonic/gin"
 	log "github.com/sirupsen/logrus"
 	"reichard.io/antholume/database"
@@ -18,20 +20,19 @@ import (
 	"reichard.io/antholume/pkg/sliceutils"
 	"reichard.io/antholume/pkg/utils"
 	"reichard.io/antholume/search"
-	"reichard.io/antholume/web/components/layout"
 	"reichard.io/antholume/web/components/stats"
 	"reichard.io/antholume/web/models"
 	"reichard.io/antholume/web/pages"
 )
 
-func (api *API) appGetHomeNew(c *gin.Context) {
+func (api *API) appGetHome(c *gin.Context) {
 	_, auth := api.getBaseTemplateVars("home", c)
 
 	start := time.Now()
 	dailyStats, err := api.db.Queries.GetDailyReadStats(c, auth.UserName)
 	if err != nil {
-		log.Error("GetDailyReadStats DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDailyReadStats DB Error: %v", err))
+		log.WithError(err).Error("failed to get daily read stats")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get daily read stats: %s", err))
 		return
 	}
 	log.Debug("GetDailyReadStats DB Performance: ", time.Since(start))
@@ -39,8 +40,8 @@ func (api *API) appGetHomeNew(c *gin.Context) {
 	start = time.Now()
 	databaseInfo, err := api.db.Queries.GetDatabaseInfo(c, auth.UserName)
 	if err != nil {
-		log.Error("GetDatabaseInfo DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDatabaseInfo DB Error: %v", err))
+		log.WithError(err).Error("failed to get database info")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get database info: %s", err))
 		return
 	}
 	log.Debug("GetDatabaseInfo DB Performance: ", time.Since(start))
@@ -48,8 +49,8 @@ func (api *API) appGetHomeNew(c *gin.Context) {
 	start = time.Now()
 	streaks, err := api.db.Queries.GetUserStreaks(c, auth.UserName)
 	if err != nil {
-		log.Error("GetUserStreaks DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetUserStreaks DB Error: %v", err))
+		log.WithError(err).Error("failed to get user streaks")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get user streaks: %s", err))
 		return
 	}
 	log.Debug("GetUserStreaks DB Performance: ", time.Since(start))
@@ -57,35 +58,27 @@ func (api *API) appGetHomeNew(c *gin.Context) {
 	start = time.Now()
 	userStatistics, err := api.db.Queries.GetUserStatistics(c)
 	if err != nil {
-		log.Error("GetUserStatistics DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetUserStatistics DB Error: %v", err))
+		log.WithError(err).Error("failed to get user statistics")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get user statistics: %s", err))
 		return
 	}
 	log.Debug("GetUserStatistics DB Performance: ", time.Since(start))
 
-	err = layout.Layout(
-		pages.Home{
-			Leaderboard: arrangeUserStatisticsNew(userStatistics),
+	api.renderPage(c, &pages.Home{
+		Leaderboard: arrangeUserStatistic(userStatistics),
 		Streaks:     streaks,
 		DailyStats:  dailyStats,
 		RecordInfo:  &databaseInfo,
-		},
-		layout.LayoutOptions{
-			Username:      auth.UserName,
-			IsAdmin:       auth.IsAdmin,
-			SearchEnabled: api.cfg.SearchEnabled,
-			Version:       api.cfg.Version,
-		},
-	).Render(c.Writer)
-	if err != nil {
-		log.Error("Render Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Unknown Error: %v", err))
-	}
+	})
 }
 
-func (api *API) appGetDocumentsNew(c *gin.Context) {
-	_, auth := api.getBaseTemplateVars("documents", c)
-	qParams := bindQueryParams(c, 9)
+func (api *API) appGetDocuments(c *gin.Context) {
+	qParams, err := bindQueryParams(c, 9)
+	if err != nil {
+		log.WithError(err).Error("failed to bind query params")
+		appErrorPage(c, http.StatusBadRequest, fmt.Sprintf("failed to bind query params: %s", err))
+		return
+	}
 
 	var query *string
 	if qParams.Search != nil && *qParams.Search != "" {
@@ -93,6 +86,7 @@ func (api *API) appGetDocumentsNew(c *gin.Context) {
 		query = &search
 	}
 
+	_, auth := api.getBaseTemplateVars("documents", c)
 	documents, err := api.db.Queries.GetDocumentsWithStats(c, database.GetDocumentsWithStatsParams{
 		UserID:  auth.UserName,
 		Query:   query,
@@ -101,170 +95,114 @@ func (api *API) appGetDocumentsNew(c *gin.Context) {
 		Limit:   *qParams.Limit,
 	})
 	if err != nil {
-		log.Error("GetDocumentsWithStats DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDocumentsWithStats DB Error: %v", err))
+		log.WithError(err).Error("failed to get documents with stats")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get documents with stats: %s", err))
 		return
 	}
 
 	length, err := api.db.Queries.GetDocumentsSize(c, query)
 	if err != nil {
-		log.Error("GetDocumentsSize DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDocumentsSize DB Error: %v", err))
+		log.WithError(err).Error("failed to get document sizes")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get document sizes: %s", err))
 		return
 	}
 
 	if err = api.getDocumentsWordCount(c, documents); err != nil {
-		log.Error("Unable to Get Word Counts: ", err)
+		log.WithError(err).Error("failed to get word counts")
 	}
 
 	totalPages := int64(math.Ceil(float64(length) / float64(*qParams.Limit)))
 	nextPage := *qParams.Page + 1
 	previousPage := *qParams.Page - 1
 
-	err = layout.Layout(
-		pages.Documents{
+	api.renderPage(c, pages.Documents{
 		Data:     sliceutils.Map(documents, convertDBDocToUI),
 		Previous: utils.Ternary(previousPage >= 0, int(previousPage), 0),
 		Next:     utils.Ternary(nextPage <= totalPages, int(nextPage), 0),
 		Limit:    int(ptr.Deref(qParams.Limit)),
-		},
-		layout.LayoutOptions{
-			Username:      auth.UserName,
-			IsAdmin:       auth.IsAdmin,
-			SearchEnabled: api.cfg.SearchEnabled,
-			Version:       api.cfg.Version,
-		},
-	).Render(c.Writer)
-	if err != nil {
-		log.Error("Render Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Unknown Error: %v", err))
-	}
+	})
 }
 
-func (api *API) appGetDocumentNew(c *gin.Context) {
-	_, auth := api.getBaseTemplateVars("document", c)
-
+func (api *API) appGetDocument(c *gin.Context) {
 	var rDocID requestDocumentID
 	if err := c.ShouldBindUri(&rDocID); err != nil {
-		log.Error("Invalid URI Bind")
+		log.WithError(err).Error("failed to bind URI")
 		appErrorPage(c, http.StatusNotFound, "Invalid document")
 		return
 	}
 
+	_, auth := api.getBaseTemplateVars("document", c)
 	document, err := api.db.GetDocument(c, rDocID.DocumentID, auth.UserName)
 	if err != nil {
-		log.Error("GetDocument DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDocument DB Error: %v", err))
+		log.WithError(err).Error("failed to get document")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get document: %s", err))
 		return
 	}
 
-	err = layout.Layout(
-		pages.Document{
-			Data: convertDBDocToUI(*document),
-		},
-		layout.LayoutOptions{
-			Username:      auth.UserName,
-			IsAdmin:       auth.IsAdmin,
-			SearchEnabled: api.cfg.SearchEnabled,
-			Version:       api.cfg.Version,
-		},
-	).Render(c.Writer)
-	if err != nil {
-		log.Error("Render Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Unknown Error: %v", err))
-	}
+	api.renderPage(c, &pages.Document{Data: convertDBDocToUI(*document)})
+}
+
+func (api *API) appGetActivity(c *gin.Context) {
+	qParams, err := bindQueryParams(c, 15)
+	if err != nil {
+		log.WithError(err).Error("failed to bind query params")
+		appErrorPage(c, http.StatusBadRequest, fmt.Sprintf("failed to bind query params: %s", err))
+		return
 	}
 
-func (api *API) appGetActivityNew(c *gin.Context) {
 	_, auth := api.getBaseTemplateVars("activity", c)
-	qParams := bindQueryParams(c, 15)
-
-	activityFilter := database.GetActivityParams{
+	activity, err := api.db.Queries.GetActivity(c, database.GetActivityParams{
 		UserID:     auth.UserName,
 		Offset:     (*qParams.Page - 1) * *qParams.Limit,
 		Limit:      *qParams.Limit,
-	}
-
-	if qParams.Document != nil {
-		activityFilter.DocFilter = true
-		activityFilter.DocumentID = *qParams.Document
-	}
-
-	activity, err := api.db.Queries.GetActivity(c, activityFilter)
+		DocFilter:  qParams.Document != nil,
+		DocumentID: ptr.Deref(qParams.Document),
+	})
 	if err != nil {
-		log.Error("GetActivity DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetActivity DB Error: %v", err))
+		log.WithError(err).Error("failed to get activity")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get activity: %s", err))
 		return
 	}
 
-	err = layout.Layout(
-		pages.Activity{
-			Data: sliceutils.Map(activity, convertDBActivityToUI),
-		},
-		layout.LayoutOptions{
-			Username:      auth.UserName,
-			IsAdmin:       auth.IsAdmin,
-			SearchEnabled: api.cfg.SearchEnabled,
-			Version:       api.cfg.Version,
-		},
-	).Render(c.Writer)
-	if err != nil {
-		log.Error("Render Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Unknown Error: %v", err))
-	}
+	api.renderPage(c, &pages.Activity{Data: sliceutils.Map(activity, convertDBActivityToUI)})
+}
+
+func (api *API) appGetProgress(c *gin.Context) {
+	qParams, err := bindQueryParams(c, 15)
+	if err != nil {
+		log.WithError(err).Error("failed to bind query params")
+		appErrorPage(c, http.StatusBadRequest, fmt.Sprintf("failed to bind query params: %s", err))
+		return
 	}
 
-func (api *API) appGetProgressNew(c *gin.Context) {
 	_, auth := api.getBaseTemplateVars("progress", c)
-
-	qParams := bindQueryParams(c, 15)
-
-	progressFilter := database.GetProgressParams{
+	progress, err := api.db.Queries.GetProgress(c, database.GetProgressParams{
 		UserID:     auth.UserName,
 		Offset:     (*qParams.Page - 1) * *qParams.Limit,
 		Limit:      *qParams.Limit,
-	}
-
-	if qParams.Document != nil {
-		progressFilter.DocFilter = true
-		progressFilter.DocumentID = *qParams.Document
-	}
-
-	progress, err := api.db.Queries.GetProgress(c, progressFilter)
+		DocFilter:  qParams.Document != nil,
+		DocumentID: ptr.Deref(qParams.Document),
+	})
 	if err != nil {
-		log.Error("GetProgress DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetActivity DB Error: %v", err))
+		log.WithError(err).Error("failed to get progress")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get progress: %s", err))
 		return
 	}
 
-	err = layout.Layout(
-		pages.Progress{
-			Data: sliceutils.Map(progress, convertDBProgressToUI),
-		},
-		layout.LayoutOptions{
-			Username:      auth.UserName,
-			IsAdmin:       auth.IsAdmin,
-			SearchEnabled: api.cfg.SearchEnabled,
-			Version:       api.cfg.Version,
-		},
-	).Render(c.Writer)
-	if err != nil {
-		log.Error("Render Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Unknown Error: %v", err))
-	}
+	api.renderPage(c, &pages.Progress{Data: sliceutils.Map(progress, convertDBProgressToUI)})
 }
 
 func (api *API) appIdentifyDocumentNew(c *gin.Context) {
 	var rDocID requestDocumentID
 	if err := c.ShouldBindUri(&rDocID); err != nil {
-		log.Error("Invalid URI Bind")
+		log.WithError(err).Error("failed to bind URI")
 		appErrorPage(c, http.StatusNotFound, "Invalid document")
 		return
 	}
 
 	var rDocIdentify requestDocumentIdentify
 	if err := c.ShouldBind(&rDocIdentify); err != nil {
-		log.Error("Invalid Form Bind")
+		log.WithError(err).Error("failed to bind form")
 		appErrorPage(c, http.StatusBadRequest, "Invalid or missing form values")
 		return
 	}
@@ -282,15 +220,14 @@ func (api *API) appIdentifyDocumentNew(c *gin.Context) {
 
 	// Validate Values
 	if rDocIdentify.ISBN == nil && rDocIdentify.Title == nil && rDocIdentify.Author == nil {
-		log.Error("Invalid Form")
+		log.Error("invalid or missing form values")
 		appErrorPage(c, http.StatusBadRequest, "Invalid or missing form values")
 		return
 	}
 
-	// Get Template Variables
-	_, auth := api.getBaseTemplateVars("document", c)
-
 	// Get Metadata
+	var searchResult *models.DocumentMetadata
+	var allNotifications []*models.Notification
 	metadataResults, err := metadata.SearchMetadata(metadata.SourceGoogleBooks, metadata.MetadataInfo{
 		Title:  rDocIdentify.Title,
 		Author: rDocIdentify.Author,
@@ -298,14 +235,12 @@ func (api *API) appIdentifyDocumentNew(c *gin.Context) {
 		ISBN13: rDocIdentify.ISBN,
 	})
 	if err != nil {
-		log.Error("Search Metadata Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Search Metadata Error: %v", err))
+		log.WithError(err).Error("failed to search metadata")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to search metadata: %s", err))
 		return
-	}
+	} else if firstResult, found := sliceutils.First(metadataResults); found {
+		searchResult = convertMetaToUI(firstResult)
 
-	var errorMsg *string
-	firstResult, found := sliceutils.First(metadataResults)
-	if found {
 		// Store First Metadata Result
 		if _, err = api.db.Queries.AddMetadata(c, database.AddMetadataParams{
 			DocumentID:  rDocID.DocumentID,
@@ -313,52 +248,42 @@ func (api *API) appIdentifyDocumentNew(c *gin.Context) {
 			Author:      firstResult.Author,
 			Description: firstResult.Description,
 			Gbid:        firstResult.SourceID,
-			Olid:        nil,
 			Isbn10:      firstResult.ISBN10,
 			Isbn13:      firstResult.ISBN13,
 		}); err != nil {
-			log.Error("AddMetadata DB Error: ", err)
+			log.WithError(err).Error("failed to add metadata")
 		}
 	} else {
-		errorMsg = ptr.Of("No Metadata Found")
+		allNotifications = append(allNotifications, &models.Notification{
+			Type:    models.NotificationTypeError,
+			Content: "No Metadata Found",
+		})
 	}
 
+	// Get Auth
+	_, auth := api.getBaseTemplateVars("document", c)
 	document, err := api.db.GetDocument(c, rDocID.DocumentID, auth.UserName)
 	if err != nil {
-		log.Error("GetDocument DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDocument DB Error: %v", err))
+		log.WithError(err).Error("failed to get document")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get document: %s", err))
 		return
 	}
 
-	err = layout.Layout(
-		pages.Document{
+	api.renderPage(c, &pages.Document{
 		Data:   convertDBDocToUI(*document),
-			Search: convertMetaToUI(firstResult, errorMsg),
-		},
-		layout.LayoutOptions{
-			Username:      auth.UserName,
-			IsAdmin:       auth.IsAdmin,
-			SearchEnabled: api.cfg.SearchEnabled,
-			Version:       api.cfg.Version,
-		},
-	).Render(c.Writer)
-	if err != nil {
-		log.Error("Render Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Unknown Error: %v", err))
-	}
+		Search: searchResult,
+	}, allNotifications...)
 }
 
 // Tabs:
 //   - General (Import, Backup & Restore, Version (githash?), Stats?)
 //   - Users
 //   - Metadata
-func (api *API) appGetSearchNew(c *gin.Context) {
-	_, auth := api.getBaseTemplateVars("search", c)
-
+func (api *API) appGetSearch(c *gin.Context) {
 	var sParams searchParams
-	err := c.BindQuery(&sParams)
-	if err != nil {
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Invalid Form Bind: %v", err))
+	if err := c.BindQuery(&sParams); err != nil {
+		log.WithError(err).Error("failed to bind form")
+		appErrorPage(c, http.StatusBadRequest, "Invalid or missing form values")
 		return
 	}
 
@@ -368,6 +293,7 @@ func (api *API) appGetSearchNew(c *gin.Context) {
 	if sParams.Query != nil && sParams.Source != nil {
 		results, err := search.SearchBook(*sParams.Query, *sParams.Source)
 		if err != nil {
+			log.WithError(err).Error("failed to search book")
 			appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Search Error: %v", err))
 			return
 		}
@@ -376,23 +302,159 @@ func (api *API) appGetSearchNew(c *gin.Context) {
 		searchError = "Invailid Query"
 	}
 
-	err = layout.Layout(
-		pages.Search{
+	api.renderPage(c, &pages.Search{
 		Results: searchResults,
 		Source:  ptr.Deref(sParams.Source),
 		Query:   ptr.Deref(sParams.Query),
 		Error:   searchError,
-		},
-		layout.LayoutOptions{
+	})
+}
+
+func (api *API) appGetSettings(c *gin.Context) {
+	_, auth := api.getBaseTemplateVars("settings", c)
+
+	user, err := api.db.Queries.GetUser(c, auth.UserName)
+	if err != nil {
+		log.WithError(err).Error("failed to get user")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get user: %s", err))
+		return
+	}
+
+	devices, err := api.db.Queries.GetDevices(c, auth.UserName)
+	if err != nil {
+		log.WithError(err).Error("failed to get devices")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get devices: %s", err))
+		return
+	}
+
+	api.renderPage(c, &pages.Settings{
+		Timezone: ptr.Deref(user.Timezone),
+		Devices:  sliceutils.Map(devices, convertDBDeviceToUI),
+	})
+}
+
+func (api *API) appEditSettings(c *gin.Context) {
+	var rUserSettings requestSettingsEdit
+	if err := c.ShouldBind(&rUserSettings); err != nil {
+		log.WithError(err).Error("failed to bind form")
+		appErrorPage(c, http.StatusBadRequest, "Invalid or missing form values")
+		return
+	}
+
+	// Validate Something Exists
+	if rUserSettings.Password == nil && rUserSettings.NewPassword == nil && rUserSettings.Timezone == nil {
+		log.Error("invalid or missing form values")
+		appErrorPage(c, http.StatusBadRequest, "Invalid or missing form values")
+		return
+	}
+
+	_, auth := api.getBaseTemplateVars("settings", c)
+
+	newUserSettings := database.UpdateUserParams{
+		UserID: auth.UserName,
+		Admin:  auth.IsAdmin,
+	}
+
+	// Set New Password
+	var allNotifications []*models.Notification
+	if rUserSettings.Password != nil && rUserSettings.NewPassword != nil {
+		password := fmt.Sprintf("%x", md5.Sum([]byte(*rUserSettings.Password)))
+		if _, err := api.authorizeCredentials(c, auth.UserName, password); err != nil {
+			allNotifications = append(allNotifications, &models.Notification{
+				Type:    models.NotificationTypeError,
+				Content: "Invalid Password",
+			})
+		} else {
+			password := fmt.Sprintf("%x", md5.Sum([]byte(*rUserSettings.NewPassword)))
+			hashedPassword, err := argon2.CreateHash(password, argon2.DefaultParams)
+			if err != nil {
+				allNotifications = append(allNotifications, &models.Notification{
+					Type:    models.NotificationTypeError,
+					Content: "Unknown Error",
+				})
+			} else {
+				allNotifications = append(allNotifications, &models.Notification{
+					Type:    models.NotificationTypeSuccess,
+					Content: "Password Updated",
+				})
+				newUserSettings.Password = &hashedPassword
+			}
+		}
+	}
+
+	// Set Time Offset
+	if rUserSettings.Timezone != nil {
+		allNotifications = append(allNotifications, &models.Notification{
+			Type:    models.NotificationTypeSuccess,
+			Content: "Time Offset Updated",
+		})
+		newUserSettings.Timezone = rUserSettings.Timezone
+	}
+
+	// Update User
+	_, err := api.db.Queries.UpdateUser(c, newUserSettings)
+	if err != nil {
+		log.WithError(err).Error("failed to update user")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to update user: %s", err))
+		return
+	}
+
+	// Get User
+	user, err := api.db.Queries.GetUser(c, auth.UserName)
+	if err != nil {
+		log.WithError(err).Error("failed to get user")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get user: %s", err))
+		return
+	}
+
+	// Get Devices
+	devices, err := api.db.Queries.GetDevices(c, auth.UserName)
+	if err != nil {
+		log.WithError(err).Error("failed to get devices")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to get devices: %s", err))
+		return
+	}
+
+	api.renderPage(c, &pages.Settings{
+		Devices:  sliceutils.Map(devices, convertDBDeviceToUI),
+		Timezone: ptr.Deref(user.Timezone),
+	}, allNotifications...)
+}
+
+func (api *API) renderPage(c *gin.Context, page pages.Page, notifications ...*models.Notification) {
+	// Get Authentication Data
+	auth, err := getAuthData(c)
+	if err != nil {
+		log.WithError(err).Error("failed to acquire auth data")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to acquire auth data: %s", err))
+		return
+	}
+
+	// Generate Page
+	pageNode, err := page.Generate(models.PageContext{
+		UserInfo: &models.UserInfo{
 			Username: auth.UserName,
 			IsAdmin:  auth.IsAdmin,
+		},
+		ServerInfo: &models.ServerInfo{
+			RegistrationEnabled: api.cfg.RegistrationEnabled,
 			SearchEnabled:       api.cfg.SearchEnabled,
 			Version:             api.cfg.Version,
 		},
-	).Render(c.Writer)
+		Notifications: notifications,
+	})
 	if err != nil {
-		log.Error("Render Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Unknown Error: %v", err))
+		log.WithError(err).Error("failed to generate page")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to generate page: %s", err))
+		return
+	}
+
+	// Render Page
+	err = pageNode.Render(c.Writer)
+	if err != nil {
+		log.WithError(err).Error("failed to render page")
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("failed to render page: %s", err))
+		return
 	}
 }
 
@@ -415,7 +477,7 @@ func sortItem[T cmp.Ordered](
 	return items
 }
 
-func arrangeUserStatisticsNew(data []database.GetUserStatisticsRow) []stats.LeaderboardData {
+func arrangeUserStatistic(data []database.GetUserStatisticsRow) []stats.LeaderboardData {
 	wpmFormatter := func(v float64) string { return fmt.Sprintf("%.2f WPM", v) }
 	return []stats.LeaderboardData{
 		{

api/app-routes.go

@@ -2,28 +2,22 @@ package api
 
 import (
 	"context"
-	"crypto/md5"
 	"database/sql"
 	"fmt"
 	"io"
-	"math"
 	"mime/multipart"
 	"net/http"
 	"os"
 	"path/filepath"
-	"reflect"
-	"sort"
 	"strings"
 	"time"
 
-	argon2 "github.com/alexedwards/argon2id"
 	"github.com/gabriel-vasile/mimetype"
 	"github.com/gin-gonic/gin"
 	log "github.com/sirupsen/logrus"
 	"golang.org/x/exp/slices"
 	"reichard.io/antholume/database"
 	"reichard.io/antholume/metadata"
-	"reichard.io/antholume/pkg/ptr"
 	"reichard.io/antholume/search"
 )
 
@@ -101,242 +95,6 @@ func (api *API) appDocumentReader(c *gin.Context) {
 	c.FileFromFS("assets/reader/index.htm", http.FS(api.assets))
 }
 
-func (api *API) appGetDocuments(c *gin.Context) {
-	templateVars, auth := api.getBaseTemplateVars("documents", c)
-	qParams := bindQueryParams(c, 9)
-
-	var query *string
-	if qParams.Search != nil && *qParams.Search != "" {
-		search := "%" + *qParams.Search + "%"
-		query = &search
-	}
-
-	documents, err := api.db.Queries.GetDocumentsWithStats(c, database.GetDocumentsWithStatsParams{
-		UserID:  auth.UserName,
-		Query:   query,
-		Deleted: ptr.Of(false),
-		Offset:  (*qParams.Page - 1) * *qParams.Limit,
-		Limit:   *qParams.Limit,
-	})
-	if err != nil {
-		log.Error("GetDocumentsWithStats DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDocumentsWithStats DB Error: %v", err))
-		return
-	}
-
-	length, err := api.db.Queries.GetDocumentsSize(c, query)
-	if err != nil {
-		log.Error("GetDocumentsSize DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDocumentsSize DB Error: %v", err))
-		return
-	}
-
-	if err = api.getDocumentsWordCount(c, documents); err != nil {
-		log.Error("Unable to Get Word Counts: ", err)
-	}
-
-	totalPages := int64(math.Ceil(float64(length) / float64(*qParams.Limit)))
-	nextPage := *qParams.Page + 1
-	previousPage := *qParams.Page - 1
-
-	if nextPage <= totalPages {
-		templateVars["NextPage"] = nextPage
-	}
-
-	if previousPage >= 0 {
-		templateVars["PreviousPage"] = previousPage
-	}
-
-	templateVars["PageLimit"] = *qParams.Limit
-	templateVars["Data"] = documents
-
-	c.HTML(http.StatusOK, "page/documents", templateVars)
-}
-
-func (api *API) appGetDocument(c *gin.Context) {
-	templateVars, auth := api.getBaseTemplateVars("document", c)
-
-	var rDocID requestDocumentID
-	if err := c.ShouldBindUri(&rDocID); err != nil {
-		log.Error("Invalid URI Bind")
-		appErrorPage(c, http.StatusNotFound, "Invalid document")
-		return
-	}
-
-	document, err := api.db.GetDocument(c, rDocID.DocumentID, auth.UserName)
-	if err != nil {
-		log.Error("GetDocument DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDocument DB Error: %v", err))
-		return
-	}
-
-	templateVars["Data"] = document
-	templateVars["TotalTimeLeftSeconds"] = int64((100.0 - document.Percentage) * float64(document.SecondsPerPercent))
-
-	c.HTML(http.StatusOK, "page/document", templateVars)
-}
-
-func (api *API) appGetProgress(c *gin.Context) {
-	templateVars, auth := api.getBaseTemplateVars("progress", c)
-
-	qParams := bindQueryParams(c, 15)
-
-	progressFilter := database.GetProgressParams{
-		UserID: auth.UserName,
-		Offset: (*qParams.Page - 1) * *qParams.Limit,
-		Limit:  *qParams.Limit,
-	}
-
-	if qParams.Document != nil {
-		progressFilter.DocFilter = true
-		progressFilter.DocumentID = *qParams.Document
-	}
-
-	progress, err := api.db.Queries.GetProgress(c, progressFilter)
-	if err != nil {
-		log.Error("GetProgress DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetActivity DB Error: %v", err))
-		return
-	}
-
-	templateVars["Data"] = progress
-
-	c.HTML(http.StatusOK, "page/progress", templateVars)
-}
-
-func (api *API) appGetActivity(c *gin.Context) {
-	templateVars, auth := api.getBaseTemplateVars("activity", c)
-	qParams := bindQueryParams(c, 15)
-
-	activityFilter := database.GetActivityParams{
-		UserID: auth.UserName,
-		Offset: (*qParams.Page - 1) * *qParams.Limit,
-		Limit:  *qParams.Limit,
-	}
-
-	if qParams.Document != nil {
-		activityFilter.DocFilter = true
-		activityFilter.DocumentID = *qParams.Document
-	}
-
-	activity, err := api.db.Queries.GetActivity(c, activityFilter)
-	if err != nil {
-		log.Error("GetActivity DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetActivity DB Error: %v", err))
-		return
-	}
-
-	templateVars["Data"] = activity
-
-	c.HTML(http.StatusOK, "page/activity", templateVars)
-}
-
-func (api *API) appGetHome(c *gin.Context) {
-	templateVars, auth := api.getBaseTemplateVars("home", c)
-
-	start := time.Now()
-	graphData, err := api.db.Queries.GetDailyReadStats(c, auth.UserName)
-	if err != nil {
-		log.Error("GetDailyReadStats DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDailyReadStats DB Error: %v", err))
-		return
-	}
-	log.Debug("GetDailyReadStats DB Performance: ", time.Since(start))
-
-	start = time.Now()
-	databaseInfo, err := api.db.Queries.GetDatabaseInfo(c, auth.UserName)
-	if err != nil {
-		log.Error("GetDatabaseInfo DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDatabaseInfo DB Error: %v", err))
-		return
-	}
-	log.Debug("GetDatabaseInfo DB Performance: ", time.Since(start))
-
-	start = time.Now()
-	streaks, err := api.db.Queries.GetUserStreaks(c, auth.UserName)
-	if err != nil {
-		log.Error("GetUserStreaks DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetUserStreaks DB Error: %v", err))
-		return
-	}
-	log.Debug("GetUserStreaks DB Performance: ", time.Since(start))
-
-	start = time.Now()
-	userStatistics, err := api.db.Queries.GetUserStatistics(c)
-	if err != nil {
-		log.Error("GetUserStatistics DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetUserStatistics DB Error: %v", err))
-		return
-	}
-	log.Debug("GetUserStatistics DB Performance: ", time.Since(start))
-
-	templateVars["Data"] = gin.H{
-		"Streaks":        streaks,
-		"GraphData":      graphData,
-		"DatabaseInfo":   databaseInfo,
-		"UserStatistics": arrangeUserStatistics(userStatistics),
-	}
-
-	c.HTML(http.StatusOK, "page/home", templateVars)
-}
-
-func (api *API) appGetSettings(c *gin.Context) {
-	templateVars, auth := api.getBaseTemplateVars("settings", c)
-
-	user, err := api.db.Queries.GetUser(c, auth.UserName)
-	if err != nil {
-		log.Error("GetUser DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetUser DB Error: %v", err))
-		return
-	}
-
-	devices, err := api.db.Queries.GetDevices(c, auth.UserName)
-	if err != nil {
-		log.Error("GetDevices DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDevices DB Error: %v", err))
-		return
-	}
-
-	templateVars["Data"] = gin.H{
-		"Timezone": *user.Timezone,
-		"Devices":  devices,
-	}
-
-	c.HTML(http.StatusOK, "page/settings", templateVars)
-}
-
-// Tabs:
-//   - General (Import, Backup & Restore, Version (githash?), Stats?)
-//   - Users
-//   - Metadata
-func (api *API) appGetSearch(c *gin.Context) {
-	templateVars, _ := api.getBaseTemplateVars("search", c)
-
-	var sParams searchParams
-	err := c.BindQuery(&sParams)
-	if err != nil {
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Invalid Form Bind: %v", err))
-		return
-	}
-
-	// Only Handle Query
-	if sParams.Query != nil && sParams.Source != nil {
-		// Search
-		searchResults, err := search.SearchBook(*sParams.Query, *sParams.Source)
-		if err != nil {
-			appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Search Error: %v", err))
-			return
-		}
-
-		templateVars["Data"] = searchResults
-		templateVars["Source"] = *sParams.Source
-	} else if sParams.Query != nil || sParams.Source != nil {
-		templateVars["SearchErrorMessage"] = "Invalid Query"
-	}
-
-	c.HTML(http.StatusOK, "page/search", templateVars)
-}
-
 func (api *API) appGetLogin(c *gin.Context) {
 	templateVars, _ := api.getBaseTemplateVars("login", c)
 	templateVars["RegistrationEnabled"] = api.cfg.RegistrationEnabled
@@ -617,85 +375,6 @@ func (api *API) appDeleteDocument(c *gin.Context) {
 	c.Redirect(http.StatusFound, "../")
 }
 
-func (api *API) appIdentifyDocument(c *gin.Context) {
-	var rDocID requestDocumentID
-	if err := c.ShouldBindUri(&rDocID); err != nil {
-		log.Error("Invalid URI Bind")
-		appErrorPage(c, http.StatusNotFound, "Invalid document")
-		return
-	}
-
-	var rDocIdentify requestDocumentIdentify
-	if err := c.ShouldBind(&rDocIdentify); err != nil {
-		log.Error("Invalid Form Bind")
-		appErrorPage(c, http.StatusBadRequest, "Invalid or missing form values")
-		return
-	}
-
-	// Disallow Empty Strings
-	if rDocIdentify.Title != nil && strings.TrimSpace(*rDocIdentify.Title) == "" {
-		rDocIdentify.Title = nil
-	}
-	if rDocIdentify.Author != nil && strings.TrimSpace(*rDocIdentify.Author) == "" {
-		rDocIdentify.Author = nil
-	}
-	if rDocIdentify.ISBN != nil && strings.TrimSpace(*rDocIdentify.ISBN) == "" {
-		rDocIdentify.ISBN = nil
-	}
-
-	// Validate Values
-	if rDocIdentify.ISBN == nil && rDocIdentify.Title == nil && rDocIdentify.Author == nil {
-		log.Error("Invalid Form")
-		appErrorPage(c, http.StatusBadRequest, "Invalid or missing form values")
-		return
-	}
-
-	// Get Template Variables
-	templateVars, auth := api.getBaseTemplateVars("document", c)
-
-	// Get Metadata
-	metadataResults, err := metadata.SearchMetadata(metadata.SourceGoogleBooks, metadata.MetadataInfo{
-		Title:  rDocIdentify.Title,
-		Author: rDocIdentify.Author,
-		ISBN10: rDocIdentify.ISBN,
-		ISBN13: rDocIdentify.ISBN,
-	})
-	if err == nil && len(metadataResults) > 0 {
-		firstResult := metadataResults[0]
-
-		// Store First Metadata Result
-		if _, err = api.db.Queries.AddMetadata(c, database.AddMetadataParams{
-			DocumentID:  rDocID.DocumentID,
-			Title:       firstResult.Title,
-			Author:      firstResult.Author,
-			Description: firstResult.Description,
-			Gbid:        firstResult.SourceID,
-			Olid:        nil,
-			Isbn10:      firstResult.ISBN10,
-			Isbn13:      firstResult.ISBN13,
-		}); err != nil {
-			log.Error("AddMetadata DB Error: ", err)
-		}
-
-		templateVars["Metadata"] = firstResult
-	} else {
-		log.Warn("Metadata Error")
-		templateVars["MetadataError"] = "No Metadata Found"
-	}
-
-	document, err := api.db.GetDocument(c, rDocID.DocumentID, auth.UserName)
-	if err != nil {
-		log.Error("GetDocument DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDocument DB Error: %v", err))
-		return
-	}
-
-	templateVars["Data"] = document
-	templateVars["TotalTimeLeftSeconds"] = int64((100.0 - document.Percentage) * float64(document.SecondsPerPercent))
-
-	c.HTML(http.StatusOK, "page/document", templateVars)
-}
-
 func (api *API) appSaveNewDocument(c *gin.Context) {
 	var rDocAdd requestDocumentAdd
 	if err := c.ShouldBind(&rDocAdd); err != nil {
@@ -833,84 +512,6 @@ func (api *API) appSaveNewDocument(c *gin.Context) {
 	})
 }
 
-func (api *API) appEditSettings(c *gin.Context) {
-	var rUserSettings requestSettingsEdit
-	if err := c.ShouldBind(&rUserSettings); err != nil {
-		log.Error("Invalid Form Bind")
-		appErrorPage(c, http.StatusBadRequest, "Invalid or missing form values")
-		return
-	}
-
-	// Validate Something Exists
-	if rUserSettings.Password == nil && rUserSettings.NewPassword == nil && rUserSettings.Timezone == nil {
-		log.Error("Missing Form Values")
-		appErrorPage(c, http.StatusBadRequest, "Invalid or missing form values")
-		return
-	}
-
-	templateVars, auth := api.getBaseTemplateVars("settings", c)
-
-	newUserSettings := database.UpdateUserParams{
-		UserID: auth.UserName,
-		Admin:  auth.IsAdmin,
-	}
-
-	// Set New Password
-	if rUserSettings.Password != nil && rUserSettings.NewPassword != nil {
-		password := fmt.Sprintf("%x", md5.Sum([]byte(*rUserSettings.Password)))
-		data := api.authorizeCredentials(c, auth.UserName, password)
-		if data == nil {
-			templateVars["PasswordErrorMessage"] = "Invalid Password"
-		} else {
-			password := fmt.Sprintf("%x", md5.Sum([]byte(*rUserSettings.NewPassword)))
-			hashedPassword, err := argon2.CreateHash(password, argon2.DefaultParams)
-			if err != nil {
-				templateVars["PasswordErrorMessage"] = "Unknown Error"
-			} else {
-				templateVars["PasswordMessage"] = "Password Updated"
-				newUserSettings.Password = &hashedPassword
-			}
-		}
-	}
-
-	// Set Time Offset
-	if rUserSettings.Timezone != nil {
-		templateVars["TimeOffsetMessage"] = "Time Offset Updated"
-		newUserSettings.Timezone = rUserSettings.Timezone
-	}
-
-	// Update User
-	_, err := api.db.Queries.UpdateUser(c, newUserSettings)
-	if err != nil {
-		log.Error("UpdateUser DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("UpdateUser DB Error: %v", err))
-		return
-	}
-
-	// Get User
-	user, err := api.db.Queries.GetUser(c, auth.UserName)
-	if err != nil {
-		log.Error("GetUser DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetUser DB Error: %v", err))
-		return
-	}
-
-	// Get Devices
-	devices, err := api.db.Queries.GetDevices(c, auth.UserName)
-	if err != nil {
-		log.Error("GetDevices DB Error: ", err)
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("GetDevices DB Error: %v", err))
-		return
-	}
-
-	templateVars["Data"] = gin.H{
-		"Timezone": *user.Timezone,
-		"Devices":  devices,
-	}
-
-	c.HTML(http.StatusOK, "page/settings", templateVars)
-}
-
 func (api *API) appDemoModeError(c *gin.Context) {
 	appErrorPage(c, http.StatusUnauthorized, "Not Allowed in Demo Mode")
 }
@@ -958,10 +559,10 @@ func (api *API) getDocumentsWordCount(ctx context.Context, documents []database.
 	return nil
 }
 
-func (api *API) getBaseTemplateVars(routeName string, c *gin.Context) (gin.H, authData) {
-	var auth authData
+func (api *API) getBaseTemplateVars(routeName string, c *gin.Context) (gin.H, *authData) {
+	var auth *authData
 	if data, _ := c.Get("Authorization"); data != nil {
-		auth = data.(authData)
+		auth = data.(*authData)
 	}
 
 	return gin.H{
@@ -975,12 +576,11 @@ func (api *API) getBaseTemplateVars(routeName string, c *gin.Context) (gin.H, au
 	}, auth
 }
 
-func bindQueryParams(c *gin.Context, defaultLimit int64) queryParams {
+func bindQueryParams(c *gin.Context, defaultLimit int64) (*queryParams, error) {
 	var qParams queryParams
 	err := c.BindQuery(&qParams)
 	if err != nil {
-		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Invalid Form Bind: %v", err))
-		return qParams
+		return nil, err
 	}
 
 	if qParams.Limit == nil {
@@ -995,7 +595,7 @@ func bindQueryParams(c *gin.Context, defaultLimit int64) queryParams {
 		qParams.Page = &oneValue
 	}
 
-	return qParams
+	return &qParams, nil
 }
 
 func appErrorPage(c *gin.Context, errorCode int, errorMessage string) {
@@ -1018,80 +618,3 @@ func appErrorPage(c *gin.Context, errorCode int, errorMessage string) {
 		"Message": errorMessage,
 	})
 }
-
-func arrangeUserStatistics(userStatistics []database.GetUserStatisticsRow) gin.H {
-	// Item Sorter
-	sortItem := func(userStatistics []database.GetUserStatisticsRow, key string, less func(i int, j int) bool) []map[string]any {
-		sortedData := append([]database.GetUserStatisticsRow(nil), userStatistics...)
-		sort.SliceStable(sortedData, less)
-
-		newData := make([]map[string]any, 0)
-		for _, item := range sortedData {
-			v := reflect.Indirect(reflect.ValueOf(item))
-
-			var value string
-			if strings.Contains(key, "Wpm") {
-				rawVal := v.FieldByName(key).Float()
-				value = fmt.Sprintf("%.2f WPM", rawVal)
-			} else if strings.Contains(key, "Seconds") {
-				rawVal := v.FieldByName(key).Int()
-				value = niceSeconds(rawVal)
-			} else if strings.Contains(key, "Words") {
-				rawVal := v.FieldByName(key).Int()
-				value = niceNumbers(rawVal)
-			}
-
-			newData = append(newData, map[string]any{
-				"UserID": item.UserID,
-				"Value":  value,
-			})
-		}
-
-		return newData
-	}
-
-	return gin.H{
-		"WPM": gin.H{
-			"All": sortItem(userStatistics, "TotalWpm", func(i, j int) bool {
-				return userStatistics[i].TotalWpm > userStatistics[j].TotalWpm
-			}),
-			"Year": sortItem(userStatistics, "YearlyWpm", func(i, j int) bool {
-				return userStatistics[i].YearlyWpm > userStatistics[j].YearlyWpm
-			}),
-			"Month": sortItem(userStatistics, "MonthlyWpm", func(i, j int) bool {
-				return userStatistics[i].MonthlyWpm > userStatistics[j].MonthlyWpm
-			}),
-			"Week": sortItem(userStatistics, "WeeklyWpm", func(i, j int) bool {
-				return userStatistics[i].WeeklyWpm > userStatistics[j].WeeklyWpm
-			}),
-		},
-		"Duration": gin.H{
-			"All": sortItem(userStatistics, "TotalSeconds", func(i, j int) bool {
-				return userStatistics[i].TotalSeconds > userStatistics[j].TotalSeconds
-			}),
-			"Year": sortItem(userStatistics, "YearlySeconds", func(i, j int) bool {
-				return userStatistics[i].YearlySeconds > userStatistics[j].YearlySeconds
-			}),
-			"Month": sortItem(userStatistics, "MonthlySeconds", func(i, j int) bool {
-				return userStatistics[i].MonthlySeconds > userStatistics[j].MonthlySeconds
-			}),
-			"Week": sortItem(userStatistics, "WeeklySeconds", func(i, j int) bool {
-				return userStatistics[i].WeeklySeconds > userStatistics[j].WeeklySeconds
-			}),
-		},
-		"Words": gin.H{
-			"All": sortItem(userStatistics, "TotalWordsRead", func(i, j int) bool {
-				return userStatistics[i].TotalWordsRead > userStatistics[j].TotalWordsRead
-			}),
-			"Year": sortItem(userStatistics, "YearlyWordsRead", func(i, j int) bool {
-				return userStatistics[i].YearlyWordsRead > userStatistics[j].YearlyWordsRead
-			}),
-			"Month": sortItem(userStatistics, "MonthlyWordsRead", func(i, j int) bool {
-				return userStatistics[i].MonthlyWordsRead > userStatistics[j].MonthlyWordsRead
-			}),
-			"Week": sortItem(userStatistics, "WeeklyWordsRead", func(i, j int) bool {
-				return userStatistics[i].WeeklyWordsRead > userStatistics[j].WeeklyWordsRead
-			}),
-		},
-	}
-}

api/auth.go

@@ -30,31 +30,31 @@ type authKOHeader struct {
 	AuthKey  string `header:"x-auth-key"`
 }
 
-func (api *API) authorizeCredentials(ctx context.Context, username string, password string) (auth *authData) {
+func (api *API) authorizeCredentials(ctx context.Context, username string, password string) (*authData, error) {
 	user, err := api.db.Queries.GetUser(ctx, username)
 	if err != nil {
-		return
+		return nil, err
 	}
 
 	if match, err := argon2.ComparePasswordAndHash(password, *user.Pass); err != nil || !match {
-		return
+		return nil, err
 	}
 
-	// Update auth cache
+	// Update Auth Cache
 	api.userAuthCache[user.ID] = *user.AuthHash
 
 	return &authData{
 		UserName: user.ID,
 		IsAdmin:  user.Admin,
 		AuthHash: *user.AuthHash,
-	}
+	}, nil
 }
 
 func (api *API) authKOMiddleware(c *gin.Context) {
 	session := sessions.Default(c)
 
 	// Check Session First
-	if auth, ok := api.getSession(c, session); ok {
+	if auth, ok := api.authorizeSession(c, session); ok {
 		c.Set("Authorization", auth)
 		c.Header("Cache-Control", "private")
 		c.Next()
@@ -65,21 +65,25 @@ func (api *API) authKOMiddleware(c *gin.Context) {
 
 	var rHeader authKOHeader
 	if err := c.ShouldBindHeader(&rHeader); err != nil {
+		log.WithError(err).Error("failed to bind auth headers")
 		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "Incorrect Headers"})
 		return
 	}
 	if rHeader.AuthUser == "" || rHeader.AuthKey == "" {
+		log.Error("invalid authentication headers")
 		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid Authorization Headers"})
 		return
 	}
 
-	authData := api.authorizeCredentials(c, rHeader.AuthUser, rHeader.AuthKey)
-	if authData == nil {
+	authData, err := api.authorizeCredentials(c, rHeader.AuthUser, rHeader.AuthKey)
+	if err != nil {
+		log.WithField("user", rHeader.AuthUser).WithError(err).Error("failed to authorize credentials")
 		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
 		return
 	}
 
-	if err := api.setSession(session, *authData); err != nil {
+	if err := api.setSession(session, authData); err != nil {
+		log.WithField("user", rHeader.AuthUser).WithError(err).Error("failed to set session")
 		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
 		return
 	}
@@ -96,14 +100,16 @@ func (api *API) authOPDSMiddleware(c *gin.Context) {
 
 	// Validate Auth Fields
 	if !hasAuth || user == "" || rawPassword == "" {
+		log.Error("invalid authorization headers")
 		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid Authorization Headers"})
 		return
 	}
 
 	// Validate Auth
 	password := fmt.Sprintf("%x", md5.Sum([]byte(rawPassword)))
-	authData := api.authorizeCredentials(c, user, password)
-	if authData == nil {
+	authData, err := api.authorizeCredentials(c, user, password)
+	if err != nil {
+		log.WithField("user", user).WithError(err).Error("failed to authorize credentials")
 		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
 		return
 	}
@@ -117,7 +123,7 @@ func (api *API) authWebAppMiddleware(c *gin.Context) {
 	session := sessions.Default(c)
 
 	// Check Session
-	if auth, ok := api.getSession(c, session); ok {
+	if auth, ok := api.authorizeSession(c, session); ok {
 		c.Set("Authorization", auth)
 		c.Header("Cache-Control", "private")
 		c.Next()
@@ -130,7 +136,7 @@ func (api *API) authWebAppMiddleware(c *gin.Context) {
 
 func (api *API) authAdminWebAppMiddleware(c *gin.Context) {
 	if data, _ := c.Get("Authorization"); data != nil {
-		auth := data.(authData)
+		auth := data.(*authData)
 		if auth.IsAdmin {
 			c.Next()
 			return
@@ -155,8 +161,9 @@ func (api *API) appAuthLogin(c *gin.Context) {
 
 	// MD5 - KOSync Compatiblity
 	password := fmt.Sprintf("%x", md5.Sum([]byte(rawPassword)))
-	authData := api.authorizeCredentials(c, username, password)
-	if authData == nil {
+	authData, err := api.authorizeCredentials(c, username, password)
+	if err != nil {
+		log.WithField("user", username).WithError(err).Error("failed to authorize credentials")
 		templateVars["Error"] = "Invalid Credentials"
 		c.HTML(http.StatusUnauthorized, "page/login", templateVars)
 		return
@@ -164,7 +171,7 @@ func (api *API) appAuthLogin(c *gin.Context) {
 
 	// Set Session
 	session := sessions.Default(c)
-	if err := api.setSession(session, *authData); err != nil {
+	if err := api.setSession(session, authData); err != nil {
 		templateVars["Error"] = "Invalid Credentials"
 		c.HTML(http.StatusUnauthorized, "page/login", templateVars)
 		return
@@ -253,7 +260,7 @@ func (api *API) appAuthRegister(c *gin.Context) {
 	}
 
 	// Set session
-	auth := authData{
+	auth := &authData{
 		UserName: user.ID,
 		IsAdmin:  user.Admin,
 		AuthHash: *user.AuthHash,
@@ -349,35 +356,40 @@ func (api *API) koAuthRegister(c *gin.Context) {
 	})
 }
 
-func (api *API) getSession(ctx context.Context, session sessions.Session) (auth authData, ok bool) {
+func (api *API) authorizeSession(ctx context.Context, session sessions.Session) (*authData, bool) {
 	// Get Session
 	authorizedUser := session.Get("authorizedUser")
 	isAdmin := session.Get("isAdmin")
 	expiresAt := session.Get("expiresAt")
 	authHash := session.Get("authHash")
 	if authorizedUser == nil || isAdmin == nil || expiresAt == nil || authHash == nil {
-		return
+		return nil, false
 	}
 
 	// Create Auth Object
-	auth = authData{
+	auth := &authData{
 		UserName: authorizedUser.(string),
 		IsAdmin:  isAdmin.(bool),
 		AuthHash: authHash.(string),
 	}
+	logger := log.WithField("user", auth.UserName)
 
 	// Validate Auth Hash
 	correctAuthHash, err := api.getUserAuthHash(ctx, auth.UserName)
-	if err != nil || correctAuthHash != auth.AuthHash {
-		return
+	if err != nil {
+		logger.WithError(err).Error("failed to get auth hash")
+		return nil, false
+	} else if correctAuthHash != auth.AuthHash {
+		logger.Warn("user auth hash mismatch")
+		return nil, false
 	}
 
 	// Refresh
 	if expiresAt.(int64)-time.Now().Unix() < 60*60*24 {
-		log.Info("Refreshing Session")
+		logger.Info("refreshing session")
 		if err := api.setSession(session, auth); err != nil {
-			log.Error("unable to get session")
-			return
+			logger.WithError(err).Error("failed to refresh session")
+			return nil, false
 		}
 	}
 
@@ -385,7 +397,7 @@ func (api *API) getSession(ctx context.Context, session sessions.Session) (auth
 	return auth, true
 }
 
-func (api *API) setSession(session sessions.Session, auth authData) error {
+func (api *API) setSession(session sessions.Session, auth *authData) error {
 	// Set Session Cookie
 	session.Set("authorizedUser", auth.UserName)
 	session.Set("isAdmin", auth.IsAdmin)

api/convert.go

@@ -28,7 +28,7 @@ func convertDBDocToUI(r database.GetDocumentsWithStatsRow) models.Document {
 	}
 }
 
-func convertMetaToUI(m metadata.MetadataInfo, errorMsg *string) *models.DocumentMetadata {
+func convertMetaToUI(m metadata.MetadataInfo) *models.DocumentMetadata {
 	return &models.DocumentMetadata{
 		SourceID:    ptr.Deref(m.SourceID),
 		ISBN10:      ptr.Deref(m.ISBN10),
@@ -37,7 +37,6 @@ func convertMetaToUI(m metadata.MetadataInfo, errorMsg *string) *models.Document
 		Author:      ptr.Deref(m.Author),
 		Description: ptr.Deref(m.Description),
 		Source:      m.Source,
-		Error:       errorMsg,
 	}
 }
 
@@ -63,6 +62,14 @@ func convertDBProgressToUI(r database.GetProgressRow) models.Progress {
 	}
 }
 
+func convertDBDeviceToUI(r database.GetDevicesRow) models.Device {
+	return models.Device{
+		DeviceName: r.DeviceName,
+		LastSynced: r.LastSynced,
+		CreatedAt:  r.CreatedAt,
+	}
+}
+
 func convertSearchToUI(r search.SearchItem) models.SearchResult {
 	return models.SearchResult{
 		ID:         r.ID,

api/opds-routes.go

@@ -62,13 +62,19 @@ func (api *API) opdsEntry(c *gin.Context) {
 }
 
 func (api *API) opdsDocuments(c *gin.Context) {
-	var auth authData
-	if data, _ := c.Get("Authorization"); data != nil {
-		auth = data.(authData)
+	auth, err := getAuthData(c)
+	if err != nil {
+		log.WithError(err).Error("failed to acquire auth data")
+		c.AbortWithStatus(http.StatusInternalServerError)
 	}
 
 	// Potential URL Parameters (Default Pagination - 100)
-	qParams := bindQueryParams(c, 100)
+	qParams, err := bindQueryParams(c, 100)
+	if err != nil {
+		log.WithError(err).Error("failed to bind query params")
+		c.AbortWithStatus(http.StatusBadRequest)
+		return
+	}
 
 	// Possible Query
 	var query *string
@@ -86,7 +92,7 @@ func (api *API) opdsDocuments(c *gin.Context) {
 		Limit:   *qParams.Limit,
 	})
 	if err != nil {
-		log.Error("GetDocumentsWithStats DB Error:", err)
+		log.WithError(err).Error("failed to get documents with stats")
 		c.AbortWithStatus(http.StatusBadRequest)
 		return
 	}

api/utils.go

@@ -8,11 +8,22 @@ import (
 	"reflect"
 	"strings"
 
+	"github.com/gin-gonic/gin"
 	"reichard.io/antholume/database"
 	"reichard.io/antholume/graph"
 	"reichard.io/antholume/metadata"
 )
 
+func getAuthData(ctx *gin.Context) (*authData, error) {
+	if data, ok := ctx.Get("Authorization"); ok {
+		var auth *authData
+		if auth, ok = data.(*authData); ok {
+			return auth, nil
+		}
+	}
+	return nil, errors.New("could not acquire auth data")
+}
+
 // getTimeZones returns a string slice of IANA timezones.
 func getTimeZones() []string {
 	return []string{

database/query.sql

@@ -138,8 +138,8 @@ WHERE id = $device_id LIMIT 1;
 SELECT
     devices.id,
     devices.device_name,
-    LOCAL_TIME(devices.created_at, users.timezone) AS created_at,
-    LOCAL_TIME(devices.last_synced, users.timezone) AS last_synced
+    CAST(LOCAL_TIME(devices.created_at, users.timezone) AS TEXT) AS created_at,
+    CAST(LOCAL_TIME(devices.last_synced, users.timezone) AS TEXT) AS last_synced
 FROM devices
 JOIN users ON users.id = devices.user_id
 WHERE users.id = $user_id

database/query.sql.go

@@ -422,8 +422,8 @@ const getDevices = `-- name: GetDevices :many
 SELECT
     devices.id,
     devices.device_name,
-    LOCAL_TIME(devices.created_at, users.timezone) AS created_at,
-    LOCAL_TIME(devices.last_synced, users.timezone) AS last_synced
+    CAST(LOCAL_TIME(devices.created_at, users.timezone) AS TEXT) AS created_at,
+    CAST(LOCAL_TIME(devices.last_synced, users.timezone) AS TEXT) AS last_synced
 FROM devices
 JOIN users ON users.id = devices.user_id
 WHERE users.id = ?1
@@ -433,8 +433,8 @@ ORDER BY devices.last_synced DESC
 type GetDevicesRow struct {
 	ID         string `json:"id"`
 	DeviceName string `json:"device_name"`
-	CreatedAt  interface{} `json:"created_at"`
-	LastSynced interface{} `json:"last_synced"`
+	CreatedAt  string `json:"created_at"`
+	LastSynced string `json:"last_synced"`
 }
 
 func (q *Queries) GetDevices(ctx context.Context, userID string) ([]GetDevicesRow, error) {

metadata/epub.go

@@ -53,10 +53,12 @@ func countEPUBWords(filepath string) (int64, error) {
 	rf := rc.Rootfiles[0]
 
 	var completeCount int64
-	for _, item := range rf.Spine.Itemrefs {
+	for _, item := range rf.Itemrefs {
 		f, _ := item.Open()
 		doc, _ := goquery.NewDocumentFromReader(f)
-		completeCount = completeCount + int64(len(strings.Fields(doc.Text())))
+		doc.Find("script, style, noscript, iframe").Remove()
+		words := len(strings.Fields(doc.Text()))
+		completeCount = completeCount + int64(words)
 	}
 
 	return completeCount, nil

metadata/metadata.go

@@ -88,7 +88,7 @@ func GetWordCount(filepath string) (*int64, error) {
 		}
 		return &totalWords, nil
 	} else {
-		return nil, fmt.Errorf("Invalid extension: %s", fileExtension)
+		return nil, fmt.Errorf("invalid extension: %s", fileExtension)
 	}
 }
 

search/search.go

@@ -58,7 +58,6 @@ func SearchBook(query string, source Source) ([]SearchItem, error) {
 	if !found {
 		return nil, fmt.Errorf("invalid source: %s", source)
 	}
-	log.Debug("Source: ", source)
 	return searchFunc(query)
 }
 

tailwind.config.js

@@ -17,6 +17,20 @@ module.exports = {
       minWidth: {
         40: "10rem",
       },
+      animation: {
+        notification:
+          "slideIn 0.25s ease-out forwards, slideOut 0.25s ease-out 4.5s forwards",
+      },
+      keyframes: {
+        slideIn: {
+          "0%": { transform: "translateX(100%)" },
+          "100%": { transform: "translateX(0)" },
+        },
+        slideOut: {
+          "0%": { transform: "translateX(0)" },
+          "100%": { transform: "translateX(100%)" },
+        },
+      },
     },
   },
   plugins: [],

templates/components/activity.tmpl

@@ -1,28 +0,0 @@
-{{ template "base" . }}
-{{ define "title" }}Activity{{ end }}
-{{ define "header" }}<a href="./activity">Activity</a>{{ end }}
-{{ define "content" }}
-  <div class="overflow-x-auto">
-    <div class="inline-block min-w-full overflow-hidden rounded shadow">
-      <!-- Table Component - Utilizes Template "table-cell" -->
-      {{ template "component/table" (dict
-        "Columns" (slice "Document" "Time" "Duration" "Percent")
-        "Keys" (slice "Document" "StartTime" "Duration" "EndPercentage")
-        "Rows" .Data
-        )
-      }}
-    </div>
-  </div>
-{{ end }}
-<!-- Table Cell Definition -->
-{{ define "table-cell" }}
-  {{ if eq .Name "Document" }}
-    <a href="./documents/{{ .Data.DocumentID }}"
-      >{{ .Data.Author }} - {{ .Data.Title }}</a
-    >
-  {{ else if eq .Name "EndPercentage" }}
-    {{ index (fields .Data) .Name }}%
-  {{ else }}
-    {{ index (fields .Data) .Name }}
-  {{ end }}
-{{ end }}

templates/components/document-card.tmpl

@@ -1,50 +0,0 @@
-<div class="w-full relative">
-  <div
-    class="flex gap-4 w-full h-full p-4 shadow-lg bg-white dark:bg-gray-700 rounded"
-  >
-    <div class="min-w-fit my-auto h-48 relative">
-      <a href="./documents/{{ .ID }}">
-        <img
-          class="rounded object-cover h-full"
-          src="./documents/{{ .ID }}/cover"
-        />
-      </a>
-    </div>
-    <div class="flex flex-col justify-around dark:text-white w-full text-sm">
-      <div class="inline-flex shrink-0 items-center">
-        <div>
-          <p class="text-gray-400">Title</p>
-          <p class="font-medium">{{ or .Title "Unknown" }}</p>
-        </div>
-      </div>
-      <div class="inline-flex shrink-0 items-center">
-        <div>
-          <p class="text-gray-400">Author</p>
-          <p class="font-medium">{{ or .Author "Unknown" }}</p>
-        </div>
-      </div>
-      <div class="inline-flex shrink-0 items-center">
-        <div>
-          <p class="text-gray-400">Progress</p>
-          <p class="font-medium">{{ .Percentage }}%</p>
-        </div>
-      </div>
-      <div class="inline-flex shrink-0 items-center">
-        <div>
-          <p class="text-gray-400">Time Read</p>
-          <p class="font-medium">{{ niceSeconds .TotalTimeSeconds }}</p>
-        </div>
-      </div>
-    </div>
-    <div
-      class="absolute flex flex-col gap-2 right-4 bottom-4 text-gray-500 dark:text-gray-400"
-    >
-      <a href="./activity?document={{ .ID }}">{{ template "svg/activity" }}</a>
-      {{ if .Filepath }}
-        <a href="./documents/{{ .ID }}/file">{{ template "svg/download" }}</a>
-      {{ else }}
-        {{ template "svg/download" (dict "Disabled" true) }}
-      {{ end }}
-    </div>
-  </div>
-</div>

templates/components/info-card.tmpl

@@ -1,12 +0,0 @@
-{{ if .Link }}<a href="{{ .Link }}" {{ else }} <div {{ end }}class="w-full">
-<div class="flex gap-4 w-full p-4 bg-white shadow-lg dark:bg-gray-700 rounded">
-  <div class="flex flex-col justify-around dark:text-white w-full text-sm">
-    <p class="text-2xl font-bold text-black dark:text-white">{{ .Size }}</p>
-    <p class="text-sm text-gray-400">{{ .Title }}</p>
-  </div>
-</div>
-{{ if .Link }}
-</a>
-{{ else }}
-</div>
-{{ end }}

templates/components/key-val-edit.tmpl

@@ -1,32 +0,0 @@
-<div class="relative">
-  <div class="text-gray-500 inline-flex gap-2 relative">
-    <p>{{ .Title }}</p>
-    <label class="my-auto cursor-pointer" for="edit-{{ .FormValue }}-button">
-      {{ template "svg/edit" (dict "Size" 18) }}
-    </label>
-    <input
-      type="checkbox"
-      id="edit-{{ .FormValue }}-button"
-      class="hidden css-button"
-    />
-    <div
-      class="absolute z-30 top-7 right-0 p-3 transition-all duration-200 bg-gray-200 rounded shadow-lg shadow-gray-500 dark:shadow-gray-900 dark:bg-gray-600"
-    >
-      <form
-        method="POST"
-        action="{{ .URL }}"
-        class="flex flex-col gap-2 text-black dark:text-white text-sm"
-      >
-        <input
-          type="text"
-          id="{{ .FormValue }}"
-          name="{{ .FormValue }}"
-          value="{{ or .Value "N/A" }}"
-          class="p-2 bg-gray-300 text-black dark:bg-gray-700 dark:text-white"
-        />
-        {{ template "component/button" (dict "Title" "Save") }}
-      </form>
-    </div>
-  </div>
-  <p class="font-medium text-lg">{{ or .Value "N/A" }}</p>
-</div>

templates/components/leaderboard-card.tmpl

@@ -1,64 +0,0 @@
-<div class="w-full">
-  <div class="flex flex-col justify-between h-full w-full px-4 py-6 bg-white shadow-lg dark:bg-gray-700 rounded">
-    <div>
-      <div class="flex justify-between">
-        <p class="text-sm font-semibold text-gray-700 border-b border-gray-200 w-max dark:text-white dark:border-gray-500">
-          {{ .Name }} Leaderboard
-        </p>
-        <div class="flex gap-2 text-xs text-gray-400 items-center">
-          <label for="all-{{ .Name }}"
-                 class="cursor-pointer hover:text-black dark:hover:text-white">all</label>
-          <label for="year-{{ .Name }}"
-                 class="cursor-pointer hover:text-black dark:hover:text-white">year</label>
-          <label for="month-{{ .Name }}"
-                 class="cursor-pointer hover:text-black dark:hover:text-white">month</label>
-          <label for="week-{{ .Name }}"
-                 class="cursor-pointer hover:text-black dark:hover:text-white">week</label>
-        </div>
-      </div>
-    </div>
-    <input type="radio"
-           name="options-{{ .Name }}"
-           id="all-{{ .Name }}"
-           class="hidden peer/All"
-           checked />
-    <input type="radio"
-           name="options-{{ .Name }}"
-           id="year-{{ .Name }}"
-           class="hidden peer/Year" />
-    <input type="radio"
-           name="options-{{ .Name }}"
-           id="month-{{ .Name }}"
-           class="hidden peer/Month" />
-    <input type="radio"
-           name="options-{{ .Name }}"
-           id="week-{{ .Name }}"
-           class="hidden peer/Week" />
-    {{ range $key, $data := .Data }}
-    <div class="flex items-end my-6 space-x-2 hidden peer-checked/{{ $key }}:block">
-      {{ $length := len $data }}
-      {{ if eq $length 0 }}
-      <p class="text-5xl font-bold text-black dark:text-white">N/A</p>
-      {{ else }}
-      <p class="text-5xl font-bold text-black dark:text-white">{{ (index $data 0).UserID }}</p>
-      {{ end }}
-    </div>
-    <div class="hidden dark:text-white peer-checked/{{ $key }}:block">
-      {{ range $index, $item := $data }}
-      {{ if lt $index 3 }}
-      {{ if eq $index 0 }}
-      <div class="flex items-center justify-between pt-2 pb-2 text-sm">
-      {{ else }}
-      <div class="flex items-center justify-between pt-2 pb-2 text-sm border-t border-gray-200">
-      {{ end }}
-	<div>
-	  <p>{{ $item.UserID }}</p>
-	</div>
-	<div class="flex items-end font-bold">{{ $item.Value }}</div>
-      </div>
-      {{ end }}
-      {{ end }}
-    </div>
-    {{ end}}
-  </div>
-</div>

templates/components/metadata.tmpl

@@ -1,147 +0,0 @@
-{{ if .Error }}
-  <div class="absolute top-0 left-0 w-full h-full z-50">
-    <div class="fixed top-0 left-0 bg-black opacity-50 w-screen h-screen"></div>
-    <div
-      class="relative flex flex-col gap-4 p-4 max-h-[95%] bg-white dark:bg-gray-800 overflow-scroll -translate-x-2/4 -translate-y-2/4 top-1/2 left-1/2 w-5/6 overflow-hidden shadow rounded"
-    >
-      <div class="text-center">
-        <h3 class="text-lg font-bold leading-6 dark:text-gray-300">
-          No Metadata Results Found
-        </h3>
-      </div>
-      {{ template "component/button" (dict
-        "Title" "Back to Document"
-        "Type" "Link"
-        "URL" (printf "/documents/%s" .ID)
-        )
-      }}
-    </div>
-  </div>
-{{ end }}
-{{ if .Metadata }}
-  <div class="absolute top-0 left-0 w-full h-full z-50">
-    <div class="fixed top-0 left-0 bg-black opacity-50 w-screen h-screen"></div>
-    <div
-      class="relative max-h-[95%] bg-white dark:bg-gray-800 overflow-scroll -translate-x-2/4 -translate-y-2/4 top-1/2 left-1/2 w-5/6 overflow-hidden shadow rounded"
-    >
-      <div class="py-5 text-center">
-        <h3 class="text-lg font-bold leading-6 dark:text-gray-300">
-          Metadata Results
-        </h3>
-      </div>
-      <form
-        id="metadata-save"
-        method="POST"
-        action="/documents/{{ .ID }}/edit"
-        class="text-black dark:text-white border-b dark:border-black"
-      >
-        <dl>
-          <div
-            class="p-3 bg-gray-100 dark:bg-gray-900 grid grid-cols-3 gap-4 sm:px-6"
-          >
-            <dt class="my-auto font-medium text-gray-500">Cover</dt>
-            <dd class="mt-1 text-sm sm:mt-0 sm:col-span-2">
-              <img
-                class="rounded object-fill h-32"
-                src="https://books.google.com/books/content/images/frontcover/{{ .Metadata.SourceID }}?fife=w480-h690"
-              />
-            </dd>
-          </div>
-          <div
-            class="p-3 bg-white dark:bg-gray-800 grid grid-cols-3 gap-4 sm:px-6"
-          >
-            <dt class="my-auto font-medium text-gray-500">Title</dt>
-            <dd class="mt-1 text-sm sm:mt-0 sm:col-span-2">
-              {{ or .Metadata.Title "N/A" }}
-            </dd>
-          </div>
-          <div
-            class="p-3 bg-gray-100 dark:bg-gray-900 grid grid-cols-3 gap-4 sm:px-6"
-          >
-            <dt class="my-auto font-medium text-gray-500">Author</dt>
-            <dd class="mt-1 text-sm sm:mt-0 sm:col-span-2">
-              {{ or .Metadata.Author "N/A" }}
-            </dd>
-          </div>
-          <div
-            class="p-3 bg-white dark:bg-gray-800 grid grid-cols-3 gap-4 sm:px-6"
-          >
-            <dt class="my-auto font-medium text-gray-500">ISBN 10</dt>
-            <dd class="mt-1 text-sm sm:mt-0 sm:col-span-2">
-              {{ or .Metadata.ISBN10 "N/A" }}
-            </dd>
-          </div>
-          <div
-            class="p-3 bg-gray-100 dark:bg-gray-900 grid grid-cols-3 gap-4 sm:px-6"
-          >
-            <dt class="my-auto font-medium text-gray-500">ISBN 13</dt>
-            <dd class="mt-1 text-sm sm:mt-0 sm:col-span-2">
-              {{ or .Metadata.ISBN13 "N/A" }}
-            </dd>
-          </div>
-          <div
-            class="p-3 bg-white dark:bg-gray-800 sm:grid sm:grid-cols-3 sm:gap-4 px-6"
-          >
-            <dt class="my-auto font-medium text-gray-500">Description</dt>
-            <dd class="max-h-[10em] overflow-scroll mt-1 sm:mt-0 sm:col-span-2">
-              {{ or .Metadata.Description "N/A" }}
-            </dd>
-          </div>
-        </dl>
-        <div class="hidden">
-          <input
-            type="text"
-            id="title"
-            name="title"
-            value="{{ .Metadata.Title }}"
-          />
-          <input
-            type="text"
-            id="author"
-            name="author"
-            value="{{ .Metadata.Author }}"
-          />
-          <input
-            type="text"
-            id="description"
-            name="description"
-            value="{{ .Metadata.Description }}"
-          />
-          <input
-            type="text"
-            id="isbn_10"
-            name="isbn_10"
-            value="{{ .Metadata.ISBN10 }}"
-          />
-          <input
-            type="text"
-            id="isbn_13"
-            name="isbn_13"
-            value="{{ .Metadata.ISBN13 }}"
-          />
-          <input
-            type="text"
-            id="cover_gbid"
-            name="cover_gbid"
-            value="{{ .Metadata.SourceID }}"
-          />
-        </div>
-      </form>
-      <div class="flex justify-end">
-        <div class="flex gap-4 m-4 w-48">
-          {{ template "component/button" (dict
-            "Title" "Cancel"
-            "Type" "Link"
-            "URL" (printf "/documents/%s" .ID)
-            )
-          }}
-          {{ template "component/button" (dict
-            "Title" "Save"
-            "FormName" "metadata-save"
-            )
-          }}
-        </div>
-      </div>
-    </div>
-  </div>
-{{ end }}

templates/components/streak-card.tmpl

@@ -1,54 +0,0 @@
-<div class="w-full">
-  <div
-    class="relative w-full px-4 py-6 bg-white shadow-lg dark:bg-gray-700 rounded"
-  >
-    <p
-      class="text-sm font-semibold text-gray-700 border-b border-gray-200 w-max dark:text-white dark:border-gray-500"
-    >
-      {{ if eq .Window "WEEK" }}
-        Weekly Read Streak
-      {{ else }}
-        Daily Read Streak
-      {{ end }}
-    </p>
-    <div class="flex items-end my-6 space-x-2">
-      <p class="text-5xl font-bold text-black dark:text-white">
-        {{ .CurrentStreak }}
-      </p>
-    </div>
-    <div class="dark:text-white">
-      <div
-        class="flex items-center justify-between pb-2 mb-2 text-sm border-b border-gray-200"
-      >
-        <div>
-          <p>
-            {{ if eq .Window "WEEK" }}
-              Current Weekly Streak
-            {{ else }}
-              Current Daily Streak
-            {{ end }}
-          </p>
-          <div class="flex items-end text-sm text-gray-400">
-            {{ .CurrentStreakStartDate }} ➞ {{ .CurrentStreakEndDate }}
-          </div>
-        </div>
-        <div class="flex items-end font-bold">{{ .CurrentStreak }}</div>
-      </div>
-      <div class="flex items-center justify-between pb-2 mb-2 text-sm">
-        <div>
-          <p>
-            {{ if eq .Window "WEEK" }}
-              Best Weekly Streak
-            {{ else }}
-              Best Daily Streak
-            {{ end }}
-          </p>
-          <div class="flex items-end text-sm text-gray-400">
-            {{ .MaxStreakStartDate }} ➞ {{ .MaxStreakEndDate }}
-          </div>
-        </div>
-        <div class="flex items-end font-bold">{{ .MaxStreak }}</div>
-      </div>
-    </div>
-  </div>
-</div>

templates/components/table.tmpl

@@ -1,32 +0,0 @@
-{{ $rows := .Rows }}
-{{ $cols := .Columns }}
-{{ $keys := .Keys }}
-<table class="min-w-full leading-normal bg-white dark:bg-gray-700 text-sm">
-  <thead class="text-gray-800 dark:text-gray-400">
-    <tr>
-      {{ range $col := $cols }}
-        <th
-          class="p-3 font-normal text-left uppercase border-b border-gray-200 dark:border-gray-800"
-        >
-          {{ $col }}
-        </th>
-      {{ end }}
-    </tr>
-  </thead>
-  <tbody class="text-black dark:text-white">
-    {{ if not $rows }}
-      <tr>
-        <td class="text-center p-3" colspan="4">No Results</td>
-      </tr>
-    {{ end }}
-    {{ range $row := $rows }}
-      <tr>
-        {{ range $key := $keys }}
-          <td class="p-3 border-b border-gray-200">
-            {{ template "table-cell" (dict "Data" $row "Name" $key ) }}
-          </td>
-        {{ end }}
-      </tr>
-    {{ end }}
-  </tbody>
-</table>

templates/pages/activity.tmpl

@@ -1,28 +0,0 @@
-{{ template "base" . }}
-{{ define "title" }}Activity{{ end }}
-{{ define "header" }}<a href="./activity">Activity</a>{{ end }}
-{{ define "content" }}
-  <div class="overflow-x-auto">
-    <div class="inline-block min-w-full overflow-hidden rounded shadow">
-      <!-- Table Component - Utilizes Template "table-cell" -->
-      {{ template "component/table" (dict
-        "Columns" (slice "Document" "Time" "Duration" "Percent")
-        "Keys" (slice "Document" "StartTime" "Duration" "EndPercentage")
-        "Rows" .Data
-        )
-      }}
-    </div>
-  </div>
-{{ end }}
-<!-- Table Cell Definition -->
-{{ define "table-cell" }}
-  {{ if eq .Name "Document" }}
-    <a href="./documents/{{ .Data.DocumentID }}"
-      >{{ .Data.Author }} - {{ .Data.Title }}</a
-    >
-  {{ else if eq .Name "EndPercentage" }}
-    {{ index (fields .Data) .Name }}%
-  {{ else }}
-    {{ index (fields .Data) .Name }}
-  {{ end }}
-{{ end }}

templates/pages/document.tmpl

@@ -1,254 +0,0 @@
-{{ template "base" . }}
-{{ define "title" }}Documents{{ end }}
-{{ define "header" }}<a href="/documents">Documents</a>{{ end }}
-{{ define "content" }}
-  <div class="h-full w-full relative">
-    <!-- Document Info -->
-    <div
-      class="h-full w-full overflow-scroll bg-white shadow-lg dark:bg-gray-700 rounded dark:text-white p-4"
-    >
-      <div
-        class="flex flex-col gap-2 float-left w-44 md:w-60 lg:w-80 mr-4 mb-2 relative"
-      >
-        <label class="z-10 cursor-pointer" for="edit-cover-button">
-          <img
-            class="rounded object-fill w-full"
-            src="/documents/{{ .Data.ID }}/cover"
-          />
-        </label>
-        {{ if .Data.Filepath }}
-          <a
-            href="/reader#id={{ .Data.ID }}&type=REMOTE"
-            class="z-10 text-white bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:ring-blue-300 font-medium rounded text-sm text-center py-1 dark:bg-blue-600 dark:hover:bg-blue-700 focus:outline-none dark:focus:ring-blue-800"
-            >Read</a
-          >
-        {{ end }}
-        <div class="flex flex-wrap-reverse justify-between z-20 gap-2 relative">
-          <div class="min-w-[50%] md:mr-2">
-            <div class="flex gap-1 text-sm">
-              <p class="text-gray-500">ISBN-10:</p>
-              <p class="font-medium">{{ or .Data.Isbn10 "N/A" }}</p>
-            </div>
-            <div class="flex gap-1 text-sm">
-              <p class="text-gray-500">ISBN-13:</p>
-              <p class="font-medium">{{ or .Data.Isbn13 "N/A" }}</p>
-            </div>
-          </div>
-          <div
-            class="flex grow justify-between my-auto text-gray-500 dark:text-gray-500"
-          >
-            <input
-              type="checkbox"
-              id="edit-cover-button"
-              class="hidden css-button"
-            />
-            <div
-              class="absolute z-30 flex flex-col gap-2 top-0 left-0 p-3 transition-all duration-200 bg-gray-200 rounded shadow-lg shadow-gray-500 dark:shadow-gray-900 dark:bg-gray-600"
-            >
-              <form
-                method="POST"
-                enctype="multipart/form-data"
-                action="./{{ .Data.ID }}/edit"
-                class="flex flex-col gap-2 w-72 text-black dark:text-white text-sm"
-              >
-                <input type="file" id="cover_file" name="cover_file" />
-                {{ template "component/button" (dict "Title" "Upload Cover") }}
-              </form>
-              <form
-                method="POST"
-                action="./{{ .Data.ID }}/edit"
-                class="flex flex-col gap-2 w-72 text-black dark:text-white text-sm"
-              >
-                <input
-                  type="checkbox"
-                  checked
-                  id="remove_cover"
-                  name="remove_cover"
-                  class="hidden"
-                />
-                {{ template "component/button" (dict "Title" "Remove Cover") }}
-              </form>
-            </div>
-            <div class="relative">
-              <label for="delete-button" class="cursor-pointer"
-                >{{ template "svg/delete" (dict "Size" 28) }}</label
-              >
-              <input
-                type="checkbox"
-                id="delete-button"
-                class="hidden css-button"
-              />
-              <div
-                class="absolute z-30 bottom-7 left-5 p-3 transition-all duration-200 bg-gray-200 rounded shadow-lg shadow-gray-500 dark:shadow-gray-900 dark:bg-gray-600"
-              >
-                <form
-                  method="POST"
-                  action="./{{ .Data.ID }}/delete"
-                  class="text-black dark:text-white text-sm w-24"
-                >
-                  {{ template "component/button" (dict "Title" "Delete") }}
-                </form>
-              </div>
-            </div>
-            <a href="../activity?document={{ .Data.ID }}"
-              >{{ template "svg/activity" (dict "Size" 28) }}</a
-            >
-            <div class="relative">
-              <label for="search-button"
-                >{{ template "svg/search" (dict "Size" 28) }}</label
-              >
-              <input
-                type="checkbox"
-                id="search-button"
-                class="hidden css-button"
-              />
-              <div
-                class="absolute z-30 bottom-7 left-5 p-3 transition-all duration-200 bg-gray-200 rounded shadow-lg shadow-gray-500 dark:shadow-gray-900 dark:bg-gray-600"
-              >
-                <form
-                  method="POST"
-                  action="./{{ .Data.ID }}/identify"
-                  class="flex flex-col gap-2 text-black dark:text-white text-sm"
-                >
-                  <input
-                    type="text"
-                    id="title"
-                    name="title"
-                    placeholder="Title"
-                    value="{{ or .Data.Title nil }}"
-                    class="p-2 bg-gray-300 text-black dark:bg-gray-700 dark:text-white"
-                  />
-                  <input
-                    type="text"
-                    id="author"
-                    name="author"
-                    placeholder="Author"
-                    value="{{ or .Data.Author nil }}"
-                    class="p-2 bg-gray-300 text-black dark:bg-gray-700 dark:text-white"
-                  />
-                  <input
-                    type="text"
-                    id="isbn"
-                    name="isbn"
-                    placeholder="ISBN 10 / ISBN 13"
-                    value="{{ or .Data.Isbn13 (or .Data.Isbn10 nil) }}"
-                    class="p-2 bg-gray-300 text-black dark:bg-gray-700 dark:text-white"
-                  />
-                  {{ template "component/button" (dict "Title" "Identify") }}
-                </form>
-              </div>
-            </div>
-            {{ if .Data.Filepath }}
-              <a href="./{{ .Data.ID }}/file"
-                >{{ template "svg/download" (dict "Size" 28) }}</a
-              >
-            {{ else }}
-              {{ template "svg/download" (dict "Size" 28 "Disabled" true) }}
-            {{ end }}
-          </div>
-        </div>
-      </div>
-      <div class="grid sm:grid-cols-2 justify-between gap-4 pb-4">
-        {{ template "component/key-val-edit" (dict
-          "Title" "Title"
-          "Value" .Data.Title
-          "URL" (printf "./%s/edit" .Data.ID)
-          "FormValue" "title"
-          )
-        }}
-        {{ template "component/key-val-edit" (dict
-          "Title" "Author"
-          "Value" .Data.Author
-          "URL" (printf "./%s/edit" .Data.ID)
-          "FormValue" "author"
-          )
-        }}
-        <div class="relative">
-          <div class="text-gray-500 inline-flex gap-2 relative">
-            <p>Time Read</p>
-            <label class="my-auto" for="progress-info-button"
-              >{{ template "svg/info" (dict "Size" 18) }}</label
-            >
-            <input
-              type="checkbox"
-              id="progress-info-button"
-              class="hidden css-button"
-            />
-            <div
-              class="absolute z-30 top-7 right-0 p-3 transition-all duration-200 bg-gray-200 rounded shadow-lg shadow-gray-500 dark:shadow-gray-900 dark:bg-gray-600"
-            >
-              <div class="text-xs flex">
-                <p class="text-gray-400 w-32">Seconds / Percent</p>
-                <p class="font-medium dark:text-white">
-                  {{ .Data.SecondsPerPercent }}
-                </p>
-              </div>
-              <div class="text-xs flex">
-                <p class="text-gray-400 w-32">Words / Minute</p>
-                <p class="font-medium dark:text-white">{{ .Data.Wpm }}</p>
-              </div>
-              <div class="text-xs flex">
-                <p class="text-gray-400 w-32">Est. Time Left</p>
-                <p class="font-medium dark:text-white whitespace-nowrap">
-                  {{ niceSeconds .TotalTimeLeftSeconds }}
-                </p>
-              </div>
-            </div>
-          </div>
-          <p class="font-medium text-lg">
-            {{ niceSeconds .Data.TotalTimeSeconds }}
-          </p>
-        </div>
-        <div>
-          <p class="text-gray-500">Progress</p>
-          <p class="font-medium text-lg">{{ .Data.Percentage }}%</p>
-        </div>
-      </div>
-      <div class="relative">
-        <div class="text-gray-500 inline-flex gap-2 relative">
-          <p>Description</p>
-          <label class="my-auto" for="edit-description-button"
-            >{{ template "svg/edit" (dict "Size" 18) }}</label
-          >
-        </div>
-      </div>
-      <div class="relative font-medium text-justify hyphens-auto">
-        <input
-          type="checkbox"
-          id="edit-description-button"
-          class="hidden css-button"
-        />
-        <div
-          class="absolute h-full w-full min-h-[10em] z-30 top-1 right-0 gap-4 flex transition-all duration-200"
-        >
-          <img
-            class="hidden md:block invisible rounded w-44 md:w-60 lg:w-80 object-fill"
-            src="/documents/{{ .Data.ID }}/cover"
-          />
-          <form
-            method="POST"
-            action="./{{ .Data.ID }}/edit"
-            class="flex flex-col gap-2 w-full text-black bg-gray-200 rounded shadow-lg shadow-gray-500 dark:text-white dark:shadow-gray-900 dark:bg-gray-600 text-sm p-3"
-          >
-            <textarea
-              type="text"
-              id="description"
-              name="description"
-              class="h-full w-full p-2 bg-gray-300 text-black dark:bg-gray-700 dark:text-white"
-            >
-{{ or .Data.Description "N/A" }}</textarea
-            >
-            {{ template "component/button" (dict "Title" "Save") }}
-          </form>
-        </div>
-        <p>{{ or .Data.Description "N/A" }}</p>
-      </div>
-    </div>
-    {{ template "component/metadata" (dict
-      "ID" .Data.ID
-      "Metadata" .Metadata
-      "Error" .MetadataError
-      )
-    }}
-  </div>
-{{ end }}

templates/pages/documents.tmpl

@@ -1,99 +0,0 @@
-{{ template "base" . }}
-{{ define "title" }}Documents{{ end }}
-{{ define "header" }}<a href="./documents">Documents</a>{{ end }}
-{{ define "content" }}
-  <div
-    class="flex flex-col gap-2 grow p-4 mb-4 rounded shadow-lg bg-white dark:bg-gray-700 text-gray-500 dark:text-white"
-  >
-    <form
-      class="flex gap-4 flex-col lg:flex-row"
-      action="./documents"
-      method="GET"
-    >
-      <div class="flex flex-col w-full grow">
-        <div class="flex relative">
-          <span
-            class="inline-flex items-center px-3 border-t bg-white border-l border-b border-gray-300 text-gray-500 shadow-sm text-sm"
-          >
-            {{ template "svg/search2" (dict "Size" 15) }}
-          </span>
-          <input
-            type="text"
-            id="search"
-            name="search"
-            class="flex-1 appearance-none rounded-none border border-gray-300 w-full py-2 px-2 bg-white text-gray-700 placeholder-gray-400 shadow-sm text-base focus:outline-none focus:ring-2 focus:ring-purple-600 focus:border-transparent"
-            placeholder="Search Author / Title"
-          />
-        </div>
-      </div>
-      <div class="lg:w-60">
-        {{ template "component/button" (dict
-          "Title" "Search"
-          "Variant" "Secondary"
-          )
-        }}
-      </div>
-    </form>
-  </div>
-  <div class="grid grid-cols-1 gap-4 md:grid-cols-2 lg:grid-cols-3">
-    {{ range $doc := .Data }}
-      {{ template "component/document-card" $doc }}
-    {{ end }}
-  </div>
-  <div class="w-full flex gap-4 justify-center mt-4 text-black dark:text-white">
-    {{ if .PreviousPage }}
-      <a
-        href="./documents?page={{ .PreviousPage }}&limit={{ .PageLimit }}"
-        class="bg-white shadow-lg dark:bg-gray-600 hover:bg-gray-400 font-medium rounded text-sm text-center p-2 w-24 dark:hover:bg-gray-700 focus:outline-none"
-        >◄</a
-      >
-    {{ end }}
-    {{ if .NextPage }}
-      <a
-        href="./documents?page={{ .NextPage }}&limit={{ .PageLimit }}"
-        class="bg-white shadow-lg dark:bg-gray-600 hover:bg-gray-400 font-medium rounded text-sm text-center p-2 w-24 dark:hover:bg-gray-700 focus:outline-none"
-        >►</a
-      >
-    {{ end }}
-  </div>
-  <div
-    class="fixed bottom-6 right-6 rounded-full flex items-center justify-center"
-  >
-    <input type="checkbox" id="upload-file-button" class="hidden css-button" />
-    <div
-      class="absolute right-0 z-10 bottom-0 rounded p-4 bg-gray-800 dark:bg-gray-200 text-white dark:text-black w-72 text-sm flex flex-col gap-2"
-    >
-      <form
-        method="POST"
-        enctype="multipart/form-data"
-        action="./documents"
-        class="flex flex-col gap-2"
-      >
-        <input
-          type="file"
-          accept=".epub"
-          id="document_file"
-          name="document_file"
-        />
-        <button
-          class="font-medium px-2 py-1 text-gray-800 bg-gray-500 dark:text-white hover:bg-gray-100 dark:hover:bg-gray-800"
-          type="submit"
-        >
-          Upload File
-        </button>
-      </form>
-      <label for="upload-file-button">
-        <div
-          class="w-full text-center cursor-pointer font-medium mt-2 px-2 py-1 text-gray-800 bg-gray-500 dark:text-white hover:bg-gray-100 dark:hover:bg-gray-800"
-        >
-          Cancel Upload
-        </div>
-      </label>
-    </div>
-    <label
-      class="w-16 h-16 bg-gray-800 dark:bg-gray-200 rounded-full flex items-center justify-center opacity-30 hover:opacity-100 transition-all duration-200 cursor-pointer"
-      for="upload-file-button"
-      >{{ template "svg/upload" (dict "Size" 34) }}</label
-    >
-  </div>
-{{ end }}

templates/pages/home.tmpl

@@ -1,109 +0,0 @@
-{{ template "base" . }}
-{{ define "title" }}Home{{ end }}
-{{ define "header" }}<a href="./">Home</a>{{ end }}
-{{ define "content" }}
-  <div class="flex flex-col gap-4">
-    <div class="w-full">
-      <div class="relative w-full bg-white shadow-lg dark:bg-gray-700 rounded">
-        <p
-          class="absolute top-3 left-5 text-sm font-semibold text-gray-700 border-b border-gray-200 w-max dark:text-white dark:border-gray-500"
-        >
-          Daily Read Totals
-        </p>
-        {{ $data := (getSVGGraphData .Data.GraphData 800 70 ) }}
-        <div class="relative">
-          <svg
-            viewBox="26 0 755 {{ $data.Height }}"
-            preserveAspectRatio="none"
-            width="100%"
-            height="6em"
-          >
-            <!-- Bezier Line Graph -->
-            <path
-              fill="#316BBE"
-              fill-opacity="0.5"
-              stroke="none"
-              d="{{ $data.BezierPath }} {{ $data.BezierFill }}"
-            />
-            <path fill="none" stroke="#316BBE" d="{{ $data.BezierPath }}" />
-          </svg>
-          <div
-            class="flex absolute w-full h-full top-0"
-            style="width: calc(100%*31/30);
-                    transform: translateX(-50%);
-                    left: 50%"
-          >
-            {{ range $index, $item := $data.LinePoints }}
-              <!-- Required for iOS "Hover" Events (onclick) -->
-              <div
-                onclick
-                class="opacity-0 hover:opacity-100 w-full"
-                style="background: linear-gradient(rgba(128, 128, 128, 0.5), rgba(128, 128, 128, 0.5)) no-repeat center/2px 100%"
-              >
-                <div
-                  class="flex flex-col items-center p-2 rounded absolute top-3 dark:text-white text-xs pointer-events-none"
-                  style="transform: translateX(-50%);
-                        background-color: rgba(128, 128, 128, 0.2);
-                        left: 50%"
-                >
-                  <span>{{ (index $.Data.GraphData $index).Date }}</span>
-                  <span
-                    >{{ (index $.Data.GraphData $index).MinutesRead }}
-                    minutes</span
-                  >
-                </div>
-              </div>
-            {{ end }}
-          </div>
-        </div>
-      </div>
-    </div>
-    <div class="grid grid-cols-2 gap-4 md:grid-cols-4">
-      {{ template "component/info-card" (dict
-        "Title" "Documents"
-        "Size" .Data.DatabaseInfo.DocumentsSize
-        "Link" "./documents"
-        )
-      }}
-      {{ template "component/info-card" (dict
-        "Title" "Activity Records"
-        "Size" .Data.DatabaseInfo.ActivitySize
-        "Link" "./activity"
-        )
-      }}
-      {{ template "component/info-card" (dict
-        "Title" "Progress Records"
-        "Size" .Data.DatabaseInfo.ProgressSize
-        "Link" "./progress"
-        )
-      }}
-      {{ template "component/info-card" (dict
-        "Title" "Devices"
-        "Size" .Data.DatabaseInfo.DevicesSize
-        )
-      }}
-    </div>
-    <div class="grid grid-cols-1 gap-4 md:grid-cols-2">
-      {{ range $item := .Data.Streaks }}
-        {{ template "component/streak-card" $item }}
-      {{ end }}
-    </div>
-    <div class="grid grid-cols-1 gap-4 md:grid-cols-2 lg:grid-cols-3">
-      {{ template "component/leaderboard-card" (dict
-        "Name" "WPM"
-        "Data" .Data.UserStatistics.WPM
-        )
-      }}
-      {{ template "component/leaderboard-card" (dict
-        "Name" "Duration"
-        "Data" .Data.UserStatistics.Duration
-        )
-      }}
-      {{ template "component/leaderboard-card" (dict
-        "Name" "Words"
-        "Data" .Data.UserStatistics.Words
-        )
-      }}
-    </div>
-  </div>
-{{ end }}

templates/pages/progress.tmpl

@@ -1,28 +0,0 @@
-{{ template "base" . }}
-{{ define "title" }}Progress{{ end }}
-{{ define "header" }}<a href="./progress">Progress</a>{{ end }}
-{{ define "content" }}
-  <div class="overflow-x-auto">
-    <div class="inline-block min-w-full overflow-hidden rounded shadow">
-      <!-- Table Component - Utilizes Template "table-cell" -->
-      {{ template "component/table" (dict
-        "Columns" (slice "Document" "Device Name" "Percentage" "Created At")
-        "Keys" (slice "Document" "DeviceName" "Percentage" "CreatedAt")
-        "Rows" .Data
-        )
-      }}
-    </div>
-  </div>
-{{ end }}
-<!-- Table Cell Definition -->
-{{ define "table-cell" }}
-  {{ if eq .Name "Document" }}
-    <a href="./documents/{{ .Data.DocumentID }}"
-      >{{ .Data.Author }} - {{ .Data.Title }}</a
-    >
-  {{ else if eq .Name "Percentage" }}
-    {{ index (fields .Data) .Name }}%
-  {{ else }}
-    {{ index (fields .Data) .Name }}
-  {{ end }}
-{{ end }}

templates/pages/search.tmpl

@@ -1,157 +0,0 @@
-{{ template "base" . }}
-{{ define "title" }}Search{{ end }}
-{{ define "header" }}<a href="./search">Search</a>{{ end }}
-{{ define "content" }}
-  <div class="w-full flex flex-col md:flex-row gap-4">
-    <div class="flex flex-col gap-4 grow">
-      <div
-        class="flex flex-col gap-2 grow p-4 rounded shadow-lg bg-white dark:bg-gray-700 text-gray-500 dark:text-white"
-      >
-        <form class="flex gap-4 flex-col lg:flex-row" action="./search">
-          <div class="flex flex-col w-full grow">
-            <div class="flex relative">
-              <span
-                class="inline-flex items-center px-3 border-t bg-white border-l border-b border-gray-300 text-gray-500 shadow-sm text-sm"
-              >
-                {{ template "svg/search2" (dict "Size" 15) }}
-              </span>
-              <input
-                type="text"
-                id="query"
-                name="query"
-                class="flex-1 appearance-none rounded-none border border-gray-300 w-full py-2 px-4 bg-white text-gray-700 placeholder-gray-400 shadow-sm text-base focus:outline-none focus:ring-2 focus:ring-purple-600 focus:border-transparent"
-                placeholder="Query"
-              />
-            </div>
-          </div>
-          <div class="flex relative min-w-[12em]">
-            <span
-              class="inline-flex items-center px-3 border-t bg-white border-l border-b border-gray-300 text-gray-500 shadow-sm text-sm"
-            >
-              {{ template "svg/documents" (dict "Size" 15) }}
-            </span>
-            <select
-              class="flex-1 appearance-none rounded-none border border-gray-300 w-full py-2 px-4 bg-white text-gray-700 placeholder-gray-400 shadow-sm text-base focus:outline-none focus:ring-2 focus:ring-purple-600 focus:border-transparent"
-              id="source"
-              name="source"
-            >
-              <option value="LibGen">Library Genesis</option>
-              <option value="Annas Archive">Annas Archive</option>
-            </select>
-          </div>
-          <div class="lg:w-60">
-            {{ template "component/button" (dict
-              "Title" "Search"
-              "Variant" "Secondary"
-              )
-            }}
-          </div>
-        </form>
-        {{ if .SearchErrorMessage }}
-          <span class="text-red-400 text-xs">{{ .SearchErrorMessage }}</span>
-        {{ end }}
-      </div>
-      <div class="inline-block min-w-full overflow-hidden rounded shadow">
-        <table
-          class="min-w-full leading-normal bg-white dark:bg-gray-700 text-sm md:text-sm"
-        >
-          <thead class="text-gray-800 dark:text-gray-400">
-            <tr>
-              <th
-                scope="col"
-                class="w-12 p-3 font-normal text-left uppercase border-b border-gray-200 dark:border-gray-800"
-              ></th>
-              <th
-                scope="col"
-                class="p-3 font-normal text-left uppercase border-b border-gray-200 dark:border-gray-800"
-              >
-                Document
-              </th>
-              <th
-                scope="col"
-                class="p-3 font-normal text-left uppercase border-b border-gray-200 dark:border-gray-800"
-              >
-                Series
-              </th>
-              <th
-                scope="col"
-                class="p-3 font-normal text-left uppercase border-b border-gray-200 dark:border-gray-800"
-              >
-                Type
-              </th>
-              <th
-                scope="col"
-                class="p-3 font-normal text-left uppercase border-b border-gray-200 dark:border-gray-800"
-              >
-                Size
-              </th>
-              <th
-                scope="col"
-                class="p-3 hidden md:block font-normal text-left uppercase border-b border-gray-200 dark:border-gray-800"
-              >
-                Date
-              </th>
-            </tr>
-          </thead>
-          <tbody class="text-black dark:text-white">
-            {{ if not .Data }}
-              <tr>
-                <td class="text-center p-3" colspan="6">No Results</td>
-              </tr>
-            {{ end }}
-            {{ range $item := .Data }}
-              <tr>
-                <td
-                  class="p-3 border-b border-gray-200 text-gray-500 dark:text-gray-500"
-                >
-                  <form action="./search" method="POST">
-                    <input
-                      class="hidden"
-                      type="text"
-                      id="source"
-                      name="source"
-                      value="{{ $.Source }}"
-                    />
-                    <input
-                      class="hidden"
-                      type="text"
-                      id="title"
-                      name="title"
-                      value="{{ $item.Title }}"
-                    />
-                    <input
-                      class="hidden"
-                      type="text"
-                      id="author"
-                      name="author"
-                      value="{{ $item.Author }}"
-                    />
-                    <button name="id" value="{{ $item.ID }}">
-                      {{ template "svg/download" }}
-                    </button>
-                  </form>
-                </td>
-                <td class="p-3 border-b border-gray-200">
-                  {{ $item.Author }} -
-                  {{ $item.Title }}
-                </td>
-                <td class="p-3 border-b border-gray-200">
-                  <p>{{ or $item.Series "N/A" }}</p>
-                </td>
-                <td class="p-3 border-b border-gray-200">
-                  <p>{{ or $item.FileType "N/A" }}</p>
-                </td>
-                <td class="p-3 border-b border-gray-200">
-                  <p>{{ or $item.FileSize "N/A" }}</p>
-                </td>
-                <td class="hidden md:table-cell p-3 border-b border-gray-200">
-                  <p>{{ or $item.UploadDate "N/A" }}</p>
-                </td>
-              </tr>
-            {{ end }}
-          </tbody>
-        </table>
-      </div>
-    </div>
-  </div>
-{{ end }}

web/assets/svgs/password.svg

@@ -1 +1 @@
-<path fill-rule="nonzero" fill="rgb(0%, 0%, 0%)" fill-opacity="1" d="M 18.429688 10.285156 C 18.785156 10.285156 19.089844 10.410156 19.339844 10.660156 C 19.589844 10.910156 19.714844 11.214844 19.714844 11.570312 L 19.714844 19.285156 C 19.714844 19.644531 19.589844 19.945312 19.339844 20.195312 C 19.089844 20.445312 18.785156 20.570312 18.429688 20.570312 L 5.570312 20.570312 C 5.214844 20.570312 4.910156 20.445312 4.660156 20.195312 C 4.410156 19.945312 4.285156 19.644531 4.285156 19.285156 L 4.285156 11.570312 C 4.285156 11.214844 4.410156 10.910156 4.660156 10.660156 C 4.910156 10.410156 5.214844 10.285156 5.570312 10.285156 L 6 10.285156 L 6 6 C 6 4.347656 6.585938 2.933594 7.761719 1.761719 C 8.933594 0.585938 10.347656 0 12 0 C 13.652344 0 15.066406 0.585938 16.238281 1.761719 C 17.414062 2.933594 18 4.347656 18 6 C 18 6.230469 17.914062 6.433594 17.746094 6.601562 C 17.574219 6.773438 17.375 6.855469 17.144531 6.855469 L 16.285156 6.855469 C 16.054688 6.855469 15.851562 6.773438 15.683594 6.601562 C 15.511719 6.433594 15.429688 6.230469 15.429688 6 C 15.429688 5.054688 15.09375 4.246094 14.425781 3.574219 C 13.753906 2.90625 12.945312 2.570312 12 2.570312 C 11.054688 2.570312 10.246094 2.90625 9.574219 3.574219 C 8.90625 4.246094 8.570312 5.054688 8.570312 6 L 8.570312 10.285156 Z M 18.429688 10.285156 "/>
+<path fill-rule="nonzero" fill-opacity="1" d="M 18.429688 10.285156 C 18.785156 10.285156 19.089844 10.410156 19.339844 10.660156 C 19.589844 10.910156 19.714844 11.214844 19.714844 11.570312 L 19.714844 19.285156 C 19.714844 19.644531 19.589844 19.945312 19.339844 20.195312 C 19.089844 20.445312 18.785156 20.570312 18.429688 20.570312 L 5.570312 20.570312 C 5.214844 20.570312 4.910156 20.445312 4.660156 20.195312 C 4.410156 19.945312 4.285156 19.644531 4.285156 19.285156 L 4.285156 11.570312 C 4.285156 11.214844 4.410156 10.910156 4.660156 10.660156 C 4.910156 10.410156 5.214844 10.285156 5.570312 10.285156 L 6 10.285156 L 6 6 C 6 4.347656 6.585938 2.933594 7.761719 1.761719 C 8.933594 0.585938 10.347656 0 12 0 C 13.652344 0 15.066406 0.585938 16.238281 1.761719 C 17.414062 2.933594 18 4.347656 18 6 C 18 6.230469 17.914062 6.433594 17.746094 6.601562 C 17.574219 6.773438 17.375 6.855469 17.144531 6.855469 L 16.285156 6.855469 C 16.054688 6.855469 15.851562 6.773438 15.683594 6.601562 C 15.511719 6.433594 15.429688 6.230469 15.429688 6 C 15.429688 5.054688 15.09375 4.246094 14.425781 3.574219 C 13.753906 2.90625 12.945312 2.570312 12 2.570312 C 11.054688 2.570312 10.246094 2.90625 9.574219 3.574219 C 8.90625 4.246094 8.570312 5.054688 8.570312 6 L 8.570312 10.285156 Z M 18.429688 10.285156 "/>

web/components/document/identify.go

@@ -15,21 +15,6 @@ func IdentifyPopover(docID string, m *models.DocumentMetadata) g.Node {
 		return nil
 	}
 
-	if m.Error != nil {
-		return ui.Popover(h.Div(
-			h.Class("flex flex-col gap-2"),
-			h.H3(
-				h.Class("text-lg font-bold text-center"),
-				g.Text("Error"),
-			),
-			h.Div(
-				h.Class("bg-gray-100 dark:bg-gray-900 p-2"),
-				h.P(g.Text(*m.Error)),
-			),
-			ui.LinkButton(g.Text("Back to Document"), fmt.Sprintf("/documents/%s", docID)),
-		))
-	}
-
 	return ui.Popover(h.Div(
 		h.Class("flex flex-col gap-2"),
 		h.H3(

web/components/ui/notification.go

@@ -0,0 +1,28 @@
+package ui
+
+import (
+	g "maragu.dev/gomponents"
+	h "maragu.dev/gomponents/html"
+	"reichard.io/antholume/pkg/sliceutils"
+	"reichard.io/antholume/web/models"
+)
+
+func Notifications(notifications []*models.Notification) g.Node {
+	if len(notifications) == 0 {
+		return nil
+	}
+	return h.Div(
+		h.Class("fixed flex flex-col gap-2 bottom-0 right-0 text-white dark:text-black"),
+		g.Group(sliceutils.Map(notifications, notificationNode)),
+	)
+}
+
+func notificationNode(n *models.Notification) g.Node {
+	return h.Div(
+		h.Class("p-2 sm:p-4 animate-notification"),
+		h.Div(
+			h.Class("bg-gray-600 dark:bg-gray-400 px-4 py-2 rounded-lg shadow-lg w-64"),
+			g.Text(n.Content),
+		),
+	)
+}

web/models/device.go

@@ -0,0 +1,7 @@
+package models
+
+type Device struct {
+	DeviceName string
+	LastSynced string
+	CreatedAt  string
+}

web/models/document.go

@@ -29,5 +29,4 @@ type DocumentMetadata struct {
 	Author      string
 	Description string
 	Source      metadata.Source
-	Error       *string
 }

web/models/info.go

@@ -0,0 +1,12 @@
+package models
+
+type UserInfo struct {
+	Username string
+	IsAdmin  bool
+}
+
+type ServerInfo struct {
+	RegistrationEnabled bool
+	SearchEnabled       bool
+	Version             string
+}

web/models/notification.go

@@ -0,0 +1,13 @@
+package models
+
+type NotificationType int
+
+const (
+	NotificationTypeSuccess NotificationType = iota
+	NotificationTypeError
+)
+
+type Notification struct {
+	Content string
+	Type    NotificationType
+}

web/models/page.go

@@ -0,0 +1,52 @@
+package models
+
+type PageContext struct {
+	Route         PageRoute
+	UserInfo      *UserInfo
+	ServerInfo    *ServerInfo
+	Notifications []*Notification
+}
+
+func (ctx PageContext) WithRoute(route PageRoute) PageContext {
+	ctx.Route = route
+	return ctx
+}
+
+type PageRoute string
+
+const (
+	HomePage         PageRoute = "home"
+	DocumentPage     PageRoute = "document"
+	DocumentsPage    PageRoute = "documents"
+	ProgressPage     PageRoute = "progress"
+	ActivityPage     PageRoute = "activity"
+	SearchPage       PageRoute = "search"
+	SettingsPage     PageRoute = "settings"
+	AdminGeneralPage PageRoute = "admin-general"
+	AdminImportPage  PageRoute = "admin-import"
+	AdminUsersPage   PageRoute = "admin-users"
+	AdminLogsPage    PageRoute = "admin-logs"
+)
+
+var pageTitleMap = map[PageRoute]string{
+	HomePage:         "Home",
+	DocumentPage:     "Document",
+	DocumentsPage:    "Documents",
+	ProgressPage:     "Progress",
+	ActivityPage:     "Activity",
+	SearchPage:       "Search",
+	SettingsPage:     "Settings",
+	AdminGeneralPage: "Admin - General",
+	AdminImportPage:  "Admin - Import",
+	AdminUsersPage:   "Admin - Users",
+	AdminLogsPage:    "Admin - Logs",
+}
+
+func (p PageRoute) Title() string {
+	return pageTitleMap[p]
+}
+
+func (p PageRoute) Valid() bool {
+	_, ok := pageTitleMap[p]
+	return ok
+}

web/pages/activity.go

@@ -9,6 +9,7 @@ import (
 	"reichard.io/antholume/pkg/sliceutils"
 	"reichard.io/antholume/web/components/ui"
 	"reichard.io/antholume/web/models"
+	"reichard.io/antholume/web/pages/layout"
 )
 
 var _ Page = (*Activity)(nil)
@@ -17,15 +18,16 @@ type Activity struct {
 	Data []models.Activity
 }
 
-func (Activity) Route() PageRoute { return ActivityPage }
-
-func (p Activity) Render() g.Node {
-	return h.Div(
+func (p *Activity) Generate(ctx models.PageContext) (g.Node, error) {
+	return layout.Layout(
+		ctx.WithRoute(models.ActivityPage),
+		h.Div(
 			h.Class("overflow-x-auto"),
 			h.Div(
 				h.Class("inline-block min-w-full overflow-hidden rounded shadow"),
 				ui.Table(p.buildTableConfig()),
 			),
+		),
 	)
 }
 

web/pages/admin.go

@@ -0,0 +1,153 @@
+package pages
+
+import (
+	g "maragu.dev/gomponents"
+	h "maragu.dev/gomponents/html"
+
+	"reichard.io/antholume/web/components/ui"
+	"reichard.io/antholume/web/models"
+	"reichard.io/antholume/web/pages/layout"
+)
+
+var _ Page = (*AdminGeneral)(nil)
+
+type AdminGeneral struct{}
+
+func (p *AdminGeneral) Generate(ctx models.PageContext) (g.Node, error) {
+	return layout.Layout(
+		ctx.WithRoute(models.AdminGeneralPage),
+		h.Div(
+			h.Class("w-full flex flex-col gap-4 grow"),
+			backupAndRestoreSection(),
+			tasksSection(),
+		),
+	)
+}
+
+func backupAndRestoreSection() g.Node {
+	return h.Div(
+		h.Class("flex flex-col gap-2 grow p-4 rounded shadow-lg bg-white dark:bg-gray-700 text-gray-500 dark:text-white"),
+		h.P(
+			h.Class("text-lg font-semibold mb-2"),
+			g.Text("Backup & Restore"),
+		),
+		h.Div(
+			h.Class("flex flex-col gap-4"),
+			backupForm(),
+			restoreForm(),
+		),
+	)
+}
+
+func backupForm() g.Node {
+	return h.Form(
+		h.Class("flex justify-between"),
+		h.Action("./admin"),
+		h.Method("POST"),
+		h.Input(
+			h.Type("text"),
+			h.Name("action"),
+			h.Value("BACKUP"),
+			h.Class("hidden"),
+		),
+		h.Div(
+			h.Class("flex gap-8"),
+			h.Div(
+				h.Class("flex gap-2 items-center"),
+				h.Input(
+					h.Type("checkbox"),
+					h.ID("backup_covers"),
+					h.Name("backup_types"),
+					h.Value("COVERS"),
+				),
+				h.Label(
+					h.For("backup_covers"),
+					g.Text("Covers"),
+				),
+			),
+			h.Div(
+				h.Class("flex gap-2 items-center"),
+				h.Input(
+					h.Type("checkbox"),
+					h.ID("backup_documents"),
+					h.Name("backup_types"),
+					h.Value("DOCUMENTS"),
+				),
+				h.Label(
+					h.For("backup_documents"),
+					g.Text("Documents"),
+				),
+			),
+		),
+		h.Div(
+			h.Class("h-10 w-40"),
+			ui.FormButton(g.Text("Backup"), "", ui.ButtonConfig{Variant: ui.ButtonVariantSecondary}),
+		),
+	)
+}
+
+func restoreForm() g.Node {
+	return h.Form(
+		h.Class("flex justify-between"),
+		h.Action("./admin"),
+		h.Method("POST"),
+		g.Attr("enctype", "multipart/form-data"),
+		h.Input(
+			h.Type("text"),
+			h.Name("action"),
+			h.Value("RESTORE"),
+			h.Class("hidden"),
+		),
+		h.Div(
+			h.Class("flex items-center"),
+			h.Input(
+				h.Type("file"),
+				h.Accept(".zip"),
+				h.Name("restore_file"),
+				h.Class("w-full"),
+			),
+		),
+		h.Div(
+			h.Class("h-10 w-40"),
+			ui.FormButton(g.Text("Restore"), "", ui.ButtonConfig{Variant: ui.ButtonVariantSecondary}),
+		),
+	)
+}
+
+func tasksSection() g.Node {
+	return h.Div(
+		h.Class("flex flex-col grow p-4 rounded shadow-lg bg-white dark:bg-gray-700 text-gray-500 dark:text-white"),
+		h.P(
+			h.Class("text-lg font-semibold mb-4"),
+			g.Text("Tasks"),
+		),
+		h.Div(
+			h.Class("grid grid-cols-[1fr_auto] gap-x-4 gap-y-3 items-center"),
+			g.Group(taskItem("Metadata Matching", "METADATA_MATCH")),
+			g.Group(taskItem("Cache Tables", "CACHE_TABLES")),
+		),
+	)
+}
+
+func taskItem(name, action string) []g.Node {
+	return []g.Node{
+		h.P(
+			h.Class("text-black dark:text-white"),
+			g.Text(name),
+		),
+		h.Form(
+			h.Action("./admin"),
+			h.Method("POST"),
+			h.Input(
+				h.Type("text"),
+				h.Name("action"),
+				h.Value(action),
+				h.Class("hidden"),
+			),
+			h.Div(
+				h.Class("h-10 w-40"),
+				ui.FormButton(g.Text("Run"), "", ui.ButtonConfig{Variant: ui.ButtonVariantSecondary}),
+			),
+		),
+	}
+}

web/pages/document.go

@@ -13,6 +13,7 @@ import (
 	"reichard.io/antholume/web/components/document"
 	"reichard.io/antholume/web/components/ui"
 	"reichard.io/antholume/web/models"
+	"reichard.io/antholume/web/pages/layout"
 )
 
 var _ Page = (*Document)(nil)
@@ -22,9 +23,14 @@ type Document struct {
 	Search *models.DocumentMetadata
 }
 
-func (Document) Route() PageRoute { return DocumentPage }
+func (p *Document) Generate(ctx models.PageContext) (g.Node, error) {
+	return layout.Layout(
+		ctx.WithRoute(models.DocumentPage),
+		p.content(),
+	)
+}
 
-func (p Document) Render() g.Node {
+func (p *Document) content() g.Node {
 	return h.Div(
 		h.Class("h-full w-full overflow-scroll bg-white shadow-lg dark:bg-gray-700 rounded dark:text-white p-4"),
 		document.Actions(p.Data),

web/pages/documents.go

@@ -9,6 +9,7 @@ import (
 	"reichard.io/antholume/web/components/document"
 	"reichard.io/antholume/web/components/ui"
 	"reichard.io/antholume/web/models"
+	"reichard.io/antholume/web/pages/layout"
 )
 
 var _ Page = (*Documents)(nil)
@@ -20,15 +21,13 @@ type Documents struct {
 	Limit    int
 }
 
-func (Documents) Route() PageRoute { return DocumentsPage }
-
-func (p Documents) Render() g.Node {
-	return g.Group([]g.Node{
+func (p Documents) Generate(ctx models.PageContext) (g.Node, error) {
+	return layout.Layout(ctx.WithRoute(models.DocumentsPage),
 		searchBar(),
 		documentGrid(p.Data),
 		pagination(p.Previous, p.Next, p.Limit),
 		uploadFAB(),
-	})
+	)
 }
 
 func searchBar() g.Node {

web/pages/home.go

@@ -5,6 +5,8 @@ import (
 	h "maragu.dev/gomponents/html"
 	"reichard.io/antholume/database"
 	"reichard.io/antholume/web/components/stats"
+	"reichard.io/antholume/web/models"
+	"reichard.io/antholume/web/pages/layout"
 )
 
 var _ Page = (*Home)(nil)
@@ -16,9 +18,11 @@ type Home struct {
 	RecordInfo  *database.GetDatabaseInfoRow
 }
 
-func (Home) Route() PageRoute { return HomePage }
+func (p *Home) Generate(ctx models.PageContext) (g.Node, error) {
+	return layout.Layout(ctx.WithRoute(models.HomePage), p.content())
+}
 
-func (p Home) Render() g.Node {
+func (p *Home) content() g.Node {
 	return h.Div(
 		g.Attr("class", "flex flex-col gap-4"),
 		h.Div(

web/pages/layout/layout.go

@@ -1,35 +1,41 @@
 package layout
 
 import (
+	"errors"
+	"fmt"
+
 	g "maragu.dev/gomponents"
 	h "maragu.dev/gomponents/html"
-	"reichard.io/antholume/web/pages"
+	"reichard.io/antholume/web/components/ui"
+	"reichard.io/antholume/web/models"
 )
 
-type LayoutOptions struct {
-	SearchEnabled bool
-	IsAdmin       bool
-	Username      string
-	Version       string
+func Layout(ctx models.PageContext, children ...g.Node) (g.Node, error) {
+	if ctx.UserInfo == nil {
+		return nil, errors.New("no user info")
+	} else if ctx.ServerInfo == nil {
+		return nil, errors.New("no server info")
+	} else if !ctx.Route.Valid() {
+		return nil, fmt.Errorf("invalid route: %s", ctx.Route)
 	}
 
-func Layout(p pages.Page, opts LayoutOptions) g.Node {
 	return h.Doctype(
 		h.HTML(
 			g.Attr("lang", "en"),
-			Head(p.Route().Title()),
+			Head(ctx.Route.Title()),
 			h.Body(
 				g.Attr("class", "bg-gray-100 dark:bg-gray-800 text-black dark:text-white"),
-				Navigation(p.Route(), &opts),
-				Base(p.Render()),
+				Navigation(ctx),
+				Base(children),
+				ui.Notifications(ctx.Notifications),
 			),
 		),
-	)
+	), nil
 }
 
 func Head(routeTitle string) g.Node {
 	return h.Head(
-		h.Title("AnthoLume - "+routeTitle),
+		g.El("title", g.Text("AnthoLume - "+routeTitle)),
 		h.Meta(g.Attr("charset", "utf-8")),
 		h.Meta(g.Attr("name", "viewport"), g.Attr("content", "width=device-width, initial-scale=0.9, user-scalable=no, viewport-fit=cover")),
 		h.Meta(g.Attr("name", "apple-mobile-web-app-capable"), g.Attr("content", "yes")),
@@ -45,13 +51,13 @@ func Head(routeTitle string) g.Node {
 	)
 }
 
-func Base(body g.Node) g.Node {
+func Base(body []g.Node) g.Node {
 	return h.Main(
 		g.Attr("class", "relative overflow-hidden"),
 		h.Div(
 			g.Attr("id", "container"),
 			g.Attr("class", "h-[100dvh] px-4 overflow-auto md:px-6 lg:ml-48"),
-			body,
+			g.Group(body),
 		),
 	)
 }

web/pages/layout/navigation.go

@@ -6,7 +6,7 @@ import (
 	g "maragu.dev/gomponents"
 	h "maragu.dev/gomponents/html"
 	"reichard.io/antholume/web/assets"
-	"reichard.io/antholume/web/pages"
+	"reichard.io/antholume/web/models"
 )
 
 const (
@@ -14,29 +14,28 @@ const (
 	inactive = "border-transparent text-gray-400 hover:text-gray-800 dark:hover:text-gray-100"
 )
 
-func Navigation(currentRoute pages.PageRoute, opts *LayoutOptions) g.Node {
+func Navigation(ctx models.PageContext) g.Node {
 	return h.Div(
 		g.Attr("class", "flex items-center justify-between w-full h-16"),
-		Sidebar(currentRoute, opts),
-		h.H1(g.Attr("class", "text-xl font-bold px-6 lg:ml-44"), g.Text(currentRoute.Title())),
-		Dropdown(opts.Username),
+		Sidebar(ctx),
+		h.H1(g.Attr("class", "text-xl font-bold whitespace-nowrap px-6 lg:ml-44"), g.Text(ctx.Route.Title())),
+		Dropdown(ctx.UserInfo.Username),
 	)
 }
 
-func Sidebar(currentRoute pages.PageRoute, opts *LayoutOptions) g.Node {
+func Sidebar(ctx models.PageContext) g.Node {
 	links := []g.Node{
-		navLink(currentRoute, pages.HomePage, "/", "home"),
-		navLink(currentRoute, pages.DocumentsPage, "/documents", "documents"),
-		navLink(currentRoute, pages.ProgressPage, "/progress", "activity"),
-		navLink(currentRoute, pages.ActivityPage, "/activity", "activity"),
+		navLink(ctx.Route, models.HomePage, "/", "home"),
+		navLink(ctx.Route, models.DocumentsPage, "/documents", "documents"),
+		navLink(ctx.Route, models.ProgressPage, "/progress", "activity"),
+		navLink(ctx.Route, models.ActivityPage, "/activity", "activity"),
 	}
-	if opts.SearchEnabled {
-		links = append(links, navLink(currentRoute, pages.SearchPage, "/search", "search"))
+	if ctx.ServerInfo.SearchEnabled {
+		links = append(links, navLink(ctx.Route, models.SearchPage, "/search", "search"))
 	}
-	if opts.IsAdmin {
-		links = append(links, adminLinks(currentRoute))
+	if ctx.UserInfo.IsAdmin {
+		links = append(links, adminLinks(ctx.Route))
 	}
-
 	return h.Div(
 		g.Attr("id", "mobile-nav-button"),
 		g.Attr("class", "flex flex-col z-40 relative ml-6"),
@@ -54,13 +53,13 @@ func Sidebar(currentRoute pages.PageRoute, opts *LayoutOptions) g.Node {
 				g.Attr("target", "_blank"),
 				g.Attr("class", "flex flex-col gap-2 justify-center items-center p-6 w-full absolute bottom-0 text-black dark:text-white"),
 				assets.Icon("gitea", 20),
-				h.Span(g.Attr("class", "text-xs"), g.Text(opts.Version)),
+				h.Span(g.Attr("class", "text-xs"), g.Text(ctx.ServerInfo.Version)),
 			),
 		),
 	)
 }
 
-func navLink(currentRoute, linkRoute pages.PageRoute, path, icon string) g.Node {
+func navLink(currentRoute, linkRoute models.PageRoute, path, icon string) g.Node {
 	class := inactive
 	if currentRoute == linkRoute {
 		class = active
@@ -73,7 +72,7 @@ func navLink(currentRoute, linkRoute pages.PageRoute, path, icon string) g.Node
 	)
 }
 
-func adminLinks(currentRoute pages.PageRoute) g.Node {
+func adminLinks(currentRoute models.PageRoute) g.Node {
 	routeID := string(currentRoute)
 
 	class := inactive
@@ -83,10 +82,10 @@ func adminLinks(currentRoute pages.PageRoute) g.Node {
 
 	children := g.If(strings.HasPrefix(routeID, "admin"),
 		g.Group([]g.Node{
-			subNavLink(currentRoute, pages.AdminGeneralPage, "/admin"),
-			subNavLink(currentRoute, pages.AdminImportPage, "/admin/import"),
-			subNavLink(currentRoute, pages.AdminUsersPage, "/admin/users"),
-			subNavLink(currentRoute, pages.AdminLogsPage, "/admin/logs"),
+			subNavLink(currentRoute, models.AdminGeneralPage, "/admin"),
+			subNavLink(currentRoute, models.AdminImportPage, "/admin/import"),
+			subNavLink(currentRoute, models.AdminUsersPage, "/admin/users"),
+			subNavLink(currentRoute, models.AdminLogsPage, "/admin/logs"),
 		}),
 	)
 
@@ -102,7 +101,7 @@ func adminLinks(currentRoute pages.PageRoute) g.Node {
 	)
 }
 
-func subNavLink(currentRoute, linkRoute pages.PageRoute, path string) g.Node {
+func subNavLink(currentRoute, linkRoute models.PageRoute, path string) g.Node {
 	class := inactive
 	if currentRoute == linkRoute {
 		class = active

web/pages/layout/route.go

@@ -0,0 +1,35 @@
+package layout
+
+type Route string
+
+const (
+	HomePage         Route = "home"
+	DocumentPage     Route = "document"
+	DocumentsPage    Route = "documents"
+	ProgressPage     Route = "progress"
+	ActivityPage     Route = "activity"
+	SearchPage       Route = "search"
+	SettingsPage     Route = "settings"
+	AdminGeneralPage Route = "admin-general"
+	AdminImportPage  Route = "admin-import"
+	AdminUsersPage   Route = "admin-users"
+	AdminLogsPage    Route = "admin-logs"
+)
+
+var pageTitleMap = map[Route]string{
+	HomePage:         "Home",
+	DocumentPage:     "Document",
+	DocumentsPage:    "Documents",
+	ProgressPage:     "Progress",
+	ActivityPage:     "Activity",
+	SearchPage:       "Search",
+	SettingsPage:     "Settings",
+	AdminGeneralPage: "Admin - General",
+	AdminImportPage:  "Admin - Import",
+	AdminUsersPage:   "Admin - Users",
+	AdminLogsPage:    "Admin - Logs",
+}
+
+func (p Route) Title() string {
+	return pageTitleMap[p]
+}

web/pages/page.go

@@ -2,41 +2,9 @@ package pages
 
 import (
 	g "maragu.dev/gomponents"
+	"reichard.io/antholume/web/models"
 )
 
-type PageRoute string
-
-const (
-	HomePage         PageRoute = "home"
-	DocumentPage     PageRoute = "document"
-	DocumentsPage    PageRoute = "documents"
-	ProgressPage     PageRoute = "progress"
-	ActivityPage     PageRoute = "activity"
-	SearchPage       PageRoute = "search"
-	AdminGeneralPage PageRoute = "admin-general"
-	AdminImportPage  PageRoute = "admin-import"
-	AdminUsersPage   PageRoute = "admin-users"
-	AdminLogsPage    PageRoute = "admin-logs"
-)
-
-var pageTitleMap = map[PageRoute]string{
-	HomePage:         "Home",
-	DocumentPage:     "Document",
-	DocumentsPage:    "Documents",
-	ProgressPage:     "Progress",
-	ActivityPage:     "Activity",
-	SearchPage:       "Search",
-	AdminGeneralPage: "Admin - General",
-	AdminImportPage:  "Admin - Import",
-	AdminUsersPage:   "Admin - Users",
-	AdminLogsPage:    "Admin - Logs",
-}
-
-func (p PageRoute) Title() string {
-	return pageTitleMap[p]
-}
-
 type Page interface {
-	Route() PageRoute
-	Render() g.Node
+	Generate(ctx models.PageContext) (g.Node, error)
 }

web/pages/progress.go

@@ -8,6 +8,7 @@ import (
 	"reichard.io/antholume/pkg/sliceutils"
 	"reichard.io/antholume/web/components/ui"
 	"reichard.io/antholume/web/models"
+	"reichard.io/antholume/web/pages/layout"
 )
 
 var _ Page = (*Progress)(nil)
@@ -16,15 +17,16 @@ type Progress struct {
 	Data []models.Progress
 }
 
-func (Progress) Route() PageRoute { return ProgressPage }
-
-func (p Progress) Render() g.Node {
-	return h.Div(
+func (p *Progress) Generate(ctx models.PageContext) (g.Node, error) {
+	return layout.Layout(
+		ctx.WithRoute(models.ProgressPage),
+		h.Div(
 			h.Class("overflow-x-auto"),
 			h.Div(
 				h.Class("inline-block min-w-full overflow-hidden rounded shadow"),
 				ui.Table(p.buildTableConfig()),
 			),
+		),
 	)
 }
 

web/pages/search.go

@@ -12,6 +12,7 @@ import (
 	"reichard.io/antholume/web/assets"
 	"reichard.io/antholume/web/components/ui"
 	"reichard.io/antholume/web/models"
+	"reichard.io/antholume/web/pages/layout"
 )
 
 var _ Page = (*Search)(nil)
@@ -23,9 +24,14 @@ type Search struct {
 	Error   string
 }
 
-func (Search) Route() PageRoute { return SearchPage }
+func (p Search) Generate(ctx models.PageContext) (g.Node, error) {
+	return layout.Layout(
+		ctx.WithRoute(models.SearchPage),
+		p.content(),
+	)
+}
 
-func (p Search) Render() g.Node {
+func (p *Search) content() g.Node {
 	return h.Div(
 		h.Class("flex flex-col gap-4"),
 		h.Div(
@@ -96,7 +102,7 @@ func (p Search) Render() g.Node {
 	)
 }
 
-func (p Search) tableRows() []ui.TableRow {
+func (p *Search) tableRows() []ui.TableRow {
 	return sliceutils.Map(p.Results, func(r models.SearchResult) ui.TableRow {
 		return ui.TableRow{
 			"": ui.TableCell{

web/pages/settings.go

@@ -0,0 +1,184 @@
+package pages
+
+import (
+	g "maragu.dev/gomponents"
+	h "maragu.dev/gomponents/html"
+	"reichard.io/antholume/pkg/sliceutils"
+	"reichard.io/antholume/web/assets"
+	"reichard.io/antholume/web/components/ui"
+	"reichard.io/antholume/web/models"
+	"reichard.io/antholume/web/pages/layout"
+)
+
+var _ Page = (*Settings)(nil)
+
+type Settings struct {
+	Timezone string
+	Devices  []models.Device
+}
+
+func (p *Settings) Generate(ctx models.PageContext) (g.Node, error) {
+	return layout.Layout(
+		ctx.WithRoute(models.SettingsPage),
+		h.Div(
+			h.Class("flex flex-col md:flex-row gap-4"),
+			h.Div(
+				h.Div(
+					h.Class("flex flex-col p-4 items-center rounded shadow-lg md:w-60 lg:w-80 bg-white dark:bg-gray-700 text-gray-500 dark:text-white"),
+					assets.Icon("user", 60),
+					h.P(h.Class("text-lg"), g.Text(ctx.UserInfo.Username)),
+				),
+			),
+			h.Div(
+				h.Class("flex flex-col gap-4 grow"),
+				p.passwordForm(),
+				p.timezoneForm(),
+				p.devicesTable(),
+			),
+		),
+	)
+}
+
+func (p Settings) passwordForm() g.Node {
+	return h.Div(
+		h.Class("flex flex-col gap-2 p-4 rounded shadow-lg bg-white dark:bg-gray-700 text-gray-500 dark:text-white"),
+		h.P(h.Class("text-lg font-semibold"), g.Text("Change Password")),
+		h.Form(
+			h.Class("flex gap-4 flex-col lg:flex-row"),
+			h.Action("./settings"),
+			h.Method("POST"),
+			// Current Password
+			h.Div(
+				h.Class("flex grow"),
+				h.Span(
+					h.Class("inline-flex items-center px-3 border-t bg-white border-l border-b border-gray-300 text-gray-500 shadow-sm text-sm"),
+					assets.Icon("password", 15),
+				),
+				h.Input(
+					h.Type("password"),
+					h.ID("password"),
+					h.Name("password"),
+					h.Class("flex-1 appearance-none rounded-none border border-gray-300 w-full py-2 px-4 bg-white text-gray-700 placeholder-gray-400 shadow-sm text-base focus:outline-none focus:ring-2 focus:ring-purple-600 focus:border-transparent"),
+					h.Placeholder("Password"),
+				),
+			),
+			// New Password
+			h.Div(
+				h.Class("flex grow"),
+				h.Span(
+					h.Class("inline-flex items-center px-3 border-t bg-white border-l border-b border-gray-300 text-gray-500 shadow-sm text-sm"),
+					assets.Icon("password", 15),
+				),
+				h.Input(
+					h.Type("password"),
+					h.ID("new_password"),
+					h.Name("new_password"),
+					h.Class("flex-1 appearance-none rounded-none border border-gray-300 w-full py-2 px-4 bg-white text-gray-700 placeholder-gray-400 shadow-sm text-base focus:outline-none focus:ring-2 focus:ring-purple-600 focus:border-transparent"),
+					h.Placeholder("New Password"),
+				),
+			),
+			// Submit Button
+			h.Div(
+				h.Class("lg:w-60"),
+				ui.FormButton(
+					g.Text("Submit"),
+					"",
+					ui.ButtonConfig{Variant: ui.ButtonVariantSecondary},
+				),
+			),
+		),
+	)
+}
+
+func (p Settings) timezoneForm() g.Node {
+	tzs := []string{
+		"Africa/Cairo",
+		"Africa/Johannesburg",
+		"Africa/Lagos",
+		"Africa/Nairobi",
+		"America/Adak",
+		"America/Anchorage",
+		"America/Buenos_Aires",
+		"America/Chicago",
+		"America/Denver",
+		"America/Los_Angeles",
+		"America/Mexico_City",
+		"America/New_York",
+		"America/Nuuk",
+		"America/Phoenix",
+		"America/Puerto_Rico",
+		"America/Sao_Paulo",
+		"America/St_Johns",
+		"America/Toronto",
+		"Asia/Dubai",
+		"Asia/Hong_Kong",
+		"Asia/Kolkata",
+		"Asia/Seoul",
+		"Asia/Shanghai",
+		"Asia/Singapore",
+		"Asia/Tokyo",
+		"Atlantic/Azores",
+		"Australia/Melbourne",
+		"Australia/Sydney",
+		"Europe/Berlin",
+		"Europe/London",
+		"Europe/Moscow",
+		"Europe/Paris",
+		"Pacific/Auckland",
+		"Pacific/Honolulu",
+	}
+
+	return h.Div(
+		h.Class("flex flex-col grow gap-2 p-4 rounded shadow-lg bg-white dark:bg-gray-700 text-gray-500 dark:text-white"),
+		h.P(h.Class("text-lg font-semibold"), g.Text("Change Timezone")),
+		h.Form(
+			h.Class("flex gap-4 flex-col lg:flex-row"),
+			h.Action("./settings"),
+			h.Method("POST"),
+			h.Div(
+				h.Class("flex grow"),
+				h.Span(
+					h.Class("inline-flex items-center px-3 border-t bg-white border-l border-b border-gray-300 text-gray-500 shadow-sm text-sm"),
+					assets.Icon("clock", 15),
+				),
+				h.Select(
+					h.Class("flex-1 appearance-none rounded-none border border-gray-300 w-full py-2 px-4 bg-white text-gray-700 placeholder-gray-400 shadow-sm text-base focus:outline-none focus:ring-2 focus:ring-purple-600 focus:border-transparent"),
+					h.ID("timezone"),
+					h.Name("timezone"),
+					g.Group(g.Map(tzs, func(tz string) g.Node {
+						return h.Option(
+							h.Value(tz),
+							g.If(tz == p.Timezone, h.Selected()),
+							g.Text(tz),
+						)
+					})),
+				),
+			),
+			h.Div(
+				h.Class("lg:w-60"),
+				ui.FormButton(
+					g.Text("Submit"),
+					"",
+					ui.ButtonConfig{Variant: ui.ButtonVariantSecondary},
+				),
+			),
+		),
+	)
+}
+
+func (p Settings) devicesTable() g.Node {
+	return h.Div(
+		h.Class("flex flex-col grow p-4 rounded shadow-lg bg-white dark:bg-gray-700 text-gray-500 dark:text-white"),
+		h.P(h.Class("text-lg font-semibold"), g.Text("Devices")),
+		ui.Table(ui.TableConfig{
+			Columns: []string{"Name", "Last Sync", "Created"},
+			Rows: sliceutils.Map(p.Devices, func(d models.Device) ui.TableRow {
+				return ui.TableRow{
+					"Name":      ui.TableCell{String: d.DeviceName},
+					"Last Sync": ui.TableCell{String: d.LastSynced},
+					"Created":   ui.TableCell{String: d.CreatedAt},
+				}
+			}),
+		}),
+	)
+}