import re import os import time import requests import base64 import asyncio from datetime import datetime, timedelta from typing import Dict, List, Optional from fastapi import FastAPI, Request, HTTPException, BackgroundTasks, UploadFile, File, Form from fastapi.responses import JSONResponse, StreamingResponse, RedirectResponse from fastapi.encoders import jsonable_encoder from sqlalchemy import select, update, func 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, Boolean from sqlalchemy import JSON import logging import hmac import hashlib import json import uuid from sqlalchemy.exc import SQLAlchemyError from pydantic import BaseModel import os import random PAYSTACK_SECRET_KEY = os.getenv("PAYSTACK_SECRET_KEY", "your_default_secret_key") # Configure logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger("delivery_service") # -------------------- # DATABASE SETUP # -------------------- DATABASE_URL = os.getenv("DATABASE_URL", "sqlite+aiosqlite:///./test.db") engine = create_async_engine(DATABASE_URL, echo=True) async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False) Base = declarative_base() # -------------------- # DATABASE MODELS # -------------------- class UserProfile(Base): __tablename__ = "user_profiles" id = Column(Integer, primary_key=True, index=True) user_id = Column(String(36), unique=True, index=True) phone_number = Column(String(20)) name = Column(String(100)) email = Column(String(100)) preferences = Column(JSON, default={"favorite_cuisines": [], "delivery_times": []}) last_interaction = Column(DateTime) ux_mode = Column(String(20), default="default") accessibility_prefs = Column(JSON, default={}) current_order_status = Column(String(50)) # Add other missing columns as needed class UXPreferences(Base): __tablename__ = "ux_preferences" user_id = Column(String(36), primary_key=True) interaction_speed = Column(String(20), default="normal") color_scheme = Column(String(20), default="light") input_preference = Column(String(20), default="buttons") class ChatHistory(Base): __tablename__ = "chat_history" id = Column(Integer, primary_key=True, index=True) user_id = Column(String(36), index=True) message = Column(Text) timestamp = Column(DateTime, default=datetime.utcnow) class Order(Base): __tablename__ = "orders" id = Column(Integer, primary_key=True, index=True) order_id = Column(String, unique=True, index=True) user_id = Column(String, index=True) dish = Column(String, nullable=True) quantity = Column(String, nullable=True) price = Column(String, default="0") status = Column(String, default="Pending Payment") payment_reference = Column(String, nullable=True) delivery_address = Column(String, default="") timestamp = Column(DateTime, default=datetime.utcnow) pickup_address = Column(String, nullable=True) # <-- Add this last_location = Column(String, nullable=True) # <-- Add this contact_number = Column(String, nullable=True) # <-- Add this class OrderTracking(Base): __tablename__ = "order_tracking" id = Column(Integer, primary_key=True, index=True) order_id = Column(String(36), index=True) status = Column(String(50)) message = Column(Text) timestamp = Column(DateTime, default=datetime.utcnow) location = Column(Text, nullable=True) # Stored as a JSON string class DeliveryOrderRequest(BaseModel): user_id: str package_description: str pickup_address: str delivery_address: str contact_number: str class TrackingUpdate(BaseModel): status: str message: str timestamp: str # using ISO formatted datetime strings location: Optional[Dict] = None estimated_delivery: Optional[str] = None # -------------------- # INITIALIZATION # -------------------- async def init_db(): async with engine.begin() as conn: await conn.run_sync(Base.metadata.create_all) logger.info("Database tables created.") # -------------------- # STATE MANAGEMENT # -------------------- class ConversationState: def __init__(self): self.flow: Optional[str] = None self.step: int = 0 self.data: Dict = {} self.context: List[Dict] = [] self.last_active: datetime = datetime.utcnow() def update_last_active(self): self.last_active = datetime.utcnow() def add_context(self, role: str, message: str): self.context.append({ "timestamp": datetime.utcnow(), "role": role, "message": message }) # Keep only the last 5 messages if len(self.context) > 5: self.context = self.context[-5:] # Global state dictionary user_state: Dict[str, ConversationState] = {} # -------------------- # CORE UTILITIES # -------------------- async def update_user_last_interaction(user_id: str): async with async_session() as session: await session.execute( update(UserProfile) .where(UserProfile.user_id == user_id) .values(last_interaction=datetime.utcnow()) ) await session.commit() async def get_or_create_user_profile(user_id: str, phone: str = None) -> UserProfile: async with async_session() as session: result = await session.execute( select(UserProfile).where(UserProfile.user_id == user_id) ) profile = result.scalar_one_or_none() if not profile: profile = UserProfile( user_id=user_id, phone_number=phone, last_interaction=datetime.utcnow() ) session.add(profile) await session.commit() await session.refresh(profile) return profile # -------------------- # ENHANCED UX FEATURES # -------------------- class DeliveryUXManager: @staticmethod async def generate_response_template(user_id: str) -> Dict: """Generate a personalized response structure.""" profile = await get_or_create_user_profile(user_id) return { "meta": { "ux_mode": profile.ux_mode, "color_scheme": "light", "interaction_mode": "text" }, "content": { "text": "", "quick_replies": [], "carousel": None, "status_overlay": None } } @staticmethod async def handle_ux_preferences(user_id: str, preference: str): """Update UX preferences.""" async with async_session() as session: prefs = await session.get(UXPreferences, user_id) if not prefs: prefs = UXPreferences(user_id=user_id) session.add(prefs) # Update specific preference based on input if preference.startswith("color_"): prefs.color_scheme = preference.split("_")[1] elif preference.startswith("speed_"): prefs.interaction_speed = preference.split("_")[1] await session.commit() # -------------------- # HELPER FUNCTIONS FOR PAYMENT CALLBACK & TRACKING # -------------------- async def log_order_tracking(order_id: str, status: str, message: str): async with async_session() as session: tracking_entry = OrderTracking( order_id=order_id, status=status, message=message ) session.add(tracking_entry) await session.commit() async def send_whatsapp_message(number: str, message: str): # Dummy implementation for sending WhatsApp messages logger.info(f"Sending WhatsApp message to {number}: {message}") async def update_user_order_status(user_id: str, order_id: str, status: str): async with async_session() as session: await session.execute( update(UserProfile) .where(UserProfile.user_id == user_id) .values(current_order_status=status) ) await session.commit() async def get_order_details(order_id: str) -> Optional[Order]: async with async_session() as session: result = await session.execute( select(Order).where(Order.order_id == order_id) ) return result.scalar_one_or_none() def send_email_notification(order_details): # Build the email payload based on the delivery request details. payload = { "from": "yungdml31@gmail.com", "to": "samyung05@gmail.com, angelofoodcourt@gmail.com", "subject": f"New Delivery Request Received: {order_details['order_id']}", "body": ( f"New Delivery Request Received:\n" f"Order ID: {order_details['order_id']}\n" f"Package Description: {order_details.get('package_description', 'Not Provided')}\n" f"Pickup Address: {order_details.get('pickup_address', 'Not Provided')}\n" f"Delivery Address: {order_details.get('delivery_address', 'Not Provided')}\n" f"Contact Number: {order_details.get('contact_number', 'Not Provided')}\n" f"Status: Pending Payment" ), "smtpHost": "smtp.gmail.com", "smtpPort": 587, "smtpSecure": "false", "smtpUser": "yungdml31@gmail.com", "smtpPassword": "uddvxabxotlvfewk", } url = "https://smtp-server-ten.vercel.app/smtp" # Adjust to your SMTP API endpoint. try: response = requests.post(url, json=payload, timeout=10) response.raise_for_status() return response.json() except Exception as e: print(f"Error sending email: {e}") return None def calculate_eta(last_location: dict) -> str: # Implement actual ETA calculation logic here. return "30 minutes" TOWN_SHIPPING_COSTS = { "lasu gate": 1000, "ojo": 800, "ajangbadi": 1200, "iba": 900, "okokomaiko": 1500, "default": 1000 # Default if location is not listed } # -------------------- # MAIN APPLICATION # -------------------- app = FastAPI(title="Delivery Service Chatbot") @app.on_event("startup") async def on_startup(): await init_db() logger = logging.getLogger(__name__) @app.post("/delivery") async def create_delivery_order(order_req: DeliveryOrderRequest, bg: BackgroundTasks): try: logger.info(f"Received order request: {order_req}") # Generate a unique order ID like "DEL-123456789" order_id = f"DEL-{random.randint(100000000, 999999999)}" logger.info(f"Generated order ID: {order_id}") # Extract delivery location and calculate shipping cost. delivery_address = order_req.delivery_address.lower() shipping_cost = TOWN_SHIPPING_COSTS.get("default", 1000) for town, cost in TOWN_SHIPPING_COSTS.items(): if town in delivery_address: shipping_cost = cost break logger.info(f"Calculated shipping cost: ₦{shipping_cost}") # Set item price (adjustable as needed) and calculate total. item_price = 5000 total_amount = item_price + shipping_cost total_amount_kobo = total_amount * 100 # Convert to kobo logger.info(f"Total order amount: ₦{total_amount}") # Get user email or default email = getattr(order_req, "email", "customer@example.com") # Generate Paystack payment link payment_data = create_paystack_payment_link(email, total_amount_kobo, order_id) logger.info(f"Generated payment data: {payment_data}") # Notify admin via email in the background email_details = { "order_id": order_id, "package_description": order_req.package_description, "pickup_address": order_req.pickup_address, "delivery_address": order_req.delivery_address, "contact_number": order_req.contact_number, } bg.add_task(send_email_notification, email_details) if payment_data.get("status"): payment_link = payment_data["data"]["authorization_url"] return { "order_id": order_id, "total_amount": f"₦{total_amount}", "shipping_cost": f"₦{shipping_cost}", "payment_link": payment_link, "message": "Delivery request created successfully. Please complete payment using the link provided." } else: logger.error(f"Failed to generate payment link for order {order_id}") return { "order_id": order_id, "total_amount": f"₦{total_amount}", "shipping_cost": f"₦{shipping_cost}", "message": "Delivery request created, but payment initialization failed. Please try again later." } except Exception as e: logger.error(f"Error creating delivery order: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Error: {str(e)}") @app.post("/chatbot") async def enhanced_chatbot_handler(request: Request, bg: BackgroundTasks): data = await request.json() user_id = data["user_id"] message = data.get("message", "").strip().lower() # Initialize conversation state if it doesn't exist if user_id not in user_state: user_state[user_id] = ConversationState() state = user_state[user_id] state.update_last_active() # Generate a response template response = await DeliveryUXManager.generate_response_template(user_id) # Handle specific commands if message == "delivery": # For example, generate a dummy delivery ID using the current timestamp delivery_id = f"DEL-{int(time.time())}" response["content"]["text"] = f"Your delivery request has been received. Your delivery id is {delivery_id}." elif message == "rates": response["content"]["text"] = "Delivery rates:\n• Standard: ₦500\n• Express: ₦1000" elif message == "track delivery": response["content"]["text"] = "Please provide your delivery ID (e.g., 'track delivery DEL-123456789')." else: response["content"]["text"] = f"Received your message: {message}" state.add_context("user", message) bg.add_task(update_user_last_interaction, user_id) return JSONResponse(response) def create_paystack_payment_link(email: str, amount: int, reference: str) -> dict: url = "https://api.paystack.co/transaction/initialize" headers = { "Authorization": f"Bearer {PAYSTACK_SECRET_KEY}", "Content-Type": "application/json", } data = { "email": email, "amount": amount, # Amount must be in kobo (₦100 = 10000 kobo) "reference": reference, "callback_url": "https://your-website.com/payment_callback" } response = requests.post(url, json=data, headers=headers, timeout=10) return response.json() if response.status_code == 200 else {"status": False, "message": "Payment initialization failed"} @app.post("/ux/preferences") async def update_ux_preferences(request: Request): data = await request.json() await DeliveryUXManager.handle_ux_preferences( data["user_id"], data["preference"] ) return {"status": "preferences updated"} @app.get("/chat_history/{user_id}") async def get_chat_history(user_id: str): async with async_session() as session: result = await session.execute( select(ChatHistory).where(ChatHistory.user_id == user_id) ) history = result.scalars().all() return [jsonable_encoder({ "user_id": entry.user_id, "message": entry.message, "timestamp": entry.timestamp.isoformat() }) for entry in history] @app.get("/order/{order_id}") async def get_order(order_id: str): async with async_session() as session: result = await session.execute( select(Order).where(Order.order_id == order_id) ) order = result.scalar_one_or_none() if order: return jsonable_encoder({ "order_id": order.order_id, "user_id": order.user_id, "status": order.status, "payment_reference": order.payment_reference, "last_location": order.last_location }) 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(), "ux_mode": profile.ux_mode, "current_order_status": profile.current_order_status } @app.get("/analytics") async def get_analytics(): async with async_session() as session: msg_result = await session.execute( select(func.count()).select_from(ChatHistory) ) total_messages = msg_result.scalar() or 0 order_result = await session.execute( select(func.count()).select_from(Order) ) total_orders = order_result.scalar() or 0 # This query assumes a sentiment_logs table exists with a sentiment_score column. 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 } @app.post("/voice") async def process_voice(file: UploadFile = File(...)): contents = await file.read() simulated_text = "Simulated speech-to-text conversion result." return {"transcription": simulated_text} @app.api_route("/payment_callback", methods=["GET", "POST"]) async def payment_callback(request: Request): PAYSTACK_SECRET_KEY = os.getenv("PAYSTACK_SECRET_KEY", "dummy_secret") MANAGEMENT_WHATSAPP_NUMBER = os.getenv("MANAGEMENT_WHATSAPP_NUMBER", "+1234567890") try: if request.method == "POST": # Verify Paystack signature signature = request.headers.get("x-paystack-signature") if not signature: raise HTTPException(status_code=403, detail="Missing signature") body = await request.body() computed_sha = hmac.new( PAYSTACK_SECRET_KEY.encode(), body, digestmod=hashlib.sha512 ).hexdigest() if not hmac.compare_digest(computed_sha, signature): raise HTTPException(status_code=403, detail="Invalid signature") data = await request.json() event = data.get("event") order_id = data.get("data", {}).get("reference") status = "Paid" if event == "charge.success" else "Failed" elif request.method == "GET": data = request.query_params order_id = data.get("reference") status = data.get("status", "Paid") if not order_id: raise HTTPException(status_code=400, detail="Missing order reference") async with async_session() as session: result = await session.execute( select(Order) .where(Order.order_id == order_id) .with_for_update() ) order = result.scalar_one_or_none() if not order: raise HTTPException(status_code=404, detail="Order not found") valid_statuses = ["Paid", "Failed", "Pending"] if status not in valid_statuses: raise HTTPException(status_code=400, detail="Invalid status") order.status = status order.payment_reference = order_id # Add tracking update tracking_entry = OrderTracking( order_id=order_id, status="Payment Updated", message=f"Payment status changed to {status}" ) session.add(tracking_entry) await session.commit() # Send notifications concurrently await asyncio.gather( log_order_tracking(order_id, "Payment Updated", f"Payment status changed to {status}"), send_whatsapp_message( MANAGEMENT_WHATSAPP_NUMBER, f"Payment Update: Order {order_id} - {status}" ), update_user_order_status(order.user_id, order_id, status) ) if request.method == "GET": redirect_url = os.getenv("PAYMENT_REDIRECT_URL", "https://default-redirect.com") return RedirectResponse( url=redirect_url, status_code=303 ) return JSONResponse(content={"status": "success", "order_id": order_id}) except HTTPException as he: raise he except Exception as e: logger.error(f"Payment callback error: {str(e)}") raise HTTPException(status_code=500, detail="Internal server error") from fastapi_cache.decorator import cache @app.get("/track_order/{deliveryId}", response_model=List[TrackingUpdate]) async def get_order_tracking(deliveryId: str, page: int = 1, limit: int = 10): order_id = deliveryId.upper() # Normalize the order ID to uppercase try: async with async_session() as session: order_result = await session.execute( select(Order).where(Order.order_id == order_id) ) if not order_result.scalar_one_or_none(): raise HTTPException(status_code=404, detail="Order not found") tracking_result = await session.execute( select(OrderTracking) .where(OrderTracking.order_id == order_id) .order_by(OrderTracking.timestamp.desc()) .offset((page-1)*limit) .limit(limit) ) tracking_updates = tracking_result.scalars().all() if not tracking_updates: return JSONResponse(content=[]) response = [ { "status": update.status, "message": update.message, "timestamp": update.timestamp.isoformat(), "location": json.loads(update.location) if update.location else None } for update in tracking_updates ] # Add estimated delivery time if order is shipped order = await get_order_details(order_id) if order and order.status.lower() == "shipped": loc = json.loads(order.last_location) if order.last_location else {} response[0]["estimated_delivery"] = calculate_eta(loc) return JSONResponse(content=response) except HTTPException as he: raise he except Exception as e: logger.error(f"Tracking error: {str(e)}") raise HTTPException(status_code=500, detail="Internal server error") # -------------------- # PROACTIVE FEATURES # -------------------- async def send_proactive_update(user_id: str, update_type: str): """Send unsolicited updates to users.""" state = user_state.get(user_id) if not state: return # User not active response = await DeliveryUXManager.generate_response_template(user_id) if update_type == "delivery_eta": response["content"]["text"] = "📦 Your package is arriving in 15 minutes!" response["content"]["quick_replies"] = [ {"title": "Track Live", "action": "track_live"}, {"title": "Delay Delivery", "action": "delay_delivery"} ] return response # -------------------- # ERROR HANDLING # -------------------- @app.exception_handler(HTTPException) async def ux_error_handler(request: Request, exc: HTTPException): return JSONResponse({ "meta": {"error": True}, "content": { "text": f"⚠️ Error: {exc.detail}", "quick_replies": [{"title": "Main Menu", "action": "reset"}] } }, status_code=exc.status_code) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)