feat: robust report management and configuration architecture + API

Author: Calebnzm

.gitignore

@@ -2,4 +2,6 @@
 .idea
 venv
 .venv
-*.db
+*.db
+template_files/
+.env

api/db/models.py

@@ -14,6 +14,8 @@ class Template(SQLModel, table=True):
 class FormSubmission(SQLModel, table=True):
     id: int | None = Field(default=None, primary_key=True)
     template_id: int
+    report_schema_id: int | None = Field(default=None)
+    name: str | None = Field(default=None)
     input_text: str
     output_pdf_path: str
     created_at: datetime = Field(default_factory=datetime.utcnow)

api/main.py

@@ -1,7 +1,25 @@
 from fastapi import FastAPI
-from api.routes import templates, forms
+from fastapi.middleware.cors import CORSMiddleware
+
+from api.routes import templates, forms, report_schemas
+from api.errors.handlers import register_exception_handlers
 
 app = FastAPI()
+register_exception_handlers(app)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://127.0.0.1:5173",
+        "http://localhost:5173",
+        "http://127.0.0.1:4173",
+        "http://localhost:4173",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 app.include_router(templates.router)
-app.include_router(forms.router)
+app.include_router(forms.router)
+app.include_router(report_schemas.router)

api/routes/report_schemas.py

@@ -0,0 +1,178 @@
+from pathlib import Path
+from sqlite3 import IntegrityError
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import FileResponse
+from sqlmodel import Session, select
+from api.deps import get_db
+from api.schemas.report_class import (
+    ReportSchemaCreate,
+    ReportSchemaUpdate,
+    ReportSchemaResponse,
+    TemplateAssociation,
+    SchemaFieldResponse,
+    SchemaFieldUpdate,
+    CanonicalSchema,
+    ReportFill,
+    ReportFillResponse,
+    FormSubmissionResponse,
+)
+from api.db import repositories as repo
+from api.db.models import ReportSchema
+from src.report_schema import ReportSchemaProcessor
+from src.controller import Controller
+from api.db.models import FormSubmission, ReportSchemaTemplate
+from sqlalchemy.exc import IntegrityError
+
+router = APIRouter(prefix="/schemas", tags=["schemas"])
+
+
+@router.post("/create", response_model=ReportSchemaResponse)
+def create_schema(data: ReportSchemaCreate, db: Session = Depends(get_db)):
+    schema = ReportSchema(**data.model_dump())
+    try:
+        return repo.create_report_schema(db, schema)
+    except IntegrityError:
+        raise HTTPException(
+            status_code=409,
+            detail="A schema with this name already exists"
+        )
+
+@router.get("/", response_model=list[ReportSchemaResponse])
+def list_schemas(db: Session = Depends(get_db)):
+    return repo.list_report_schemas(db)
+
+@router.get("/{schema_id}", response_model=ReportSchemaResponse)
+def get_schema(schema_id: int, db: Session = Depends(get_db)):
+    schema = repo.get_report_schema(db, schema_id)
+    if not schema:
+        raise HTTPException(status_code=404, detail="Schema not found")
+    return schema
+
+@router.put("/{schema_id}", response_model=ReportSchemaResponse)
+def update_schema(schema_id: int, data: ReportSchemaUpdate, db: Session = Depends(get_db)):
+    updates = data.model_dump(exclude_none=True)
+    schema = repo.update_report_schema(db, schema_id, updates)
+    if not schema:
+        raise HTTPException(status_code=404, detail="Schema not found")
+    return schema
+
+@router.delete("/{schema_id}")
+def delete_schema(schema_id: int, db: Session = Depends(get_db)):
+    deleted = repo.delete_report_schema(db, schema_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Schema not found")
+    return {"detail": "Schema deleted"}
+
+
+@router.post("/{schema_id}/templates", response_model=list[SchemaFieldResponse])
+def add_template(schema_id: int, data: TemplateAssociation, db: Session = Depends(get_db)):
+    """Associate a template with a schema.
+
+    Auto-creates SchemaField entries from template.fields and returns them.
+    """
+    try:
+        repo.add_template_to_schema(db, schema_id, data.template_id)
+    except IntegrityError:
+        raise HTTPException(status_code=409, detail="Template is already added to schema")
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    return repo.get_schema_fields(db, schema_id)
+
+@router.delete("/{schema_id}/templates/{template_id}")
+def remove_template(schema_id: int, template_id: int, db: Session = Depends(get_db)):
+    removed = repo.remove_template_from_schema(db, schema_id, template_id)
+    if not removed:
+        raise HTTPException(status_code=404, detail="Template association not found")
+    return {"detail": "Template disassociated"}
+
+
+
+@router.get("/{schema_id}/fields", response_model=list[SchemaFieldResponse])
+def list_fields(schema_id: int, db: Session = Depends(get_db)):
+    return repo.get_schema_fields(db, schema_id)
+
+@router.put("/{schema_id}/fields/{field_id}", response_model=SchemaFieldResponse)
+def update_field(schema_id: int, field_id: int, data: SchemaFieldUpdate, db: Session = Depends(get_db)):
+    updates = data.model_dump(exclude_none=True)
+    field = repo.update_schema_field(db, schema_id, field_id, updates)
+    if not field:
+        raise HTTPException(status_code=404, detail="Field not found or does not belong to this schema")
+    return field
+
+
+@router.post("/{schema_id}/canonize", response_model=CanonicalSchema)
+def canonize_schema(schema_id: int, db: Session = Depends(get_db)):
+    """Trigger canonization: group fields, assign canonical names, generate field mappings."""
+    schema = repo.get_report_schema(db, schema_id)
+    if not schema:
+        raise HTTPException(status_code=404, detail="Schema not found")
+
+    return ReportSchemaProcessor.canonize(db, schema_id)
+
+@router.get("/mapping/{schema_id}/{template_id}")
+def get_schema_template_mapping(schema_id: int, template_id: int, db: Session = Depends(get_db)):
+    return repo.get_field_mapping(db, schema_id, template_id)
+
+@router.post("/{schema_id}/fill", response_model=ReportFillResponse)
+def fill_schema(schema_id: int, data: ReportFill, db: Session = Depends(get_db)):
+    """
+    End-to-end report generation.
+    Takes a single transcript, extracts canonical fields, distributes to
+    all schema templates, fills them, and logs the submissions.
+    """
+    schema = repo.get_report_schema(db, schema_id)
+    if not schema:
+        raise HTTPException(status_code=404, detail="Schema not found")
+    
+    controller = Controller()
+    
+    output_paths = controller.fill_report(db, data.input_text, schema_id)
+
+    # Log submissions
+    submission_ids: list[int] = []
+    for template_id, path in output_paths.items():
+        submission = FormSubmission(
+            template_id=template_id,
+            report_schema_id=schema_id,
+            name=data.name,
+            input_text=data.input_text,
+            output_pdf_path=path
+        )
+        db.add(submission)
+        db.flush()
+        submission_ids.append(submission.id)  # type: ignore
+            
+    db.commit()
+
+    return ReportFillResponse(
+        schema_id=schema_id,
+        input_text=data.input_text,
+        output_pdf_paths=list(output_paths.values()),
+        submission_ids=submission_ids,
+    )
+
+
+@router.get("/{schema_id}/submissions", response_model=list[FormSubmissionResponse])
+def list_submissions(schema_id: int, db: Session = Depends(get_db)):
+    """List all form submissions for a given schema."""
+    return db.exec(
+        select(FormSubmission)
+        .where(FormSubmission.report_schema_id == schema_id)
+        .order_by(FormSubmission.created_at.desc())  # type: ignore
+    ).all()
+
+
+@router.get("/submissions/{submission_id}/pdf")
+def get_submission_pdf(submission_id: int, db: Session = Depends(get_db)):
+    """Serve a filled PDF for a given form submission."""
+    submission = db.get(FormSubmission, submission_id)
+    if not submission:
+        raise HTTPException(status_code=404, detail="Submission not found")
+    path = Path(submission.output_pdf_path).resolve()
+    if not path.is_file():
+        raise HTTPException(status_code=404, detail="PDF file missing on disk")
+    return FileResponse(
+        path,
+        media_type="application/pdf",
+        filename=f"submission_{submission_id}.pdf",
+    )

api/routes/templates.py

@@ -1,16 +1,131 @@
-from fastapi import APIRouter, Depends
+import re
+from sqlalchemy.exc import IntegrityError
+import uuid
+from pathlib import Path
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
+from fastapi.responses import FileResponse
 from sqlmodel import Session
+
 from api.deps import get_db
-from api.schemas.templates import TemplateCreate, TemplateResponse
-from api.db.repositories import create_template
 from api.db.models import Template
+from api.db.repositories import (
+    create_template,
+    delete_template,
+    get_template,
+    update_template,
+    list_templates
+)
+from api.schemas.templates import TemplateResponse, TemplateUpdate
 from src.controller import Controller
 
 router = APIRouter(prefix="/templates", tags=["templates"])
 
+INPUT_FILES_DIR = Path(__file__).resolve().parents[2] / "template_files"
+
+
+def _safe_name_fragment(name: str) -> str:
+    base = Path(name).name
+    s = re.sub(r"[^\w\-.]+", "_", base.strip(), flags=re.UNICODE)
+    s = s.strip("._-") or "template"
+    return s[:120]
+
+
 @router.post("/create", response_model=TemplateResponse)
-def create(template: TemplateCreate, db: Session = Depends(get_db)):
+def create(
+    name: str = Form(...),
+    file: UploadFile = File(...),
+    db: Session = Depends(get_db),
+):
+    filename = (file.filename or "").lower()
+    if not filename.endswith(".pdf"):
+        raise HTTPException(status_code=400, detail="File must be a .pdf")
+
+    frag = _safe_name_fragment(name)
+    uid = uuid.uuid4().hex
+    INPUT_FILES_DIR.mkdir(parents=True, exist_ok=True)
+    dest = INPUT_FILES_DIR / f"{frag}_{uid}.pdf"
+
+    raw = file.file.read()
+    if not raw:
+        raise HTTPException(status_code=400, detail="Empty file")
+    dest.write_bytes(raw)
+
     controller = Controller()
-    template_path = controller.create_template(template.pdf_path)
-    tpl = Template(**template.model_dump(exclude={"pdf_path"}), pdf_path=template_path)
-    return create_template(db, tpl)
+    try:
+        template_path = controller.create_template(str(dest))
+    except Exception as e:
+        dest.unlink(missing_ok=True)
+        print(e)
+        raise HTTPException(
+            status_code=500, detail=f"Failed to prepare PDF template: {e}"
+        ) from e
+
+    fields = controller.extract_template_fields(template_path)
+    tpl = Template(name=name.strip(), fields=fields, pdf_path=template_path)
+
+    try:
+        return create_template(db, tpl)
+    except IntegrityError:
+        raise HTTPException(
+            status_code=409,
+            detail="A template with the same name already  exists"
+        )
+
+@router.get("/", response_model=list[Template])
+def list(db: Session = Depends(get_db)):
+    return list_templates(db)
+
+
+@router.get("/{template_id}/pdf")
+def get_template_pdf(template_id: int, db: Session = Depends(get_db)):
+    """Serve the stored PDF for preview in the schema wizard."""
+    tpl = get_template(db, template_id)
+    if not tpl:
+        raise HTTPException(status_code=404, detail="Template not found")
+    root = INPUT_FILES_DIR.resolve()
+    path = Path(tpl.pdf_path).resolve()
+    try:
+        path.relative_to(root)
+    except ValueError:
+        raise HTTPException(status_code=403, detail="Invalid template file location")
+    if not path.is_file():
+        raise HTTPException(status_code=404, detail="PDF file missing on disk")
+    return FileResponse(
+        path,
+        media_type="application/pdf",
+        filename=f"{tpl.name}.pdf",
+    )
+
+
+@router.get("/{template_id}", response_model=TemplateResponse)
+def get_one(template_id: int, db: Session = Depends(get_db)):
+    tpl = get_template(db, template_id)
+    if not tpl:
+        raise HTTPException(status_code=404, detail="Template not found")
+    return tpl
+
+
+@router.put("/{template_id}", response_model=TemplateResponse)
+def update_one(
+    template_id: int,
+    data: TemplateUpdate,
+    db: Session = Depends(get_db),
+):
+    updates = data.model_dump(exclude_none=True)
+    if not updates:
+        tpl = get_template(db, template_id)
+        if not tpl:
+            raise HTTPException(status_code=404, detail="Template not found")
+        return tpl
+    tpl = update_template(db, template_id, updates)
+    if not tpl:
+        raise HTTPException(status_code=404, detail="Template not found")
+    return tpl
+
+
+@router.delete("/{template_id}")
+def delete_one(template_id: int, db: Session = Depends(get_db)):
+    if not delete_template(db, template_id):
+        raise HTTPException(status_code=404, detail="Template not found")
+    return {"detail": "Template deleted"}