Files

171 lines
6.7 KiB
Python
Raw Permalink Normal View History

2026-11-16 20:45:22 +08:00
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",
}
)