Update app.py

app.py

@@ -7,8 +7,6 @@ import asyncio
 from datetime import datetime, timedelta
 from bs4 import BeautifulSoup
 from sqlalchemy import select
-import ssl
-from sqlalchemy.ext.asyncio import create_async_engine
 
 from fastapi import FastAPI, Request, HTTPException, BackgroundTasks, UploadFile, File, Form
 from fastapi.responses import JSONResponse, StreamingResponse, RedirectResponse
@@ -23,10 +21,10 @@ from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
 from sqlalchemy.orm import sessionmaker, declarative_base
 from sqlalchemy import Column, Integer, String, DateTime, Text, Float
 
-# Environment Variables
+# --- Environment Variables and API Keys ---
 SPOONACULAR_API_KEY = os.getenv("SPOONACULAR_API_KEY", "default_fallback_value")
 PAYSTACK_SECRET_KEY = os.getenv("PAYSTACK_SECRET_KEY", "default_fallback_value")
-DATABASE_URL = os.getenv("DATABASE_URL", "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")
 
@@ -35,6 +33,7 @@ WHATSAPP_PHONE_NUMBER_ID = os.getenv("WHATSAPP_PHONE_NUMBER_ID", "default_value"
 WHATSAPP_ACCESS_TOKEN = os.getenv("WHATSAPP_ACCESS_TOKEN", "default_value")
 MANAGEMENT_WHATSAPP_NUMBER = os.getenv("MANAGEMENT_WHATSAPP_NUMBER", "default_value")
 
+# --- Database Setup ---
 Base = declarative_base()
 
 class ChatHistory(Base):
@@ -50,10 +49,12 @@ class Order(Base):
     id = Column(Integer, primary_key=True, index=True)
     order_id = Column(String, unique=True, index=True)
     user_id = Column(String, index=True)
-    pickup_location = Column(String)
-    dropoff_location = Column(String)
-    package_details = Column(String)
-    status = Column(String, default="Pending")
+    dish = Column(String)
+    quantity = Column(String)
+    price = Column(String, default="0")
+    status = Column(String, default="Pending Payment")
+    payment_reference = Column(String, nullable=True)
+    delivery_address = Column(String, default="")  # New field for address
     timestamp = Column(DateTime, default=datetime.utcnow)
 
 class UserProfile(Base):
@@ -65,6 +66,8 @@ class UserProfile(Base):
     email = Column(String, default="unknown@example.com")
     preferences = Column(Text, default="")
     last_interaction = Column(DateTime, default=datetime.utcnow)
+    loyalty_points = Column(Integer, default=0)  # New field for loyalty points
+    preferred_language = Column(String, default="English")  # New field for language preference
 
 class SentimentLog(Base):
     __tablename__ = "sentiment_logs"
@@ -74,7 +77,23 @@ class SentimentLog(Base):
     sentiment_score = Column(Float)
     message = Column(Text)
 
+class OrderTracking(Base):
+    __tablename__ = "order_tracking"
+    id = Column(Integer, primary_key=True, index=True)
+    order_id = Column(String, index=True)
+    status = Column(String)  # e.g., "Order Placed", "Payment Confirmed", etc.
+    message = Column(Text, nullable=True)  # Optional additional details
+    timestamp = Column(DateTime, default=datetime.utcnow)
+
+class Feedback(Base):
+    __tablename__ = "feedback"
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(String, index=True)
+    rating = Column(Integer)
+    comment = Column(Text, nullable=True)
+    timestamp = Column(DateTime, default=datetime.utcnow)
 
+# --- Create Engine and Session ---
 engine = create_async_engine(DATABASE_URL, echo=True)
 async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
 
@@ -83,30 +102,9 @@ async def init_db():
         await conn.run_sync(Base.metadata.create_all)
 
 # --- Global In-Memory Stores ---
-user_state = {}  # { user_id: ConversationState }
+user_state = {}       # e.g., { user_id: ConversationState }
 conversation_context = {}  # { user_id: [ { "timestamp": ..., "role": "user"/"bot", "message": ... }, ... ] }
-
-# --- Conversation State Management ---
-SESSION_TIMEOUT = timedelta(minutes=5)
-
-class ConversationState:
-    def __init__(self):
-        self.flow = None  # e.g., "track_order", "schedule_delivery"
-        self.step = 0
-        self.data = {}
-        self.last_active = datetime.utcnow()
-
-    def update_last_active(self):
-        self.last_active = datetime.utcnow()
-
-    def is_expired(self):
-        return datetime.utcnow() - self.last_active > SESSION_TIMEOUT
-
-    def reset(self):
-        self.flow = None
-        self.step = 0
-        self.data = {}
-        self.last_active = datetime.utcnow()
+proactive_timer = {}
 
 # --- Utility Functions ---
 async def log_chat_to_db(user_id: str, direction: str, message: str):
@@ -125,84 +123,137 @@ def analyze_sentiment(text: str) -> float:
     blob = TextBlob(text)
     return blob.sentiment.polarity
 
-# --- Delivery Service UX Functions ---
-def generate_main_menu() -> str:
-    """Generate the main menu with quick reply options."""
-    menu_text = "Hi there! 👋 Welcome to [Delivery Service Co.]. I’m here to help with your deliveries. What would you like to do today?\n\n"
-    menu_text += "1. Track an Order\n"
-    menu_text += "2. Schedule a Delivery\n"
-    menu_text += "3. FAQs & Support\n"
-    menu_text += "4. Talk to an Agent\n"
-    menu_text += "\nPlease reply with the number of your choice."
-    return menu_text
-
-def generate_faq_menu() -> str:
-    """Generate the FAQ menu with quick reply options."""
-    faq_text = "What do you need help with? Choose a category below:\n\n"
-    faq_text += "1. Pricing & Fees\n"
-    faq_text += "2. Delivery Times\n"
-    faq_text += "3. Order Cancellations\n"
-    faq_text += "4. Other Questions\n"
-    faq_text += "\nPlease reply with the number of your choice."
-    return faq_text
-
-def handle_faq_response(choice: str) -> str:
-    """Provide detailed answers based on FAQ category."""
-    if choice == "1":
-        return "Our pricing is based on distance, package size, and weight. For more details, visit [Link] or let me know if you have a specific question."
-    elif choice == "2":
-        return "Standard delivery times are between 9 AM and 6 PM. Express delivery is available for an additional fee."
-    elif choice == "3":
-        return "You can cancel your order up to 1 hour before the scheduled pickup time. Refunds are processed within 3-5 business days."
-    elif choice == "4":
-        return "Please type your question, and I’ll do my best to assist. If you’d like to speak with a live agent, just type 'agent'."
+# --- New Features Implementation ---
+async def send_main_menu(user_id: str):
+    menu_message = (
+        "Hi there! 👋 Welcome to [Delivery Service Co.]. I’m here to help with your deliveries. "
+        "What would you like to do today?"
+    )
+    quick_replies = [
+        {"title": "Track an Order", "payload": "track_order"},
+        {"title": "Schedule a Delivery", "payload": "schedule_delivery"},
+        {"title": "FAQs & Support", "payload": "faqs"},
+        {"title": "Loyalty Points", "payload": "loyalty_points"},
+        {"title": "Talk to an Agent", "payload": "live_agent"},
+    ]
+    await log_chat_to_db(user_id, "outbound", menu_message)
+    return {"response": menu_message, "quick_replies": quick_replies}
+
+async def track_order(user_id: str, order_id: str):
+    # Simulate fetching real-time tracking data
+    tracking_data = {
+        "status": "On the way",
+        "estimated_time": "30 minutes",
+        "driver_location": "https://maps.google.com/?q=6.5244,3.3792",  # Example location
+    }
+    tracking_message = (
+        f"🚚 Your order ({order_id}) is currently {tracking_data['status']} and is expected to arrive in {tracking_data['estimated_time']}. "
+        f"Tap below to track your package in real-time."
+    )
+    quick_replies = [
+        {"title": "Track on Map", "url": tracking_data["driver_location"]},
+        {"title": "Back to Menu", "payload": "main_menu"},
+    ]
+    await log_chat_to_db(user_id, "outbound", tracking_message)
+    return {"response": tracking_message, "quick_replies": quick_replies}
+
+async def recommend_package(user_id: str, package_description: str):
+    # Simulate AI analysis
+    package_size = "Medium"
+    price = 2500
+    recommendation_message = (
+        f"Based on your description, we recommend a {package_size} package for ₦{price}. "
+        "Does this sound right?"
+    )
+    quick_replies = [
+        {"title": "Yes, proceed", "payload": f"confirm_package:{package_size}:{price}"},
+        {"title": "No, adjust size", "payload": "adjust_package"},
+    ]
+    await log_chat_to_db(user_id, "outbound", recommendation_message)
+    return {"response": recommendation_message, "quick_replies": quick_replies}
+
+async def check_loyalty_points(user_id: str):
+    # Simulate fetching loyalty points
+    points = 200
+    discount = 500
+    loyalty_message = (
+        f"🎉 You’ve earned 50 points for this delivery! You now have {points} points. "
+        f"Redeem them for a ₦{discount} discount on your next order."
+    )
+    quick_replies = [
+        {"title": "Redeem Points", "payload": "redeem_points"},
+        {"title": "Back to Menu", "payload": "main_menu"},
+    ]
+    await log_chat_to_db(user_id, "outbound", loyalty_message)
+    return {"response": loyalty_message, "quick_replies": quick_replies}
+
+async def send_proactive_update(user_id: str, order_id: str, status: str):
+    if status == "picked_up":
+        message = f"🚚 Your order ({order_id}) has been picked up and is on the way!"
+    elif status == "nearby":
+        message = f"🚚 Your driver is 10 minutes away! Please ensure someone is available to receive the package."
+    await log_chat_to_db(user_id, "outbound", message)
+    return {"response": message}
+
+async def set_language(user_id: str, language: str):
+    supported_languages = ["English", "Français", "Español"]
+    if language in supported_languages:
+        user_state[user_id]["language"] = language
+        message = f"Language set to {language}. How can I assist you today?"
     else:
-        return "I didn’t quite catch that. Please choose a valid option from the list."
-
-async def track_order_flow(user_id: str, order_id: str) -> str:
-    """Handle the order tracking flow."""
-    async with async_session() as session:
-        result = await session.execute(
-            select(Order).where(Order.order_id == order_id)
-        )
-        order = result.scalars().first()
-        if order:
-            return f"Your order (ID: {order_id}) is currently {order.status} and is expected to arrive by {order.timestamp + timedelta(hours=2)}."
-        else:
-            return "Hmm, that order ID doesn’t seem right. Please check and try again or type 'help' for assistance."
-
-async def schedule_delivery_flow(user_id: str, step: int, user_input: str = None) -> str:
-    """Handle the delivery scheduling flow."""
-    state = user_state.get(user_id, ConversationState())
-    if step == 1:
-        state.flow = "schedule_delivery"
-        state.step = 1
-        state.data = {}
-        user_state[user_id] = state
-        return "Great! Let’s schedule your delivery. Please share your pickup and drop-off locations. You can type in the addresses or share your location."
-    elif step == 2:
-        if user_input:
-            state.data["locations"] = user_input
-            state.step = 2
-            return "Please provide details about your package (size, weight, and any special instructions)."
-        else:
-            return "I didn’t catch that. Please share your pickup and drop-off locations."
-    elif step == 3:
-        if user_input:
-            state.data["package_details"] = user_input
-            state.step = 3
-            return "Thank you! Your delivery is scheduled. We will confirm the pickup time shortly. Would you like to receive updates via WhatsApp? (Yes/No)"
-        else:
-            return "Please provide package details (size, weight, and any special instructions)."
-    elif step == 4:
-        if user_input.lower() in ["yes", "y"]:
-            state.data["updates"] = True
-            state.reset()
-            return "Awesome! You’ll receive updates on your delivery. Type 'menu' to return to the main menu."
-        else:
-            state.data["updates"] = False
-            state.reset()
-            return "Got it. You won’t receive updates. Type 'menu' to return to the main menu."
+        message = "Sorry, that language is not supported. Please choose from: English, Français, Español."
+    quick_replies = [{"title": lang, "payload": f"set_language:{lang}"} for lang in supported_languages]
+    await log_chat_to_db(user_id, "outbound", message)
+    return {"response": message, "quick_replies": quick_replies}
+
+async def request_feedback(user_id: str):
+    feedback_message = "How was your delivery experience? Tap to rate:"
+    quick_replies = [
+        {"title": "⭐️⭐️⭐️⭐️⭐️", "payload": "rate:5"},
+        {"title": "⭐️⭐️⭐️⭐️", "payload": "rate:4"},
+        {"title": "⭐️⭐️⭐️", "payload": "rate:3"},
+        {"title": "⭐️⭐️", "payload": "rate:2"},
+        {"title": "⭐️", "payload": "rate:1"},
+    ]
+    await log_chat_to_db(user_id, "outbound", feedback_message)
+    return {"response": feedback_message, "quick_replies": quick_replies}
+
+async def show_environmental_impact(user_id: str):
+    impact_message = "🌍 Your delivery saved 2kg of CO2 emissions! Thank you for choosing eco-friendly shipping."
+    await log_chat_to_db(user_id, "outbound", impact_message)
+    return {"response": impact_message}
+
+async def start_onboarding(user_id: str):
+    tutorial_message = (
+        "Let me guide you through how to schedule a delivery. Tap ‘Next’ to continue."
+    )
+    quick_replies = [
+        {"title": "Next", "payload": "tutorial_step_1"},
+        {"title": "Skip Tutorial", "payload": "main_menu"},
+    ]
+    await log_chat_to_db(user_id, "outbound", tutorial_message)
+    return {"response": tutorial_message, "quick_replies": quick_replies}
+
+async def suggest_faqs(user_id: str, user_input: str):
+    # Simulate AI-powered FAQ suggestions
+    suggested_faqs = [
+        "How long does delivery take?",
+        "Can I change my delivery time?",
+        "What are your pricing options?",
+    ]
+    faq_message = (
+        f"It looks like you’re asking about delivery times. Here are some related FAQs:"
+    )
+    quick_replies = [{"title": faq, "payload": f"faq:{faq}"} for faq in suggested_faqs]
+    await log_chat_to_db(user_id, "outbound", faq_message)
+    return {"response": faq_message, "quick_replies": quick_replies}
+
+async def schedule_offline(user_id: str):
+    offline_message = (
+        "You’re offline. Your delivery has been scheduled and will be confirmed once you’re back online."
+    )
+    await log_chat_to_db(user_id, "outbound", offline_message)
+    return {"response": offline_message}
 
 # --- FastAPI Setup & Endpoints ---
 app = FastAPI()
@@ -215,53 +266,160 @@ async def on_startup():
 async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
     data = await request.json()
     user_id = data.get("user_id")
+    phone_number = data.get("phone_number")
     user_message = data.get("message", "").strip()
+    is_image = data.get("is_image", False)
+    image_b64 = data.get("image_base64", None)
 
     if not user_id:
         raise HTTPException(status_code=400, detail="Missing user_id in payload.")
 
-    # Initialize conversation context if not present
+    # 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
+    # Append the inbound message to the conversation context.
     conversation_context[user_id].append({
         "timestamp": datetime.utcnow().isoformat(),
         "role": "user",
         "message": user_message
     })
 
-    # Log the chat to the database
     background_tasks.add_task(log_chat_to_db, user_id, "inbound", user_message)
-
-    # Handle main menu options
-    if user_message.lower() in ["menu", "hi", "hello"]:
-        response_text = generate_main_menu()
-    elif user_message == "1":  # Track an Order
-        response_text = "Please enter your Order ID, or type 'help' if you need assistance."
-    elif user_message == "2":  # Schedule a Delivery
-        response_text = await schedule_delivery_flow(user_id, step=1)
-    elif user_message == "3":  # FAQs & Support
-        response_text = generate_faq_menu()
-    elif user_message == "4":  # Talk to an Agent
-        response_text = "Please hold on while I connect you to one of our agents."
-    elif user_message.isdigit() and len(user_message) == 1 and user_message in ["1", "2", "3", "4"]:  # FAQ Submenu
-        response_text = handle_faq_response(user_message)
-    elif "track" in user_message.lower():  # Order Tracking
-        order_id = user_message.replace("track", "").strip()
-        response_text = await track_order_flow(user_id, order_id)
-    else:
-        response_text = "I didn’t quite catch that. Please choose a valid option or type 'menu' to see the main menu."
-
-    # Log the outbound response
-    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": response_text})
+    await update_user_last_interaction(user_id)
+    await get_or_create_user_profile(user_id, phone_number)
+
+    # Handle image queries
+    if is_image and image_b64:
+        if len(image_b64) >= 180_000:
+            raise HTTPException(status_code=400, detail="Image too large.")
+        return StreamingResponse(stream_image_completion(image_b64), media_type="text/plain")
+
+    sentiment_score = analyze_sentiment(user_message)
+    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. "
+    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())
+    if order_id_match:
+        order_id = order_id_match.group(0)
+        try:
+            # Call the /track_order endpoint
+            tracking_response = await track_order(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})
+
+    # --- Menu Display ---
+    if "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)
+
+    # --- Dish Selection via Menu ---
+    if any(item["name"].lower() in user_message.lower() for item in menu_items) or \
+       any(str(index) == user_message.strip() for index, item in enumerate(menu_items, start=1)):
+        selected_dish = None
+        if user_message.strip().isdigit():
+            dish_number = int(user_message.strip())
+            if 1 <= dish_number <= len(menu_items):
+                selected_dish = menu_items[dish_number - 1]["name"]
+        else:
+            for item in menu_items:
+                if item["name"].lower() in user_message.lower():
+                    selected_dish = item["name"]
+                    break
+        if selected_dish:
+            state = ConversationState()
+            state.flow = "order"
+            # Set step to 2 since the dish is already selected
+            state.step = 2  
+            state.data["dish"] = selected_dish
+            state.update_last_active()
+            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 ---
+    if "nutritional facts for" in user_message.lower():
+        dish_name = user_message.lower().replace("nutritional facts for", "").strip().title()
+        dish = next((item for item in menu_items if item["name"].lower() == dish_name.lower()), None)
+        if dish:
+            response_text = f"Nutritional facts for {dish['name']}:\n{dish['nutrition']}"
+        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 with Conversation Context ---
+    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
+    fallback_log = f"LLM fallback response for prompt: {prompt}"
+    background_tasks.add_task(log_chat_to_db, user_id, "outbound", fallback_log)
+    return StreamingResponse(stream_response(), media_type="text/plain")
 
 # --- Other Endpoints (Chat History, Order Details, User Profile, Analytics, Voice, Payment Callback) ---
 @app.get("/chat_history/{user_id}")
@@ -338,12 +496,14 @@ async def payment_callback(request: Request):
                 await session.commit()
             else:
                 raise HTTPException(status_code=404, detail="Order not found.")
+        # Record payment confirmation tracking update
+        await log_order_tracking(order_id, "Payment Confirmed", f"Payment status updated to {status}.")
         # Notify management via WhatsApp about the payment update
         await asyncio.to_thread(send_whatsapp_message, MANAGEMENT_WHATSAPP_NUMBER,
             f"Payment Update:\nOrder ID: {order_id} is now {status}."
         )
         # Redirect user back to the chat interface (adjust URL as needed)
-        redirect_url = f"https://yourdomain.com/chat?order_id={order_id}&status=success"
+        redirect_url = f"https://wa.link/am87s2"
         return RedirectResponse(url=redirect_url)
     # POST: Server-to-server callback from Paystack
     else:
@@ -360,12 +520,37 @@ async def payment_callback(request: Request):
             if order:
                 order.status = new_status
                 await session.commit()
+                await log_order_tracking(order_id, "Payment Confirmed", f"Payment status updated to {new_status}.")
                 await asyncio.to_thread(send_whatsapp_message, MANAGEMENT_WHATSAPP_NUMBER,
                     f"Payment Update:\nOrder ID: {order_id} is now {new_status}."
                 )
                 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):
+    """
+    Fetch order tracking details for a given order ID.
+    """
+    async with async_session() as session:
+        result = await session.execute(
+            select(OrderTracking)
+            .where(OrderTracking.order_id == order_id)
+            .order_by(OrderTracking.timestamp)
+        )
+        tracking_updates = result.scalars().all()
+        if tracking_updates:
+            response = []
+            for update in tracking_updates:
+                response.append({
+                    "status": update.status,
+                    "message": update.message,
+                    "timestamp": update.timestamp.isoformat(),
+                })
+            return JSONResponse(content=response)
+        else:
+            raise HTTPException(status_code=404, detail="No tracking information found for this order.")
 
 if __name__ == "__main__":
     import uvicorn