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

+1
View File
@@ -0,0 +1 @@
"""Sakura Cloud backend package."""
+38
View File
@@ -0,0 +1,38 @@
[alembic]
script_location = migrations
prepend_sys_path = ..
version_path_separator = os
sqlalchemy.url = postgresql+psycopg://sakura:sakura@localhost:5432/sakura_cloud
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARN
handlers = console
[logger_sqlalchemy]
level = WARN
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S
+1
View File
@@ -0,0 +1 @@
"""HTTP API package."""
+65
View File
@@ -0,0 +1,65 @@
from __future__ import annotations
from typing import Annotated
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
from sqlalchemy.orm import Session
from sakura_cloud.core.config import settings
from sakura_cloud.core.security import decode_token
from sakura_cloud.db.session import get_db
from sakura_cloud.models.user import User, UserRole
oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"{settings.api_prefix}/auth/login")
DbSession = Annotated[Session, Depends(get_db)]
def get_current_user(token: Annotated[str, Depends(oauth2_scheme)], db: DbSession) -> User:
try:
payload = decode_token(token)
except ValueError as exc:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token") from exc
if payload.get("type") != "access":
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token type")
user_id = payload.get("sub")
if not user_id:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token subject")
user = db.get(User, str(user_id))
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(payload.get("tv") or 0) != int(user.token_version or 0):
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Token has been revoked")
return user
CurrentUser = Annotated[User, Depends(get_current_user)]
def require_admin_user(current_user: CurrentUser) -> User:
if current_user.role not in {UserRole.ADMIN, UserRole.SUPER_ADMIN}:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Admin privileges required")
return current_user
AdminUser = Annotated[User, Depends(require_admin_user)]
def require_super_admin_user(current_user: CurrentUser) -> User:
if current_user.role != UserRole.SUPER_ADMIN:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Super admin privileges required")
return current_user
SuperAdminUser = Annotated[User, Depends(require_super_admin_user)]
def assert_owner_or_admin(resource_user_id: str, current_user: User) -> None:
if resource_user_id == current_user.id:
return
if current_user.role in {UserRole.ADMIN, UserRole.SUPER_ADMIN}:
return
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Resource not found")
+87
View File
@@ -0,0 +1,87 @@
from __future__ import annotations
import time
import uuid
from collections.abc import Callable
from urllib.parse import urlparse
from fastapi import Request, Response
from loguru import logger
from sakura_cloud.core.config import settings
def _origin(value: str) -> str:
parsed = urlparse(value)
if not parsed.scheme or not parsed.netloc:
return ""
return f"{parsed.scheme}://{parsed.netloc}"
def _csp_connect_sources(request: Request) -> str:
sources = {"'self'"}
request_origin = _origin(str(request.base_url))
if request_origin:
sources.add(request_origin)
for origin in settings.cors_origins:
if origin == "*":
continue
parsed_origin = _origin(origin)
if parsed_origin:
sources.add(parsed_origin)
if settings.debug:
sources.update(
{
"http://localhost:*",
"http://127.0.0.1:*",
"ws://localhost:5173",
"ws://localhost:5174",
"ws://127.0.0.1:5173",
"ws://127.0.0.1:5174",
}
)
return " ".join(sorted(sources))
async def trace_logging_middleware(request: Request, call_next: Callable) -> Response:
trace_id = request.headers.get("X-Trace-Id") or str(uuid.uuid4())
start = time.perf_counter()
try:
response = await call_next(request)
except Exception:
logger.bind(trace_id=trace_id, kind="api").exception("request failed")
raise
elapsed_ms = int((time.perf_counter() - start) * 1000)
response.headers["X-Trace-Id"] = trace_id
logger.bind(trace_id=trace_id, kind="api").info(
"{method} {path} {status} {elapsed_ms}ms",
method=request.method,
path=request.url.path,
status=response.status_code,
elapsed_ms=elapsed_ms,
)
return response
async def security_headers_middleware(request: Request, call_next: Callable) -> Response:
response = await call_next(request)
response.headers.setdefault("X-Content-Type-Options", "nosniff")
response.headers.setdefault("X-Frame-Options", "DENY")
response.headers.setdefault("Referrer-Policy", "no-referrer")
response.headers.setdefault("Permissions-Policy", "camera=(), microphone=(), geolocation=(), payment=()")
csp = (
"default-src 'self'; "
"base-uri 'self'; "
"object-src 'none'; "
"frame-ancestors 'none'; "
"img-src 'self' data: blob: https: http:; "
"font-src 'self' data:; "
"style-src 'self' 'unsafe-inline'; "
"script-src 'self'; "
f"connect-src {_csp_connect_sources(request)}"
)
response.headers.setdefault(
"Content-Security-Policy",
csp,
)
return response
+1
View File
@@ -0,0 +1 @@
"""Versioned API routes."""
@@ -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})
+39
View File
@@ -0,0 +1,39 @@
from __future__ import annotations
from fastapi import APIRouter
from sakura_cloud.api.v1.endpoints import (
auth,
admin,
devices,
files,
follows,
gallery,
health,
me,
novels,
online_search,
push,
sync,
tags,
upload,
users,
)
api_router = APIRouter()
api_router.include_router(health.router, tags=["health"])
api_router.include_router(auth.router, prefix="/auth", tags=["auth"])
api_router.include_router(admin.router, prefix="/admin", tags=["admin"])
api_router.include_router(users.router, prefix="/users", tags=["users"])
api_router.include_router(me.router, prefix="/me", tags=["me"])
api_router.include_router(devices.router, prefix="/devices", tags=["devices"])
api_router.include_router(upload.router, prefix="/upload", tags=["upload"])
api_router.include_router(files.router, prefix="/files", tags=["files"])
api_router.include_router(gallery.router, prefix="/gallery", tags=["gallery"])
api_router.include_router(novels.router, prefix="/novels", tags=["novels"])
api_router.include_router(online_search.router, prefix="/online-search", tags=["online-search"])
api_router.include_router(follows.router, prefix="/follows", tags=["follows"])
api_router.include_router(push.router, prefix="/push", tags=["push"])
api_router.include_router(sync.router, prefix="/sync", tags=["sync"])
api_router.include_router(tags.router, prefix="/tags", tags=["tags"])
+1
View File
@@ -0,0 +1 @@
"""Core configuration and security helpers."""
+149
View File
@@ -0,0 +1,149 @@
from __future__ import annotations
from functools import lru_cache
from typing import Any
from pydantic import Field, field_validator, model_validator
from pydantic_settings import BaseSettings, SettingsConfigDict
class Settings(BaseSettings):
app_name: str = "Sakura Cloud"
app_version: str = "0.1.0"
api_prefix: str = "/api/v1"
debug: bool = False
environment: str = Field(default="development", validation_alias="SAKURA_ENV")
auto_migrate_on_startup: bool = False
database_url: str = "postgresql+psycopg://sakura:sakura@localhost:5432/sakura_cloud"
redis_url: str = "redis://localhost:6379/0"
storage_root: str = "data/sakura"
log_dir: str = "data/sakura/logs"
minio_endpoint: str = "localhost:9000"
minio_access_key: str = "minioadmin"
minio_secret_key: str = "minioadmin"
minio_bucket: str = "sakura-cloud"
minio_secure: bool = False
jwt_secret_key: str = Field(default="change-this-secret-in-production", min_length=16)
jwt_algorithm: str = "HS256"
jwt_issuer: str = "sakura-cloud"
jwt_audience: str = "sakura-cloud"
jwt_access_token_expire_hours: int = 24
jwt_refresh_token_expire_days: int = 30
default_storage_limit_gb: int = 5
max_upload_size_mb: int = 100
max_video_upload_size_mb: int = 2048
video_storage_limit_gb: int = 30
max_batch_size_mb: int = 500
allowed_upload_mime_types: list[str] = [
"image/jpeg",
"image/png",
"image/webp",
"image/gif",
"video/mp4",
"video/webm",
"video/quicktime",
"video/x-m4v",
"video/x-msvideo",
"text/plain",
]
allowed_external_url_domains: list[str] = [
"pixiv.net",
"www.pixiv.net",
"i.pximg.net",
"pximg.net",
"x.com",
"twitter.com",
]
upload_chunk_size: int = 5 * 1024 * 1024
temp_upload_ttl_hours: int = 24
thumbnail_max_size: int = 640
thumbnail_quality: int = 82
fcm_enabled: bool = True
firebase_credentials_path: str = ""
firebase_credentials_json: str = ""
ocr_enabled: bool = False
ocr_language: str = "ch"
ocr_max_image_dimension: int = 1800
ocr_max_attempts: int = 3
ocr_max_concurrency: int = 1
cors_origins: list[str] = [
"http://localhost:5173",
"http://127.0.0.1:5173",
"http://localhost:5174",
"http://127.0.0.1:5174",
"http://localhost:3000",
"http://127.0.0.1:3000",
"app://.",
]
admin_login_rate_limit_per_minute: int = 5
admin_frontend_enabled: bool = True
model_config = SettingsConfigDict(
env_file=".env",
env_file_encoding="utf-8",
extra="ignore",
)
@field_validator("cors_origins", mode="before")
@classmethod
def parse_cors_origins(cls, value: Any) -> list[str]:
if isinstance(value, str):
text = value.strip()
if text.startswith("["):
import json
return list(json.loads(text))
return [item.strip() for item in text.split(",") if item.strip()]
return value
@field_validator("allowed_upload_mime_types", "allowed_external_url_domains", mode="before")
@classmethod
def parse_string_list(cls, value: Any) -> list[str]:
if isinstance(value, str):
text = value.strip()
if text.startswith("["):
import json
return list(json.loads(text))
return [item.strip() for item in text.split(",") if item.strip()]
return value
@model_validator(mode="after")
def reject_insecure_production_defaults(self) -> "Settings":
if self.environment.lower() not in {"prod", "production"}:
return self
insecure: list[str] = []
if self.jwt_secret_key == "change-this-secret-in-production":
insecure.append("JWT_SECRET_KEY")
if "sakura:sakura@" in self.database_url:
insecure.append("DATABASE_URL")
if self.minio_access_key == "minioadmin" or self.minio_secret_key == "minioadmin":
insecure.append("MINIO_ACCESS_KEY/MINIO_SECRET_KEY")
if insecure:
raise ValueError(
"Refusing to start production with insecure default credentials: "
+ ", ".join(insecure)
)
return self
@property
def default_storage_limit_bytes(self) -> int:
return self.default_storage_limit_gb * 1024 * 1024 * 1024
@property
def video_storage_limit_bytes(self) -> int:
return self.video_storage_limit_gb * 1024 * 1024 * 1024
@lru_cache
def get_settings() -> Settings:
return Settings()
settings = get_settings()
+19
View File
@@ -0,0 +1,19 @@
from __future__ import annotations
import sys
from pathlib import Path
from loguru import logger
from sakura_cloud.core.config import settings
def configure_logging() -> None:
log_dir = Path(settings.log_dir)
log_dir.mkdir(parents=True, exist_ok=True)
logger.remove()
logger.add(sys.stderr, level="INFO", enqueue=True)
logger.add(log_dir / "app.log", level="INFO", rotation="50 MB", retention=10, enqueue=True)
logger.add(log_dir / "api.log", level="INFO", rotation="100 MB", retention=5, enqueue=True, filter=lambda r: r["extra"].get("kind") == "api")
logger.add(log_dir / "sync.log", level="INFO", rotation="50 MB", retention=10, enqueue=True, filter=lambda r: r["extra"].get("kind") == "sync")
logger.add(log_dir / "error.log", level="ERROR", rotation="50 MB", retention="30 days", enqueue=True)
+38
View File
@@ -0,0 +1,38 @@
from __future__ import annotations
import ipaddress
from pathlib import PurePath
from urllib.parse import urlparse
from sakura_cloud.core.config import settings
def is_safe_upload_filename(file_name: str) -> bool:
name = file_name.strip()
if not name:
return False
path = PurePath(name)
return path.name == name and name not in {".", ".."} and ".." not in path.parts
def is_allowed_upload_mime(mime_type: str | None) -> bool:
if not mime_type:
return False
return mime_type.lower().strip() in {item.lower() for item in settings.allowed_upload_mime_types}
def is_allowed_external_url(url: str) -> bool:
parsed = urlparse(url.strip())
if parsed.scheme not in {"http", "https"} or not parsed.hostname:
return False
host = parsed.hostname.rstrip(".").lower()
try:
ip = ipaddress.ip_address(host)
except ValueError:
ip = None
if ip is not None:
return not (ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_reserved or ip.is_multicast)
if host in {"localhost"} or host.endswith(".localhost"):
return False
allowed = {item.lower().strip().rstrip(".") for item in settings.allowed_external_url_domains}
return any(host == domain or host.endswith(f".{domain}") for domain in allowed if domain)
+70
View File
@@ -0,0 +1,70 @@
from __future__ import annotations
from datetime import datetime, timedelta, timezone
from typing import Any
from jose import JWTError, jwt
from passlib.context import CryptContext
from sakura_cloud.core.config import settings
pwd_context = CryptContext(schemes=["pbkdf2_sha256", "bcrypt"], deprecated="auto")
def hash_password(password: str) -> str:
return pwd_context.hash(password)
def verify_password(password: str, password_hash: str) -> bool:
return pwd_context.verify(password, password_hash)
def create_token(subject: str, *, token_type: str, expires_delta: timedelta, token_version: int = 0) -> str:
now = datetime.now(timezone.utc)
payload: dict[str, Any] = {
"sub": subject,
"type": token_type,
"tv": token_version,
"iss": settings.jwt_issuer,
"aud": settings.jwt_audience,
"iat": int(now.timestamp()),
"exp": int((now + expires_delta).timestamp()),
}
return jwt.encode(payload, settings.jwt_secret_key, algorithm=settings.jwt_algorithm)
def create_access_token(subject: str, token_version: int = 0) -> str:
return create_token(
subject,
token_type="access",
expires_delta=timedelta(hours=settings.jwt_access_token_expire_hours),
token_version=token_version,
)
def create_refresh_token(subject: str, token_version: int = 0) -> str:
return create_token(
subject,
token_type="refresh",
expires_delta=timedelta(days=settings.jwt_refresh_token_expire_days),
token_version=token_version,
)
def decode_token(token: str) -> dict[str, Any]:
try:
payload = jwt.decode(
token,
settings.jwt_secret_key,
algorithms=[settings.jwt_algorithm],
audience=settings.jwt_audience,
issuer=settings.jwt_issuer,
)
except JWTError as exc:
raise ValueError("Invalid token") from exc
if "exp" not in payload:
raise ValueError("Invalid token")
if payload.get("type") not in {"access", "refresh"}:
raise ValueError("Invalid token")
return payload
+1
View File
@@ -0,0 +1 @@
"""Database session and model metadata."""
+7
View File
@@ -0,0 +1,7 @@
from __future__ import annotations
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
pass
+20
View File
@@ -0,0 +1,20 @@
from __future__ import annotations
from collections.abc import Generator
from sqlalchemy import create_engine
from sqlalchemy.orm import Session, sessionmaker
from sakura_cloud.core.config import settings
engine = create_engine(settings.database_url, pool_pre_ping=True)
SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False)
def get_db() -> Generator[Session, None, None]:
db = SessionLocal()
try:
yield db
finally:
db.close()
+23
View File
@@ -0,0 +1,23 @@
services:
postgres:
image: postgres:15
container_name: sakura-cloud-postgres
restart: unless-stopped
environment:
POSTGRES_USER: sakura
POSTGRES_PASSWORD: sakura
POSTGRES_DB: sakura_cloud
ports:
- "5432:5432"
volumes:
- sakura_cloud_postgres:/var/lib/postgresql/data
redis:
image: redis:7
container_name: sakura-cloud-redis
restart: unless-stopped
ports:
- "6379:6379"
volumes:
sakura_cloud_postgres:
+410
View File
@@ -0,0 +1,410 @@
from __future__ import annotations
import asyncio
from pathlib import Path
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import FileResponse, HTMLResponse
from fastapi.staticfiles import StaticFiles
from sakura_cloud.api.middleware import security_headers_middleware, trace_logging_middleware
from sakura_cloud.api.v1.router import api_router
from sakura_cloud.core.config import settings
from sakura_cloud.core.logging import configure_logging, logger
from sakura_cloud.db.session import SessionLocal
from sakura_cloud.services.migrations import upgrade_database_to_head
from sakura_cloud.services.reminders import run_daily_reminder_digest
from sakura_cloud.services.storage import cleanup_stale_uploads
def _admin_frontend_dist() -> Path:
base_dir = Path(__file__).resolve().parent
candidates = [
base_dir.parent / "sakura_admin_web" / "dist",
base_dir / "sakura_admin_web" / "dist",
]
for candidate in candidates:
if (candidate / "index.html").is_file():
return candidate
return candidates[0]
def _cloud_public_dir() -> Path:
return Path(__file__).resolve().parent / "public"
def _online_search_page() -> HTMLResponse:
return HTMLResponse(
"""<!doctype html>
<html lang="zh-CN">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Sakura Cloud 在线搜索</title>
<style>
* { box-sizing: border-box; }
:root {
font-family: "Microsoft YaHei", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
color: #243142;
background: #fff7fb;
color-scheme: light;
}
body {
margin: 0;
min-height: 100vh;
background:
radial-gradient(circle at 16% -8%, rgba(255, 208, 225, .6), transparent 28%),
linear-gradient(180deg, #fff7fb, #f7fbff);
}
main { width: min(1100px, calc(100% - 32px)); margin: 0 auto; padding: 28px 0 44px; }
.hero {
display: grid;
grid-template-columns: minmax(0, 1fr) auto;
gap: 16px;
align-items: end;
margin-bottom: 18px;
}
h1 { margin: 0 0 8px; font-size: clamp(26px, 5vw, 38px); font-weight: 750; letter-spacing: 0; }
p { margin: 0; color: #728094; line-height: 1.7; }
.badge {
display: inline-flex;
align-items: center;
min-height: 36px;
padding: 0 14px;
border-radius: 999px;
background: #ffe8f0;
color: #bd4f7c;
font-weight: 700;
white-space: nowrap;
}
.panel {
margin-top: 18px;
padding: 18px;
border: 1px solid #ead7df;
border-radius: 14px;
background: rgba(255, 255, 255, .92);
box-shadow: 0 18px 48px rgba(171, 92, 126, .10);
}
.toolbar { display: grid; grid-template-columns: 150px 190px minmax(220px, 1fr); gap: 10px; align-items: center; }
.searchbar { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 10px; margin-top: 12px; }
.source-tools { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 10px; align-items: center; margin-top: 12px; }
input, select, textarea, button {
min-height: 44px;
border: 1px solid #ead7df;
border-radius: 10px;
font: inherit;
max-width: 100%;
}
input, select, textarea { width: 100%; padding: 0 13px; background: #fff; color: #243142; }
textarea {
width: 100%;
min-height: 132px;
margin-top: 10px;
padding: 12px 13px;
resize: vertical;
font-family: ui-monospace, "Cascadia Mono", Consolas, monospace;
font-size: 13px;
line-height: 1.5;
}
button {
padding: 0 18px;
cursor: pointer;
background: #fff;
color: #243142;
font-weight: 700;
white-space: nowrap;
}
button.primary { border: 0; background: #d65f8f; color: #fff; box-shadow: 0 10px 24px rgba(214, 95, 143, .25); }
button.ghost { color: #bd4f7c; }
.muted { color: #728094; }
.error { color: #b7465c; }
.status-line { min-height: 28px; margin-top: 12px; }
.results { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 12px; margin-top: 14px; }
.card {
display: grid;
grid-template-columns: 70px minmax(0,1fr);
gap: 12px;
padding: 12px;
border: 1px solid #ead7df;
border-radius: 12px;
background: #fffafd;
min-width: 0;
}
.cover {
width: 70px;
aspect-ratio: 3/4;
display: grid;
place-items: center;
overflow: hidden;
border-radius: 10px;
background: #ffe8f0;
color: #cf5f8b;
font-weight: 800;
}
.cover img { width: 100%; height: 100%; object-fit: cover; }
.card strong, .card span { display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.card strong { font-size: 16px; line-height: 1.45; }
.card a {
display: block;
margin-top: 8px;
color: #a63f6a;
text-decoration: none;
overflow-wrap: anywhere;
line-height: 1.45;
}
@media (max-width: 760px) {
main { width: min(100% - 24px, 560px); padding: 20px 0 32px; }
.hero { grid-template-columns: 1fr; align-items: start; }
.badge { width: fit-content; }
.panel { padding: 14px; border-radius: 18px; }
.toolbar, .searchbar, .source-tools { grid-template-columns: 1fr; }
button { width: 100%; min-height: 48px; }
textarea { min-height: 108px; }
.results { grid-template-columns: 1fr; }
.card { grid-template-columns: 62px minmax(0, 1fr); padding: 10px; }
.cover { width: 62px; }
}
</style>
</head>
<body>
<main>
<header class="hero">
<div>
<h1>Sakura 在线搜索</h1>
<p>搜索漫画和小说,可使用云端内置 JSON 源,也可以粘贴自己的 Legado 书源/漫画源 JSON。</p>
</div>
<span class="badge">手机端已适配</span>
</header>
<section class="panel">
<div class="toolbar">
<select id="mode">
<option value="novel">小说</option>
<option value="manga">漫画</option>
</select>
<select id="preset"></select>
<input id="token" type="password" placeholder="Bearer Token,可从网页登录后复制" autocomplete="off">
</div>
<div class="searchbar">
<input id="query" type="search" placeholder="输入关键词">
<button class="primary" id="search">在线搜索</button>
</div>
<div class="source-tools">
<p class="muted">默认使用内置精选源。需要临时测试时,可以展开并粘贴 JSON。</p>
<button class="ghost" id="toggleSources" type="button">展开源 JSON</button>
</div>
<textarea id="sources" placeholder="书源/漫画源 JSON" hidden></textarea>
<p id="status" class="muted status-line"></p>
<div id="results" class="results"></div>
</section>
</main>
<script>
const presets = [
{ name: "精选50书源", url: "/sources/精选50书源.json", mode: "novel" },
{ name: "精选50漫画源", url: "/sources/精选50漫画源.json", mode: "manga" }
];
const presetEl = document.querySelector("#preset");
const modeEl = document.querySelector("#mode");
const tokenEl = document.querySelector("#token");
const queryEl = document.querySelector("#query");
const sourcesEl = document.querySelector("#sources");
const statusEl = document.querySelector("#status");
const resultsEl = document.querySelector("#results");
tokenEl.value = localStorage.getItem("sakura-online-token") || "";
presets.forEach((item, index) => {
const option = document.createElement("option");
option.value = String(index);
option.textContent = item.name;
presetEl.appendChild(option);
});
async function loadPreset() {
const item = presets[Number(presetEl.value || 0)];
modeEl.value = item.mode;
statusEl.textContent = "正在加载内置源...";
sourcesEl.value = await fetch(item.url).then(r => r.text());
statusEl.textContent = "内置源已加载。";
}
presetEl.addEventListener("change", loadPreset);
loadPreset().catch(err => statusEl.textContent = err.message || "内置源加载失败");
document.querySelector("#toggleSources").addEventListener("click", event => {
const visible = sourcesEl.hasAttribute("hidden");
sourcesEl.toggleAttribute("hidden", !visible);
event.currentTarget.textContent = visible ? "收起源 JSON" : "展开源 JSON";
});
queryEl.addEventListener("keydown", event => {
if (event.key === "Enter") document.querySelector("#search").click();
});
document.querySelector("#search").addEventListener("click", async () => {
resultsEl.innerHTML = "";
statusEl.textContent = "";
statusEl.className = "muted";
const token = tokenEl.value.trim().replace(/^Bearer\\s+/i, "");
localStorage.setItem("sakura-online-token", token);
let parsed;
try { parsed = JSON.parse(sourcesEl.value); } catch { statusEl.textContent = "JSON 格式不正确"; statusEl.className = "error"; return; }
try {
statusEl.textContent = "搜索中...";
const res = await fetch(`/api/v1/online-search?mode=${encodeURIComponent(modeEl.value)}`, {
method: "POST",
headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
body: JSON.stringify({ query: queryEl.value.trim(), sources: parsed, limit_sources: 50, per_source_limit: 20 })
});
const body = await res.json();
if (!res.ok) throw new Error(body.detail || body.message || `HTTP ${res.status}`);
const rows = body.data || [];
statusEl.textContent = `找到 ${rows.length} 条结果`;
resultsEl.innerHTML = rows.map(item => `
<article class="card">
<div class="cover">${item.cover_url ? `<img src="${item.cover_url}" alt="">` : (item.kind === "manga" ? "漫" : "文")}</div>
<div>
<strong>${escapeHtml(item.title || "未命名")}</strong>
<span class="muted">${escapeHtml([item.author, item.source_name].filter(Boolean).join(" · "))}</span>
<a href="${item.detail_url}" target="_blank" rel="noreferrer">${item.detail_url}</a>
</div>
</article>`).join("");
} catch (err) {
statusEl.textContent = err.message || "搜索失败";
statusEl.className = "error";
}
});
function escapeHtml(value) {
return String(value || "").replace(/[&<>"']/g, ch => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[ch]));
}
</script>
</body>
</html>""",
headers={
"Content-Security-Policy": (
"default-src 'self'; base-uri 'self'; object-src 'none'; "
"frame-ancestors 'none'; img-src 'self' data: blob: https: http:; "
"style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; "
"connect-src 'self'"
)
},
)
def _admin_placeholder() -> HTMLResponse:
return HTMLResponse(
"""<!doctype html>
<html lang="zh-CN">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Sakura Cloud Admin</title>
</head>
<body>
<main>
<h1>Sakura Cloud Admin</h1>
<p>Frontend not built. Run: cd sakura_admin_web && npm run build</p>
</main>
</body>
</html>"""
)
def _spa_index(frontend_dist: Path) -> FileResponse | HTMLResponse:
index_path = frontend_dist / "index.html"
if index_path.is_file():
return FileResponse(index_path)
return _admin_placeholder()
async def cleanup_uploads_loop() -> None:
while True:
await asyncio.sleep(3600)
db = SessionLocal()
try:
cleanup_stale_uploads(db)
except Exception:
logger.exception("Cleanup stale uploads failed")
finally:
db.close()
async def reminder_digest_loop() -> None:
while True:
await asyncio.sleep(300)
db = SessionLocal()
try:
run_daily_reminder_digest(db)
except Exception:
logger.exception("Reminder digest loop failed")
finally:
db.close()
def create_app() -> FastAPI:
configure_logging()
app = FastAPI(
title=settings.app_name,
version=settings.app_version,
openapi_url=f"{settings.api_prefix}/openapi.json",
)
app.add_middleware(
CORSMiddleware,
allow_origins=settings.cors_origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.middleware("http")(security_headers_middleware)
app.middleware("http")(trace_logging_middleware)
app.include_router(api_router, prefix=settings.api_prefix)
frontend_dist = _admin_frontend_dist()
public_dir = _cloud_public_dir()
assets_dir = frontend_dist / "assets"
if settings.admin_frontend_enabled and assets_dir.is_dir():
app.mount("/assets", StaticFiles(directory=assets_dir), name="admin_assets")
sources_dir = public_dir / "sources"
if sources_dir.is_dir():
app.mount("/sources", StaticFiles(directory=sources_dir), name="source_json")
@app.get("/online-search", response_model=None)
def online_search_console() -> HTMLResponse:
return _online_search_page()
@app.get("/search", response_model=None)
def search_console() -> HTMLResponse:
return _online_search_page()
@app.get("/admin", response_model=None)
def admin_console() -> FileResponse | HTMLResponse:
if not settings.admin_frontend_enabled:
return HTMLResponse("<h1>Admin console disabled</h1>", status_code=404)
return _spa_index(frontend_dist)
@app.get("/{full_path:path}", include_in_schema=False, response_model=None)
def spa_fallback(full_path: str) -> FileResponse | HTMLResponse:
api_prefix = settings.api_prefix.strip("/")
if full_path == api_prefix or full_path.startswith(api_prefix + "/"):
raise HTTPException(status_code=404, detail="API route not found")
if not settings.admin_frontend_enabled:
raise HTTPException(status_code=404, detail="Frontend disabled")
return _spa_index(frontend_dist)
@app.on_event("startup")
async def _start_background_tasks() -> None:
if settings.auto_migrate_on_startup:
logger.info("Auto migration enabled, upgrading database to head")
upgrade_database_to_head()
else:
logger.info("Auto migration disabled, skipping database upgrade on startup")
db = SessionLocal()
try:
cleanup_stale_uploads(db)
try:
run_daily_reminder_digest(db)
except Exception:
logger.exception("Initial reminder digest failed during startup")
finally:
db.close()
logger.info("Startup tasks completed")
asyncio.create_task(cleanup_uploads_loop())
asyncio.create_task(reminder_digest_loop())
return app
app = create_app()
+47
View File
@@ -0,0 +1,47 @@
from __future__ import annotations
from logging.config import fileConfig
from alembic import context
from sqlalchemy import engine_from_config, pool
from sakura_cloud.core.config import settings
from sakura_cloud.db.base import Base
from sakura_cloud import models # noqa: F401
config = context.config
if config.config_file_name is not None:
fileConfig(config.config_file_name)
config.set_main_option("sqlalchemy.url", settings.database_url)
target_metadata = Base.metadata
def run_migrations_offline() -> None:
context.configure(
url=settings.database_url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online() -> None:
connectable = engine_from_config(
config.get_section(config.config_ini_section, {}),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+26
View File
@@ -0,0 +1,26 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
def upgrade() -> None:
${upgrades if upgrades else "pass"}
def downgrade() -> None:
${downgrades if downgrades else "pass"}
@@ -0,0 +1,180 @@
"""initial cloud schema
Revision ID: 0001_initial_cloud_schema
Revises:
Create Date: 2026-06-02
"""
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "0001_initial_cloud_schema"
down_revision = None
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_table(
"users",
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("username", sa.String(length=50), nullable=False),
sa.Column("email", sa.String(length=100), nullable=False),
sa.Column("password_hash", sa.String(length=255), nullable=False),
sa.Column("avatar", sa.Text(), nullable=True),
sa.Column("storage_used", sa.BigInteger(), nullable=False),
sa.Column("storage_limit", sa.BigInteger(), nullable=False),
sa.Column("role", sa.Enum("ADMIN", "USER", name="userrole"), nullable=False),
sa.PrimaryKeyConstraint("id"),
sa.UniqueConstraint("email"),
sa.UniqueConstraint("username"),
)
op.create_index("idx_users_email", "users", ["email"])
op.create_index("idx_users_username", "users", ["username"])
op.create_table(
"file_blobs",
sa.Column("sha256", sa.String(length=64), nullable=False),
sa.Column("storage_path", sa.Text(), nullable=False),
sa.Column("file_size", sa.BigInteger(), nullable=False),
sa.Column("mime_type", sa.String(length=50), nullable=True),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.PrimaryKeyConstraint("sha256"),
)
op.create_table(
"devices",
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("user_id", sa.String(length=36), nullable=False),
sa.Column("device_name", sa.String(length=100), nullable=False),
sa.Column("device_type", sa.String(length=20), nullable=False),
sa.Column("device_token", sa.String(length=255), nullable=True),
sa.Column("last_active_at", sa.DateTime(timezone=True), nullable=True),
sa.Column("last_sync_at", sa.DateTime(timezone=True), nullable=True),
sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
)
op.create_index("idx_devices_user_id", "devices", ["user_id"])
op.create_index("idx_devices_last_active", "devices", ["last_active_at"])
op.create_table(
"user_files",
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("user_id", sa.String(length=36), nullable=False),
sa.Column("file_sha256", sa.String(length=64), nullable=False),
sa.Column("original_name", sa.String(length=255), nullable=False),
sa.Column("uploaded_at", sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(["file_sha256"], ["file_blobs.sha256"], ondelete="CASCADE"),
sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
)
op.create_index("idx_user_files_user_id", "user_files", ["user_id"])
op.create_table(
"upload_sessions",
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("user_id", sa.String(length=36), nullable=False),
sa.Column("sha256", sa.String(length=64), nullable=False),
sa.Column("file_name", sa.String(length=255), nullable=False),
sa.Column("file_size", sa.BigInteger(), nullable=False),
sa.Column("mime_type", sa.String(length=50), nullable=True),
sa.Column("resource_type", sa.String(length=20), nullable=False),
sa.Column("chunk_size", sa.BigInteger(), nullable=False),
sa.Column("received_size", sa.BigInteger(), nullable=False),
sa.Column("temp_path", sa.Text(), nullable=False),
sa.Column("status", sa.String(length=20), nullable=False),
sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
)
op.create_index("idx_upload_sessions_user_id", "upload_sessions", ["user_id"])
op.create_index("ix_upload_sessions_sha256", "upload_sessions", ["sha256"])
op.create_table(
"artworks",
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("user_id", sa.String(length=36), nullable=False),
sa.Column("file_id", sa.String(length=36), nullable=True),
sa.Column("source_id", sa.String(length=50), nullable=True),
sa.Column("source_platform", sa.String(length=20), nullable=False),
sa.Column("title", sa.String(length=500), nullable=False),
sa.Column("author", sa.String(length=200), nullable=True),
sa.Column("author_id", sa.String(length=50), nullable=True),
sa.Column("page_count", sa.Integer(), nullable=False),
sa.Column("file_path", sa.Text(), nullable=False),
sa.Column("file_size", sa.BigInteger(), nullable=False),
sa.Column("thumbnail_path", sa.Text(), nullable=True),
sa.Column("mime_type", sa.String(length=50), nullable=True),
sa.Column("width", sa.Integer(), nullable=True),
sa.Column("height", sa.Integer(), nullable=True),
sa.Column("tags", sa.JSON(), nullable=False),
sa.Column("is_favorite", sa.Boolean(), nullable=False),
sa.Column("metadata", sa.JSON(), nullable=False),
sa.ForeignKeyConstraint(["file_id"], ["user_files.id"], ondelete="SET NULL"),
sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
)
op.create_index("ix_artworks_author", "artworks", ["author"])
op.create_index("ix_artworks_is_favorite", "artworks", ["is_favorite"])
op.create_index("ix_artworks_source_platform", "artworks", ["source_platform"])
op.create_table(
"novels",
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("user_id", sa.String(length=36), nullable=False),
sa.Column("file_id", sa.String(length=36), nullable=True),
sa.Column("source_id", sa.String(length=50), nullable=True),
sa.Column("source_platform", sa.String(length=20), nullable=False),
sa.Column("title", sa.String(length=500), nullable=False),
sa.Column("author", sa.String(length=200), nullable=True),
sa.Column("description", sa.Text(), nullable=True),
sa.Column("file_path", sa.Text(), nullable=False),
sa.Column("file_size", sa.BigInteger(), nullable=False),
sa.Column("cover_path", sa.Text(), nullable=True),
sa.Column("word_count", sa.Integer(), nullable=False),
sa.Column("current_page", sa.Integer(), nullable=False),
sa.Column("bookmark", sa.Text(), nullable=True),
sa.Column("tags", sa.JSON(), nullable=False),
sa.Column("is_favorite", sa.Boolean(), nullable=False),
sa.Column("last_read_at", sa.DateTime(timezone=True), nullable=True),
sa.ForeignKeyConstraint(["file_id"], ["user_files.id"], ondelete="SET NULL"),
sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
)
op.create_index("ix_novels_author", "novels", ["author"])
op.create_index("ix_novels_is_favorite", "novels", ["is_favorite"])
op.create_index("ix_novels_source_platform", "novels", ["source_platform"])
op.execute(
"CREATE INDEX IF NOT EXISTS idx_artworks_search ON artworks "
"USING GIN (to_tsvector('simple', coalesce(title, '') || ' ' || coalesce(author, '') || ' ' || coalesce(source_platform, '')))"
)
op.execute(
"CREATE INDEX IF NOT EXISTS idx_novels_search ON novels "
"USING GIN (to_tsvector('simple', coalesce(title, '') || ' ' || coalesce(author, '') || ' ' || coalesce(description, '')))"
)
def downgrade() -> None:
op.execute("DROP INDEX IF EXISTS idx_novels_search")
op.execute("DROP INDEX IF EXISTS idx_artworks_search")
op.drop_table("novels")
op.drop_table("artworks")
op.drop_index("ix_upload_sessions_sha256", table_name="upload_sessions")
op.drop_index("idx_upload_sessions_user_id", table_name="upload_sessions")
op.drop_table("upload_sessions")
op.drop_index("idx_user_files_user_id", table_name="user_files")
op.drop_table("user_files")
op.drop_index("idx_devices_last_active", table_name="devices")
op.drop_index("idx_devices_user_id", table_name="devices")
op.drop_table("devices")
op.drop_table("file_blobs")
op.drop_index("idx_users_username", table_name="users")
op.drop_index("idx_users_email", table_name="users")
op.drop_table("users")
op.execute("DROP TYPE IF EXISTS userrole")
@@ -0,0 +1,25 @@
"""add file blob thumbnail path
Revision ID: 0002_file_blob_thumb
Revises: 0001_initial_cloud_schema
Create Date: 2026-06-02
"""
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "0002_file_blob_thumb"
down_revision = "0001_initial_cloud_schema"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("file_blobs", sa.Column("thumbnail_path", sa.Text(), nullable=True))
def downgrade() -> None:
op.drop_column("file_blobs", "thumbnail_path")
@@ -0,0 +1,110 @@
"""add content features and alerts
Revision ID: 0003_content_features
Revises: 0002_file_blob_thumb
Create Date: 2026-06-03
"""
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "0003_content_features"
down_revision = "0002_file_blob_thumb"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("artworks", sa.Column("content_type", sa.String(length=20), nullable=False, server_default="illust"))
op.add_column("artworks", sa.Column("last_viewed_at", sa.DateTime(timezone=True), nullable=True))
op.create_index("ix_artworks_content_type", "artworks", ["content_type"])
op.create_index("ix_artworks_last_viewed_at", "artworks", ["last_viewed_at"])
op.add_column("novels", sa.Column("series_id", sa.String(length=50), nullable=True))
op.add_column("novels", sa.Column("series_title", sa.String(length=500), nullable=True))
op.add_column("novels", sa.Column("chapter_title", sa.String(length=500), nullable=True))
op.add_column("novels", sa.Column("chapter_order", sa.Integer(), nullable=False, server_default="0"))
op.add_column("novels", sa.Column("last_viewed_at", sa.DateTime(timezone=True), nullable=True))
op.create_index("ix_novels_series_id", "novels", ["series_id"])
op.create_index("ix_novels_last_viewed_at", "novels", ["last_viewed_at"])
op.create_table(
"creator_follows",
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("user_id", sa.String(length=36), nullable=False),
sa.Column("platform", sa.String(length=20), nullable=False),
sa.Column("creator_id", sa.String(length=100), nullable=False),
sa.Column("creator_name", sa.String(length=200), nullable=True),
sa.Column("creator_handle", sa.String(length=200), nullable=True),
sa.Column("profile_url", sa.Text(), nullable=True),
sa.Column("avatar_url", sa.Text(), nullable=True),
sa.Column("enabled", sa.Boolean(), nullable=False),
sa.Column("last_checked_at", sa.DateTime(timezone=True), nullable=True),
sa.Column("latest_published_at", sa.DateTime(timezone=True), nullable=True),
sa.Column("metadata", sa.JSON(), nullable=False),
sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
)
op.create_index("ix_creator_follows_user_id", "creator_follows", ["user_id"])
op.create_index("ix_creator_follows_platform", "creator_follows", ["platform"])
op.create_index("ix_creator_follows_creator_id", "creator_follows", ["creator_id"])
op.create_index("ix_creator_follows_enabled", "creator_follows", ["enabled"])
op.create_table(
"update_alerts",
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("user_id", sa.String(length=36), nullable=False),
sa.Column("follow_id", sa.String(length=36), nullable=True),
sa.Column("platform", sa.String(length=20), nullable=False),
sa.Column("creator_id", sa.String(length=100), nullable=False),
sa.Column("title", sa.String(length=500), nullable=False),
sa.Column("body", sa.Text(), nullable=True),
sa.Column("content_type", sa.String(length=20), nullable=True),
sa.Column("target_url", sa.Text(), nullable=True),
sa.Column("cover_url", sa.Text(), nullable=True),
sa.Column("is_read", sa.Boolean(), nullable=False),
sa.Column("payload", sa.JSON(), nullable=False),
sa.ForeignKeyConstraint(["follow_id"], ["creator_follows.id"], ondelete="SET NULL"),
sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
)
op.create_index("ix_update_alerts_user_id", "update_alerts", ["user_id"])
op.create_index("ix_update_alerts_follow_id", "update_alerts", ["follow_id"])
op.create_index("ix_update_alerts_platform", "update_alerts", ["platform"])
op.create_index("ix_update_alerts_creator_id", "update_alerts", ["creator_id"])
op.create_index("ix_update_alerts_is_read", "update_alerts", ["is_read"])
def downgrade() -> None:
op.drop_index("ix_update_alerts_is_read", table_name="update_alerts")
op.drop_index("ix_update_alerts_creator_id", table_name="update_alerts")
op.drop_index("ix_update_alerts_platform", table_name="update_alerts")
op.drop_index("ix_update_alerts_follow_id", table_name="update_alerts")
op.drop_index("ix_update_alerts_user_id", table_name="update_alerts")
op.drop_table("update_alerts")
op.drop_index("ix_creator_follows_enabled", table_name="creator_follows")
op.drop_index("ix_creator_follows_creator_id", table_name="creator_follows")
op.drop_index("ix_creator_follows_platform", table_name="creator_follows")
op.drop_index("ix_creator_follows_user_id", table_name="creator_follows")
op.drop_table("creator_follows")
op.drop_index("ix_novels_last_viewed_at", table_name="novels")
op.drop_index("ix_novels_series_id", table_name="novels")
op.drop_column("novels", "last_viewed_at")
op.drop_column("novels", "chapter_order")
op.drop_column("novels", "chapter_title")
op.drop_column("novels", "series_title")
op.drop_column("novels", "series_id")
op.drop_index("ix_artworks_last_viewed_at", table_name="artworks")
op.drop_index("ix_artworks_content_type", table_name="artworks")
op.drop_column("artworks", "last_viewed_at")
op.drop_column("artworks", "content_type")
@@ -0,0 +1,36 @@
"""add daily reminder preferences
Revision ID: 0004_daily_reminder_preferences
Revises: 0003_content_features
Create Date: 2026-06-03
"""
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "0004_daily_reminder_preferences"
down_revision = "0003_content_features"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("users", sa.Column("reminder_enabled", sa.Boolean(), nullable=False, server_default=sa.true()))
op.add_column("users", sa.Column("reminder_hour", sa.Integer(), nullable=False, server_default="9"))
op.add_column("users", sa.Column("reminder_minute", sa.Integer(), nullable=False, server_default="0"))
op.add_column(
"users",
sa.Column("reminder_timezone", sa.String(length=64), nullable=False, server_default="Asia/Shanghai"),
)
op.add_column("users", sa.Column("last_reminder_sent_at", sa.DateTime(timezone=True), nullable=True))
def downgrade() -> None:
op.drop_column("users", "last_reminder_sent_at")
op.drop_column("users", "reminder_timezone")
op.drop_column("users", "reminder_minute")
op.drop_column("users", "reminder_hour")
op.drop_column("users", "reminder_enabled")
@@ -0,0 +1,52 @@
"""add mobile query composite indexes
Revision ID: 0005_mobile_query_indexes
Revises: 0004_daily_reminder_preferences
Create Date: 2026-06-06
"""
from __future__ import annotations
from alembic import op
revision = "0005_mobile_query_indexes"
down_revision = "0004_daily_reminder_preferences"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_index("ix_artworks_user_content_viewed", "artworks", ["user_id", "content_type", "last_viewed_at"])
op.create_index("ix_artworks_user_created", "artworks", ["user_id", "created_at"])
op.create_index("ix_artworks_user_favorite_viewed", "artworks", ["user_id", "is_favorite", "last_viewed_at"])
op.create_index("ix_novels_user_viewed", "novels", ["user_id", "last_viewed_at"])
op.create_index("ix_novels_user_read", "novels", ["user_id", "last_read_at"])
op.create_index("ix_novels_user_series_chapter", "novels", ["user_id", "series_id", "chapter_order"])
op.create_index("ix_novels_user_favorite_viewed", "novels", ["user_id", "is_favorite", "last_viewed_at"])
op.create_index("ix_creator_follows_user_enabled_updated", "creator_follows", ["user_id", "enabled", "updated_at"])
op.create_index("ix_creator_follows_user_platform_creator", "creator_follows", ["user_id", "platform", "creator_id"])
op.create_index("ix_update_alerts_user_read_created", "update_alerts", ["user_id", "is_read", "created_at"])
op.create_index("ix_update_alerts_user_created", "update_alerts", ["user_id", "created_at"])
op.create_index("ix_update_alerts_user_platform_creator", "update_alerts", ["user_id", "platform", "creator_id"])
def downgrade() -> None:
op.drop_index("ix_update_alerts_user_platform_creator", table_name="update_alerts")
op.drop_index("ix_update_alerts_user_created", table_name="update_alerts")
op.drop_index("ix_update_alerts_user_read_created", table_name="update_alerts")
op.drop_index("ix_creator_follows_user_platform_creator", table_name="creator_follows")
op.drop_index("ix_creator_follows_user_enabled_updated", table_name="creator_follows")
op.drop_index("ix_novels_user_favorite_viewed", table_name="novels")
op.drop_index("ix_novels_user_series_chapter", table_name="novels")
op.drop_index("ix_novels_user_read", table_name="novels")
op.drop_index("ix_novels_user_viewed", table_name="novels")
op.drop_index("ix_artworks_user_favorite_viewed", table_name="artworks")
op.drop_index("ix_artworks_user_created", table_name="artworks")
op.drop_index("ix_artworks_user_content_viewed", table_name="artworks")
@@ -0,0 +1,43 @@
"""add push device tokens
Revision ID: 0006_push_device_tokens
Revises: 0005_mobile_query_indexes
Create Date: 2026-06-06
"""
from __future__ import annotations
import sqlalchemy as sa
from alembic import op
revision = "0006_push_device_tokens"
down_revision = "0005_mobile_query_indexes"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_table(
"push_device_tokens",
sa.Column("user_id", sa.String(length=36), nullable=False),
sa.Column("device_id", sa.String(length=128), nullable=False),
sa.Column("platform", sa.String(length=20), nullable=False),
sa.Column("fcm_token", sa.Text(), nullable=False),
sa.Column("is_active", sa.Boolean(), nullable=False),
sa.Column("last_seen_at", sa.DateTime(timezone=True), nullable=True),
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
sa.UniqueConstraint("user_id", "device_id", name="uq_push_device_tokens_user_device"),
)
op.create_index("ix_push_device_tokens_is_active", "push_device_tokens", ["is_active"])
op.create_index("ix_push_device_tokens_user_active", "push_device_tokens", ["user_id", "is_active"])
def downgrade() -> None:
op.drop_index("ix_push_device_tokens_user_active", table_name="push_device_tokens")
op.drop_index("ix_push_device_tokens_is_active", table_name="push_device_tokens")
op.drop_table("push_device_tokens")
@@ -0,0 +1,60 @@
"""add artwork ocr texts
Revision ID: 0007_artwork_ocr_texts
Revises: 0006_push_device_tokens
Create Date: 2026-06-06
"""
from __future__ import annotations
import sqlalchemy as sa
from alembic import op
revision = "0007_artwork_ocr_texts"
down_revision = "0006_push_device_tokens"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_table(
"artwork_ocr_texts",
sa.Column("user_id", sa.String(length=36), nullable=False),
sa.Column("artwork_id", sa.String(length=36), nullable=False),
sa.Column("file_id", sa.String(length=36), nullable=True),
sa.Column("source_platform", sa.String(length=20), nullable=True),
sa.Column("source_id", sa.String(length=50), nullable=True),
sa.Column("language", sa.String(length=20), nullable=False),
sa.Column("ocr_text", sa.Text(), nullable=False),
sa.Column("confidence", sa.Float(), nullable=True),
sa.Column("engine", sa.String(length=50), nullable=False),
sa.Column("status", sa.String(length=20), nullable=False),
sa.Column("attempts", sa.Integer(), nullable=False),
sa.Column("error", sa.Text(), nullable=True),
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(["artwork_id"], ["artworks.id"], ondelete="CASCADE"),
sa.ForeignKeyConstraint(["file_id"], ["user_files.id"], ondelete="SET NULL"),
sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
sa.UniqueConstraint("user_id", "artwork_id", name="uq_artwork_ocr_texts_user_artwork"),
)
op.create_index("ix_artwork_ocr_texts_user_artwork", "artwork_ocr_texts", ["user_id", "artwork_id"])
op.create_index("ix_artwork_ocr_texts_user_status", "artwork_ocr_texts", ["user_id", "status"])
op.create_index("ix_artwork_ocr_texts_user_source", "artwork_ocr_texts", ["user_id", "source_platform", "source_id"])
if op.get_bind().dialect.name == "postgresql":
op.execute(
"CREATE INDEX ix_artwork_ocr_texts_ocr_text_gin "
"ON artwork_ocr_texts USING gin (to_tsvector('simple', coalesce(ocr_text, '')))"
)
def downgrade() -> None:
if op.get_bind().dialect.name == "postgresql":
op.execute("DROP INDEX IF EXISTS ix_artwork_ocr_texts_ocr_text_gin")
op.drop_index("ix_artwork_ocr_texts_user_source", table_name="artwork_ocr_texts")
op.drop_index("ix_artwork_ocr_texts_user_status", table_name="artwork_ocr_texts")
op.drop_index("ix_artwork_ocr_texts_user_artwork", table_name="artwork_ocr_texts")
op.drop_table("artwork_ocr_texts")
@@ -0,0 +1,53 @@
"""add admin audit logs and user active role support
Revision ID: 0008_admin_audit_user_active
Revises: 0007_artwork_ocr_texts
Create Date: 2026-06-06
"""
from __future__ import annotations
import sqlalchemy as sa
from alembic import op
revision = "0008_admin_audit_user_active"
down_revision = "0007_artwork_ocr_texts"
branch_labels = None
depends_on = None
def upgrade() -> None:
bind = op.get_bind()
if bind.dialect.name == "postgresql":
op.execute("ALTER TYPE userrole ADD VALUE IF NOT EXISTS 'SUPER_ADMIN'")
op.add_column("users", sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.true()))
op.create_index("ix_users_is_active", "users", ["is_active"])
op.create_table(
"admin_audit_logs",
sa.Column("admin_user_id", sa.String(length=36), nullable=True),
sa.Column("action", sa.String(length=100), nullable=False),
sa.Column("target_type", sa.String(length=50), nullable=True),
sa.Column("target_id", sa.String(length=100), nullable=True),
sa.Column("ip_address", sa.String(length=64), nullable=True),
sa.Column("user_agent", sa.Text(), nullable=True),
sa.Column("detail_json", sa.JSON(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("id", sa.String(length=36), nullable=False),
sa.ForeignKeyConstraint(["admin_user_id"], ["users.id"], ondelete="SET NULL"),
sa.PrimaryKeyConstraint("id"),
)
op.create_index("ix_admin_audit_logs_action", "admin_audit_logs", ["action"])
op.create_index("ix_admin_audit_logs_admin_created", "admin_audit_logs", ["admin_user_id", "created_at"])
op.create_index("ix_admin_audit_logs_action_created", "admin_audit_logs", ["action", "created_at"])
op.create_index("ix_admin_audit_logs_target", "admin_audit_logs", ["target_type", "target_id"])
def downgrade() -> None:
op.drop_index("ix_admin_audit_logs_target", table_name="admin_audit_logs")
op.drop_index("ix_admin_audit_logs_action_created", table_name="admin_audit_logs")
op.drop_index("ix_admin_audit_logs_admin_created", table_name="admin_audit_logs")
op.drop_index("ix_admin_audit_logs_action", table_name="admin_audit_logs")
op.drop_table("admin_audit_logs")
op.drop_index("ix_users_is_active", table_name="users")
op.drop_column("users", "is_active")
@@ -0,0 +1,29 @@
"""add web admin hardening user fields
Revision ID: 0009_web_admin_hardening
Revises: 0008_admin_audit_user_active
Create Date: 2026-06-06
"""
from __future__ import annotations
import sqlalchemy as sa
from alembic import op
revision = "0009_web_admin_hardening"
down_revision = "0008_admin_audit_user_active"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("users", sa.Column("disabled_at", sa.DateTime(timezone=True), nullable=True))
op.add_column("users", sa.Column("disabled_reason", sa.Text(), nullable=True))
op.add_column("users", sa.Column("token_version", sa.Integer(), nullable=False, server_default="0"))
def downgrade() -> None:
op.drop_column("users", "token_version")
op.drop_column("users", "disabled_reason")
op.drop_column("users", "disabled_at")
@@ -0,0 +1,24 @@
"""add gallery feed updated index
Revision ID: 0010_gallery_feed_indexes
Revises: 0009_web_admin_hardening
Create Date: 2026-06-14
"""
from __future__ import annotations
from alembic import op
revision = "0010_gallery_feed_indexes"
down_revision = "0009_web_admin_hardening"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_index("ix_artworks_user_updated", "artworks", ["user_id", "updated_at"])
def downgrade() -> None:
op.drop_index("ix_artworks_user_updated", table_name="artworks")
@@ -0,0 +1,39 @@
"""add feed cache table
Revision ID: 0011_feed_cache
Revises: 0010_gallery_feed_indexes
Create Date: 2026-06-15
"""
from __future__ import annotations
import sqlalchemy as sa
from alembic import op
revision = "0011_feed_cache"
down_revision = "0010_gallery_feed_indexes"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_table(
"feed_cache",
sa.Column("user_id", sa.String(length=36), nullable=False),
sa.Column("cache_key", sa.String(length=100), nullable=False),
sa.Column("payload", sa.JSON(), nullable=False),
sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("id", sa.String(length=36), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
sa.UniqueConstraint("user_id", "cache_key", name="uq_feed_cache_user_key"),
)
op.create_index("ix_feed_cache_user_expires", "feed_cache", ["user_id", "expires_at"])
def downgrade() -> None:
op.drop_index("ix_feed_cache_user_expires", table_name="feed_cache")
op.drop_table("feed_cache")
@@ -0,0 +1,40 @@
"""add p2 query performance indexes
Revision ID: 0012_p2_query_indexes
Revises: 0011_feed_cache
Create Date: 2026-06-15
"""
from __future__ import annotations
from alembic import op
revision = "0012_p2_query_indexes"
down_revision = "0011_feed_cache"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.execute("CREATE INDEX IF NOT EXISTS ix_artworks_user_created_desc ON artworks (user_id, created_at DESC)")
op.execute("CREATE INDEX IF NOT EXISTS ix_artworks_user_updated_desc ON artworks (user_id, updated_at DESC)")
op.execute(
"CREATE INDEX IF NOT EXISTS ix_artworks_user_content_created_desc "
"ON artworks (user_id, content_type, created_at DESC)"
)
op.execute(
"CREATE INDEX IF NOT EXISTS ix_artworks_user_content_updated_desc "
"ON artworks (user_id, content_type, updated_at DESC)"
)
op.execute("CREATE INDEX IF NOT EXISTS ix_novels_user_updated_desc ON novels (user_id, updated_at DESC)")
op.execute("CREATE INDEX IF NOT EXISTS ix_novels_series_chapter_order ON novels (series_id, chapter_order)")
def downgrade() -> None:
op.execute("DROP INDEX IF EXISTS ix_novels_series_chapter_order")
op.execute("DROP INDEX IF EXISTS ix_novels_user_updated_desc")
op.execute("DROP INDEX IF EXISTS ix_artworks_user_content_updated_desc")
op.execute("DROP INDEX IF EXISTS ix_artworks_user_content_created_desc")
op.execute("DROP INDEX IF EXISTS ix_artworks_user_updated_desc")
op.execute("DROP INDEX IF EXISTS ix_artworks_user_created_desc")
+26
View File
@@ -0,0 +1,26 @@
from sakura_cloud.models.admin import AdminAuditLog
from sakura_cloud.models.artwork import Artwork
from sakura_cloud.models.device import Device
from sakura_cloud.models.file import FileBlob, UploadSession, UserFile
from sakura_cloud.models.follow import CreatorFollow, UpdateAlert
from sakura_cloud.models.feed_cache import FeedCache
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
__all__ = [
"Artwork",
"ArtworkOcrText",
"AdminAuditLog",
"CreatorFollow",
"Device",
"FileBlob",
"FeedCache",
"Novel",
"PushDeviceToken",
"UpdateAlert",
"UploadSession",
"User",
"UserFile",
]
+29
View File
@@ -0,0 +1,29 @@
from __future__ import annotations
from datetime import datetime
from sqlalchemy import DateTime, ForeignKey, Index, JSON, String, Text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sakura_cloud.db.base import Base
from sakura_cloud.models.mixins import UUIDPrimaryKeyMixin, utc_now
class AdminAuditLog(UUIDPrimaryKeyMixin, Base):
__tablename__ = "admin_audit_logs"
__table_args__ = (
Index("ix_admin_audit_logs_admin_created", "admin_user_id", "created_at"),
Index("ix_admin_audit_logs_action_created", "action", "created_at"),
Index("ix_admin_audit_logs_target", "target_type", "target_id"),
)
admin_user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
action: Mapped[str] = mapped_column(String(100), nullable=False, index=True)
target_type: Mapped[str | None] = mapped_column(String(50), nullable=True)
target_id: Mapped[str | None] = mapped_column(String(100), nullable=True)
ip_address: Mapped[str | None] = mapped_column(String(64), nullable=True)
user_agent: Mapped[str | None] = mapped_column(Text, nullable=True)
detail_json: Mapped[dict] = mapped_column("detail_json", JSON, default=dict, nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utc_now, nullable=False)
admin_user = relationship("User")
+63
View File
@@ -0,0 +1,63 @@
from __future__ import annotations
from datetime import datetime
from sqlalchemy import BigInteger, Boolean, DateTime, ForeignKey, Index, Integer, JSON, String, Text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sakura_cloud.db.base import Base
from sakura_cloud.models.mixins import TimestampMixin, UUIDPrimaryKeyMixin
class Artwork(UUIDPrimaryKeyMixin, TimestampMixin, Base):
__tablename__ = "artworks"
__table_args__ = (
Index("ix_artworks_user_content_viewed", "user_id", "content_type", "last_viewed_at"),
Index("ix_artworks_user_created", "user_id", "created_at"),
Index("ix_artworks_user_created_desc", "user_id", "created_at"),
Index("ix_artworks_user_updated", "user_id", "updated_at"),
Index("ix_artworks_user_updated_desc", "user_id", "updated_at"),
Index("ix_artworks_user_content_created_desc", "user_id", "content_type", "created_at"),
Index("ix_artworks_user_content_updated_desc", "user_id", "content_type", "updated_at"),
Index("ix_artworks_user_favorite_viewed", "user_id", "is_favorite", "last_viewed_at"),
)
user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
file_id: Mapped[str | None] = mapped_column(String(36), ForeignKey("user_files.id", ondelete="SET NULL"), nullable=True)
source_id: Mapped[str | None] = mapped_column(String(50), nullable=True)
source_platform: Mapped[str] = mapped_column(String(20), nullable=False, index=True)
content_type: Mapped[str] = mapped_column(String(20), default="illust", nullable=False, index=True)
title: Mapped[str] = mapped_column(String(500), nullable=False)
author: Mapped[str | None] = mapped_column(String(200), nullable=True, index=True)
author_id: Mapped[str | None] = mapped_column(String(50), nullable=True)
page_count: Mapped[int] = mapped_column(Integer, default=1, nullable=False)
file_path: Mapped[str] = mapped_column(Text, nullable=False)
file_size: Mapped[int] = mapped_column(BigInteger, default=0, nullable=False)
thumbnail_path: Mapped[str | None] = mapped_column(Text, nullable=True)
mime_type: Mapped[str | None] = mapped_column(String(50), nullable=True)
width: Mapped[int | None] = mapped_column(Integer, nullable=True)
height: Mapped[int | None] = mapped_column(Integer, nullable=True)
tags: Mapped[list[str]] = mapped_column(JSON, default=list, nullable=False)
is_favorite: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False, index=True)
artwork_metadata: Mapped[dict] = mapped_column("metadata", JSON, default=dict, nullable=False)
last_viewed_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True, index=True)
user = relationship("User", back_populates="artworks")
file = relationship("UserFile")
ocr_text = relationship("ArtworkOcrText", back_populates="artwork", cascade="all, delete-orphan", uselist=False)
@property
def image_url(self) -> str | None:
if self.file_id:
return f"/api/v1/files/{self.file_id}/content"
if self.file_path.startswith(("http://", "https://")):
return self.file_path
return None
@property
def thumbnail_url(self) -> str | None:
if self.file_id:
return f"/api/v1/files/{self.file_id}/thumbnail"
if self.thumbnail_path and self.thumbnail_path.startswith(("http://", "https://")):
return self.thumbnail_path
return None
+27
View File
@@ -0,0 +1,27 @@
from __future__ import annotations
from datetime import datetime
from sqlalchemy import DateTime, ForeignKey, Index, String
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sakura_cloud.db.base import Base
from sakura_cloud.models.mixins import TimestampMixin, UUIDPrimaryKeyMixin
class Device(UUIDPrimaryKeyMixin, TimestampMixin, Base):
__tablename__ = "devices"
user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
device_name: Mapped[str] = mapped_column(String(100), nullable=False)
device_type: Mapped[str] = mapped_column(String(20), nullable=False)
device_token: Mapped[str | None] = mapped_column(String(255), nullable=True)
last_active_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
last_sync_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
user = relationship("User", back_populates="devices")
__table_args__ = (
Index("idx_devices_user_id", "user_id"),
Index("idx_devices_last_active", "last_active_at"),
)
+22
View File
@@ -0,0 +1,22 @@
from __future__ import annotations
from datetime import datetime
from sqlalchemy import DateTime, ForeignKey, Index, JSON, String, UniqueConstraint
from sqlalchemy.orm import Mapped, mapped_column
from sakura_cloud.db.base import Base
from sakura_cloud.models.mixins import TimestampMixin, UUIDPrimaryKeyMixin
class FeedCache(UUIDPrimaryKeyMixin, TimestampMixin, Base):
__tablename__ = "feed_cache"
__table_args__ = (
UniqueConstraint("user_id", "cache_key", name="uq_feed_cache_user_key"),
Index("ix_feed_cache_user_expires", "user_id", "expires_at"),
)
user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
cache_key: Mapped[str] = mapped_column(String(100), nullable=False)
payload: Mapped[list[dict]] = mapped_column(JSON, default=list, nullable=False)
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+55
View File
@@ -0,0 +1,55 @@
from __future__ import annotations
from datetime import datetime
from sqlalchemy import BigInteger, DateTime, ForeignKey, Index, String, Text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sakura_cloud.db.base import Base
from sakura_cloud.models.mixins import TimestampMixin, UUIDPrimaryKeyMixin, utc_now
class FileBlob(Base):
__tablename__ = "file_blobs"
sha256: Mapped[str] = mapped_column(String(64), primary_key=True)
storage_path: Mapped[str] = mapped_column(Text, nullable=False)
thumbnail_path: Mapped[str | None] = mapped_column(Text, nullable=True)
file_size: Mapped[int] = mapped_column(BigInteger, nullable=False)
mime_type: Mapped[str | None] = mapped_column(String(50), nullable=True)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utc_now, nullable=False)
user_files = relationship("UserFile", back_populates="blob")
class UserFile(UUIDPrimaryKeyMixin, Base):
__tablename__ = "user_files"
user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
file_sha256: Mapped[str] = mapped_column(String(64), ForeignKey("file_blobs.sha256", ondelete="CASCADE"), nullable=False)
original_name: Mapped[str] = mapped_column(String(255), nullable=False)
uploaded_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utc_now, nullable=False)
user = relationship("User", back_populates="files")
blob = relationship("FileBlob", back_populates="user_files")
__table_args__ = (Index("idx_user_files_user_id", "user_id"),)
class UploadSession(UUIDPrimaryKeyMixin, TimestampMixin, Base):
__tablename__ = "upload_sessions"
user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
sha256: Mapped[str] = mapped_column(String(64), nullable=False, index=True)
file_name: Mapped[str] = mapped_column(String(255), nullable=False)
file_size: Mapped[int] = mapped_column(BigInteger, nullable=False)
mime_type: Mapped[str | None] = mapped_column(String(50), nullable=True)
resource_type: Mapped[str] = mapped_column(String(20), default="image", nullable=False)
chunk_size: Mapped[int] = mapped_column(BigInteger, nullable=False)
received_size: Mapped[int] = mapped_column(BigInteger, default=0, nullable=False)
temp_path: Mapped[str] = mapped_column(Text, nullable=False)
status: Mapped[str] = mapped_column(String(20), default="pending", nullable=False)
user = relationship("User")
__table_args__ = (Index("idx_upload_sessions_user_id", "user_id"),)
+60
View File
@@ -0,0 +1,60 @@
from __future__ import annotations
from datetime import datetime
from sqlalchemy import Boolean, DateTime, ForeignKey, Index, JSON, String, Text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sakura_cloud.db.base import Base
from sakura_cloud.models.mixins import TimestampMixin, UUIDPrimaryKeyMixin
class CreatorFollow(UUIDPrimaryKeyMixin, TimestampMixin, Base):
__tablename__ = "creator_follows"
__table_args__ = (
Index("ix_creator_follows_user_enabled_updated", "user_id", "enabled", "updated_at"),
Index("ix_creator_follows_user_platform_creator", "user_id", "platform", "creator_id"),
)
user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
platform: Mapped[str] = mapped_column(String(20), nullable=False, index=True)
creator_id: Mapped[str] = mapped_column(String(100), nullable=False, index=True)
creator_name: Mapped[str | None] = mapped_column(String(200), nullable=True)
creator_handle: Mapped[str | None] = mapped_column(String(200), nullable=True)
profile_url: Mapped[str | None] = mapped_column(Text, nullable=True)
avatar_url: Mapped[str | None] = mapped_column(Text, nullable=True)
enabled: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False, index=True)
last_checked_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
latest_published_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
metadata_json: Mapped[dict] = mapped_column("metadata", JSON, default=dict, nullable=False)
user = relationship("User", back_populates="creator_follows")
class UpdateAlert(UUIDPrimaryKeyMixin, TimestampMixin, Base):
__tablename__ = "update_alerts"
__table_args__ = (
Index("ix_update_alerts_user_read_created", "user_id", "is_read", "created_at"),
Index("ix_update_alerts_user_created", "user_id", "created_at"),
Index("ix_update_alerts_user_platform_creator", "user_id", "platform", "creator_id"),
)
user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
follow_id: Mapped[str | None] = mapped_column(
String(36),
ForeignKey("creator_follows.id", ondelete="SET NULL"),
nullable=True,
index=True,
)
platform: Mapped[str] = mapped_column(String(20), nullable=False, index=True)
creator_id: Mapped[str] = mapped_column(String(100), nullable=False, index=True)
title: Mapped[str] = mapped_column(String(500), nullable=False)
body: Mapped[str | None] = mapped_column(Text, nullable=True)
content_type: Mapped[str | None] = mapped_column(String(20), nullable=True)
target_url: Mapped[str | None] = mapped_column(Text, nullable=True)
cover_url: Mapped[str | None] = mapped_column(Text, nullable=True)
is_read: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False, index=True)
payload_json: Mapped[dict] = mapped_column("payload", JSON, default=dict, nullable=False)
user = relationship("User", back_populates="update_alerts")
follow = relationship("CreatorFollow")
+29
View File
@@ -0,0 +1,29 @@
from __future__ import annotations
import uuid
from datetime import datetime, timezone
from sqlalchemy import DateTime, String
from sqlalchemy.orm import Mapped, mapped_column
def new_uuid() -> str:
return str(uuid.uuid4())
def utc_now() -> datetime:
return datetime.now(timezone.utc)
class UUIDPrimaryKeyMixin:
id: Mapped[str] = mapped_column(String(36), primary_key=True, default=new_uuid)
class TimestampMixin:
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utc_now, nullable=False)
updated_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True),
default=utc_now,
onupdate=utc_now,
nullable=False,
)
+50
View File
@@ -0,0 +1,50 @@
from __future__ import annotations
from datetime import datetime
from sqlalchemy import BigInteger, Boolean, DateTime, ForeignKey, Index, Integer, JSON, String, Text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sakura_cloud.db.base import Base
from sakura_cloud.models.mixins import TimestampMixin, UUIDPrimaryKeyMixin
class Novel(UUIDPrimaryKeyMixin, TimestampMixin, Base):
__tablename__ = "novels"
__table_args__ = (
Index("ix_novels_user_viewed", "user_id", "last_viewed_at"),
Index("ix_novels_user_read", "user_id", "last_read_at"),
Index("ix_novels_user_series_chapter", "user_id", "series_id", "chapter_order"),
Index("ix_novels_user_updated_desc", "user_id", "updated_at"),
Index("ix_novels_series_chapter_order", "series_id", "chapter_order"),
Index("ix_novels_user_favorite_viewed", "user_id", "is_favorite", "last_viewed_at"),
)
user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
file_id: Mapped[str | None] = mapped_column(String(36), ForeignKey("user_files.id", ondelete="SET NULL"), nullable=True)
source_id: Mapped[str | None] = mapped_column(String(50), nullable=True)
source_platform: Mapped[str] = mapped_column(String(20), nullable=False, index=True)
title: Mapped[str] = mapped_column(String(500), nullable=False)
author: Mapped[str | None] = mapped_column(String(200), nullable=True, index=True)
series_id: Mapped[str | None] = mapped_column(String(50), nullable=True, index=True)
series_title: Mapped[str | None] = mapped_column(String(500), nullable=True)
chapter_title: Mapped[str | None] = mapped_column(String(500), nullable=True)
chapter_order: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
description: Mapped[str | None] = mapped_column(Text, nullable=True)
file_path: Mapped[str] = mapped_column(Text, nullable=False)
file_size: Mapped[int] = mapped_column(BigInteger, default=0, nullable=False)
cover_path: Mapped[str | None] = mapped_column(Text, nullable=True)
word_count: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
current_page: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
bookmark: Mapped[str | None] = mapped_column(Text, nullable=True)
tags: Mapped[list[str]] = mapped_column(JSON, default=list, nullable=False)
is_favorite: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False, index=True)
last_read_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
last_viewed_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True, index=True)
user = relationship("User", back_populates="novels")
file = relationship("UserFile")
@property
def content_url(self) -> str | None:
return f"/api/v1/files/{self.file_id}/content" if self.file_id else None
+33
View File
@@ -0,0 +1,33 @@
from __future__ import annotations
from sqlalchemy import Float, ForeignKey, Index, Integer, String, Text, UniqueConstraint
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sakura_cloud.db.base import Base
from sakura_cloud.models.mixins import TimestampMixin, UUIDPrimaryKeyMixin
class ArtworkOcrText(UUIDPrimaryKeyMixin, TimestampMixin, Base):
__tablename__ = "artwork_ocr_texts"
__table_args__ = (
UniqueConstraint("user_id", "artwork_id", name="uq_artwork_ocr_texts_user_artwork"),
Index("ix_artwork_ocr_texts_user_artwork", "user_id", "artwork_id"),
Index("ix_artwork_ocr_texts_user_status", "user_id", "status"),
Index("ix_artwork_ocr_texts_user_source", "user_id", "source_platform", "source_id"),
)
user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
artwork_id: Mapped[str] = mapped_column(String(36), ForeignKey("artworks.id", ondelete="CASCADE"), nullable=False)
file_id: Mapped[str | None] = mapped_column(String(36), ForeignKey("user_files.id", ondelete="SET NULL"), nullable=True)
source_platform: Mapped[str | None] = mapped_column(String(20), nullable=True)
source_id: Mapped[str | None] = mapped_column(String(50), nullable=True)
language: Mapped[str] = mapped_column(String(20), default="mixed", nullable=False)
ocr_text: Mapped[str] = mapped_column(Text, default="", nullable=False)
confidence: Mapped[float | None] = mapped_column(Float, nullable=True)
engine: Mapped[str] = mapped_column(String(50), default="paddleocr", nullable=False)
status: Mapped[str] = mapped_column(String(20), default="pending", nullable=False, index=True)
attempts: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
error: Mapped[str | None] = mapped_column(Text, nullable=True)
artwork = relationship("Artwork", back_populates="ocr_text")
user = relationship("User", back_populates="artwork_ocr_texts")
+26
View File
@@ -0,0 +1,26 @@
from __future__ import annotations
from datetime import datetime
from sqlalchemy import Boolean, DateTime, ForeignKey, Index, String, Text, UniqueConstraint
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sakura_cloud.db.base import Base
from sakura_cloud.models.mixins import TimestampMixin, UUIDPrimaryKeyMixin
class PushDeviceToken(UUIDPrimaryKeyMixin, TimestampMixin, Base):
__tablename__ = "push_device_tokens"
__table_args__ = (
UniqueConstraint("user_id", "device_id", name="uq_push_device_tokens_user_device"),
Index("ix_push_device_tokens_user_active", "user_id", "is_active"),
)
user_id: Mapped[str] = mapped_column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
device_id: Mapped[str] = mapped_column(String(128), nullable=False)
platform: Mapped[str] = mapped_column(String(20), nullable=False)
fcm_token: Mapped[str] = mapped_column(Text, nullable=False)
is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False, index=True)
last_seen_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
user = relationship("User", back_populates="push_device_tokens")
+56
View File
@@ -0,0 +1,56 @@
from __future__ import annotations
from datetime import datetime
from enum import Enum
from sqlalchemy import BigInteger, DateTime, Enum as SqlEnum, Index, String, Text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sakura_cloud.core.config import settings
from sakura_cloud.db.base import Base
from sakura_cloud.models.mixins import TimestampMixin, UUIDPrimaryKeyMixin
class UserRole(str, Enum):
ADMIN = "admin"
SUPER_ADMIN = "super_admin"
USER = "user"
class User(UUIDPrimaryKeyMixin, TimestampMixin, Base):
__tablename__ = "users"
username: Mapped[str] = mapped_column(String(50), nullable=False, unique=True)
email: Mapped[str] = mapped_column(String(100), nullable=False, unique=True)
password_hash: Mapped[str] = mapped_column(String(255), nullable=False)
avatar: Mapped[str | None] = mapped_column(Text, nullable=True)
storage_used: Mapped[int] = mapped_column(BigInteger, default=0, nullable=False)
storage_limit: Mapped[int] = mapped_column(
BigInteger,
default=lambda: settings.default_storage_limit_bytes,
nullable=False,
)
role: Mapped[UserRole] = mapped_column(SqlEnum(UserRole), default=UserRole.USER, nullable=False)
is_active: Mapped[bool] = mapped_column(default=True, nullable=False, index=True)
disabled_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
disabled_reason: Mapped[str | None] = mapped_column(Text, nullable=True)
token_version: Mapped[int] = mapped_column(default=0, nullable=False)
reminder_enabled: Mapped[bool] = mapped_column(default=True, nullable=False)
reminder_hour: Mapped[int] = mapped_column(default=9, nullable=False)
reminder_minute: Mapped[int] = mapped_column(default=0, nullable=False)
reminder_timezone: Mapped[str] = mapped_column(String(64), default="Asia/Shanghai", nullable=False)
last_reminder_sent_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
artworks = relationship("Artwork", back_populates="user", cascade="all, delete-orphan")
novels = relationship("Novel", back_populates="user", cascade="all, delete-orphan")
devices = relationship("Device", back_populates="user", cascade="all, delete-orphan")
files = relationship("UserFile", back_populates="user", cascade="all, delete-orphan")
creator_follows = relationship("CreatorFollow", back_populates="user", cascade="all, delete-orphan")
update_alerts = relationship("UpdateAlert", back_populates="user", cascade="all, delete-orphan")
push_device_tokens = relationship("PushDeviceToken", back_populates="user", cascade="all, delete-orphan")
artwork_ocr_texts = relationship("ArtworkOcrText", back_populates="user", cascade="all, delete-orphan")
__table_args__ = (
Index("idx_users_username", "username"),
Index("idx_users_email", "email"),
)
@@ -0,0 +1,12 @@
[
{
"name": "精选50书源",
"mode": "novel",
"url": "/sources/精选50书源.json"
},
{
"name": "精选50漫画源",
"mode": "manga",
"url": "/sources/精选50漫画源.json"
}
]
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+17
View File
@@ -0,0 +1,17 @@
fastapi>=0.115.0
uvicorn[standard]>=0.30.0
SQLAlchemy>=2.0.30
psycopg[binary]>=3.2.0
alembic>=1.13.0
pydantic>=2.8.0
pydantic-settings>=2.4.0
email-validator>=2.2.0
python-jose[cryptography]>=3.3.0
passlib[bcrypt]>=1.7.4
python-multipart>=0.0.9
redis>=5.0.0
loguru>=0.7.2
Pillow>=10.4.0
requests>=2.31.0
beautifulsoup4>=4.12.0
lxml>=5.2.0
+38
View File
@@ -0,0 +1,38 @@
"""Pydantic schemas."""
from sakura_cloud.schemas.follow import (
CreatorFollowBulkUpsert,
CreatorFollowBulkUpsertResult,
CreatorFollowOut,
CreatorFollowUpsert,
UpdateAlertCreate,
UpdateAlertOut,
UpdateAlertReadUpdate,
)
from sakura_cloud.schemas.gallery import ArtworkCreate, ArtworkOut, ArtworkUpdate, ArtworkViewUpdate, TagsUpdate
from sakura_cloud.schemas.novel import (
BookmarkUpdate,
NovelOut,
NovelSeriesGroup,
NovelViewUpdate,
ReadingProgressUpdate,
)
__all__ = [
"ArtworkCreate",
"ArtworkOut",
"ArtworkUpdate",
"ArtworkViewUpdate",
"BookmarkUpdate",
"CreatorFollowOut",
"CreatorFollowBulkUpsert",
"CreatorFollowBulkUpsertResult",
"CreatorFollowUpsert",
"NovelOut",
"NovelSeriesGroup",
"NovelViewUpdate",
"ReadingProgressUpdate",
"TagsUpdate",
"UpdateAlertCreate",
"UpdateAlertOut",
"UpdateAlertReadUpdate",
]
+201
View File
@@ -0,0 +1,201 @@
from __future__ import annotations
from datetime import datetime
from typing import Generic, TypeVar
from pydantic import BaseModel, ConfigDict, Field
T = TypeVar("T")
class AdminPage(BaseModel):
page: int
limit: int
total: int
class AdminListResponse(BaseModel, Generic[T]):
items: list[T]
pagination: AdminPage
class AdminUserOut(BaseModel):
id: str
username: str
email: str
role: str
is_active: bool
disabled_at: datetime | None = None
disabled_reason: str | None = None
storage_used: int
storage_limit: int
created_at: datetime
updated_at: datetime
model_config = ConfigDict(from_attributes=True)
class AdminUserStatusUpdate(BaseModel):
is_active: bool
reason: str | None = Field(default=None, max_length=300)
class AdminUserRoleUpdate(BaseModel):
role: str = Field(pattern="^(user|admin|super_admin)$")
class AdminUserPasswordReset(BaseModel):
new_password: str = Field(min_length=8, max_length=128)
class AdminLoginRequest(BaseModel):
username_or_email: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=1, max_length=128)
class AdminAuditLogOut(BaseModel):
id: str
admin_user_id: str | None
action: str
target_type: str | None
target_id: str | None
ip_address: str | None
user_agent: str | None
detail_json: dict
created_at: datetime
model_config = ConfigDict(from_attributes=True)
class AdminStatsOut(BaseModel):
users: int
active_users: int
artworks: int
novels: int
files: int
storage_used: int
uploads_pending: int
ocr_pending: int
ocr_failed: int
push_devices: int
follows: int
alerts: int
class AdminFileStatOut(BaseModel):
files: int
bytes: int
mime_type: str | None
class AdminFileOut(BaseModel):
id: str
user_id: str
original_name: str
sha256_prefix: str
file_size: int
mime_type: str | None
uploaded_at: datetime
class AdminArtworkOut(BaseModel):
id: str
user_id: str
source_platform: str
content_type: str
title: str
author: str | None
file_size: int
is_favorite: bool
created_at: datetime
updated_at: datetime
model_config = ConfigDict(from_attributes=True)
class AdminNovelOut(BaseModel):
id: str
user_id: str
source_platform: str
title: str
author: str | None
series_id: str | None
series_title: str | None
file_size: int
updated_at: datetime
model_config = ConfigDict(from_attributes=True)
class AdminTaskOut(BaseModel):
id: str
user_id: str
status: str
file_name: str | None = None
resource_type: str | None = None
file_size: int | None = None
updated_at: datetime | None = None
class AdminOcrTaskOut(BaseModel):
id: str
user_id: str
artwork_id: str
status: str
language: str
confidence: float | None
engine: str
attempts: int
error: str | None
text_length: int
updated_at: datetime
class AdminPushDeviceOut(BaseModel):
id: str
user_id: str
device_id: str
platform: str
token_tail: str
is_active: bool
last_seen_at: datetime | None
updated_at: datetime
model_config = ConfigDict(from_attributes=True)
class AdminAlertStatOut(BaseModel):
platform: str
alerts: int
unread: int
class AdminAlertOut(BaseModel):
id: str
user_id: str
platform: str
creator_id: str
title: str
content_type: str | None
is_read: bool
created_at: datetime
model_config = ConfigDict(from_attributes=True)
class AdminHealthOut(BaseModel):
ok: bool
debug: bool
auto_migrate_on_startup: bool
database: str
storage_root: str
log_dir: str
app_version: str
class AdminLogLineOut(BaseModel):
line_no: int
text: str
class AdminMigrationOut(BaseModel):
version: str | None
+39
View File
@@ -0,0 +1,39 @@
from __future__ import annotations
from pydantic import BaseModel, EmailStr, Field, field_validator
class RegisterRequest(BaseModel):
username: str = Field(min_length=3, max_length=50)
email: EmailStr
password: str = Field(min_length=8, max_length=128)
@field_validator("username", mode="before")
@classmethod
def normalize_username(cls, value: str) -> str:
return value.strip() if isinstance(value, str) else value
@field_validator("email", mode="before")
@classmethod
def normalize_email(cls, value: object) -> object:
return value.strip().lower() if isinstance(value, str) else value
class LoginRequest(BaseModel):
username_or_email: str
password: str
@field_validator("username_or_email", mode="before")
@classmethod
def normalize_login_id(cls, value: str) -> str:
return value.strip() if isinstance(value, str) else value
class RefreshRequest(BaseModel):
refresh_token: str
class TokenPair(BaseModel):
access_token: str
refresh_token: str
token_type: str = "bearer"
+28
View File
@@ -0,0 +1,28 @@
from __future__ import annotations
from datetime import datetime, timezone
from typing import Generic, TypeVar
from pydantic import BaseModel, Field
T = TypeVar("T")
class ApiResponse(BaseModel, Generic[T]):
code: int = 200
message: str = "success"
data: T | None = None
timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
class Pagination(BaseModel):
page: int
limit: int
total: int
pages: int
class PageResponse(BaseModel, Generic[T]):
items: list[T]
pagination: Pagination
+29
View File
@@ -0,0 +1,29 @@
from __future__ import annotations
from datetime import datetime
from pydantic import BaseModel, ConfigDict, Field
class DeviceOut(BaseModel):
id: str
device_name: str
device_type: str
device_token: str | None
last_active_at: datetime | None
last_sync_at: datetime | None
created_at: datetime
updated_at: datetime
model_config = ConfigDict(from_attributes=True)
class DeviceRegister(BaseModel):
device_name: str = Field(min_length=1, max_length=100)
device_type: str = Field(min_length=1, max_length=20)
device_token: str | None = Field(default=None, max_length=255)
class DeviceUpdate(BaseModel):
device_name: str | None = Field(default=None, min_length=1, max_length=100)
device_token: str | None = Field(default=None, max_length=255)
+101
View File
@@ -0,0 +1,101 @@
from __future__ import annotations
from datetime import datetime
from pydantic import BaseModel, ConfigDict, Field
class CreatorFollowOut(BaseModel):
id: str
platform: str
creator_id: str
creator_name: str | None
creator_handle: str | None
profile_url: str | None
avatar_url: str | None
enabled: bool
last_checked_at: datetime | None
latest_published_at: datetime | None
metadata_json: dict = Field(default_factory=dict, serialization_alias="metadata")
created_at: datetime
updated_at: datetime
model_config = ConfigDict(from_attributes=True, populate_by_name=True)
@classmethod
def from_row(cls, row: object) -> "CreatorFollowOut":
return cls.model_validate(
{
"id": row.id,
"platform": row.platform,
"creator_id": row.creator_id,
"creator_name": row.creator_name,
"creator_handle": row.creator_handle,
"profile_url": row.profile_url,
"avatar_url": row.avatar_url,
"enabled": row.enabled,
"last_checked_at": row.last_checked_at,
"latest_published_at": row.latest_published_at,
"metadata_json": row.metadata_json or {},
"created_at": row.created_at,
"updated_at": row.updated_at,
}
)
class CreatorFollowUpsert(BaseModel):
platform: str = Field(max_length=20)
creator_id: str = Field(max_length=100)
creator_name: str | None = Field(default=None, max_length=200)
creator_handle: str | None = Field(default=None, max_length=200)
profile_url: str | None = None
avatar_url: str | None = None
enabled: bool = True
last_checked_at: datetime | None = None
latest_published_at: datetime | None = None
metadata: dict = Field(default_factory=dict)
class CreatorFollowBulkUpsert(BaseModel):
items: list[CreatorFollowUpsert] = Field(default_factory=list, max_length=1000)
class CreatorFollowBulkUpsertResult(BaseModel):
created: int = 0
updated: int = 0
skipped: int = 0
items: list[CreatorFollowOut] = Field(default_factory=list)
class UpdateAlertOut(BaseModel):
id: str
follow_id: str | None
platform: str
creator_id: str
title: str
body: str | None
content_type: str | None
target_url: str | None
cover_url: str | None
is_read: bool
payload_json: dict = Field(default_factory=dict, serialization_alias="payload")
created_at: datetime
updated_at: datetime
model_config = ConfigDict(from_attributes=True, populate_by_name=True)
class UpdateAlertCreate(BaseModel):
platform: str = Field(max_length=20)
creator_id: str = Field(max_length=100)
title: str = Field(max_length=500)
body: str | None = None
content_type: str | None = Field(default=None, max_length=20)
target_url: str | None = None
cover_url: str | None = None
created_at: datetime | None = None
payload: dict = Field(default_factory=dict)
class UpdateAlertReadUpdate(BaseModel):
is_read: bool = True
+64
View File
@@ -0,0 +1,64 @@
from __future__ import annotations
from datetime import datetime
from pydantic import BaseModel, ConfigDict, Field
class ArtworkOut(BaseModel):
id: str
source_id: str | None
source_platform: str
content_type: str
title: str
author: str | None
author_id: str | None
page_count: int
file_path: str
file_size: int
thumbnail_path: str | None
image_url: str | None = None
thumbnail_url: str | None = None
mime_type: str | None
width: int | None
height: int | None
tags: list[str]
is_favorite: bool
artwork_metadata: dict
last_viewed_at: datetime | None
created_at: datetime
updated_at: datetime
matched_by: str | None = None
model_config = ConfigDict(from_attributes=True)
class ArtworkCreate(BaseModel):
source_id: str | None = None
source_platform: str = Field(max_length=20)
content_type: str = Field(default="illust", 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)
page_count: int = 1
file_path: str
file_size: int = 0
thumbnail_path: str | None = None
mime_type: str | None = None
width: int | None = None
height: int | None = None
tags: list[str] = Field(default_factory=list)
metadata: dict = Field(default_factory=dict)
class ArtworkViewUpdate(BaseModel):
viewed: bool = True
class TagsUpdate(BaseModel):
tags: list[str] = Field(default_factory=list)
class ArtworkUpdate(BaseModel):
title: str = Field(min_length=1, max_length=500)
tags: list[str] = Field(default_factory=list)
+56
View File
@@ -0,0 +1,56 @@
from __future__ import annotations
from datetime import datetime
from pydantic import BaseModel, ConfigDict, Field
class NovelOut(BaseModel):
id: str
source_id: str | None
source_platform: str
title: str
author: str | None
series_id: str | None
series_title: str | None
chapter_title: str | None
chapter_order: int
description: str | None
file_path: str
file_size: int
content_url: str | None = None
cover_path: str | None
word_count: int
current_page: int
bookmark: str | None
tags: list[str]
is_favorite: bool
last_read_at: datetime | None
last_viewed_at: datetime | None
created_at: datetime
updated_at: datetime
model_config = ConfigDict(from_attributes=True)
class ReadingProgressUpdate(BaseModel):
current_page: int = Field(ge=0)
class BookmarkUpdate(BaseModel):
bookmark: str
class NovelViewUpdate(BaseModel):
viewed: bool = True
class NovelSeriesGroup(BaseModel):
series_id: str
series_title: str
author: str | None = None
chapter_count: int
cover_path: str | None = None
last_read_at: datetime | None = None
last_viewed_at: datetime | None = None
chapters: list[NovelOut]
+24
View File
@@ -0,0 +1,24 @@
from __future__ import annotations
from datetime import datetime
from pydantic import BaseModel, ConfigDict
class ArtworkOcrTextOut(BaseModel):
id: str
artwork_id: str
file_id: str | None
source_platform: str | None
source_id: str | None
language: str
ocr_text: str
confidence: float | None
engine: str
status: str
attempts: int
error: str | None
created_at: datetime
updated_at: datetime
model_config = ConfigDict(from_attributes=True)
+64
View File
@@ -0,0 +1,64 @@
from __future__ import annotations
import re
from datetime import datetime
from pydantic import BaseModel, ConfigDict, Field, field_validator
_DEVICE_ID_RE = re.compile(r"^[A-Za-z0-9_.:\-]{4,128}$")
_FCM_TOKEN_RE = re.compile(r"^[A-Za-z0-9_.:\-]+$")
class PushTokenRegister(BaseModel):
device_id: str = Field(min_length=4, max_length=128)
platform: str = Field(default="android", min_length=2, max_length=20)
fcm_token: str = Field(min_length=20, max_length=4096)
@field_validator("device_id")
@classmethod
def validate_device_id(cls, value: str) -> str:
cleaned = value.strip()
if not _DEVICE_ID_RE.fullmatch(cleaned):
raise ValueError("Invalid device_id format")
return cleaned
@field_validator("platform")
@classmethod
def validate_platform(cls, value: str) -> str:
cleaned = value.strip().lower()
if cleaned not in {"android"}:
raise ValueError("Unsupported push platform")
return cleaned
@field_validator("fcm_token")
@classmethod
def validate_fcm_token(cls, value: str) -> str:
cleaned = value.strip()
if not _FCM_TOKEN_RE.fullmatch(cleaned):
raise ValueError("Invalid fcm_token format")
return cleaned
class PushTokenUnregister(BaseModel):
device_id: str = Field(min_length=4, max_length=128)
@field_validator("device_id")
@classmethod
def validate_device_id(cls, value: str) -> str:
cleaned = value.strip()
if not _DEVICE_ID_RE.fullmatch(cleaned):
raise ValueError("Invalid device_id format")
return cleaned
class PushDeviceTokenOut(BaseModel):
id: str
device_id: str
platform: str
is_active: bool
created_at: datetime
updated_at: datetime
last_seen_at: datetime | None
model_config = ConfigDict(from_attributes=True)
+39
View File
@@ -0,0 +1,39 @@
from __future__ import annotations
from pydantic import BaseModel, Field
class UploadInitRequest(BaseModel):
sha256: str = Field(min_length=64, max_length=64)
file_name: str = Field(min_length=1, max_length=255)
file_size: int = Field(ge=0)
mime_type: str | None = Field(default=None, max_length=50)
resource_type: str = Field(default="image", max_length=20)
class UploadInitResponse(BaseModel):
upload_id: str
exists: bool
chunk_size: int
received_size: int
file_id: str | None = None
class UploadStatusResponse(BaseModel):
upload_id: str
sha256: str
file_name: str
file_size: int
received_size: int
status: str
class UploadCompleteRequest(BaseModel):
upload_id: str
class UploadCompleteResponse(BaseModel):
file_id: str
sha256: str
storage_path: str
file_size: int
+42
View File
@@ -0,0 +1,42 @@
from __future__ import annotations
from datetime import datetime
from pydantic import BaseModel, ConfigDict, EmailStr, Field
class UserOut(BaseModel):
id: str
username: str
email: EmailStr
avatar: str | None
storage_used: int
storage_limit: int
role: str
is_active: bool
disabled_at: datetime | None = None
disabled_reason: str | None = None
reminder_enabled: bool
reminder_hour: int
reminder_minute: int
reminder_timezone: str
last_reminder_sent_at: datetime | None
created_at: datetime
updated_at: datetime
model_config = ConfigDict(from_attributes=True)
class UserUpdate(BaseModel):
username: str | None = Field(default=None, min_length=3, max_length=50)
email: EmailStr | None = None
avatar: str | None = None
reminder_enabled: bool | None = None
reminder_hour: int | None = Field(default=None, ge=0, le=23)
reminder_minute: int | None = Field(default=None, ge=0, le=59)
reminder_timezone: str | None = Field(default=None, min_length=1, max_length=64)
class PasswordChangeRequest(BaseModel):
old_password: str
new_password: str = Field(min_length=8, max_length=128)
+1
View File
@@ -0,0 +1 @@
"""Operational scripts for Sakura Cloud."""
+59
View File
@@ -0,0 +1,59 @@
from __future__ import annotations
import argparse
import getpass
from sqlalchemy import func, or_, select
from sakura_cloud.core.security import hash_password
from sakura_cloud.db.session import SessionLocal
from sakura_cloud.models.user import User, UserRole
def main() -> None:
parser = argparse.ArgumentParser(description="Create or promote the first Sakura Cloud super admin.")
parser.add_argument("--username", required=True)
parser.add_argument("--email", required=True)
parser.add_argument("--password", default="")
args = parser.parse_args()
password = args.password or getpass.getpass("Password: ")
if len(password) < 8:
raise SystemExit("Password must be at least 8 characters.")
db = SessionLocal()
try:
existing_super = db.scalar(select(User).where(User.role == UserRole.SUPER_ADMIN))
existing = db.scalar(
select(User).where(
or_(
func.lower(User.username) == args.username.lower(),
func.lower(User.email) == args.email.lower(),
)
)
)
if existing is None:
user = User(
username=args.username.strip(),
email=args.email.strip().lower(),
password_hash=hash_password(password),
role=UserRole.SUPER_ADMIN,
is_active=True,
)
db.add(user)
db.commit()
print(f"Created super_admin: {user.username}")
return
if existing_super is not None and existing.role != UserRole.SUPER_ADMIN:
raise SystemExit("A super_admin already exists; refusing to promote another user from this script.")
existing.password_hash = hash_password(password)
existing.role = UserRole.SUPER_ADMIN
existing.is_active = True
db.commit()
print(f"Promoted super_admin: {existing.username}")
finally:
db.close()
if __name__ == "__main__":
main()
+14
View File
@@ -0,0 +1,14 @@
from __future__ import annotations
from sakura_cloud.db.base import Base
from sakura_cloud.db.session import engine
from sakura_cloud import models # noqa: F401
def main() -> None:
Base.metadata.create_all(bind=engine)
print("Sakura Cloud database tables created.")
if __name__ == "__main__":
main()
+1
View File
@@ -0,0 +1 @@
"""Application services."""
+45
View File
@@ -0,0 +1,45 @@
from __future__ import annotations
from fastapi import Request
from sqlalchemy.orm import Session
from sakura_cloud.models.admin import AdminAuditLog
from sakura_cloud.models.user import User
def write_admin_audit_log(
db: Session,
admin: User,
*,
action: str,
target_type: str | None = None,
target_id: str | None = None,
request: Request | None = None,
detail: dict | None = None,
) -> AdminAuditLog:
ip_address = request.client.host if request is not None and request.client is not None else None
user_agent = request.headers.get("User-Agent") if request is not None else None
row = AdminAuditLog(
admin_user_id=admin.id,
action=action,
target_type=target_type,
target_id=target_id,
ip_address=ip_address,
user_agent=user_agent,
detail_json=_redact_detail(detail or {}),
)
db.add(row)
db.commit()
db.refresh(row)
return row
def _redact_detail(value: dict) -> dict:
redacted: dict = {}
for key, item in value.items():
lowered = str(key).lower()
if any(marker in lowered for marker in ("password", "token", "secret", "cookie", "key")):
redacted[key] = "***"
else:
redacted[key] = item
return redacted
+21
View File
@@ -0,0 +1,21 @@
from __future__ import annotations
from pathlib import Path
from alembic import command
from alembic.config import Config
from sakura_cloud.core.config import settings
from sakura_cloud.core.logging import logger
def upgrade_database_to_head() -> None:
cloud_dir = Path(__file__).resolve().parents[1]
alembic_ini = cloud_dir / "alembic.ini"
config = Config(str(alembic_ini))
config.set_main_option("script_location", str(cloud_dir / "migrations"))
config.set_main_option("sqlalchemy.url", settings.database_url)
logger.info("Running database migrations to head")
command.upgrade(config, "head")
+163
View File
@@ -0,0 +1,163 @@
from __future__ import annotations
import threading
from pathlib import Path
from typing import Callable
from loguru import logger
from sqlalchemy import select
from sqlalchemy.orm import Session
from sakura_cloud.core.config import settings
from sakura_cloud.db.session import SessionLocal
from sakura_cloud.models.artwork import Artwork
from sakura_cloud.models.ocr import ArtworkOcrText
OcrExtractor = Callable[[Path], tuple[str, float | None, str]]
_semaphore = threading.BoundedSemaphore(settings.ocr_max_concurrency)
def queue_ocr_for_artwork(db: Session, artwork: Artwork) -> ArtworkOcrText | None:
if not settings.ocr_enabled:
return None
row = _get_or_create_row(db, artwork)
if row.status in {"pending", "running", "done"}:
return row
row.status = "pending"
row.error = None
db.commit()
return row
def run_ocr_for_artwork_id(artwork_id: str, user_id: str) -> None:
with SessionLocal() as db:
artwork = db.get(Artwork, artwork_id)
if artwork is None or artwork.user_id != user_id:
return
run_ocr_for_artwork(db, artwork)
def run_ocr_for_artwork(
db: Session,
artwork: Artwork,
*,
extractor: OcrExtractor | None = None,
) -> ArtworkOcrText:
row = _get_or_create_row(db, artwork)
if not settings.ocr_enabled and extractor is None:
row.status = "failed"
row.error = "ocr_disabled"
db.commit()
return row
if not _is_supported_image(artwork):
row.status = "failed"
row.error = "unsupported_file_type"
db.commit()
logger.info("OCR skipped artwork={} mime={}", artwork.id, artwork.mime_type)
return row
if row.status == "running":
return row
if row.attempts >= settings.ocr_max_attempts and extractor is None:
return row
acquired = _semaphore.acquire(blocking=False)
if not acquired:
row.status = "pending"
row.error = "ocr_busy"
db.commit()
return row
try:
row.status = "running"
row.attempts += 1
row.error = None
db.commit()
text, confidence, language = (extractor or _paddle_ocr_extract)(Path(artwork.file_path))
row.ocr_text = text.strip()
row.confidence = confidence
row.language = language or "mixed"
row.engine = "paddleocr"
row.status = "done"
row.error = None
db.commit()
logger.info("OCR done artwork={} text_len={} confidence={}", artwork.id, len(row.ocr_text), confidence)
return row
except Exception as exc:
row.status = "failed"
row.error = exc.__class__.__name__
db.commit()
logger.warning("OCR failed artwork={} attempt={} error={}", artwork.id, row.attempts, exc.__class__.__name__)
return row
finally:
_semaphore.release()
def _get_or_create_row(db: Session, artwork: Artwork) -> ArtworkOcrText:
row = db.scalar(
select(ArtworkOcrText).where(
ArtworkOcrText.user_id == artwork.user_id,
ArtworkOcrText.artwork_id == artwork.id,
)
)
if row is None:
row = ArtworkOcrText(
user_id=artwork.user_id,
artwork_id=artwork.id,
file_id=artwork.file_id,
source_platform=artwork.source_platform,
source_id=artwork.source_id,
status="pending",
)
db.add(row)
db.commit()
db.refresh(row)
else:
row.file_id = artwork.file_id
row.source_platform = artwork.source_platform
row.source_id = artwork.source_id
return row
def _is_supported_image(artwork: Artwork) -> bool:
mime = (artwork.mime_type or "").lower()
if mime in {"image/jpeg", "image/png", "image/webp"}:
return True
suffix = Path(artwork.file_path or "").suffix.lower()
return suffix in {".jpg", ".jpeg", ".png", ".webp"} and mime != "image/gif"
def _paddle_ocr_extract(path: Path) -> tuple[str, float | None, str]:
from PIL import Image
from paddleocr import PaddleOCR
if not path.is_file():
raise FileNotFoundError("image_not_found")
work_path = path
with Image.open(path) as image:
original_size = image.size
image.thumbnail((settings.ocr_max_image_dimension, settings.ocr_max_image_dimension))
if image.size != original_size:
tmp = path.with_suffix(".ocr-resized.jpg")
image.convert("RGB").save(tmp, quality=90)
work_path = tmp
ocr = PaddleOCR(use_angle_cls=True, lang=settings.ocr_language, use_gpu=False)
result = ocr.ocr(str(work_path), cls=True)
texts: list[str] = []
scores: list[float] = []
for page in result or []:
for line in page or []:
if len(line) >= 2 and isinstance(line[1], (list, tuple)):
text = str(line[1][0]).strip()
if text:
texts.append(text)
try:
scores.append(float(line[1][1]))
except (TypeError, ValueError, IndexError):
pass
if work_path != path:
work_path.unlink(missing_ok=True)
confidence = sum(scores) / len(scores) if scores else None
return "\n".join(texts), confidence, settings.ocr_language
+537
View File
@@ -0,0 +1,537 @@
from __future__ import annotations
import ipaddress
import json
import re
import socket
from dataclasses import dataclass
from html import unescape
from html.parser import HTMLParser
from typing import Any
from urllib.parse import quote, urljoin, urlparse
from urllib.request import Request, urlopen
from sakura_cloud.services import online_search_engine
from sakura_cloud.services.online_search_engine import (
OnlineSearchEngine,
SearchEngineError,
assert_public_url,
build_search_url,
parse_comic,
parse_novel,
resolve_resource_url,
search_resource,
source_type,
)
class OnlineSearchError(RuntimeError):
pass
@dataclass(frozen=True)
class OnlineSearchItem:
source_name: str
source_url: str
title: str
author: str | None
cover_url: str | None
detail_url: str
kind: str
def parse_source_payload(payload: Any) -> list[dict[str, Any]]:
if isinstance(payload, str):
payload = json.loads(payload)
if isinstance(payload, list):
rows = payload
elif isinstance(payload, dict):
for key in ("sources", "bookSources", "data", "list", "items", "results"):
value = payload.get(key)
if isinstance(value, list):
rows = value
break
else:
rows = [payload]
else:
rows = []
return [dict(item) for item in rows if isinstance(item, dict)]
def search_sources(
sources: list[dict[str, Any]],
keyword: str,
*,
mode: str,
limit_sources: int = 30,
per_source_limit: int = 20,
) -> list[OnlineSearchItem]:
results: list[OnlineSearchItem] = []
expected_type = 2 if mode == "manga" else 0
engine = OnlineSearchEngine(timeout=10.0)
for source in sources[:limit_sources]:
if _source_type(source) != expected_type:
continue
try:
online_search_engine.assert_public_url = _assert_public_url
engine._request_text = ( # type: ignore[method-assign]
lambda rule, url, data=None, _source=source: _fetch_text(url, rule.base_url, _source)
)
candidates = engine.search_legado_source(source, keyword, mode=mode, limit=per_source_limit)
results.extend(
OnlineSearchItem(
source_name=item.source_name,
source_url=item.source_url,
title=item.title,
author=item.author,
cover_url=item.cover,
detail_url=item.url,
kind=mode,
)
for item in candidates
)
except SearchEngineError:
continue
except Exception:
continue
return results
def _search_one(source: dict[str, Any], keyword: str, *, mode: str, limit: int) -> list[OnlineSearchItem]:
source_name = _string(source.get("bookSourceName") or source.get("sourceName") or source.get("name")) or "未命名源"
source_url = _string(source.get("bookSourceUrl") or source.get("sourceUrl") or source.get("url")) or ""
search_url = _string(source.get("searchUrl"))
rule_search = source.get("ruleSearch") if isinstance(source.get("ruleSearch"), dict) else {}
if not search_url:
search_url = _string(rule_search.get("url") or rule_search.get("searchUrl")) or ""
if not source_url or not search_url:
return []
final_url = _resolve_url(source_url, _build_search_url(search_url, keyword))
_assert_public_url(final_url)
body = _fetch_text(final_url, source_url, source)
list_rule = _first_string(
rule_search,
"bookList",
"comicList",
"list",
"items",
"data",
"results",
)
if list_rule:
parsed = _parse_by_rules(body, final_url, source, source_name, source_url, rule_search, mode, limit)
if parsed:
return parsed
if mode == "manga":
return _fallback_manga(body, final_url, source_name, source_url, keyword, limit)
return _fallback_novel(body, final_url, source_name, source_url, keyword, limit)
def _parse_by_rules(
body: str,
base_url: str,
source: dict[str, Any],
source_name: str,
source_url: str,
rule_search: dict[str, Any],
mode: str,
limit: int,
) -> list[OnlineSearchItem]:
fragments = _select_list(body, _first_string(rule_search, "bookList", "comicList", "list", "items", "data", "results"))
results: list[OnlineSearchItem] = []
seen: set[str] = set()
for fragment in fragments:
title = _select_one(fragment, _first_string(rule_search, "name", "bookName", "comicName", "title"))
detail = _select_one(fragment, _first_string(rule_search, "bookUrl", "comicUrl", "detailUrl", "url", "href"))
if not title or not detail:
continue
detail_url = _resolve_url(base_url, detail)
if detail_url in seen:
continue
seen.add(detail_url)
results.append(
OnlineSearchItem(
source_name=source_name,
source_url=source_url,
title=title,
author=_select_one(fragment, _first_string(rule_search, "author", "bookAuthor", "comicAuthor", "writer")) or None,
cover_url=_maybe_url(base_url, _select_one(fragment, _first_string(rule_search, "coverUrl", "cover", "bookCover", "comicCover", "img", "image"))),
detail_url=detail_url,
kind=mode,
)
)
if len(results) >= limit:
break
return results
def _fallback_manga(
body: str,
base_url: str,
source_name: str,
source_url: str,
keyword: str,
limit: int,
) -> list[OnlineSearchItem]:
decoded = _decode_json_like(body)
results: list[OnlineSearchItem] = []
seen: set[str] = set()
if decoded is not None:
for node in _walk_dicts(decoded):
title = _first_value(node, "title", "name", "comicName", "comic_name", "topic_title", "topicTitle", "bookName")
if not _matches(title, keyword):
continue
detail = _first_value(node, "url", "href", "link", "bookUrl", "book_url", "comicUrl", "comic_url", "detailUrl", "detail_url", "path")
if not detail:
detail = _first_value(node, "id", "book_id", "comic_id", "topic_id")
if not detail:
continue
detail_url = _resolve_url(base_url, detail)
if detail_url in seen:
continue
seen.add(detail_url)
results.append(
OnlineSearchItem(
source_name=source_name,
source_url=source_url,
title=title,
author=_first_value(node, "author", "writer", "nickname", "user_name", "userName") or None,
cover_url=_maybe_url(base_url, _first_value(node, "cover", "coverUrl", "cover_url", "image", "imageUrl", "image_url", "pic", "pic_url", "vertical_image_url")),
detail_url=detail_url,
kind="manga",
)
)
if len(results) >= limit:
return results
if results:
return results
return _fallback_html_cards(body, base_url, source_name, source_url, keyword, "manga", limit)
def _fallback_novel(
body: str,
base_url: str,
source_name: str,
source_url: str,
keyword: str,
limit: int,
) -> list[OnlineSearchItem]:
decoded = _decode_json_like(body)
results: list[OnlineSearchItem] = []
if decoded is not None:
for node in _walk_dicts(decoded):
title = _first_value(node, "title", "name", "bookName", "book_name", "novelName")
detail = _first_value(node, "url", "href", "link", "bookUrl", "book_url", "detailUrl", "detail_url")
if not _matches(title, keyword) or not detail:
continue
results.append(
OnlineSearchItem(
source_name=source_name,
source_url=source_url,
title=title,
author=_first_value(node, "author", "bookAuthor", "writer") or None,
cover_url=_maybe_url(base_url, _first_value(node, "cover", "coverUrl", "cover_url", "img", "image")),
detail_url=_resolve_url(base_url, detail),
kind="novel",
)
)
if len(results) >= limit:
return results
return results or _fallback_html_cards(body, base_url, source_name, source_url, keyword, "novel", limit)
def _fallback_html_cards(
body: str,
base_url: str,
source_name: str,
source_url: str,
keyword: str,
kind: str,
limit: int,
) -> list[OnlineSearchItem]:
parser = _AnchorParser()
parser.feed(body)
results: list[OnlineSearchItem] = []
seen: set[str] = set()
for anchor in parser.anchors:
title = _clean(anchor.get("title") or anchor.get("alt") or anchor.get("text") or "")
href = _clean(anchor.get("href") or "")
if not href or not _matches(title, keyword):
continue
detail_url = _resolve_url(base_url, href)
if detail_url in seen:
continue
seen.add(detail_url)
results.append(
OnlineSearchItem(
source_name=source_name,
source_url=source_url,
title=title,
author=None,
cover_url=_maybe_url(base_url, anchor.get("img") or ""),
detail_url=detail_url,
kind=kind,
)
)
if len(results) >= limit:
break
return results
def _select_list(body: str, rule: str | None) -> list[str]:
if not rule:
return []
for part in _split_rule(rule, "||"):
if part.lower().startswith("regex:"):
pattern = _strip_replace(part.split(":", 1)[1])
matches = re.findall(pattern, body, re.I | re.S)
output = [_clean(item[0] if isinstance(item, tuple) else item) for item in matches]
if output:
return [item for item in output if item]
if part.startswith("$.") or part.startswith("$["):
decoded = _decode_json_like(body)
values = _json_path(decoded, part) if decoded is not None else []
output = [json.dumps(value, ensure_ascii=False) if isinstance(value, (dict, list)) else str(value) for value in values]
if output:
return output
matches = _html_rule_list(body, part)
if matches:
return matches
return []
def _select_one(fragment: str, rule: str | None) -> str:
values = _select_list(fragment, rule)
return values[0] if values else ""
def _html_rule_list(body: str, rule: str) -> list[str]:
rule = _strip_replace(rule.strip())
if not rule:
return []
tokens = [item.strip() for item in rule.split("@") if item.strip()]
selector = tokens[0] if tokens else rule
attr = tokens[-1] if tokens and tokens[-1] not in {selector, "text", "html"} else ""
if selector.startswith("class."):
classes = [item for item in selector[6:].split() if item]
class_checks = "".join(rf'(?=[^"\']*{re.escape(item)})' for item in classes[:3])
pattern = rf'<(?P<tag>[a-zA-Z0-9]+)\b[^>]*class=["\']{class_checks}[^"\']*["\'][^>]*>.*?</(?P=tag)>'
elif selector.startswith("id."):
pattern = rf'<(?P<tag>[a-zA-Z0-9]+)\b[^>]*id=["\']{re.escape(selector[3:])}["\'][^>]*>.*?</(?P=tag)>'
elif selector.startswith("tag."):
tag = re.escape(selector[4:])
pattern = rf'<{tag}\b[^>]*>.*?</{tag}>'
elif selector.startswith("$.") or selector.startswith("$["):
decoded = _decode_json_like(body)
return [json.dumps(value, ensure_ascii=False) if isinstance(value, (dict, list)) else str(value) for value in _json_path(decoded, selector)]
else:
pattern = rf'<a\b[^>]*>.*?</a>' if "href" in tokens else ""
if not pattern:
return []
blocks = [m.group(0) for m in re.finditer(pattern, body, re.I | re.S)]
if attr and attr not in {"text", "html"}:
return [_clean(m.group(1)) for block in blocks for m in [re.search(rf'{re.escape(attr)}=["\']([^"\']+)["\']', block, re.I)] if m]
if "text" in tokens:
return [_html_text(block) for block in blocks]
return blocks
def _json_path(decoded: Any, rule: str) -> list[Any]:
if decoded is None:
return []
path = re.sub(r"^\$\.?", "", rule.strip())
if path in {"", "*", "[*]"}:
return decoded if isinstance(decoded, list) else [decoded]
current = [decoded]
for segment in [item for item in path.split(".") if item]:
next_values: list[Any] = []
star = segment.endswith("[*]")
key = segment[:-3] if star else segment
for value in current:
child = value.get(key) if isinstance(value, dict) and key else value
if star and isinstance(child, list):
next_values.extend(child)
elif child is not None:
next_values.append(child)
current = next_values
return current
class _AnchorParser(HTMLParser):
def __init__(self) -> None:
super().__init__()
self.anchors: list[dict[str, str]] = []
self._current: dict[str, str] | None = None
def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
attr = {key: value or "" for key, value in attrs}
if tag.lower() == "a" and attr.get("href"):
self._current = {"href": attr.get("href", ""), "title": attr.get("title", ""), "text": ""}
elif tag.lower() == "img" and self._current is not None:
for key in ("data-original", "data-src", "src"):
if attr.get(key):
self._current["img"] = attr[key]
break
if attr.get("alt"):
self._current["alt"] = attr["alt"]
def handle_data(self, data: str) -> None:
if self._current is not None:
self._current["text"] = f'{self._current.get("text", "")} {data}'
def handle_endtag(self, tag: str) -> None:
if tag.lower() == "a" and self._current is not None:
self.anchors.append(self._current)
self._current = None
def _fetch_text(url: str, referer: str, source: dict[str, Any]) -> str:
headers = {
"User-Agent": _string(source.get("httpUserAgent")) or "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120 Safari/537.36",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,application/json;q=0.8,*/*;q=0.7",
"Accept-Language": "zh-CN,zh;q=0.9",
"Referer": referer,
}
extra = source.get("headers") or source.get("header")
if isinstance(extra, dict):
for key, value in extra.items():
if str(key).lower() in {"cookie", "authorization"}:
continue
headers[str(key)] = str(value)
with urlopen(Request(url, headers=headers), timeout=12) as response:
raw = response.read(2_000_000)
content_type = response.headers.get("content-type", "")
charset = _string(source.get("charset") or source.get("encoding")) or _charset_from_content_type(content_type) or "utf-8"
for candidate in (charset, "utf-8", "gb18030", "gbk", "gb2312"):
try:
return raw.decode(candidate, errors="replace")
except LookupError:
continue
return raw.decode("utf-8", errors="replace")
def _assert_public_url(url: str) -> None:
parsed = urlparse(url)
if parsed.scheme not in {"http", "https"} or not parsed.hostname:
raise OnlineSearchError("Only http/https source URLs are allowed")
infos = socket.getaddrinfo(parsed.hostname, parsed.port or (443 if parsed.scheme == "https" else 80), type=socket.SOCK_STREAM)
for item in infos:
ip = ipaddress.ip_address(item[4][0])
if ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_multicast or ip.is_reserved:
raise OnlineSearchError("Private network source URLs are not allowed")
def _build_search_url(template: str, keyword: str) -> str:
encoded = quote(keyword, safe="")
value = template.strip()
for token in ("{{key}}", "{{keyword}}", "{key}", "{keyword}", "<key>", "<keyword>", "searchKey"):
value = value.replace(token, encoded)
value = value.replace("%s", encoded, 1)
return value.replace("{{page}}", "1").replace("{page}", "1").replace("<page>", "1")
def _resolve_url(base: str, value: str) -> str:
return urljoin(base, value.strip())
def _maybe_url(base: str, value: str | None) -> str | None:
text = _clean(value or "")
if not text or text.lower() == "null":
return None
return _resolve_url(base, text)
def _decode_json_like(body: str) -> Any:
text = body.lstrip("\ufeff \t\r\n")
match = re.match(r"^[a-zA-Z_$][\w$]*\s*\((.*)\)\s*;?\s*$", text, re.S)
if match:
text = match.group(1)
try:
return json.loads(text)
except Exception:
return None
def _walk_dicts(node: Any):
if isinstance(node, dict):
yield node
for value in node.values():
yield from _walk_dicts(value)
elif isinstance(node, list):
for item in node:
yield from _walk_dicts(item)
def _first_value(node: dict[str, Any], *keys: str) -> str:
for key in keys:
value = node.get(key)
if value is not None:
text = _clean(str(value))
if text and text.lower() != "null":
return text
return ""
def _first_string(mapping: dict[str, Any], *keys: str) -> str | None:
for key in keys:
value = _string(mapping.get(key))
if value:
return value
return None
def _source_type(source: dict[str, Any]) -> int:
value = source.get("bookSourceType", source.get("sourceType", source.get("type", 0)))
try:
numeric = int(value)
except Exception:
numeric = 0
text = json.dumps(source, ensure_ascii=False).lower()
manga_markers = (
"comiclist",
"comicname",
"comicurl",
"imageStyle".lower(),
"chapterImages".lower(),
"manga",
"manhua",
"漫画",
)
if numeric == 0 and any(marker in text for marker in manga_markers):
return 2
return numeric
def _split_rule(rule: str, sep: str) -> list[str]:
return [item.strip() for item in rule.split(sep) if item.strip()]
def _strip_replace(rule: str) -> str:
return re.split(r"##|###", rule, maxsplit=1)[0].strip()
def _string(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _matches(title: str, keyword: str) -> bool:
title = _clean(title).lower()
keyword = _clean(keyword).lower()
return bool(title) and (not keyword or keyword in title)
def _clean(value: str) -> str:
return unescape(re.sub(r"\s+", " ", value or "")).strip()
def _html_text(value: str) -> str:
return _clean(re.sub(r"<[^>]+>", " ", value))
def _charset_from_content_type(value: str) -> str | None:
match = re.search(r"charset=([^;]+)", value or "", re.I)
return match.group(1).strip("\"'") if match else None
File diff suppressed because it is too large. Load diff
+160
View File
@@ -0,0 +1,160 @@
from __future__ import annotations
import json
from collections.abc import Callable
from dataclasses import dataclass
from typing import Any
from loguru import logger
from sqlalchemy import select
from sqlalchemy.orm import Session
from sakura_cloud.core.config import settings
from sakura_cloud.models.follow import UpdateAlert
from sakura_cloud.models.mixins import utc_now
from sakura_cloud.models.push import PushDeviceToken
PushSender = Callable[[str, str, str, dict[str, str]], bool]
@dataclass
class PushSendSummary:
attempted: int = 0
sent: int = 0
disabled: int = 0
failed: int = 0
def send_update_alert_push(
db: Session,
alert: UpdateAlert,
*,
sender: PushSender | None = None,
) -> PushSendSummary:
payload = alert.payload_json or {}
if alert.platform == "system":
title = alert.title
body = alert.body or ""
else:
title = "你关注的作者有新作品"
author_name = (
payload.get("author_name")
or payload.get("creator_name")
or payload.get("creator_handle")
or payload.get("author")
or alert.creator_id
)
body = f"{author_name} 发布了 {alert.title}"
data = {
"alert_id": alert.id,
"source_platform": alert.platform,
"source_id": str(payload.get("source_id") or payload.get("id") or alert.creator_id),
"resource_type": str(payload.get("resource_type") or alert.content_type or ""),
}
return send_push_to_user(db, alert.user_id, title, body, data, sender=sender)
def send_push_to_user(
db: Session,
user_id: str,
title: str,
body: str,
data: dict[str, Any] | None = None,
*,
sender: PushSender | None = None,
) -> PushSendSummary:
rows = db.scalars(
select(PushDeviceToken).where(
PushDeviceToken.user_id == user_id,
PushDeviceToken.is_active.is_(True),
)
).all()
summary = PushSendSummary(attempted=len(rows))
if not rows:
return summary
safe_data = {key: "" if value is None else str(value) for key, value in (data or {}).items()}
disabled_any = False
for row in rows:
try:
ok = sender(row.fcm_token, title, body, safe_data) if sender else _send_fcm(row.fcm_token, title, body, safe_data)
except Exception as exc: # pragma: no cover - defensive guard around provider SDK.
if _is_invalid_token_error(exc):
_disable_token(row)
disabled_any = True
summary.disabled += 1
logger.warning("Disabled invalid FCM token for user={} device={}", user_id, row.device_id)
else:
summary.failed += 1
logger.warning("FCM push failed for user={} device={}: {}", user_id, row.device_id, exc.__class__.__name__)
continue
if ok:
summary.sent += 1
logger.info("FCM push sent for user={} device={} alert={}", user_id, row.device_id, safe_data.get("alert_id", ""))
else:
_disable_token(row)
disabled_any = True
summary.disabled += 1
logger.warning("Disabled invalid FCM token for user={} device={}", user_id, row.device_id)
if disabled_any:
db.commit()
return summary
def _disable_token(row: PushDeviceToken) -> None:
row.is_active = False
row.last_seen_at = utc_now()
def _send_fcm(token: str, title: str, body: str, data: dict[str, str]) -> bool:
if not settings.fcm_enabled:
logger.debug("FCM push skipped because FCM_ENABLED is false")
return True
app, messaging = _firebase_context()
if app is None or messaging is None:
logger.debug("FCM push skipped because Firebase credentials are not configured")
return True
message = messaging.Message(
token=token,
notification=messaging.Notification(title=title, body=body),
data=data,
android=messaging.AndroidConfig(priority="high"),
)
messaging.send(message, app=app)
return True
def _firebase_context() -> tuple[Any | None, Any | None]:
credential_json = settings.firebase_credentials_json.strip()
credential_path = settings.firebase_credentials_path.strip()
if not credential_json and not credential_path:
return None, None
try:
import firebase_admin
from firebase_admin import credentials, messaging
except ImportError:
logger.warning("firebase-admin is not installed; FCM push is disabled")
return None, None
if firebase_admin._apps:
return firebase_admin.get_app(), messaging
if credential_json:
cred = credentials.Certificate(json.loads(credential_json))
else:
cred = credentials.Certificate(credential_path)
return firebase_admin.initialize_app(cred), messaging
def _is_invalid_token_error(exc: Exception) -> bool:
name = exc.__class__.__name__
if name in {"UnregisteredError", "SenderIdMismatchError", "InvalidArgumentError"}:
return True
text = str(exc).lower()
return "registration token" in text or "not a valid fcm" in text or "unregistered" in text
+137
View File
@@ -0,0 +1,137 @@
from __future__ import annotations
from datetime import timedelta, timezone
from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
from sqlalchemy import func, select
from sqlalchemy.orm import Session
from sakura_cloud.models.follow import UpdateAlert
from sakura_cloud.models.mixins import utc_now
from sakura_cloud.models.user import User
from sakura_cloud.services.push import send_update_alert_push
DEFAULT_REMINDER_TIMEZONE = "Asia/Shanghai"
DIGEST_PLATFORM = "system"
DIGEST_CREATOR_ID = "daily-reminder"
def _resolve_timezone(name: str | None) -> ZoneInfo:
try:
return ZoneInfo(name or DEFAULT_REMINDER_TIMEZONE)
except ZoneInfoNotFoundError:
return ZoneInfo(DEFAULT_REMINDER_TIMEZONE)
def _display_platform(platform: str) -> str:
if platform.lower() == "pixiv":
return "Pixiv"
if platform.lower() == "x":
return "X"
return platform
def run_daily_reminder_digest(db: Session) -> int:
now_utc = utc_now()
users = db.scalars(select(User).where(User.reminder_enabled.is_(True))).all()
reminders_created = 0
for user in users:
zone = _resolve_timezone(user.reminder_timezone)
local_now = now_utc.astimezone(zone)
scheduled_today = local_now.replace(
hour=user.reminder_hour,
minute=user.reminder_minute,
second=0,
microsecond=0,
)
if local_now < scheduled_today:
continue
if user.last_reminder_sent_at is not None:
last_sent_local = user.last_reminder_sent_at.astimezone(zone)
if last_sent_local.date() == local_now.date():
continue
window_start = (
user.last_reminder_sent_at
if user.last_reminder_sent_at is not None
else (scheduled_today - timedelta(days=1)).astimezone(timezone.utc)
)
new_alert_count = db.scalar(
select(func.count(UpdateAlert.id)).where(
UpdateAlert.user_id == user.id,
UpdateAlert.platform != DIGEST_PLATFORM,
UpdateAlert.created_at > window_start,
)
) or 0
recent_alerts = db.scalars(
select(UpdateAlert)
.where(
UpdateAlert.user_id == user.id,
UpdateAlert.platform != DIGEST_PLATFORM,
UpdateAlert.created_at > window_start,
)
.order_by(UpdateAlert.created_at.desc())
.limit(5)
).all()
creator_names: list[str] = []
platforms: list[str] = []
for alert in recent_alerts:
platform = _display_platform(alert.platform)
if platform not in platforms:
platforms.append(platform)
candidate = (
alert.payload_json.get("creator_name")
or alert.payload_json.get("creator_handle")
or alert.payload_json.get("author")
or alert.creator_id
)
if candidate and candidate not in creator_names:
creator_names.append(str(candidate))
date_text = f"{local_now.month}月{local_now.day}日"
platforms_text = " / ".join(platforms) if platforms else "Pixiv / X"
creators_text = ", ".join(creator_names[:3])
title = f"{date_text},未更新" if not new_alert_count else f"{date_text},更新 {new_alert_count} 条记录"
if not new_alert_count:
body = f"{date_text} 暂未发现关注作者的新内容。云端会在明天 {user.reminder_hour:02d}:{user.reminder_minute:02d} 继续检查。"
elif creators_text:
body = (
f"{date_text},{creators_text} 等作者带来了 {new_alert_count} "
f"条新动态,来自 {platforms_text}。"
)
else:
body = f"{date_text},你关注的作者有 {new_alert_count} 条新动态,来自 {platforms_text}。"
digest_alert = UpdateAlert(
user_id=user.id,
follow_id=None,
platform=DIGEST_PLATFORM,
creator_id=DIGEST_CREATOR_ID,
title=title,
body=body,
content_type="digest",
payload_json={
"kind": "daily_digest",
"window_start": window_start.isoformat(),
"new_alert_count": int(new_alert_count),
"platforms": platforms,
"creators": creator_names[:5],
"date": local_now.date().isoformat(),
"status": "updated" if new_alert_count else "not_updated",
},
)
db.add(digest_alert)
user.last_reminder_sent_at = now_utc
db.commit()
db.refresh(digest_alert)
send_update_alert_push(db, digest_alert)
reminders_created += 1
return reminders_created
+294
View File
@@ -0,0 +1,294 @@
from __future__ import annotations
import hashlib
import os
import shutil
from datetime import datetime, timedelta, timezone
from pathlib import Path
from uuid import uuid4
from fastapi import HTTPException, UploadFile, status
from sqlalchemy import func, select
from sqlalchemy.orm import Session
from sakura_cloud.core.config import settings
from sakura_cloud.core.safety import is_allowed_upload_mime, is_safe_upload_filename
from sakura_cloud.models.file import FileBlob, UploadSession, UserFile
from sakura_cloud.models.user import User
from sakura_cloud.schemas.upload import UploadCompleteResponse, UploadInitRequest, UploadInitResponse
from sakura_cloud.services.thumbnails import generate_webp_thumbnail
def _ensure_storage_quota(user: User, incoming_size: int) -> None:
size = max(0, incoming_size)
if size and user.storage_used + size > user.storage_limit:
raise HTTPException(status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, detail="Storage quota exceeded")
def _is_video_mime(mime_type: str | None) -> bool:
return (mime_type or "").lower().strip().startswith("video/")
def _user_video_storage_used(user_id: str, db: Session) -> int:
value = db.scalar(
select(func.coalesce(func.sum(FileBlob.file_size), 0))
.join(UserFile, UserFile.file_sha256 == FileBlob.sha256)
.where(UserFile.user_id == user_id, FileBlob.mime_type.like("video/%"))
)
return int(value or 0)
def _ensure_video_storage_quota(user: User, incoming_size: int, db: Session) -> None:
size = max(0, incoming_size)
if size and _user_video_storage_used(user.id, db) + size > settings.video_storage_limit_bytes:
raise HTTPException(
status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
detail=f"Video storage quota exceeded ({settings.video_storage_limit_gb}GB)",
)
def _root() -> Path:
root = Path(settings.storage_root)
root.mkdir(parents=True, exist_ok=True)
return root
def temp_upload_path(user_id: str, upload_id: str) -> Path:
path = _root() / "tmp" / user_id
path.mkdir(parents=True, exist_ok=True)
return path / f"{upload_id}.part"
def _replacement_temp_upload_path(user_id: str, upload_id: str) -> Path:
path = _root() / "tmp" / user_id
path.mkdir(parents=True, exist_ok=True)
return path / f"{upload_id}-{uuid4().hex[:8]}.part"
def blob_storage_path(resource_type: str, user_id: str, sha256: str, file_name: str) -> Path:
now = datetime.now(timezone.utc)
ext = Path(file_name).suffix.lower() or ".bin"
kind = "novels" if resource_type == "novel" else "videos" if resource_type == "video" else "images"
path = _root() / "uploads" / kind / user_id / str(now.year) / f"{now.month:02d}"
path.mkdir(parents=True, exist_ok=True)
return path / f"{sha256[:16]}{ext}"
def _open_temp_file_for_append(temp_path: Path):
temp_path.parent.mkdir(parents=True, exist_ok=True)
return temp_path.open("ab")
def _reset_unwritable_upload_session(session: UploadSession, db: Session) -> Path:
old_path = Path(session.temp_path or "")
new_path = _replacement_temp_upload_path(session.user_id, session.id)
if old_path and old_path != new_path:
try:
if old_path.is_file():
old_path.unlink()
except OSError:
pass
session.temp_path = str(new_path)
session.received_size = 0
session.status = "pending"
db.commit()
db.refresh(session)
return new_path
def calculate_sha256(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as fp:
for chunk in iter(lambda: fp.read(1024 * 1024), b""):
digest.update(chunk)
return digest.hexdigest()
def cleanup_stale_uploads(db: Session, *, older_than: timedelta | None = None) -> int:
cutoff = datetime.now(timezone.utc) - (older_than or timedelta(hours=settings.temp_upload_ttl_hours))
sessions = db.scalars(
select(UploadSession).where(
UploadSession.status != "completed",
UploadSession.updated_at < cutoff,
)
).all()
removed = 0
for session in sessions:
if session.temp_path:
Path(session.temp_path).unlink(missing_ok=True)
db.delete(session)
removed += 1
if removed:
db.commit()
return removed
def init_upload(payload: UploadInitRequest, user: User, db: Session) -> UploadInitResponse:
is_video = _is_video_mime(payload.mime_type)
resource_type = "video" if is_video else payload.resource_type
max_upload_mb = settings.max_video_upload_size_mb if is_video else settings.max_upload_size_mb
max_upload_size = max_upload_mb * 1024 * 1024
if payload.file_size > max_upload_size:
raise HTTPException(status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, detail="File is too large")
if not is_safe_upload_filename(payload.file_name):
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid file name")
if resource_type not in {"image", "novel", "video"}:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid resource type")
if not is_allowed_upload_mime(payload.mime_type):
raise HTTPException(status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE, detail="Unsupported MIME type")
if resource_type == "video" and not is_video:
raise HTTPException(status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE, detail="Unsupported video MIME type")
cleanup_stale_uploads(db)
existing_blob = db.get(FileBlob, payload.sha256)
existing_user_file = None
if existing_blob is not None:
existing_user_file = db.scalar(
select(UserFile).where(UserFile.user_id == user.id, UserFile.file_sha256 == payload.sha256)
)
if existing_user_file is None:
_ensure_storage_quota(user, existing_blob.file_size)
if _is_video_mime(existing_blob.mime_type):
_ensure_video_storage_quota(user, existing_blob.file_size, db)
user_file = UserFile(user_id=user.id, file_sha256=payload.sha256, original_name=payload.file_name)
db.add(user_file)
user.storage_used += existing_blob.file_size
db.commit()
db.refresh(user_file)
else:
user_file = existing_user_file
return UploadInitResponse(
upload_id="",
exists=True,
chunk_size=settings.upload_chunk_size,
received_size=payload.file_size,
file_id=user_file.id,
)
session = db.scalar(
select(UploadSession).where(
UploadSession.user_id == user.id,
UploadSession.sha256 == payload.sha256,
UploadSession.status != "completed",
)
)
if session is None:
_ensure_storage_quota(user, payload.file_size)
if is_video:
_ensure_video_storage_quota(user, payload.file_size, db)
session = UploadSession(
user_id=user.id,
sha256=payload.sha256,
file_name=payload.file_name,
file_size=payload.file_size,
mime_type=payload.mime_type,
resource_type=resource_type,
chunk_size=settings.upload_chunk_size,
temp_path="",
)
db.add(session)
db.flush()
session.temp_path = str(temp_upload_path(user.id, session.id))
db.commit()
db.refresh(session)
return UploadInitResponse(
upload_id=session.id,
exists=False,
chunk_size=session.chunk_size,
received_size=session.received_size,
)
async def append_chunk(upload_id: str, file: UploadFile, user: User, db: Session) -> UploadSession:
session = db.get(UploadSession, upload_id)
if session is None or session.user_id != user.id:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Upload session not found")
if session.status == "completed":
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Upload already completed")
temp_path = Path(session.temp_path)
size = 0
try:
with _open_temp_file_for_append(temp_path) as fp:
while True:
chunk = await file.read(1024 * 1024)
if not chunk:
break
size += len(chunk)
if session.received_size + size > session.file_size:
raise HTTPException(status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, detail="Upload exceeds declared size")
fp.write(chunk)
except PermissionError:
# Old upload sessions may point to temp files created by another process/user.
# Reset the session onto a fresh temp path and let the client restart from 0.
temp_parent = temp_path.parent
if not temp_parent.exists():
temp_parent.mkdir(parents=True, exist_ok=True)
if not os.access(temp_parent, os.W_OK):
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=f"Upload temp directory is not writable: {temp_parent}",
)
new_path = _reset_unwritable_upload_session(session, db)
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail=f"Upload temp file was not writable. Session reset to {new_path.name}, please retry upload.",
)
session.received_size += size
session.status = "uploading"
db.commit()
db.refresh(session)
return session
def complete_upload(upload_id: str, user: User, db: Session) -> UploadCompleteResponse:
session = db.get(UploadSession, upload_id)
if session is None or session.user_id != user.id:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Upload session not found")
temp_path = Path(session.temp_path)
if not temp_path.is_file():
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Upload file is missing")
actual_size = temp_path.stat().st_size
if actual_size != session.file_size:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Upload size mismatch")
actual_sha = calculate_sha256(temp_path)
if actual_sha != session.sha256:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="SHA256 mismatch")
storage_path = blob_storage_path(session.resource_type, user.id, session.sha256, session.file_name)
if not storage_path.exists():
shutil.move(str(temp_path), storage_path)
else:
temp_path.unlink(missing_ok=True)
thumbnail_path = generate_webp_thumbnail(storage_path) if (session.mime_type or "").startswith("image/") else None
blob = db.get(FileBlob, session.sha256)
if blob is None:
blob = FileBlob(
sha256=session.sha256,
storage_path=str(storage_path),
thumbnail_path=thumbnail_path,
file_size=session.file_size,
mime_type=session.mime_type,
)
db.add(blob)
elif thumbnail_path and not blob.thumbnail_path:
blob.thumbnail_path = thumbnail_path
user_file = db.scalar(select(UserFile).where(UserFile.user_id == user.id, UserFile.file_sha256 == session.sha256))
if user_file is None:
_ensure_storage_quota(user, session.file_size)
if _is_video_mime(session.mime_type):
_ensure_video_storage_quota(user, session.file_size, db)
user_file = UserFile(user_id=user.id, file_sha256=session.sha256, original_name=session.file_name)
db.add(user_file)
user.storage_used += session.file_size
session.status = "completed"
db.commit()
db.refresh(user_file)
return UploadCompleteResponse(
file_id=user_file.id,
sha256=session.sha256,
storage_path=str(storage_path),
file_size=session.file_size,
)
+30
View File
@@ -0,0 +1,30 @@
from __future__ import annotations
from pathlib import Path
from PIL import Image, ImageOps
from sakura_cloud.core.config import settings
def thumbnail_path_for(storage_path: str | Path) -> Path:
source = Path(storage_path)
return source.with_name(f"{source.stem}.thumb.webp")
def generate_webp_thumbnail(storage_path: str | Path) -> str | None:
source = Path(storage_path)
if not source.is_file():
return None
target = thumbnail_path_for(source)
try:
with Image.open(source) as image:
image = ImageOps.exif_transpose(image)
image.thumbnail((settings.thumbnail_max_size, settings.thumbnail_max_size))
if image.mode not in {"RGB", "RGBA"}:
image = image.convert("RGB")
target.parent.mkdir(parents=True, exist_ok=True)
image.save(target, "WEBP", quality=settings.thumbnail_quality, method=6)
return str(target)
except Exception:
return None