feat(notifications): requests and flags reach the people who act on them (#5340)

- A new request still pending after any auto-approval notifies the
  admins (request_pending), but not the requester if they are an admin.
  A request that dedups into one already in flight is not announced again.
- Approving or rejecting a request notifies the requester, and a
  rejection carries the admin's notes as the reason. An admin deciding
  their own request gets nothing.
- The reconciler notifies the requester when their request arrives
  (request_completed), linking the matched album or artist.
- A request the re-acquisition sweeper files and cannot approve itself
  notifies the admins.
- A quarantine flag notifies every admin except the flagger, naming the
  track, the flagger and the reason.

lidarrrequests.Service.CreateTracked reports whether a request was
inserted or deduped; Create wraps it.

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

internal/lidarrrequests/reconciler.go

@@ -15,6 +15,7 @@ import (
 	"git.fabledsword.com/bvandeusen/minstrel/internal/eventbus"
 	"git.fabledsword.com/bvandeusen/minstrel/internal/lidarr"
 	"git.fabledsword.com/bvandeusen/minstrel/internal/lidarrconfig"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/notifications"
 	"git.fabledsword.com/bvandeusen/minstrel/internal/tags"
 )
 
@@ -30,6 +31,7 @@ type Reconciler struct {
 	clientFn  func() *lidarr.Client
 	logger    *slog.Logger
 	bus       *eventbus.Bus
+	notifier  *notifications.Notifier // nil: no inbox notifications
 	tick      time.Duration
 	batch     int32
 	// releaseGroup names the MusicBrainz release group of a release id, to
@@ -61,9 +63,26 @@ func NewReconciler(pool *pgxpool.Pool, cfg *lidarrconfig.Service, clientFn func(
 	}
 }
 
-// publishCompleted broadcasts a request.status_changed event scoped to
-// the original requester. No-op when bus is nil.
-func (r *Reconciler) publishCompleted(row dbq.LidarrRequest) {
+// SetNotifier makes completions land in the requester's notifications inbox
+// (M489). Without one, completions are only broadcast on the bus.
+func (r *Reconciler) SetNotifier(n *notifications.Notifier) { r.notifier = n }
+
+// publishCompleted tells the requester their request arrived: a
+// request.status_changed event for open screens, and a notification that
+// outlives the connection.
+func (r *Reconciler) publishCompleted(ctx context.Context, row dbq.LidarrRequest) {
+	p := notifications.Payload{
+		RequestID:   formatUUIDForBus(row.ID),
+		RequestKind: string(row.Kind),
+		Name:        DisplayName(row),
+	}
+	if row.MatchedAlbumID.Valid {
+		p.AlbumID = formatUUIDForBus(row.MatchedAlbumID)
+	} else if row.MatchedArtistID.Valid {
+		p.ArtistID = formatUUIDForBus(row.MatchedArtistID)
+	}
+	r.notifier.NotifyLogged(ctx, notifications.KindRequestCompleted, notifications.ToUser(row.UserID), p.Map())
+
 	if r.bus == nil {
 		return
 	}
@@ -308,7 +327,7 @@ func (r *Reconciler) reconcileArtist(ctx context.Context, q *dbq.Queries, row db
 	if err != nil {
 		return err
 	}
-	r.publishCompleted(completed)
+	r.publishCompleted(ctx, completed)
 	return nil
 }
 
@@ -333,7 +352,7 @@ func (r *Reconciler) reconcileAlbum(ctx context.Context, q *dbq.Queries, row dbq
 	if err != nil {
 		return err
 	}
-	r.publishCompleted(completed)
+	r.publishCompleted(ctx, completed)
 	return nil
 }
 
@@ -374,7 +393,7 @@ func (r *Reconciler) reconcileTrack(ctx context.Context, q *dbq.Queries, row dbq
 	if err != nil {
 		return err
 	}
-	r.publishCompleted(completed)
+	r.publishCompleted(ctx, completed)
 	return nil
 }
 

internal/lidarrrequests/reconciler_notify_test.go

@@ -0,0 +1,52 @@
+package lidarrrequests
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+
+	"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/lidarrconfig"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/notifications"
+)
+
+// M489: an album request that arrives lands in the requester's inbox once,
+// linked to the album it matched.
+func TestReconciler_CompletionNotifiesRequester(t *testing.T) {
+	pool := newPool(t)
+	q := dbq.New(pool)
+	ctx := context.Background()
+
+	enableLidarrForPool(t, pool)
+	user := seedUser(t, pool)
+	artist := seedArtist(t, q, "Notify Artist", "notify-artist-mbid")
+	album := seedAlbum(t, q, artist.ID, "Notify Album", "notify-album-mbid")
+	_ = seedTrack(t, q, album.ID, artist.ID, "Notify Track", "/music/notify/01.flac")
+	seedApprovedRequestDirect(t, q, user, CreateParams{
+		Kind: "album", LidarrArtistMBID: "notify-artist-mbid", LidarrAlbumMBID: "notify-album-mbid",
+		ArtistName: "Notify Artist", AlbumTitle: "Notify Album",
+	})
+
+	rec := NewReconciler(pool, lidarrconfig.New(pool), nil, newTestLogger(), nil)
+	rec.SetNotifier(notifications.New(pool, nil, nil))
+	for i := 0; i < 2; i++ { // the second tick finds nothing left to complete
+		if err := rec.tickOnce(ctx); err != nil {
+			t.Fatalf("tickOnce: %v", err)
+		}
+	}
+
+	rows, err := q.ListNotifications(ctx, dbq.ListNotificationsParams{UserID: user, PageLimit: 10})
+	if err != nil {
+		t.Fatalf("list notifications: %v", err)
+	}
+	if len(rows) != 1 || rows[0].Kind != string(notifications.KindRequestCompleted) {
+		t.Fatalf("inbox = %+v, want one request_completed", rows)
+	}
+	var p notifications.Payload
+	if err := json.Unmarshal(rows[0].Payload, &p); err != nil {
+		t.Fatal(err)
+	}
+	if p.Name != "Notify Artist – Notify Album" || p.AlbumID != formatUUIDForBus(album.ID) || p.ArtistID != "" {
+		t.Errorf("payload = %+v", p)
+	}
+}

internal/lidarrrequests/service.go

@@ -80,8 +80,16 @@ func NewService(pool *pgxpool.Pool, cfg *lidarrconfig.Service, clientFn func() *
 // Create validates the kind→required-fields invariant and inserts a
 // pending row.
 func (s *Service) Create(ctx context.Context, userID pgtype.UUID, p CreateParams) (dbq.LidarrRequest, error) {
+	row, _, err := s.CreateTracked(ctx, userID, p)
+	return row, err
+}
+
+// CreateTracked is Create, also reporting whether a row was inserted. A
+// request that dedupes into one already in flight is not new, so callers
+// that announce new requests (M489) say nothing for it.
+func (s *Service) CreateTracked(ctx context.Context, userID pgtype.UUID, p CreateParams) (dbq.LidarrRequest, bool, error) {
 	if err := validateKindFields(p); err != nil {
-		return dbq.LidarrRequest{}, err
+		return dbq.LidarrRequest{}, false, err
 	}
 	q := dbq.New(s.pool)
 	// Dedup: if a non-terminal request for this MBID already exists,
@@ -97,9 +105,9 @@ func (s *Service) Create(ctx context.Context, userID pgtype.UUID, p CreateParams
 		dedupMBID = p.LidarrTrackMBID
 	}
 	if existing, derr := q.GetNonTerminalRequestForMBID(ctx, dedupMBID); derr == nil {
-		return existing, nil
+		return existing, false, nil
 	} else if !errors.Is(derr, pgx.ErrNoRows) {
-		return dbq.LidarrRequest{}, fmt.Errorf("create: dedup check: %w", derr)
+		return dbq.LidarrRequest{}, false, fmt.Errorf("create: dedup check: %w", derr)
 	}
 	row, err := q.CreateLidarrRequest(ctx, dbq.CreateLidarrRequestParams{
 		UserID:           userID,
@@ -112,9 +120,25 @@ func (s *Service) Create(ctx context.Context, userID pgtype.UUID, p CreateParams
 		TrackTitle:       strPtr(p.TrackTitle),
 	})
 	if err != nil {
-		return dbq.LidarrRequest{}, fmt.Errorf("create: %w", err)
+		return dbq.LidarrRequest{}, false, fmt.Errorf("create: %w", err)
 	}
-	return row, nil
+	return row, true, nil
+}
+
+// DisplayName is a request as a person would say it: "Moe Shop" for an
+// artist, "Moe Shop – WWW" for an album or a track.
+func DisplayName(row dbq.LidarrRequest) string {
+	switch row.Kind {
+	case dbq.LidarrRequestKindTrack:
+		if row.TrackTitle != nil && *row.TrackTitle != "" {
+			return row.ArtistName + " – " + *row.TrackTitle
+		}
+	case dbq.LidarrRequestKindAlbum:
+		if row.AlbumTitle != nil && *row.AlbumTitle != "" {
+			return row.ArtistName + " – " + *row.AlbumTitle
+		}
+	}
+	return row.ArtistName
 }
 
 func validateKindFields(p CreateParams) error {