FabledCurator/backend/app/api/downloads.py

"""FC-3c: GET /api/downloads (list) + GET /api/downloads/<id> (detail).

List view: keyset-paginated, newest first, optional filtering by
status/source/artist. Returns slim records.
Detail view: full DownloadEvent including the metadata JSONB.
"""

from datetime import datetime, timedelta, timezone

from quart import Blueprint, jsonify, request
from sqlalchemy import func, select

from ..extensions import get_session
from ..models import Artist, DownloadEvent, Source

downloads_bp = Blueprint("downloads", __name__, url_prefix="/api/downloads")

_ALLOWED_STATUSES = frozenset({"pending", "running", "ok", "error", "skipped"})


def _summary_from_metadata(metadata: dict | None) -> dict:
    metadata = metadata or {}
    run_stats = metadata.get("run_stats") or {}
    return {
        "downloaded": int(run_stats.get("downloaded_count", 0)),
        "skipped": int(run_stats.get("skipped_count", 0)),
        "quarantined": int(run_stats.get("quarantined_count", 0)),
        "duration_seconds": metadata.get("duration_seconds"),
        "error_type": metadata.get("error_type"),
    }


def _list_record(event: DownloadEvent, source: Source | None, artist: Artist | None) -> dict:
    return {
        "id": event.id,
        "source_id": event.source_id,
        "artist_name": artist.name if artist else None,
        "artist_slug": artist.slug if artist else None,
        "platform": source.platform if source else None,
        "status": event.status,
        "started_at": event.started_at.isoformat() if event.started_at else None,
        "finished_at": event.finished_at.isoformat() if event.finished_at else None,
        "files_count": event.files_count,
        "bytes_downloaded": event.bytes_downloaded,
        "error": event.error,
        "summary": _summary_from_metadata(event.metadata_),
    }


def _detail_record(event: DownloadEvent, source: Source | None, artist: Artist | None) -> dict:
    base = _list_record(event, source, artist)
    base["metadata"] = event.metadata_ or {}
    return base


@downloads_bp.route("", methods=["GET"])
async def list_downloads():
    status = request.args.get("status")
    if status and status not in _ALLOWED_STATUSES:
        return jsonify({"error": "invalid_status"}), 400
    try:
        limit = int(request.args.get("limit", "50"))
    except ValueError:
        return jsonify({"error": "invalid_limit"}), 400
    limit = max(1, min(200, limit))
    before_raw = request.args.get("before")
    before = None
    if before_raw is not None:
        try:
            before = int(before_raw)
        except ValueError:
            return jsonify({"error": "invalid_before"}), 400
    try:
        source_id = int(request.args["source_id"]) if "source_id" in request.args else None
        artist_id = int(request.args["artist_id"]) if "artist_id" in request.args else None
    except (ValueError, KeyError):
        return jsonify({"error": "invalid_filter"}), 400

    async with get_session() as session:
        stmt = (
            select(DownloadEvent, Source, Artist)
            .outerjoin(Source, Source.id == DownloadEvent.source_id)
            .outerjoin(Artist, Artist.id == Source.artist_id)
            .order_by(DownloadEvent.id.desc())
            .limit(limit)
        )
        if status:
            stmt = stmt.where(DownloadEvent.status == status)
        if source_id is not None:
            stmt = stmt.where(DownloadEvent.source_id == source_id)
        if artist_id is not None:
            stmt = stmt.where(Source.artist_id == artist_id)
        if before is not None:
            stmt = stmt.where(DownloadEvent.id < before)
        rows = (await session.execute(stmt)).all()

    return jsonify([_list_record(e, s, a) for e, s, a in rows])


@downloads_bp.route("/stats", methods=["GET"])
async def downloads_stats():
    """Status-grouped count over download_event for the dashboard stat chips.

    `?window_hours=` (default 24) bounds by `started_at`. The full set of
    statuses is always present in the response (zero for missing) so the
    UI doesn't have to fill in defaults.
    """
    try:
        window_hours = int(request.args.get("window_hours", "24"))
    except ValueError:
        return jsonify({"error": "invalid_window_hours"}), 400
    if window_hours < 1 or window_hours > 24 * 365:
        return jsonify({"error": "invalid_window_hours"}), 400

    since = datetime.now(timezone.utc) - timedelta(hours=window_hours)
    out = {"pending": 0, "running": 0, "ok": 0, "error": 0, "skipped": 0}
    async with get_session() as session:
        stmt = (
            select(DownloadEvent.status, func.count())
            .where(DownloadEvent.started_at >= since)
            .group_by(DownloadEvent.status)
        )
        for status, n in (await session.execute(stmt)).all():
            if status in out:
                out[status] = int(n)
    return jsonify(out)


@downloads_bp.route("/<int:event_id>", methods=["GET"])
async def get_download(event_id: int):
    async with get_session() as session:
        row = (await session.execute(
            select(DownloadEvent, Source, Artist)
            .outerjoin(Source, Source.id == DownloadEvent.source_id)
            .outerjoin(Artist, Artist.id == Source.artist_id)
            .where(DownloadEvent.id == event_id)
        )).first()
        if row is None:
            return jsonify({"error": "not_found"}), 404
        event, source, artist = row
    return jsonify(_detail_record(event, source, artist))