feat(handlers): Add OPDS, collections, book matching, and sync handlers

- Add OPDS handler for device catalog and book downloads - Add collections handler for collection CRUD - Add book matching service for cross-device book linking - Add sidecar handler for Kobo metadata sync - Add sync handler for device synchronization
2026-01-31 22:32:23 -05:00
parent d28002e4cb
commit 6495cc2c7c
5 changed files with 2196 additions and 0 deletions
@@ -0,0 +1,334 @@
+package handlers
+
+import (
+	"bookmann/internal/database"
+	"bookmann/internal/services"
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/labstack/echo/v4"
+)
+
+// Book matching service (added to Handler struct in ebook.go initialization)
+func (h *Handler) getMatchingService() *services.BookMatchingService {
+	return services.NewBookMatchingService(h.db)
+}
+
+// QueryBooks handles POST /api/sync/books/query
+func (h *Handler) QueryBooks(c echo.Context) error {
+	matchingService := h.getMatchingService()
+
+	var req services.BookQueryRequest
+	if err := c.Bind(&req); err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid request body",
+		})
+	}
+
+	response, err := matchingService.QueryBooks(c.Request().Context(), &req)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"error": "Failed to query books",
+		})
+	}
+
+	return c.JSON(http.StatusOK, response)
+}
+
+// LinkBook handles POST /api/sync/link-book
+func (h *Handler) LinkBook(c echo.Context) error {
+	matchingService := h.getMatchingService()
+
+	var req services.LinkBookRequest
+	if err := c.Bind(&req); err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid request body",
+		})
+	}
+
+	// Get device ID from context (set by auth middleware)
+	deviceIDStr := c.Param("deviceId")
+	deviceID, err := uuid.Parse(deviceIDStr)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid device ID",
+		})
+	}
+
+	alias, err := matchingService.LinkBook(c.Request().Context(), deviceID, &req)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"error": fmt.Sprintf("Failed to link book: %v", err),
+		})
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"status": "linked",
+		"device_file_alias": map[string]interface{}{
+			"id":               uuid.UUID(alias.ID.Bytes).String(),
+			"media_item_id":    uuid.UUID(alias.MediaItemID.Bytes).String(),
+			"device_id":        uuid.UUID(alias.DeviceID.Bytes).String(),
+			"file_path":        alias.FilePath,
+			"file_sha256":      alias.FileSha256.String,
+			"confidence_score": alias.ConfidenceScore.Float64,
+		},
+	})
+}
+
+// GetUnlinkedBooks handles GET /api/sync/unlinked-books
+func (h *Handler) GetUnlinkedBooks(c echo.Context) error {
+	matchingService := h.getMatchingService()
+
+	deviceIDStr := c.Param("deviceId")
+	deviceID, err := uuid.Parse(deviceIDStr)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid device ID",
+		})
+	}
+
+	unlinked, err := matchingService.GetUnlinkedBooks(c.Request().Context(), deviceID)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"error": "Failed to get unlinked books",
+		})
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"unlinked": unlinked,
+		"total":    len(unlinked),
+	})
+}
+
+// GetDeviceFileAliases handles GET /api/devices/:id/file-aliases
+func (h *Handler) GetDeviceFileAliases(c echo.Context) error {
+	deviceIDStr := c.Param("id")
+	deviceID, err := uuid.Parse(deviceIDStr)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid device ID",
+		})
+	}
+
+	aliases, err := h.db.GetDeviceFileAliasesByDevice(c.Request().Context(), pgtype.UUID{Bytes: deviceID, Valid: true})
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"error": "Failed to get file aliases",
+		})
+	}
+
+	// Convert to response format
+	type AliasResponse struct {
+		ID              string  `json:"id"`
+		MediaItemID     string  `json:"media_item_id"`
+		FilePath        string  `json:"file_path"`
+		FileSHA256      string  `json:"file_sha256"`
+		ConfidenceScore float64 `json:"confidence_score"`
+		LastSeenAt      string  `json:"last_seen_at"`
+	}
+
+	response := make([]AliasResponse, len(aliases))
+	for i, alias := range aliases {
+		response[i] = AliasResponse{
+			ID:              uuid.UUID(alias.ID.Bytes).String(),
+			MediaItemID:     uuid.UUID(alias.MediaItemID.Bytes).String(),
+			FilePath:        alias.FilePath,
+			FileSHA256:      alias.FileSha256.String,
+			ConfidenceScore: alias.ConfidenceScore.Float64,
+			LastSeenAt:      alias.LastSeenAt.Time.String(),
+		}
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"device_id": deviceIDStr,
+		"aliases":   response,
+		"total":     len(response),
+	})
+}
+
+// CreateDeviceFileAlias handles POST /api/devices/:id/file-aliases
+func (h *Handler) CreateDeviceFileAlias(c echo.Context) error {
+	deviceIDStr := c.Param("id")
+	deviceID, err := uuid.Parse(deviceIDStr)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid device ID",
+		})
+	}
+
+	var req struct {
+		MediaItemID     string  `json:"media_item_id"`
+		FilePath        string  `json:"file_path"`
+		FileSHA256      string  `json:"file_sha256"`
+		ConfidenceScore float64 `json:"confidence_score"`
+	}
+
+	if err := c.Bind(&req); err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid request body",
+		})
+	}
+
+	mediaItemID, err := uuid.Parse(req.MediaItemID)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid media item ID",
+		})
+	}
+
+	alias, err := h.db.CreateDeviceFileAlias(c.Request().Context(), database.CreateDeviceFileAliasParams{
+		MediaItemID:     pgtype.UUID{Bytes: mediaItemID, Valid: true},
+		DeviceID:        pgtype.UUID{Bytes: deviceID, Valid: true},
+		FilePath:        req.FilePath,
+		FileSha256:      pgtype.Text{String: req.FileSHA256, Valid: req.FileSHA256 != ""},
+		ConfidenceScore: pgtype.Float8{Float64: req.ConfidenceScore, Valid: true},
+	})
+
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"error": fmt.Sprintf("Failed to create file alias: %v", err),
+		})
+	}
+
+	return c.JSON(http.StatusCreated, map[string]interface{}{
+		"id":               uuid.UUID(alias.ID.Bytes).String(),
+		"media_item_id":    uuid.UUID(alias.MediaItemID.Bytes).String(),
+		"device_id":        deviceIDStr,
+		"file_path":        alias.FilePath,
+		"file_sha256":      alias.FileSha256.String,
+		"confidence_score": alias.ConfidenceScore.Float64,
+		"last_seen_at":     alias.LastSeenAt.Time.String(),
+	})
+}
+
+// UpdateDeviceFileAlias handles PUT /api/devices/:id/file-aliases/:aliasId
+func (h *Handler) UpdateDeviceFileAlias(c echo.Context) error {
+	aliasIDStr := c.Param("aliasId")
+	aliasID, err := uuid.Parse(aliasIDStr)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid alias ID",
+		})
+	}
+
+	var req struct {
+		MediaItemID     *string  `json:"media_item_id"`
+		FileSHA256      *string  `json:"file_sha256"`
+		ConfidenceScore *float64 `json:"confidence_score"`
+	}
+
+	if err := c.Bind(&req); err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid request body",
+		})
+	}
+
+	// Build update parameters
+	var mediaItemID pgtype.UUID
+	if req.MediaItemID != nil {
+		parsedID, err := uuid.Parse(*req.MediaItemID)
+		if err != nil {
+			return c.JSON(http.StatusBadRequest, map[string]string{
+				"error": "Invalid media item ID",
+			})
+		}
+		mediaItemID = pgtype.UUID{Bytes: parsedID, Valid: true}
+	}
+
+	var fileSHA256 pgtype.Text
+	if req.FileSHA256 != nil {
+		fileSHA256 = pgtype.Text{String: *req.FileSHA256, Valid: true}
+	}
+
+	var confidenceScore pgtype.Float8
+	if req.ConfidenceScore != nil {
+		confidenceScore = pgtype.Float8{Float64: *req.ConfidenceScore, Valid: true}
+	}
+
+	alias, err := h.db.UpdateDeviceFileAlias(c.Request().Context(), database.UpdateDeviceFileAliasParams{
+		ID:              pgtype.UUID{Bytes: aliasID, Valid: true},
+		MediaItemID:     mediaItemID,
+		FileSha256:      fileSHA256,
+		ConfidenceScore: confidenceScore,
+	})
+
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"error": fmt.Sprintf("Failed to update file alias: %v", err),
+		})
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"id":               uuid.UUID(alias.ID.Bytes).String(),
+		"media_item_id":    uuid.UUID(alias.MediaItemID.Bytes).String(),
+		"file_path":        alias.FilePath,
+		"file_sha256":      alias.FileSha256.String,
+		"confidence_score": alias.ConfidenceScore.Float64,
+		"last_seen_at":     alias.LastSeenAt.Time.String(),
+	})
+}
+
+// DeleteDeviceFileAlias handles DELETE /api/devices/:id/file-aliases/:aliasId
+func (h *Handler) DeleteDeviceFileAlias(c echo.Context) error {
+	aliasIDStr := c.Param("aliasId")
+	aliasID, err := uuid.Parse(aliasIDStr)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{
+			"error": "Invalid alias ID",
+		})
+	}
+
+	err = h.db.DeleteDeviceFileAlias(c.Request().Context(), pgtype.UUID{Bytes: aliasID, Valid: true})
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"error": "Failed to delete file alias",
+		})
+	}
+
+	return c.JSON(http.StatusOK, map[string]string{
+		"message": "File alias deleted successfully",
+	})
+}
+
+// GetBookMatches handles GET /api/books/match
+func (h *Handler) GetBookMatches(c echo.Context) error {
+	matchingService := h.getMatchingService()
+
+	// Get query parameters
+	identifiers := c.QueryParams()["identifier"]
+	sha256 := c.QueryParam("sha256")
+	title := c.QueryParam("title")
+	author := c.QueryParam("author")
+	fileSizeStr := c.QueryParam("file_size")
+
+	var fileSize int64
+	if fileSizeStr != "" {
+		size, err := strconv.ParseInt(fileSizeStr, 10, 64)
+		if err != nil {
+			return c.JSON(http.StatusBadRequest, map[string]string{
+				"error": "Invalid file_size parameter",
+			})
+		}
+		fileSize = size
+	}
+
+	req := &services.BookQueryRequest{
+		Identifiers: identifiers,
+		SHA256:      sha256,
+		Title:       title,
+		Author:      author,
+		FileSize:    fileSize,
+	}
+
+	response, err := matchingService.QueryBooks(c.Request().Context(), req)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"error": "Failed to query books",
+		})
+	}
+
+	return c.JSON(http.StatusOK, response)
+}