200 lines
6.4 KiB
Python
200 lines
6.4 KiB
Python
"""/articles 列表与详情。"""
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import json
|
|
from datetime import datetime
|
|
from typing import Annotated
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
|
from sqlalchemy import and_, desc, func, or_, select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.core.deps import get_current_user
|
|
from app.database import get_session
|
|
from app.models.article import Article
|
|
from app.models.bookmark import Bookmark
|
|
from app.models.source import Source
|
|
from app.models.user import User
|
|
from app.schemas.article import (
|
|
ArticleDetail,
|
|
ArticleListItem,
|
|
ArticleListResponse,
|
|
SourceBrief,
|
|
)
|
|
|
|
router = APIRouter(prefix="/articles", tags=["articles"])
|
|
|
|
|
|
def _encode_cursor(article: Article) -> str:
|
|
payload = {"id": article.id, "ts": int(article.fetched_at.timestamp())}
|
|
return base64.urlsafe_b64encode(json.dumps(payload).encode()).decode()
|
|
|
|
|
|
def _decode_cursor(cur: str) -> tuple[int, datetime]:
|
|
try:
|
|
data = json.loads(base64.urlsafe_b64decode(cur.encode()).decode())
|
|
return int(data["id"]), datetime.fromtimestamp(int(data["ts"]))
|
|
except Exception:
|
|
raise HTTPException(status.HTTP_400_BAD_REQUEST, "Invalid cursor")
|
|
|
|
|
|
@router.get("", response_model=ArticleListResponse)
|
|
async def list_articles(
|
|
since: datetime | None = Query(default=None, description="起时间 UTC"),
|
|
until: datetime | None = Query(default=None, description="止时间 UTC"),
|
|
source: str | None = Query(default=None, description="逗号分隔 source slug"),
|
|
category: str | None = None,
|
|
q: str | None = Query(default=None, description="标题/正文搜索"),
|
|
lang: Annotated[str, Query(pattern=r"^(src|zh|both)$")] = "both",
|
|
limit: int = Query(default=50, ge=1, le=200),
|
|
cursor: str | None = None,
|
|
starred_only: bool = False,
|
|
user: User = Depends(get_current_user),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
stmt = (
|
|
select(Article, Source)
|
|
.join(Source, Source.id == Article.source_id)
|
|
.where(Article.duplicate_of.is_(None))
|
|
)
|
|
|
|
# 默认过去 24h
|
|
if since is None and until is None and cursor is None:
|
|
since = _default_since_24h()
|
|
|
|
if since:
|
|
stmt = stmt.where(Article.published_at >= since)
|
|
if until:
|
|
stmt = stmt.where(Article.published_at <= until)
|
|
if category:
|
|
stmt = stmt.where(Article.category == category)
|
|
|
|
if source:
|
|
slugs = [s.strip() for s in source.split(",") if s.strip()]
|
|
if slugs:
|
|
stmt = stmt.where(Source.slug.in_(slugs))
|
|
|
|
if q:
|
|
like = f"%{q}%"
|
|
stmt = stmt.where(or_(Article.title.ilike(like), Article.body_text.ilike(like)))
|
|
|
|
# 语言过滤
|
|
if lang == "zh":
|
|
stmt = stmt.where(Article.title_zh.is_not(None))
|
|
elif lang == "src":
|
|
# 只要原文已有
|
|
pass
|
|
|
|
if cursor:
|
|
last_id, _ = _decode_cursor(cursor)
|
|
stmt = stmt.where(Article.id < last_id)
|
|
|
|
if starred_only:
|
|
stmt = stmt.join(Bookmark, and_(Bookmark.article_id == Article.id, Bookmark.user_id == user.id))
|
|
|
|
stmt = stmt.order_by(desc(Article.published_at), desc(Article.id)).limit(limit + 1)
|
|
|
|
result = await session.execute(stmt)
|
|
rows = result.all()
|
|
has_more = len(rows) > limit
|
|
rows = rows[:limit]
|
|
|
|
# 标记 is_starred(批量)
|
|
ids = [a.id for a, _ in rows]
|
|
starred_ids: set[int] = set()
|
|
if ids:
|
|
bm_rows = (
|
|
await session.execute(
|
|
select(Bookmark.article_id).where(
|
|
Bookmark.user_id == user.id, Bookmark.article_id.in_(ids)
|
|
)
|
|
)
|
|
).all()
|
|
starred_ids = {b[0] for b in bm_rows}
|
|
|
|
items = []
|
|
for art, src in rows:
|
|
item = ArticleListItem(
|
|
id=art.id,
|
|
source=SourceBrief.model_validate(src),
|
|
title=art.title,
|
|
title_zh=art.title_zh,
|
|
summary_zh=art.summary_zh,
|
|
lang_src=art.lang_src,
|
|
translation_status=art.translation_status,
|
|
category=art.category,
|
|
published_at=art.published_at,
|
|
fetched_at=art.fetched_at,
|
|
image_url=art.image_url,
|
|
is_starred=art.id in starred_ids,
|
|
)
|
|
items.append(item)
|
|
|
|
next_cursor = _encode_cursor(rows[-1][0]) if has_more and rows else None
|
|
return ArticleListResponse(items=items, next_cursor=next_cursor, total=None)
|
|
|
|
|
|
@router.get("/{article_id}", response_model=ArticleDetail)
|
|
async def get_article(
|
|
article_id: int,
|
|
user: User = Depends(get_current_user),
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
result = await session.execute(
|
|
select(Article, Source)
|
|
.join(Source, Source.id == Article.source_id)
|
|
.where(Article.id == article_id)
|
|
)
|
|
art = result.first()
|
|
if not art:
|
|
raise HTTPException(status.HTTP_404_NOT_FOUND, "Article not found")
|
|
article, source = art
|
|
|
|
is_starred = (
|
|
await session.execute(
|
|
select(Bookmark.id).where(
|
|
Bookmark.user_id == user.id, Bookmark.article_id == article.id
|
|
)
|
|
)
|
|
).first() is not None
|
|
|
|
return ArticleDetail(
|
|
id=article.id,
|
|
source=SourceBrief.model_validate(source),
|
|
url=article.url,
|
|
title=article.title,
|
|
body_html=article.body_html,
|
|
body_text=article.body_text,
|
|
title_zh=article.title_zh,
|
|
body_zh_html=article.body_zh_html,
|
|
body_zh_text=article.body_zh_text,
|
|
body_zh_formatted=article.body_zh_formatted,
|
|
summary_zh=article.summary_zh,
|
|
lang_src=article.lang_src,
|
|
author=article.author,
|
|
image_url=article.image_url,
|
|
image_ai_url=article.image_ai_url,
|
|
translation_status=article.translation_status,
|
|
translation_engine=article.translation_engine,
|
|
translated_at=article.translated_at,
|
|
category=article.category,
|
|
format_status=article.format_status,
|
|
classify_status=article.classify_status,
|
|
image_ai_status=article.image_ai_status,
|
|
commentary_status=article.commentary_status,
|
|
commentary=article.commentary,
|
|
entities=article.entities,
|
|
sentiment=article.sentiment,
|
|
duplicate_of=article.duplicate_of,
|
|
published_at=article.published_at,
|
|
fetched_at=article.fetched_at,
|
|
is_starred=is_starred,
|
|
)
|
|
|
|
|
|
def _default_since_24h() -> datetime:
|
|
from datetime import timedelta
|
|
|
|
return datetime.utcnow() - timedelta(hours=24)
|