| """Document upload, list, delete, and file serving."""
|
|
|
| from __future__ import annotations
|
|
|
| import logging
|
| from pathlib import Path
|
|
|
| from fastapi import (
|
| APIRouter,
|
| Depends,
|
| File,
|
| Form,
|
| HTTPException,
|
| UploadFile,
|
| )
|
| from fastapi.responses import FileResponse
|
| from sqlalchemy import func, select
|
| from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
| from app.config import get_settings
|
| from app.db import get_session
|
| from app.models import Document
|
| from app.schemas import DocumentOut, FolderOut, IngestResponse
|
| from app.services.rag import (
|
| SUPPORTED_SUFFIXES,
|
| document_file_path,
|
| ingest_file,
|
| )
|
| from app.services.store import get_document_store
|
|
|
| logger = logging.getLogger(__name__)
|
| router = APIRouter(prefix="/api/documents", tags=["documents"])
|
|
|
|
|
| @router.get("", response_model=list[DocumentOut])
|
| async def list_documents(
|
| folder: str | None = None,
|
| session: AsyncSession = Depends(get_session),
|
| ) -> list[Document]:
|
| """List indexed documents."""
|
| stmt = select(Document).order_by(Document.created_at.desc())
|
| if folder:
|
| stmt = stmt.where(Document.folder == folder)
|
| result = await session.execute(stmt)
|
| return list(result.scalars().all())
|
|
|
|
|
| @router.get("/folders", response_model=list[FolderOut])
|
| async def list_folders(
|
| session: AsyncSession = Depends(get_session),
|
| ) -> list[FolderOut]:
|
| """List folders with document counts."""
|
| result = await session.execute(
|
| select(Document.folder, func.count(Document.id))
|
| .group_by(Document.folder)
|
| .order_by(Document.folder)
|
| )
|
| return [
|
| FolderOut(name=row[0], document_count=row[1])
|
| for row in result.all()
|
| ]
|
|
|
|
|
| @router.get("/{document_id}", response_model=DocumentOut)
|
| async def get_document(
|
| document_id: str,
|
| session: AsyncSession = Depends(get_session),
|
| ) -> Document:
|
| """Fetch one document metadata row."""
|
| doc = await session.get(Document, document_id)
|
| if doc is None:
|
| raise HTTPException(404, "Document not found")
|
| return doc
|
|
|
|
|
| @router.get("/{document_id}/file")
|
| async def download_document(
|
| document_id: str,
|
| session: AsyncSession = Depends(get_session),
|
| ) -> FileResponse:
|
| """Serve the original file for the PDF viewer."""
|
| path = await document_file_path(session, document_id)
|
| if path is None or not path.exists():
|
| raise HTTPException(404, "File not found")
|
| doc = await session.get(Document, document_id)
|
| media = doc.media_type if doc else "application/octet-stream"
|
| return FileResponse(
|
| path,
|
| media_type=media,
|
| filename=doc.original_name if doc else path.name,
|
| )
|
|
|
|
|
| @router.post("/upload", response_model=IngestResponse)
|
| async def upload_document(
|
| file: UploadFile = File(...),
|
| folder: str = Form("general"),
|
| session: AsyncSession = Depends(get_session),
|
| ) -> IngestResponse:
|
| """Upload and index a document."""
|
| settings = get_settings()
|
| name = file.filename or "upload.bin"
|
| suffix = Path(name).suffix.lower()
|
| if suffix not in SUPPORTED_SUFFIXES:
|
| raise HTTPException(
|
| 400,
|
| f"Unsupported type {suffix}. "
|
| f"Allowed: {', '.join(sorted(SUPPORTED_SUFFIXES))}",
|
| )
|
|
|
| raw = await file.read()
|
| max_bytes = settings.max_upload_mb * 1024 * 1024
|
| if len(raw) > max_bytes:
|
| raise HTTPException(
|
| 400,
|
| f"File exceeds {settings.max_upload_mb} MB limit",
|
| )
|
|
|
| tmp_dir = Path(settings.upload_path) / "_tmp"
|
| tmp_dir.mkdir(parents=True, exist_ok=True)
|
| tmp_path = tmp_dir / name
|
| tmp_path.write_bytes(raw)
|
|
|
| try:
|
| doc, chunks = await ingest_file(
|
| session,
|
| source_path=tmp_path,
|
| original_name=name,
|
| folder=(folder or "general").strip() or "general",
|
| media_type=file.content_type
|
| or "application/octet-stream",
|
| )
|
| finally:
|
| if tmp_path.exists():
|
| tmp_path.unlink()
|
|
|
| return IngestResponse(
|
| document=DocumentOut.model_validate(doc),
|
| chunks_added=chunks,
|
| )
|
|
|
|
|
| @router.delete("/{document_id}")
|
| async def delete_document(
|
| document_id: str,
|
| session: AsyncSession = Depends(get_session),
|
| ) -> dict[str, str]:
|
| """Delete document metadata, chunks, and file."""
|
| doc = await session.get(Document, document_id)
|
| if doc is None:
|
| raise HTTPException(404, "Document not found")
|
|
|
| store = get_document_store()
|
| store.delete_by_document(document_id)
|
|
|
| settings = get_settings()
|
| folder = Path(settings.upload_path) / document_id
|
| if folder.exists():
|
| for child in folder.iterdir():
|
| child.unlink(missing_ok=True)
|
| folder.rmdir()
|
|
|
| await session.delete(doc)
|
| await session.commit()
|
| return {"status": "deleted", "id": document_id}
|
|
|
