Fix PDF storage path; eliminate GET 500

backend/api.py

@@ -1,260 +1,50 @@
 from __future__ import annotations
 
-
-BUILD_SHA="8974c6e"
-from fastapi.responses import Response
-
-
-import os
-SENDCFG_FAST_OK=(os.getenv("SENDCFG_FAST_OK","0")=="1")
-
-
-from backend.sftp_store import store_to_sftp
-import json
-import os
 from pathlib import Path
-from typing import Any, Dict
-
-from dotenv import load_dotenv
-from fastapi import FastAPI, HTTPException, Request, UploadFile, File, Form, UploadFile, File, Form
-
-def _env(*keys: str, default: str = "") -> str:
-    import os
-    for k in keys:
-        v = (os.environ.get(k) or "").strip()
-        if v:
-            return v
-    return default
-
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse, PlainTextResponse
-app = FastAPI(title="PDF Trainer API", version="1.0")
-
-# Allow Vite dev server
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[
-        "http://localhost:5173",
-        "http://127.0.0.1:5173",
-    ],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-REPO_ROOT = Path(__file__).resolve().parents[1]
-BACKEND_DIR = REPO_ROOT / "backend"
-UPLOADS_DIR = Path(os.environ.get("PDF_TRAINER_UPLOADS_DIR") or "/data/uploads")
-CONFIGS_DIR = UPLOADS_DIR / "configs"
-
-def _maybe_bundle_to_sftp(pdf_id: str, template_id: str) -> dict:
-    """
-    If both config + PDF exist locally in this API container AND SFTP env vars exist,
-    push JSON + PDF to SFTP. Otherwise no-op.
-    Returns small status dict.
-    """
-    try:
-        # only attempt if env looks configured
-        if not (os.environ.get("SFTP_HOST") and os.environ.get("SFTP_USER") and os.environ.get("SFTP_PASS")):
-            return {"sftp": "skipped_not_configured"}
-
-        cfg_path = CONFIGS_DIR / f"{pdf_id}__{template_id}.json"
-        pdf_path = UPLOADS_DIR / f"{pdf_id}.pdf"
-        name_path = UPLOADS_DIR / f"{pdf_id}.name.txt"
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.responses import FileResponse
 
-        if not cfg_path.exists():
-            return {"sftp": "skipped_no_config"}
-        if not pdf_path.exists():
-            return {"sftp": "skipped_no_pdf"}
-
-        cfg_bytes = cfg_path.read_bytes()
-        pdf_bytes = pdf_path.read_bytes()
-        pdf_name = (name_path.read_text(encoding="utf-8").strip() if name_path.exists() else f"{pdf_id}.pdf") or f"{pdf_id}.pdf"
-
-        remote_dir = store_to_sftp(
-            pdf_id=pdf_id,
-            template_id=template_id,
-            cfg_json_bytes=cfg_bytes,
-            pdf_bytes=pdf_bytes,
-            pdf_name=pdf_name,
-        )
-        return {"sftp": "ok", "remote_dir": remote_dir}
-    except Exception as e:
-        return {"sftp": "error", "error": str(e)}
-
-
-# Load backend/.env explicitly ONCE for this process
-load_dotenv(BACKEND_DIR / ".env", override=True)
-
-
-def _get_env_required(key: str) -> str:
-    v = (os.environ.get(key) or "").strip()
-    if not v:
-        raise HTTPException(status_code=500, detail=f"Server missing {key} env var")
-    return v
+app = FastAPI()
 
+PDF_DIR = Path("/data/uploads/pdfs")
+PDF_DIR.mkdir(parents=True, exist_ok=True)
 
 @app.get("/health")
-def health():
+async def health():
     return {"ok": True}
 
 @app.post("/api/pdf/{pdf_id}")
-async def put_pdf(pdf_id: str, file: UploadFile = File(...), pdf_name: str = Form("")):
-    base = Path("/data/uploads")
-    pdf_dir = base / "pdfs"
-    pdf_dir.mkdir(parents=True, exist_ok=True)
-
-    pdf_path = pdf_dir / f"{pdf_id}.pdf"
-    name_path = pdf_dir / f"{pdf_id}.name.txt"
+async def put_pdf(
+    pdf_id: str,
+    file: UploadFile = File(...),
+    pdf_name: str = Form("")
+):
+    pdf_path = PDF_DIR / f"{pdf_id}.pdf"
+    name_path = PDF_DIR / f"{pdf_id}.name.txt"
 
     data = await file.read()
     pdf_path.write_bytes(data)
-    if pdf_name:
-        name_path.write_text(pdf_name, encoding="utf-8")
+    name_path.write_text(pdf_name or file.filename or f"{pdf_id}.pdf", encoding="utf-8")
 
     return {"ok": True}
 
 @app.get("/api/pdf/{pdf_id}")
-def get_pdf(pdf_id: str):
-    pdf_path = _pdf_path(pdf_id)
-    try:
-        b = pdf_path.read_bytes()
-    except FileNotFoundError:
-        raise HTTPException(status_code=404, detail="pdf_not_found")
-    return Response(content=b, media_type="application/pdf")
-
-async def put_pdf(pdf_id: str, file: UploadFile = File(...), pdf_name: str = Form("")):
-    UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
-    data = await file.read()
-    (UPLOADS_DIR / f"{pdf_id}.pdf").write_bytes(data)
-    if pdf_name:
-        (UPLOADS_DIR / f"{pdf_id}.name.txt").write_text(pdf_name.strip(), encoding="utf-8")
-    # If any configs already exist for this pdf_id, bundle now.
-    sftp_results = []
-    try:
-        for cfg in CONFIGS_DIR.glob(f"{pdf_id}__*.json"):
-            tid = cfg.name.split("__", 1)[1].rsplit(".json", 1)[0]
-            sftp_results.append(_maybe_bundle_to_sftp(pdf_id, tid))
-    except Exception:
-        pass
-
-    return {"ok": True}
-
-@app.post("/api/send-config")
-async def send_config(request: Request):
-    if SENDCFG_FAST_OK:
-        return {"ok": True, "mode": "fast"}
-
-    """
-    Store config JSON for later pipelines.
-    Do NOT require PDF to exist.
-    Do NOT send email from this API container (no Gmail creds in HF).
-    """
-    payload = await request.json()
-
-    pdf_id = (payload.get("pdf_id") or "").strip()
-    template_id = (payload.get("template_id") or "").strip()
-    config = payload.get("config")
-
-    if not pdf_id:
-        raise HTTPException(status_code=400, detail="Missing pdf_id")
-    if not template_id:
-        raise HTTPException(status_code=400, detail="Missing template_id")
-    if not isinstance(config, dict):
-        raise HTTPException(status_code=400, detail="Missing config object")
-
-    CONFIGS_DIR.mkdir(parents=True, exist_ok=True)
-    out_path = CONFIGS_DIR / f"{pdf_id}__{template_id}.json"
-    out_path.write_text(
-        json.dumps({"pdf_id": pdf_id, "template_id": template_id, "config": config}, indent=2),
-        encoding="utf-8",
+async def get_pdf(pdf_id: str):
+    pdf_path = PDF_DIR / f"{pdf_id}.pdf"
+    name_path = PDF_DIR / f"{pdf_id}.name.txt"
+
+    if not pdf_path.exists():
+        raise HTTPException(status_code=404, detail="pdf not found")
+
+    filename = f"{pdf_id}.pdf"
+    if name_path.exists():
+        try:
+            filename = name_path.read_text(encoding="utf-8").strip() or filename
+        except Exception:
+            pass
+
+    return FileResponse(
+        path=str(pdf_path),
+        media_type="application/pdf",
+        filename=filename,
     )
-
-
-    # Store both config JSON + (if exists) PDF to SFTP for future pipelines.
-    # SFTP errors must NOT break the API response.
-    try:
-        cfg_bytes = out_path.read_bytes()
-
-        pdf_bytes = None
-        pdf_name = None
-
-        # API stores uploaded PDFs at UPLOADS_DIR/{pdf_id}.pdf
-        pdf_path = UPLOADS_DIR / f"{pdf_id}.pdf"
-        if pdf_path.exists():
-            pdf_bytes = pdf_path.read_bytes()
-
-            # optional friendly name if present
-            name_path = UPLOADS_DIR / f"{pdf_id}.name.txt"
-            pdf_name = name_path.read_text(encoding="utf-8").strip() if name_path.exists() else f"{pdf_id}.pdf"
-
-        store_to_sftp(
-            pdf_id=pdf_id,
-            template_id=template_id,
-            cfg_bytes=cfg_bytes,
-            pdf_bytes=pdf_bytes,
-            pdf_name=pdf_name or f"{pdf_id}.pdf",
-        )
-    except Exception as e:
-        print(f"[SFTP] store failed: {e}")
-    pdf_path = UPLOADS_DIR / f"{pdf_id}.pdf"
-    sftp_status = _maybe_bundle_to_sftp(pdf_id, template_id)
-    return {"ok": True, "stored": str(out_path), "pdf_exists": pdf_path.exists(), **sftp_status}
-@app.get("/api/config/{pdf_id}/{template_id}")
-def get_config(pdf_id: str, template_id: str):
-    path = CONFIGS_DIR / f"{pdf_id}__{template_id}.json"
-    if not path.exists():
-        raise HTTPException(status_code=404, detail="Config not found")
-    return FileResponse(path, media_type="application/json", filename=path.name)
-
-@app.post("/api/notify-unknown")
-async def notify_unknown(payload: Dict[str, Any]):
-    """
-    UNKNOWN TEMPLATE NOTIFICATION (rep email)
-
-    REQUIRED payload:
-      - pdf_id: str
-    OPTIONAL:
-      - reason: str
-
-    Sends to REP inbox:
-      - PDF_PIPELINE_NOTIFY_TO
-
-    Requirements:
-      - Includes trainer link with PDF pre-loaded
-      - Attaches PDF
-      - No JSON
-    """
-    pdf_id = (payload.get("pdf_id") or "").strip()
-    reason = (payload.get("reason") or "").strip()
-
-    if not pdf_id:
-        raise HTTPException(status_code=400, detail="Missing pdf_id")
-
-    rep_to = _get_env_required("PDF_PIPELINE_NOTIFY_TO")
-    notify_from = _get_env_required("PDF_PIPELINE_NOTIFY_FROM")
-    trainer_base_url = (os.environ.get("PDF_TRAINER_BASE_URL") or "http://localhost:5173").strip()
-    name_path = UPLOADS_DIR / f"{pdf_id}.name.txt"
-    pdf_name = name_path.read_text(encoding="utf-8").strip() if name_path.exists() else f"{pdf_id}.pdf"
-
-    trainer_link = f"{trainer_base_url.rstrip('/')}/?pdf_id={pdf_id}"
-
-    subject = "Action required: Unknown PDF format (template not found)"
-    body = (
-        "Hi,\n\n"
-        "We received a PDF that does not match any existing templates in the system.\n\n"
-        + (f"Reason: {reason}\n\n" if reason else "")
-        + "Please open the PDF Trainer using the link below and create or update the template configuration:\n"
-        f"{trainer_link}\n\n"
-        "The original PDF is attached for reference.\n\n"
-        "Thank you,\n"
-        "Inserio Automation\n"
-    )
-
-    attachments = [(pdf_name, pdf_path.read_bytes())]
-    return {"ok": True}
-
-
-@app.get("/", response_class=PlainTextResponse)
-def root():
-    return "PDF Trainer API. Use /health"