Update main.py

main.py

@@ -24,6 +24,13 @@ load_dotenv()
 nameserver1 = os.getenv('nameserver1', '8.8.8.8')
 nameserver2 = os.getenv('nameserver2', '8.8.4.4')
 
+# Configure Gemini AI
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+gemini = genai.GenerativeModel('gemini-2.0-flash-exp')
+
+products_df = pd.read_csv("supermarket_data1.csv")
+user_carts: Dict[str, List[dict]] = {}
+
 # Configure global DNS resolution
 def setup_dns():
     """Configure DNS resolution globally"""
@@ -49,6 +56,72 @@ def setup_dns():
 # Setup DNS resolution
 setup_dns()
 
+def parse_user_intent(text: str) -> dict:
+    """Use Gemini to parse user intent and context"""
+    try:
+        prompt = f"""Analyze this shopping query and return JSON with:
+        - intent: [product_search, cart_check, checkout, other]
+        - scenario: brief description
+        - budget: extracted number or null
+        - required_categories: list of relevant product categories
+        - constraints: list of important constraints
+        
+        Query: {text}"""
+        
+        response = gemini.generate_content(prompt)
+        return eval(response.text)
+    except Exception as e:
+        logger.error(f"Gemini parse error: {e}")
+        return {"intent": "other"}
+
+def search_products(query: dict, branch: str = "Harare") -> pd.DataFrame:
+    """Search products based on Gemini analysis"""
+    try:
+        filtered = products_df[
+            (products_df["Branch"] == branch) &
+            (products_df["Category"].isin(query.get("required_categories", []))) &
+            (products_df["Price"] <= (query.get("budget") or float('inf')))
+        ]
+        return filtered.sort_values("Price").head(5)
+    except Exception as e:
+        logger.error(f"Search error: {e}")
+        return pd.DataFrame()
+
+def create_cart_response(user_id: str, products: pd.DataFrame, total: float = 0):
+    """Create interactive cart response with buttons"""
+    products_text = "\n".join(
+        f"{row['Product']} - ${row['Price']:.2f}" 
+        for _, row in products.iterrows()
+    )
+    
+    buttons = []
+    if not products.empty:
+        for _, row in products.iterrows():
+            buttons.append({
+                "type": "reply",
+                "reply": {"id": f"add_{row.name}", "title": f"Add {row['Product']}"}
+            })
+        buttons.append({"type": "reply", "reply": {"id": "cancel", "title": "Cancel"}})
+    else:
+        return {"text": "No products found matching your criteria."}
+
+    cart = user_carts.get(user_id, [])
+    if cart:
+        cart_total = sum(item["price"] for item in cart)
+        response_text = (
+            f"Suggested Products:\n{products_text}\n\n"
+            f"Current Cart Total: ${cart_total:.2f}\n"
+            "Select products to add:"
+        )
+        buttons.extend([
+            {"type": "reply", "reply": {"id": "checkout", "title": "Checkout"}},
+            {"type": "reply", "reply": {"id": "continue", "title": "Keep Shopping"}}
+        ])
+    else:
+        response_text = f"Suggested Products:\n{products_text}\n\nSelect products to add:"
+
+    return {"text": response_text, "buttons": buttons}
+
 # Initialize WhatsApp
 try:
     messenger = WhatsApp(
@@ -102,87 +175,85 @@ def hook():
     """Main webhook handler"""
     try:
         data = request.get_json()
-        logger.info("Received webhook data: %s", data)
-        
-        changed_field = messenger.changed_field(data)
-        if changed_field != "messages":
-            return "OK", 200
-            
-        if not messenger.is_message(data):
-            delivery = messenger.get_delivery(data)
-            if delivery:
-                logger.info(f"Message delivery status: {delivery}")
-            return "OK", 200
-
-        # Extract message details
         mobile = messenger.get_mobile(data)
-        name = messenger.get_name(data)
-        message_type = messenger.get_message_type(data)
         
-        logger.info(f"New Message; sender:{mobile} name:{name} type:{message_type}")
-
-        # Handle different message types
-        try:
-            if message_type == "text":
-                message = messenger.get_message(data)
-                logger.info("Message: %s", message)
-                messenger.send_message(f"Hi {name}, nice to connect with you", mobile)
-
-            elif message_type == "interactive":
-                message_response = messenger.get_interactive_response(data)
-                interactive_type = message_response.get("type")
-                message_id = message_response[interactive_type]["id"]
-                message_text = message_response[interactive_type]["title"]
-                logger.info(f"Interactive Message; {message_id}: {message_text}")
-
-            elif message_type == "location":
-                message_location = messenger.get_location(data)
-                message_latitude = message_location["latitude"]
-                message_longitude = message_location["longitude"]
-                logger.info("Location: %s, %s", message_latitude, message_longitude)
-
-            elif message_type in ["image", "video", "audio", "document"]:
-                handle_media_message(messenger, data, message_type, mobile)
-
+        if messenger.is_message(data):
+            message = messenger.get_message(data)
+            intent = parse_user_intent(message)
+            
+            if intent["intent"] == "checkout":
+                return handle_checkout(mobile)
+                
+            elif intent["intent"] == "cart_check":
+                return send_cart_summary(mobile)
+                
             else:
-                logger.info(f"{mobile} sent unsupported message type: {message_type}")
-                logger.debug(f"Full message data: {data}")
-
-        except Exception as e:
-            logger.error(f"Error processing message type {message_type}: {str(e)}")
-            return "Internal server error", 500
-
+                products = search_products(intent)
+                response = create_cart_response(mobile, products)
+                messenger.send_interactive_button(
+                    response["text"], 
+                    response["buttons"],
+                    mobile
+                )
+                
+        elif messenger.is_interactive(data):
+            response = messenger.get_interactive_response(data)
+            handle_button_click(mobile, response["id"])
+            
         return "OK", 200
 
     except Exception as e:
-        logger.error(f"Error in webhook handler: {str(e)}")
+        logger.error(f"Webhook error: {e}")
         return "Internal server error", 500
 
-def handle_media_message(messenger, data, message_type, mobile):
-    """Handle different types of media messages"""
-    try:
-        media_methods = {
-            "image": messenger.get_image,
-            "video": messenger.get_video,
-            "audio": messenger.get_audio,
-            "document": messenger.get_document
-        }
+def handle_button_click(user_id: str, button_id: str):
+    """Handle interactive button clicks"""
+    if button_id.startswith("add_"):
+        product_id = int(button_id.split("_")[1])
+        product = products_df.loc[product_id].to_dict()
+        user_carts.setdefault(user_id, []).append(product)
+        messenger.send_message(f"{product['Product']} added to cart!", user_id)
         
-        media = media_methods[message_type](data)
-        media_id, mime_type = media["id"], media["mime_type"]
+    elif button_id == "checkout":
+        messenger.send_interactive_button(
+            "Confirm checkout?",
+            [
+                {"type": "reply", "reply": {"id": "confirm", "title": "Confirm"}},
+                {"type": "reply", "reply": {"id": "cancel", "title": "Cancel"}}
+            ],
+            user_id
+        )
         
-        try:
-            media_url = messenger.query_media_url(media_id)
-            media_filename = messenger.download_media(media_url, mime_type)
-            logger.info(f"{mobile} sent {message_type} {media_filename}")
-        except requests.exceptions.ConnectionError as ce:
-            logger.error(f"Connection error while downloading {message_type}: {str(ce)}")
-        except Exception as e:
-            logger.error(f"Error downloading {message_type}: {str(e)}")
-            
-    except Exception as e:
-        logger.error(f"Error processing {message_type} message: {str(e)}")
-        raise
+    elif button_id == "confirm":
+        cart = user_carts.pop(user_id, [])
+        total = sum(item["Price"] for item in cart)
+        messenger.send_message(
+            f"Order confirmed! Total: ${total:.2f}\n"
+            "Your items will be ready for pickup in 1 hour.",
+            user_id
+        )
+
+def send_cart_summary(user_id: str):
+    """Send current cart summary to user"""
+    cart = user_carts.get(user_id, [])
+    if not cart:
+        messenger.send_message("Your cart is empty!", user_id)
+        return
+    
+    cart_text = "\n".join(
+        f"{item['Product']} - ${item['Price']:.2f}" 
+        for item in cart
+    )
+    total = sum(item["Price"] for item in cart)
+    
+    messenger.send_interactive_button(
+        f"Current Cart:\n{cart_text}\nTotal: ${total:.2f}",
+        [
+            {"type": "reply", "reply": {"id": "checkout", "title": "Checkout"}},
+            {"type": "reply", "reply": {"id": "clear", "title": "Clear Cart"}}
+        ],
+        user_id
+    )
 
 def test_connection():
     """Test DNS resolution and connection to Graph API"""