Update app.py

app.py

@@ -460,6 +460,331 @@ async def process_order_flow(user_id: str, message: str) -> str:
                     return f"You selected {found_dish}. How many servings would you like?"
         else:
             return "I couldn't identify the dish. Please type the dish name from our menu."
+                if state.step == 2:
+                numbers = re.findall(r'\d+', message)
+                if not numbers:
+                    return "Please enter a valid number for the quantity (e.g., 1, 2, 3)."
+                quantity = int(numbers[0])
+                if quantity <= 0:
+                    return "Please enter a valid quantity (e.g., 1, 2, 3)."
+                state.data["quantity"] = quantity
+                state.step = 3
+                return f"Got it. {quantity} serving(s) of {state.data.get('dish')}. Please provide your phone number and delivery address."
+        
+            if state.step == 3:
+                phone_pattern = r'(\+?\d{10,15})'
+                phone_match = re.search(phone_pattern, message)
+                address = None
+                if phone_match:
+                    phone_number = phone_match.group(1)
+                    address_start = phone_match.end()
+                    address = message[address_start:].strip()
+                    address = re.sub(r'^[,\s]+|[,\s]+$', '', address)
+                if phone_match and address:
+                    state.data["phone_number"] = phone_number
+                    state.data["address"] = address
+                    asyncio.create_task(update_user_profile(user_id, phone_number, address))
+                    shipping_cost = calculate_shipping_cost(address)
+                    state.data["shipping_cost"] = shipping_cost
+                    state.step = 5
+                    return (f"Thanks! Your phone number is recorded as: {phone_number}.\n"
+                            f"Your delivery address is: {address}.\n"
+                            f"Your delivery cost is N{shipping_cost}. Would you like extras (yes/no)?")
+                elif phone_match:
+                    state.data["phone_number"] = phone_match.group(1)
+                    asyncio.create_task(update_user_profile(user_id, phone_number))
+                    return "Thank you. Please provide your delivery address."
+                else:
+                    return ("Please provide both your phone number and delivery address. "
+                            "For example: '09162409591, 1, Iyana Isashi, Isashi, Ojo, Lagos'.")
+        
+            # Steps 4, 5, 6, and 7 remain unchanged.
+            if state.step == 4:
+                state.data["address"] = message
+                asyncio.create_task(update_user_profile(user_id, address=message))
+                shipping_cost = calculate_shipping_cost(message)
+                state.data["shipping_cost"] = shipping_cost
+                state.step = 5
+                return (f"Thanks. Your delivery address is recorded as: {message}.\n"
+                        f"Your delivery cost is N{shipping_cost}. Would you like extras (yes/no)?")
+        
+            if state.step == 5:
+                if message.lower() in ["yes", "y"]:
+                    state.step = 6
+                    return "Please list the extras you'd like (e.g., drinks, sides)."
+                elif message.lower() in ["no", "n"]:
+                    state.data["extras"] = ""
+                    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)
+                    price_per_serving = 1500
+                    total_price = (quantity * price_per_serving) + shipping_cost
+                    summary = (f"Order Summary:\nDish: {dish}\nQuantity: {quantity}\n"
+                               f"Phone: {phone}\nAddress: {address}\n"
+                               f"Shipping Cost: N{shipping_cost}\n"
+                               f"Total Price: N{total_price}\n"
+                               f"Extras: None\nConfirm order? (yes/no)")
+                    return summary
+                else:
+                    return "Please respond with 'yes' or 'no' regarding extras."
+        
+            if state.step == 6:
+                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", "")
+                price_per_serving = 1500
+                total_price = (quantity * price_per_serving) + shipping_cost
+                summary = (f"Order Summary:\nDish: {dish}\nQuantity: {quantity}\n"
+                           f"Phone: {phone}\nAddress: {address}\n"
+                           f"Shipping Cost: N{shipping_cost}\n"
+                           f"Total Price: N{total_price}\n"
+                           f"Extras: {extras}\nConfirm order? (yes/no)")
+                return summary
+        
+            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
+                    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)
+        
+                    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", "")
+                            )
+                            session.add(order)
+                            await session.commit()
+                    asyncio.create_task(save_order())
+                    asyncio.create_task(log_order_tracking(order_id, "Order Placed", "Order placed and awaiting payment."))
+        
+                    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"
+                    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."
+        return ""
+    
+        
+    async def get_or_create_user_profile(user_id: str, phone_number: str = None) -> UserProfile:
+        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,
+                    last_interaction=datetime.utcnow()
+                )
+                session.add(profile)
+                await session.commit()
+            return profile
+    
+    async def update_user_last_interaction(user_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:
+                profile.last_interaction = datetime.utcnow()
+                await session.commit()
+    
+    async def send_proactive_greeting(user_id: str):
+        greeting = "Hi again! We miss you. Would you like to see our new menu items or get personalized recommendations?"
+        await log_chat_to_db(user_id, "outbound", greeting)
+        return greeting
+    
+    app = FastAPI()
+    
+    @app.on_event("startup")
+    async def on_startup():
+        await init_db()
+    
+    @app.post("/chatbot")
+    async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
+        data = await request.json()
+        user_id = data.get("user_id")
+        user_message = data.get("message", "").strip()
+    
+        if user_id not in conversation_context:
+            conversation_context[user_id] = []
+    
+        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)
+    
+        sentiment_score = analyze_sentiment(user_message)
+        background_tasks.add_task(log_sentiment, user_id, user_message, sentiment_score)
+        sentiment_modifier = "Great to hear from you! " if sentiment_score > 0.3 else ""
+    
+        if user_message.strip() == "1" or "menu" in user_message.lower():
+            if user_id in user_state:
+                del user_state[user_id]
+            menu_with_images = []
+            for index, item in enumerate(menu_items, start=1):
+                image_url = google_image_scrape(item["name"])
+                menu_with_images.append({
+                    "number": index,
+                    "name": item["name"],
+                    "description": item["description"],
+                    "price": item["price"],
+                    "image_url": image_url
+                })
+            response_payload = {
+                "response": sentiment_modifier + "Here’s our delicious menu:",
+                "menu": menu_with_images,
+                "follow_up": (
+                    "To order, type the *number* or *name* of the dish you'd like. "
+                    "For example, type '1' or 'Jollof Rice' to order Jollof Rice.\n\n"
+                    "You can also ask for nutritional facts by typing, for example, 'Nutritional facts for Jollof Rice'."
+                )
+            }
+            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)
+    
+        if is_order_intent(user_message) or (user_id in user_state and user_state[user_id].flow == "order"):
+            order_response = await 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})
+    
+        # Instead of calling the LLM fallback, use a default response:
+        default_response = "I'm sorry, I didn't understand that. Please type 'menu' to see our options or 'order' to place an order."
+        background_tasks.add_task(log_chat_to_db, user_id, "outbound", default_response)
+        conversation_context[user_id].append({
+            "timestamp": datetime.utcnow().isoformat(),
+            "role": "bot",
+            "message": default_response
+        })
+        return JSONResponse(content={"response": sentiment_modifier + default_response})
+    
+    
+    @app.get("/chat_history/{user_id}")
+    async def get_chat_history(user_id: str):
+        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]
+    
+    @app.get("/order/{order_id}")
+    async def get_order(order_id: str):
+        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.")
+    
+    @app.get("/user_profile/{user_id}")
+    async def get_user_profile(user_id: str):
+        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(),
+            "order_ids": profile.order_ids
+        }
+    
+    @app.get("/analytics")
+    async def get_analytics():
+        async with async_session() as session:
+            msg_result = await session.execute(ChatHistory.__table__.count())
+            total_messages = msg_result.scalar() or 0
+            order_result = await session.execute(Order.__table__.count())
+            total_orders = order_result.scalar() or 0
+            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
+        }
+    
+    HUGGING_FACE_API_TOKEN = os.getenv("HUGGING_FACE_API_TOKEN")
+    if not HUGGING_FACE_API_TOKEN:
+        raise ValueError("Hugging Face API token not found in environment variables.")
+    
+    WHISPER_API_URL = "https://router.huggingface.co/fal-ai"
+    WHISPER_API_HEADERS = {"Authorization": f"Bearer {HUGGING_FACE_API_TOKEN}"}
 
 class TranscriptionResponse(BaseModel):
     transcription: str