Update main.py

main.py

@@ -7,6 +7,10 @@ import hashlib
 import secrets
 import sqlite3
 import threading
+import json
+import hashlib
+from datetime import datetime, timedelta
+from fastapi.responses import JSONResponse
 from fastapi import FastAPI, Request, HTTPException, UploadFile, File, Form
 from pathlib import Path
 from datetime import datetime, timedelta
@@ -38,12 +42,24 @@ PUBLIC_BASE_URL = os.getenv("PUBLIC_BASE_URL", "https://domify-signup.hf.space")
 BREVO_API_KEY = os.getenv("BREVO_API_KEY", "")
 BREVO_FROM_EMAIL = os.getenv("BREVO_FROM_EMAIL", "domifyacademy@gmail.com")
 BREVO_FROM_NAME = os.getenv("BREVO_FROM_NAME", "Domify Academy")
-LEMON_API_KEY = os.getenv("LEMON_API_KEY", "")
-LEMON_WEBHOOK_SECRET = os.getenv("LEMON_WEBHOOK_SECRET", "")
 APPS_SCRIPT_URL = os.getenv("APPS_SCRIPT_URL", "")
 INTERNAL_API_TOKEN = os.getenv("INTERNAL_API_TOKEN", "")
 ADMIN_API_TOKEN = os.getenv("ADMIN_API_TOKEN", "")
 
+# ═══════════════════════════════════════════════
+#  DODO PAYMENTS CONFIGURATION
+# ═══════════════════════════════════════════════
+DODO_PAYMENTS_API_KEY = os.getenv("DODO_PAYMENTS_API_KEY", "")
+DODO_PAYMENTS_WEBHOOK_KEY = os.getenv("DODO_PAYMENTS_WEBHOOK_KEY", "")
+DODO_PAYMENTS_RETURN_URL = os.getenv("DODO_PAYMENTS_RETURN_URL", "https://domify-academy.free.nf/learn-cyber-security-2.html?upgrade=success")
+DODO_PAYMENTS_ENV = os.getenv("DODO_PAYMENTS_ENVIRONMENT", "test_mode")
+
+# Product ID → Tier mapping
+DODO_PRODUCT_TIERS = {
+    "pdt_0Nf7j0m48xid1j872jfkj": {"tier": "Professional", "days": 30, "cert_paid": False},
+    "pdt_0Nf7lGXVl9CQ2TmHcam4T": {"tier": "Master", "days": 30, "cert_paid": True},
+    "pdt_0Nf7lz4x5HvTks4rzvfqN": {"tier": None, "days": 0, "cert_paid": True},  # Certificate add‑on: tier unchanged
+}
 ADMIN_IPS = {
     "fe80::f26d:78ff:fe61:be53",
     "192.168.7.71",
@@ -179,7 +195,14 @@ def init_db() -> None:
             )
             """
         )
-
+conn.execute("""
+    CREATE TABLE IF NOT EXISTS webhook_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        webhook_id TEXT UNIQUE,
+        event_type TEXT,
+        processed_at TEXT
+    )
+""")
         conn.commit()
     finally:
         conn.close()
@@ -1191,7 +1214,249 @@ async def test_email(request: Request, to_email: str):
     ok = await send_brevo_email(to_email, "Test User", "Domify Test Email", html_body)
     return {"success": ok}
 
+# ═══════════════════════════════════════════════
+#  DODO PAYMENTS – CHECKOUT SESSION
+# ═══════════════════════════════════════════════
+from pydantic import BaseModel
+from typing import Optional
+
+class CheckoutRequest(BaseModel):
+    product_id: str
+    quantity: int = 1
+    customer_email: Optional[str] = None
+    customer_name: Optional[str] = None
+
+@app.post("/api/create-checkout")
+async def create_checkout_session(data: CheckoutRequest):
+    """
+    Creates a Dodo Payments checkout session and returns the hosted checkout URL.
+    The frontend redirects the user to this URL to complete payment.
+    """
+    if not DODO_PAYMENTS_API_KEY:
+        raise HTTPException(status_code=500, detail="DODO_PAYMENTS_API_KEY not configured")
+
+    if data.product_id not in DODO_PRODUCT_TIERS:
+        raise HTTPException(status_code=400, detail=f"Unknown product_id: {data.product_id}")
+
+    try:
+        from dodopayments import DodoPayments
+
+        client = DodoPayments(
+            bearer_token=DODO_PAYMENTS_API_KEY,
+            environment=DODO_PAYMENTS_ENV,
+        )
+
+        customer_block = {}
+        if data.customer_email:
+            customer_block["email"] = data.customer_email
+        if data.customer_name:
+            customer_block["name"] = data.customer_name
+
+        session = client.checkout_sessions.create(
+            product_cart=[{
+                "product_id": data.product_id,
+                "quantity": data.quantity,
+            }],
+            customer=customer_block if customer_block else None,
+            show_saved_payment_methods=True,
+            feature_flags={"allow_discount_code": True},
+            return_url=DODO_PAYMENTS_RETURN_URL,
+        )
+
+        return {
+            "success": True,
+            "session_id": session.session_id,
+            "checkout_url": session.checkout_url,
+        }
+
+    except ImportError:
+        raise HTTPException(
+            status_code=500,
+            detail="dodopayments SDK not installed. Run: pip install dodopayments"
+        )
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+# ═══════════════════════════════════════════════
+#  DODO PAYMENTS – WEBHOOK HANDLER
+# ═══════════════════════════════════════════════
+@app.post("/webhook/dodo")
+async def dodo_webhook_handler(request: Request):
+    """
+    Handles Dodo Payments webhook events.
+    Verifies the webhook signature using the Dodo Payments SDK and processes
+    payment confirmations to upgrade user tiers.
+    """
+    if not DODO_PAYMENTS_WEBHOOK_KEY:
+        raise HTTPException(status_code=500, detail="DODO_PAYMENTS_WEBHOOK_KEY is not set")
+
+    try:
+        body = await request.body()
+
+        # ── SDK‑based signature verification (official Dodo boilerplate) ──
+        try:
+            from dodopayments import DodoPayments
+
+            client = DodoPayments(
+                bearer_token=DODO_PAYMENTS_API_KEY,
+                environment=DODO_PAYMENTS_ENV,
+                webhook_key=DODO_PAYMENTS_WEBHOOK_KEY,
+            )
+            unwrapped = client.webhooks.unwrap(
+                body,
+                headers={
+                    "webhook-id": request.headers.get("webhook-id", ""),
+                    "webhook-signature": request.headers.get("webhook-signature", ""),
+                    "webhook-timestamp": request.headers.get("webhook-timestamp", ""),
+                },
+            )
+            if not unwrapped:
+                return JSONResponse(status_code=400, content={"error": "Webhook verification failed"})
+
+        except ImportError:
+            # ── Fallback: manual HMAC‑SHA256 verification ──
+            webhook_id = request.headers.get("webhook-id", "")
+            webhook_signature = request.headers.get("webhook-signature", "")
+            webhook_timestamp = request.headers.get("webhook-timestamp", "")
+
+            if not all([webhook_id, webhook_signature, webhook_timestamp]):
+                return JSONResponse(status_code=400, content={"error": "Missing webhook headers"})
+
+            # Reject webhooks older than 5 minutes (anti‑replay)
+            try:
+                ts_int = int(webhook_timestamp)
+                if abs(time.time() - ts_int) > 300:
+                    return JSONResponse(status_code=400, content={"error": "Webhook too old"})
+            except ValueError:
+                return JSONResponse(status_code=400, content={"error": "Invalid timestamp"})
+
+            signed_message = f"{webhook_id}.{webhook_timestamp}.{body.decode()}"
+            expected = hmac.new(
+                DODO_PAYMENTS_WEBHOOK_KEY.encode(),
+                signed_message.encode(),
+                hashlib.sha256,
+            ).hexdigest()
+
+            if not hmac.compare_digest(webhook_signature, expected):
+                return JSONResponse(status_code=401, content={"error": "Invalid signature"})
+
+        # ── Parse payload ──
+        try:
+            raw_text = body.decode("utf-8") if isinstance(body, (bytes, bytearray)) else body
+            payload = json.loads(raw_text)
+        except json.JSONDecodeError:
+            return JSONResponse(status_code=400, content={"error": "Invalid JSON"})
+
+        event_type = payload.get("type", "")
+        event_data = payload.get("data", {})
+        webhook_id_val = payload.get("id", "") or request.headers.get("webhook-id", "")
 
+        print(f"📨 Dodo webhook: {event_type} (id={webhook_id_val})")
+
+        if event_type != "payment.succeeded":
+            return {"status": "ignored", "event": event_type}
+
+        # ── Idempotency check ──
+        conn = get_db()
+        try:
+            existing = conn.execute(
+                "SELECT id FROM webhook_events WHERE webhook_id = ?", (webhook_id_val,)
+            ).fetchone()
+            if existing:
+                conn.close()
+                return {"status": "already_processed", "webhook_id": webhook_id_val}
+
+            conn.execute(
+                "INSERT INTO webhook_events (webhook_id, event_type, processed_at) VALUES (?, ?, ?)",
+                (webhook_id_val, event_type, datetime.utcnow().isoformat()),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+        # ── Extract customer & product ──
+        customer_email = event_data.get("customer", {}).get("email", "")
+        # product_id may be nested in different locations
+        product_id = (
+            event_data.get("product_id")
+            or (event_data.get("product_cart", [{}])[0].get("product_id") if event_data.get("product_cart") else None)
+            or ""
+        )
+
+        if not customer_email or not product_id:
+            return {"status": "ignored", "reason": "Missing email or product_id"}
+
+        product_config = DODO_PRODUCT_TIERS.get(product_id)
+        if not product_config:
+            return {"status": "ignored", "reason": f"Unknown product_id: {product_id}"}
+
+        # ── Update user tier ──
+        conn = get_db()
+        try:
+            with DB_LOCK:
+                user = conn.execute(
+                    "SELECT * FROM users WHERE email = ?", (customer_email,)
+                ).fetchone()
+
+                if user:
+                    if product_config["tier"] is not None:
+                        # Normal tier upgrade
+                        expiry = None
+                        if product_config["days"] > 0:
+                            expiry = (datetime.utcnow() + timedelta(days=product_config["days"])).isoformat()
+                        conn.execute(
+                            "UPDATE users SET tier = ?, expiry = ?, cert_paid = ? WHERE email = ?",
+                            (product_config["tier"], expiry, 1 if product_config["cert_paid"] else 0, customer_email),
+                        )
+                    else:
+                        # Certificate add‑on: only flip cert_paid, leave tier/expiry alone
+                        conn.execute(
+                            "UPDATE users SET cert_paid = 1 WHERE email = ?",
+                            (customer_email,),
+                        )
+                    print(f"✅ Upgraded {customer_email} to {product_config['tier'] or 'certificate add-on'}")
+                else:
+                    # Create user if they don't exist yet
+                    expiry = None
+                    if product_config["days"] > 0:
+                        expiry = (datetime.utcnow() + timedelta(days=product_config["days"])).isoformat()
+                    tier = product_config["tier"] or "Free"
+                    conn.execute(
+                        """
+                        INSERT INTO users (user_id, full_name, email, signup_date, country, source,
+                                           ip, timestamp, tier, expiry, cert_paid, cert_generated)
+                        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                        """,
+                        (
+                            f"dodo_{webhook_id_val}",
+                            customer_email,
+                            customer_email,
+                            datetime.utcnow().isoformat(),
+                            "",
+                            "dodo_payment",
+                            "",
+                            datetime.utcnow().isoformat(),
+                            tier,
+                            expiry,
+                            1 if product_config["cert_paid"] else 0,
+                            0,
+                        ),
+                    )
+                    print(f"✅ Created new user {customer_email} via Dodo payment")
+
+                conn.commit()
+        finally:
+            conn.close()
+
+        return {"status": "success", "tier": product_config.get("tier")}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"❌ Dodo webhook error: {str(e)}")
+        return JSONResponse(status_code=500, content={"error": str(e)})
+        
 async def keep_alive_self():
     while True:
         try: