Update app.py

app.py

@@ -79,8 +79,8 @@ async def init_db():
 # --- Global In-Memory Stores ---
 # Instead of a plain dict for conversation context, we use a dedicated class below.
 user_state = {}       # e.g., { user_id: ConversationState }
-conversation_context = {}  
-proactive_timer = {}   
+conversation_context = {}  # { user_id: [ { "timestamp": ..., "role": "user"/"bot", "message": ... }, ... ] }
+proactive_timer = {}
 
 menu_items = [
     {"name": "Jollof Rice", "description": "A spicy and flavorful rice dish", "price": 1500, "nutrition": "Calories: 300 kcal, Carbs: 50g, Protein: 10g, Fat: 5g"},
@@ -213,7 +213,7 @@ def process_order_flow(user_id: str, message: str) -> str:
     """
     Implements an FSM-based order flow that:
       - In step 1, expects the user to mention a dish name (optionally with quantity)
-      - In step 2, asks for quantity if it was not provided
+      - In step 2, asks for quantity if not provided
       - In step 3, finalizes the order and creates a payment link
     """
     # Retrieve or initialize conversation state
@@ -232,7 +232,6 @@ def process_order_flow(user_id: str, message: str) -> str:
         user_state[user_id] = state
         if message.lower() == "order":
             return "Sure! What dish would you like to order?"
-        # For "menu", let the menu handler run by returning empty.
         return ""
 
     # If no state exists but the message includes "order", start the order flow.
@@ -248,7 +247,6 @@ def process_order_flow(user_id: str, message: str) -> str:
         state.update_last_active()
         # --- Step 1: Expecting Dish Selection (and optionally quantity) ---
         if state.step == 1:
-            # Look for a dish name in the message
             dish_candidates = [item["name"] for item in menu_items]
             found_dish = None
             for dish in dish_candidates:
@@ -259,7 +257,6 @@ def process_order_flow(user_id: str, message: str) -> str:
             numbers = re.findall(r'\d+', message)
             if found_dish:
                 state.data["dish"] = found_dish
-                # If a quantity is provided, move to finalizing the order directly.
                 if numbers:
                     quantity = int(numbers[0])
                     if quantity <= 0:
@@ -286,8 +283,7 @@ def process_order_flow(user_id: str, message: str) -> str:
         if state.step == 3:
             order_id = f"ORD-{int(time.time())}"
             state.data["order_id"] = order_id
-            # Use a fixed price per serving for demonstration purposes.
-            price_per_serving = 1500
+            price_per_serving = 1500  # fixed price per serving for demonstration
             quantity = state.data.get("quantity", 1)
             total_price = quantity * price_per_serving
             state.data["price"] = str(total_price)
@@ -307,13 +303,9 @@ def process_order_flow(user_id: str, message: str) -> str:
                     await session.commit()
             asyncio.create_task(save_order())
 
-            # Retrieve email from user profile if available (placeholder used here)
-            email = "customer@example.com"
+            email = "customer@example.com"  # Placeholder; retrieve from profile if available
             payment_data = create_paystack_payment_link(email, total_price * 100, order_id)
-
-            # Before returning, capture the dish name for the response
             dish_name = state.data.get("dish", "")
-            # Clear the conversation state after finalizing the order.
             state.reset()
             if user_id in user_state:
                 del user_state[user_id]
@@ -379,6 +371,16 @@ async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
     if not user_id:
         raise HTTPException(status_code=400, detail="Missing user_id in payload.")
 
+    # Initialize conversation context for the user if not present.
+    if user_id not in conversation_context:
+        conversation_context[user_id] = []
+    # Append the inbound message to the conversation context.
+    conversation_context[user_id].append({
+        "timestamp": datetime.utcnow().isoformat(),
+        "role": "user",
+        "message": user_message
+    })
+
     background_tasks.add_task(log_chat_to_db, user_id, "inbound", user_message)
     await update_user_last_interaction(user_id)
     await get_or_create_user_profile(user_id, phone_number)
@@ -401,11 +403,15 @@ async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
     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():
-        # Clear any active order flow if user explicitly asks for the menu.
         if user_id in user_state:
             del user_state[user_id]
         menu_with_images = []
@@ -428,6 +434,11 @@ async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
             )
         }
         background_tasks.add_task(log_chat_to_db, user_id, "outbound", str(response_payload))
+        conversation_context[user_id].append({
+            "timestamp": datetime.utcnow().isoformat(),
+            "role": "bot",
+            "message": response_payload["response"]
+        })
         return JSONResponse(content=response_payload)
 
     # --- Dish Selection via Menu ---
@@ -444,7 +455,6 @@ async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
                     selected_dish = item["name"]
                     break
         if selected_dish:
-            # Start a new order flow with the selected dish.
             state = ConversationState()
             state.flow = "order"
             state.step = 1
@@ -453,10 +463,20 @@ async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
             user_state[user_id] = state
             response_text = f"You selected {selected_dish}. How many servings would you like?"
             background_tasks.add_task(log_chat_to_db, user_id, "outbound", response_text)
+            conversation_context[user_id].append({
+                "timestamp": datetime.utcnow().isoformat(),
+                "role": "bot",
+                "message": response_text
+            })
             return JSONResponse(content={"response": sentiment_modifier + response_text})
         else:
             response_text = "Sorry, I couldn't find that dish in the menu. Please try again."
             background_tasks.add_task(log_chat_to_db, user_id, "outbound", response_text)
+            conversation_context[user_id].append({
+                "timestamp": datetime.utcnow().isoformat(),
+                "role": "bot",
+                "message": response_text
+            })
             return JSONResponse(content={"response": sentiment_modifier + response_text})
 
     # --- Nutritional Facts ---
@@ -468,19 +488,133 @@ async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
         else:
             response_text = f"Sorry, I couldn't find nutritional facts for {dish_name}."
         background_tasks.add_task(log_chat_to_db, user_id, "outbound", response_text)
+        conversation_context[user_id].append({
+            "timestamp": datetime.utcnow().isoformat(),
+            "role": "bot",
+            "message": response_text
+        })
         return JSONResponse(content={"response": sentiment_modifier + response_text})
 
-    # --- Fallback: LLM Response Streaming ---
-    prompt = f"User query: {user_message}\nGenerate a helpful, personalized response for a restaurant chatbot."
+    # --- Fallback: LLM Response Streaming with Conversation Context ---
+    # Build recent conversation history (e.g., last 5 messages)
+    recent_context = conversation_context.get(user_id, [])[-5:]
+    context_str = "\n".join([f"{entry['role'].capitalize()}: {entry['message']}" for entry in recent_context])
+    prompt = f"Conversation context:\n{context_str}\nUser query: {user_message}\nGenerate a helpful, personalized response for a restaurant chatbot."
     def stream_response():
         for chunk in stream_text_completion(prompt):
             yield chunk
-    background_tasks.add_task(log_chat_to_db, user_id, "outbound", f"LLM fallback response for prompt: {prompt}")
+    fallback_log = f"LLM fallback response for prompt: {prompt}"
+    background_tasks.add_task(log_chat_to_db, user_id, "outbound", fallback_log)
+    # (Optionally, you might want to capture and add the streamed response to conversation_context)
     return StreamingResponse(stream_response(), media_type="text/plain")
 
-# --- Other Endpoints (Chat History, Order Details, User Profile, Analytics, Voice, Payment Callback) ---
-# ... (Implement other endpoints as needed) ...
+    # --- Chat History Endpoint ---
+@app.get("/chat_history/{user_id}")
+async def get_chat_history(user_id: str):
+    """
+    Retrieve chat history for a user.
+    """
+    async with async_session() as session:
+        result = await session.execute(
+            ChatHistory.__table__.select().where(ChatHistory.user_id == user_id)
+        )
+        history = result.fetchall()
+        return [dict(row) for row in history]
+
+# --- Order Details Endpoint ---
+@app.get("/order/{order_id}")
+async def get_order(order_id: str):
+    """
+    Retrieve details for a specific order.
+    """
+    async with async_session() as session:
+        result = await session.execute(
+            Order.__table__.select().where(Order.order_id == order_id)
+        )
+        order = result.fetchone()
+        if order:
+            return dict(order)
+        else:
+            raise HTTPException(status_code=404, detail="Order not found.")
+
+# --- User Profile Endpoint ---
+@app.get("/user_profile/{user_id}")
+async def get_user_profile(user_id: str):
+    """
+    Retrieve the user profile.
+    """
+    profile = await get_or_create_user_profile(user_id)
+    return {
+        "user_id": profile.user_id,
+        "phone_number": profile.phone_number,
+        "name": profile.name,
+        "email": profile.email,
+        "preferences": profile.preferences,
+        "last_interaction": profile.last_interaction.isoformat()
+    }
+
+# --- Analytics Endpoint ---
+@app.get("/analytics")
+async def get_analytics():
+    """
+    Simple analytics dashboard endpoint.
+    Returns counts of messages, orders, and average sentiment.
+    """
+    async with async_session() as session:
+        # Total messages count
+        msg_result = await session.execute(ChatHistory.__table__.count())
+        total_messages = msg_result.scalar() or 0
+
+        # Total orders count
+        order_result = await session.execute(Order.__table__.count())
+        total_orders = order_result.scalar() or 0
+
+        # Average sentiment score
+        sentiment_result = await session.execute("SELECT AVG(sentiment_score) FROM sentiment_logs")
+        avg_sentiment = sentiment_result.scalar() or 0
+
+    return {
+        "total_messages": total_messages,
+        "total_orders": total_orders,
+        "average_sentiment": avg_sentiment
+    }
+
+# --- Voice Integration Endpoint ---
+@app.post("/voice")
+async def process_voice(file: UploadFile = File(...)):
+    """
+    Accept a voice file upload, perform speech-to-text (simulated), and process the resulting text.
+    In production, integrate with a real STT service.
+    """
+    contents = await file.read()
+    # Simulated Speech-to-Text: In real implementation, send `contents` to an STT service.
+    simulated_text = "Simulated speech-to-text conversion result."
+    return {"transcription": simulated_text}
+
+# --- Payment Callback Endpoint (Stub) ---
+@app.post("/payment_callback")
+async def payment_callback(request: Request):
+    """
+    Endpoint to handle payment callbacks from Paystack.
+    Update order status based on callback data.
+    """
+    data = await request.json()
+    # Extract order reference and update order status accordingly.
+    # In production, verify callback signature and extract data.
+    order_id = data.get("reference")
+    new_status = data.get("status", "Paid")
+    async with async_session() as session:
+        result = await session.execute(
+            Order.__table__.select().where(Order.order_id == order_id)
+        )
+        order = result.scalar_one_or_none()
+        if order:
+            order.status = new_status
+            await session.commit()
+            return JSONResponse(content={"message": "Order updated successfully."})
+        else:
+            raise HTTPException(status_code=404, detail="Order not found.")
 
 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)