Add Reject button: blocklist + delete a wrong Spotify match

dprodger · claude · dprodger · commit 83a161436070 · 2026-04-28T19:53:21.000-04:00
Sits next to the Verify button on /admin/duration-mismatches/&lt;song&gt;.
Confirms first, then in a single transaction:

  1. Inserts into bad_streaming_matches at block_level='track' so
     get_blocked_tracks_for_song will return this Spotify track on the
     next match attempt — the matcher already consults this list at the
     top of match_track_to_recording and skips blocked candidates. The
     block survives every rematch / refresh / sweep cycle.

  2. DELETEs the recording_release_streaming_links row.

Idempotent: the unique constraint on bad_streaming_matches collapses
duplicate inserts; a second reject on the same link 404s on the
already-deleted row.

Concrete case from production: a Spotify track linked to the wrong
album entirely (different artists, different songs). Plain delete
without blocking would let the next rematch re-find and re-link the
same wrong track. The block tells the matcher "this Spotify track is
never a match for this song," permanently.

Plumbing:

- New helper integrations.spotify.db.block_streaming_track(conn, song_id,
  track_id, ...) — inserts the blocklist row idempotently. Uses
  column-list ON CONFLICT (not constraint-name) so test environments
  bootstrapped from sql/jazz-db-schema.sql work without depending on
  the named-constraint form in the migration file.

- New admin endpoint POST /admin/duration-mismatches/links/&lt;id&gt;/reject
  with optional body {"reason": "..."} captured into
  bad_streaming_matches.reason for human review. 404s for unknown link.
  Goes through the existing admin gate + CSRF double-submit.

- Reject button on the Status column with a destructive confirm
  dialog ("This is permanent until you remove the blocklist entry
  manually"). Only shown on unverified rows — verified rows have
  already been intentionally accepted, so a reject affordance there
  would be confusing.

Tests: 7 new in test_admin_verify_match.py covering the db helper's
insert + idempotency, and the endpoint's auth gate, success path,
reason persistence, 404, and idempotency.

Co-Authored-By: Claude Opus 4.7 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/backend/integrations/spotify/db.py b/backend/integrations/spotify/db.py
@@ -668,6 +668,57 @@ def set_track_link_manual_override(conn, streaming_link_id: str,
     return True
 
 
+def block_streaming_track(conn, song_id: str, track_id: str,
+                          service: str = 'spotify',
+                          reason: str = None,
+                          log: logging.Logger = None) -> bool:
+    """Add an entry to bad_streaming_matches at block_level='track'.
+
+    Tells the matcher to never re-link this Spotify track to recordings
+    of `song_id`. The matcher consults this list via
+    get_blocked_tracks_for_song on every track-match attempt, so the
+    block survives all subsequent rematch / refresh / sweep cycles.
+
+    Used by the admin "Reject" action — call this in the same transaction
+    as the streaming-link delete so a wrong link gets both removed AND
+    blocklisted in one shot.
+
+    Returns True when a new row was inserted, False when an equivalent
+    block already existed (the unique constraint
+    bad_streaming_matches_unique collapses duplicates).
+    """
+    log = log or logger
+    with conn.cursor() as cur:
+        # Column-list ON CONFLICT instead of constraint-name ON CONFLICT —
+        # the constraint is named in the migration file but anonymous in
+        # sql/jazz-db-schema.sql, so test environments bootstrapped from
+        # the schema file don't have the named constraint to reference.
+        # The column list matches both definitions.
+        cur.execute(
+            """
+            INSERT INTO bad_streaming_matches
+                (service, block_level, service_id, song_id, reason)
+            VALUES (%s, 'track', %s, %s, %s)
+            ON CONFLICT (service, block_level, service_id, song_id)
+            DO NOTHING
+            RETURNING id
+            """,
+            (service, track_id, song_id, reason),
+        )
+        new_row = cur.fetchone()
+    if new_row:
+        log.info(
+            "Blocked %s track %s for song %s (reason=%r)",
+            service, track_id, song_id, reason,
+        )
+        return True
+    log.debug(
+        "%s track %s already blocked for song %s — no-op",
+        service, track_id, song_id,
+    )
+    return False
+
+
 def is_album_manual_override(conn, release_id: str, service: str = 'spotify') -> bool:
     """
     Check if an existing album link is a manual override that should be preserved.
diff --git a/backend/routes/admin.py b/backend/routes/admin.py
@@ -25,6 +25,7 @@
 from integrations.musicbrainz.performer_importer import PerformerImporter
 from integrations.musicbrainz.utils import MusicBrainzSearcher
 from integrations.spotify.db import (
+    block_streaming_track,
     is_track_manual_override,
     set_track_link_manual_override,
 )
@@ -3041,6 +3042,86 @@ def duration_mismatches_verify_link(link_id):
     })
 
 
+@admin_bp.route('/duration-mismatches/links/<link_id>/reject', methods=['POST'])
+def duration_mismatches_reject_link(link_id):
+    """Block + delete a wrong Spotify streaming link.
+
+    Two-step operation in a single transaction:
+
+      1. Insert into bad_streaming_matches at block_level='track', so the
+         matcher's get_blocked_tracks_for_song lookup will skip this
+         (song_id, spotify_track_id) pair on every future match attempt.
+      2. Delete the streaming link itself. The page reloads to confirm.
+
+    Idempotent against repeated invocations: the bad_streaming_matches
+    unique constraint collapses duplicate blocks, and the DELETE
+    no-ops on a missing link.
+
+    Body: optional JSON {"reason": "..."} captured into bad_streaming_matches.reason
+    for human review. The default is "rejected via admin UI".
+    """
+    data = request.get_json(silent=True) or {}
+    reason = (data.get('reason') or 'rejected via admin UI').strip()
+
+    try:
+        with get_db_connection() as db:
+            with db.cursor() as cur:
+                # Pull (song_id, service_id) from the link we're about to nuke.
+                # Going through recording_releases → recordings → songs.id is
+                # the only reachable path; rrsl itself has no song_id.
+                cur.execute(
+                    """
+                    SELECT rec.song_id AS song_id, rrsl.service_id AS spotify_track_id
+                    FROM recording_release_streaming_links rrsl
+                    JOIN recording_releases rr ON rr.id = rrsl.recording_release_id
+                    JOIN recordings rec ON rec.id = rr.recording_id
+                    WHERE rrsl.id = %s
+                      AND rrsl.service = 'spotify'
+                    """,
+                    (link_id,),
+                )
+                row = cur.fetchone()
+            if not row:
+                return jsonify({'error': 'Streaming link not found'}), 404
+            song_id = str(row['song_id'])
+            spotify_track_id = row['spotify_track_id']
+
+            # Step 1 — block the (song, track) pair so the matcher skips it.
+            # Skipped silently if there's no service_id to block (defensive;
+            # in practice every spotify link has one).
+            if spotify_track_id:
+                block_streaming_track(
+                    db, song_id, spotify_track_id,
+                    service='spotify', reason=reason, log=logger,
+                )
+
+            # Step 2 — delete the link itself.
+            with db.cursor() as cur:
+                cur.execute(
+                    """
+                    DELETE FROM recording_release_streaming_links
+                    WHERE id = %s AND service = 'spotify'
+                    RETURNING id
+                    """,
+                    (link_id,),
+                )
+                deleted = cur.fetchone()
+
+            db.commit()
+    except Exception as e:
+        logger.error(f"Error rejecting link {link_id}: {e}")
+        return jsonify({'error': str(e)}), 500
+
+    return jsonify({
+        'success': True,
+        'link_id': link_id,
+        'song_id': song_id,
+        'spotify_track_id': spotify_track_id,
+        'deleted': bool(deleted),
+        'blocked': bool(spotify_track_id),
+    })
+
+
 @admin_bp.route('/users')
 def users_list():
     """List user accounts with email search and pagination."""
diff --git a/backend/templates/admin/duration_mismatches_review.html b/backend/templates/admin/duration_mismatches_review.html
@@ -329,6 +329,29 @@
             cursor: wait;
         }
 
+        /* Destructive sibling to the Verify button — deletes the link AND
+           writes to bad_streaming_matches so the matcher won't re-link.
+           Uses a deliberately distinct red so admins don't fat-finger it. */
+        .reject-btn {
+            font-family: inherit;
+            font-size: 11px;
+            padding: 3px 10px;
+            margin-left: 4px;
+            border: 1px solid #b73d3d;
+            background: #fff;
+            color: #b73d3d;
+            border-radius: 4px;
+            cursor: pointer;
+            line-height: 1.3;
+        }
+        .reject-btn:hover {
+            background: #fbeaea;
+        }
+        .reject-btn:disabled {
+            opacity: 0.5;
+            cursor: wait;
+        }
+
         /* When the row is verified-and-shown (?include_verified=1), tone
            it down so it visually recedes from the still-actionable rows. */
         tr.verified-row {
@@ -614,6 +637,10 @@ <h1>Duration Mismatches</h1>
                                         data-action="verify"
                                         onclick="toggleVerify(this)"
                                         title="Mark this match as manually verified — matcher will leave it alone on rematch">Verify</button>
+                                <button type="button" class="reject-btn"
+                                        data-link-id="{{ link.streaming_link_id }}"
+                                        onclick="rejectLink(this)"
+                                        title="Wrong match — delete this link AND blocklist this Spotify track for this song so the matcher never re-links it">Reject</button>
                                 {% endif %}
                             </td>
                         </tr>
@@ -687,6 +714,50 @@ <h2>No mismatches found</h2>
             }
         }
 
+        async function rejectLink(btn) {
+            // Destructive: delete the link AND blocklist the Spotify track
+            // for this song. Confirm before firing because there's no
+            // single-click undo (admin can manually remove the
+            // bad_streaming_matches row, but that's a DB op).
+            if (!confirm(
+                'Reject this match?\n\n' +
+                '- The Spotify link will be deleted.\n' +
+                '- The Spotify track will be added to the blocklist for ' +
+                'this song so the matcher never re-links it.\n\n' +
+                'This is permanent until you remove the blocklist entry ' +
+                'manually.'
+            )) {
+                return;
+            }
+            const linkId = btn.dataset.linkId;
+            btn.disabled = true;
+            try {
+                const resp = await fetch(
+                    `/admin/duration-mismatches/links/${linkId}/reject`,
+                    {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Accept': 'application/json',
+                        },
+                        body: JSON.stringify({}),
+                    }
+                );
+                const data = await resp.json();
+                if (!resp.ok || !data.success) {
+                    throw new Error(data.error || ('HTTP ' + resp.status));
+                }
+                showToast(
+                    'Match rejected and Spotify track blocklisted',
+                    'success',
+                );
+                setTimeout(() => window.location.reload(), 500);
+            } catch (err) {
+                btn.disabled = false;
+                showToast('Failed: ' + err.message, 'error');
+            }
+        }
+
         // Enter key in threshold input
         document.getElementById('thresholdInput').addEventListener('keydown', function(e) {
             if (e.key === 'Enter') updateThreshold();
diff --git a/backend/tests/test_admin_verify_match.py b/backend/tests/test_admin_verify_match.py
