Files

208 lines
7.2 KiB
Python
Raw Permalink Normal View History

2026-11-16 20:45:22 +08:00
from __future__ import annotations
from fastapi import APIRouter, HTTPException, Query, status
from sqlalchemy import select
from sakura_cloud.api.deps import CurrentUser, DbSession
from sakura_cloud.models.follow import CreatorFollow, UpdateAlert
from sakura_cloud.models.mixins import utc_now
from sakura_cloud.schemas.common import ApiResponse
from sakura_cloud.schemas.follow import (
CreatorFollowBulkUpsert,
CreatorFollowBulkUpsertResult,
CreatorFollowOut,
CreatorFollowUpsert,
UpdateAlertCreate,
UpdateAlertOut,
UpdateAlertReadUpdate,
)
from sakura_cloud.services.push import send_update_alert_push
router = APIRouter()
@router.get("", response_model=ApiResponse[list[CreatorFollowOut]])
def list_follows(
current_user: CurrentUser,
db: DbSession,
platform: str | None = Query(default=None),
enabled: bool | None = Query(default=None),
) -> ApiResponse[list[CreatorFollowOut]]:
query = select(CreatorFollow).where(CreatorFollow.user_id == current_user.id)
if platform:
query = query.where(CreatorFollow.platform == platform)
if enabled is not None:
query = query.where(CreatorFollow.enabled == enabled)
rows = db.scalars(query.order_by(CreatorFollow.updated_at.desc())).all()
return ApiResponse(data=[CreatorFollowOut.from_row(row) for row in rows])
@router.post("", response_model=ApiResponse[CreatorFollowOut], status_code=status.HTTP_201_CREATED)
def upsert_follow(
payload: CreatorFollowUpsert,
current_user: CurrentUser,
db: DbSession,
) -> ApiResponse[CreatorFollowOut]:
row, _created = _upsert_follow_row(payload, current_user.id, db)
db.commit()
db.refresh(row)
return ApiResponse(code=201, message="created", data=CreatorFollowOut.from_row(row))
@router.post("/bulk-upsert", response_model=ApiResponse[CreatorFollowBulkUpsertResult])
def bulk_upsert_follows(
payload: CreatorFollowBulkUpsert,
current_user: CurrentUser,
db: DbSession,
) -> ApiResponse[CreatorFollowBulkUpsertResult]:
created = 0
updated = 0
skipped = 0
rows: list[CreatorFollow] = []
seen: set[tuple[str, str]] = set()
for item in payload.items:
key = (item.platform.strip(), item.creator_id.strip())
if not key[0] or not key[1] or key in seen:
skipped += 1
continue
seen.add(key)
row, was_created = _upsert_follow_row(item, current_user.id, db)
rows.append(row)
if was_created:
created += 1
else:
updated += 1
db.commit()
for row in rows:
db.refresh(row)
return ApiResponse(
data=CreatorFollowBulkUpsertResult(
created=created,
updated=updated,
skipped=skipped,
items=[CreatorFollowOut.from_row(row) for row in rows],
)
)
def _upsert_follow_row(
payload: CreatorFollowUpsert,
user_id: str,
db: DbSession,
) -> tuple[CreatorFollow, bool]:
row = db.scalar(
select(CreatorFollow).where(
CreatorFollow.user_id == user_id,
CreatorFollow.platform == payload.platform,
CreatorFollow.creator_id == payload.creator_id,
)
)
created = row is None
if row is None:
row = CreatorFollow(
user_id=user_id,
platform=payload.platform,
creator_id=payload.creator_id,
)
db.add(row)
row.creator_name = payload.creator_name
row.creator_handle = payload.creator_handle
row.profile_url = payload.profile_url
row.avatar_url = payload.avatar_url
row.enabled = payload.enabled
row.latest_published_at = payload.latest_published_at
row.metadata_json = payload.metadata
row.last_checked_at = payload.last_checked_at or utc_now()
return row, created
@router.delete("/{follow_id}", response_model=ApiResponse[dict[str, bool]])
def disable_follow(follow_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, bool]]:
row = db.get(CreatorFollow, follow_id)
if row is None or row.user_id != current_user.id:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Follow not found")
row.enabled = False
row.last_checked_at = utc_now()
db.commit()
return ApiResponse(data={"ok": True})
@router.get("/alerts", response_model=ApiResponse[list[UpdateAlertOut]])
def list_alerts(
current_user: CurrentUser,
db: DbSession,
unread_only: bool = Query(default=False),
limit: int = Query(default=50, ge=1, le=200),
) -> ApiResponse[list[UpdateAlertOut]]:
query = select(UpdateAlert).where(UpdateAlert.user_id == current_user.id)
if unread_only:
query = query.where(UpdateAlert.is_read == False)
rows = db.scalars(query.order_by(UpdateAlert.created_at.desc()).limit(limit)).all()
return ApiResponse(data=[UpdateAlertOut.model_validate(row) for row in rows])
@router.post("/alerts", response_model=ApiResponse[UpdateAlertOut], status_code=status.HTTP_201_CREATED)
def create_alert(
payload: UpdateAlertCreate,
current_user: CurrentUser,
db: DbSession,
) -> ApiResponse[UpdateAlertOut]:
follow = db.scalar(
select(CreatorFollow).where(
CreatorFollow.user_id == current_user.id,
CreatorFollow.platform == payload.platform,
CreatorFollow.creator_id == payload.creator_id,
)
)
existing = db.scalar(
select(UpdateAlert).where(
UpdateAlert.user_id == current_user.id,
UpdateAlert.platform == payload.platform,
UpdateAlert.creator_id == payload.creator_id,
UpdateAlert.title == payload.title,
UpdateAlert.target_url == payload.target_url,
)
)
if existing is not None:
if existing.follow_id is None and follow is not None:
existing.follow_id = follow.id
db.commit()
db.refresh(existing)
return ApiResponse(code=200, message="exists", data=UpdateAlertOut.model_validate(existing))
row = UpdateAlert(
user_id=current_user.id,
follow_id=follow.id if follow else None,
platform=payload.platform,
creator_id=payload.creator_id,
title=payload.title,
body=payload.body,
content_type=payload.content_type,
target_url=payload.target_url,
cover_url=payload.cover_url,
payload_json=payload.payload,
)
if payload.created_at is not None:
row.created_at = payload.created_at
row.updated_at = payload.created_at
db.add(row)
db.commit()
db.refresh(row)
send_update_alert_push(db, row)
return ApiResponse(code=201, message="created", data=UpdateAlertOut.model_validate(row))
@router.post("/alerts/{alert_id}/read", response_model=ApiResponse[UpdateAlertOut])
def mark_alert_read(
alert_id: str,
payload: UpdateAlertReadUpdate,
current_user: CurrentUser,
db: DbSession,
) -> ApiResponse[UpdateAlertOut]:
row = db.get(UpdateAlert, alert_id)
if row is None or row.user_id != current_user.id:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Alert not found")
row.is_read = payload.is_read
db.commit()
db.refresh(row)
return ApiResponse(data=UpdateAlertOut.model_validate(row))