221 lines
7.8 KiB
Python
221 lines
7.8 KiB
Python
"""Document management endpoints."""
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Query
|
|
from fastapi.responses import FileResponse
|
|
from sqlalchemy.orm import Session
|
|
from sqlalchemy import desc
|
|
from datetime import datetime, timezone
|
|
|
|
from app.auth.dependencies import get_current_user, verify_csrf
|
|
from app.db import get_db
|
|
from app.models.document import Document
|
|
from app.models.annotation_state import AnnotationState
|
|
from app.models.version import Version
|
|
from app.schemas.document import (
|
|
DocumentListResponse, DocumentMeta, BulkDeleteRequest,
|
|
BulkRestoreRequest, DocumentUpdateRequest
|
|
)
|
|
from app.services.storage import save_upload_file, delete_pdf_file
|
|
from app.services.thumbnails import generate_thumbnail, delete_thumbnail
|
|
from app.config import settings
|
|
|
|
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)
|
|
):
|
|
"""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=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)
|
|
):
|
|
"""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=items, total=total)
|
|
|
|
|
|
@router.post("", dependencies=[Depends(verify_csrf)], response_model=DocumentMeta)
|
|
async def upload_document(
|
|
file: UploadFile = File(...),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""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
|
|
generate_thumbnail(file_id)
|
|
|
|
now = datetime.now(timezone.utc).isoformat()
|
|
doc = Document(
|
|
id=file_id,
|
|
title=file.filename or "Untitled",
|
|
original_filename=file.filename or "Untitled.pdf",
|
|
file_path=str(settings.PDF_STORAGE_PATH / f"{file_id}.pdf"),
|
|
page_count=page_count,
|
|
size_bytes=size_bytes,
|
|
created_at=now,
|
|
updated_at=now
|
|
)
|
|
db.add(doc)
|
|
db.commit()
|
|
db.refresh(doc)
|
|
return doc
|
|
|
|
|
|
@router.get("/{id}", response_model=DocumentMeta)
|
|
def get_document(id: str, db: Session = Depends(get_db)):
|
|
doc = db.query(Document).filter(Document.id == id).first()
|
|
if not doc:
|
|
raise HTTPException(status_code=404, detail="Document not found")
|
|
return doc
|
|
|
|
|
|
@router.patch("/{id}", dependencies=[Depends(verify_csrf)], response_model=DocumentMeta)
|
|
def update_document(id: str, update: DocumentUpdateRequest, db: Session = Depends(get_db)):
|
|
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:
|
|
doc.title = update.title
|
|
|
|
if update.in_trash is not None:
|
|
if update.in_trash:
|
|
doc.deleted_at = datetime.now(timezone.utc).isoformat()
|
|
else:
|
|
doc.deleted_at = None
|
|
|
|
doc.updated_at = datetime.now(timezone.utc).isoformat()
|
|
db.commit()
|
|
db.refresh(doc)
|
|
return doc
|
|
|
|
|
|
@router.delete("/{id}", dependencies=[Depends(verify_csrf)])
|
|
def delete_document(id: str, permanent: bool = False, db: Session = Depends(get_db)):
|
|
"""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)
|
|
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(timezone.utc).isoformat()
|
|
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)):
|
|
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(timezone.utc).isoformat()
|
|
db.commit()
|
|
db.refresh(doc)
|
|
return doc
|
|
|
|
|
|
@router.post("/bulk-delete", dependencies=[Depends(verify_csrf)])
|
|
def bulk_delete(data: BulkDeleteRequest, db: Session = Depends(get_db)):
|
|
now = datetime.now(timezone.utc).isoformat()
|
|
db.query(Document).filter(Document.id.in_(data.ids)).update({
|
|
Document.deleted_at: now
|
|
}, synchronize_session=False)
|
|
db.commit()
|
|
return {"status": "ok", "count": len(data.ids)}
|
|
|
|
|
|
@router.post("/bulk-restore", dependencies=[Depends(verify_csrf)])
|
|
def bulk_restore(data: BulkRestoreRequest, db: Session = Depends(get_db)):
|
|
now = datetime.now(timezone.utc).isoformat()
|
|
db.query(Document).filter(Document.id.in_(data.ids)).update({
|
|
Document.deleted_at: None,
|
|
Document.updated_at: now
|
|
}, synchronize_session=False)
|
|
db.commit()
|
|
return {"status": "ok", "count": len(data.ids)}
|
|
|
|
|
|
@router.post("/trash/empty", dependencies=[Depends(verify_csrf)])
|
|
def empty_trash(db: Session = Depends(get_db)):
|
|
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)
|
|
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)):
|
|
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)):
|
|
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")
|