andrew
270c9c0ed1
library_edit.update_track_fields: single-track tag edits via `beet modify -y -m` (subprocess with an argument list, not beets.library.Library in-process -- an arg-list subprocess has no shell-injection surface to avoid in the first place, and correctly reuses beets' own configured path-format/move logic rather than reimplementing it against a hand-built Library object with guessed config). Every changed field gets a manual_fix_audit row with old/new values; triggers a Navidrome rescan afterward if anything changed. Uses "genres" (plural) as the field name, matching this deployment's actual beets column and every existing script's convention, not the generic beets docs' singular "genre". genre_fix.set_artist_genre and retag.retag_from_url wrap the existing fix-genre.sh and fix-track-metadata.py as callable services rather than reimplementing their per-format mutagen tag-writing logic. manual_import: ties pipeline_runner.run_import_track to the manual_imports table, mirrors import-track.sh's own argument-count-based disambiguation (0/1/2 args), plus import-me/ listing and upload-with-path-traversal-guard. routers/library.py + routers/import_.py: browsable library list, a track detail/edit page (tag edit, artist-wide genre override, retag-from-URL forms), and the import page (upload + trigger). Minimal templates for now, Task 9 covers full UI polish. Verified update_track_fields end-to-end against a REAL beets library (not mocked): generated a tagged FLAC with ffmpeg/metaflac, imported it via a real `beet import`, edited artist+title through the service, and confirmed the file was physically moved to the new path-template location, tags were rewritten on disk, the DB updated, and both changes landed correctly in manual_fix_audit. Also verified the full app boots with the new routers registered and all four new routes correctly redirect to login when unauthenticated.
90 lines
3.5 KiB
Python
90 lines
3.5 KiB
Python
import asyncio
|
|
import subprocess
|
|
import time
|
|
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.models import ManualFixAudit
|
|
from app.services import beets_service, pipeline_runner
|
|
|
|
# "genres" (plural) matches this deployment's actual beets DB column and
|
|
# every existing script's `beet ls -f '$genres'` convention -- not the
|
|
# generic beets docs' singular "genre".
|
|
EDITABLE_FIELDS = ["artist", "title", "album", "albumartist", "genres", "grouping", "track", "year"]
|
|
|
|
|
|
def _run_beet_modify(item_id: int, changes: dict[str, str]) -> subprocess.CompletedProcess:
|
|
"""subprocess with an argument list (no shell=True) -- user-submitted
|
|
field values never pass through a shell, so there's no injection risk
|
|
to escape against. This also reuses beets' own configured path-format/
|
|
move logic exactly as the `beet` CLI does, rather than reimplementing
|
|
it against a hand-built beets.library.Library object with guessed
|
|
config values (directory/path_formats aren't reliably knowable from
|
|
here during the migration's transitional beets-mount period)."""
|
|
field_args = [f"{field}={value}" for field, value in changes.items()]
|
|
return subprocess.run(
|
|
["beet", "modify", "-y", "-m", f"id:{item_id}"] + field_args,
|
|
capture_output=True,
|
|
text=True,
|
|
)
|
|
|
|
|
|
async def update_track_fields(
|
|
db: Session, item_id: int, changes: dict[str, str], changed_by: str
|
|
) -> list[str]:
|
|
"""Apply one or more field edits to a single beets item via `beet
|
|
modify -y -m` (writes tags to the file, updates the DB, and moves the
|
|
file if the new fields change its path template -- all three in one
|
|
beets-native operation).
|
|
|
|
Every field that actually changed value gets one manual_fix_audit row
|
|
with old/new values. Triggers a (share-health-gated) Navidrome rescan
|
|
afterward if anything changed, so the edit shows up without waiting for
|
|
the next scheduled scan.
|
|
|
|
Returns the list of field names that were actually different after the
|
|
edit (a value re-submitted unchanged doesn't generate an audit row).
|
|
"""
|
|
unknown = set(changes) - set(EDITABLE_FIELDS)
|
|
if unknown:
|
|
raise ValueError(f"not editable: {unknown}")
|
|
if not changes:
|
|
return []
|
|
|
|
before = beets_service.get_item(item_id)
|
|
if before is None:
|
|
raise ValueError(f"no beets item with id={item_id}")
|
|
|
|
result = await asyncio.to_thread(_run_beet_modify, item_id, changes)
|
|
if result.returncode != 0:
|
|
raise RuntimeError(f"beet modify failed: {result.stderr.strip()}")
|
|
|
|
after = beets_service.get_item(item_id) or {}
|
|
changed_fields = []
|
|
now = time.time()
|
|
for field in changes:
|
|
old_value = before.get(field)
|
|
new_value = after.get(field, changes[field])
|
|
if old_value != new_value:
|
|
db.add(
|
|
ManualFixAudit(
|
|
beets_item_id=item_id,
|
|
file_path=after.get("path", before.get("path", "")),
|
|
field=field,
|
|
old_value=str(old_value) if old_value is not None else None,
|
|
new_value=str(new_value) if new_value is not None else None,
|
|
changed_by=changed_by,
|
|
changed_at=now,
|
|
source="tag_edit",
|
|
)
|
|
)
|
|
changed_fields.append(field)
|
|
db.commit()
|
|
|
|
if changed_fields:
|
|
await pipeline_runner.run_lib_script(
|
|
"manual:navidrome_scan_after_edit", "navidrome-scan.sh", triggered_by="manual"
|
|
)
|
|
|
|
return changed_fields
|