first commit

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
kunkunxiaomaoandClaude committed 2026-11-16 20:45:22 +08:00
commit 9c5fef1a4d
412 files changed
+94582

No files matched your search

@@ -0,0 +1 @@
"""API endpoint modules."""
+659
View File
@@ -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)]
+120
View File
@@ -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)
+78
View File
@@ -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})
+50
View File
@@ -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"},
)
+208
View File
@@ -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))
+520
View File
@@ -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))
+13
View File
@@ -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"})
+82
View File
@@ -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)
+461
View File
@@ -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)
+76
View File
@@ -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])
+171
View File
@@ -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",
}
)
+20
View File
@@ -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)
+62
View File
@@ -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,
)
+63
View File
@@ -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})