290 lines
8.8 KiB
Go
290 lines
8.8 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log/slog"
|
|
"net/http"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"github.com/Silo-Server/silo-server/internal/metadata"
|
|
"github.com/Silo-Server/silo-server/internal/models"
|
|
)
|
|
|
|
// MatchItemLookup loads a media item by content ID.
|
|
type MatchItemLookup interface {
|
|
GetByID(ctx context.Context, contentID string) (*models.MediaItem, error)
|
|
}
|
|
|
|
// MatchFolderLookup resolves the primary library folder for a content ID.
|
|
type MatchFolderLookup interface {
|
|
GetFolderIDForItem(ctx context.Context, contentID string) (int, error)
|
|
GetFolderIDsForItem(ctx context.Context, contentID string) ([]int, error)
|
|
}
|
|
|
|
// MatchMetadataService exposes search and process operations needed by the
|
|
// admin match endpoints.
|
|
type MatchMetadataService interface {
|
|
SearchAndNormalize(ctx context.Context, query metadata.SearchQuery, folderID int) ([]metadata.MatchCandidate, error)
|
|
Process(ctx context.Context, req metadata.ProcessRequest) (*metadata.ProcessResult, error)
|
|
}
|
|
|
|
// AdminMatchHandler handles the explicit match search and apply endpoints
|
|
// used by the admin match-repair UI.
|
|
type AdminMatchHandler struct {
|
|
items MatchItemLookup
|
|
folders MatchFolderLookup
|
|
metadata MatchMetadataService
|
|
}
|
|
|
|
// NewAdminMatchHandler creates a handler for admin match search/apply endpoints.
|
|
func NewAdminMatchHandler(
|
|
items MatchItemLookup,
|
|
folders MatchFolderLookup,
|
|
metadataSvc MatchMetadataService,
|
|
) *AdminMatchHandler {
|
|
return &AdminMatchHandler{
|
|
items: items,
|
|
folders: folders,
|
|
metadata: metadataSvc,
|
|
}
|
|
}
|
|
|
|
// --- Request/Response types ---
|
|
|
|
type matchSearchRequest struct {
|
|
Title string `json:"title"`
|
|
Year int `json:"year"`
|
|
ImdbID string `json:"imdb_id"`
|
|
TmdbID string `json:"tmdb_id"`
|
|
TvdbID string `json:"tvdb_id"`
|
|
LibraryID *int `json:"library_id,omitempty"`
|
|
}
|
|
|
|
type matchSearchResponse struct {
|
|
Candidates []metadata.MatchCandidate `json:"candidates"`
|
|
}
|
|
|
|
type matchApplyRequest struct {
|
|
ProviderIDs map[string]string `json:"provider_ids"`
|
|
LibraryID *int `json:"library_id,omitempty"`
|
|
}
|
|
|
|
type matchApplyResponse struct {
|
|
ContentID string `json:"content_id"`
|
|
Updated bool `json:"updated"`
|
|
}
|
|
|
|
// HandleSearchItemMatchCandidates handles POST /admin/items/{id}/match/search.
|
|
// It searches metadata providers for candidate matches based on the given
|
|
// query parameters (title, year, external IDs) and returns normalized,
|
|
// deduplicated candidates.
|
|
func (h *AdminMatchHandler) HandleSearchItemMatchCandidates(w http.ResponseWriter, r *http.Request) {
|
|
contentID := chi.URLParam(r, "id")
|
|
if contentID == "" {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "Item ID is required")
|
|
return
|
|
}
|
|
|
|
var req matchSearchRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "Invalid request body")
|
|
return
|
|
}
|
|
|
|
// Load the existing item to infer content type.
|
|
item, err := h.items.GetByID(r.Context(), contentID)
|
|
if err != nil {
|
|
slog.Warn("admin match: item not found", "content_id", contentID, "error", err)
|
|
writeError(w, http.StatusNotFound, "not_found", "Item not found")
|
|
return
|
|
}
|
|
|
|
folderID, err := h.resolveMatchFolderID(r.Context(), contentID, req.LibraryID)
|
|
if err != nil {
|
|
if err.Error() == "ambiguous_library" {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "library_id is required for items in multiple libraries")
|
|
return
|
|
}
|
|
slog.Warn("admin match: resolve folder failed", "content_id", contentID, "error", err)
|
|
writeError(w, http.StatusBadRequest, "bad_request", "Invalid library_id")
|
|
return
|
|
}
|
|
|
|
// Build the search query from the request, falling back to item metadata.
|
|
query := metadata.SearchQuery{
|
|
Title: req.Title,
|
|
Year: req.Year,
|
|
ContentType: item.Type,
|
|
ProviderIDs: make(map[string]string),
|
|
}
|
|
if query.Title == "" {
|
|
query.Title = item.Title
|
|
}
|
|
if query.Year == 0 {
|
|
query.Year = item.Year
|
|
}
|
|
|
|
// Inject any provider IDs from the request.
|
|
if req.ImdbID != "" {
|
|
query.ProviderIDs["imdb"] = req.ImdbID
|
|
}
|
|
if req.TmdbID != "" {
|
|
query.ProviderIDs["tmdb"] = req.TmdbID
|
|
}
|
|
if req.TvdbID != "" {
|
|
query.ProviderIDs["tvdb"] = req.TvdbID
|
|
}
|
|
|
|
candidates, err := h.metadata.SearchAndNormalize(r.Context(), query, folderID)
|
|
if err != nil {
|
|
slog.Error("admin match: search failed", "content_id", contentID, "error", err)
|
|
writeError(w, http.StatusInternalServerError, "internal_error", "Metadata search failed")
|
|
return
|
|
}
|
|
|
|
writeJSON(w, http.StatusOK, matchSearchResponse{Candidates: candidates})
|
|
}
|
|
|
|
// HandleApplyItemMatch handles POST /admin/items/{id}/match/apply.
|
|
// It applies the user-selected provider IDs to the item via ModeIdentify,
|
|
// preserving the original content_id.
|
|
func (h *AdminMatchHandler) HandleApplyItemMatch(w http.ResponseWriter, r *http.Request) {
|
|
contentID := chi.URLParam(r, "id")
|
|
if contentID == "" {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "Item ID is required")
|
|
return
|
|
}
|
|
|
|
var req matchApplyRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "Invalid request body")
|
|
return
|
|
}
|
|
|
|
if len(req.ProviderIDs) == 0 {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "At least one provider ID is required")
|
|
return
|
|
}
|
|
|
|
// Verify the item exists.
|
|
_, err := h.items.GetByID(r.Context(), contentID)
|
|
if err != nil {
|
|
slog.Warn("admin match: item not found for apply", "content_id", contentID, "error", err)
|
|
writeError(w, http.StatusNotFound, "not_found", "Item not found")
|
|
return
|
|
}
|
|
|
|
folderID, err := h.resolveMatchFolderID(r.Context(), contentID, req.LibraryID)
|
|
if err != nil {
|
|
if err.Error() == "ambiguous_library" {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "library_id is required for items in multiple libraries")
|
|
return
|
|
}
|
|
slog.Warn("admin match: resolve folder failed for apply", "content_id", contentID, "error", err)
|
|
writeError(w, http.StatusBadRequest, "bad_request", "Invalid library_id")
|
|
return
|
|
}
|
|
folderIDStr := ""
|
|
if folderID > 0 {
|
|
folderIDStr = fmt.Sprintf("%d", folderID)
|
|
}
|
|
|
|
result, err := h.metadata.Process(r.Context(), metadata.ProcessRequest{
|
|
ContentID: contentID,
|
|
ProviderIDs: req.ProviderIDs,
|
|
FolderID: folderIDStr,
|
|
Mode: metadata.ModeIdentify,
|
|
})
|
|
if err != nil {
|
|
slog.Error("admin match: apply failed", "content_id", contentID, "error", err)
|
|
writeError(w, http.StatusInternalServerError, "internal_error", "Failed to apply match")
|
|
return
|
|
}
|
|
|
|
writeJSON(w, http.StatusOK, matchApplyResponse{
|
|
ContentID: result.ContentID,
|
|
Updated: result.Updated,
|
|
})
|
|
}
|
|
|
|
// PoolFolderLookup implements MatchFolderLookup using a direct pgx pool query
|
|
// against the media_item_libraries table.
|
|
type PoolFolderLookup struct {
|
|
Pool *pgxpool.Pool
|
|
}
|
|
|
|
// GetFolderIDForItem returns the first library folder ID associated with the
|
|
// given content ID.
|
|
func (l *PoolFolderLookup) GetFolderIDForItem(ctx context.Context, contentID string) (int, error) {
|
|
var folderID int
|
|
err := l.Pool.QueryRow(ctx,
|
|
`SELECT media_folder_id FROM media_item_libraries WHERE content_id = $1 ORDER BY media_folder_id ASC LIMIT 1`,
|
|
contentID,
|
|
).Scan(&folderID)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("looking up folder for item %s: %w", contentID, err)
|
|
}
|
|
return folderID, nil
|
|
}
|
|
|
|
func (l *PoolFolderLookup) GetFolderIDsForItem(ctx context.Context, contentID string) ([]int, error) {
|
|
rows, err := l.Pool.Query(ctx,
|
|
`SELECT media_folder_id FROM media_item_libraries WHERE content_id = $1 ORDER BY media_folder_id ASC`,
|
|
contentID,
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("looking up folders for item %s: %w", contentID, err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var folderIDs []int
|
|
for rows.Next() {
|
|
var folderID int
|
|
if scanErr := rows.Scan(&folderID); scanErr != nil {
|
|
return nil, fmt.Errorf("scanning folder for item %s: %w", contentID, scanErr)
|
|
}
|
|
folderIDs = append(folderIDs, folderID)
|
|
}
|
|
return folderIDs, rows.Err()
|
|
}
|
|
|
|
func (h *AdminMatchHandler) resolveMatchFolderID(ctx context.Context, contentID string, requestedLibraryID *int) (int, error) {
|
|
if h.folders == nil {
|
|
if requestedLibraryID != nil && *requestedLibraryID > 0 {
|
|
return *requestedLibraryID, nil
|
|
}
|
|
return 0, nil
|
|
}
|
|
if requestedLibraryID != nil {
|
|
if *requestedLibraryID <= 0 {
|
|
return 0, fmt.Errorf("invalid library id")
|
|
}
|
|
folderIDs, err := h.folders.GetFolderIDsForItem(ctx, contentID)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("invalid library id")
|
|
}
|
|
for _, folderID := range folderIDs {
|
|
if folderID == *requestedLibraryID {
|
|
return folderID, nil
|
|
}
|
|
}
|
|
return 0, fmt.Errorf("invalid library id")
|
|
}
|
|
folderIDs, err := h.folders.GetFolderIDsForItem(ctx, contentID)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("folder lookup failed: %w", err)
|
|
}
|
|
switch len(folderIDs) {
|
|
case 0:
|
|
return 0, nil
|
|
case 1:
|
|
return folderIDs[0], nil
|
|
default:
|
|
return 0, fmt.Errorf("ambiguous_library")
|
|
}
|
|
}
|