140 lines
5.2 KiB
Python
140 lines
5.2 KiB
Python
import base64
|
|
from datetime import datetime, timezone
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Query
|
|
from sqlalchemy import func, or_, select
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.core.auth_dependency import require_session
|
|
from app.db import get_db
|
|
from app.models.channel import Channel
|
|
from app.models.channel_category import channel_categories
|
|
from app.models.download_job import DownloadJob
|
|
from app.models.video import Video
|
|
from app.services.download_jobs import latest_jobs_map
|
|
from app.services.video_presentation import channel_categories_map, serialize_video
|
|
|
|
router = APIRouter(dependencies=[Depends(require_session)])
|
|
|
|
DEFAULT_LIMIT = 30
|
|
MAX_LIMIT = 100
|
|
|
|
|
|
def _encode_cursor(published_at: datetime, video_id: int) -> str:
|
|
raw = f"{published_at.isoformat()}|{video_id}"
|
|
return base64.urlsafe_b64encode(raw.encode()).decode()
|
|
|
|
|
|
def _decode_cursor(cursor: str) -> tuple[datetime, int]:
|
|
try:
|
|
raw = base64.urlsafe_b64decode(cursor.encode()).decode()
|
|
published_at_raw, video_id_raw = raw.rsplit("|", 1)
|
|
published_at = datetime.fromisoformat(published_at_raw)
|
|
if published_at.tzinfo is None:
|
|
published_at = published_at.replace(tzinfo=timezone.utc)
|
|
return published_at, int(video_id_raw)
|
|
except Exception:
|
|
raise HTTPException(status_code=400, detail="Invalid cursor")
|
|
|
|
|
|
def _completed_video_ids():
|
|
# A video may have several download_jobs over time (retries,
|
|
# redownload after delete); only its most recent one counts.
|
|
latest_job_ids = select(func.max(DownloadJob.id)).group_by(DownloadJob.video_id)
|
|
return select(DownloadJob.video_id).where(
|
|
DownloadJob.id.in_(latest_job_ids), DownloadJob.status == "completed"
|
|
)
|
|
|
|
|
|
@router.get("/feed/saved-counts")
|
|
def get_saved_counts(db: Session = Depends(get_db)) -> dict:
|
|
"""Per-category counts of saved (downloaded) videos, for the Saved
|
|
page's sidebar -- distinct from /api/categories' channel_count."""
|
|
completed_video_ids = _completed_video_ids()
|
|
|
|
all_count = db.query(Video).filter(Video.id.in_(completed_video_ids)).count()
|
|
|
|
categorized_channel_ids = select(channel_categories.c.channel_id)
|
|
uncategorized_count = (
|
|
db.query(Video)
|
|
.filter(Video.id.in_(completed_video_ids), ~Video.channel_id.in_(categorized_channel_ids))
|
|
.count()
|
|
)
|
|
|
|
rows = (
|
|
db.query(channel_categories.c.category_id, func.count(func.distinct(Video.id)))
|
|
.join(Video, Video.channel_id == channel_categories.c.channel_id)
|
|
.filter(Video.id.in_(completed_video_ids))
|
|
.group_by(channel_categories.c.category_id)
|
|
.all()
|
|
)
|
|
categories = {str(category_id): count for category_id, count in rows}
|
|
|
|
return {"all": all_count, "uncategorized": uncategorized_count, "categories": categories}
|
|
|
|
|
|
@router.get("/feed")
|
|
def get_feed(
|
|
category_id: int | None = None,
|
|
uncategorized: bool = False,
|
|
channel_id: int | None = None,
|
|
downloaded: bool = False,
|
|
search: str | None = Query(None, max_length=200),
|
|
limit: int = Query(DEFAULT_LIMIT, ge=1, le=MAX_LIMIT),
|
|
cursor: str | None = None,
|
|
db: Session = Depends(get_db),
|
|
) -> dict:
|
|
query = db.query(Video)
|
|
|
|
if channel_id is not None:
|
|
query = query.filter(Video.channel_id == channel_id)
|
|
elif uncategorized:
|
|
categorized_channel_ids = select(channel_categories.c.channel_id)
|
|
query = query.filter(~Video.channel_id.in_(categorized_channel_ids))
|
|
elif category_id is not None:
|
|
channel_ids_in_category = select(channel_categories.c.channel_id).where(
|
|
channel_categories.c.category_id == category_id
|
|
)
|
|
query = query.filter(Video.channel_id.in_(channel_ids_in_category))
|
|
|
|
if downloaded:
|
|
query = query.filter(Video.id.in_(_completed_video_ids()))
|
|
|
|
if search and search.strip():
|
|
escaped = search.strip().replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
|
|
needle = f"%{escaped}%"
|
|
query = query.join(Channel, Channel.id == Video.channel_id).filter(
|
|
or_(Video.title.ilike(needle, escape="\\"), Channel.title.ilike(needle, escape="\\"))
|
|
)
|
|
|
|
if cursor:
|
|
cursor_published_at, cursor_id = _decode_cursor(cursor)
|
|
query = query.filter(
|
|
(Video.published_at < cursor_published_at)
|
|
| ((Video.published_at == cursor_published_at) & (Video.id < cursor_id))
|
|
)
|
|
|
|
query = query.order_by(Video.published_at.desc(), Video.id.desc())
|
|
rows = query.limit(limit + 1).all()
|
|
|
|
next_cursor = None
|
|
if len(rows) > limit:
|
|
last_kept = rows[limit - 1]
|
|
next_cursor = _encode_cursor(last_kept.published_at, last_kept.id)
|
|
rows = rows[:limit]
|
|
|
|
channel_ids = list({v.channel_id for v in rows})
|
|
channels = {c.id: c for c in db.query(Channel).filter(Channel.id.in_(channel_ids)).all()}
|
|
categories_map = channel_categories_map(db, channel_ids)
|
|
jobs_map = latest_jobs_map(db, [v.id for v in rows])
|
|
|
|
items = []
|
|
for video in rows:
|
|
channel = channels.get(video.channel_id)
|
|
if channel is None:
|
|
continue
|
|
items.append(
|
|
serialize_video(video, channel, categories_map.get(channel.id, []), jobs_map.get(video.id))
|
|
)
|
|
|
|
return {"items": items, "next_cursor": next_cursor}
|