webhook integration

app.py

@@ -1,34 +1,34 @@
-# app.py
 import os
 import sys
 from fastapi import FastAPI
+
+# Add paths to sys.path to allow relative imports
 sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "components")))
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "routes"))) 
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "routes")))
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "routes", "api")))
 
+# Import your API routes
+from routes.api import ingest  # routes/api/ingest.py
+from routes.api import query   # routes/api/query.py
+from routes.api import headlines  # routes/api/headlines.py
+from routes.api import wa_headlines  # routes/api/wa_headlines.py
+from routes.api import whatsapp_webhook as whatsapp_webhook_router_module
 
-# --- Your original imports ---
-from routes.api import ingest # Assuming routes/api/ingest.py exists and has a 'router'
-from routes.api import query # Assuming routes/api/query.py exists and has a 'router'
-from routes.api import headlines # Assuming routes/api/headlines.py exists and has a 'router'
-from routes.api import wa_headlines
-
-# You included Settings in your original, so I'll put it back.
-# NOTE: Settings.llm = None can cause issues if LlamaIndex operations
-# elsewhere expect a global LLM to be configured via Settings.
+# Optional: Global Settings (LlamaIndex)
 from llama_index.core.settings import Settings
 Settings.llm = None
 
-
+# Create FastAPI app
 app = FastAPI()
 
 @app.get("/")
 def greet():
     return {"welcome": "nuse ai"}
 
-# --- Your original router inclusions ---
+# Include your route modules
 app.include_router(ingest.router)
 app.include_router(query.router)
 app.include_router(headlines.router)
-app.include_router(wa_headlines.router)
+app.include_router(wa_headlines.router)
+app.include_router(whatsapp_webhook_router_module.router, prefix="/api/whatsapp", tags=["WhatsApp Webhook"])

components/gateways/headlines_to_wa.py

@@ -2,8 +2,8 @@ import os
 import json
 import redis
 import requests
-from fastapi import FastAPI
-from fastapi.responses import JSONResponse
+from fastapi import FastAPI # This import is not strictly needed in this file if it's just a module
+from fastapi.responses import JSONResponse # This import is not strictly needed in this file if it's just a module
 import logging
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -11,15 +11,12 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 # 🌐 Configuration from Environment Variables
 # These variables MUST be set in your environment (e.g., .env file, shell exports, deployment configs)
 REDIS_URL = os.environ.get("UPSTASH_REDIS_URL", "redis://localhost:6379")
-# Reverting API URL to generic WhatsApp message endpoint
 WHATSAPP_API_URL = os.environ.get("WHATSAPP_API_URL", "https://api.gupshup.io/wa/api/v1/msg") 
 WHATSAPP_TOKEN = os.environ.get("WHATSAPP_TOKEN")
 WHATSAPP_TO_NUMBER = os.environ.get("WHATSAPP_TO_NUMBER", "353899495777")  # e.g., "91xxxxxxxxxx"
 GUPSHUP_SOURCE_NUMBER = os.environ.get("GUPSHUP_SOURCE_NUMBER")  # e.g., your WABA number
 GUPSHUP_APP_NAME = os.environ.get("GUPSHUP_APP_NAME")  # e.g., your Gupshup app name
 
-# Removed: WHATSAPP_CATALOG_ID, WHATSAPP_PRODUCT_RETAILER_ID, WHATSAPP_FOOTER_TEXT, WHATSAPP_TEMPLATE_ID
-
 # ✅ Redis connection
 try:
     redis_client = redis.Redis.from_url(REDIS_URL, decode_responses=True)
@@ -30,7 +27,6 @@ except Exception as e:
     raise
 
 # 🧾 Fetch and format headlines
-# Reverting this function to generate the full text message content
 def fetch_cached_headlines() -> str:
     try:
         raw = redis_client.get("detailed_news_feed_cache") 
@@ -64,7 +60,6 @@ def fetch_cached_headlines() -> str:
     return "\n".join(message_parts)
 
 # 📤 Send via Gupshup WhatsApp API
-# Reverting to send a standard text message
 def send_to_whatsapp(message_text: str) -> dict: # Function expects the full message text
     # Validate critical environment variables for sending a message
     if not WHATSAPP_TOKEN or \
@@ -81,7 +76,6 @@ def send_to_whatsapp(message_text: str) -> dict: # Function expects the full mes
         "Cache-Control": "no-cache" # Add Cache-Control header
     }
 
-    # <<< REVERTED MESSAGE PAYLOAD FOR STANDARD TEXT MESSAGE >>>
     whatsapp_message_content = {
         "type": "text",
         "text": message_text # This is the full formatted text
@@ -112,61 +106,9 @@ def send_to_whatsapp(message_text: str) -> dict: # Function expects the full mes
         logging.error(f"❌ An unexpected error occurred during WhatsApp send: {e}")
         return {"status": "failed", "error": str(e), "code": 500}
 
-# 🚀 FastAPI App
-app = FastAPI()
-
-@app.get("/send-daily-whatsapp")
-def send_daily_whatsapp_digest():
-    logging.info("API Call: /send-daily-whatsapp initiated.")
-    
-    # fetch_cached_headlines now returns the full message text
-    full_message_text = fetch_cached_headlines()
-
-    if full_message_text.startswith("❌") or full_message_text.startswith("⚠️"):
-        logging.warning(f"Returning error due to issue fetching headlines: {full_message_text}")
-        return JSONResponse(status_code=404, content={"error": full_message_text})
-
-    # Call send_to_whatsapp with the full formatted text
-    result = send_to_whatsapp(full_message_text) 
-    
-    if result.get("status") == "success":
-        logging.info("✅ WhatsApp message sent successfully.")
-        return JSONResponse(status_code=200, content=result)
-    else:
-        logging.error(f"❌ Failed to send WhatsApp message: {result.get('error')}")
-        return JSONResponse(status_code=result.get("code", 500), content=result)
+# Removed the FastAPI app instance and endpoint from here,
+# as it will be defined in routes/api/wa_headlines.py
+# and then included in app.py.
 
-# 🧪 For local testing
-if __name__ == "__main__":
-    # For local testing, ensure these environment variables are set in your shell or .env file.
-    # Example .env content:
-    # UPSTASH_REDIS_URL="redis://your_redis_url"
-    # WHATSAPP_API_URL="https://api.gupshup.io/wa/api/v1/msg"
-    # WHATSAPP_TOKEN="YOUR_GUPSHUP_API_KEY"
-    # WHATSAPP_TO_NUMBER="919999999999"
-    # GUPSHUP_SOURCE_NUMBER="15557926439"
-    # GUPSHUP_APP_NAME="NuseAI"
-
-    # Simulate a cached detailed feed for testing
-    dummy_cached_detailed_feed = {
-        "india": {
-            "1": {"title": "India's Economy Surges", "description": "Rapid growth in manufacturing and services sectors signals a strong economic recovery, boosting investor confidence and job creation.", "sources": ["Times of India"]},
-            "2": {"title": "New Tech Policy Unveiled", "description": "Government introduces new regulations to foster innovation while addressing data privacy concerns, aiming to balance growth with user protection.", "sources": ["Indian Express"]}
-        },
-        "world": {
-            "3": {"title": "Global Climate Talks Advance", "description": "Nations agree on ambitious new targets for emissions reduction, marking a significant step towards combating climate change despite earlier disagreements.", "sources": ["BBC News"]},
-            "4": {"title": "Space Mission Explores Mars", "description": "A new rover successfully lands on Mars, sending back groundbreaking data that could revolutionize our understanding of planetary geology and potential for life.", "sources": ["CNN World"]}
-        }
-    }
-    # Store dummy data in Redis for testing fetch_cached_headlines
-    redis_client.set("detailed_news_feed_cache", json.dumps(dummy_cached_detailed_feed))
-
-
-    logging.info("\n--- WhatsApp Message Preview ---\n")
-    msg_preview = fetch_cached_headlines()
-    print(msg_preview)
-    
-    logging.info("\n--- Sending WhatsApp Message (Test) ---\n")
-    # This will attempt to send a real message if your env vars are valid
-    test_result = send_to_whatsapp(msg_preview)
-    print(test_result)
+# Removed the if __name__ == "__main__": block from here,
+# as it will be in routes/api/wa_headlines.py for local testing.

routes/api/whatsapp_webhook.py

@@ -0,0 +1,114 @@
+# routes/api/whatsapp_webhook.py
+from fastapi import APIRouter, Request, HTTPException, status
+from fastapi.responses import JSONResponse
+import logging
+import json
+
+# Import your function to send messages back
+from components.gateways.headlines_to_wa import fetch_cached_headlines, send_to_whatsapp
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+router = APIRouter()
+
+# WhatsApp/Gupshup webhook endpoint
+@router.post("/message-received")
+async def whatsapp_webhook_receiver(request: Request):
+    """
+    Receives incoming messages from Gupshup WhatsApp webhook.
+    Sends a daily news digest if the user sends a specific command.
+    """
+    try:
+        # Gupshup sends data as application/x-www-form-urlencoded
+        # or sometimes as raw JSON depending on setup.
+        # We need to try parsing both.
+        try:
+            form_data = await request.form()
+            payload_str = form_data.get('payload') # Gupshup often wraps JSON in a 'payload' field
+            if payload_str:
+                incoming_message = json.loads(payload_str)
+            else: # If not 'payload' field, try direct form parsing
+                incoming_message = dict(form_data)
+        except json.JSONDecodeError:
+            # Fallback for raw JSON body (less common for Gupshup, but good to have)
+            incoming_message = await request.json()
+        except Exception as e:
+            logging.error(f"Error parsing webhook request body: {e}")
+            return JSONResponse(status_code=400, content={"status": "error", "message": "Invalid request format"})
+
+
+        logging.info(f"Received WhatsApp webhook: {json.dumps(incoming_message, indent=2)}")
+
+        # Extract relevant info (Gupshup webhook structure can vary, common fields used below)
+        # This part might need fine-tuning based on actual Gupshup webhook JSON
+        message_data = incoming_message.get('payload', {}).get('payload', {}) # Gupshup often double-nests 'payload'
+        
+        # Try a different path if the above didn't work (common for raw JSON webhooks)
+        if not message_data:
+            message_data = incoming_message.get('message', {})
+            if not message_data: # Sometimes the direct message object is at the top level
+                message_data = incoming_message
+
+        from_number = message_data.get('sender', {}).get('phone') or message_data.get('from')
+        message_text = message_data.get('message', {}).get('text') or message_data.get('body') # Common text fields
+
+        if not from_number or not message_text:
+            logging.warning("Received webhook without valid sender or message text.")
+            return JSONResponse(status_code=200, content={"status": "ignored", "message": "Missing sender or text"})
+
+        logging.info(f"Message from {from_number}: {message_text}")
+
+        # Check for specific commands to send the digest
+        if message_text.lower().strip() == "digest":
+            logging.info(f"User {from_number} requested daily digest.")
+            
+            # Fetch the digest headlines
+            full_message_text = fetch_cached_headlines()
+
+            if full_message_text.startswith("❌") or full_message_text.startswith("⚠️"):
+                logging.error(f"Failed to fetch digest for {from_number}: {full_message_text}")
+                # Send an error message back to the user
+                send_to_whatsapp(f"Sorry, I couldn't fetch the news digest today. {full_message_text}", destination_number=from_number)
+                return JSONResponse(status_code=500, content={"status": "error", "message": "Failed to fetch digest"})
+            
+            # Send the digest back to the user who requested it
+            result = send_to_whatsapp(full_message_text, destination_number=from_number)
+
+            if result.get("status") == "success":
+                logging.info(f"✅ Successfully sent digest to {from_number}.")
+                return JSONResponse(status_code=200, content={"status": "success", "message": "Digest sent"})
+            else:
+                logging.error(f"❌ Failed to send digest to {from_number}: {result.get('error')}")
+                # Send an error message back to the user
+                send_to_whatsapp(f"Sorry, I couldn't send the news digest to you. Error: {result.get('error', 'unknown')}", destination_number=from_number)
+                return JSONResponse(status_code=500, content={"status": "error", "message": "Failed to send digest"})
+        else:
+            logging.info(f"Received unhandled message from {from_number}: '{message_text}'")
+            # Optional: Send a generic response for unhandled commands
+            # send_to_whatsapp("Sorry, I only understand 'Digest' for now.", destination_number=from_number)
+            return JSONResponse(status_code=200, content={"status": "ignored", "message": "No action taken for this command"})
+
+    except Exception as e:
+        logging.error(f"Error processing webhook: {e}", exc_info=True)
+        return JSONResponse(status_code=500, content={"status": "error", "message": str(e)})
+
+# Gupshup webhook verification endpoint (GET request with 'hub.mode' and 'hub.challenge')
+@router.get("/message-received")
+async def whatsapp_webhook_verify(request: Request):
+    """
+    Endpoint for Gupshup webhook verification.
+    """
+    mode = request.query_params.get("hub.mode")
+    challenge = request.query_params.get("hub.challenge")
+    verify_token = request.query_params.get("hub.verify_token") # You might set an env var for this
+
+    # Gupshup typically doesn't require a verify_token, unlike Facebook directly.
+    # However, if you configure it, you should check it.
+    # For now, we'll just return the challenge if mode is 'subscribe'.
+    
+    if mode == "subscribe" and challenge:
+        logging.info(f"Webhook verification successful. Challenge: {challenge}")
+        return JSONResponse(status_code=200, content=int(challenge)) # Challenge needs to be an integer
+    else:
+        logging.warning(f"Webhook verification failed. Mode: {mode}, Challenge: {challenge}")
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Verification failed")