Update app.py

app.py

@@ -457,10 +457,31 @@ def send_email_notification(order_details):
         return None
 
 
+
+def match_dishes(user_input: str, threshold: int = 70) -> list:
+    matched_dishes = []
+    user_input_lower = user_input.lower()
+    for item in menu_items:
+        dish_name = item["name"]
+        # Direct substring check
+        if dish_name.lower() in user_input_lower:
+            matched_dishes.append(dish_name)
+        else:
+            score = fuzz.token_sort_ratio(user_input_lower, dish_name.lower())
+            if score >= threshold:
+                matched_dishes.append(dish_name)
+    return list(set(matched_dishes))
+
+def get_dish_price(dish: str) -> int:
+    for item in menu_items:
+        if item["name"].lower() == dish.lower():
+            return item["price"]
+    return 0
+
+
 async def process_order_flow(user_id: str, message: str) -> str:
     """
-    A unified approach to parse dish(es), quantity, phone, and address
-    whether the user provides them all at once or in multiple steps.
+    Processes order flow allowing an unlimited number of dishes.
     """
     state = user_state.get(user_id)
     if state and state.is_expired():
@@ -468,7 +489,7 @@ async def process_order_flow(user_id: str, message: str) -> str:
         del user_state[user_id]
         state = None
 
-    # 1) If user says "menu" or "order", initialize the flow
+    # 1) If user says "order" or "menu", initialize the order flow.
     if message.lower() in ["order", "menu"]:
         state = ConversationState()
         state.flow = "order"
@@ -479,7 +500,6 @@ async def process_order_flow(user_id: str, message: str) -> str:
             return "Sure! What dish would you like to order?"
         return ""
 
-    # If user says "order" but we have no state
     if not state and "order" in message.lower():
         state = ConversationState()
         state.flow = "order"
@@ -488,50 +508,33 @@ async def process_order_flow(user_id: str, message: str) -> str:
         user_state[user_id] = state
         return "Sure! What dish would you like to order?"
 
-    # 2) If we aren't in the order flow yet, try to detect dish(es)
+    # 2) If we are not already in the order flow, detect dish(es) from the message.
     if not state or state.flow != "order":
         matched = match_dishes(message)
         if matched:
-            # Multiple candidate dishes
-            if len(matched) > 1:
-                state = ConversationState()
-                state.flow = "order"
-                state.update_last_active()
-                user_state[user_id] = state
-                state.data["candidate_dishes"] = matched
-                dish_options = ", ".join(matched)
-                return (f"We found multiple dishes in your request: {dish_options}. "
-                        "Please specify which one you'd like to order or type 'both' if you'd like all.")
-            else:
-                # Single dish
+            if len(matched) == 1:
+                # Single dish: store in state.data["dish"]
                 found_dish = matched[0]
                 state = ConversationState()
                 state.flow = "order"
                 state.update_last_active()
                 user_state[user_id] = state
                 state.data["dish"] = found_dish
-                # Attempt to parse quantity, phone, address if user typed them all
-                single_dish_parse = _parse_single_dish_line(message, found_dish)
-                if single_dish_parse["quantity"]:
-                    state.data["quantity"] = single_dish_parse["quantity"]
+                # Try to parse quantity, phone, address from the same message.
+                single_parse = _parse_single_dish_line(message, found_dish)
+                if single_parse["quantity"]:
+                    state.data["quantity"] = single_parse["quantity"]
                     state.step = 3
                 else:
-                    # If no quantity found, we still need quantity
                     state.step = 2
-
-                if single_dish_parse["phone"]:
-                    state.data["phone_number"] = single_dish_parse["phone"]
-                if single_dish_parse["address"]:
-                    state.data["address"] = single_dish_parse["address"]
-
-                # Now see how much info we have:
+                if single_parse["phone"]:
+                    state.data["phone_number"] = single_parse["phone"]
+                if single_parse["address"]:
+                    state.data["address"] = single_parse["address"]
                 if state.step == 2 and not state.data.get("quantity"):
-                    # We must ask for quantity
                     return f"You selected {found_dish}. How many servings would you like?"
                 elif state.step == 3:
-                    # We have a quantity. Check if we also have phone and address
                     if state.data.get("phone_number") and state.data.get("address"):
-                        # We have everything needed to skip to step 5
                         shipping_cost = calculate_shipping_cost(state.data["address"])
                         state.data["shipping_cost"] = shipping_cost
                         state.step = 5
@@ -542,40 +545,29 @@ async def process_order_flow(user_id: str, message: str) -> str:
                         return "Thank you. Please provide your delivery address."
                     else:
                         return "Please provide your phone number and address."
+            else:
+                # Multiple dishes detected—allow unlimited dishes.
+                state = ConversationState()
+                state.flow = "order"
+                state.update_last_active()
+                user_state[user_id] = state
+                state.data["dishes"] = matched  # Store all matched dishes
+                state.step = 2
+                dish_options = ", ".join(matched)
+                return (f"You have selected the following dishes: {dish_options}.\n"
+                        "How many servings of each would you like? "
+                        "For example: '2 for Jollof Rice, 3 for Chicken Wings, 1 for Fish'")
         else:
-            # No dish matched
             return "I couldn't identify the dish. Please type the dish name from our menu."
 
-    # 3) If we have candidate dishes and user needs to clarify
-    if state and state.flow == "order" and "candidate_dishes" in state.data:
-        # If user typed "both" => they want all candidate dishes
-        if message.strip().lower() in ["both", "all"]:
-            state.data["dishes"] = state.data["candidate_dishes"]
-            del state.data["candidate_dishes"]
-            state.step = 2  # We'll parse "2 for Jollof Rice and 3 for Fried Rice"
-            dishes_str = ", ".join(state.data["dishes"])
-            return (f"You have selected: {dishes_str}. How many servings of each would you like? "
-                    "(For example, '2 for Jollof Rice and 3 for Fried Rice')")
-        else:
-            # Maybe the user typed a single dish out of the candidates
-            for dish in state.data["candidate_dishes"]:
-                if dish.lower() in message.lower():
-                    state.data["dish"] = dish
-                    del state.data["candidate_dishes"]
-                    state.step = 2
-                    return f"You selected {dish}. How many servings would you like?"
-            # If still unclear
-            dish_options = ", ".join(state.data["candidate_dishes"])
-            return (f"Please specify which one you'd like to order from: {dish_options} "
-                    "(or type 'both' if you'd like to order all).")
-
-    # 4) If step == 2 for multiple dishes => parse "2 for Jollof Rice and 3 for Fried Rice"
+    # 3) If state exists and we're at step 2: parse quantity details.
     if state and state.flow == "order" and state.step == 2:
+        # For multi-dish orders, expect input like "2 for Jollof Rice, 3 for Chicken Wings, 1 for Fish"
         if "dishes" in state.data and len(state.data["dishes"]) > 1:
             pairs = re.findall(r'(\d+)\s*for\s*([a-zA-Z\s]+)', message, flags=re.IGNORECASE)
             if not pairs:
                 return ("I'm sorry, I didn't understand the quantity details. "
-                        "Please specify like '2 for Jollof Rice and 3 for Fried Rice'.")
+                        "Please specify like '2 for Jollof Rice, 3 for Chicken Wings, 1 for Fish'.")
             order_quantities = {}
             for quantity, dish_text in pairs:
                 dish_text = dish_text.strip().lower()
@@ -590,9 +582,8 @@ async def process_order_flow(user_id: str, message: str) -> str:
                         "Please provide your phone number and delivery address.")
             else:
                 return ("I'm sorry, I couldn't match those dishes. "
-                        "Please try something like '2 for Jollof Rice and 3 for Fried Rice'.")
-
-        # Single-dish scenario at step 2 => user typed just a quantity
+                        "Please try something like '2 for Jollof Rice, 3 for Chicken Wings, 1 for Fish'.")
+        # For single-dish order at step 2: user types just a quantity.
         numbers = re.findall(r'\d+', message)
         if not numbers:
             return "Please enter a valid number for the quantity (e.g., 1, 2, 3)."
@@ -602,10 +593,10 @@ async def process_order_flow(user_id: str, message: str) -> str:
         state.data["quantity"] = quantity
         state.step = 3
         dish = state.data.get("dish", "")
-        return (f"Got it. {quantity} serving(s) of {dish}. "
+        return (f"Got it. {quantity} serving(s) of {dish}.\n"
                 "Please provide your phone number and delivery address.")
 
-    # 5) Step == 3 => parse phone & address for single or multiple dishes
+    # 4) If state.step == 3: parse phone & address
     if state and state.flow == "order" and state.step == 3:
         phone_pattern = r'(\+?\d{10,15})'
         phone_match = re.search(phone_pattern, message)
@@ -619,133 +610,99 @@ async def process_order_flow(user_id: str, message: str) -> str:
             state.data["address"] = address
             asyncio.create_task(update_user_profile(user_id, phone_number, address))
         else:
-            # Maybe the user typed an address only, or partial info
-            # If the phone was previously stored, we just store the address
             if "phone_number" in state.data:
                 state.data["address"] = message.strip()
             else:
-                # If no phone number found yet, we need it
                 return ("Please provide both your phone number and address. "
                         "For example: '09162409591, 1, Iyana Isashi, Isashi, Lagos'.")
-
         if "address" not in state.data:
-            # If we only found phone but no address, ask for address
             return "Thank you. Please provide your delivery address."
-
-        # If we have phone + address, move to step 5 => ask extras
         shipping_cost = calculate_shipping_cost(state.data["address"])
         state.data["shipping_cost"] = shipping_cost
         state.step = 5
         return (f"Thanks! Your phone number is recorded as: {state.data['phone_number']}.\n"
                 f"Your delivery address is: {state.data['address']}.\n"
                 f"Your delivery cost is N{shipping_cost}. Would you like extras (yes/no)?")
-    
-        # ... existing code above ...
 
-    # Step 5: Ask user about extras
+    # 5) Step 5: Ask about extras.
     if state and state.flow == "order" and state.step == 5:
-        # If user wants extras
         if message.lower() in ["yes", "y"]:
             state.step = 6
             return "Please list the extras you'd like (e.g., drinks, sides)."
-
-        # If user doesn't want extras
         elif message.lower() in ["no", "n"]:
             state.data["extras"] = ""
             state.step = 7
-            # Summarize the order so far
-            # If you handled multiple dishes, you'd need to show all. 
-            # For single dish, just show dish + quantity:
-            dish = state.data.get("dish", "")
-            quantity = state.data.get("quantity", 1)
-            phone = state.data.get("phone_number", "")
-            address = state.data.get("address", "")
-            shipping_cost = state.data.get("shipping_cost", 0)
-            extras = "None"
-            
-            # If you used state.data["orders"] for multiple dishes, 
-            # you'd build a summary from that dictionary.
-            
-            price_per_serving = 1500
-            total_price = (quantity * price_per_serving) + shipping_cost
-            summary = (f"Order Summary:\n"
-                       f"Dish: {dish}\n"
-                       f"Quantity: {quantity}\n"
-                       f"Phone: {phone}\n"
-                       f"Address: {address}\n"
-                       f"Shipping Cost: N{shipping_cost}\n"
-                       f"Total Price: N{total_price}\n"
-                       f"Extras: {extras}\n"
-                       f"Confirm order? (yes/no)")
-            return summary
-
+            # Prepare order summary for confirmation.
+            if "orders" in state.data:
+                # Multi-dish order summary:
+                summary = "\n".join([f"{qty} serving(s) of {dish}" for dish, qty in state.data["orders"].items()])
+                quantity_total = sum(state.data["orders"].values())
+                dish_summary = ", ".join(state.data["orders"].keys())
+            else:
+                summary = f"{state.data.get('quantity', 1)} serving(s) of {state.data.get('dish', '')}"
+                quantity_total = state.data.get("quantity", 1)
+                dish_summary = state.data.get("dish", "")
+            price_per_serving = get_dish_price(state.data.get("dish", "")) if "dish" in state.data else 0
+            total_price = (quantity_total * price_per_serving) + state.data.get("shipping_cost", 0)
+            confirmation = (f"Order Summary:\nDish(es): {dish_summary}\nQuantity: {quantity_total}\n"
+                            f"Phone: {state.data.get('phone_number', '')}\n"
+                            f"Address: {state.data.get('address', '')}\n"
+                            f"Shipping Cost: N{state.data.get('shipping_cost', 0)}\n"
+                            f"Total Price: N{total_price}\n"
+                            f"Extras: None\nConfirm order? (yes/no)")
+            return confirmation
         else:
-            # If user typed something else at step 5
             return "Please respond with 'yes' or 'no' regarding extras."
 
-    # Step 6: If user typed "yes" for extras, we prompt them for a list
+    # 6) Step 6: Process extras list.
     if state and state.flow == "order" and state.step == 6:
-        # The user has just listed extras
         state.data["extras"] = message
         state.step = 7
-        dish = state.data.get("dish", "")
-        quantity = state.data.get("quantity", 1)
-        phone = state.data.get("phone_number", "")
-        address = state.data.get("address", "")
-        shipping_cost = state.data.get("shipping_cost", 0)
-        extras = state.data.get("extras", "None")
-
-        price_per_serving = get_dish_price(state.data["dish"])
-        total_price = (quantity * price_per_serving) + shipping_cost
-        summary = (f"Order Summary:\n"
-                   f"Dish: {dish}\n"
-                   f"Quantity: {quantity}\n"
-                   f"Phone: {phone}\n"
-                   f"Address: {address}\n"
-                   f"Shipping Cost: N{shipping_cost}\n"
-                   f"Total Price: N{total_price}\n"
-                   f"Extras: {extras}\n"
-                   f"Confirm order? (yes/no)")
-        return summary
-
-    
-    # --- Step 7: Order Confirmation and Payment Link Generation ---
+        if "orders" in state.data:
+            summary = "\n".join([f"{qty} serving(s) of {dish}" for dish, qty in state.data["orders"].items()])
+            quantity_total = sum(state.data["orders"].values())
+            dish_summary = ", ".join(state.data["orders"].keys())
+        else:
+            summary = f"{state.data.get('quantity', 1)} serving(s) of {state.data.get('dish', '')}"
+            quantity_total = state.data.get("quantity", 1)
+            dish_summary = state.data.get("dish", "")
+        price_per_serving = get_dish_price(state.data.get("dish", "")) if "dish" in state.data else 0
+        total_price = (quantity_total * price_per_serving) + state.data.get("shipping_cost", 0)
+        confirmation = (f"Order Summary:\nDish(es): {dish_summary}\nQuantity: {quantity_total}\n"
+                        f"Phone: {state.data.get('phone_number', '')}\n"
+                        f"Address: {state.data.get('address', '')}\n"
+                        f"Shipping Cost: N{state.data.get('shipping_cost', 0)}\n"
+                        f"Total Price: N{total_price}\n"
+                        f"Extras: {state.data.get('extras', 'None')}\nConfirm order? (yes/no)")
+        return confirmation
+
+    # 7) Step 7: Order Confirmation and Payment Link Generation
     if state and state.flow == "order" and state.step == 7:
         if message.lower() in ["yes", "y"]:
             order_id = f"ORD-{int(time.time())}"
             state.data["order_id"] = order_id
-    
-            # Determine whether this is a single-dish order or multi-dish order.
+            # Handle both single-dish and multi-dish orders:
             if "orders" in state.data:
-                # Multi-dish order: state.data["orders"] is a dict mapping dish name to quantity.
                 total_price = 0
                 for dish, qty in state.data["orders"].items():
                     total_price += get_dish_price(dish) * qty
+                # Add shipping cost once.
                 total_price += state.data.get("shipping_cost", 0)
-                dish_summary = ", ".join([f"{dish} (x{qty})" for dish, qty in state.data["orders"].items()])
+                dish_summary = ", ".join(state.data["orders"].keys())
+                quantity_total = sum(state.data["orders"].values())
             else:
-                # Single-dish order:
-                if "dish" in state.data:
-                    dish_name = state.data["dish"]
-                elif "dishes" in state.data and len(state.data["dishes"]) == 1:
-                    dish_name = state.data["dishes"][0]
-                else:
-                    return "Error: No dish selected in your order. Please try ordering again."
-                price_per_serving = get_dish_price(dish_name)
-                quantity = state.data.get("quantity", 1)
-                total_price = (quantity * price_per_serving) + state.data.get("shipping_cost", 0)
-                dish_summary = dish_name
-    
+                dish_summary = state.data.get("dish", "")
+                quantity_total = state.data.get("quantity", 1)
+                total_price = (quantity_total * get_dish_price(dish_summary)) + state.data.get("shipping_cost", 0)
             state.data["price"] = str(total_price)
-    
+
             async def save_order():
                 async with async_session() as session:
-                    # For simplicity, we store the dish summary as a string.
                     order = Order(
                         order_id=order_id,
                         user_id=user_id,
                         dish=dish_summary,
-                        quantity=str(state.data.get("quantity", 1)),
+                        quantity=str(quantity_total),
                         price=str(total_price),
                         status="Pending Payment",
                         delivery_address=state.data.get("address", "")
@@ -754,57 +711,36 @@ async def process_order_flow(user_id: str, message: str) -> str:
                     await session.commit()
             asyncio.create_task(save_order())
             asyncio.create_task(log_order_tracking(order_id, "Order Placed", "Order placed and awaiting payment."))
-    
-            # Prepare order details for email (or any other notification)
-            order_details = {
-                "order_id": order_id,
-                "dish": dish_summary,
-                "quantity": state.data.get("quantity", 1),
-                "price": state.data["price"],
-                "address": state.data.get("address", ""),
-                "phone_number": state.data.get("phone_number", ""),
-                "extras": state.data.get("extras", "None")
-            }
-    
-            # Send email notification to admins via SMTP
-            admin_emails = os.getenv("ADMIN_EMAILS", "admin@example.com").split(",")
+
+            # Send email notification to admin via SMTP (using your SMTP integration)
+            admin_emails = os.getenv("ADMIN_EMAILS", "samyung05@gmail.com").split(",")
             email_subject = f"New Order Received: {order_id}"
             email_body = (
                 f"New Order Received:\n"
                 f"Order ID: {order_id}\n"
-                f"Dish: {order_details['dish']}\n"
-                f"Quantity: {order_details['quantity']}\n"
-                f"Total Price: N{order_details['price']}\n"
-                f"Phone: {order_details['phone_number']}\n"
-                f"Delivery Address: {order_details['address']}\n"
-                f"Extras: {order_details['extras']}\n"
+                f"Dish(es): {dish_summary}\n"
+                f"Quantity: {quantity_total}\n"
+                f"Total Price: N{total_price}\n"
+                f"Phone: {state.data.get('phone_number', '')}\n"
+                f"Delivery Address: {state.data.get('address', 'Not Provided')}\n"
+                f"Extras: {state.data.get('extras', 'None')}\n"
                 f"Status: Pending Payment"
             )
-            # Call your SMTP email helper; note that send_email_notification is synchronous.
+            # Call your SMTP API or use a helper to send email:
             email_sent = send_email_notification(admin_emails, email_subject, email_body)
             if email_sent:
                 print("Email notification sent successfully.")
             else:
                 print("Failed to send email notification.")
-    
-            # Generate Paystack payment link (amount in kobo)
-            email_for_paystack = "customer@example.com"  # Replace with actual customer email if available
+
+            email_for_paystack = "customer@example.com"  # Replace with actual email if available
             payment_data = create_paystack_payment_link(email_for_paystack, total_price * 100, order_id)
-            # Use dish from either "dish" or join "dishes" list
-            if "dish" in state.data:
-                dish_display = state.data["dish"]
-            elif "dishes" in state.data:
-                dish_display = ", ".join(state.data["dishes"])
-            else:
-                dish_display = "Unknown Dish"
-    
             state.reset()
             if user_id in user_state:
                 del user_state[user_id]
-    
             if payment_data.get("status"):
                 payment_link = payment_data["data"]["authorization_url"]
-                return (f"Thank you for your order of {state.data.get('quantity', 1)} serving(s) of {dish_display}! "
+                return (f"Thank you for your order of {quantity_total} serving(s) of {dish_summary}! "
                         f"Your Order ID is {order_id}.\n\n"
                         "Please complete your payment using one of the following options:\n"
                         f"1. Pay online via our Paystack link: {payment_link}\n"
@@ -825,9 +761,9 @@ async def process_order_flow(user_id: str, message: str) -> str:
             if user_id in user_state:
                 del user_state[user_id]
             return "Order canceled. Let me know if you'd like to try again."
-    return ""
-
 
+    # Final fallback
+    return ""
         
 
 def _parse_single_dish_line(message: str, dish_name: str) -> dict: