Rescue Paperjet v1 implementation
This commit is contained in:
parent
7ff5c8130d
commit
db9e2ca51b
83 changed files with 6186 additions and 3894 deletions
|
|
@ -2,9 +2,14 @@
|
|||
|
||||
from fastapi import APIRouter
|
||||
|
||||
from app.api.v1.annotations import router as annotations_router
|
||||
from app.api.v1.assets import router as assets_router
|
||||
from app.api.v1.auth import router as auth_router
|
||||
from app.api.v1.documents import router as documents_router
|
||||
from app.api.v1.export import router as export_router
|
||||
from app.api.v1.health import router as health_router
|
||||
from app.api.v1.versions import router as versions_router
|
||||
from app.config import settings
|
||||
|
||||
router = APIRouter(prefix="/api/v1")
|
||||
|
||||
|
|
@ -15,17 +20,18 @@ router.include_router(auth_router)
|
|||
router.include_router(documents_router)
|
||||
|
||||
# Assets
|
||||
from app.api.v1.assets import router as assets_router
|
||||
router.include_router(assets_router)
|
||||
|
||||
# Annotations
|
||||
from app.api.v1.annotations import router as annotations_router
|
||||
router.include_router(annotations_router)
|
||||
|
||||
# Versions and export
|
||||
router.include_router(versions_router)
|
||||
router.include_router(export_router)
|
||||
|
||||
# Health (unauthenticated)
|
||||
router.include_router(health_router)
|
||||
|
||||
from app.config import settings
|
||||
if settings.DEBUG:
|
||||
from app.api.v1.debug import router as debug_router
|
||||
router.include_router(debug_router)
|
||||
|
|
|
|||
|
|
@ -1,91 +1,95 @@
|
|||
from typing import Any
|
||||
"""Opaque working-state annotation endpoints."""
|
||||
|
||||
import json
|
||||
from datetime import UTC, datetime
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.orm import Session
|
||||
from datetime import datetime, timezone
|
||||
import json
|
||||
|
||||
from app.db import get_db
|
||||
from app.models.document import Document
|
||||
from app.models.annotation_state import AnnotationState
|
||||
from app.auth.dependencies import get_current_user, verify_csrf
|
||||
from app.schemas.annotations import AnnotationStateResponse, AnnotationStateUpdateRequest, AnnotationStateUpdateResponse
|
||||
from app.db import get_db
|
||||
from app.models.annotation_state import AnnotationState
|
||||
from app.models.document import Document
|
||||
from app.schemas.annotations import (
|
||||
AnnotationPayload,
|
||||
AnnotationStateResponse,
|
||||
AnnotationStateUpdateRequest,
|
||||
AnnotationStateUpdateResponse,
|
||||
)
|
||||
|
||||
router = APIRouter(prefix="/documents", tags=["annotations"])
|
||||
|
||||
router = APIRouter(prefix="/documents", tags=["Annotations"])
|
||||
|
||||
def _now_iso() -> str:
|
||||
return datetime.now(timezone.utc).isoformat()
|
||||
return datetime.now(UTC).isoformat()
|
||||
|
||||
@router.get("/{document_id}/annotations", response_model=AnnotationStateResponse)
|
||||
async def get_annotations(
|
||||
document_id: str,
|
||||
db: Session = Depends(get_db),
|
||||
user_id: Any = Depends(get_current_user)
|
||||
):
|
||||
doc = db.scalar(select(Document).where(Document.id == document_id, Document.deleted_at.is_(None)))
|
||||
if not doc:
|
||||
|
||||
def _utc(value: datetime) -> datetime:
|
||||
return value.replace(tzinfo=UTC) if value.tzinfo is None else value.astimezone(UTC)
|
||||
|
||||
|
||||
def _document_or_404(document_id: str, db: Session) -> Document:
|
||||
document = db.scalar(
|
||||
select(Document).where(Document.id == document_id, Document.deleted_at.is_(None))
|
||||
)
|
||||
if not document:
|
||||
raise HTTPException(status_code=404, detail="Document not found")
|
||||
|
||||
state = db.scalar(select(AnnotationState).where(AnnotationState.document_id == document_id))
|
||||
|
||||
return document
|
||||
|
||||
|
||||
def _read_data(state: AnnotationState | None) -> list[AnnotationPayload]:
|
||||
if not state:
|
||||
return AnnotationStateResponse(data=[], updatedAt=datetime.now(timezone.utc))
|
||||
|
||||
return []
|
||||
try:
|
||||
data = json.loads(state.data)
|
||||
except json.JSONDecodeError:
|
||||
data = []
|
||||
|
||||
return AnnotationStateResponse(
|
||||
data=data,
|
||||
updatedAt=datetime.fromisoformat(state.updated_at)
|
||||
)
|
||||
return []
|
||||
return data if isinstance(data, list) else []
|
||||
|
||||
@router.put("/{document_id}/annotations", response_model=AnnotationStateUpdateResponse, dependencies=[Depends(verify_csrf)])
|
||||
async def update_annotations(
|
||||
|
||||
@router.get("/{document_id}/annotations", response_model=AnnotationStateResponse)
|
||||
def get_annotations(
|
||||
document_id: str,
|
||||
db: Session = Depends(get_db),
|
||||
_user_id: int = Depends(get_current_user),
|
||||
) -> AnnotationStateResponse:
|
||||
_document_or_404(document_id, db)
|
||||
state = db.scalar(select(AnnotationState).where(AnnotationState.document_id == document_id))
|
||||
updated_at = datetime.now(UTC) if not state else _utc(datetime.fromisoformat(state.updated_at))
|
||||
return AnnotationStateResponse(data=_read_data(state), updatedAt=updated_at)
|
||||
|
||||
|
||||
@router.put(
|
||||
"/{document_id}/annotations",
|
||||
response_model=AnnotationStateUpdateResponse,
|
||||
dependencies=[Depends(verify_csrf)],
|
||||
)
|
||||
def update_annotations(
|
||||
document_id: str,
|
||||
request: AnnotationStateUpdateRequest,
|
||||
db: Session = Depends(get_db),
|
||||
user_id: Any = Depends(get_current_user)
|
||||
):
|
||||
doc = db.scalar(select(Document).where(Document.id == document_id, Document.deleted_at.is_(None)))
|
||||
if not doc:
|
||||
raise HTTPException(status_code=404, detail="Document not found")
|
||||
|
||||
_user_id: int = Depends(get_current_user),
|
||||
) -> AnnotationStateUpdateResponse:
|
||||
document = _document_or_404(document_id, db)
|
||||
state = db.scalar(select(AnnotationState).where(AnnotationState.document_id == document_id))
|
||||
|
||||
# Check for stale tab
|
||||
|
||||
if state and request.baseUpdatedAt:
|
||||
current_updated_at = datetime.fromisoformat(state.updated_at).replace(tzinfo=timezone.utc)
|
||||
request_updated_at = request.baseUpdatedAt.replace(tzinfo=timezone.utc)
|
||||
# Allow a small grace period for timezone/parsing discrepancies
|
||||
current_updated_at = _utc(datetime.fromisoformat(state.updated_at))
|
||||
request_updated_at = _utc(request.baseUpdatedAt)
|
||||
if abs((current_updated_at - request_updated_at).total_seconds()) > 1.0:
|
||||
raise HTTPException(
|
||||
status_code=409,
|
||||
detail=f"Conflict: annotations have been modified since {request.baseUpdatedAt}"
|
||||
status_code=409,
|
||||
detail=f"Conflict: annotations have been modified since {request.baseUpdatedAt}",
|
||||
)
|
||||
|
||||
now = _now_iso()
|
||||
|
||||
import json
|
||||
|
||||
# serialize request.data list of models to json string
|
||||
data_json = json.dumps([a.model_dump(mode="json", by_alias=True) for a in request.data])
|
||||
|
||||
if not state:
|
||||
state = AnnotationState(
|
||||
document_id=document_id,
|
||||
data=data_json,
|
||||
updated_at=now
|
||||
)
|
||||
db.add(state)
|
||||
else:
|
||||
now = _now_iso()
|
||||
data_json = json.dumps(request.data, separators=(",", ":"))
|
||||
if state:
|
||||
state.data = data_json
|
||||
state.updated_at = now
|
||||
|
||||
# Bump document updated_at
|
||||
doc.updated_at = now
|
||||
|
||||
else:
|
||||
db.add(AnnotationState(document_id=document_id, data=data_json, updated_at=now))
|
||||
document.updated_at = now
|
||||
db.commit()
|
||||
|
||||
return AnnotationStateUpdateResponse(updatedAt=datetime.fromisoformat(now))
|
||||
|
|
|
|||
|
|
@ -1,58 +1,101 @@
|
|||
from fastapi import APIRouter, Depends, UploadFile, File, HTTPException
|
||||
from fastapi.responses import FileResponse
|
||||
from sqlalchemy.orm import Session
|
||||
"""Authenticated binary assets used by annotations."""
|
||||
|
||||
import uuid
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
from app.db import get_db
|
||||
from app.auth.dependencies import get_current_user
|
||||
from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
|
||||
from fastapi.responses import FileResponse
|
||||
from sqlalchemy import select
|
||||
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.document import Document
|
||||
|
||||
router = APIRouter(prefix="/documents", tags=["Assets"])
|
||||
_ASSET_CHUNK_SIZE = 1024 * 1024
|
||||
_MAX_ASSET_BYTES = 25 * 1024 * 1024
|
||||
|
||||
def get_asset_path(document_id: str, ref: str) -> Path:
|
||||
# Ensure directory exists
|
||||
dir_path = settings.PDF_STORAGE_PATH / "assets" / document_id
|
||||
dir_path.mkdir(parents=True, exist_ok=True)
|
||||
return dir_path / ref
|
||||
|
||||
@router.post("/{id}/assets")
|
||||
def get_asset_path(document_id: str, ref: str, *, create: bool = False) -> Path:
|
||||
"""Return a safe asset path; only writes are allowed to create directories."""
|
||||
try:
|
||||
asset_ref = str(uuid.UUID(ref))
|
||||
except ValueError as err:
|
||||
raise HTTPException(status_code=404, detail="Asset not found") from err
|
||||
|
||||
directory = settings.PDF_STORAGE_PATH / "assets" / document_id
|
||||
if create:
|
||||
directory.mkdir(parents=True, exist_ok=True)
|
||||
return directory / asset_ref
|
||||
|
||||
|
||||
def _is_supported_image(filepath: Path) -> bool:
|
||||
with filepath.open("rb") as file:
|
||||
header = file.read(12)
|
||||
return (
|
||||
header.startswith(b"\x89PNG\r\n\x1a\n")
|
||||
or header.startswith(b"\xff\xd8\xff")
|
||||
or header.startswith((b"GIF87a", b"GIF89a"))
|
||||
or (header.startswith(b"RIFF") and header[8:12] == b"WEBP")
|
||||
)
|
||||
|
||||
|
||||
@router.post("/{id}/assets", dependencies=[Depends(verify_csrf)])
|
||||
async def upload_asset(
|
||||
id: str,
|
||||
file: UploadFile = File(...),
|
||||
user_id: int = Depends(get_current_user),
|
||||
db: Session = Depends(get_db)
|
||||
):
|
||||
"""Upload a binary asset (like an image or signature) for a document."""
|
||||
# In a real app we'd verify the user owns the document here
|
||||
# For this single-user app, we trust the ID
|
||||
|
||||
if not file.content_type or not file.content_type.startswith("image/"):
|
||||
raise HTTPException(status_code=400, detail="Only image assets are supported")
|
||||
db: Session = Depends(get_db),
|
||||
) -> dict[str, str]:
|
||||
"""Upload a PNG, JPEG, GIF, or WebP annotation asset."""
|
||||
document = db.scalar(select(Document).where(Document.id == id))
|
||||
if not document:
|
||||
raise HTTPException(status_code=404, detail="Document not found")
|
||||
|
||||
ref = str(uuid.uuid4())
|
||||
filepath = get_asset_path(id, ref)
|
||||
|
||||
try:
|
||||
with open(filepath, "wb") as f:
|
||||
shutil.copyfileobj(file.file, f)
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=500, detail=f"Failed to save asset: {e}")
|
||||
filepath = get_asset_path(id, ref, create=True)
|
||||
total_bytes = 0
|
||||
|
||||
try:
|
||||
with filepath.open("wb") as destination:
|
||||
while chunk := file.file.read(_ASSET_CHUNK_SIZE):
|
||||
total_bytes += len(chunk)
|
||||
if total_bytes > _MAX_ASSET_BYTES:
|
||||
raise HTTPException(status_code=413, detail="Image asset is too large")
|
||||
destination.write(chunk)
|
||||
except HTTPException:
|
||||
filepath.unlink(missing_ok=True)
|
||||
raise
|
||||
except Exception as err:
|
||||
filepath.unlink(missing_ok=True)
|
||||
raise HTTPException(status_code=500, detail="Failed to save asset") from err
|
||||
|
||||
if not _is_supported_image(filepath):
|
||||
filepath.unlink(missing_ok=True)
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail="Only PNG, JPEG, GIF, and WebP images are supported",
|
||||
)
|
||||
|
||||
return {"ref": ref, "url": f"/api/v1/documents/{id}/assets/{ref}"}
|
||||
|
||||
return {
|
||||
"ref": ref,
|
||||
"url": f"/api/v1/documents/{id}/assets/{ref}"
|
||||
}
|
||||
|
||||
@router.get("/{id}/assets/{ref}")
|
||||
async def get_asset(
|
||||
id: str,
|
||||
ref: str,
|
||||
):
|
||||
"""Serve a binary asset."""
|
||||
db: Session = Depends(get_db),
|
||||
user_id: int = Depends(get_current_user),
|
||||
) -> FileResponse:
|
||||
"""Serve an annotation asset to an authenticated session."""
|
||||
document = db.scalar(select(Document).where(Document.id == id))
|
||||
if not document:
|
||||
raise HTTPException(status_code=404, detail="Document not found")
|
||||
|
||||
filepath = get_asset_path(id, ref)
|
||||
if not filepath.exists() or not filepath.is_file():
|
||||
raise HTTPException(status_code=404, detail="Asset not found")
|
||||
|
||||
|
||||
return FileResponse(filepath)
|
||||
|
|
|
|||
|
|
@ -31,37 +31,37 @@ def get_auth_status(request: Request, db: Session = Depends(get_db)) -> AuthStat
|
|||
app_settings = Settings()
|
||||
db.add(app_settings)
|
||||
db.commit()
|
||||
|
||||
|
||||
setup_required = app_settings.password_hash is None
|
||||
|
||||
|
||||
token = request.cookies.get(settings.COOKIE_NAME)
|
||||
logged_in = False
|
||||
if token:
|
||||
user_id = verify_session(token)
|
||||
if user_id is not None:
|
||||
logged_in = True
|
||||
|
||||
|
||||
return AuthStatusResponse(setupRequired=setup_required, loggedIn=logged_in)
|
||||
|
||||
|
||||
@router.post("/setup", dependencies=[Depends(verify_csrf)])
|
||||
def setup_password(
|
||||
data: SetupRequest,
|
||||
response: Response,
|
||||
data: SetupRequest,
|
||||
response: Response,
|
||||
db: Session = Depends(get_db)
|
||||
) -> dict[str, str]:
|
||||
"""First-run setup."""
|
||||
app_settings = db.query(Settings).first()
|
||||
if app_settings and app_settings.password_hash:
|
||||
raise HTTPException(status_code=409, detail="Password already set")
|
||||
|
||||
|
||||
if not app_settings:
|
||||
app_settings = Settings()
|
||||
db.add(app_settings)
|
||||
|
||||
|
||||
app_settings.password_hash = hash_password(data.password)
|
||||
db.commit()
|
||||
|
||||
|
||||
# Log them in automatically
|
||||
create_session(response)
|
||||
return {"status": "ok"}
|
||||
|
|
@ -77,16 +77,16 @@ def login(
|
|||
"""Validate password and issue session cookie."""
|
||||
ip = get_client_ip(request)
|
||||
check_rate_limit(ip)
|
||||
|
||||
|
||||
app_settings = db.query(Settings).first()
|
||||
if not app_settings or not app_settings.password_hash:
|
||||
record_failed_attempt(ip)
|
||||
raise HTTPException(status_code=401, detail="Invalid credentials")
|
||||
|
||||
|
||||
if not verify_password(app_settings.password_hash, data.password):
|
||||
record_failed_attempt(ip)
|
||||
raise HTTPException(status_code=401, detail="Invalid credentials")
|
||||
|
||||
|
||||
clear_attempts(ip)
|
||||
create_session(response)
|
||||
return {"status": "ok"}
|
||||
|
|
@ -108,17 +108,17 @@ def change_password(
|
|||
"""Change an existing password."""
|
||||
ip = get_client_ip(request)
|
||||
check_rate_limit(ip)
|
||||
|
||||
|
||||
app_settings = db.query(Settings).first()
|
||||
if not app_settings or not app_settings.password_hash:
|
||||
raise HTTPException(status_code=400, detail="Setup required first")
|
||||
|
||||
|
||||
if not verify_password(app_settings.password_hash, data.current_password):
|
||||
record_failed_attempt(ip)
|
||||
raise HTTPException(status_code=401, detail="Invalid current password")
|
||||
|
||||
|
||||
clear_attempts(ip)
|
||||
app_settings.password_hash = hash_password(data.new_password)
|
||||
db.commit()
|
||||
|
||||
|
||||
return {"status": "ok"}
|
||||
|
|
|
|||
|
|
@ -28,28 +28,28 @@ async def verify_coords(req: VerifyCoordsRequest):
|
|||
|
||||
try:
|
||||
doc = pymupdf.open(filepath)
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=500, detail=str(e))
|
||||
except Exception as error:
|
||||
raise HTTPException(status_code=500, detail=str(error)) from error
|
||||
|
||||
if req.page < 0 or req.page >= len(doc):
|
||||
doc.close()
|
||||
raise HTTPException(status_code=400, detail="Invalid page number")
|
||||
|
||||
page = doc[req.page]
|
||||
|
||||
|
||||
# Canonical space is defined as relative to the unrotated CropBox.
|
||||
# PyMuPDF naturally draws relative to the current rotation.
|
||||
# By temporarily setting rotation to 0, we can draw directly using canonical coordinates.
|
||||
original_rotation = page.rotation
|
||||
if original_rotation != 0:
|
||||
page.set_rotation(0)
|
||||
|
||||
|
||||
rect = pymupdf.Rect(req.x, req.y, req.x + req.width, req.y + req.height)
|
||||
page.draw_rect(rect, color=(1, 0, 0), width=2, fill=(1, 0, 0), fill_opacity=0.3)
|
||||
|
||||
|
||||
if original_rotation != 0:
|
||||
page.set_rotation(original_rotation)
|
||||
|
||||
|
||||
pdf_bytes = doc.write()
|
||||
doc.close()
|
||||
|
||||
|
|
|
|||
|
|
@ -1,28 +1,31 @@
|
|||
"""Document management endpoints."""
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Query
|
||||
from datetime import UTC, datetime
|
||||
|
||||
from fastapi import APIRouter, Depends, File, HTTPException, Query, UploadFile, status
|
||||
from fastapi.responses import FileResponse
|
||||
from sqlalchemy.orm import Session
|
||||
from sqlalchemy import desc
|
||||
from datetime import datetime, timezone
|
||||
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.document import Document
|
||||
from app.models.annotation_state import AnnotationState
|
||||
from app.models.document import Document
|
||||
from app.models.version import Version
|
||||
from app.schemas.document import (
|
||||
DocumentListResponse, DocumentMeta, BulkDeleteRequest,
|
||||
BulkRestoreRequest, DocumentUpdateRequest
|
||||
BulkDeleteRequest,
|
||||
BulkRestoreRequest,
|
||||
DocumentListResponse,
|
||||
DocumentMeta,
|
||||
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
|
||||
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)]
|
||||
prefix="/documents", tags=["documents"], dependencies=[Depends(get_current_user)]
|
||||
)
|
||||
|
||||
|
||||
|
|
@ -31,109 +34,135 @@ def list_documents(
|
|||
query: str = "",
|
||||
skip: int = Query(0, ge=0),
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
db: Session = Depends(get_db)
|
||||
):
|
||||
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=items, total=total)
|
||||
|
||||
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)
|
||||
):
|
||||
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=items, total=total)
|
||||
return DocumentListResponse(
|
||||
items=[DocumentMeta.model_validate(item) for item in items], total=total
|
||||
)
|
||||
|
||||
|
||||
@router.post("", dependencies=[Depends(verify_csrf)], response_model=DocumentMeta)
|
||||
@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)
|
||||
):
|
||||
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
|
||||
generate_thumbnail(file_id)
|
||||
|
||||
now = datetime.now(timezone.utc).isoformat()
|
||||
thumbnail_generated = generate_thumbnail(file_id)
|
||||
|
||||
now = datetime.now(UTC).isoformat()
|
||||
filename = safe_filename(file.filename)
|
||||
doc = Document(
|
||||
id=file_id,
|
||||
title=file.filename or "Untitled",
|
||||
original_filename=file.filename or "Untitled.pdf",
|
||||
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
|
||||
updated_at=now,
|
||||
)
|
||||
db.add(doc)
|
||||
db.commit()
|
||||
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 doc
|
||||
return DocumentMeta.model_validate(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()
|
||||
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 doc
|
||||
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)):
|
||||
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:
|
||||
doc.title = update.title
|
||||
|
||||
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(timezone.utc).isoformat()
|
||||
doc.deleted_at = datetime.now(UTC).isoformat()
|
||||
else:
|
||||
doc.deleted_at = None
|
||||
|
||||
doc.updated_at = datetime.now(timezone.utc).isoformat()
|
||||
|
||||
doc.updated_at = datetime.now(UTC).isoformat()
|
||||
db.commit()
|
||||
db.refresh(doc)
|
||||
return 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)):
|
||||
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)
|
||||
|
|
@ -141,52 +170,57 @@ def delete_document(id: str, permanent: bool = False, db: Session = Depends(get_
|
|||
return {"status": "deleted"}
|
||||
else:
|
||||
# Soft delete
|
||||
doc.deleted_at = datetime.now(timezone.utc).isoformat()
|
||||
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)):
|
||||
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(timezone.utc).isoformat()
|
||||
doc.updated_at = datetime.now(UTC).isoformat()
|
||||
db.commit()
|
||||
db.refresh(doc)
|
||||
return doc
|
||||
return DocumentMeta.model_validate(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)
|
||||
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": len(data.ids)}
|
||||
return {"status": "ok", "count": count}
|
||||
|
||||
|
||||
@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)
|
||||
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": len(data.ids)}
|
||||
return {"status": "ok", "count": count}
|
||||
|
||||
|
||||
@router.post("/trash/empty", dependencies=[Depends(verify_csrf)])
|
||||
def empty_trash(db: Session = Depends(get_db)):
|
||||
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)
|
||||
|
|
@ -196,26 +230,26 @@ def empty_trash(db: Session = Depends(get_db)):
|
|||
|
||||
|
||||
@router.get("/{id}/file")
|
||||
def get_document_file(id: str, db: Session = Depends(get_db)):
|
||||
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)):
|
||||
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")
|
||||
|
|
|
|||
94
backend/app/api/v1/export.py
Normal file
94
backend/app/api/v1/export.py
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
"""Flattened PDF export endpoint."""
|
||||
|
||||
import json
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from fastapi.responses import Response
|
||||
from sqlalchemy import select
|
||||
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.export import ExportRequest
|
||||
from app.services.export.renderer import export_annotations
|
||||
from app.services.storage import safe_filename
|
||||
|
||||
router = APIRouter(
|
||||
prefix="/documents",
|
||||
tags=["export"],
|
||||
dependencies=[Depends(get_current_user)],
|
||||
)
|
||||
|
||||
|
||||
def _document_or_404(document_id: str, db: Session) -> Document:
|
||||
document = db.scalar(
|
||||
select(Document).where(Document.id == document_id, Document.deleted_at.is_(None))
|
||||
)
|
||||
if not document:
|
||||
raise HTTPException(status_code=404, detail="Document not found")
|
||||
return document
|
||||
|
||||
|
||||
def _state_data(document_id: str, db: Session) -> list[dict[str, object]]:
|
||||
state = db.scalar(select(AnnotationState).where(AnnotationState.document_id == document_id))
|
||||
if not state:
|
||||
return []
|
||||
try:
|
||||
data = json.loads(state.data)
|
||||
except json.JSONDecodeError:
|
||||
return []
|
||||
return data if isinstance(data, list) else []
|
||||
|
||||
|
||||
@router.post("/{document_id}/export", dependencies=[Depends(verify_csrf)])
|
||||
def export_document(
|
||||
document_id: str,
|
||||
request: ExportRequest,
|
||||
db: Session = Depends(get_db),
|
||||
) -> Response:
|
||||
"""Export the working layer or a selected version as a downloadable PDF."""
|
||||
document = _document_or_404(document_id, db)
|
||||
pdf_path = settings.PDF_STORAGE_PATH / f"{document.id}.pdf"
|
||||
if not pdf_path.is_file():
|
||||
raise HTTPException(status_code=404, detail="Original PDF is missing")
|
||||
|
||||
if not request.flatten:
|
||||
content = pdf_path.read_bytes()
|
||||
elif request.versionId:
|
||||
version = db.scalar(
|
||||
select(Version).where(
|
||||
Version.id == request.versionId,
|
||||
Version.document_id == document_id,
|
||||
)
|
||||
)
|
||||
if not version:
|
||||
raise HTTPException(status_code=404, detail="Version not found")
|
||||
try:
|
||||
version_data = json.loads(version.data)
|
||||
except json.JSONDecodeError:
|
||||
version_data = []
|
||||
content = export_annotations(
|
||||
pdf_path,
|
||||
version_data if isinstance(version_data, list) else [],
|
||||
settings.PDF_STORAGE_PATH / "assets" / document.id,
|
||||
)
|
||||
else:
|
||||
content = export_annotations(
|
||||
pdf_path,
|
||||
_state_data(document_id, db),
|
||||
settings.PDF_STORAGE_PATH / "assets" / document.id,
|
||||
)
|
||||
|
||||
filename = safe_filename(document.original_filename)
|
||||
if not filename.lower().endswith(".pdf"):
|
||||
filename = f"{filename}.pdf"
|
||||
filename = filename.replace('"', "'").replace("\r", "").replace("\n", "")
|
||||
return Response(
|
||||
content=content,
|
||||
media_type="application/pdf",
|
||||
headers={"Content-Disposition": f'attachment; filename="{filename}"'},
|
||||
)
|
||||
203
backend/app/api/v1/versions.py
Normal file
203
backend/app/api/v1/versions.py
Normal file
|
|
@ -0,0 +1,203 @@
|
|||
"""Annotation checkpoint and restore endpoints."""
|
||||
|
||||
import json
|
||||
from datetime import UTC, datetime
|
||||
from typing import Literal, cast
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, Response, status
|
||||
from sqlalchemy import desc, select
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.auth.dependencies import get_current_user, verify_csrf
|
||||
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.annotations import AnnotationPayload
|
||||
from app.schemas.versions import (
|
||||
VersionCreateRequest,
|
||||
VersionDataResponse,
|
||||
VersionListResponse,
|
||||
VersionMeta,
|
||||
VersionRestoreResponse,
|
||||
)
|
||||
|
||||
router = APIRouter(
|
||||
prefix="/documents",
|
||||
tags=["versions"],
|
||||
dependencies=[Depends(get_current_user)],
|
||||
)
|
||||
|
||||
|
||||
def _now_iso() -> str:
|
||||
return datetime.now(UTC).isoformat()
|
||||
|
||||
|
||||
def _document_or_404(document_id: str, db: Session) -> Document:
|
||||
document = db.scalar(
|
||||
select(Document).where(Document.id == document_id, Document.deleted_at.is_(None))
|
||||
)
|
||||
if not document:
|
||||
raise HTTPException(status_code=404, detail="Document not found")
|
||||
return document
|
||||
|
||||
|
||||
def _read_state(document_id: str, db: Session) -> list[AnnotationPayload]:
|
||||
state = db.scalar(select(AnnotationState).where(AnnotationState.document_id == document_id))
|
||||
if not state:
|
||||
return []
|
||||
try:
|
||||
data = json.loads(state.data)
|
||||
except json.JSONDecodeError:
|
||||
return []
|
||||
return data if isinstance(data, list) else []
|
||||
|
||||
|
||||
def _version_meta(version: Version) -> VersionMeta:
|
||||
try:
|
||||
data = json.loads(version.data)
|
||||
except json.JSONDecodeError:
|
||||
data = []
|
||||
return VersionMeta(
|
||||
id=version.id,
|
||||
documentId=version.document_id,
|
||||
label=version.label,
|
||||
kind=cast(
|
||||
Literal["manual", "auto"],
|
||||
version.kind if version.kind in {"manual", "auto"} else "auto",
|
||||
),
|
||||
createdAt=datetime.fromisoformat(version.created_at),
|
||||
annotationCount=len(data) if isinstance(data, list) else 0,
|
||||
)
|
||||
|
||||
|
||||
def _create_snapshot(
|
||||
document_id: str,
|
||||
db: Session,
|
||||
*,
|
||||
label: str | None,
|
||||
kind: str,
|
||||
) -> Version:
|
||||
version = Version(
|
||||
document_id=document_id,
|
||||
label=label,
|
||||
kind=kind,
|
||||
data=json.dumps(_read_state(document_id, db), separators=(",", ":")),
|
||||
)
|
||||
db.add(version)
|
||||
db.flush()
|
||||
return version
|
||||
|
||||
|
||||
@router.get("/{document_id}/versions", response_model=VersionListResponse)
|
||||
def list_versions(document_id: str, db: Session = Depends(get_db)) -> VersionListResponse:
|
||||
_document_or_404(document_id, db)
|
||||
versions = db.scalars(
|
||||
select(Version).where(Version.document_id == document_id).order_by(desc(Version.created_at))
|
||||
).all()
|
||||
return VersionListResponse(items=[_version_meta(version) for version in versions])
|
||||
|
||||
|
||||
@router.post(
|
||||
"/{document_id}/versions",
|
||||
response_model=VersionMeta,
|
||||
status_code=status.HTTP_201_CREATED,
|
||||
dependencies=[Depends(verify_csrf)],
|
||||
)
|
||||
def create_version(
|
||||
document_id: str,
|
||||
request: VersionCreateRequest,
|
||||
db: Session = Depends(get_db),
|
||||
) -> VersionMeta:
|
||||
_document_or_404(document_id, db)
|
||||
version = _create_snapshot(
|
||||
document_id,
|
||||
db,
|
||||
label=request.label.strip() if request.label and request.label.strip() else None,
|
||||
kind=request.kind,
|
||||
)
|
||||
db.commit()
|
||||
return _version_meta(version)
|
||||
|
||||
|
||||
@router.get("/{document_id}/versions/{version_id}", response_model=VersionDataResponse)
|
||||
def get_version(
|
||||
document_id: str,
|
||||
version_id: str,
|
||||
db: Session = Depends(get_db),
|
||||
) -> VersionDataResponse:
|
||||
_document_or_404(document_id, db)
|
||||
version = db.scalar(
|
||||
select(Version).where(Version.id == version_id, Version.document_id == document_id)
|
||||
)
|
||||
if not version:
|
||||
raise HTTPException(status_code=404, detail="Version not found")
|
||||
try:
|
||||
data = json.loads(version.data)
|
||||
except json.JSONDecodeError:
|
||||
data = []
|
||||
return VersionDataResponse(
|
||||
data=data if isinstance(data, list) else [],
|
||||
meta=_version_meta(version),
|
||||
)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/{document_id}/versions/{version_id}/restore",
|
||||
response_model=VersionRestoreResponse,
|
||||
dependencies=[Depends(verify_csrf)],
|
||||
)
|
||||
def restore_version(
|
||||
document_id: str,
|
||||
version_id: str,
|
||||
db: Session = Depends(get_db),
|
||||
) -> VersionRestoreResponse:
|
||||
document = _document_or_404(document_id, db)
|
||||
target = db.scalar(
|
||||
select(Version).where(Version.id == version_id, Version.document_id == document_id)
|
||||
)
|
||||
if not target:
|
||||
raise HTTPException(status_code=404, detail="Version not found")
|
||||
|
||||
# Restoring is destructive to the current working layer, so make it undoable.
|
||||
_create_snapshot(document_id, db, label="Before restore", kind="auto")
|
||||
try:
|
||||
restored_data = json.loads(target.data)
|
||||
except json.JSONDecodeError:
|
||||
restored_data = []
|
||||
if not isinstance(restored_data, list):
|
||||
restored_data = []
|
||||
|
||||
state = db.scalar(select(AnnotationState).where(AnnotationState.document_id == document_id))
|
||||
now = _now_iso()
|
||||
if state:
|
||||
state.data = json.dumps(restored_data, separators=(",", ":"))
|
||||
state.updated_at = now
|
||||
else:
|
||||
db.add(
|
||||
AnnotationState(
|
||||
document_id=document_id,
|
||||
data=json.dumps(restored_data, separators=(",", ":")),
|
||||
updated_at=now,
|
||||
)
|
||||
)
|
||||
document.updated_at = now
|
||||
db.commit()
|
||||
return VersionRestoreResponse(updatedAt=datetime.fromisoformat(now))
|
||||
|
||||
|
||||
@router.delete(
|
||||
"/{document_id}/versions/{version_id}",
|
||||
status_code=status.HTTP_204_NO_CONTENT,
|
||||
dependencies=[Depends(verify_csrf)],
|
||||
)
|
||||
def delete_version(document_id: str, version_id: str, db: Session = Depends(get_db)) -> Response:
|
||||
_document_or_404(document_id, db)
|
||||
version = db.scalar(
|
||||
select(Version).where(Version.id == version_id, Version.document_id == document_id)
|
||||
)
|
||||
if not version:
|
||||
raise HTTPException(status_code=404, detail="Version not found")
|
||||
db.delete(version)
|
||||
db.commit()
|
||||
return Response(status_code=status.HTTP_204_NO_CONTENT)
|
||||
Loading…
Add table
Add a link
Reference in a new issue