Make /api/send-config store-first; email best-effort

backend/api.py

@@ -87,10 +87,16 @@ async def put_pdf(pdf_id: str, file: UploadFile = File(...), pdf_name: str = For
     return {"ok": True}
 
 @app.post("/api/send-config")
-async def send_config(payload: Dict[str, Any]):
-    import os, json, io
-    from fastapi import HTTPException
+async def send_config(request: Request):
+    """
+    Store config (always) and email pipeline (best-effort).
 
+    Required JSON payload:
+      - pdf_id: str
+      - template_id: str
+      - config: dict
+    """
+    payload = await request.json()
     pdf_id = (payload.get("pdf_id") or "").strip()
     template_id = (payload.get("template_id") or "").strip()
     config = payload.get("config")
@@ -102,6 +108,7 @@ async def send_config(payload: Dict[str, Any]):
     if not isinstance(config, dict):
         raise HTTPException(status_code=400, detail="Missing config object")
 
+    # PDF must exist in API uploads (worker uploads it first)
     pdf_path = UPLOADS_DIR / f"{pdf_id}.pdf"
     if not pdf_path.exists():
         raise HTTPException(status_code=404, detail="PDF not found for pdf_id")
@@ -109,93 +116,32 @@ async def send_config(payload: Dict[str, Any]):
     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"
 
-    cfg_obj = {"pdf_id": pdf_id, "template_id": template_id, "config": config}
-    cfg_bytes = (json.dumps(cfg_obj, indent=2) + "\n").encode("utf-8")
-    pdf_bytes = pdf_path.read_bytes()
-
-    # Local store (always)
-    local_dir = (UPLOADS_DIR / "configs" / template_id / pdf_id)
-    local_dir.mkdir(parents=True, exist_ok=True)
-    (local_dir / f"trainer_config_{pdf_id}_{template_id}.json").write_bytes(cfg_bytes)
-    (local_dir / pdf_name).write_bytes(pdf_bytes)
-
-    # SFTP store (best-effort)
-    sftp_status = {"enabled": False, "ok": False, "error": ""}
-    host = (os.environ.get("SFTP_HOST") or "").strip()
-    user = (os.environ.get("SFTP_USER") or "").strip()
-    root = (os.environ.get("SFTP_ROOT") or "").strip().rstrip("/")
-    if host and user and root:
-        sftp_status["enabled"] = True
-        try:
-            import paramiko
-            port = int((os.environ.get("SFTP_PORT") or "22").strip())
-            timeout = int((os.environ.get("SFTP_TIMEOUT_SECONDS") or "20").strip())
-            password = (os.environ.get("SFTP_PASS") or "").strip()
-            pkey_text = (os.environ.get("SFTP_PRIVATE_KEY") or "").strip()
-
-            client = paramiko.SSHClient()
-            client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-
-            pkey = None
-            if pkey_text:
-                try:
-                    pkey = paramiko.RSAKey.from_private_key(io.StringIO(pkey_text))
-                except Exception:
-                    pkey = paramiko.Ed25519Key.from_private_key(io.StringIO(pkey_text))
-
-            client.connect(
-                hostname=host,
-                port=port,
-                username=user,
-                password=password if (password and not pkey) else None,
-                pkey=pkey,
-                timeout=timeout,
-                banner_timeout=timeout,
-                auth_timeout=timeout,
-            )
-
-            sftp = client.open_sftp()
-
-            def mkdir_p(path: str):
-                parts = path.strip("/").split("/")
-                cur = ""
-                for part in parts:
-                    cur += "/" + part
-                    try:
-                        sftp.stat(cur)
-                    except IOError:
-                        sftp.mkdir(cur)
-
-            base = f"{root}/{template_id}/{pdf_id}".replace("//", "/")
-            mkdir_p(base)
-
-            with sftp.open(f"{base}/trainer_config_{pdf_id}_{template_id}.json", "wb") as f:
-                f.write(cfg_bytes)
-            with sftp.open(f"{base}/{pdf_name}", "wb") as f:
-                f.write(pdf_bytes)
-
-            sftp_status["ok"] = True
-        except Exception as e:
-            sftp_status["error"] = str(e)
-        finally:
-            try:
-                sftp.close()
-            except Exception:
-                pass
-            try:
-                client.close()
-            except Exception:
-                pass
-
-    # Email (best-effort: must NOT 500 the request)
-    email_status = {"ok": False, "error": ""}
+    # 1) STORE config on disk (source of truth)
+    CONFIGS_DIR.mkdir(parents=True, exist_ok=True)
+    out_path = CONFIGS_DIR / f"trainer_config_{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",
+    )
+
+    # 2) EMAIL pipeline best-effort (never 500 if email fails)
+    email_ok = False
+    email_err = ""
     try:
         pipeline_to = _get_env_required("PDF_PIPELINE_PIPELINE_NOTIFY_TO")
         notify_from = _get_env_required("PDF_PIPELINE_NOTIFY_FROM")
-        trainer_base_url = (os.environ.get("PDF_TRAINER_BASE_URL") or "https://saadmin-pdf-trainer-ui.hf.space").strip()
-        trainer_link = f"{trainer_base_url.rstrip('/')}/?pdf_id={pdf_id}"
+
+        # creds/token can be path OR raw json text; we only support path in HF container
+        creds = (os.environ.get("PDF_PIPELINE_GMAIL_CREDENTIALS_JSON") or "").strip()
+        token = (os.environ.get("PDF_PIPELINE_GMAIL_TOKEN_JSON") or "").strip()
+
+        if not creds or not token or not Path(creds).exists() or not Path(token).exists():
+            raise RuntimeError("Gmail OAuth files not present in container (expected file paths)")
 
         subject = f"PDF_TRAINER_CONFIG_SUBMITTED | template_id={template_id}"
+        trainer_base_url = (os.environ.get("PDF_TRAINER_BASE_URL") or "").strip()
+        trainer_link = f"{trainer_base_url.rstrip('/')}/?pdf_id={pdf_id}" if trainer_base_url else f"(trainer url not set) pdf_id={pdf_id}"
+
         body = (
             "Hi,\n\n"
             "A PDF Trainer configuration was submitted.\n\n"
@@ -203,36 +149,40 @@ async def send_config(payload: Dict[str, Any]):
             f"pdf_id: {pdf_id}\n"
             f"trainer_link: {trainer_link}\n\n"
             "Attachments:\n"
-            f"- trainer_config_{pdf_id}_{template_id}.json\n"
+            f"- {out_path.name}\n"
             f"- {pdf_name}\n\n"
             "Thank you,\n"
             "Inserio Automation\n"
         )
 
+        cfg_bytes = out_path.read_bytes()
+        attachments = [
+            (out_path.name, cfg_bytes),
+            (pdf_name, pdf_path.read_bytes()),
+        ]
+
         gmail = _gmail()
         gmail.send_email(
             to_email=pipeline_to,
             from_email=notify_from,
             subject=subject,
             body_text=body,
-            attachments=[
-                (f"trainer_config_{pdf_id}_{template_id}.json", cfg_bytes),
-                (pdf_name, pdf_bytes),
-            ],
+            attachments=attachments,
         )
-        email_status["ok"] = True
+        email_ok = True
+
     except Exception as e:
-        email_status["error"] = str(e)
+        email_err = str(e)
 
     return {
         "ok": True,
-        "pdf_id": pdf_id,
-        "template_id": template_id,
-        "local_dir": str(local_dir),
-        "sftp": sftp_status,
-        "email": email_status,
+        "stored": str(out_path),
+        "pdf_present": True,
+        "email_ok": email_ok,
+        "email_error": email_err,
     }
 
+
 @app.post("/api/notify-unknown")
 async def notify_unknown(payload: Dict[str, Any]):
     """