john-okeefe
2a7338200c
Health check endpoint:
- Add /health endpoint that pings database with 2-second timeout
- Returns 200 when DB connected, 503 when unavailable
- Provides true end-to-end health verification
Frontend routes restoration (routes removed in c5f327b):
- Add public routes: /, /login, /register with smart auth detection
- Add redirect routes: /bookshelf, /dashboard
- Add admin routes: /admin, /admin/profile, /admin/library
- Add SSR routes: /api/devices-page, /api/conflicts-page
- Add 'FRONTEND ROUTES - DO NOT DELETE' comment block to prevent future removal
Docker Compose healthcheck:
- Update to use curl on /health endpoint (pg_isready not in Alpine)
- Add 10s start_period for app initialization
- Accurately reflects app + database health status
All changes maintain backward compatibility and existing API behavior.
859 lines
28 KiB
Go
859 lines
28 KiB
Go
package main
|
|
|
|
import (
|
|
"bookhoard/internal/config"
|
|
"bookhoard/internal/database"
|
|
"bookhoard/internal/docs"
|
|
"bookhoard/internal/handlers"
|
|
"bookhoard/internal/middleware"
|
|
ratelimit "bookhoard/internal/middleware"
|
|
"bookhoard/internal/services"
|
|
"bookhoard/internal/sync"
|
|
"bookhoard/templates"
|
|
"bytes"
|
|
"context"
|
|
"log"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/go-playground/validator/v10"
|
|
"github.com/golang-jwt/jwt/v5"
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
"github.com/labstack/echo-jwt/v4"
|
|
"github.com/labstack/echo/v4"
|
|
echomiddleware "github.com/labstack/echo/v4/middleware"
|
|
)
|
|
|
|
// CustomValidator wraps the go-playground validator
|
|
type CustomValidator struct {
|
|
validator *validator.Validate
|
|
}
|
|
|
|
func (cv *CustomValidator) Validate(i interface{}) error {
|
|
return cv.validator.Struct(i)
|
|
}
|
|
|
|
func getTemplateUserWithTheme(c echo.Context, queries *database.Queries) (templates.User, error) {
|
|
userID := c.Get("user_id").(string)
|
|
userEmail := c.Get("user_email").(string)
|
|
userUsername := c.Get("user_username").(string)
|
|
userRole := c.Get("user_role").(string)
|
|
|
|
userUUID, err := uuid.Parse(userID)
|
|
if err != nil {
|
|
return templates.User{}, err
|
|
}
|
|
|
|
userDB, err := queries.GetUser(c.Request().Context(), pgtype.UUID{Bytes: userUUID, Valid: true})
|
|
if err != nil {
|
|
return templates.User{}, err
|
|
}
|
|
|
|
userTheme := "tokyo-night"
|
|
if userDB.Theme.Valid {
|
|
userTheme = userDB.Theme.String
|
|
}
|
|
|
|
return templates.User{
|
|
ID: userID,
|
|
Email: userEmail,
|
|
Username: userUsername,
|
|
Role: userRole,
|
|
Theme: userTheme,
|
|
}, nil
|
|
}
|
|
|
|
func main() {
|
|
cfg := config.LoadConfig()
|
|
|
|
dbPool, err := pgxpool.New(context.Background(), cfg.DatabaseURL())
|
|
if err != nil {
|
|
log.Fatal("Failed to connect to database:", err)
|
|
}
|
|
defer dbPool.Close()
|
|
|
|
queries := database.New(dbPool)
|
|
|
|
// Create login attempt tracker: 5 failed attempts = 15 minute lockout
|
|
loginAttemptTracker := ratelimit.NewLoginAttemptTracker(5, 15*time.Minute, 5*time.Minute)
|
|
|
|
authHandler := handlers.NewAuthHandler(queries, cfg.JWTSecret, loginAttemptTracker)
|
|
libraryHandler := handlers.NewLibraryHandler(queries)
|
|
deviceHandler := handlers.NewDeviceHandler(queries, cfg.JWTSecret, cfg)
|
|
deviceAuthMiddleware := middleware.NewDeviceAuthMiddleware(queries)
|
|
|
|
// Create WebSocket connection manager
|
|
connManager := sync.NewConnectionManager()
|
|
connManager.StartCleanupTask()
|
|
|
|
// Create sync queue processor
|
|
queueProcessor := sync.NewSyncQueueProcessor(queries)
|
|
go queueProcessor.Start(context.Background())
|
|
|
|
koreaderHandler := handlers.NewKOReaderHandler(queries, connManager, queueProcessor)
|
|
wsHandler := handlers.NewWSHandler(queries, connManager, cfg.JWTSecret, deviceAuthMiddleware)
|
|
conflictHandler := handlers.NewConflictHandler(queries, connManager)
|
|
analyticsHandler := handlers.NewAnalyticsHandler(queries)
|
|
queueHandler := handlers.NewQueueHandler(queries, queueProcessor)
|
|
|
|
// Create conversion service for EPUB→KEPUB conversion
|
|
conversionService := services.NewConversionService(queries, "/var/bookhoard/cache/kepub")
|
|
opdsHandler := handlers.NewOPDSHandler(queries, conversionService)
|
|
|
|
e := echo.New()
|
|
|
|
// Set up validator
|
|
v := validator.New()
|
|
|
|
// Register custom password complexity validator
|
|
if err := ratelimit.RegisterPasswordValidation(v); err != nil {
|
|
log.Fatal("Failed to register password validator:", err)
|
|
}
|
|
|
|
e.Validator = &CustomValidator{validator: v}
|
|
|
|
// Middleware
|
|
e.Use(echomiddleware.Logger())
|
|
e.Use(echomiddleware.Recover())
|
|
e.Use(echomiddleware.CORS())
|
|
e.Use(ratelimit.RequestTracingMiddleware(cfg))
|
|
|
|
// Rate limiter for auth endpoints
|
|
rateLimiterConfig := ratelimit.RateLimiterConfig{
|
|
Enabled: cfg.RateLimitEnabled,
|
|
RequestsPerMinute: cfg.RequestsPerMinute,
|
|
CleanupInterval: 5 * time.Minute,
|
|
}
|
|
rateLimiter := ratelimit.NewRateLimiter(rateLimiterConfig)
|
|
rateLimitMiddleware := ratelimit.RateLimiterMiddleware(rateLimiter)
|
|
|
|
// Auth routes (no auth required, but rate limited)
|
|
e.POST("/api/auth/register", rateLimitMiddleware(authHandler.Register))
|
|
e.POST("/api/auth/login", rateLimitMiddleware(authHandler.Login))
|
|
|
|
// JWT middleware for protected routes
|
|
jwtMiddleware := echojwt.WithConfig(echojwt.Config{
|
|
SigningKey: []byte(cfg.JWTSecret),
|
|
ContextKey: "user",
|
|
SuccessHandler: func(c echo.Context) {
|
|
token := c.Get("user").(*jwt.Token)
|
|
claims := token.Claims.(jwt.MapClaims)
|
|
c.Set("user_id", claims["user_id"])
|
|
c.Set("user_role", claims["user_role"])
|
|
c.Set("user_email", claims["user_email"])
|
|
c.Set("user_username", claims["user_username"])
|
|
// Parse UUID from string claims
|
|
userIDStr, _ := claims["user_id"].(string)
|
|
userUUID, err := uuid.Parse(userIDStr)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, map[string]string{"error": "invalid user ID in token"})
|
|
return
|
|
}
|
|
|
|
c.Set("user", database.Users{
|
|
ID: pgtype.UUID{Bytes: [16]byte(userUUID), Valid: true},
|
|
Email: claims["user_email"].(string),
|
|
Username: claims["user_username"].(string),
|
|
Role: claims["user_role"].(string),
|
|
})
|
|
},
|
|
})
|
|
|
|
// Protected routes
|
|
protected := e.Group("/api", jwtMiddleware)
|
|
|
|
// Setup ebook handler routes first (so we can use it for library scan)
|
|
h := handlers.SetupRoutes(protected, queries, connManager)
|
|
|
|
// Public library types endpoint (no authentication required)
|
|
e.GET("/api/libraries/types", libraryHandler.GetLibraryTypes)
|
|
|
|
// Refresh token endpoint (no authentication required - uses refresh token from body)
|
|
e.POST("/api/auth/refresh", authHandler.RefreshAccessToken)
|
|
|
|
// Logout endpoint (optional authentication - can revoke tokens if provided)
|
|
e.POST("/api/auth/logout", authHandler.Logout)
|
|
|
|
// Protected routes
|
|
protected = e.Group("/api", jwtMiddleware)
|
|
|
|
// Setup ebook handler routes first (so we can use it for library scan)
|
|
|
|
protected.GET("/auth/profile", authHandler.GetProfile)
|
|
protected.PUT("/auth/profile", authHandler.UpdateProfile)
|
|
|
|
// Admin-only routes for user and folder management
|
|
admin := protected.Group("/auth", handlers.AdminMiddleware)
|
|
admin.GET("/users", authHandler.ListUsers)
|
|
admin.PUT("/users/:id/max-devices", authHandler.UpdateUserMaxDevices)
|
|
|
|
// Library management routes
|
|
library := protected.Group("/libraries")
|
|
|
|
// Admin-only library routes
|
|
adminLibrary := library.Group("", handlers.AdminMiddleware)
|
|
adminLibrary.POST("", libraryHandler.CreateLibrary)
|
|
adminLibrary.GET("", libraryHandler.ListLibraries)
|
|
adminLibrary.GET("/:id", libraryHandler.GetLibrary)
|
|
adminLibrary.PUT("/:id", libraryHandler.UpdateLibrary)
|
|
adminLibrary.DELETE("/:id", libraryHandler.DeleteLibrary)
|
|
adminLibrary.POST("/:id/folders", libraryHandler.AddLibraryFolder)
|
|
adminLibrary.GET("/:id/folders", libraryHandler.GetLibraryFolders)
|
|
adminLibrary.DELETE("/:id/folders", libraryHandler.DeleteLibraryFolder)
|
|
adminLibrary.GET("/:id/stats", libraryHandler.GetLibraryStats)
|
|
adminLibrary.POST("/:id/scan", func(c echo.Context) error {
|
|
libraryID := c.Param("id")
|
|
scanReq := map[string]interface{}{
|
|
"library_id": libraryID,
|
|
}
|
|
c.Set("scan_request", scanReq)
|
|
return h.ScanEbooks(c)
|
|
})
|
|
adminLibrary.GET("/:id/media-items", func(c echo.Context) error {
|
|
libraryID := c.Param("id")
|
|
c.QueryParams().Set("library_id", libraryID)
|
|
return h.ListMediaItems(c)
|
|
})
|
|
|
|
// User library visibility control
|
|
protected.POST("/libraries/visibility", libraryHandler.SetLibraryVisibility)
|
|
protected.GET("/libraries/visible", libraryHandler.GetUserVisibleLibraries)
|
|
|
|
protected.DELETE("/auth/account", authHandler.DeleteAccount)
|
|
protected.PUT("/library/scan-settings", authHandler.UpdateScanSettings)
|
|
protected.GET("/library/scan-settings", authHandler.GetScanSettings)
|
|
|
|
// Auth update routes
|
|
authGroup := e.Group("/api/auth", jwtMiddleware)
|
|
authGroup.PUT("/email", authHandler.UpdateEmail)
|
|
authGroup.PUT("/username", authHandler.UpdateUsername)
|
|
authGroup.PUT("/password", authHandler.UpdatePassword)
|
|
authGroup.PUT("/theme", authHandler.UpdateTheme)
|
|
// force rebuild
|
|
|
|
// Device management routes (public - for registration)
|
|
e.POST("/api/devices/register", deviceHandler.InitiateRegistration)
|
|
e.POST("/api/devices/register/status", deviceHandler.CheckRegistrationStatus)
|
|
|
|
// KOReader sync routes (device authentication required)
|
|
koreaderSync := e.Group("/api/sync/koreader")
|
|
koreaderSync.POST("/progress", deviceAuthMiddleware.Authenticate(koreaderHandler.SyncProgress))
|
|
koreaderSync.GET("/metadata/:uuid", deviceAuthMiddleware.Authenticate(koreaderHandler.GetMetadata))
|
|
koreaderSync.GET("/library", deviceAuthMiddleware.Authenticate(koreaderHandler.GetLibrary))
|
|
koreaderSync.POST("/bookmarks", deviceAuthMiddleware.Authenticate(koreaderHandler.SyncBookmarks))
|
|
|
|
// Kobo sync routes (device authentication required)
|
|
koboHandler := handlers.NewKoboHandler(queries, connManager)
|
|
koboSync := e.Group("/api/sync/kobo")
|
|
koboSync.POST("/markup", deviceAuthMiddleware.Authenticate(koboHandler.Markup))
|
|
koboSync.POST("/bookmark", deviceAuthMiddleware.Authenticate(koboHandler.Bookmark))
|
|
koboSync.POST("/v1/analytics/gettests", deviceAuthMiddleware.Authenticate(koboHandler.AnalyticsGettests))
|
|
koboSync.GET("/v1/initialization", deviceAuthMiddleware.Authenticate(koboHandler.Initialization))
|
|
koboSync.POST("/sync-from-server", deviceAuthMiddleware.Authenticate(koboHandler.SyncFromServer))
|
|
|
|
// Book matching and unlinked book resolution routes
|
|
sync := protected.Group("/sync")
|
|
sync.POST("/bulk-link-books", h.BulkLinkBooks)
|
|
sync.POST("/auto-link-books", h.AutoLinkBooks)
|
|
sync.GET("/unlinked-books/:id/suggestions", h.GetUnlinkedBookSuggestions)
|
|
|
|
// Media item routes (download and shelf management)
|
|
mediaHandler := handlers.NewMediaHandler(queries)
|
|
e.GET("/api/books/:uuid/download", mediaHandler.DownloadBook)
|
|
protected.POST("/devices/:id/shelves", mediaHandler.AddToShelf)
|
|
protected.GET("/devices/:id/shelves", mediaHandler.GetShelf)
|
|
protected.DELETE("/devices/:id/shelves", mediaHandler.RemoveFromShelf)
|
|
protected.DELETE("/devices/:id/shelves/clear", mediaHandler.ClearShelf)
|
|
|
|
// Bulk book operations (protected - require user auth)
|
|
books := protected.Group("/books")
|
|
books.POST("/bulk-delete", mediaHandler.HandleBulkDelete)
|
|
books.POST("/bulk-update", mediaHandler.HandleBulkUpdate)
|
|
|
|
// Device management routes (protected - require user auth)
|
|
devices := protected.Group("/devices")
|
|
devices.GET("", deviceHandler.ListDevices)
|
|
devices.GET("/:id", deviceHandler.GetDevice)
|
|
devices.PUT("/:id", deviceHandler.UpdateDevice)
|
|
devices.DELETE("/:id", deviceHandler.DeleteDevice)
|
|
devices.GET("/pending", deviceHandler.ListPendingRegistrations)
|
|
devices.GET("/approve/:registration_id", deviceHandler.ApproveDevice)
|
|
devices.POST("/reject/:registration_id", deviceHandler.RejectDevice)
|
|
|
|
// Conflict resolution routes (protected - require user auth)
|
|
conflicts := protected.Group("/conflicts")
|
|
conflicts.GET("", conflictHandler.ListConflicts)
|
|
conflicts.GET("/:id", conflictHandler.GetConflict)
|
|
conflicts.POST("/:id/resolve", conflictHandler.ResolveConflict)
|
|
conflicts.DELETE("/:id", conflictHandler.DeleteConflict)
|
|
conflicts.POST("/dismiss-all", conflictHandler.DismissAllResolved)
|
|
conflicts.POST("/bulk-resolve", conflictHandler.BulkResolveConflicts)
|
|
conflicts.POST("/bulk-dismiss", conflictHandler.BulkDismissConflicts)
|
|
|
|
// Analytics routes (protected - require user auth)
|
|
analytics := protected.Group("/analytics")
|
|
analytics.GET("/reading-stats", analyticsHandler.GetReadingStats)
|
|
analytics.GET("/device-usage", analyticsHandler.GetDeviceUsage)
|
|
analytics.GET("/popular-books", analyticsHandler.GetPopularBooks)
|
|
|
|
// Sync queue management routes (protected - require user auth)
|
|
queue := protected.Group("/queue")
|
|
queue.GET("/devices/:device_id/stats", queueHandler.GetDeviceQueueStats)
|
|
queue.GET("/devices/:device_id/items", queueHandler.ListDeviceQueueItems)
|
|
queue.POST("/items/:item_id/retry", queueHandler.RetryQueueItem)
|
|
queue.DELETE("/items/:item_id", queueHandler.DeleteQueueItem)
|
|
queue.DELETE("/devices/:device_id/clear", queueHandler.ClearDeviceQueue)
|
|
|
|
// Admin-only queue routes
|
|
adminQueue := queue.Group("", handlers.AdminMiddleware)
|
|
adminQueue.GET("/items", queueHandler.ListAllQueueItems)
|
|
|
|
// WebSocket endpoint for real-time sync
|
|
e.GET("/ws/sync", wsHandler.HandleWebSocket)
|
|
|
|
// OPDS routes (public - device authentication optional)
|
|
opds := e.Group("/opds/devices")
|
|
opds.GET("/:deviceId/catalog", opdsHandler.GetDeviceCatalog)
|
|
opds.GET("/:deviceId/search", opdsHandler.SearchDeviceCatalog)
|
|
opds.GET("/:deviceId/nav", opdsHandler.GetDeviceNavigation)
|
|
opds.GET("/:deviceId/download/:bookId", opdsHandler.DownloadBook)
|
|
opds.GET("/:deviceId/cover/:bookId", opdsHandler.GetCoverImage)
|
|
opds.GET("/:deviceId/formats/:bookId", opdsHandler.ListFormats)
|
|
|
|
// Static files
|
|
e.Static("/static", "web/static")
|
|
|
|
// Start scheduler for auto-scanning
|
|
go h.StartScheduler()
|
|
defer h.StopScheduler()
|
|
|
|
// Start watch mode for all libraries (background)
|
|
go func() {
|
|
time.Sleep(2 * time.Second) // Wait a bit for server to be ready
|
|
if err := h.StartWatchModeForAllLibraries(context.Background()); err != nil {
|
|
log.Printf("Warning: failed to start watch mode for libraries: %v", err)
|
|
}
|
|
}()
|
|
|
|
// Bookshelf route (protected) - new default for logged-in users
|
|
protected.GET("/bookshelf", func(c echo.Context) error {
|
|
user := c.Get("user").(database.Users)
|
|
userUUID := uuid.UUID(user.ID.Bytes)
|
|
|
|
// Fetch libraries server-side for SSR
|
|
librariesData, err := libraryHandler.GetUserVisibleLibrariesData(c.Request().Context(), pgtype.UUID{Bytes: userUUID, Valid: true})
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading libraries")
|
|
}
|
|
|
|
// Convert to template format
|
|
libraries := make([]templates.LibraryData, len(librariesData))
|
|
for i, lib := range librariesData {
|
|
libUUID := uuid.UUID(lib.ID.Bytes)
|
|
description := ""
|
|
if lib.Description.Valid {
|
|
description = lib.Description.String
|
|
}
|
|
libraries[i] = templates.LibraryData{
|
|
ID: libUUID.String(),
|
|
Name: lib.Name,
|
|
Description: description,
|
|
TypeName: lib.TypeName,
|
|
}
|
|
}
|
|
|
|
userTemplate := templates.User{
|
|
ID: userUUID.String(),
|
|
Email: user.Email,
|
|
Username: user.Username,
|
|
Role: user.Role,
|
|
}
|
|
|
|
// Render template WITH libraries data (SSR)
|
|
var buf bytes.Buffer
|
|
err = templates.BookShelf(userTemplate, libraries).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
// Analytics route (protected) - SSR version
|
|
protected.GET("/analytics", func(c echo.Context) error {
|
|
user, err := getTemplateUserWithTheme(c, queries)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading user")
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
err = templates.Analytics(user).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
// Queue Management route (protected) - SSR version
|
|
// Progress visualization route (protected) - SSR version
|
|
protected.GET("/progress", func(c echo.Context) error {
|
|
user, err := getTemplateUserWithTheme(c, queries)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading user")
|
|
}
|
|
|
|
progressData, err := h.GetAllProgressData(c)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading progress")
|
|
}
|
|
|
|
progressItems := make([]templates.ProgressItemData, len(progressData))
|
|
for i, p := range progressData {
|
|
deviceIcon := ""
|
|
deviceType := ""
|
|
switch p.LastSyncDevice {
|
|
case "koreader":
|
|
deviceIcon = "📖"
|
|
deviceType = "KOReader"
|
|
case "kobo":
|
|
deviceIcon = "📚"
|
|
deviceType = "Kobo"
|
|
case "web":
|
|
deviceIcon = "🌐"
|
|
deviceType = "Web"
|
|
case "mobile":
|
|
deviceIcon = "📱"
|
|
deviceType = "Mobile"
|
|
}
|
|
|
|
progressItems[i] = templates.ProgressItemData{
|
|
MediaItemID: uuid.UUID(p.MediaItemID).String(),
|
|
Title: p.Title,
|
|
Author: p.Author,
|
|
CoverImagePath: p.CoverImagePath,
|
|
CurrentPage: p.CurrentPage,
|
|
TotalPages: p.TotalPages,
|
|
ProgressPercentage: p.Percentage,
|
|
LastUpdated: p.LastReadAt.Format("2006-01-02T15:04:05Z07:00"),
|
|
DeviceName: p.LastSyncDevice,
|
|
DeviceType: deviceType,
|
|
DeviceIcon: deviceIcon,
|
|
EpubCFI: p.Epubcfi,
|
|
}
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
err = templates.Progress(user, progressItems).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
// Queue Management route (protected) - SSR version
|
|
protected.GET("/queue", func(c echo.Context) error {
|
|
userID := c.Get("user_id").(string)
|
|
userEmail := c.Get("user_email").(string)
|
|
userUsername := c.Get("user_username").(string)
|
|
userRole := c.Get("user_role").(string)
|
|
|
|
user := templates.User{
|
|
ID: userID,
|
|
Email: userEmail,
|
|
Username: userUsername,
|
|
Role: userRole,
|
|
}
|
|
|
|
// Fetch queue items for SSR (uses existing handler method)
|
|
queueItems, err := queueHandler.GetQueueData(c)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading queue")
|
|
}
|
|
|
|
// Calculate stats from items
|
|
stats := handlers.QueueStatsResponse{
|
|
PendingCount: 0,
|
|
ProcessingCount: 0,
|
|
FailedCount: 0,
|
|
CompletedCount: 0,
|
|
TotalCount: int64(len(queueItems)),
|
|
}
|
|
for _, item := range queueItems {
|
|
switch item.Status {
|
|
case "pending":
|
|
stats.PendingCount++
|
|
case "processing":
|
|
stats.ProcessingCount++
|
|
case "failed":
|
|
stats.FailedCount++
|
|
case "completed":
|
|
stats.CompletedCount++
|
|
}
|
|
}
|
|
|
|
// Render template WITH data (SSR)
|
|
var buf bytes.Buffer
|
|
err = templates.Queue(user, queueItems, stats).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
// Collections management route (protected) - SSR version
|
|
collectionHandler := handlers.NewCollectionHandler(queries, connManager)
|
|
collections := protected.Group("/collections")
|
|
collections.POST("/bulk-add-books", collectionHandler.HandleBulkAddBooks)
|
|
collections.GET("", func(c echo.Context) error {
|
|
user, err := getTemplateUserWithTheme(c, queries)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading user")
|
|
}
|
|
|
|
// Fetch collections for SSR
|
|
collectionData, err := collectionHandler.GetCollectionsData(c)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading collections")
|
|
}
|
|
|
|
// Convert to template format
|
|
collectionsList := make([]templates.CollectionData, len(collectionData))
|
|
for i, col := range collectionData {
|
|
description := ""
|
|
if col.Description.Valid {
|
|
description = col.Description.String
|
|
}
|
|
color := ""
|
|
if col.Color.Valid {
|
|
color = col.Color.String
|
|
}
|
|
icon := ""
|
|
if col.Icon.Valid {
|
|
icon = col.Icon.String
|
|
}
|
|
|
|
collectionsList[i] = templates.CollectionData{
|
|
ID: uuid.UUID(col.ID.Bytes).String(),
|
|
Name: col.Name,
|
|
Description: description,
|
|
Color: color,
|
|
Icon: icon,
|
|
}
|
|
}
|
|
|
|
// Render template WITH data (SSR)
|
|
var buf bytes.Buffer
|
|
err = templates.Collection(user, collectionsList).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
collections.GET("/:id", func(c echo.Context) error {
|
|
user, err := getTemplateUserWithTheme(c, queries)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading user")
|
|
}
|
|
|
|
collectionID, err := uuid.Parse(c.Param("id"))
|
|
if err != nil {
|
|
return c.HTML(http.StatusBadRequest, "Invalid collection ID")
|
|
}
|
|
|
|
// Fetch collection for SSR
|
|
collectionDB, err := collectionHandler.GetCollectionData(c, collectionID)
|
|
if err != nil {
|
|
return c.HTML(http.StatusNotFound, "Collection not found")
|
|
}
|
|
|
|
// Fetch books for SSR
|
|
booksData, err := collectionHandler.GetCollectionBooksData(c, collectionID)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading books")
|
|
}
|
|
|
|
// Convert to template format
|
|
description := ""
|
|
if collectionDB.Description.Valid {
|
|
description = collectionDB.Description.String
|
|
}
|
|
color := ""
|
|
if collectionDB.Color.Valid {
|
|
color = collectionDB.Color.String
|
|
}
|
|
icon := ""
|
|
if collectionDB.Icon.Valid {
|
|
icon = collectionDB.Icon.String
|
|
}
|
|
|
|
collectionDetail := templates.CollectionDetailData{
|
|
ID: uuid.UUID(collectionDB.ID.Bytes).String(),
|
|
Name: collectionDB.Name,
|
|
Description: description,
|
|
Color: color,
|
|
Icon: icon,
|
|
}
|
|
|
|
books := make([]templates.BookData, len(booksData))
|
|
for i, book := range booksData {
|
|
author := ""
|
|
if book.Author.Valid {
|
|
author = book.Author.String
|
|
}
|
|
coverPath := ""
|
|
if book.CoverImagePath.Valid {
|
|
coverPath = book.CoverImagePath.String
|
|
}
|
|
books[i] = templates.BookData{
|
|
MediaItemID: uuid.UUID(book.MediaItemID.Bytes).String(),
|
|
Title: book.Title,
|
|
Author: author,
|
|
CoverImagePath: coverPath,
|
|
}
|
|
}
|
|
|
|
// Render template WITH data (SSR)
|
|
var buf bytes.Buffer
|
|
err = templates.CollectionDetail(user, collectionDetail, books).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
// ============================================================================
|
|
// FRONTEND ROUTES - DO NOT DELETE
|
|
// These routes serve Server-Side Rendered (SSR) HTML pages for the web UI.
|
|
// They are NOT API endpoints and should NOT be removed during refactors.
|
|
// All authenticated frontend routes use the jwtMiddleware to validate tokens.
|
|
// ============================================================================
|
|
|
|
// Public routes for login and registration pages (no auth required)
|
|
e.GET("/login", func(c echo.Context) error {
|
|
var buf bytes.Buffer
|
|
err := templates.Login().Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
e.GET("/register", func(c echo.Context) error {
|
|
var buf bytes.Buffer
|
|
err := templates.Register().Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
// Root route - landing page with smart login detection
|
|
e.GET("/", func(c echo.Context) error {
|
|
var buf bytes.Buffer
|
|
|
|
tokenString := c.Request().Header.Get("Authorization")
|
|
if tokenString != "" && len(tokenString) > 7 && tokenString[:7] == "Bearer " {
|
|
tokenString = tokenString[7:]
|
|
} else {
|
|
cookie, err := c.Cookie("token")
|
|
if err == nil {
|
|
tokenString = cookie.Value
|
|
}
|
|
}
|
|
|
|
loggedIn := false
|
|
if tokenString != "" {
|
|
token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
|
|
return []byte(cfg.JWTSecret), nil
|
|
})
|
|
loggedIn = err == nil && token.Valid
|
|
}
|
|
|
|
err = templates.Index(loggedIn).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
// Public redirect routes - convenience shortcuts to authenticated routes
|
|
e.GET("/bookshelf", func(c echo.Context) error {
|
|
return c.Redirect(http.StatusTemporaryRedirect, "/api/bookshelf")
|
|
})
|
|
|
|
e.GET("/dashboard", func(c echo.Context) error {
|
|
return c.Redirect(http.StatusTemporaryRedirect, "/api/bookshelf")
|
|
})
|
|
|
|
// Admin area routes (authenticated, admin role required, SSR)
|
|
e.GET("/admin", handlers.AdminMiddleware(func(c echo.Context) error {
|
|
user, err := getTemplateUserWithTheme(c, queries)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading user")
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
err = templates.Admin(user).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
}))
|
|
|
|
e.GET("/admin/", handlers.AdminMiddleware(func(c echo.Context) error {
|
|
user, err := getTemplateUserWithTheme(c, queries)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading user")
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
err = templates.Admin(user).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
}))
|
|
|
|
e.GET("/admin/profile", handlers.AdminMiddleware(func(c echo.Context) error {
|
|
user, err := getTemplateUserWithTheme(c, queries)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading user")
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
err = templates.AdminProfile(user).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
}))
|
|
|
|
e.GET("/admin/library", handlers.AdminMiddleware(func(c echo.Context) error {
|
|
user, err := getTemplateUserWithTheme(c, queries)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading user")
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
err = templates.AdminLibrary(user).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
}))
|
|
|
|
// Devices management page (authenticated SSR route)
|
|
protected.GET("/devices-page", func(c echo.Context) error {
|
|
user, err := getTemplateUserWithTheme(c, queries)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading user")
|
|
}
|
|
|
|
deviceData, err := deviceHandler.GetDevicesData(c)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading devices")
|
|
}
|
|
|
|
pendingData, err := deviceHandler.GetPendingRegistrationsData(c)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading pending registrations")
|
|
}
|
|
|
|
devicesList := make([]templates.DeviceData, len(deviceData))
|
|
for i, d := range deviceData {
|
|
lastSync := ""
|
|
if d.LastSync != nil {
|
|
lastSync = d.LastSync.Format("2006-01-02T15:04:05Z07:00")
|
|
}
|
|
lastSeen := ""
|
|
if d.LastSeen != nil {
|
|
lastSeen = d.LastSeen.Format("2006-01-02T15:04:05Z07:00")
|
|
}
|
|
|
|
devicesList[i] = templates.DeviceData{
|
|
ID: d.ID.String(),
|
|
DeviceName: d.DeviceName,
|
|
DeviceType: d.DeviceType,
|
|
SyncEnabled: d.SyncEnabled,
|
|
LastSync: lastSync,
|
|
LastSeen: lastSeen,
|
|
}
|
|
}
|
|
|
|
pendingList := make([]templates.PendingRegistrationData, len(pendingData))
|
|
for i, p := range pendingData {
|
|
pendingList[i] = templates.PendingRegistrationData{
|
|
RegistrationID: p["registration_id"].(string),
|
|
DeviceName: p["device_name"].(string),
|
|
DeviceType: p["device_type"].(string),
|
|
ExpiresAt: p["expires_at"].(string),
|
|
}
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
err = templates.Devices(user, devicesList, pendingList).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
// Conflicts management page (authenticated SSR route)
|
|
protected.GET("/conflicts-page", func(c echo.Context) error {
|
|
user, err := getTemplateUserWithTheme(c, queries)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading user")
|
|
}
|
|
|
|
conflictsData, total, unresolved, err := conflictHandler.GetConflictsData(c)
|
|
if err != nil {
|
|
return c.HTML(http.StatusInternalServerError, "Error loading conflicts")
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
err = templates.Conflicts(user, conflictsData, total, unresolved).Render(c.Request().Context(), &buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.HTML(http.StatusOK, buf.String())
|
|
})
|
|
|
|
// ============================================================================
|
|
// HEALTH CHECK (public - no authentication required)
|
|
// ============================================================================
|
|
|
|
e.GET("/health", func(c echo.Context) error {
|
|
ctx, cancel := context.WithTimeout(c.Request().Context(), 2*time.Second)
|
|
defer cancel()
|
|
|
|
if err := dbPool.Ping(ctx); err != nil {
|
|
return c.JSON(http.StatusServiceUnavailable, map[string]string{
|
|
"status": "unhealthy",
|
|
"error": "database unavailable",
|
|
})
|
|
}
|
|
|
|
return c.JSON(http.StatusOK, map[string]string{
|
|
"status": "healthy",
|
|
"database": "connected",
|
|
})
|
|
})
|
|
|
|
// ============================================================================
|
|
// DOCUMENTATION ROUTES (public - no authentication required)
|
|
// ============================================================================
|
|
|
|
// Documentation routes (no authentication required)
|
|
docsHandler := docs.NewHTTPHandler("docs")
|
|
e.GET("/docs", docsHandler.DocsHome)
|
|
e.GET("/docs/*", docsHandler.ShowDocumentation)
|
|
e.GET("/docs/api/search", docsHandler.Search)
|
|
e.GET("/docs/search-index.json", docsHandler.ServeSearchIndex)
|
|
|
|
// Start server
|
|
log.Printf("Starting server on port %s", cfg.ServerPort)
|
|
e.Logger.Fatal(e.Start(":" + cfg.ServerPort))
|
|
}
|