Update app.py

app.py

@@ -28,6 +28,7 @@ PAYSTACK_SECRET_KEY = os.getenv("PAYSTACK_SECRET_KEY", "default_fallback_value")
 DATABASE_URL = os.getenv("DATABASE_URL", "default_fallback_value")  # Example using SQLite
 NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY", "default_fallback_value")
 openai.api_key = os.getenv("OPENAI_API_KEY", "default_fallback_value")
+GOOGLE_MAPS_API_KEY = os.getenv("GOOGLE_MAPS_API_KEY", "default_fallback_value")  # Add Google Maps API key
 
 # WhatsApp Business API credentials (Cloud API)
 WHATSAPP_PHONE_NUMBER_ID = os.getenv("WHATSAPP_PHONE_NUMBER_ID", "default_value")
@@ -77,6 +78,7 @@ class UserProfile(Base):
     email = Column(String, default="unknown@example.com")
     preferences = Column(Text, default="")
     last_interaction = Column(DateTime, default=datetime.utcnow)
+    order_ids = Column(Text, default="")  # Store order IDs as a comma-separated string
 
 class SentimentLog(Base):
     __tablename__ = "sentiment_logs"
@@ -86,7 +88,6 @@ class SentimentLog(Base):
     sentiment_score = Column(Float)
     message = Column(Text)
 
-# --- New Model: Order Tracking ---
 class OrderTracking(Base):
     __tablename__ = "order_tracking"
     id = Column(Integer, primary_key=True, index=True)
@@ -276,33 +277,96 @@ def calculate_shipping_cost(address: str) -> int:
             return cost
     return TOWN_SHIPPING_COSTS["default"]  # Default shipping cost for unknown areas
 
-# ... (rest of your imports and setup)
+# --- Google Maps ETA Calculation ---
+def calculate_eta(destination: str) -> str:
+    """
+    Calculate ETA from the restaurant address to the customer's delivery address using Google Maps API.
+    """
+    if not GOOGLE_MAPS_API_KEY:
+        return "ETA unavailable (Google Maps API key missing)."
 
-async def update_user_profile(user_id: str, phone_number: str = None, address: str = None) -> UserProfile:
+    origin = "Plot 13 Isashi Road, Iyana Isashi, Off Lagos - Badagry Expy, Lagos"
+    url = f"https://maps.googleapis.com/maps/api/directions/json?origin={origin}&destination={destination}&key={GOOGLE_MAPS_API_KEY}"
+    
+    try:
+        response = requests.get(url, timeout=10)
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("routes"):
+                duration = data["routes"][0]["legs"][0]["duration"]["text"]
+                return f"Estimated delivery time: {duration}"
+            else:
+                return "ETA unavailable (no route found)."
+        else:
+            return "ETA unavailable (API error)."
+    except Exception as e:
+        return f"ETA unavailable (error: {str(e)})."
+
+# --- Contextual Order Intent Detection ---
+def is_order_intent(message: str) -> bool:
+    """
+    Check if the user's message indicates an intent to place an order.
     """
-    Update or create a user profile with the provided phone number and address.
+    order_keywords = ["order", "menu", "dish", "food", "deliver", "hungry"]
+    order_phrases = ["I want to order", "Can I order", "I'd like to order", "get food", "place an order"]
+
+    message_lower = message.lower()
+    for phrase in order_phrases:
+        if phrase in message_lower:
+            return True
+    for keyword in order_keywords:
+        if keyword in message_lower:
+            # Ensure the keyword is not part of another word (e.g., "border")
+            if re.search(rf"\b{keyword}\b", message_lower):
+                return True
+    return False
+
+# --- Order Tracking Functionality ---
+async def track_order(user_id: str, order_id: str) -> str:
     """
+    Track an order and return its status and ETA.
+    """
+    async with async_session() as session:
+        # Fetch order details
+        order_result = await session.execute(
+            select(Order).where(Order.order_id == order_id)
+        order = order_result.scalars().first()
+        if not order:
+            return "Order not found. Please check your order ID."
+
+        # Fetch tracking updates
+        tracking_result = await session.execute(
+            select(OrderTracking)
+            .where(OrderTracking.order_id == order_id)
+            .order_by(OrderTracking.timestamp)
+        )
+        tracking_updates = tracking_result.scalars().all()
+
+        # Calculate ETA
+        eta = calculate_eta(order.delivery_address)
+
+        # Prepare response
+        response = f"Order ID: {order_id}\nStatus: {order.status}\n"
+        if tracking_updates:
+            response += "Tracking Updates:\n"
+            for update in tracking_updates:
+                response += f"- {update.status} ({update.timestamp}): {update.message or 'No details'}\n"
+        response += f"\n{eta}"
+        return response
+
+# --- Update User Profile with Order IDs ---
+async def update_user_profile_with_order(user_id: str, order_id: str):
     async with async_session() as session:
         result = await session.execute(
             select(UserProfile).where(UserProfile.user_id == user_id)
         )
         profile = result.scalars().first()
-        if profile is None:
-            profile = UserProfile(
-                user_id=user_id,
-                phone_number=phone_number,
-                address=address,
-                last_interaction=datetime.utcnow()
-            )
-        else:
-            if phone_number:
-                profile.phone_number = phone_number
-            if address:
-                profile.address = address
-            profile.last_interaction = datetime.utcnow()
-        session.add(profile)
-        await session.commit()
-        return profile
+        if profile:
+            if profile.order_ids:
+                profile.order_ids += f",{order_id}"
+            else:
+                profile.order_ids = order_id
+            await session.commit()
 
 # ... (rest of your imports and setup)
 
@@ -522,79 +586,88 @@ def process_order_flow(user_id: str, message: str) -> str:
                        f"Extras: {extras}\nConfirm order? (yes/no)")
             return summary
 
-        # --- Step 7: Order Confirmation & Finalization ---
-        if state.step == 7:
-            if message.lower() in ["yes", "y"]:
-                order_id = f"ORD-{int(time.time())}"
-                state.data["order_id"] = order_id
-                price_per_serving = 1500  # Fixed price per serving
-                quantity = state.data.get("quantity", 1)
-                shipping_cost = state.data.get("shipping_cost", 0)
-                total_price = (quantity * price_per_serving) + shipping_cost
-                state.data["price"] = str(total_price)
-
-                # Save the order asynchronously (including delivery_address, phone, extras, shipping_cost)
-                async def save_order():
-                    async with async_session() as session:
-                        order = Order(
-                            order_id=order_id,
-                            user_id=user_id,
-                            dish=state.data["dish"],
-                            quantity=str(quantity),
-                            price=str(total_price),
-                            status="Pending Payment",
-                            delivery_address=state.data.get("address", ""),
-                            shipping_cost=str(shipping_cost)  # Save shipping cost
-                        )
-                        session.add(order)
-                        await session.commit()
-                asyncio.create_task(save_order())
-
-                # Record the initial tracking update: Order Placed
-                asyncio.create_task(log_order_tracking(order_id, "Order Placed", "Order placed and awaiting payment."))
-
-                # Notify management of the new order via WhatsApp
-                async def notify_management_order(order_details: dict):
-                    message_body = (
-                        f"New Order Received:\n"
-                        f"Order ID: {order_details['order_id']}\n"
-                        f"Dish: {order_details['dish']}\n"
-                        f"Quantity: {order_details['quantity']}\n"
-                        f"Total Price: {order_details['price']}\n"
-                        f"Phone: {state.data.get('phone_number', '')}\n"
-                        f"Delivery Address: {order_details.get('address', 'Not Provided')}\n"
-                        f"Extras: {state.data.get('extras', 'None')}\n"
-                        f"Status: Pending Payment"
-                    )
-                    await asyncio.to_thread(send_whatsapp_message, MANAGEMENT_WHATSAPP_NUMBER, message_body)
-                order_details = {
-                    "order_id": order_id,
-                    "dish": state.data["dish"],
-                    "quantity": state.data["quantity"],
-                    "price": state.data["price"],
-                    "address": state.data.get("address", "")
-                }
-                asyncio.create_task(notify_management_order(order_details))
-
-                email = "customer@example.com"  # Placeholder; retrieve from profile if available
-                payment_data = create_paystack_payment_link(email, total_price * 100, order_id)
-                dish_name = state.data.get("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 {quantity} serving(s) of {dish_name}! "
-                            f"Your Order ID is {order_id}.\nPlease complete payment here: {payment_link}\n"
-                            "You can track your order status using your Order ID.\n"
-                            "Is there anything else you'd like to order?")
-                else:
-                    return f"Your order has been placed with Order ID {order_id}, but we could not initialize payment. Please try again later."
-            else:
-                state.reset()
-                if user_id in user_state:
-                    del user_state[user_id]
-                return "Order canceled. Let me know if you'd like to try again."
+      # Inside the order confirmation step (step 7)
+if state.step == 7:
+    if message.lower() in ["yes", "y"]:
+        order_id = f"ORD-{int(time.time())}"
+        state.data["order_id"] = order_id
+        price_per_serving = 1500  # Fixed price per serving
+        quantity = state.data.get("quantity", 1)
+        shipping_cost = state.data.get("shipping_cost", 0)
+        total_price = (quantity * price_per_serving) + shipping_cost
+        state.data["price"] = str(total_price)
+
+        # Calculate ETA
+        delivery_address = state.data.get("address", "")
+        eta = calculate_eta(delivery_address)
+
+        # Save the order asynchronously
+        async def save_order():
+            async with async_session() as session:
+                order = Order(
+                    order_id=order_id,
+                    user_id=user_id,
+                    dish=state.data["dish"],
+                    quantity=str(quantity),
+                    price=str(total_price),
+                    status="Pending Payment",
+                    delivery_address=delivery_address,
+                    shipping_cost=str(shipping_cost)
+                )
+                session.add(order)
+                await session.commit()
+        asyncio.create_task(save_order())
+
+        # Record the initial tracking update: Order Placed
+        await log_order_tracking(order_id, "Order Placed", "Order placed and awaiting payment.")
+
+        # Notify management via WhatsApp about the new order
+        async def notify_management_order(order_details: dict):
+            message_body = (
+                f"New Order Received:\n"
+                f"Order ID: {order_details['order_id']}\n"
+                f"Dish: {order_details['dish']}\n"
+                f"Quantity: {order_details['quantity']}\n"
+                f"Total Price: {order_details['price']}\n"
+                f"Phone: {state.data.get('phone_number', '')}\n"
+                f"Delivery Address: {order_details.get('address', 'Not Provided')}\n"
+                f"Extras: {state.data.get('extras', 'None')}\n"
+                f"Status: Pending Payment"
+            )
+            await asyncio.to_thread(send_whatsapp_message, MANAGEMENT_WHATSAPP_NUMBER, message_body)
+        order_details = {
+            "order_id": order_id,
+            "dish": state.data["dish"],
+            "quantity": state.data["quantity"],
+            "price": state.data["price"],
+            "address": state.data.get("address", "")
+        }
+        asyncio.create_task(notify_management_order(order_details))
+
+        # Update user profile with the new order ID
+        asyncio.create_task(update_user_profile_with_order(user_id, order_id))
+
+        # Generate payment link
+        email = "customer@example.com"  # Placeholder; retrieve from profile if available
+        payment_data = create_paystack_payment_link(email, total_price * 100, order_id)
+        dish_name = state.data.get("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 {quantity} serving(s) of {dish_name}! "
+                    f"Your Order ID is {order_id}.\nPlease complete payment here: {payment_link}\n"
+                    f"Estimated delivery time: {eta}\n"
+                    "You can track your order status using your Order ID.\n"
+                    "Is there anything else you'd like to order?")
+        else:
+            return f"Your order has been placed with Order ID {order_id}, but we could not initialize payment. Please try again later."
+    else:
+        state.reset()
+        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 ""
     
@@ -638,6 +711,7 @@ app = FastAPI()
 async def on_startup():
     await init_db()
 
+
 @app.post("/chatbot")
 async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
     data = await request.json()
@@ -674,31 +748,31 @@ async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
     background_tasks.add_task(log_sentiment, user_id, user_message, sentiment_score)
     sentiment_modifier = ""
     if sentiment_score < -0.3:
-        sentiment_modifier = "I'm sorry if you're having a tough time. "
+            sentiment_modifier = "I'm sorry if you're having a tough time. "
     elif sentiment_score > 0.3:
         sentiment_modifier = "Great to hear from you! "
 
-          # --- Order Tracking Handling ---
-    order_id_match = re.search(r"ord-\d+", user_message.lower())
+    # --- Order Tracking Handling ---
+    order_id_match = re.search(r"ORD-\d+", user_message.upper())
     if order_id_match:
         order_id = order_id_match.group(0)
         try:
-            # Call the /track_order endpoint
-            tracking_response = await track_order(order_id)
+            tracking_response = await track_order(user_id, order_id)
             return JSONResponse(content={"response": tracking_response})
         except HTTPException as e:
             return JSONResponse(content={"response": f"⚠️ {e.detail}"})
 
     # --- Order Flow Handling ---
-    order_response = process_order_flow(user_id, user_message)
-    if order_response:
-        background_tasks.add_task(log_chat_to_db, user_id, "outbound", order_response)
-        conversation_context[user_id].append({
-            "timestamp": datetime.utcnow().isoformat(),
-            "role": "bot",
-            "message": order_response
-        })
-        return JSONResponse(content={"response": sentiment_modifier + order_response})
+    if is_order_intent(user_message):
+        order_response = process_order_flow(user_id, user_message)
+        if order_response:
+            background_tasks.add_task(log_chat_to_db, user_id, "outbound", order_response)
+            conversation_context[user_id].append({
+                "timestamp": datetime.utcnow().isoformat(),
+                "role": "bot",
+                "message": order_response
+            })
+            return JSONResponse(content={"response": sentiment_modifier + order_response})
 
     # --- Menu Display ---
     if "menu" in user_message.lower():
@@ -828,7 +902,8 @@ async def get_user_profile(user_id: str):
         "name": profile.name,
         "email": profile.email,
         "preferences": profile.preferences,
-        "last_interaction": profile.last_interaction.isoformat()
+        "last_interaction": profile.last_interaction.isoformat(),
+        "order_ids": profile.order_ids
     }
 
 @app.get("/analytics")
@@ -897,7 +972,6 @@ async def process_voice(file: UploadFile = File(...)):
 
 # --- Payment Callback Endpoint with Payment Tracking and Redirection ---
 @app.api_route("/payment_callback", methods=["GET", "POST"])
-
 async def payment_callback(request: Request):
     # GET: User redirection after payment
     if request.method == "GET":
@@ -947,7 +1021,7 @@ async def payment_callback(request: Request):
                 return JSONResponse(content={"message": "Order updated successfully."})
             else:
                 raise HTTPException(status_code=404, detail="Order not found.")
-                
+
 @app.get("/track_order/{order_id}")
 async def track_order(order_id: str):
     """
@@ -974,4 +1048,4 @@ async def track_order(order_id: str):
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8000)