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