wip

2025-08-17 17:04:27 -04:00
parent f9f23f2d3f
commit 2eed0d9021
72 changed files with 2713 additions and 100 deletions
--- a/api/app-routes-new.go
+++ b/api/app-routes-new.go
@@ -0,0 +1,451 @@
+package api
+
+import (
+	"cmp"
+	"fmt"
+	"math"
+	"net/http"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"reichard.io/antholume/database"
+	"reichard.io/antholume/metadata"
+	"reichard.io/antholume/pkg/formatters"
+	"reichard.io/antholume/pkg/ptr"
+	"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) {
+	_, 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))
+		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))
+
+	err = layout.Layout(
+		pages.Home{
+			Leaderboard: arrangeUserStatisticsNew(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)
+
+	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
+
+	err = layout.Layout(
+		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)
+
+	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
+	}
+
+	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))
+	}
+}
+
+func (api *API) appGetActivityNew(c *gin.Context) {
+	_, 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
+	}
+
+	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))
+	}
+}
+
+func (api *API) appGetProgressNew(c *gin.Context) {
+	_, 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
+	}
+
+	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))
+	}
+}
+
+func (api *API) appIdentifyDocumentNew(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
+	_, 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 {
+		log.Error("Search Metadata Error: ", err)
+		appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Search Metadata Error: %v", err))
+		return
+	}
+
+	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,
+			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)
+		}
+	} else {
+		errorMsg = ptr.Of("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
+	}
+
+	err = layout.Layout(
+		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))
+	}
+}
+
+// Tabs:
+//   - General (Import, Backup & Restore, Version (githash?), Stats?)
+//   - Users
+//   - Metadata
+func (api *API) appGetSearchNew(c *gin.Context) {
+	_, auth := 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
+	var searchResults []models.SearchResult
+	var searchError string
+	if sParams.Query != nil && sParams.Source != nil {
+		results, err := search.SearchBook(*sParams.Query, *sParams.Source)
+		if err != nil {
+			appErrorPage(c, http.StatusInternalServerError, fmt.Sprintf("Search Error: %v", err))
+			return
+		}
+		searchResults = sliceutils.Map(results, convertSearchToUI)
+	} else if sParams.Query != nil || sParams.Source != nil {
+		searchError = "Invailid Query"
+	}
+
+	err = layout.Layout(
+		pages.Search{
+			Results: searchResults,
+			Source:  ptr.Deref(sParams.Source),
+			Query:   ptr.Deref(sParams.Query),
+			Error:   searchError,
+		},
+		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 sortItem[T cmp.Ordered](
+	data []database.GetUserStatisticsRow,
+	accessor func(s database.GetUserStatisticsRow) T,
+	formatter func(s T) string,
+) []stats.LeaderboardItem {
+	sort.SliceStable(data, func(i, j int) bool {
+		return accessor(data[i]) > accessor(data[j])
+	})
+
+	var items []stats.LeaderboardItem
+	for _, s := range data {
+		items = append(items, stats.LeaderboardItem{
+			UserID: s.UserID,
+			Value:  formatter(accessor(s)),
+		})
+	}
+	return items
+}
+
+func arrangeUserStatisticsNew(data []database.GetUserStatisticsRow) []stats.LeaderboardData {
+	wpmFormatter := func(v float64) string { return fmt.Sprintf("%.2f WPM", v) }
+	return []stats.LeaderboardData{
+		{
+			Name:  "WPM",
+			All:   sortItem(data, func(r database.GetUserStatisticsRow) float64 { return r.TotalWpm }, wpmFormatter),
+			Year:  sortItem(data, func(r database.GetUserStatisticsRow) float64 { return r.YearlyWpm }, wpmFormatter),
+			Month: sortItem(data, func(r database.GetUserStatisticsRow) float64 { return r.MonthlyWpm }, wpmFormatter),
+			Week:  sortItem(data, func(r database.GetUserStatisticsRow) float64 { return r.WeeklyWpm }, wpmFormatter),
+		},
+		{
+			Name:  "Words",
+			All:   sortItem(data, func(r database.GetUserStatisticsRow) int64 { return r.TotalWordsRead }, formatters.FormatNumber),
+			Year:  sortItem(data, func(r database.GetUserStatisticsRow) int64 { return r.YearlyWordsRead }, formatters.FormatNumber),
+			Month: sortItem(data, func(r database.GetUserStatisticsRow) int64 { return r.MonthlyWordsRead }, formatters.FormatNumber),
+			Week:  sortItem(data, func(r database.GetUserStatisticsRow) int64 { return r.WeeklyWordsRead }, formatters.FormatNumber),
+		},
+		{
+			Name: "Duration",
+			All: sortItem(data, func(r database.GetUserStatisticsRow) time.Duration {
+				return time.Duration(r.TotalSeconds) * time.Second
+			}, formatters.FormatDuration),
+			Year: sortItem(data, func(r database.GetUserStatisticsRow) time.Duration {
+				return time.Duration(r.YearlySeconds) * time.Second
+			}, formatters.FormatDuration),
+			Month: sortItem(data, func(r database.GetUserStatisticsRow) time.Duration {
+				return time.Duration(r.MonthlySeconds) * time.Second
+			}, formatters.FormatDuration),
+			Week: sortItem(data, func(r database.GetUserStatisticsRow) time.Duration {
+				return time.Duration(r.WeeklySeconds) * time.Second
+			}, formatters.FormatDuration),
+		},
+	}
+}