Update app.py

app.py

@@ -6,7 +6,7 @@ import base64
 import asyncio
 from datetime import datetime, timedelta
 from bs4 import BeautifulSoup
-from sqlalchemy import select, text  # make sure to import text for SQL commands
+from sqlalchemy import select
 from pydantic import BaseModel
 
 from fastapi import FastAPI, Request, HTTPException, BackgroundTasks, UploadFile, File, Form
@@ -25,10 +25,9 @@ from sqlalchemy import Column, Integer, String, DateTime, Text, Float
 # --- 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", "postgresql+asyncpg://user:password@localhost/dbname")  # Update as needed
+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")
 
 # WhatsApp Business API credentials (Cloud API)
 WHATSAPP_PHONE_NUMBER_ID = os.getenv("WHATSAPP_PHONE_NUMBER_ID", "default_value")
@@ -78,7 +77,6 @@ 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="")  # New column
 
 class SentimentLog(Base):
     __tablename__ = "sentiment_logs"
@@ -88,6 +86,7 @@ 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)
@@ -100,31 +99,11 @@ class OrderTracking(Base):
 engine = create_async_engine(DATABASE_URL, echo=True)
 async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
 
-# --- Migration Functions ---
-async def add_order_ids_column():
-    async with engine.connect() as conn:
-        # Ensure the column exists (PostgreSQL 9.6+ supports IF NOT EXISTS)
-        await conn.execute(
-            text("ALTER TABLE user_profiles ADD COLUMN IF NOT EXISTS order_ids TEXT DEFAULT ''")
-        )
-        await conn.commit()
-    print("Column 'order_ids' ensured on user_profiles.")
-
 async def init_db():
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
-    print("Database initialized.")
-
-# --- FastAPI Application Setup ---
-app = FastAPI()
-
-# Run migrations at startup
-@app.on_event("startup")
-async def startup_event():
-    await add_order_ids_column()
-    await init_db()
 
-# --- Global In-Memory Stores and Other Code ---
+# --- Global In-Memory Stores ---
 user_state = {}       # e.g., { user_id: ConversationState }
 conversation_context = {}  # { user_id: [ { "timestamp": ..., "role": "user"/"bot", "message": ... }, ... ] }
 proactive_timer = {}
@@ -136,6 +115,7 @@ menu_items = [
     {"name": "Egusi Soup", "description": "A rich and hearty soup made with melon seeds", "price": 1000, "nutrition": "Calories: 250 kcal, Carbs: 15g, Protein: 8g, Fat: 10g"}
 ]
 
+# --- Conversation State Management ---
 SESSION_TIMEOUT = timedelta(minutes=5)
 
 class ConversationState:
@@ -296,104 +276,41 @@ def calculate_shipping_cost(address: str) -> int:
             return cost
     return TOWN_SHIPPING_COSTS["default"]  # Default shipping cost for unknown areas
 
-# --- 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)."
-
-    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)})."
+# ... (rest of your imports and setup)
 
-# --- Contextual Order Intent Detection ---
-def is_order_intent(message: str) -> bool:
-    """
-    Check if the user's message indicates an intent to place an order.
+async def update_user_profile(user_id: str, phone_number: str = None, address: str = None) -> UserProfile:
     """
-    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:
+    Update or create a user profile with the provided phone number and address.
     """
-    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:
-            if profile.order_ids:
-                profile.order_ids += f",{order_id}"
-            else:
-                profile.order_ids = order_id
-            await session.commit()
+        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
 
 # ... (rest of your imports and setup)
 
-async def process_order_flow(user_id: str, message: str) -> str:
+def process_order_flow(user_id: str, message: str) -> str:
     """
     Implements an FSM-based order flow with shipping cost calculation.
     """
+            
     # Retrieve or initialize conversation state
     state = user_state.get(user_id)
     if state and state.is_expired():
@@ -460,7 +377,7 @@ async def process_order_flow(user_id: str, message: str) -> str:
                 state.data["phone_number"] = phone_number
                 state.data["address"] = address
                 # Save phone number and address to the user's profile
-                await update_user_profile(user_id, phone_number, address)
+                asyncio.create_task(update_user_profile(user_id, phone_number, address))
                 # Calculate shipping cost based on the address
                 shipping_cost = calculate_shipping_cost(address)
                 state.data["shipping_cost"] = shipping_cost
@@ -471,7 +388,7 @@ async def process_order_flow(user_id: str, message: str) -> str:
             elif phone_match:
                 state.data["phone_number"] = phone_match.group(1)
                 # Save phone number to the user's profile
-                await update_user_profile(user_id, phone_number)
+                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'."
@@ -534,7 +451,7 @@ async def process_order_flow(user_id: str, message: str) -> str:
                 state.data["phone_number"] = phone_number
                 state.data["address"] = address
                 # Save phone number and address to the user's profile
-                await update_user_profile(user_id, phone_number, address)
+                asyncio.create_task(update_user_profile(user_id, phone_number, address))
                 # Calculate shipping cost based on the address
                 shipping_cost = calculate_shipping_cost(address)
                 state.data["shipping_cost"] = shipping_cost
@@ -545,7 +462,7 @@ async def process_order_flow(user_id: str, message: str) -> str:
             elif phone_match:
                 state.data["phone_number"] = phone_match.group(1)
                 # Save phone number to the user's profile
-                await update_user_profile(user_id, phone_number)
+                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'."
@@ -554,7 +471,7 @@ async def process_order_flow(user_id: str, message: str) -> str:
         if state.step == 4:
             state.data["address"] = message
             # Save address to the user's profile
-            await update_user_profile(user_id, address=message)
+            asyncio.create_task(update_user_profile(user_id, address=message))
             # Calculate shipping cost based on the address
             shipping_cost = calculate_shipping_cost(message)
             state.data["shipping_cost"] = shipping_cost
@@ -634,7 +551,7 @@ async def process_order_flow(user_id: str, message: str) -> str:
                 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.")
+                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):
@@ -659,10 +576,6 @@ async def process_order_flow(user_id: str, message: str) -> str:
                 }
                 asyncio.create_task(notify_management_order(order_details))
 
-                # Update user profile with the new order ID
-                await 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", "")
@@ -725,7 +638,6 @@ 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()
@@ -762,31 +674,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.upper())
+          # --- 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:
-            tracking_response = await track_order(user_id, order_id)
+            # 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 ---
-    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})
+    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():
@@ -916,8 +828,7 @@ async def get_user_profile(user_id: str):
         "name": profile.name,
         "email": profile.email,
         "preferences": profile.preferences,
-        "last_interaction": profile.last_interaction.isoformat(),
-        "order_ids": profile.order_ids
+        "last_interaction": profile.last_interaction.isoformat()
     }
 
 @app.get("/analytics")
@@ -986,6 +897,7 @@ 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":
@@ -1035,7 +947,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):
     """