feat: import with verification, and a Wanted view of its own (M502 #5522)

A finished download is checked against MusicBrainz before anything is
filed: the files are paired with an edition's tracks by position or path,
and AcoustID, tag ids, lengths and titles say whether it is the album.
What is the album is copied into the library as
Artist/Album (Year)/Artist - Album - NN - Title, tagged with Picard's
MusicBrainz ids, and scanned; the download keeps seeding. What is not is
refused: set aside, removed from the client, and the album searched for
again. A download the check cannot settle waits for a person, who imports
it anyway or refuses it. Tracks the library already holds are skipped.

The wanted list leaves Admin for a top-level Wanted view, admin-only and
web-only, with tabs for Wanted, Activity (downloads and their imports,
the ones needing a person first), Missing files, Held, Following (with the
release-type profiles, moved off Integrations) and Blocked. The search
settings gain "File new music into" when the library has several folders.

The search pass logs why each failed search failed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/api/admin_import.go

@@ -0,0 +1,205 @@
+package api
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/jackc/pgx/v5"
+
+	"git.fabledsword.com/bvandeusen/minstrel/internal/apierror"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/importer"
+)
+
+// Downloads and their imports (M502 #5522): the Wanted view's Activity tab,
+// a person's "import anyway", "refuse" and "retry", and the Blocked tab.
+
+// downloadView is one grab and what its import made of it.
+type downloadView struct {
+	ID            string             `json:"id"`
+	WantID        *string            `json:"want_id"`
+	WantTitle     string             `json:"want_title"`
+	WantArtist    string             `json:"want_artist"`
+	Name          string             `json:"name"`
+	Indexer       string             `json:"indexer"`
+	Client        string             `json:"client"`
+	Quality       string             `json:"quality"`
+	Origin        string             `json:"origin"`
+	GrabbedAt     string             `json:"grabbed_at"`
+	EndedAt       *string            `json:"ended_at"`
+	EndReason     string             `json:"end_reason"`
+	Progress      float32            `json:"progress"`
+	ImportState   string             `json:"import_state"`
+	ImportReason  string             `json:"import_reason"`
+	ImportedAt    *string            `json:"imported_at"`
+	ImportedFiles int32              `json:"imported_files"`
+	Destination   string             `json:"destination"`
+	Edition       string             `json:"edition,omitempty"`
+	Evidence      *importer.Evidence `json:"evidence,omitempty"`
+	Files         []string           `json:"files"`
+	Skipped       int                `json:"skipped"`
+	RehomedFrom   string             `json:"rehomed_from,omitempty"`
+}
+
+func downloadFrom(g dbq.ListGrabsRow) downloadView {
+	v := downloadView{
+		ID: uuidToString(g.ID), Name: g.Name, Indexer: g.Indexer, Client: g.Client, Quality: g.Quality,
+		Origin: g.Origin, GrabbedAt: formatTimestamp(g.GrabbedAt), EndReason: g.EndReason,
+		Progress: g.Progress, ImportState: g.ImportState, ImportReason: g.ImportReason,
+		ImportedFiles: g.ImportedFiles, Destination: g.Destination, Files: []string{},
+	}
+	if g.WantID.Valid {
+		id := uuidToString(g.WantID)
+		v.WantID = &id
+	}
+	if g.WantTitle != nil {
+		v.WantTitle = *g.WantTitle
+	}
+	if g.WantArtist != nil {
+		v.WantArtist = *g.WantArtist
+	}
+	if g.EndedAt.Valid {
+		at := formatTimestamp(g.EndedAt)
+		v.EndedAt = &at
+	}
+	if g.ImportedAt.Valid {
+		at := formatTimestamp(g.ImportedAt)
+		v.ImportedAt = &at
+	}
+	var det importer.Detail
+	if len(g.ImportDetail) > 0 && json.Unmarshal(g.ImportDetail, &det) == nil && det.Verdict.Outcome != "" {
+		ev := det.Verdict.Evidence
+		v.Evidence, v.Edition, v.Skipped, v.RehomedFrom = &ev, det.Edition, det.Skipped, det.RehomedFrom
+		if det.Files != nil {
+			v.Files = det.Files
+		}
+	}
+	return v
+}
+
+type downloadsPage struct {
+	Items  []downloadView `json:"items"`
+	Limit  int            `json:"limit"`
+	Offset int            `json:"offset"`
+}
+
+// handleListDownloads implements GET /api/admin/downloads?offset=: running
+// downloads first, then the rest newest first.
+func (h *handlers) handleListDownloads(w http.ResponseWriter, r *http.Request) {
+	limit, offset, err := parsePaging(r.URL.Query())
+	if err != nil {
+		writeErr(w, apierror.BadRequest("invalid_paging", "limit and offset must be numbers"))
+		return
+	}
+	rows, err := dbq.New(h.pool).ListGrabs(r.Context(), dbq.ListGrabsParams{MaxRows: int32(limit), Skip: int32(offset)})
+	if err != nil {
+		writeErrWithLog(w, h.logger, "admin downloads: list", apierror.Internal(err))
+		return
+	}
+	out := downloadsPage{Items: make([]downloadView, 0, len(rows)), Limit: limit, Offset: offset}
+	for _, g := range rows {
+		out.Items = append(out.Items, downloadFrom(g))
+	}
+	writeJSON(w, http.StatusOK, out)
+}
+
+// handleImportAnyway implements POST /api/admin/downloads/{id}/import: a
+// download the check held for a person (or one that failed) is imported on
+// the next pass whatever the check says.
+func (h *handlers) handleImportAnyway(w http.ResponseWriter, r *http.Request) {
+	id, ok := requireURLUUID(w, r, "id")
+	if !ok {
+		return
+	}
+	if _, err := dbq.New(h.pool).ForceGrabImport(r.Context(), id); err != nil {
+		h.writeImportErr(w, "import anyway", err)
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// handleRetryImport implements POST /api/admin/downloads/{id}/retry.
+func (h *handlers) handleRetryImport(w http.ResponseWriter, r *http.Request) {
+	id, ok := requireURLUUID(w, r, "id")
+	if !ok {
+		return
+	}
+	if _, err := dbq.New(h.pool).RetryGrabImport(r.Context(), id); err != nil {
+		h.writeImportErr(w, "retry", err)
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// handleRefuseDownload implements POST /api/admin/downloads/{id}/refuse: the
+// release is blocked, the download removed and the album searched again.
+func (h *handlers) handleRefuseDownload(w http.ResponseWriter, r *http.Request) {
+	admin, ok := requireUser(w, r)
+	if !ok {
+		return
+	}
+	id, ok := requireURLUUID(w, r, "id")
+	if !ok {
+		return
+	}
+	if _, err := h.importer.Refuse(r.Context(), id, admin.ID); err != nil {
+		h.writeImportErr(w, "refuse", err)
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func (h *handlers) writeImportErr(w http.ResponseWriter, what string, err error) {
+	switch {
+	case errors.Is(err, pgx.ErrNoRows), errors.Is(err, importer.ErrNotDecidable):
+		writeErr(w, apierror.Conflict("not_decidable", "that download is not waiting on a decision"))
+	default:
+		writeErrWithLog(w, h.logger, "admin downloads: "+what, apierror.Internal(err))
+	}
+}
+
+type releaseBlockView struct {
+	InfoHash   string `json:"info_hash"`
+	Name       string `json:"name"`
+	Reason     string `json:"reason"`
+	Detail     string `json:"detail"`
+	BlockedAt  string `json:"blocked_at"`
+	WantTitle  string `json:"want_title"`
+	WantArtist string `json:"want_artist"`
+}
+
+type releaseBlocksPage struct {
+	Items  []releaseBlockView `json:"items"`
+	Limit  int                `json:"limit"`
+	Offset int                `json:"offset"`
+}
+
+// handleListReleaseBlocks implements GET /api/admin/release-blocks?offset=:
+// every release set aside, by a person or by a check, newest first.
+func (h *handlers) handleListReleaseBlocks(w http.ResponseWriter, r *http.Request) {
+	limit, offset, err := parsePaging(r.URL.Query())
+	if err != nil {
+		writeErr(w, apierror.BadRequest("invalid_paging", "limit and offset must be numbers"))
+		return
+	}
+	rows, err := dbq.New(h.pool).ListReleaseBlocksPage(r.Context(), dbq.ListReleaseBlocksPageParams{
+		MaxRows: int32(limit), Skip: int32(offset)})
+	if err != nil {
+		writeErrWithLog(w, h.logger, "admin release blocks: list", apierror.Internal(err))
+		return
+	}
+	out := releaseBlocksPage{Items: make([]releaseBlockView, 0, len(rows)), Limit: limit, Offset: offset}
+	for _, b := range rows {
+		v := releaseBlockView{InfoHash: b.InfoHash, Name: b.Name, Reason: b.Reason, Detail: b.Detail,
+			BlockedAt: formatTimestamp(b.BlockedAt)}
+		if b.WantTitle != nil {
+			v.WantTitle = *b.WantTitle
+		}
+		if b.WantArtist != nil {
+			v.WantArtist = *b.WantArtist
+		}
+		out.Items = append(out.Items, v)
+	}
+	writeJSON(w, http.StatusOK, out)
+}