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", } )