fix 106

components/gateways/headlines_to_wa.py

@@ -4,44 +4,83 @@ import redis
 import requests
 from fastapi import FastAPI
 from fastapi.responses import JSONResponse
+import logging # Import logging for better output
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # 🌐 Redis config
 REDIS_URL = os.environ.get("UPSTASH_REDIS_URL", "redis://localhost:6379")
 WHATSAPP_API_URL = os.environ.get("WHATSAPP_API_URL", "https://api.gupshup.io/sm/api/v1/msg")
-WHATSAPP_TOKEN = os.environ.get("WHATSAPP_TOKEN", "sk_e73f674b797549ed80c85105ded5a0d1")
-WHATSAPP_TO_NUMBER = os.environ.get("WHATSAPP_TO_NUMBER", "353899495777")  # e.g., "91xxxxxxxxxx"
-GUPSHUP_SOURCE_NUMBER = os.environ.get("GUPSHUP_SOURCE_NUMBER", "+1 555-792-6439")  # e.g., your WABA number
-GUPSHUP_APP_NAME = os.environ.get("GUPSHUP_APP_NAME", "NuseAI")  # e.g., your Gupshup app name
+WHATSAPP_TOKEN = os.environ.get("WHATSAPP_TOKEN")
+WHATSAPP_TO_NUMBER = os.environ.get("WHATSAPP_TO_NUMBER")  # 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
 
 # ✅ Redis connection
-redis_client = redis.Redis.from_url(REDIS_URL, decode_responses=True)
+try:
+    redis_client = redis.Redis.from_url(REDIS_URL, decode_responses=True)
+    redis_client.ping() # Test connection
+    logging.info("Redis client connected successfully.")
+except Exception as e:
+    logging.error(f"❌ Failed to connect to Redis: {e}")
+    # Depending on your application's needs, you might want to exit or fail gracefully here.
+    raise
 
 # 🧾 Fetch and format headlines
 def fetch_cached_headlines() -> str:
     try:
-        raw = redis_client.get("daily_news_headline_json")
+        # Assuming 'detailed_news_feed_cache' is the key for the final detailed headlines
+        # This key should match what's used in components/generators/detailed_explainer.py
+        raw = redis_client.get("detailed_news_feed_cache") 
         if not raw:
+            logging.warning("⚠️ No detailed news headlines found in cache.")
             return "⚠️ No daily headlines found in cache."
         data = json.loads(raw)
     except Exception as e:
+        logging.error(f"❌ Error reading from Redis: {e}")
         return f"❌ Error reading from Redis: {e}"
 
-    message = ["🗞️ *Your Daily Digest* 🟡\n"]
-    for topic, stories in data.items():
-        title = topic.replace("_", " ").title()
-        message.append(f"🏷️ *{title}*")
-        for ref, item in stories.items():
-            summary = item.get("summary", "")
-            explanation = item.get("explanation", "")
-            message.append(f"{ref}. {summary}\n_Why this matters_: {explanation}")
-        message.append("")  # spacing between sections
+    message_parts = ["🗞️ *Your Daily Digest* 🟡\n"]
+    
+    # Iterate through topics in the order defined by TOPIC_KEYS (if available, otherwise iterate data.items())
+    # Assuming TOPIC_KEYS is available globally or passed here if needed for consistent order
+    # For now, just iterate through the data items as they are in the cached JSON
+    
+    # Sort topics alphabetically for consistent output if no external order is provided
+    sorted_topics = sorted(data.keys())
+
+    for topic_key in sorted_topics:
+        stories = data[topic_key]
+        # Format topic title nicely (e.g., "india" -> "India", "world" -> "World")
+        title = topic_key.replace("_", " ").title() 
+        message_parts.append(f"🏷️ *{title}*")
+        
+        # Sort stories by their sequential ID for consistent order
+        sorted_story_ids = sorted(stories.keys(), key=int) # Ensure keys are treated as integers for sorting
+
+        for ref_id in sorted_story_ids:
+            item = stories[ref_id]
+            summary = item.get("title", "") # Use 'title' key for the summary/headline
+            description = item.get("description", "") # Use 'description' key for the explanation
+            
+            # Ensure ref_id is a string for the message
+            message_parts.append(f"{ref_id}. {summary}\n_Why this matters_: {description}")
+        message_parts.append("")  # spacing between sections
 
-    return "\n".join(message)
+    return "\n".join(message_parts)
 
 # 📤 Send via Gupshup WhatsApp API
 def send_to_whatsapp(message_text: str) -> dict:
+    # Validate environment variables
+    if not WHATSAPP_TOKEN or not WHATSAPP_TO_NUMBER or not GUPSHUP_SOURCE_NUMBER or not GUPSHUP_APP_NAME:
+        error_msg = "❌ Missing one or more WhatsApp API environment variables (WHATSAPP_TOKEN, WHATSAPP_TO_NUMBER, GUPSHUP_SOURCE_NUMBER, GUPSHUP_APP_NAME)."
+        logging.error(error_msg)
+        return {"status": "failed", "error": error_msg, "code": 500}
+
+    # Gupshup requires the API key in the 'apikey' header
     headers = {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/x-www-form-urlencoded",
+        "apikey": WHATSAPP_TOKEN # <<< FIX: API key in 'apikey' header
     }
 
     payload = {
@@ -55,35 +94,74 @@ def send_to_whatsapp(message_text: str) -> dict:
         "src.name": GUPSHUP_APP_NAME,
     }
 
-    response = requests.post(
-        WHATSAPP_API_URL,
-        headers=headers,
-        data=payload,
-        auth=(WHATSAPP_TOKEN, '')  # Gupshup uses Basic Auth (API key as username)
-    )
+    try:
+        logging.info(f"Attempting to send WhatsApp message to {WHATSAPP_TO_NUMBER} via Gupshup.")
+        response = requests.post(
+            WHATSAPP_API_URL,
+            headers=headers,
+            data=payload,
+            # auth=(WHATSAPP_TOKEN, '') # <<< REMOVED: This sends Basic Auth, which Gupshup doesn't support for API key
+        )
+        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
 
-    if response.status_code == 200:
         return {"status": "success", "details": response.json()}
-    else:
-        return {"status": "failed", "error": response.text, "code": response.status_code}
+    except requests.exceptions.RequestException as e:
+        logging.error(f"❌ Failed to send WhatsApp message: {e}")
+        return {"status": "failed", "error": str(e), "code": e.response.status_code if e.response else 500}
+    except Exception as e:
+        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.")
     message = fetch_cached_headlines()
 
     if message.startswith("❌") or message.startswith("⚠️"):
+        logging.warning(f"Returning error due to issue fetching headlines: {message}")
         return JSONResponse(status_code=404, content={"error": message})
 
     result = send_to_whatsapp(message)
-    return result
+    
+    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)
 
 # 🧪 For local testing
 if __name__ == "__main__":
-    msg = fetch_cached_headlines()
-    print("--- WhatsApp Message Preview ---\n")
-    print(msg)
-    result = send_to_whatsapp(msg)
-    print(result)
+    # Set dummy environment variables for local testing if not already set
+    os.environ.setdefault("WHATSAPP_API_URL", "https://api.gupshup.io/sm/api/v1/msg")
+    os.environ.setdefault("WHATSAPP_TOKEN", "YOUR_GUPSHUP_API_KEY") # Replace with a real dummy or your actual key
+    os.environ.setdefault("WHATSAPP_TO_NUMBER", "919999999999") # Replace with a test number
+    os.environ.setdefault("GUPSHUP_SOURCE_NUMBER", "918888888888") # Replace with your WABA number
+    os.environ.setdefault("GUPSHUP_APP_NAME", "YourTestApp") # Replace with your app name
+
+    # 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)