172 lines
6.7 KiB
Python
172 lines
6.7 KiB
Python
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",
|
|
}
|
|
)
|