feat(uploads): match release groups with MusicBrainz and AcoustID

services/api/internal/uploads/releases.go

@@ -0,0 +1,298 @@
+package uploads
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"os"
+	"sort"
+	"strconv"
+	"time"
+
+	"github.com/google/uuid"
+	"pipu/api/internal/auth"
+	"pipu/api/internal/musicbrainz"
+	"pipu/api/internal/platform/apperr"
+)
+
+func (s *Service) lookupNextRelease(ctx context.Context) bool {
+	job, err := s.store.ClaimRelease(ctx)
+	if errors.Is(err, ErrNotFound) {
+		return false
+	}
+	if err != nil {
+		s.log.Error("uploads: release job", "err", err)
+		return false
+	}
+	run, cancel := context.WithTimeout(ctx, 4*time.Minute)
+	defer cancel()
+	files, err := s.store.AllInReleaseGroup(run, job.ID, job.GroupKey)
+	report := ReleaseReport{State: "error", Candidates: []ReleaseCandidate{}, GroupID: job.GroupKey}
+	if err == nil {
+		report.InputHash = releaseHash(files)
+		q := job.Query
+		var audio map[uuid.UUID]AudioRecognition
+		if q.Audio {
+			report.AudioResults, audio, q.RecordingIDs, err = s.identifyAudio(run, files)
+		}
+		valid := true
+		if !q.Audio && q.Artist == "" && q.Album == "" && q.ReleaseID == "" {
+			q, valid = batchReleaseQuery(files)
+		}
+		if err != nil {
+			report.State = "error"
+		} else if q.Audio && len(q.RecordingIDs) == 0 {
+			report.State = "not_found"
+		} else if !q.Audio && (!valid || q.ReleaseID == "" && (q.Artist == "" || q.Album == "")) {
+			report.State = "needs_input"
+		} else {
+			var releases []musicbrainz.Release
+			releases, err = s.catalogue.Search(run, q)
+			if err == nil {
+				report.State = "not_found"
+				for _, release := range releases {
+					candidate := matchReleaseWithAudio(files, release, audio)
+					candidate.Existing, err = s.store.ExistingReleaseTracks(run, candidate.Missing)
+					if err != nil {
+						break
+					}
+					report.Candidates = append(report.Candidates, candidate)
+				}
+				if len(report.Candidates) > 0 {
+					report.State = "ready"
+				}
+				sort.SliceStable(report.Candidates, func(i, j int) bool {
+					a, b := report.Candidates[i], report.Candidates[j]
+					if a.Complete != b.Complete {
+						return a.Complete
+					}
+					if a.Matched != b.Matched {
+						return a.Matched > b.Matched
+					}
+					return len(a.Unmatched) < len(b.Unmatched)
+				})
+			}
+		}
+	}
+	if err != nil {
+		report.State = "error"
+		report.Candidates = []ReleaseCandidate{}
+		s.log.Warn("uploads: release lookup", "batch_id", job.ID, "err", err)
+	}
+	if err = s.store.SaveRelease(ctx, job, report); err != nil {
+		s.log.Error("uploads: save release lookup", "err", err)
+	}
+	return true
+}
+func (s *Service) GetReleaseReport(ctx context.Context, id uuid.UUID, scope ...string) (ReleaseReport, error) {
+	if _, err := principal(ctx, auth.PermReviewUploads); err != nil {
+		return ReleaseReport{}, err
+	}
+	files, err := s.store.AllInBatch(ctx, id)
+	if err != nil {
+		return ReleaseReport{}, notFound(err)
+	}
+	files, groups, key, err := s.releaseScope(ctx, id, firstGroup(scope))
+	if err != nil {
+		return ReleaseReport{}, err
+	}
+	if s.catalogue == nil {
+		return ReleaseReport{State: "disabled", Candidates: []ReleaseCandidate{}, GroupID: key, Groups: groups}, nil
+	}
+	if len(groups) > 1 && key == "" {
+		return ReleaseReport{State: "needs_input", Candidates: []ReleaseCandidate{}, Groups: groups, AudioAvailable: s.identifier != nil}, nil
+	}
+	report, err := s.store.ReleaseReport(ctx, id, key)
+	if err != nil {
+		return report, err
+	}
+	if report.InputHash != "" && report.InputHash != releaseHash(files) && report.State != "queued" && report.State != "searching" {
+		if err = s.store.QueueRelease(ctx, id, musicbrainz.Query{GroupID: key}); err != nil {
+			return report, err
+		}
+		report = ReleaseReport{State: "queued", Candidates: []ReleaseCandidate{}, GroupID: key}
+	}
+	report.AudioAvailable = s.identifier != nil
+	report.Groups = groups
+	return report, nil
+}
+func (s *Service) SearchReleases(ctx context.Context, id uuid.UUID, q musicbrainz.Query) (ReleaseReport, error) {
+	if _, err := principal(ctx, auth.PermReviewUploads); err != nil {
+		return ReleaseReport{}, err
+	}
+	if s.catalogue == nil {
+		return ReleaseReport{}, apperr.Conflict("uploads.metadata_disabled", "external metadata is disabled")
+	}
+	if q.Audio && s.identifier == nil {
+		return ReleaseReport{}, apperr.Conflict("uploads.audio_disabled", "AcoustID application key is not configured")
+	}
+	files, groups, key, err := s.releaseScope(ctx, id, q.GroupID)
+	if err != nil {
+		return ReleaseReport{}, notFound(err)
+	}
+	if key == "" {
+		return ReleaseReport{}, apperr.Conflict("uploads.release_group_required", "choose a release group")
+	}
+	q.GroupID = key
+	editable := false
+	for _, f := range files {
+		editable = editable || f.Status == StatusPendingReview || f.Status == StatusImportFailed
+	}
+	if !editable {
+		return ReleaseReport{}, notFound(ErrWrongStatus)
+	}
+	if q.Audio {
+		count := 0
+		for _, f := range releaseFiles(files) {
+			if f.Status == StatusPendingReview || f.Status == StatusImportFailed {
+				count++
+			}
+		}
+		if count > maxAudioFiles {
+			return ReleaseReport{}, apperr.Validation("audio", "uploads.audio_batch_limit", "at most 50 editable tracks per audio lookup", nil)
+		}
+		q = musicbrainz.Query{Audio: true, GroupID: key}
+	}
+	if len(q.Artist) > 500 || len(q.Album) > 500 {
+		return ReleaseReport{}, apperr.Validation("query", "common.bad_request", "query too long", nil)
+	}
+	if q.ReleaseID != "" {
+		if _, err = uuid.Parse(q.ReleaseID); err != nil {
+			return ReleaseReport{}, apperr.Validation("release_id", "common.bad_request", "invalid release ID", nil)
+		}
+	}
+	if err = s.store.QueueRelease(ctx, id, q); err != nil {
+		return ReleaseReport{}, err
+	}
+	return ReleaseReport{State: "queued", Candidates: []ReleaseCandidate{}, AudioAvailable: s.identifier != nil, GroupID: key, Groups: groups}, nil
+}
+func (s *Service) releaseCandidate(ctx context.Context, batch uuid.UUID, release string, scope ...string) (ReleaseCandidate, []File, ReleaseReport, error) {
+	if _, err := principal(ctx, auth.PermReviewUploads); err != nil {
+		return ReleaseCandidate{}, nil, ReleaseReport{}, err
+	}
+	files, groups, key, err := s.releaseScope(ctx, batch, firstGroup(scope))
+	if err != nil {
+		return ReleaseCandidate{}, nil, ReleaseReport{}, notFound(err)
+	}
+	if len(groups) > 1 && key == "" {
+		return ReleaseCandidate{}, nil, ReleaseReport{}, apperr.Conflict("uploads.release_group_required", "choose a release group")
+	}
+	report, err := s.store.ReleaseReport(ctx, batch, key)
+	if err != nil {
+		return ReleaseCandidate{}, files, report, err
+	}
+	report.Groups = groups
+	if report.State != "ready" || report.InputHash != releaseHash(files) {
+		return ReleaseCandidate{}, files, report, apperr.Conflict("uploads.release_stale", "metadata changed; repeat release lookup")
+	}
+	for _, candidate := range report.Candidates {
+		if candidate.Release.ID == release {
+			return candidate, files, report, nil
+		}
+	}
+	return ReleaseCandidate{}, files, report, apperr.NotFound("uploads.release_not_found", "release is not in this batch's candidates")
+}
+func (s *Service) ReleaseCover(ctx context.Context, batch uuid.UUID, release string, scope ...string) (musicbrainz.Cover, error) {
+	c, _, _, err := s.releaseCandidate(ctx, batch, release, scope...)
+	if err != nil {
+		return musicbrainz.Cover{}, err
+	}
+	if s.catalogue == nil {
+		return musicbrainz.Cover{}, apperr.Conflict("uploads.metadata_disabled", "external metadata is disabled")
+	}
+	cover, err := s.catalogue.Cover(ctx, c.Release)
+	if errors.Is(err, musicbrainz.ErrNotFound) {
+		return cover, apperr.NotFound("uploads.release_cover_missing", "release has no cover")
+	}
+	if err != nil {
+		return cover, apperr.New(http.StatusServiceUnavailable, "uploads.metadata_unavailable", "cover provider is unavailable")
+	}
+	return cover, err
+}
+
+type releaseChange struct {
+	File      File
+	Meta      Meta
+	Placement placement
+	Tags      map[string]string
+}
+
+func (s *Service) ApplyRelease(ctx context.Context, batch uuid.UUID, release string, metadata, cover bool, scope ...string) (ReleaseReport, error) {
+	candidate, files, report, err := s.releaseCandidate(ctx, batch, release, scope...)
+	if err != nil {
+		return report, err
+	}
+	if !metadata && !cover {
+		return report, apperr.Validation("apply_metadata", "common.bad_request", "choose metadata or cover", nil)
+	}
+	var coverPath *string
+	if cover {
+		image, err := s.ReleaseCover(ctx, batch, release, report.GroupID)
+		if err != nil {
+			return report, err
+		}
+		coverPath, err = s.createCover(image.Data)
+		if err != nil {
+			return report, err
+		}
+	}
+	committed := false
+	defer func() {
+		if !committed && coverPath != nil {
+			_ = os.Remove(s.stagingAbs(*coverPath))
+		}
+	}()
+	changes := []releaseChange{}
+	byID := map[uuid.UUID]int{}
+	for i, f := range files {
+		byID[f.ID] = i
+	}
+	for _, match := range candidate.Matches {
+		i := byID[match.FileID]
+		f := files[i]
+		if !metadata || f.Meta == nil || f.Status != StatusPendingReview && f.Status != StatusImportFailed {
+			continue
+		}
+		t := candidate.Release.Tracks[match.TrackIndex]
+		m := *f.Meta
+		m.Artist, m.AlbumArtist, m.Album, m.Title = t.Artist, candidate.Release.Artist, candidate.Release.Title, t.Title
+		m.Disc, m.Track = &t.Disc, &t.Position
+		if len(candidate.Release.Date) >= 4 {
+			if y, e := strconv.Atoi(candidate.Release.Date[:4]); e == nil {
+				m.Year = &y
+			}
+		}
+		m = normalizeMeta(m)
+		tags := map[string]string{}
+		for k, v := range f.Tags {
+			tags[k] = v
+		}
+		tags["musicbrainz_albumid"], tags["musicbrainz_releasegroupid"], tags["musicbrainz_trackid"] = candidate.Release.ID, candidate.Release.GroupID, t.RecordingID
+		changes = append(changes, releaseChange{f, m, s.plan(ctx, f, m, f.TargetSourceID), tags})
+		files[i].Meta, files[i].Tags = &m, tags
+	}
+	if metadata && len(changes) == 0 {
+		return report, apperr.Conflict(CodeWrongStatus, "no matched editable tracks")
+	}
+	report.SelectedRelease = &release
+	next := report
+	next.InputHash = releaseHash(files)
+	reviewer, _ := principal(ctx, auth.PermReviewUploads)
+	if err = s.store.ApplyRelease(ctx, batch, report.InputHash, changes, coverPath, next, reviewer.UserID); err != nil {
+		return report, notFound(err)
+	}
+	committed = true
+	next.AudioAvailable = s.identifier != nil
+	for i, g := range next.Groups {
+		if g.ID == next.GroupID {
+			if cover {
+				next.Groups[i].HasCover = true
+			}
+			if metadata {
+				next.Groups[i].Artist = candidate.Release.Artist
+				next.Groups[i].Album = candidate.Release.Title
+			}
+		}
+	}
+	return next, nil
+}