commit
9c5fef1a4d
412 files changed
+94582
No files matched your search
@@ -0,0 +1 @@
|
||||
"""Versioned API routes."""
|
||||
@@ -0,0 +1 @@
|
||||
"""API endpoint modules."""
|
||||
@@ -0,0 +1,659 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
import time
|
||||
from collections import defaultdict, deque
|
||||
from pathlib import Path
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Query, Request, status
|
||||
from sqlalchemy import func, or_, select, text
|
||||
|
||||
from sakura_cloud.api.deps import AdminUser, DbSession, SuperAdminUser
|
||||
from sakura_cloud.core.config import settings
|
||||
from sakura_cloud.core.security import create_access_token, create_refresh_token, hash_password, verify_password
|
||||
from sakura_cloud.models.admin import AdminAuditLog
|
||||
from sakura_cloud.models.artwork import Artwork
|
||||
from sakura_cloud.models.file import FileBlob, UploadSession, UserFile
|
||||
from sakura_cloud.models.follow import CreatorFollow, UpdateAlert
|
||||
from sakura_cloud.models.novel import Novel
|
||||
from sakura_cloud.models.ocr import ArtworkOcrText
|
||||
from sakura_cloud.models.push import PushDeviceToken
|
||||
from sakura_cloud.models.user import User, UserRole
|
||||
from sakura_cloud.models.mixins import utc_now
|
||||
from sakura_cloud.schemas.admin import (
|
||||
AdminAlertStatOut,
|
||||
AdminAlertOut,
|
||||
AdminAuditLogOut,
|
||||
AdminArtworkOut,
|
||||
AdminFileOut,
|
||||
AdminFileStatOut,
|
||||
AdminHealthOut,
|
||||
AdminListResponse,
|
||||
AdminLogLineOut,
|
||||
AdminLoginRequest,
|
||||
AdminMigrationOut,
|
||||
AdminNovelOut,
|
||||
AdminOcrTaskOut,
|
||||
AdminPage,
|
||||
AdminPushDeviceOut,
|
||||
AdminStatsOut,
|
||||
AdminTaskOut,
|
||||
AdminUserOut,
|
||||
AdminUserStatusUpdate,
|
||||
AdminUserRoleUpdate,
|
||||
AdminUserPasswordReset,
|
||||
)
|
||||
from sakura_cloud.schemas.auth import TokenPair
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
from sakura_cloud.services.audit import write_admin_audit_log
|
||||
from sakura_cloud.services.ocr import run_ocr_for_artwork
|
||||
from sakura_cloud.services.push import send_push_to_user
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
_login_attempts: dict[str, deque[float]] = defaultdict(deque)
|
||||
|
||||
|
||||
@router.post("/login", response_model=ApiResponse[TokenPair])
|
||||
def admin_login(payload: AdminLoginRequest, request: Request, db: DbSession) -> ApiResponse[TokenPair]:
|
||||
_check_login_rate_limit(request)
|
||||
login_id = payload.username_or_email.strip()
|
||||
user = db.scalar(
|
||||
select(User).where(
|
||||
or_(
|
||||
func.lower(User.username) == login_id.lower(),
|
||||
func.lower(User.email) == login_id.lower(),
|
||||
)
|
||||
)
|
||||
)
|
||||
if (
|
||||
user is None
|
||||
or user.role not in {UserRole.ADMIN, UserRole.SUPER_ADMIN}
|
||||
or not user.is_active
|
||||
or not verify_password(payload.password, user.password_hash)
|
||||
):
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid admin credentials")
|
||||
write_admin_audit_log(db, user, action="admin_login", target_type="user", target_id=user.id, request=request)
|
||||
return ApiResponse(
|
||||
data=TokenPair(
|
||||
access_token=create_access_token(user.id, user.token_version),
|
||||
refresh_token=create_refresh_token(user.id, user.token_version),
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
@router.get("/dashboard", response_model=ApiResponse[AdminStatsOut])
|
||||
def dashboard(_: AdminUser, db: DbSession) -> ApiResponse[AdminStatsOut]:
|
||||
storage_used = int(db.scalar(select(func.coalesce(func.sum(FileBlob.file_size), 0))) or 0)
|
||||
data = AdminStatsOut(
|
||||
users=_count(db, User),
|
||||
active_users=int(db.scalar(select(func.count()).select_from(User).where(User.is_active.is_(True))) or 0),
|
||||
artworks=_count(db, Artwork),
|
||||
novels=_count(db, Novel),
|
||||
files=_count(db, FileBlob),
|
||||
storage_used=storage_used,
|
||||
uploads_pending=int(db.scalar(select(func.count()).select_from(UploadSession).where(UploadSession.status != "completed")) or 0),
|
||||
ocr_pending=int(db.scalar(select(func.count()).select_from(ArtworkOcrText).where(ArtworkOcrText.status.in_(["pending", "running"]))) or 0),
|
||||
ocr_failed=int(db.scalar(select(func.count()).select_from(ArtworkOcrText).where(ArtworkOcrText.status == "failed")) or 0),
|
||||
push_devices=_count(db, PushDeviceToken),
|
||||
follows=_count(db, CreatorFollow),
|
||||
alerts=_count(db, UpdateAlert),
|
||||
)
|
||||
return ApiResponse(data=data)
|
||||
|
||||
|
||||
@router.get("/users", response_model=ApiResponse[AdminListResponse[AdminUserOut]])
|
||||
def list_users(
|
||||
_: AdminUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
q: str | None = Query(default=None, max_length=100),
|
||||
role: str | None = Query(default=None, pattern="^(user|admin|super_admin)$"),
|
||||
sort: str = Query(default="created_at", pattern="^(created_at|updated_at|username|storage_used)$"),
|
||||
order: str = Query(default="desc", pattern="^(asc|desc)$"),
|
||||
) -> ApiResponse[AdminListResponse[AdminUserOut]]:
|
||||
query = select(User)
|
||||
count_query = select(func.count()).select_from(User)
|
||||
filters = []
|
||||
if q:
|
||||
like = f"%{q.strip()}%"
|
||||
filters.append(or_(User.username.ilike(like), User.email.ilike(like)))
|
||||
if role:
|
||||
filters.append(User.role == _role_from_value(role))
|
||||
for item in filters:
|
||||
query = query.where(item)
|
||||
count_query = count_query.where(item)
|
||||
total = int(db.scalar(count_query) or 0)
|
||||
order_col = getattr(User, sort)
|
||||
if order == "desc":
|
||||
order_col = order_col.desc()
|
||||
rows = db.scalars(query.order_by(order_col).offset((page - 1) * limit).limit(limit)).all()
|
||||
return ApiResponse(data=_page([AdminUserOut.model_validate(row) for row in rows], page, limit, total))
|
||||
|
||||
|
||||
@router.get("/users/{user_id}", response_model=ApiResponse[AdminUserOut])
|
||||
def get_user(user_id: str, _: AdminUser, db: DbSession) -> ApiResponse[AdminUserOut]:
|
||||
user = db.get(User, user_id)
|
||||
if user is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
|
||||
return ApiResponse(data=AdminUserOut.model_validate(user))
|
||||
|
||||
|
||||
@router.patch("/users/{user_id}/status", response_model=ApiResponse[AdminUserOut])
|
||||
def set_user_status(
|
||||
user_id: str,
|
||||
payload: AdminUserStatusUpdate,
|
||||
request: Request,
|
||||
current_admin: AdminUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[AdminUserOut]:
|
||||
user = db.get(User, user_id)
|
||||
if user is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
|
||||
_ensure_can_operate_user(current_admin, user, desired_active=payload.is_active)
|
||||
user.is_active = payload.is_active
|
||||
user.disabled_at = None if payload.is_active else utc_now()
|
||||
user.disabled_reason = None if payload.is_active else payload.reason
|
||||
user.token_version += 1
|
||||
db.commit()
|
||||
db.refresh(user)
|
||||
write_admin_audit_log(
|
||||
db,
|
||||
current_admin,
|
||||
action="enable_user" if payload.is_active else "disable_user",
|
||||
target_type="user",
|
||||
target_id=user.id,
|
||||
request=request,
|
||||
detail={"is_active": payload.is_active, "reason": payload.reason},
|
||||
)
|
||||
return ApiResponse(data=AdminUserOut.model_validate(user))
|
||||
|
||||
|
||||
@router.patch("/users/{user_id}/role", response_model=ApiResponse[AdminUserOut])
|
||||
def set_user_role(
|
||||
user_id: str,
|
||||
payload: AdminUserRoleUpdate,
|
||||
request: Request,
|
||||
current_admin: SuperAdminUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[AdminUserOut]:
|
||||
user = db.get(User, user_id)
|
||||
if user is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
|
||||
new_role = _role_from_value(payload.role)
|
||||
if user.id == current_admin.id and new_role != UserRole.SUPER_ADMIN:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Cannot demote yourself")
|
||||
if new_role != UserRole.SUPER_ADMIN and user.role == UserRole.SUPER_ADMIN and _super_admin_count(db) <= 1:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="At least one super admin is required")
|
||||
user.role = new_role
|
||||
user.token_version += 1
|
||||
db.commit()
|
||||
db.refresh(user)
|
||||
write_admin_audit_log(db, current_admin, action="change_user_role", target_type="user", target_id=user.id, request=request, detail={"role": payload.role})
|
||||
return ApiResponse(data=AdminUserOut.model_validate(user))
|
||||
|
||||
|
||||
@router.post("/users/{user_id}/reset-password", response_model=ApiResponse[dict[str, bool]])
|
||||
def reset_user_password(
|
||||
user_id: str,
|
||||
payload: AdminUserPasswordReset,
|
||||
request: Request,
|
||||
current_admin: AdminUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[dict[str, bool]]:
|
||||
user = db.get(User, user_id)
|
||||
if user is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
|
||||
_ensure_can_operate_user(current_admin, user)
|
||||
user.password_hash = hash_password(payload.new_password)
|
||||
user.token_version += 1
|
||||
db.commit()
|
||||
write_admin_audit_log(db, current_admin, action="reset_user_password", target_type="user", target_id=user.id, request=request)
|
||||
return ApiResponse(data={"ok": True})
|
||||
|
||||
|
||||
@router.get("/users/{user_id}/files", response_model=ApiResponse[AdminListResponse[AdminFileOut]])
|
||||
def user_files(user_id: str, _: AdminUser, db: DbSession, page: int = Query(default=1, ge=1), limit: int = Query(default=30, ge=1, le=100)):
|
||||
if db.get(User, user_id) is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
|
||||
return _list_files(db, page=page, limit=limit, user_id=user_id)
|
||||
|
||||
|
||||
@router.get("/files/stats", response_model=ApiResponse[list[AdminFileStatOut]])
|
||||
def file_stats(_: AdminUser, db: DbSession) -> ApiResponse[list[AdminFileStatOut]]:
|
||||
rows = db.execute(
|
||||
select(FileBlob.mime_type, func.count(FileBlob.sha256), func.coalesce(func.sum(FileBlob.file_size), 0)).group_by(FileBlob.mime_type)
|
||||
).all()
|
||||
return ApiResponse(data=[AdminFileStatOut(mime_type=row[0], files=int(row[1]), bytes=int(row[2] or 0)) for row in rows])
|
||||
|
||||
|
||||
@router.get("/files", response_model=ApiResponse[AdminListResponse[AdminFileOut]])
|
||||
def list_files(
|
||||
_: AdminUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
user_id: str | None = Query(default=None, max_length=36),
|
||||
mime_type: str | None = Query(default=None, max_length=50),
|
||||
) -> ApiResponse[AdminListResponse[AdminFileOut]]:
|
||||
return _list_files(db, page=page, limit=limit, user_id=user_id, mime_type=mime_type)
|
||||
|
||||
|
||||
@router.delete("/files/{file_id}", response_model=ApiResponse[dict[str, bool]])
|
||||
def delete_file(file_id: str, request: Request, current_admin: AdminUser, db: DbSession) -> ApiResponse[dict[str, bool]]:
|
||||
row = db.get(UserFile, file_id)
|
||||
if row is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="File not found")
|
||||
db.delete(row)
|
||||
db.commit()
|
||||
write_admin_audit_log(db, current_admin, action="delete_file", target_type="file", target_id=file_id, request=request)
|
||||
return ApiResponse(data={"ok": True})
|
||||
|
||||
|
||||
@router.get("/gallery", response_model=ApiResponse[AdminListResponse[AdminArtworkOut]])
|
||||
def admin_gallery(
|
||||
_: AdminUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
user_id: str | None = Query(default=None, max_length=36),
|
||||
platform: str | None = Query(default=None, max_length=20),
|
||||
content_type: str | None = Query(default=None, max_length=20),
|
||||
q: str | None = Query(default=None, max_length=100),
|
||||
) -> ApiResponse[AdminListResponse[AdminArtworkOut]]:
|
||||
query = select(Artwork)
|
||||
count_query = select(func.count()).select_from(Artwork)
|
||||
filters = []
|
||||
if user_id:
|
||||
filters.append(Artwork.user_id == user_id)
|
||||
if platform:
|
||||
filters.append(Artwork.source_platform == platform)
|
||||
if content_type:
|
||||
filters.append(Artwork.content_type == content_type)
|
||||
if q:
|
||||
like = f"%{q.strip()}%"
|
||||
filters.append(or_(Artwork.title.ilike(like), Artwork.author.ilike(like)))
|
||||
for item in filters:
|
||||
query = query.where(item)
|
||||
count_query = count_query.where(item)
|
||||
total = int(db.scalar(count_query) or 0)
|
||||
rows = db.scalars(query.order_by(Artwork.updated_at.desc()).offset((page - 1) * limit).limit(limit)).all()
|
||||
return ApiResponse(data=_page([AdminArtworkOut.model_validate(row) for row in rows], page, limit, total))
|
||||
|
||||
|
||||
@router.get("/novels", response_model=ApiResponse[AdminListResponse[AdminNovelOut]])
|
||||
def admin_novels(
|
||||
_: AdminUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
user_id: str | None = Query(default=None, max_length=36),
|
||||
q: str | None = Query(default=None, max_length=100),
|
||||
) -> ApiResponse[AdminListResponse[AdminNovelOut]]:
|
||||
query = select(Novel)
|
||||
count_query = select(func.count()).select_from(Novel)
|
||||
filters = []
|
||||
if user_id:
|
||||
filters.append(Novel.user_id == user_id)
|
||||
if q:
|
||||
like = f"%{q.strip()}%"
|
||||
filters.append(or_(Novel.title.ilike(like), Novel.author.ilike(like), Novel.series_title.ilike(like)))
|
||||
for item in filters:
|
||||
query = query.where(item)
|
||||
count_query = count_query.where(item)
|
||||
total = int(db.scalar(count_query) or 0)
|
||||
rows = db.scalars(query.order_by(Novel.updated_at.desc()).offset((page - 1) * limit).limit(limit)).all()
|
||||
return ApiResponse(data=_page([AdminNovelOut.model_validate(row) for row in rows], page, limit, total))
|
||||
|
||||
|
||||
@router.get("/uploads", response_model=ApiResponse[AdminListResponse[AdminTaskOut]])
|
||||
def upload_tasks(
|
||||
_: AdminUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
status_filter: str | None = Query(default=None, alias="status", max_length=30),
|
||||
) -> ApiResponse[AdminListResponse[AdminTaskOut]]:
|
||||
query = select(UploadSession)
|
||||
count_query = select(func.count()).select_from(UploadSession)
|
||||
if status_filter:
|
||||
query = query.where(UploadSession.status == status_filter)
|
||||
count_query = count_query.where(UploadSession.status == status_filter)
|
||||
total = int(db.scalar(count_query) or 0)
|
||||
rows = db.scalars(query.order_by(UploadSession.updated_at.desc()).offset((page - 1) * limit).limit(limit)).all()
|
||||
items = [
|
||||
AdminTaskOut(
|
||||
id=row.id,
|
||||
user_id=row.user_id,
|
||||
status=row.status,
|
||||
file_name=Path(row.file_name).name if row.file_name else None,
|
||||
resource_type=row.resource_type,
|
||||
file_size=row.file_size,
|
||||
updated_at=row.updated_at,
|
||||
)
|
||||
for row in rows
|
||||
]
|
||||
return ApiResponse(data=_page(items, page, limit, total))
|
||||
|
||||
|
||||
@router.get("/ocr/tasks", response_model=ApiResponse[AdminListResponse[AdminOcrTaskOut]])
|
||||
def ocr_tasks(
|
||||
_: AdminUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
status_filter: str | None = Query(default=None, alias="status", pattern="^(pending|running|done|failed)$"),
|
||||
) -> ApiResponse[AdminListResponse[AdminOcrTaskOut]]:
|
||||
query = select(ArtworkOcrText)
|
||||
count_query = select(func.count()).select_from(ArtworkOcrText)
|
||||
if status_filter:
|
||||
query = query.where(ArtworkOcrText.status == status_filter)
|
||||
count_query = count_query.where(ArtworkOcrText.status == status_filter)
|
||||
total = int(db.scalar(count_query) or 0)
|
||||
rows = db.scalars(query.order_by(ArtworkOcrText.updated_at.desc()).offset((page - 1) * limit).limit(limit)).all()
|
||||
items = [
|
||||
AdminOcrTaskOut(
|
||||
id=row.id,
|
||||
user_id=row.user_id,
|
||||
artwork_id=row.artwork_id,
|
||||
status=row.status,
|
||||
language=row.language,
|
||||
confidence=row.confidence,
|
||||
engine=row.engine,
|
||||
attempts=row.attempts,
|
||||
error=row.error,
|
||||
text_length=len(row.ocr_text or ""),
|
||||
updated_at=row.updated_at,
|
||||
)
|
||||
for row in rows
|
||||
]
|
||||
return ApiResponse(data=_page(items, page, limit, total))
|
||||
|
||||
|
||||
@router.post("/ocr/tasks/{task_id}/retry", response_model=ApiResponse[AdminOcrTaskOut])
|
||||
def retry_ocr_task(task_id: str, request: Request, current_admin: AdminUser, db: DbSession) -> ApiResponse[AdminOcrTaskOut]:
|
||||
task = db.get(ArtworkOcrText, task_id)
|
||||
if task is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="OCR task not found")
|
||||
artwork = db.get(Artwork, task.artwork_id)
|
||||
if artwork is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artwork not found")
|
||||
task.status = "pending"
|
||||
task.error = None
|
||||
db.commit()
|
||||
row = run_ocr_for_artwork(db, artwork)
|
||||
write_admin_audit_log(db, current_admin, action="retry_ocr", target_type="ocr_task", target_id=task_id, request=request)
|
||||
return ApiResponse(data=_ocr_out(row))
|
||||
|
||||
|
||||
@router.get("/push/devices", response_model=ApiResponse[AdminListResponse[AdminPushDeviceOut]])
|
||||
def push_devices(
|
||||
_: AdminUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
) -> ApiResponse[AdminListResponse[AdminPushDeviceOut]]:
|
||||
total = int(db.scalar(select(func.count()).select_from(PushDeviceToken)) or 0)
|
||||
rows = db.scalars(select(PushDeviceToken).order_by(PushDeviceToken.updated_at.desc()).offset((page - 1) * limit).limit(limit)).all()
|
||||
items = [_push_device_out(row) for row in rows]
|
||||
return ApiResponse(data=_page(items, page, limit, total))
|
||||
|
||||
|
||||
@router.get("/push/logs", response_model=ApiResponse[list[AdminLogLineOut]])
|
||||
def push_logs(_: AdminUser, limit: int = Query(default=100, ge=1, le=500)) -> ApiResponse[list[AdminLogLineOut]]:
|
||||
return ApiResponse(data=_read_filtered_log_lines(("FCM", "push"), limit=limit))
|
||||
|
||||
|
||||
@router.post("/push/test", response_model=ApiResponse[dict[str, int]])
|
||||
def send_test_push(request: Request, current_admin: AdminUser, db: DbSession, user_id: str = Query(max_length=36)) -> ApiResponse[dict[str, int]]:
|
||||
user = db.get(User, user_id)
|
||||
if user is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
|
||||
summary = send_push_to_user(db, user_id, "Sakura Cloud test push", "Admin test push has been sent.", {"kind": "admin_test"})
|
||||
write_admin_audit_log(db, current_admin, action="send_test_push", target_type="user", target_id=user_id, request=request)
|
||||
return ApiResponse(data={"attempted": summary.attempted, "sent": summary.sent, "disabled": summary.disabled, "failed": summary.failed})
|
||||
|
||||
|
||||
@router.get("/alerts/stats", response_model=ApiResponse[list[AdminAlertStatOut]])
|
||||
def alert_stats(_: AdminUser, db: DbSession) -> ApiResponse[list[AdminAlertStatOut]]:
|
||||
rows = db.execute(
|
||||
select(UpdateAlert.platform, func.count(UpdateAlert.id)).group_by(UpdateAlert.platform)
|
||||
).all()
|
||||
data = []
|
||||
for platform, total in rows:
|
||||
unread = int(db.scalar(select(func.count()).select_from(UpdateAlert).where(UpdateAlert.platform == platform, UpdateAlert.is_read.is_(False))) or 0)
|
||||
data.append(AdminAlertStatOut(platform=platform, alerts=int(total), unread=unread))
|
||||
return ApiResponse(data=data)
|
||||
|
||||
|
||||
@router.get("/alerts", response_model=ApiResponse[AdminListResponse[AdminAlertOut]])
|
||||
def admin_alerts(
|
||||
_: AdminUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
user_id: str | None = Query(default=None, max_length=36),
|
||||
platform: str | None = Query(default=None, max_length=20),
|
||||
) -> ApiResponse[AdminListResponse[AdminAlertOut]]:
|
||||
query = select(UpdateAlert)
|
||||
count_query = select(func.count()).select_from(UpdateAlert)
|
||||
filters = []
|
||||
if user_id:
|
||||
filters.append(UpdateAlert.user_id == user_id)
|
||||
if platform:
|
||||
filters.append(UpdateAlert.platform == platform)
|
||||
for item in filters:
|
||||
query = query.where(item)
|
||||
count_query = count_query.where(item)
|
||||
total = int(db.scalar(count_query) or 0)
|
||||
rows = db.scalars(query.order_by(UpdateAlert.created_at.desc()).offset((page - 1) * limit).limit(limit)).all()
|
||||
return ApiResponse(data=_page([AdminAlertOut.model_validate(row) for row in rows], page, limit, total))
|
||||
|
||||
|
||||
@router.get("/system/health", response_model=ApiResponse[AdminHealthOut])
|
||||
def admin_system_health(current_admin: AdminUser) -> ApiResponse[AdminHealthOut]:
|
||||
return admin_health(current_admin)
|
||||
|
||||
|
||||
@router.get("/health", response_model=ApiResponse[AdminHealthOut])
|
||||
def admin_health(_: AdminUser) -> ApiResponse[AdminHealthOut]:
|
||||
return ApiResponse(
|
||||
data=AdminHealthOut(
|
||||
ok=True,
|
||||
debug=settings.debug,
|
||||
auto_migrate_on_startup=settings.auto_migrate_on_startup,
|
||||
database=_redact_url(settings.database_url),
|
||||
storage_root=str(Path(settings.storage_root).name or "storage"),
|
||||
log_dir=str(Path(settings.log_dir).name or "logs"),
|
||||
app_version=settings.app_version,
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
@router.get("/logs/errors", response_model=ApiResponse[list[AdminLogLineOut]])
|
||||
def error_logs(
|
||||
_: AdminUser,
|
||||
file: str = Query(default="error.log", pattern=r"^[A-Za-z0-9_.-]+$"),
|
||||
limit: int = Query(default=100, ge=1, le=500),
|
||||
) -> ApiResponse[list[AdminLogLineOut]]:
|
||||
path = (Path(settings.log_dir) / file).resolve()
|
||||
root = Path(settings.log_dir).resolve()
|
||||
if not str(path).startswith(str(root)) or not path.is_file():
|
||||
return ApiResponse(data=[])
|
||||
lines = path.read_text(encoding="utf-8", errors="replace").splitlines()[-limit:]
|
||||
return ApiResponse(data=[AdminLogLineOut(line_no=index + 1, text=_redact_log_line(line)) for index, line in enumerate(lines)])
|
||||
|
||||
|
||||
@router.get("/migrations/version", response_model=ApiResponse[AdminMigrationOut])
|
||||
def migration_version(_: AdminUser, db: DbSession) -> ApiResponse[AdminMigrationOut]:
|
||||
try:
|
||||
version = db.execute(text("SELECT version_num FROM alembic_version LIMIT 1")).scalar()
|
||||
except Exception:
|
||||
version = None
|
||||
return ApiResponse(data=AdminMigrationOut(version=str(version) if version else None))
|
||||
|
||||
|
||||
@router.get("/audit-logs", response_model=ApiResponse[AdminListResponse[AdminAuditLogOut]])
|
||||
def audit_logs(
|
||||
_: AdminUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
action: str | None = Query(default=None, max_length=100),
|
||||
) -> ApiResponse[AdminListResponse[AdminAuditLogOut]]:
|
||||
query = select(AdminAuditLog)
|
||||
count_query = select(func.count()).select_from(AdminAuditLog)
|
||||
if action:
|
||||
query = query.where(AdminAuditLog.action == action)
|
||||
count_query = count_query.where(AdminAuditLog.action == action)
|
||||
total = int(db.scalar(count_query) or 0)
|
||||
rows = db.scalars(query.order_by(AdminAuditLog.created_at.desc()).offset((page - 1) * limit).limit(limit)).all()
|
||||
return ApiResponse(data=_page([AdminAuditLogOut.model_validate(row) for row in rows], page, limit, total))
|
||||
|
||||
|
||||
def _count(db: DbSession, model: object) -> int:
|
||||
return int(db.scalar(select(func.count()).select_from(model)) or 0)
|
||||
|
||||
|
||||
def _page(items: list, page: int, limit: int, total: int) -> AdminListResponse:
|
||||
return AdminListResponse(items=items, pagination=AdminPage(page=page, limit=limit, total=total))
|
||||
|
||||
|
||||
def _role_from_value(value: str) -> UserRole:
|
||||
return {
|
||||
"user": UserRole.USER,
|
||||
"admin": UserRole.ADMIN,
|
||||
"super_admin": UserRole.SUPER_ADMIN,
|
||||
}[value]
|
||||
|
||||
|
||||
def _ensure_can_operate_user(admin: User, target: User, *, desired_active: bool | None = None) -> None:
|
||||
if target.role == UserRole.SUPER_ADMIN and admin.role != UserRole.SUPER_ADMIN:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Cannot operate super admin")
|
||||
if target.id == admin.id and desired_active is False:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Cannot disable yourself")
|
||||
|
||||
|
||||
def _super_admin_count(db: DbSession) -> int:
|
||||
return int(db.scalar(select(func.count()).select_from(User).where(User.role == UserRole.SUPER_ADMIN)) or 0)
|
||||
|
||||
|
||||
def _list_files(
|
||||
db: DbSession,
|
||||
*,
|
||||
page: int,
|
||||
limit: int,
|
||||
user_id: str | None = None,
|
||||
mime_type: str | None = None,
|
||||
) -> ApiResponse[AdminListResponse[AdminFileOut]]:
|
||||
query = select(UserFile, FileBlob).join(FileBlob, UserFile.file_sha256 == FileBlob.sha256)
|
||||
count_query = select(func.count()).select_from(UserFile).join(FileBlob, UserFile.file_sha256 == FileBlob.sha256)
|
||||
filters = []
|
||||
if user_id:
|
||||
filters.append(UserFile.user_id == user_id)
|
||||
if mime_type:
|
||||
filters.append(FileBlob.mime_type == mime_type)
|
||||
for item in filters:
|
||||
query = query.where(item)
|
||||
count_query = count_query.where(item)
|
||||
total = int(db.scalar(count_query) or 0)
|
||||
rows = db.execute(
|
||||
query.order_by(UserFile.uploaded_at.desc())
|
||||
.offset((page - 1) * limit)
|
||||
.limit(limit)
|
||||
).all()
|
||||
items = [
|
||||
AdminFileOut(
|
||||
id=user_file.id,
|
||||
user_id=user_file.user_id,
|
||||
original_name=Path(user_file.original_name).name,
|
||||
sha256_prefix=blob.sha256[:12],
|
||||
file_size=blob.file_size,
|
||||
mime_type=blob.mime_type,
|
||||
uploaded_at=user_file.uploaded_at,
|
||||
)
|
||||
for user_file, blob in rows
|
||||
]
|
||||
return ApiResponse(data=_page(items, page, limit, total))
|
||||
|
||||
|
||||
def _ocr_out(row: ArtworkOcrText) -> AdminOcrTaskOut:
|
||||
return AdminOcrTaskOut(
|
||||
id=row.id,
|
||||
user_id=row.user_id,
|
||||
artwork_id=row.artwork_id,
|
||||
status=row.status,
|
||||
language=row.language,
|
||||
confidence=row.confidence,
|
||||
engine=row.engine,
|
||||
attempts=row.attempts,
|
||||
error=row.error,
|
||||
text_length=len(row.ocr_text or ""),
|
||||
updated_at=row.updated_at,
|
||||
)
|
||||
|
||||
|
||||
def _push_device_out(row: PushDeviceToken) -> AdminPushDeviceOut:
|
||||
return AdminPushDeviceOut(
|
||||
id=row.id,
|
||||
user_id=row.user_id,
|
||||
device_id=row.device_id,
|
||||
platform=row.platform,
|
||||
token_tail=row.fcm_token[-8:] if row.fcm_token else "",
|
||||
is_active=row.is_active,
|
||||
last_seen_at=row.last_seen_at,
|
||||
updated_at=row.updated_at,
|
||||
)
|
||||
|
||||
|
||||
def _check_login_rate_limit(request: Request) -> None:
|
||||
key = request.client.host if request.client is not None else "unknown"
|
||||
now = time.time()
|
||||
attempts = _login_attempts[key]
|
||||
while attempts and now - attempts[0] > 60:
|
||||
attempts.popleft()
|
||||
if len(attempts) >= settings.admin_login_rate_limit_per_minute:
|
||||
raise HTTPException(status_code=status.HTTP_429_TOO_MANY_REQUESTS, detail="Too many admin login attempts")
|
||||
attempts.append(now)
|
||||
|
||||
|
||||
def _redact_url(value: str) -> str:
|
||||
if "@" not in value:
|
||||
return value
|
||||
prefix, suffix = value.rsplit("@", 1)
|
||||
scheme = prefix.split(":", 1)[0]
|
||||
return f"{scheme}:***@{suffix}"
|
||||
|
||||
|
||||
def _redact_log_line(line: str) -> str:
|
||||
text_value = line
|
||||
for marker in ("Bearer ", "token=", "password=", "cookie=", "secret="):
|
||||
index = text_value.lower().find(marker.lower())
|
||||
if index >= 0:
|
||||
text_value = text_value[: index + len(marker)] + "***"
|
||||
return text_value
|
||||
|
||||
|
||||
def _read_filtered_log_lines(keywords: tuple[str, ...], *, limit: int) -> list[AdminLogLineOut]:
|
||||
root = Path(settings.log_dir).resolve()
|
||||
if not root.is_dir():
|
||||
return []
|
||||
candidates = sorted(root.glob("*.log"), key=lambda item: item.stat().st_mtime if item.exists() else 0, reverse=True)
|
||||
matched: list[str] = []
|
||||
lowered_keywords = tuple(item.lower() for item in keywords)
|
||||
for path in candidates[:5]:
|
||||
try:
|
||||
lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
|
||||
except OSError:
|
||||
continue
|
||||
for line in reversed(lines):
|
||||
lowered = line.lower()
|
||||
if any(keyword in lowered for keyword in lowered_keywords):
|
||||
matched.append(_redact_log_line(line))
|
||||
if len(matched) >= limit:
|
||||
break
|
||||
if len(matched) >= limit:
|
||||
break
|
||||
matched.reverse()
|
||||
return [AdminLogLineOut(line_no=index + 1, text=line) for index, line in enumerate(matched)]
|
||||
@@ -0,0 +1,120 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from time import monotonic
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Request, status
|
||||
from sqlalchemy import func, or_, select
|
||||
from sqlalchemy.exc import IntegrityError, SQLAlchemyError
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.core.security import (
|
||||
create_access_token,
|
||||
create_refresh_token,
|
||||
decode_token,
|
||||
hash_password,
|
||||
verify_password,
|
||||
)
|
||||
from sakura_cloud.models.user import User
|
||||
from sakura_cloud.schemas.auth import LoginRequest, RefreshRequest, RegisterRequest, TokenPair
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
from sakura_cloud.schemas.user import UserOut
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
_rate_buckets: dict[str, list[float]] = {}
|
||||
|
||||
|
||||
def _rate_limit(request: Request, scope: str, *, limit: int = 5, window_seconds: int = 60) -> None:
|
||||
client_ip = request.client.host if request.client else "unknown"
|
||||
key = f"{scope}:{client_ip}"
|
||||
now = monotonic()
|
||||
bucket = [item for item in _rate_buckets.get(key, []) if now - item < window_seconds]
|
||||
if len(bucket) >= limit:
|
||||
_rate_buckets[key] = bucket
|
||||
raise HTTPException(status_code=status.HTTP_429_TOO_MANY_REQUESTS, detail="Too many requests")
|
||||
bucket.append(now)
|
||||
_rate_buckets[key] = bucket
|
||||
|
||||
|
||||
@router.post("/register", response_model=ApiResponse[UserOut], status_code=status.HTTP_201_CREATED)
|
||||
def register(payload: RegisterRequest, request: Request, db: DbSession) -> ApiResponse[UserOut]:
|
||||
_rate_limit(request, "register")
|
||||
username = payload.username.strip()
|
||||
email = str(payload.email).strip().lower()
|
||||
exists = db.scalar(
|
||||
select(User).where(
|
||||
or_(
|
||||
func.lower(User.username) == username.lower(),
|
||||
func.lower(User.email) == email,
|
||||
)
|
||||
)
|
||||
)
|
||||
if exists is not None:
|
||||
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="注册失败,请检查输入")
|
||||
user = User(
|
||||
username=username,
|
||||
email=email,
|
||||
password_hash=hash_password(payload.password),
|
||||
)
|
||||
try:
|
||||
db.add(user)
|
||||
db.commit()
|
||||
db.refresh(user)
|
||||
except IntegrityError as exc:
|
||||
db.rollback()
|
||||
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="注册失败,请检查输入") from exc
|
||||
except SQLAlchemyError as exc:
|
||||
db.rollback()
|
||||
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="注册失败,请稍后重试") from exc
|
||||
return ApiResponse(code=201, message="created", data=UserOut.model_validate(user))
|
||||
|
||||
|
||||
@router.post("/login", response_model=ApiResponse[TokenPair])
|
||||
def login(payload: LoginRequest, request: Request, db: DbSession) -> ApiResponse[TokenPair]:
|
||||
_rate_limit(request, "login")
|
||||
login_id = payload.username_or_email.strip()
|
||||
user = db.scalar(
|
||||
select(User).where(
|
||||
or_(
|
||||
func.lower(User.username) == login_id.lower(),
|
||||
func.lower(User.email) == login_id.lower(),
|
||||
)
|
||||
)
|
||||
)
|
||||
if user is None or not verify_password(payload.password, user.password_hash):
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
|
||||
tokens = TokenPair(
|
||||
access_token=create_access_token(user.id, user.token_version),
|
||||
refresh_token=create_refresh_token(user.id, user.token_version),
|
||||
)
|
||||
return ApiResponse(data=tokens)
|
||||
|
||||
|
||||
@router.post("/logout", response_model=ApiResponse[dict[str, bool]])
|
||||
def logout(current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, bool]]:
|
||||
# 临时方案:只让客户端清本地 token,不在服务端吊销所有端
|
||||
return ApiResponse(data={"ok": True})
|
||||
|
||||
|
||||
@router.post("/refresh", response_model=ApiResponse[TokenPair])
|
||||
def refresh(payload: RefreshRequest, request: Request, db: DbSession) -> ApiResponse[TokenPair]:
|
||||
_rate_limit(request, "refresh")
|
||||
try:
|
||||
token_payload = decode_token(payload.refresh_token)
|
||||
except ValueError as exc:
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid refresh token") from exc
|
||||
if token_payload.get("type") != "refresh":
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token type")
|
||||
user_id = token_payload.get("sub")
|
||||
user = db.get(User, str(user_id)) if user_id else None
|
||||
if user is None:
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found")
|
||||
if not user.is_active:
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User is disabled")
|
||||
if int(token_payload.get("tv") or 0) != int(user.token_version or 0):
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Token has been revoked")
|
||||
tokens = TokenPair(
|
||||
access_token=create_access_token(user.id, user.token_version),
|
||||
refresh_token=create_refresh_token(user.id, user.token_version),
|
||||
)
|
||||
return ApiResponse(data=tokens)
|
||||
@@ -0,0 +1,78 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import APIRouter, HTTPException, status
|
||||
from sqlalchemy import select
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.models.device import Device
|
||||
from sakura_cloud.models.mixins import utc_now
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
from sakura_cloud.schemas.device import DeviceOut, DeviceRegister, DeviceUpdate
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.post("/register", response_model=ApiResponse[DeviceOut], status_code=status.HTTP_201_CREATED)
|
||||
def register_device(payload: DeviceRegister, current_user: CurrentUser, db: DbSession) -> ApiResponse[DeviceOut]:
|
||||
device = Device(
|
||||
user_id=current_user.id,
|
||||
device_name=payload.device_name,
|
||||
device_type=payload.device_type,
|
||||
device_token=payload.device_token,
|
||||
last_active_at=utc_now(),
|
||||
)
|
||||
db.add(device)
|
||||
db.commit()
|
||||
db.refresh(device)
|
||||
return ApiResponse(code=201, message="created", data=DeviceOut.model_validate(device))
|
||||
|
||||
|
||||
@router.get("", response_model=ApiResponse[list[DeviceOut]])
|
||||
def list_devices(current_user: CurrentUser, db: DbSession) -> ApiResponse[list[DeviceOut]]:
|
||||
rows = db.scalars(select(Device).where(Device.user_id == current_user.id).order_by(Device.updated_at.desc())).all()
|
||||
return ApiResponse(data=[DeviceOut.model_validate(row) for row in rows])
|
||||
|
||||
|
||||
@router.get("/sync/status", response_model=ApiResponse[dict[str, str | int | None]])
|
||||
def sync_status(current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, str | int | None]]:
|
||||
latest = db.scalar(
|
||||
select(Device).where(Device.user_id == current_user.id).order_by(Device.last_sync_at.desc().nulls_last())
|
||||
)
|
||||
return ApiResponse(
|
||||
data={
|
||||
"user_id": current_user.id,
|
||||
"storage_used": current_user.storage_used,
|
||||
"last_sync_at": latest.last_sync_at.isoformat() if latest and latest.last_sync_at else None,
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@router.put("/{device_id}", response_model=ApiResponse[DeviceOut])
|
||||
def update_device(
|
||||
device_id: str,
|
||||
payload: DeviceUpdate,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[DeviceOut]:
|
||||
device = db.get(Device, device_id)
|
||||
if device is None or device.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Device not found")
|
||||
if payload.device_name is not None:
|
||||
device.device_name = payload.device_name
|
||||
if payload.device_token is not None:
|
||||
device.device_token = payload.device_token
|
||||
device.last_active_at = utc_now()
|
||||
db.commit()
|
||||
db.refresh(device)
|
||||
return ApiResponse(data=DeviceOut.model_validate(device))
|
||||
|
||||
|
||||
@router.delete("/{device_id}", response_model=ApiResponse[dict[str, bool]])
|
||||
def delete_device(device_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, bool]]:
|
||||
device = db.get(Device, device_id)
|
||||
if device is None or device.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Device not found")
|
||||
db.delete(device)
|
||||
db.commit()
|
||||
return ApiResponse(data={"ok": True})
|
||||
@@ -0,0 +1,50 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
from fastapi import APIRouter, HTTPException, status
|
||||
from fastapi.responses import FileResponse
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.models.file import FileBlob, UserFile
|
||||
from sakura_cloud.services.thumbnails import generate_webp_thumbnail
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
def _owned_user_file(file_id: str, current_user: CurrentUser, db: DbSession) -> tuple[UserFile, FileBlob]:
|
||||
user_file = db.get(UserFile, file_id)
|
||||
if user_file is None or user_file.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="File not found")
|
||||
blob = db.get(FileBlob, user_file.file_sha256)
|
||||
if blob is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Blob not found")
|
||||
return user_file, blob
|
||||
|
||||
|
||||
@router.get("/{file_id}/content")
|
||||
def file_content(file_id: str, current_user: CurrentUser, db: DbSession) -> FileResponse:
|
||||
user_file, blob = _owned_user_file(file_id, current_user, db)
|
||||
path = Path(blob.storage_path)
|
||||
if not path.is_file():
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="File missing from storage")
|
||||
return FileResponse(path, media_type=blob.mime_type, filename=user_file.original_name)
|
||||
|
||||
|
||||
@router.get("/{file_id}/thumbnail")
|
||||
def file_thumbnail(file_id: str, current_user: CurrentUser, db: DbSession) -> FileResponse:
|
||||
_, blob = _owned_user_file(file_id, current_user, db)
|
||||
if not blob.thumbnail_path:
|
||||
blob.thumbnail_path = generate_webp_thumbnail(blob.storage_path)
|
||||
db.commit()
|
||||
db.refresh(blob)
|
||||
path = Path(blob.thumbnail_path or blob.storage_path)
|
||||
if not path.is_file():
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Thumbnail missing from storage")
|
||||
media_type = "image/webp" if path.suffix.lower() == ".webp" else blob.mime_type
|
||||
return FileResponse(
|
||||
path,
|
||||
media_type=media_type,
|
||||
headers={"Cache-Control": "private, max-age=604800"},
|
||||
)
|
||||
@@ -0,0 +1,208 @@
|
||||
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))
|
||||
@@ -0,0 +1,520 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
import hashlib
|
||||
from datetime import timedelta
|
||||
|
||||
from fastapi import APIRouter, BackgroundTasks, HTTPException, Query, status
|
||||
from pydantic import BaseModel, Field
|
||||
from sqlalchemy import String, delete, func, or_, select
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.models.artwork import Artwork
|
||||
from sakura_cloud.models.feed_cache import FeedCache
|
||||
from sakura_cloud.models.mixins import utc_now
|
||||
from sakura_cloud.models.ocr import ArtworkOcrText
|
||||
from sakura_cloud.schemas.common import ApiResponse, PageResponse, Pagination
|
||||
from sakura_cloud.schemas.gallery import ArtworkCreate, ArtworkOut, ArtworkUpdate, ArtworkViewUpdate, TagsUpdate
|
||||
from sakura_cloud.schemas.ocr import ArtworkOcrTextOut
|
||||
from sakura_cloud.services.ocr import queue_ocr_for_artwork, run_ocr_for_artwork, run_ocr_for_artwork_id
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
class ArtworkBatchDeleteRequest(BaseModel):
|
||||
ids: list[str] = Field(default_factory=list, min_length=1, max_length=200)
|
||||
|
||||
|
||||
class OnlineMangaImportRequest(BaseModel):
|
||||
source_platform: str = Field(max_length=20)
|
||||
title: str = Field(min_length=1, max_length=500)
|
||||
author: str | None = Field(default=None, max_length=200)
|
||||
detail_url: str = Field(min_length=1, max_length=2048)
|
||||
cover_url: str | None = Field(default=None, max_length=2048)
|
||||
page_urls: list[str] = Field(min_length=1, max_length=300)
|
||||
headers: dict[str, str] = Field(default_factory=dict)
|
||||
tags: list[str] = Field(default_factory=list, max_length=50)
|
||||
|
||||
|
||||
def _ensure_storage_quota(current_user: CurrentUser, incoming_size: int) -> None:
|
||||
size = max(0, incoming_size)
|
||||
if size and current_user.storage_used + size > current_user.storage_limit:
|
||||
raise HTTPException(status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, detail="Storage quota exceeded")
|
||||
|
||||
|
||||
def _online_source_id(value: str) -> str:
|
||||
return hashlib.sha256(value.encode("utf-8")).hexdigest()[:32]
|
||||
|
||||
|
||||
@router.get("", response_model=ApiResponse[PageResponse[ArtworkOut]])
|
||||
def list_gallery(
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
source_platform: str | None = None,
|
||||
author: str | None = None,
|
||||
tag: str | None = None,
|
||||
content_type: str | None = None,
|
||||
is_favorite: bool | None = None,
|
||||
search: str | None = None,
|
||||
query: str | None = None,
|
||||
search_scope: str = Query(default="all", pattern="^(title|tags|ocr|all)$"),
|
||||
sort: str = Query(default="recent", pattern="^(recent|updated)$"),
|
||||
include_total: bool = Query(default=True),
|
||||
) -> ApiResponse[PageResponse[ArtworkOut]]:
|
||||
search_text = (query or search or "").strip()
|
||||
query = select(Artwork).where(Artwork.user_id == current_user.id)
|
||||
count_query = select(func.count()).select_from(Artwork).where(Artwork.user_id == current_user.id)
|
||||
filters = []
|
||||
if source_platform:
|
||||
filters.append(Artwork.source_platform == source_platform)
|
||||
if author:
|
||||
filters.append(Artwork.author.ilike(f"%{author}%"))
|
||||
if content_type:
|
||||
filters.append(Artwork.content_type == content_type)
|
||||
if is_favorite is not None:
|
||||
filters.append(Artwork.is_favorite == is_favorite)
|
||||
if search_text:
|
||||
text_filters = []
|
||||
if search_scope in {"title", "all"}:
|
||||
text_filters.append(Artwork.title.ilike(f"%{search_text}%"))
|
||||
text_filters.append(Artwork.author.ilike(f"%{search_text}%"))
|
||||
if db.bind is not None and db.bind.dialect.name == "postgresql":
|
||||
vector = func.to_tsvector(
|
||||
"simple",
|
||||
func.concat_ws(" ", Artwork.title, Artwork.author, Artwork.source_platform),
|
||||
)
|
||||
text_filters.append(vector.op("@@")(func.plainto_tsquery("simple", search_text)))
|
||||
if search_scope in {"tags", "all"}:
|
||||
text_filters.append(Artwork.tags.cast(String).ilike(f"%{search_text}%"))
|
||||
if search_scope in {"ocr", "all"}:
|
||||
ocr_match = (
|
||||
select(ArtworkOcrText.id).where(
|
||||
ArtworkOcrText.user_id == current_user.id,
|
||||
ArtworkOcrText.artwork_id == Artwork.id,
|
||||
ArtworkOcrText.status == "done",
|
||||
ArtworkOcrText.ocr_text.ilike(f"%{search_text}%"),
|
||||
)
|
||||
).exists()
|
||||
if db.bind is not None and db.bind.dialect.name == "postgresql":
|
||||
ocr_match = (
|
||||
select(ArtworkOcrText.id).where(
|
||||
ArtworkOcrText.user_id == current_user.id,
|
||||
ArtworkOcrText.artwork_id == Artwork.id,
|
||||
ArtworkOcrText.status == "done",
|
||||
func.to_tsvector("simple", ArtworkOcrText.ocr_text).op("@@")(
|
||||
func.plainto_tsquery("simple", search_text)
|
||||
),
|
||||
)
|
||||
).exists()
|
||||
text_filters.append(ocr_match)
|
||||
if text_filters:
|
||||
filters.append(or_(*text_filters))
|
||||
elif db.bind is not None and db.bind.dialect.name == "postgresql":
|
||||
vector = func.to_tsvector(
|
||||
"simple",
|
||||
func.concat_ws(" ", Artwork.title, Artwork.author, Artwork.source_platform),
|
||||
)
|
||||
filters.append(vector.op("@@")(func.plainto_tsquery("simple", search_text)))
|
||||
if tag:
|
||||
filters.append(Artwork.tags.contains([tag]))
|
||||
for item in filters:
|
||||
query = query.where(item)
|
||||
count_query = count_query.where(item)
|
||||
order_by = (
|
||||
(Artwork.updated_at.desc(), Artwork.created_at.desc())
|
||||
if sort == "updated"
|
||||
else (Artwork.last_viewed_at.desc().nullslast(), Artwork.updated_at.desc())
|
||||
)
|
||||
rows = db.scalars(query.order_by(*order_by).offset((page - 1) * limit).limit(limit)).all()
|
||||
if include_total:
|
||||
total = int(db.scalar(count_query) or 0)
|
||||
pages = math.ceil(total / limit) if total else 0
|
||||
else:
|
||||
has_more = len(rows) >= limit
|
||||
total = (page - 1) * limit + len(rows) + (1 if has_more else 0)
|
||||
pages = page + 1 if has_more else page
|
||||
if search_text:
|
||||
_annotate_gallery_matches(db, rows, current_user.id, search_text, search_scope)
|
||||
data = PageResponse(
|
||||
items=[ArtworkOut.model_validate(row) for row in rows],
|
||||
pagination=Pagination(page=page, limit=limit, total=total, pages=pages),
|
||||
)
|
||||
return ApiResponse(data=data)
|
||||
|
||||
|
||||
@router.get("/feed", response_model=ApiResponse[list[ArtworkOut]])
|
||||
def gallery_feed(
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
mode: str = Query(default="created", pattern="^(created|recent)$"),
|
||||
) -> ApiResponse[list[ArtworkOut]]:
|
||||
cache_key = f"gallery_feed:{mode}:{limit}"
|
||||
now = utc_now()
|
||||
cached = db.scalar(
|
||||
select(FeedCache).where(
|
||||
FeedCache.user_id == current_user.id,
|
||||
FeedCache.cache_key == cache_key,
|
||||
FeedCache.expires_at > now,
|
||||
)
|
||||
)
|
||||
if cached is not None:
|
||||
return ApiResponse(data=[ArtworkOut.model_validate(item) for item in cached.payload])
|
||||
|
||||
order_by = Artwork.last_viewed_at.desc() if mode == "recent" else Artwork.created_at.desc()
|
||||
where = [Artwork.user_id == current_user.id]
|
||||
if mode == "recent":
|
||||
where.append(Artwork.last_viewed_at.is_not(None))
|
||||
rows = db.scalars(
|
||||
select(Artwork).where(*where).order_by(order_by).limit(limit)
|
||||
).all()
|
||||
data = [ArtworkOut.model_validate(row) for row in rows]
|
||||
payload = [item.model_dump(mode="json") for item in data]
|
||||
existing = db.scalar(
|
||||
select(FeedCache).where(
|
||||
FeedCache.user_id == current_user.id,
|
||||
FeedCache.cache_key == cache_key,
|
||||
)
|
||||
)
|
||||
if existing is None:
|
||||
db.add(
|
||||
FeedCache(
|
||||
user_id=current_user.id,
|
||||
cache_key=cache_key,
|
||||
payload=payload,
|
||||
expires_at=now + timedelta(minutes=5),
|
||||
)
|
||||
)
|
||||
else:
|
||||
existing.payload = payload
|
||||
existing.expires_at = now + timedelta(minutes=5)
|
||||
db.commit()
|
||||
return ApiResponse(data=data)
|
||||
|
||||
|
||||
@router.get("/search", response_model=ApiResponse[PageResponse[ArtworkOut]])
|
||||
def search_gallery(
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
q: str = Query(min_length=1),
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
) -> ApiResponse[PageResponse[ArtworkOut]]:
|
||||
return list_gallery(current_user=current_user, db=db, page=page, limit=limit, search=q, search_scope="all")
|
||||
|
||||
|
||||
@router.post("/import-online", response_model=ApiResponse[list[ArtworkOut]], status_code=status.HTTP_201_CREATED)
|
||||
def import_online_manga(
|
||||
payload: OnlineMangaImportRequest,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[list[ArtworkOut]]:
|
||||
series_id = _online_source_id(payload.detail_url)
|
||||
existing = db.scalars(
|
||||
select(Artwork)
|
||||
.where(
|
||||
Artwork.user_id == current_user.id,
|
||||
Artwork.source_platform == payload.source_platform,
|
||||
Artwork.source_id.like(f"{series_id}:%"),
|
||||
Artwork.content_type == "manga",
|
||||
)
|
||||
.order_by(Artwork.title.asc())
|
||||
).all()
|
||||
if existing:
|
||||
return ApiResponse(data=[ArtworkOut.model_validate(item) for item in existing])
|
||||
|
||||
safe_headers = {
|
||||
key: value
|
||||
for key, value in payload.headers.items()
|
||||
if key.lower() in {"user-agent", "referer", "cookie", "accept", "accept-language"} and value
|
||||
}
|
||||
rows: list[Artwork] = []
|
||||
page_count = len(payload.page_urls)
|
||||
for index, page_url in enumerate(payload.page_urls, start=1):
|
||||
url = page_url.strip()
|
||||
if not url.startswith(("http://", "https://")):
|
||||
continue
|
||||
artwork = Artwork(
|
||||
user_id=current_user.id,
|
||||
source_id=f"{series_id}:{index:04d}",
|
||||
source_platform=payload.source_platform,
|
||||
content_type="manga",
|
||||
title=f"{payload.title.strip()} #{index:03d}",
|
||||
author=payload.author,
|
||||
page_count=page_count,
|
||||
file_path=url,
|
||||
file_size=0,
|
||||
thumbnail_path=payload.cover_url or url,
|
||||
mime_type="image/jpeg",
|
||||
tags=payload.tags,
|
||||
artwork_metadata={
|
||||
"online_import": True,
|
||||
"detail_url": payload.detail_url,
|
||||
"series_id": series_id,
|
||||
"page_index": index,
|
||||
"headers": safe_headers,
|
||||
},
|
||||
)
|
||||
db.add(artwork)
|
||||
rows.append(artwork)
|
||||
if not rows:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No valid manga page URL")
|
||||
db.commit()
|
||||
for row in rows:
|
||||
db.refresh(row)
|
||||
_clear_gallery_feed_cache(db, current_user.id)
|
||||
return ApiResponse(code=201, message="created", data=[ArtworkOut.model_validate(item) for item in rows])
|
||||
|
||||
|
||||
@router.get("/stat", response_model=ApiResponse[dict[str, int]])
|
||||
def gallery_stat(current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, int]]:
|
||||
total = int(db.scalar(select(func.count()).select_from(Artwork).where(Artwork.user_id == current_user.id)) or 0)
|
||||
favorites = int(
|
||||
db.scalar(
|
||||
select(func.count()).select_from(Artwork).where(Artwork.user_id == current_user.id, Artwork.is_favorite == True)
|
||||
)
|
||||
or 0
|
||||
)
|
||||
return ApiResponse(data={"total": total, "favorites": favorites, "storage_used": current_user.storage_used})
|
||||
|
||||
|
||||
@router.post("", response_model=ApiResponse[ArtworkOut], status_code=status.HTTP_201_CREATED)
|
||||
def create_artwork(
|
||||
payload: ArtworkCreate,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
background_tasks: BackgroundTasks,
|
||||
) -> ApiResponse[ArtworkOut]:
|
||||
_ensure_storage_quota(current_user, payload.file_size)
|
||||
artwork = Artwork(
|
||||
user_id=current_user.id,
|
||||
source_id=payload.source_id,
|
||||
source_platform=payload.source_platform,
|
||||
content_type=payload.content_type,
|
||||
title=payload.title,
|
||||
author=payload.author,
|
||||
author_id=payload.author_id,
|
||||
page_count=payload.page_count,
|
||||
file_path=payload.file_path,
|
||||
file_size=payload.file_size,
|
||||
thumbnail_path=payload.thumbnail_path,
|
||||
mime_type=payload.mime_type,
|
||||
width=payload.width,
|
||||
height=payload.height,
|
||||
tags=payload.tags,
|
||||
artwork_metadata=payload.metadata,
|
||||
)
|
||||
db.add(artwork)
|
||||
current_user.storage_used += max(0, payload.file_size)
|
||||
db.commit()
|
||||
db.refresh(artwork)
|
||||
if queue_ocr_for_artwork(db, artwork) is not None:
|
||||
background_tasks.add_task(run_ocr_for_artwork_id, artwork.id, current_user.id)
|
||||
_clear_gallery_feed_cache(db, current_user.id)
|
||||
return ApiResponse(code=201, message="created", data=ArtworkOut.model_validate(artwork))
|
||||
|
||||
|
||||
@router.get("/tags", response_model=ApiResponse[list[str]])
|
||||
def list_tags(current_user: CurrentUser, db: DbSession) -> ApiResponse[list[str]]:
|
||||
rows = db.scalars(select(Artwork.tags).where(Artwork.user_id == current_user.id)).all()
|
||||
tags = sorted({tag for row in rows for tag in (row or [])})
|
||||
return ApiResponse(data=tags)
|
||||
|
||||
|
||||
@router.get("/{artwork_id}/ocr", response_model=ApiResponse[ArtworkOcrTextOut | None])
|
||||
def get_artwork_ocr(artwork_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[ArtworkOcrTextOut | None]:
|
||||
artwork = db.get(Artwork, artwork_id)
|
||||
if artwork is None or artwork.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artwork not found")
|
||||
row = db.scalar(
|
||||
select(ArtworkOcrText).where(
|
||||
ArtworkOcrText.user_id == current_user.id,
|
||||
ArtworkOcrText.artwork_id == artwork_id,
|
||||
)
|
||||
)
|
||||
return ApiResponse(data=ArtworkOcrTextOut.model_validate(row) if row is not None else None)
|
||||
|
||||
|
||||
@router.post("/{artwork_id}/ocr/retry", response_model=ApiResponse[ArtworkOcrTextOut])
|
||||
def retry_artwork_ocr(
|
||||
artwork_id: str,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
background_tasks: BackgroundTasks,
|
||||
) -> ApiResponse[ArtworkOcrTextOut]:
|
||||
artwork = db.get(Artwork, artwork_id)
|
||||
if artwork is None or artwork.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artwork not found")
|
||||
row = queue_ocr_for_artwork(db, artwork)
|
||||
if row is None:
|
||||
row = run_ocr_for_artwork(db, artwork)
|
||||
else:
|
||||
background_tasks.add_task(run_ocr_for_artwork_id, artwork.id, current_user.id)
|
||||
db.refresh(row)
|
||||
return ApiResponse(data=ArtworkOcrTextOut.model_validate(row))
|
||||
|
||||
|
||||
@router.get("/{artwork_id}", response_model=ApiResponse[ArtworkOut])
|
||||
def get_artwork(artwork_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[ArtworkOut]:
|
||||
artwork = db.get(Artwork, artwork_id)
|
||||
if artwork is None or artwork.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artwork not found")
|
||||
return ApiResponse(data=ArtworkOut.model_validate(artwork))
|
||||
|
||||
|
||||
def _annotate_gallery_matches(
|
||||
db: DbSession,
|
||||
rows: list[Artwork],
|
||||
user_id: str,
|
||||
search_text: str,
|
||||
search_scope: str,
|
||||
) -> None:
|
||||
lowered = search_text.lower()
|
||||
artwork_ids = [row.id for row in rows]
|
||||
ocr_hits: set[str] = set()
|
||||
if artwork_ids and search_scope in {"ocr", "all"}:
|
||||
ocr_hits = set(
|
||||
db.scalars(
|
||||
select(ArtworkOcrText.artwork_id).where(
|
||||
ArtworkOcrText.user_id == user_id,
|
||||
ArtworkOcrText.artwork_id.in_(artwork_ids),
|
||||
ArtworkOcrText.status == "done",
|
||||
ArtworkOcrText.ocr_text.ilike(f"%{search_text}%"),
|
||||
)
|
||||
).all()
|
||||
)
|
||||
for row in rows:
|
||||
title_hit = lowered in (row.title or "").lower() or lowered in (row.author or "").lower()
|
||||
tag_hit = any(lowered in str(tag).lower() for tag in (row.tags or []))
|
||||
if row.id in ocr_hits:
|
||||
row.matched_by = "ocr"
|
||||
elif title_hit:
|
||||
row.matched_by = "title"
|
||||
elif tag_hit:
|
||||
row.matched_by = "tags"
|
||||
else:
|
||||
row.matched_by = None
|
||||
|
||||
|
||||
def _clear_gallery_feed_cache(db: DbSession, user_id: str) -> None:
|
||||
db.execute(
|
||||
delete(FeedCache).where(
|
||||
FeedCache.user_id == user_id,
|
||||
FeedCache.cache_key.like("gallery_feed:%"),
|
||||
)
|
||||
)
|
||||
db.commit()
|
||||
|
||||
|
||||
@router.delete("/{artwork_id}", response_model=ApiResponse[dict[str, bool]])
|
||||
def delete_artwork(artwork_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, bool]]:
|
||||
artwork = db.get(Artwork, artwork_id)
|
||||
if artwork is None or artwork.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artwork not found")
|
||||
current_user.storage_used = max(0, current_user.storage_used - max(0, artwork.file_size))
|
||||
db.delete(artwork)
|
||||
db.commit()
|
||||
return ApiResponse(data={"ok": True})
|
||||
|
||||
|
||||
@router.post("/batch-delete", response_model=ApiResponse[dict[str, int]])
|
||||
def batch_delete_artworks(
|
||||
payload: ArtworkBatchDeleteRequest,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[dict[str, int]]:
|
||||
ids = sorted({item.strip() for item in payload.ids if item.strip()})
|
||||
if not ids:
|
||||
return ApiResponse(data={"deleted": 0})
|
||||
|
||||
rows = db.scalars(
|
||||
select(Artwork).where(
|
||||
Artwork.user_id == current_user.id,
|
||||
Artwork.id.in_(ids),
|
||||
)
|
||||
).all()
|
||||
deleted = 0
|
||||
released = 0
|
||||
for artwork in rows:
|
||||
released += max(0, artwork.file_size)
|
||||
db.delete(artwork)
|
||||
deleted += 1
|
||||
if deleted:
|
||||
current_user.storage_used = max(0, current_user.storage_used - released)
|
||||
db.commit()
|
||||
return ApiResponse(data={"deleted": deleted})
|
||||
|
||||
|
||||
@router.post("/{artwork_id}/favorite", response_model=ApiResponse[ArtworkOut])
|
||||
def favorite_artwork(artwork_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[ArtworkOut]:
|
||||
artwork = db.get(Artwork, artwork_id)
|
||||
if artwork is None or artwork.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artwork not found")
|
||||
artwork.is_favorite = True
|
||||
db.commit()
|
||||
db.refresh(artwork)
|
||||
return ApiResponse(data=ArtworkOut.model_validate(artwork))
|
||||
|
||||
|
||||
@router.delete("/{artwork_id}/favorite", response_model=ApiResponse[ArtworkOut])
|
||||
def unfavorite_artwork(artwork_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[ArtworkOut]:
|
||||
artwork = db.get(Artwork, artwork_id)
|
||||
if artwork is None or artwork.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artwork not found")
|
||||
artwork.is_favorite = False
|
||||
db.commit()
|
||||
db.refresh(artwork)
|
||||
return ApiResponse(data=ArtworkOut.model_validate(artwork))
|
||||
|
||||
|
||||
@router.put("/{artwork_id}/tags", response_model=ApiResponse[ArtworkOut])
|
||||
def update_artwork_tags(
|
||||
artwork_id: str,
|
||||
payload: TagsUpdate,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[ArtworkOut]:
|
||||
artwork = db.get(Artwork, artwork_id)
|
||||
if artwork is None or artwork.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artwork not found")
|
||||
artwork.tags = sorted(set(payload.tags))
|
||||
db.commit()
|
||||
db.refresh(artwork)
|
||||
return ApiResponse(data=ArtworkOut.model_validate(artwork))
|
||||
|
||||
|
||||
@router.put("/{artwork_id}", response_model=ApiResponse[ArtworkOut])
|
||||
def update_artwork(
|
||||
artwork_id: str,
|
||||
payload: ArtworkUpdate,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[ArtworkOut]:
|
||||
artwork = db.get(Artwork, artwork_id)
|
||||
if artwork is None or artwork.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artwork not found")
|
||||
artwork.title = payload.title.strip()
|
||||
artwork.tags = sorted({item.strip() for item in payload.tags if item.strip()})
|
||||
db.commit()
|
||||
db.refresh(artwork)
|
||||
return ApiResponse(data=ArtworkOut.model_validate(artwork))
|
||||
|
||||
|
||||
@router.post("/{artwork_id}/view", response_model=ApiResponse[ArtworkOut])
|
||||
def mark_artwork_viewed(
|
||||
artwork_id: str,
|
||||
payload: ArtworkViewUpdate,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[ArtworkOut]:
|
||||
artwork = db.get(Artwork, artwork_id)
|
||||
if artwork is None or artwork.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artwork not found")
|
||||
if payload.viewed:
|
||||
artwork.last_viewed_at = utc_now()
|
||||
db.commit()
|
||||
db.refresh(artwork)
|
||||
return ApiResponse(data=ArtworkOut.model_validate(artwork))
|
||||
@@ -0,0 +1,13 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import APIRouter
|
||||
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get("/health", response_model=ApiResponse[dict[str, str]])
|
||||
def health_check() -> ApiResponse[dict[str, str]]:
|
||||
return ApiResponse(data={"status": "ok", "service": "sakura-cloud"})
|
||||
@@ -0,0 +1,82 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import APIRouter, Query
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.api.v1.endpoints import follows, gallery, novels, push, users
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
from sakura_cloud.schemas.user import PasswordChangeRequest, UserOut, UserUpdate
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get("", response_model=ApiResponse[UserOut])
|
||||
def me(current_user: CurrentUser) -> ApiResponse[UserOut]:
|
||||
return users.get_me(current_user)
|
||||
|
||||
|
||||
@router.patch("/profile", response_model=ApiResponse[UserOut])
|
||||
def update_profile(payload: UserUpdate, current_user: CurrentUser, db: DbSession) -> ApiResponse[UserOut]:
|
||||
return users.update_me(payload, current_user, db)
|
||||
|
||||
|
||||
@router.patch("/password", response_model=ApiResponse[dict[str, bool]])
|
||||
def update_password(payload: PasswordChangeRequest, current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, bool]]:
|
||||
return users.change_password(payload, current_user, db)
|
||||
|
||||
|
||||
@router.get("/gallery")
|
||||
def my_gallery(
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
search: str | None = None,
|
||||
query: str | None = None,
|
||||
search_scope: str = Query(default="all", pattern="^(title|tags|ocr|all)$"),
|
||||
sort: str = Query(default="recent", pattern="^(recent|updated)$"),
|
||||
is_favorite: bool | None = None,
|
||||
content_type: str | None = None,
|
||||
include_total: bool = Query(default=True),
|
||||
):
|
||||
return gallery.list_gallery(
|
||||
current_user=current_user,
|
||||
db=db,
|
||||
page=page,
|
||||
limit=limit,
|
||||
search=search,
|
||||
query=query,
|
||||
search_scope=search_scope,
|
||||
sort=sort,
|
||||
is_favorite=is_favorite,
|
||||
content_type=content_type,
|
||||
include_total=include_total,
|
||||
)
|
||||
|
||||
|
||||
@router.get("/novels")
|
||||
def my_novels(
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
search: str | None = None,
|
||||
is_favorite: bool | None = None,
|
||||
):
|
||||
return novels.list_novels(current_user=current_user, db=db, page=page, limit=limit, search=search, is_favorite=is_favorite)
|
||||
|
||||
|
||||
@router.get("/alerts")
|
||||
def my_alerts(
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
unread_only: bool = Query(default=False),
|
||||
limit: int = Query(default=50, ge=1, le=200),
|
||||
):
|
||||
return follows.list_alerts(current_user=current_user, db=db, unread_only=unread_only, limit=limit)
|
||||
|
||||
|
||||
@router.get("/devices")
|
||||
def my_push_devices(current_user: CurrentUser, db: DbSession):
|
||||
return push.list_devices(current_user=current_user, db=db)
|
||||
@@ -0,0 +1,461 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
import hashlib
|
||||
from pathlib import Path
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Query, status
|
||||
from fastapi.responses import FileResponse
|
||||
from pydantic import BaseModel, Field, model_validator
|
||||
from sqlalchemy import func, select
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.core.config import settings
|
||||
from sakura_cloud.models.file import FileBlob, UserFile
|
||||
from sakura_cloud.models.mixins import utc_now
|
||||
from sakura_cloud.models.novel import Novel
|
||||
from sakura_cloud.schemas.common import ApiResponse, PageResponse, Pagination
|
||||
from sakura_cloud.schemas.novel import (
|
||||
BookmarkUpdate,
|
||||
NovelOut,
|
||||
NovelSeriesGroup,
|
||||
NovelViewUpdate,
|
||||
ReadingProgressUpdate,
|
||||
)
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
class NovelBatchDeleteRequest(BaseModel):
|
||||
ids: list[str] = Field(default_factory=list, max_length=200)
|
||||
series_ids: list[str] = Field(default_factory=list, max_length=50)
|
||||
|
||||
@model_validator(mode="after")
|
||||
def normalize_targets(self) -> "NovelBatchDeleteRequest":
|
||||
self.ids = [item.strip() for item in self.ids if item and item.strip()]
|
||||
self.series_ids = [item.strip() for item in self.series_ids if item and item.strip()]
|
||||
return self
|
||||
|
||||
|
||||
class OnlineNovelImportRequest(BaseModel):
|
||||
source_platform: str = Field(max_length=20)
|
||||
title: str = Field(min_length=1, max_length=500)
|
||||
author: str | None = Field(default=None, max_length=200)
|
||||
detail_url: str = Field(min_length=1, max_length=2048)
|
||||
cover_url: str | None = Field(default=None, max_length=2048)
|
||||
content: str = Field(min_length=1, max_length=2_000_000)
|
||||
tags: list[str] = Field(default_factory=list, max_length=50)
|
||||
|
||||
|
||||
def _latest_non_null(values: list[datetime | None]) -> datetime | None:
|
||||
normalized = [value for value in values if value is not None]
|
||||
return max(normalized) if normalized else None
|
||||
|
||||
|
||||
def _series_group_from_items(series_id: str, items: list[Novel], *, include_chapters: bool = True) -> NovelSeriesGroup:
|
||||
sorted_items = sorted(items, key=lambda item: (item.chapter_order, item.updated_at))
|
||||
first = sorted_items[0]
|
||||
return NovelSeriesGroup(
|
||||
series_id=series_id,
|
||||
series_title=first.series_title or first.title,
|
||||
author=first.author,
|
||||
chapter_count=len(sorted_items),
|
||||
cover_path=first.cover_path,
|
||||
last_read_at=_latest_non_null([item.last_read_at for item in sorted_items]),
|
||||
last_viewed_at=_latest_non_null([item.last_viewed_at for item in sorted_items]),
|
||||
chapters=[NovelOut.model_validate(item) for item in sorted_items] if include_chapters else [],
|
||||
)
|
||||
|
||||
|
||||
def _resolve_novel_storage_path(novel: Novel, db: DbSession) -> Path:
|
||||
path = Path(novel.file_path or "")
|
||||
if path.is_file():
|
||||
return path
|
||||
|
||||
if novel.file_id:
|
||||
user_file = db.get(UserFile, novel.file_id)
|
||||
if user_file is not None:
|
||||
blob = db.get(FileBlob, user_file.file_sha256)
|
||||
if blob is not None:
|
||||
blob_path = Path(blob.storage_path)
|
||||
if blob_path.is_file():
|
||||
novel.file_path = blob.storage_path
|
||||
novel.file_size = blob.file_size
|
||||
if not novel.cover_path:
|
||||
novel.cover_path = blob.thumbnail_path
|
||||
db.commit()
|
||||
db.refresh(novel)
|
||||
return blob_path
|
||||
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel file missing from storage")
|
||||
|
||||
|
||||
def _online_source_id(detail_url: str) -> str:
|
||||
return hashlib.sha256(detail_url.encode("utf-8")).hexdigest()[:32]
|
||||
|
||||
|
||||
def _write_online_novel_file(user_id: str, source_id: str, content: str) -> tuple[str, str, int]:
|
||||
data = content.encode("utf-8")
|
||||
sha256 = hashlib.sha256(data).hexdigest()
|
||||
path = Path(settings.storage_root) / "online_imports" / "novels" / user_id
|
||||
path.mkdir(parents=True, exist_ok=True)
|
||||
target = path / f"{source_id}-{sha256[:12]}.txt"
|
||||
if not target.exists():
|
||||
target.write_bytes(data)
|
||||
return str(target), sha256, len(data)
|
||||
|
||||
|
||||
def _ensure_storage_quota(current_user: CurrentUser, incoming_size: int) -> None:
|
||||
size = max(0, incoming_size)
|
||||
if size and current_user.storage_used + size > current_user.storage_limit:
|
||||
raise HTTPException(status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, detail="Storage quota exceeded")
|
||||
|
||||
|
||||
@router.get("", response_model=ApiResponse[PageResponse[NovelOut]])
|
||||
def list_novels(
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
page: int = Query(default=1, ge=1),
|
||||
limit: int = Query(default=30, ge=1, le=100),
|
||||
search: str | None = None,
|
||||
is_favorite: bool | None = None,
|
||||
) -> ApiResponse[PageResponse[NovelOut]]:
|
||||
query = select(Novel).where(Novel.user_id == current_user.id)
|
||||
count_query = select(func.count()).select_from(Novel).where(Novel.user_id == current_user.id)
|
||||
if search:
|
||||
if db.bind is not None and db.bind.dialect.name == "postgresql":
|
||||
vector = func.to_tsvector("simple", func.concat_ws(" ", Novel.title, Novel.author, Novel.description))
|
||||
condition = vector.op("@@")(func.plainto_tsquery("simple", search))
|
||||
else:
|
||||
condition = Novel.title.ilike(f"%{search}%") | Novel.author.ilike(f"%{search}%")
|
||||
query = query.where(condition)
|
||||
count_query = count_query.where(condition)
|
||||
if is_favorite is not None:
|
||||
query = query.where(Novel.is_favorite == is_favorite)
|
||||
count_query = count_query.where(Novel.is_favorite == is_favorite)
|
||||
total = int(db.scalar(count_query) or 0)
|
||||
rows = db.scalars(
|
||||
query.order_by(Novel.last_viewed_at.desc().nullslast(), Novel.updated_at.desc())
|
||||
.offset((page - 1) * limit)
|
||||
.limit(limit)
|
||||
).all()
|
||||
data = PageResponse(
|
||||
items=[NovelOut.model_validate(row) for row in rows],
|
||||
pagination=Pagination(page=page, limit=limit, total=total, pages=math.ceil(total / limit) if total else 0),
|
||||
)
|
||||
return ApiResponse(data=data)
|
||||
|
||||
|
||||
@router.get("/continue-reading", response_model=ApiResponse[list[NovelOut]])
|
||||
def continue_reading(current_user: CurrentUser, db: DbSession) -> ApiResponse[list[NovelOut]]:
|
||||
rows = db.scalars(
|
||||
select(Novel)
|
||||
.where(Novel.user_id == current_user.id, Novel.last_read_at.is_not(None))
|
||||
.order_by(Novel.last_read_at.desc())
|
||||
.limit(20)
|
||||
).all()
|
||||
return ApiResponse(data=[NovelOut.model_validate(row) for row in rows])
|
||||
|
||||
|
||||
@router.get("/recent", response_model=ApiResponse[list[NovelOut]])
|
||||
def recent_novels(
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
limit: int = Query(default=20, ge=1, le=100),
|
||||
) -> ApiResponse[list[NovelOut]]:
|
||||
rows = db.scalars(
|
||||
select(Novel)
|
||||
.where(Novel.user_id == current_user.id, Novel.last_viewed_at.is_not(None))
|
||||
.order_by(Novel.last_viewed_at.desc())
|
||||
.limit(limit)
|
||||
).all()
|
||||
return ApiResponse(data=[NovelOut.model_validate(row) for row in rows])
|
||||
|
||||
|
||||
@router.get("/series", response_model=ApiResponse[list[NovelSeriesGroup]])
|
||||
def list_novel_series(
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
include_chapters: bool = Query(default=True),
|
||||
) -> ApiResponse[list[NovelSeriesGroup]]:
|
||||
# Mobile shelf uses include_chapters=false to avoid loading every chapter for every series.
|
||||
# The exact series catalog is fetched later by /series/{series_id}.
|
||||
if not include_chapters:
|
||||
rows = db.execute(
|
||||
select(
|
||||
Novel.series_id,
|
||||
func.min(Novel.series_title),
|
||||
func.min(Novel.author),
|
||||
func.count(Novel.id),
|
||||
func.min(Novel.cover_path),
|
||||
func.max(Novel.last_read_at),
|
||||
func.max(Novel.last_viewed_at),
|
||||
func.max(Novel.updated_at),
|
||||
)
|
||||
.where(Novel.user_id == current_user.id, Novel.series_id.is_not(None))
|
||||
.group_by(Novel.series_id)
|
||||
.order_by(func.max(Novel.last_viewed_at).desc().nullslast(), func.max(Novel.updated_at).desc())
|
||||
).all()
|
||||
return ApiResponse(
|
||||
data=[
|
||||
NovelSeriesGroup(
|
||||
series_id=str(row[0]),
|
||||
series_title=str(row[1] or "Untitled series"),
|
||||
author=row[2],
|
||||
chapter_count=int(row[3] or 0),
|
||||
cover_path=row[4],
|
||||
last_read_at=row[5],
|
||||
last_viewed_at=row[6],
|
||||
chapters=[],
|
||||
)
|
||||
for row in rows
|
||||
if row[0]
|
||||
]
|
||||
)
|
||||
|
||||
rows = db.scalars(
|
||||
select(Novel)
|
||||
.where(Novel.user_id == current_user.id, Novel.series_id.is_not(None))
|
||||
.order_by(Novel.series_title.asc(), Novel.chapter_order.asc(), Novel.updated_at.desc())
|
||||
).all()
|
||||
groups: dict[str, list[Novel]] = {}
|
||||
for row in rows:
|
||||
if not row.series_id:
|
||||
continue
|
||||
groups.setdefault(row.series_id, []).append(row)
|
||||
data = []
|
||||
for series_id, items in groups.items():
|
||||
data.append(_series_group_from_items(series_id, items, include_chapters=include_chapters))
|
||||
data.sort(key=lambda item: item.last_viewed_at or item.last_read_at or datetime.min.replace(tzinfo=timezone.utc), reverse=True)
|
||||
return ApiResponse(data=data)
|
||||
|
||||
|
||||
@router.get("/series/{series_id}", response_model=ApiResponse[NovelSeriesGroup])
|
||||
def get_novel_series(series_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[NovelSeriesGroup]:
|
||||
rows = db.scalars(
|
||||
select(Novel)
|
||||
.where(
|
||||
Novel.user_id == current_user.id,
|
||||
Novel.series_id == series_id,
|
||||
)
|
||||
.order_by(Novel.chapter_order.asc(), Novel.updated_at.desc())
|
||||
).all()
|
||||
if not rows:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel series not found")
|
||||
return ApiResponse(data=_series_group_from_items(series_id, rows, include_chapters=True))
|
||||
|
||||
|
||||
@router.post("/import-online", response_model=ApiResponse[NovelOut], status_code=status.HTTP_201_CREATED)
|
||||
def import_online_novel(
|
||||
payload: OnlineNovelImportRequest,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[NovelOut]:
|
||||
source_id = _online_source_id(payload.detail_url)
|
||||
existing = db.scalar(
|
||||
select(Novel).where(
|
||||
Novel.user_id == current_user.id,
|
||||
Novel.source_platform == payload.source_platform,
|
||||
Novel.source_id == source_id,
|
||||
)
|
||||
)
|
||||
if existing is not None:
|
||||
return ApiResponse(data=NovelOut.model_validate(existing))
|
||||
|
||||
storage_path, sha256, file_size = _write_online_novel_file(current_user.id, source_id, payload.content)
|
||||
blob = db.get(FileBlob, sha256)
|
||||
if blob is None:
|
||||
blob = FileBlob(
|
||||
sha256=sha256,
|
||||
storage_path=storage_path,
|
||||
thumbnail_path=payload.cover_url,
|
||||
file_size=file_size,
|
||||
mime_type="text/plain",
|
||||
)
|
||||
db.add(blob)
|
||||
|
||||
user_file = db.scalar(select(UserFile).where(UserFile.user_id == current_user.id, UserFile.file_sha256 == sha256))
|
||||
if user_file is None:
|
||||
_ensure_storage_quota(current_user, file_size)
|
||||
user_file = UserFile(
|
||||
user_id=current_user.id,
|
||||
file_sha256=sha256,
|
||||
original_name=f"{payload.title[:80]}.txt",
|
||||
)
|
||||
db.add(user_file)
|
||||
current_user.storage_used += file_size
|
||||
db.flush()
|
||||
|
||||
novel = Novel(
|
||||
user_id=current_user.id,
|
||||
file_id=user_file.id,
|
||||
source_id=source_id,
|
||||
source_platform=payload.source_platform,
|
||||
title=payload.title.strip(),
|
||||
author=payload.author,
|
||||
file_path=storage_path,
|
||||
file_size=file_size,
|
||||
cover_path=payload.cover_url,
|
||||
word_count=len(payload.content),
|
||||
tags=payload.tags,
|
||||
description=payload.detail_url,
|
||||
)
|
||||
db.add(novel)
|
||||
db.commit()
|
||||
db.refresh(novel)
|
||||
return ApiResponse(code=201, message="created", data=NovelOut.model_validate(novel))
|
||||
|
||||
|
||||
@router.get("/{novel_id}/content")
|
||||
def get_novel_content(novel_id: str, current_user: CurrentUser, db: DbSession) -> FileResponse:
|
||||
novel = db.get(Novel, novel_id)
|
||||
if novel is None or novel.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found")
|
||||
path = _resolve_novel_storage_path(novel, db)
|
||||
novel.last_viewed_at = utc_now()
|
||||
db.commit()
|
||||
return FileResponse(path, media_type="text/plain", filename=path.name)
|
||||
|
||||
|
||||
@router.get("/{novel_id}", response_model=ApiResponse[NovelOut])
|
||||
def get_novel(novel_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[NovelOut]:
|
||||
novel = db.get(Novel, novel_id)
|
||||
if novel is None or novel.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found")
|
||||
novel.last_viewed_at = utc_now()
|
||||
db.commit()
|
||||
db.refresh(novel)
|
||||
return ApiResponse(data=NovelOut.model_validate(novel))
|
||||
|
||||
|
||||
@router.delete("/{novel_id}", response_model=ApiResponse[dict[str, bool]])
|
||||
def delete_novel(novel_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, bool]]:
|
||||
novel = db.get(Novel, novel_id)
|
||||
if novel is None or novel.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found")
|
||||
current_user.storage_used = max(0, current_user.storage_used - max(0, novel.file_size))
|
||||
db.delete(novel)
|
||||
db.commit()
|
||||
return ApiResponse(data={"ok": True})
|
||||
|
||||
|
||||
@router.post("/batch-delete", response_model=ApiResponse[dict[str, int]])
|
||||
def batch_delete_novels(
|
||||
payload: NovelBatchDeleteRequest,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[dict[str, int]]:
|
||||
ids = sorted({item.strip() for item in payload.ids if item.strip()})
|
||||
series_ids = sorted({item.strip() for item in payload.series_ids if item.strip()})
|
||||
if not ids and not series_ids:
|
||||
return ApiResponse(data={"deleted": 0})
|
||||
|
||||
rows: list[Novel] = []
|
||||
if ids:
|
||||
rows.extend(
|
||||
db.scalars(
|
||||
select(Novel).where(
|
||||
Novel.user_id == current_user.id,
|
||||
Novel.id.in_(ids),
|
||||
)
|
||||
).all()
|
||||
)
|
||||
if series_ids:
|
||||
rows.extend(
|
||||
db.scalars(
|
||||
select(Novel).where(
|
||||
Novel.user_id == current_user.id,
|
||||
Novel.series_id.in_(series_ids),
|
||||
)
|
||||
).all()
|
||||
)
|
||||
|
||||
deleted = 0
|
||||
released = 0
|
||||
seen: set[str] = set()
|
||||
for novel in rows:
|
||||
if novel.id in seen:
|
||||
continue
|
||||
seen.add(novel.id)
|
||||
released += max(0, novel.file_size)
|
||||
db.delete(novel)
|
||||
deleted += 1
|
||||
if deleted:
|
||||
current_user.storage_used = max(0, current_user.storage_used - released)
|
||||
db.commit()
|
||||
return ApiResponse(data={"deleted": deleted})
|
||||
|
||||
|
||||
@router.post("/{novel_id}/favorite", response_model=ApiResponse[NovelOut])
|
||||
def favorite_novel(novel_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[NovelOut]:
|
||||
novel = db.get(Novel, novel_id)
|
||||
if novel is None or novel.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found")
|
||||
novel.is_favorite = True
|
||||
db.commit()
|
||||
db.refresh(novel)
|
||||
return ApiResponse(data=NovelOut.model_validate(novel))
|
||||
|
||||
|
||||
@router.delete("/{novel_id}/favorite", response_model=ApiResponse[NovelOut])
|
||||
def unfavorite_novel(novel_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[NovelOut]:
|
||||
novel = db.get(Novel, novel_id)
|
||||
if novel is None or novel.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found")
|
||||
novel.is_favorite = False
|
||||
db.commit()
|
||||
db.refresh(novel)
|
||||
return ApiResponse(data=NovelOut.model_validate(novel))
|
||||
|
||||
|
||||
@router.post("/{novel_id}/progress", response_model=ApiResponse[NovelOut])
|
||||
def update_progress(
|
||||
novel_id: str,
|
||||
payload: ReadingProgressUpdate,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[NovelOut]:
|
||||
novel = db.get(Novel, novel_id)
|
||||
if novel is None or novel.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found")
|
||||
novel.current_page = payload.current_page
|
||||
novel.last_read_at = utc_now()
|
||||
novel.last_viewed_at = novel.last_read_at
|
||||
db.commit()
|
||||
db.refresh(novel)
|
||||
return ApiResponse(data=NovelOut.model_validate(novel))
|
||||
|
||||
|
||||
@router.post("/{novel_id}/bookmark", response_model=ApiResponse[NovelOut])
|
||||
def update_bookmark(
|
||||
novel_id: str,
|
||||
payload: BookmarkUpdate,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[NovelOut]:
|
||||
novel = db.get(Novel, novel_id)
|
||||
if novel is None or novel.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found")
|
||||
novel.bookmark = payload.bookmark
|
||||
db.commit()
|
||||
db.refresh(novel)
|
||||
return ApiResponse(data=NovelOut.model_validate(novel))
|
||||
|
||||
|
||||
@router.post("/{novel_id}/view", response_model=ApiResponse[NovelOut])
|
||||
def mark_novel_viewed(
|
||||
novel_id: str,
|
||||
payload: NovelViewUpdate,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[NovelOut]:
|
||||
novel = db.get(Novel, novel_id)
|
||||
if novel is None or novel.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found")
|
||||
if payload.viewed:
|
||||
novel.last_viewed_at = utc_now()
|
||||
db.commit()
|
||||
db.refresh(novel)
|
||||
return ApiResponse(data=NovelOut.model_validate(novel))
|
||||
@@ -0,0 +1,100 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Query, status
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
from sakura_cloud.services.online_search import OnlineSearchError, parse_source_payload, search_sources
|
||||
from sakura_cloud.services.online_search_engine import OnlineSearchEngine, SearchEngineError
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
class OnlineSearchRequest(BaseModel):
|
||||
query: str = Field(min_length=1, max_length=80)
|
||||
sources: Any
|
||||
limit_sources: int = Field(default=30, ge=1, le=80)
|
||||
per_source_limit: int = Field(default=20, ge=1, le=50)
|
||||
|
||||
|
||||
class OnlineSearchResult(BaseModel):
|
||||
source_name: str
|
||||
source_url: str
|
||||
title: str
|
||||
author: str | None = None
|
||||
cover_url: str | None = None
|
||||
detail_url: str
|
||||
kind: str
|
||||
|
||||
|
||||
class OnlineParseRequest(BaseModel):
|
||||
detail_url: str = Field(min_length=1, max_length=2048)
|
||||
|
||||
|
||||
class OnlineParsedChapter(BaseModel):
|
||||
name: str
|
||||
url: str | None = None
|
||||
content: str | None = None
|
||||
images: list[str] = Field(default_factory=list)
|
||||
|
||||
|
||||
class OnlineParsedContent(BaseModel):
|
||||
title: str
|
||||
cover: str | None = None
|
||||
kind: str
|
||||
chapters: list[OnlineParsedChapter]
|
||||
|
||||
|
||||
@router.post("", response_model=ApiResponse[list[OnlineSearchResult]])
|
||||
def online_search(
|
||||
payload: OnlineSearchRequest,
|
||||
current_user: CurrentUser,
|
||||
mode: str = Query(pattern="^(novel|manga)$"),
|
||||
) -> ApiResponse[list[OnlineSearchResult]]:
|
||||
try:
|
||||
sources = parse_source_payload(payload.sources)
|
||||
rows = search_sources(
|
||||
sources,
|
||||
payload.query.strip(),
|
||||
mode=mode,
|
||||
limit_sources=payload.limit_sources,
|
||||
per_source_limit=payload.per_source_limit,
|
||||
)
|
||||
except OnlineSearchError as error:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(error)) from error
|
||||
except ValueError as error:
|
||||
raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Invalid source JSON") from error
|
||||
return ApiResponse(data=[OnlineSearchResult(**item.__dict__) for item in rows])
|
||||
|
||||
|
||||
@router.post("/parse", response_model=ApiResponse[OnlineParsedContent])
|
||||
def parse_online_content(
|
||||
payload: OnlineParseRequest,
|
||||
current_user: CurrentUser,
|
||||
mode: str = Query(pattern="^(novel|manga)$"),
|
||||
) -> ApiResponse[OnlineParsedContent]:
|
||||
engine = OnlineSearchEngine(timeout=12.0)
|
||||
try:
|
||||
if mode == "manga":
|
||||
parsed = engine.parse_comic(payload.detail_url)
|
||||
chapters = [
|
||||
OnlineParsedChapter(name=item.name, url=item.url, images=list(item.images))
|
||||
for item in parsed.chapters
|
||||
]
|
||||
data = OnlineParsedContent(title=parsed.title, cover=parsed.cover, kind="manga", chapters=chapters)
|
||||
else:
|
||||
parsed = engine.parse_novel(payload.detail_url)
|
||||
chapters = [
|
||||
OnlineParsedChapter(name=item.name, url=item.url, content=item.content)
|
||||
for item in parsed.chapters
|
||||
]
|
||||
data = OnlineParsedContent(title=parsed.title, cover=parsed.cover, kind="novel", chapters=chapters)
|
||||
except SearchEngineError as error:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(error)) from error
|
||||
except Exception as error:
|
||||
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail="Online source parse failed") from error
|
||||
return ApiResponse(data=data)
|
||||
@@ -0,0 +1,76 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import APIRouter, status
|
||||
from sqlalchemy import select
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.models.mixins import utc_now
|
||||
from sakura_cloud.models.push import PushDeviceToken
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
from sakura_cloud.schemas.push import PushDeviceTokenOut, PushTokenRegister, PushTokenUnregister
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.post("/register-token", response_model=ApiResponse[PushDeviceTokenOut], status_code=status.HTTP_201_CREATED)
|
||||
def register_token(
|
||||
payload: PushTokenRegister,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[PushDeviceTokenOut]:
|
||||
row = db.scalar(
|
||||
select(PushDeviceToken).where(
|
||||
PushDeviceToken.user_id == current_user.id,
|
||||
PushDeviceToken.device_id == payload.device_id,
|
||||
)
|
||||
)
|
||||
now = utc_now()
|
||||
if row is None:
|
||||
row = PushDeviceToken(
|
||||
user_id=current_user.id,
|
||||
device_id=payload.device_id,
|
||||
platform=payload.platform,
|
||||
fcm_token=payload.fcm_token,
|
||||
is_active=True,
|
||||
last_seen_at=now,
|
||||
)
|
||||
db.add(row)
|
||||
else:
|
||||
row.platform = payload.platform
|
||||
row.fcm_token = payload.fcm_token
|
||||
row.is_active = True
|
||||
row.last_seen_at = now
|
||||
|
||||
db.commit()
|
||||
db.refresh(row)
|
||||
return ApiResponse(code=201, message="registered", data=PushDeviceTokenOut.model_validate(row))
|
||||
|
||||
|
||||
@router.post("/unregister-token", response_model=ApiResponse[dict[str, bool]])
|
||||
def unregister_token(
|
||||
payload: PushTokenUnregister,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[dict[str, bool]]:
|
||||
row = db.scalar(
|
||||
select(PushDeviceToken).where(
|
||||
PushDeviceToken.user_id == current_user.id,
|
||||
PushDeviceToken.device_id == payload.device_id,
|
||||
)
|
||||
)
|
||||
if row is not None:
|
||||
row.is_active = False
|
||||
row.last_seen_at = utc_now()
|
||||
db.commit()
|
||||
return ApiResponse(message="unregistered", data={"ok": True})
|
||||
|
||||
|
||||
@router.get("/devices", response_model=ApiResponse[list[PushDeviceTokenOut]])
|
||||
def list_devices(current_user: CurrentUser, db: DbSession) -> ApiResponse[list[PushDeviceTokenOut]]:
|
||||
rows = db.scalars(
|
||||
select(PushDeviceToken)
|
||||
.where(PushDeviceToken.user_id == current_user.id)
|
||||
.order_by(PushDeviceToken.last_seen_at.desc().nullslast(), PushDeviceToken.updated_at.desc())
|
||||
).all()
|
||||
return ApiResponse(data=[PushDeviceTokenOut.model_validate(row) for row in rows])
|
||||
@@ -0,0 +1,171 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from pydantic import BaseModel, Field
|
||||
from fastapi import APIRouter, BackgroundTasks, HTTPException, status
|
||||
from sqlalchemy import select
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.models.artwork import Artwork
|
||||
from sakura_cloud.models.device import Device
|
||||
from sakura_cloud.models.file import FileBlob, UserFile
|
||||
from sakura_cloud.models.mixins import utc_now
|
||||
from sakura_cloud.models.novel import Novel
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
from sakura_cloud.schemas.device import DeviceOut, DeviceRegister
|
||||
from sakura_cloud.schemas.gallery import ArtworkOut
|
||||
from sakura_cloud.schemas.novel import NovelOut
|
||||
from sakura_cloud.services.ocr import queue_ocr_for_artwork, run_ocr_for_artwork_id
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
class SyncCheckRequest(BaseModel):
|
||||
sha256: str = Field(min_length=64, max_length=64)
|
||||
file_size: int = Field(ge=0)
|
||||
|
||||
|
||||
class SyncMetadataRequest(BaseModel):
|
||||
resource_type: str = Field(pattern="^(artwork|novel)$")
|
||||
file_id: str
|
||||
source_platform: str = Field(max_length=20)
|
||||
source_id: str | None = Field(default=None, max_length=50)
|
||||
content_type: str | None = Field(default=None, max_length=20)
|
||||
title: str = Field(max_length=500)
|
||||
author: str | None = Field(default=None, max_length=200)
|
||||
author_id: str | None = Field(default=None, max_length=50)
|
||||
tags: list[str] = Field(default_factory=list)
|
||||
metadata: dict = Field(default_factory=dict)
|
||||
page_count: int = 1
|
||||
thumbnail_url: str | None = None
|
||||
description: str | None = None
|
||||
word_count: int = 0
|
||||
series_id: str | None = Field(default=None, max_length=50)
|
||||
series_title: str | None = Field(default=None, max_length=500)
|
||||
chapter_title: str | None = Field(default=None, max_length=500)
|
||||
chapter_order: int = 0
|
||||
|
||||
|
||||
@router.post("/check", response_model=ApiResponse[dict[str, bool | str | None]])
|
||||
def check_file(payload: SyncCheckRequest, current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, bool | str | None]]:
|
||||
blob = db.get(FileBlob, payload.sha256)
|
||||
user_file = None
|
||||
if blob is not None:
|
||||
user_file = db.scalar(select(UserFile).where(UserFile.user_id == current_user.id, UserFile.file_sha256 == payload.sha256))
|
||||
return ApiResponse(
|
||||
data={
|
||||
"exists": blob is not None,
|
||||
"owned_by_user": user_file is not None,
|
||||
"file_id": user_file.id if user_file is not None else None,
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@router.post("/metadata", response_model=ApiResponse[ArtworkOut | NovelOut])
|
||||
def sync_metadata(
|
||||
payload: SyncMetadataRequest,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
background_tasks: BackgroundTasks,
|
||||
) -> ApiResponse[ArtworkOut | NovelOut]:
|
||||
user_file = db.get(UserFile, payload.file_id)
|
||||
if user_file is None or user_file.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="File not found")
|
||||
blob = db.get(FileBlob, user_file.file_sha256)
|
||||
if blob is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Blob not found")
|
||||
|
||||
if payload.resource_type == "artwork":
|
||||
artwork = db.scalar(
|
||||
select(Artwork).where(
|
||||
Artwork.user_id == current_user.id,
|
||||
Artwork.file_id == user_file.id,
|
||||
)
|
||||
)
|
||||
if artwork is None:
|
||||
artwork = Artwork(user_id=current_user.id, file_id=user_file.id)
|
||||
db.add(artwork)
|
||||
artwork.source_id = payload.source_id
|
||||
artwork.source_platform = payload.source_platform
|
||||
artwork.content_type = payload.content_type or "illust"
|
||||
artwork.title = payload.title
|
||||
artwork.author = payload.author
|
||||
artwork.author_id = payload.author_id
|
||||
artwork.page_count = payload.page_count
|
||||
artwork.file_path = blob.storage_path
|
||||
artwork.file_size = blob.file_size
|
||||
artwork.thumbnail_path = blob.thumbnail_path or payload.thumbnail_url
|
||||
artwork.mime_type = blob.mime_type
|
||||
artwork.tags = payload.tags
|
||||
artwork.artwork_metadata = payload.metadata
|
||||
db.commit()
|
||||
db.refresh(artwork)
|
||||
if queue_ocr_for_artwork(db, artwork) is not None:
|
||||
background_tasks.add_task(run_ocr_for_artwork_id, artwork.id, current_user.id)
|
||||
return ApiResponse(data=ArtworkOut.model_validate(artwork))
|
||||
|
||||
novel = db.scalar(
|
||||
select(Novel).where(
|
||||
Novel.user_id == current_user.id,
|
||||
Novel.file_id == user_file.id,
|
||||
)
|
||||
)
|
||||
if novel is None and payload.source_id:
|
||||
novel = db.scalar(
|
||||
select(Novel).where(
|
||||
Novel.user_id == current_user.id,
|
||||
Novel.source_platform == payload.source_platform,
|
||||
Novel.source_id == payload.source_id,
|
||||
)
|
||||
)
|
||||
if novel is None:
|
||||
novel = Novel(user_id=current_user.id, file_id=user_file.id)
|
||||
db.add(novel)
|
||||
novel.file_id = user_file.id
|
||||
novel.source_id = payload.source_id
|
||||
novel.source_platform = payload.source_platform
|
||||
novel.title = payload.title
|
||||
novel.author = payload.author
|
||||
novel.series_id = payload.series_id
|
||||
novel.series_title = payload.series_title
|
||||
novel.chapter_title = payload.chapter_title
|
||||
novel.chapter_order = payload.chapter_order
|
||||
novel.description = payload.description
|
||||
novel.file_path = blob.storage_path
|
||||
novel.file_size = blob.file_size
|
||||
novel.word_count = payload.word_count
|
||||
novel.cover_path = blob.thumbnail_path or payload.thumbnail_url
|
||||
novel.tags = payload.tags
|
||||
db.commit()
|
||||
db.refresh(novel)
|
||||
return ApiResponse(data=NovelOut.model_validate(novel))
|
||||
|
||||
|
||||
@router.post("/device", response_model=ApiResponse[DeviceOut])
|
||||
def register_sync_device(payload: DeviceRegister, current_user: CurrentUser, db: DbSession) -> ApiResponse[DeviceOut]:
|
||||
device = Device(
|
||||
user_id=current_user.id,
|
||||
device_name=payload.device_name,
|
||||
device_type=payload.device_type,
|
||||
device_token=payload.device_token,
|
||||
last_active_at=utc_now(),
|
||||
last_sync_at=utc_now(),
|
||||
)
|
||||
db.add(device)
|
||||
db.commit()
|
||||
db.refresh(device)
|
||||
return ApiResponse(data=DeviceOut.model_validate(device))
|
||||
|
||||
|
||||
@router.get("/device/{device_id}", response_model=ApiResponse[dict[str, str | None]])
|
||||
def device_sync_status(device_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, str | None]]:
|
||||
device = db.get(Device, device_id)
|
||||
if device is None or device.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Device not found")
|
||||
return ApiResponse(
|
||||
data={
|
||||
"device_id": device.id,
|
||||
"last_sync_at": device.last_sync_at.isoformat() if device.last_sync_at else None,
|
||||
"status": "idle",
|
||||
}
|
||||
)
|
||||
@@ -0,0 +1,20 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from sqlalchemy import select
|
||||
from fastapi import APIRouter
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.models.artwork import Artwork
|
||||
from sakura_cloud.models.novel import Novel
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get("", response_model=ApiResponse[list[str]])
|
||||
def list_all_tags(current_user: CurrentUser, db: DbSession) -> ApiResponse[list[str]]:
|
||||
artwork_tags = db.scalars(select(Artwork.tags).where(Artwork.user_id == current_user.id)).all()
|
||||
novel_tags = db.scalars(select(Novel.tags).where(Novel.user_id == current_user.id)).all()
|
||||
tags = sorted({tag for row in [*artwork_tags, *novel_tags] for tag in (row or [])})
|
||||
return ApiResponse(data=tags)
|
||||
@@ -0,0 +1,62 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import APIRouter, File, Form, HTTPException, UploadFile, status
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.models.file import UploadSession
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
from sakura_cloud.schemas.upload import (
|
||||
UploadCompleteRequest,
|
||||
UploadCompleteResponse,
|
||||
UploadInitRequest,
|
||||
UploadInitResponse,
|
||||
UploadStatusResponse,
|
||||
)
|
||||
from sakura_cloud.services.storage import append_chunk, complete_upload, init_upload
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.post("/init", response_model=ApiResponse[UploadInitResponse])
|
||||
def upload_init(payload: UploadInitRequest, current_user: CurrentUser, db: DbSession) -> ApiResponse[UploadInitResponse]:
|
||||
return ApiResponse(data=init_upload(payload, current_user, db))
|
||||
|
||||
|
||||
@router.post("/chunk", response_model=ApiResponse[UploadStatusResponse])
|
||||
async def upload_chunk(
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
upload_id: str = Form(...),
|
||||
chunk: UploadFile = File(...),
|
||||
) -> ApiResponse[UploadStatusResponse]:
|
||||
session = await append_chunk(upload_id, chunk, current_user, db)
|
||||
return ApiResponse(data=_status_from_session(session))
|
||||
|
||||
|
||||
@router.post("/complete", response_model=ApiResponse[UploadCompleteResponse])
|
||||
def upload_complete(
|
||||
payload: UploadCompleteRequest,
|
||||
current_user: CurrentUser,
|
||||
db: DbSession,
|
||||
) -> ApiResponse[UploadCompleteResponse]:
|
||||
return ApiResponse(data=complete_upload(payload.upload_id, current_user, db))
|
||||
|
||||
|
||||
@router.get("/status/{upload_id}", response_model=ApiResponse[UploadStatusResponse])
|
||||
def upload_status(upload_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[UploadStatusResponse]:
|
||||
session = db.get(UploadSession, upload_id)
|
||||
if session is None or session.user_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Upload session not found")
|
||||
return ApiResponse(data=_status_from_session(session))
|
||||
|
||||
|
||||
def _status_from_session(session: UploadSession) -> UploadStatusResponse:
|
||||
return UploadStatusResponse(
|
||||
upload_id=session.id,
|
||||
sha256=session.sha256,
|
||||
file_name=session.file_name,
|
||||
file_size=session.file_size,
|
||||
received_size=session.received_size,
|
||||
status=session.status,
|
||||
)
|
||||
@@ -0,0 +1,63 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import APIRouter, HTTPException, status
|
||||
from sqlalchemy import or_, select
|
||||
|
||||
from sakura_cloud.api.deps import CurrentUser, DbSession
|
||||
from sakura_cloud.core.security import hash_password, verify_password
|
||||
from sakura_cloud.models.user import User
|
||||
from sakura_cloud.schemas.common import ApiResponse
|
||||
from sakura_cloud.schemas.user import PasswordChangeRequest, UserOut, UserUpdate
|
||||
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get("/me", response_model=ApiResponse[UserOut])
|
||||
def get_me(current_user: CurrentUser) -> ApiResponse[UserOut]:
|
||||
return ApiResponse(data=UserOut.model_validate(current_user))
|
||||
|
||||
|
||||
@router.put("/me", response_model=ApiResponse[UserOut])
|
||||
def update_me(payload: UserUpdate, current_user: CurrentUser, db: DbSession) -> ApiResponse[UserOut]:
|
||||
if payload.username or payload.email:
|
||||
conditions = []
|
||||
if payload.username:
|
||||
conditions.append(User.username == payload.username)
|
||||
if payload.email:
|
||||
conditions.append(User.email == str(payload.email))
|
||||
exists = db.scalar(select(User).where(or_(*conditions), User.id != current_user.id))
|
||||
if exists is not None:
|
||||
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Username or email already exists")
|
||||
if payload.username is not None:
|
||||
current_user.username = payload.username
|
||||
if payload.email is not None:
|
||||
current_user.email = str(payload.email)
|
||||
if payload.avatar is not None:
|
||||
current_user.avatar = payload.avatar
|
||||
if payload.reminder_enabled is not None:
|
||||
current_user.reminder_enabled = payload.reminder_enabled
|
||||
if payload.reminder_hour is not None:
|
||||
current_user.reminder_hour = payload.reminder_hour
|
||||
if payload.reminder_minute is not None:
|
||||
current_user.reminder_minute = payload.reminder_minute
|
||||
if payload.reminder_timezone is not None:
|
||||
current_user.reminder_timezone = payload.reminder_timezone
|
||||
db.commit()
|
||||
db.refresh(current_user)
|
||||
return ApiResponse(data=UserOut.model_validate(current_user))
|
||||
|
||||
|
||||
@router.post("/me/avatar", response_model=ApiResponse[dict[str, str | None]])
|
||||
def upload_avatar(current_user: CurrentUser) -> ApiResponse[dict[str, str | None]]:
|
||||
return ApiResponse(message="avatar upload placeholder", data={"avatar": current_user.avatar})
|
||||
|
||||
|
||||
@router.put("/me/password", response_model=ApiResponse[dict[str, bool]])
|
||||
def change_password(payload: PasswordChangeRequest, current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, bool]]:
|
||||
if not verify_password(payload.old_password, current_user.password_hash):
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Old password is incorrect")
|
||||
current_user.password_hash = hash_password(payload.new_password)
|
||||
current_user.token_version += 1
|
||||
db.commit()
|
||||
return ApiResponse(data={"ok": True})
|
||||
@@ -0,0 +1,39 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import APIRouter
|
||||
|
||||
from sakura_cloud.api.v1.endpoints import (
|
||||
auth,
|
||||
admin,
|
||||
devices,
|
||||
files,
|
||||
follows,
|
||||
gallery,
|
||||
health,
|
||||
me,
|
||||
novels,
|
||||
online_search,
|
||||
push,
|
||||
sync,
|
||||
tags,
|
||||
upload,
|
||||
users,
|
||||
)
|
||||
|
||||
|
||||
api_router = APIRouter()
|
||||
api_router.include_router(health.router, tags=["health"])
|
||||
api_router.include_router(auth.router, prefix="/auth", tags=["auth"])
|
||||
api_router.include_router(admin.router, prefix="/admin", tags=["admin"])
|
||||
api_router.include_router(users.router, prefix="/users", tags=["users"])
|
||||
api_router.include_router(me.router, prefix="/me", tags=["me"])
|
||||
api_router.include_router(devices.router, prefix="/devices", tags=["devices"])
|
||||
api_router.include_router(upload.router, prefix="/upload", tags=["upload"])
|
||||
api_router.include_router(files.router, prefix="/files", tags=["files"])
|
||||
api_router.include_router(gallery.router, prefix="/gallery", tags=["gallery"])
|
||||
api_router.include_router(novels.router, prefix="/novels", tags=["novels"])
|
||||
api_router.include_router(online_search.router, prefix="/online-search", tags=["online-search"])
|
||||
api_router.include_router(follows.router, prefix="/follows", tags=["follows"])
|
||||
api_router.include_router(push.router, prefix="/push", tags=["push"])
|
||||
api_router.include_router(sync.router, prefix="/sync", tags=["sync"])
|
||||
api_router.include_router(tags.router, prefix="/tags", tags=["tags"])
|
||||
Reference in new issue
Block a user