255 lines
8.9 KiB
Python
255 lines
8.9 KiB
Python
"""Document management endpoints."""
|
|
|
|
from datetime import UTC, datetime
|
|
|
|
from fastapi import APIRouter, Depends, File, HTTPException, Query, UploadFile, status
|
|
from fastapi.responses import FileResponse
|
|
from sqlalchemy import desc
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.auth.dependencies import get_current_user, verify_csrf
|
|
from app.config import settings
|
|
from app.db import get_db
|
|
from app.models.annotation_state import AnnotationState
|
|
from app.models.document import Document
|
|
from app.models.version import Version
|
|
from app.schemas.document import (
|
|
BulkDeleteRequest,
|
|
BulkRestoreRequest,
|
|
DocumentListResponse,
|
|
DocumentMeta,
|
|
DocumentUpdateRequest,
|
|
)
|
|
from app.services.assets import delete_asset_directory
|
|
from app.services.storage import delete_pdf_file, safe_filename, save_upload_file
|
|
from app.services.thumbnails import delete_thumbnail, generate_thumbnail
|
|
|
|
router = APIRouter(
|
|
prefix="/documents", tags=["documents"], dependencies=[Depends(get_current_user)]
|
|
)
|
|
|
|
|
|
@router.get("", response_model=DocumentListResponse)
|
|
def list_documents(
|
|
query: str = "",
|
|
skip: int = Query(0, ge=0),
|
|
limit: int = Query(50, ge=1, le=100),
|
|
db: Session = Depends(get_db),
|
|
) -> DocumentListResponse:
|
|
"""List non-trashed documents."""
|
|
q = db.query(Document).filter(Document.deleted_at.is_(None))
|
|
if query:
|
|
q = q.filter(Document.title.ilike(f"%{query}%"))
|
|
|
|
total = q.count()
|
|
items = q.order_by(desc(Document.updated_at)).offset(skip).limit(limit).all()
|
|
|
|
return DocumentListResponse(
|
|
items=[DocumentMeta.model_validate(item) for item in items], total=total
|
|
)
|
|
|
|
|
|
@router.get("/trash", response_model=DocumentListResponse)
|
|
def list_trash(
|
|
skip: int = Query(0, ge=0),
|
|
limit: int = Query(50, ge=1, le=100),
|
|
db: Session = Depends(get_db),
|
|
) -> DocumentListResponse:
|
|
"""List trashed documents."""
|
|
q = db.query(Document).filter(Document.deleted_at.is_not(None))
|
|
total = q.count()
|
|
items = q.order_by(desc(Document.deleted_at)).offset(skip).limit(limit).all()
|
|
return DocumentListResponse(
|
|
items=[DocumentMeta.model_validate(item) for item in items], total=total
|
|
)
|
|
|
|
|
|
@router.post(
|
|
"",
|
|
dependencies=[Depends(verify_csrf)],
|
|
response_model=DocumentMeta,
|
|
status_code=status.HTTP_201_CREATED,
|
|
)
|
|
async def upload_document(
|
|
file: UploadFile = File(...), db: Session = Depends(get_db)
|
|
) -> DocumentMeta:
|
|
"""Upload a new PDF document."""
|
|
# Note: Starlette/FastAPI loads file into memory/spooled file.
|
|
# To truly enforce max size before reading we rely on Nginx and logic in storage.py.
|
|
# But checking size if available:
|
|
if file.size and file.size > settings.MAX_UPLOAD_MB * 1024 * 1024:
|
|
raise HTTPException(status_code=413, detail="File too large")
|
|
|
|
file_id, size_bytes, page_count = await save_upload_file(file)
|
|
|
|
# Generate thumbnail synchronously
|
|
thumbnail_generated = generate_thumbnail(file_id)
|
|
|
|
now = datetime.now(UTC).isoformat()
|
|
filename = safe_filename(file.filename)
|
|
doc = Document(
|
|
id=file_id,
|
|
title=filename,
|
|
original_filename=filename,
|
|
file_path=str(settings.PDF_STORAGE_PATH / f"{file_id}.pdf"),
|
|
thumbnail_path=(
|
|
str(settings.THUMBNAILS_PATH / f"{file_id}.png") if thumbnail_generated else None
|
|
),
|
|
page_count=page_count,
|
|
size_bytes=size_bytes,
|
|
created_at=now,
|
|
updated_at=now,
|
|
)
|
|
try:
|
|
db.add(doc)
|
|
db.commit()
|
|
except Exception:
|
|
delete_pdf_file(file_id)
|
|
delete_thumbnail(file_id)
|
|
delete_asset_directory(file_id)
|
|
raise
|
|
db.refresh(doc)
|
|
return DocumentMeta.model_validate(doc)
|
|
|
|
|
|
@router.get("/{id}", response_model=DocumentMeta)
|
|
def get_document(id: str, db: Session = Depends(get_db)) -> DocumentMeta:
|
|
doc = db.query(Document).filter(Document.id == id, Document.deleted_at.is_(None)).first()
|
|
if not doc:
|
|
raise HTTPException(status_code=404, detail="Document not found")
|
|
return DocumentMeta.model_validate(doc)
|
|
|
|
|
|
@router.patch("/{id}", dependencies=[Depends(verify_csrf)], response_model=DocumentMeta)
|
|
def update_document(
|
|
id: str, update: DocumentUpdateRequest, db: Session = Depends(get_db)
|
|
) -> DocumentMeta:
|
|
doc = db.query(Document).filter(Document.id == id).first()
|
|
if not doc:
|
|
raise HTTPException(status_code=404, detail="Document not found")
|
|
|
|
if update.title is not None:
|
|
title = update.title.strip()
|
|
if not title:
|
|
raise HTTPException(status_code=422, detail="Title cannot be empty")
|
|
doc.title = title
|
|
|
|
if update.in_trash is not None:
|
|
if update.in_trash:
|
|
doc.deleted_at = datetime.now(UTC).isoformat()
|
|
else:
|
|
doc.deleted_at = None
|
|
|
|
doc.updated_at = datetime.now(UTC).isoformat()
|
|
db.commit()
|
|
db.refresh(doc)
|
|
return DocumentMeta.model_validate(doc)
|
|
|
|
|
|
@router.delete("/{id}", dependencies=[Depends(verify_csrf)])
|
|
def delete_document(
|
|
id: str, permanent: bool = False, db: Session = Depends(get_db)
|
|
) -> dict[str, str]:
|
|
"""Soft delete by default. Hard delete if permanent=True AND already in trash."""
|
|
doc = db.query(Document).filter(Document.id == id).first()
|
|
if not doc:
|
|
raise HTTPException(status_code=404, detail="Document not found")
|
|
|
|
if permanent:
|
|
if doc.deleted_at is None:
|
|
raise HTTPException(status_code=400, detail="Must be in trash to delete permanently")
|
|
|
|
# Hard delete
|
|
delete_pdf_file(doc.id)
|
|
delete_thumbnail(doc.id)
|
|
delete_asset_directory(doc.id)
|
|
db.query(AnnotationState).filter(AnnotationState.document_id == doc.id).delete()
|
|
db.query(Version).filter(Version.document_id == doc.id).delete()
|
|
db.delete(doc)
|
|
db.commit()
|
|
return {"status": "deleted"}
|
|
else:
|
|
# Soft delete
|
|
doc.deleted_at = datetime.now(UTC).isoformat()
|
|
doc.updated_at = doc.deleted_at
|
|
db.commit()
|
|
return {"status": "trashed"}
|
|
|
|
|
|
@router.post("/{id}/restore", dependencies=[Depends(verify_csrf)], response_model=DocumentMeta)
|
|
def restore_document(id: str, db: Session = Depends(get_db)) -> DocumentMeta:
|
|
doc = db.query(Document).filter(Document.id == id).first()
|
|
if not doc:
|
|
raise HTTPException(status_code=404, detail="Document not found")
|
|
|
|
doc.deleted_at = None
|
|
doc.updated_at = datetime.now(UTC).isoformat()
|
|
db.commit()
|
|
db.refresh(doc)
|
|
return DocumentMeta.model_validate(doc)
|
|
|
|
|
|
@router.post("/bulk-delete", dependencies=[Depends(verify_csrf)])
|
|
def bulk_delete(data: BulkDeleteRequest, db: Session = Depends(get_db)) -> dict[str, int | str]:
|
|
now = datetime.now(UTC).isoformat()
|
|
count = (
|
|
db.query(Document)
|
|
.filter(Document.id.in_(data.ids), Document.deleted_at.is_(None))
|
|
.update({Document.deleted_at: now}, synchronize_session=False)
|
|
)
|
|
db.commit()
|
|
return {"status": "ok", "count": count}
|
|
|
|
|
|
@router.post("/bulk-restore", dependencies=[Depends(verify_csrf)])
|
|
def bulk_restore(data: BulkRestoreRequest, db: Session = Depends(get_db)) -> dict[str, int | str]:
|
|
now = datetime.now(UTC).isoformat()
|
|
count = (
|
|
db.query(Document)
|
|
.filter(Document.id.in_(data.ids), Document.deleted_at.is_not(None))
|
|
.update({Document.deleted_at: None, Document.updated_at: now}, synchronize_session=False)
|
|
)
|
|
db.commit()
|
|
return {"status": "ok", "count": count}
|
|
|
|
|
|
@router.post("/trash/empty", dependencies=[Depends(verify_csrf)])
|
|
def empty_trash(db: Session = Depends(get_db)) -> dict[str, int | str]:
|
|
docs = db.query(Document).filter(Document.deleted_at.is_not(None)).all()
|
|
count = 0
|
|
for doc in docs:
|
|
delete_pdf_file(doc.id)
|
|
delete_thumbnail(doc.id)
|
|
delete_asset_directory(doc.id)
|
|
db.query(AnnotationState).filter(AnnotationState.document_id == doc.id).delete()
|
|
db.query(Version).filter(Version.document_id == doc.id).delete()
|
|
db.delete(doc)
|
|
count += 1
|
|
db.commit()
|
|
return {"status": "ok", "deleted": count}
|
|
|
|
|
|
@router.get("/{id}/file")
|
|
def get_document_file(id: str, db: Session = Depends(get_db)) -> FileResponse:
|
|
doc = db.query(Document).filter(Document.id == id).first()
|
|
if not doc:
|
|
raise HTTPException(status_code=404, detail="Document not found")
|
|
|
|
path = settings.PDF_STORAGE_PATH / f"{doc.id}.pdf"
|
|
if not path.exists():
|
|
raise HTTPException(status_code=404, detail="File missing")
|
|
|
|
return FileResponse(path, media_type="application/pdf", filename=doc.filename)
|
|
|
|
|
|
@router.get("/{id}/thumbnail")
|
|
def get_document_thumbnail(id: str, db: Session = Depends(get_db)) -> FileResponse:
|
|
doc = db.query(Document).filter(Document.id == id).first()
|
|
if not doc:
|
|
raise HTTPException(status_code=404, detail="Document not found")
|
|
|
|
path = settings.THUMBNAILS_PATH / f"{doc.id}.png"
|
|
if not path.exists():
|
|
raise HTTPException(status_code=404, detail="Thumbnail missing")
|
|
|
|
return FileResponse(path, media_type="image/png")
|