Email confirmation on send-config

README.md

@@ -9,3 +9,14 @@ pinned: false
 ---
 
 FastAPI service for PDF Trainer (pdf upload/download + send-config + notify-unknown).
+
+## Save configuration email
+
+When the Trainer UI calls `POST /api/send-config`, the API stores the JSON config and (optionally) emails a confirmation
+with the config JSON + original PDF attached.
+
+Set these env vars on the **pdf-trainer-api Space**:
+
+- `PDF_PIPELINE_PIPELINE_NOTIFY_TO` (recipient email for confirmations)
+- `PDF_PIPELINE_NOTIFY_FROM` (must be the same Gmail account you OAuth’d)
+- `GMAIL_CREDENTIALS_JSON` + `GMAIL_TOKEN_JSON` (paste full JSON contents; or use `PDF_PIPELINE_GMAIL_CREDENTIALS_JSON` / `PDF_PIPELINE_GMAIL_TOKEN_JSON`)

backend/api.py

@@ -8,6 +8,8 @@ from typing import Any, Dict, Optional
 from fastapi import FastAPI, UploadFile, File, Form, HTTPException
 from fastapi.responses import FileResponse, JSONResponse
 
+from backend.worker.gmail_client import GmailClient
+
 app = FastAPI(title="PDF Trainer API", version="1.0")
 
 DATA_DIR = Path(os.environ.get("DATA_DIR", "/data/uploads")).resolve()
@@ -16,6 +18,107 @@ CFG_DIR = DATA_DIR / "configs"
 PDF_DIR.mkdir(parents=True, exist_ok=True)
 CFG_DIR.mkdir(parents=True, exist_ok=True)
 
+_MAX_EMAIL_ATTACHMENT_BYTES = 20 * 1024 * 1024  # ~20MB
+
+
+def _looks_like_json(s: str) -> bool:
+    s = (s or "").strip()
+    return s.startswith("{") and s.endswith("}")
+
+
+def _alias_env(primary: str, fallback: str) -> None:
+    if (os.environ.get(primary) or "").strip():
+        return
+    fb = (os.environ.get(fallback) or "").strip()
+    if fb:
+        os.environ[primary] = fb
+
+
+def _resolve_json_or_path(env_name: str, default_path: Path, out_path: Path) -> Path:
+    raw = (os.environ.get(env_name) or "").strip()
+    if not raw:
+        return default_path
+
+    if _looks_like_json(raw):
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(raw, encoding="utf-8")
+        return out_path
+
+    return Path(raw)
+
+
+def _gmail_client() -> GmailClient:
+    _alias_env("GMAIL_CREDENTIALS_JSON", "PDF_PIPELINE_GMAIL_CREDENTIALS_JSON")
+    _alias_env("GMAIL_TOKEN_JSON", "PDF_PIPELINE_GMAIL_TOKEN_JSON")
+
+    creds_path = _resolve_json_or_path(
+        "GMAIL_CREDENTIALS_JSON",
+        Path("backend/credentials.json"),
+        Path("/tmp/credentials.json"),
+    )
+    token_path = _resolve_json_or_path(
+        "GMAIL_TOKEN_JSON",
+        Path("backend/token.json"),
+        Path("/tmp/token.json"),
+    )
+    return GmailClient(creds_path, token_path)
+
+
+def _send_config_confirmation_email(
+    *,
+    pdf_id: str,
+    template_id: str,
+    config_obj: Any,
+    notify_to: str,
+) -> None:
+    notify_from = (os.environ.get("PDF_PIPELINE_NOTIFY_FROM") or "").strip()
+    if not notify_from:
+        raise RuntimeError("Missing PDF_PIPELINE_NOTIFY_FROM env var")
+
+    cfg_filename = f"trainer_config_{pdf_id}__{template_id}.json"
+    cfg_bytes = json.dumps(config_obj, indent=2).encode("utf-8")
+
+    attachments = [(cfg_filename, cfg_bytes)]
+
+    # Attach PDF if available
+    pdf_path = PDF_DIR / f"{pdf_id}.pdf"
+    pdf_name_path = PDF_DIR / f"{pdf_id}.name.txt"
+    pdf_filename = f"{pdf_id}.pdf"
+    if pdf_name_path.exists():
+        try:
+            pdf_filename = (pdf_name_path.read_text(encoding="utf-8") or "").strip() or pdf_filename
+        except Exception:
+            pdf_filename = f"{pdf_id}.pdf"
+
+    pdf_attached = False
+    if pdf_path.exists():
+        try:
+            pdf_bytes = pdf_path.read_bytes()
+        except Exception:
+            pdf_bytes = b""
+        if pdf_bytes and len(pdf_bytes) <= _MAX_EMAIL_ATTACHMENT_BYTES:
+            attachments.append((pdf_filename, pdf_bytes))
+            pdf_attached = True
+
+    subject = f"PDF Trainer: configuration updated ({template_id})"
+    body_lines = [
+        "Configuration has been updated.",
+        "",
+        f"template_id: {template_id}",
+        f"pdf_id: {pdf_id}",
+        "",
+        f"PDF attached: {'yes' if pdf_attached else 'no'}",
+    ]
+
+    gmail = _gmail_client()
+    gmail.send_email(
+        to_email=notify_to,
+        from_email=notify_from,
+        subject=subject,
+        body_text="\n".join(body_lines) + "\n",
+        attachments=attachments,
+    )
+
 
 @app.get("/health")
 async def health() -> Dict[str, Any]:
@@ -83,6 +186,7 @@ async def send_config(payload: Dict[str, Any]) -> Dict[str, Any]:
     pdf_id = (payload.get("pdf_id") or "").strip()
     template_id = (payload.get("template_id") or "").strip()
     config = payload.get("config")
+    notify_to_override = (payload.get("notify_to") or payload.get("notifyTo") or "").strip()
 
     if not pdf_id:
         raise HTTPException(status_code=400, detail="Missing pdf_id")
@@ -99,21 +203,47 @@ async def send_config(payload: Dict[str, Any]) -> Dict[str, Any]:
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"failed to store config: {e}")
 
+    notify_to_default = (os.environ.get("PDF_PIPELINE_PIPELINE_NOTIFY_TO") or "").strip()
+    notify_to = (notify_to_override or notify_to_default).strip()
+
+    emailed = False
+    email_error: Optional[str] = None
+    if notify_to:
+        try:
+            _send_config_confirmation_email(
+                pdf_id=pdf_id,
+                template_id=template_id,
+                config_obj=out,
+                notify_to=notify_to,
+            )
+            emailed = True
+        except Exception as e:
+            email_error = str(e)
+
     pdf_exists = (PDF_DIR / f"{pdf_id}.pdf").exists()
-    return {"ok": True, "stored": str(cfg_path), "pdf_exists": pdf_exists, "sftp": "not_implemented_here"}
 
-@app.put("/api/pdf/{pdf_id}")
-async def put_pdf_alias(
-    pdf_id: str,
-    file: UploadFile = File(...),
-    pdf_name: str = Form("")
-):
-    return await post_pdf(pdf_id=pdf_id, file=file, pdf_name=pdf_name)
+    message = "Configuration has been updated."
+    if emailed:
+        message += f" Confirmation email sent to {notify_to}."
+    elif notify_to:
+        message += f" Email FAILED: {email_error}"
+    else:
+        message += " (No confirmation email: set PDF_PIPELINE_PIPELINE_NOTIFY_TO.)"
+
+    return {
+        "ok": True,
+        "message": message,
+        "stored": str(cfg_path),
+        "pdf_exists": pdf_exists,
+        "emailed": emailed,
+        "notify_to": notify_to or None,
+    }
 
 @app.put("/api/pdf/{pdf_id}")
 async def put_pdf_alias(
     pdf_id: str,
     file: UploadFile = File(...),
-    pdf_name: str = Form("")
+    pdf_name: Optional[str] = Form(None),
 ):
-    return await post_pdf(pdf_id=pdf_id, file=file, pdf_name=pdf_name)
+    # Backwards-compatible alias for clients that still use PUT.
+    return await put_pdf(pdf_id=pdf_id, file=file, pdf_name=pdf_name)