feat(core): implement unified database with multi-hotel support and session management

- Introduce unified SQLite database (Tabble.db) for all hotels
- Define comprehensive SQLAlchemy models for hotels, dishes, orders, persons, and related entities
- Implement DatabaseManager class to manage session-based connections and hotel context
- Support hotel authentication with password verification
- Ensure thread-safe database connection handling with locks and scoped sessions
- Add unique constraints for per-hotel user and loyalty configurations
- Automate table creation and session cleanup in database manager
- Prepare app structure for seamless multi-tenant data isolation within unified DB

.dockerignore

@@ -0,0 +1,73 @@
+# .dockerignore for Tabble-v3
+
+# Git
+.git
+.gitignore
+README.md
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+*.tmp
+*.temp
+
+# Documentation (already in image)
+docs/
+*.md
+
+# Development only files
+test-*.html
+start.py
+
+# Database backups
+*.db.backup
+backups/

.env.example

@@ -0,0 +1,33 @@
+# Environment Variables for Tabble-v3
+
+# Server Configuration
+PORT=7860
+HOST=0.0.0.0
+
+# Security
+SECRET_KEY=your_secret_key_here_change_in_production
+
+# Application Settings
+DEBUG=False
+APP_NAME=Tabble-v3
+APP_VERSION=3.1.0
+
+# Database Configuration
+# Note: SQLite databases are auto-created based on hotels.csv
+
+# Firebase Configuration (Optional - for production phone authentication)
+# FIREBASE_PRIVATE_KEY_ID=your_firebase_private_key_id
+# FIREBASE_PRIVATE_KEY=your_firebase_private_key
+# FIREBASE_CLIENT_EMAIL=your_firebase_client_email
+# FIREBASE_CLIENT_ID=your_firebase_client_id
+# FIREBASE_AUTH_URI=https://accounts.google.com/o/oauth2/auth
+# FIREBASE_TOKEN_URI=https://oauth2.googleapis.com/token
+
+# Hugging Face Spaces
+HUGGINGFACE_SPACES=1
+
+# CORS Settings (for production, specify allowed origins)
+ALLOWED_ORIGINS=["*"]
+
+# Logging
+LOG_LEVEL=INFO

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,68 @@
+# Ignore binary image files
+*.jpg
+*.jpeg
+*.png
+*.gif
+*.bmp
+*.webp
+*.ico
+
+# Ignore specific image directories
+app/static/images/dishes/*.jpg
+app/static/images/dishes/*.jpeg
+app/static/images/dishes/*.png
+app/static/images/dishes/*.webp
+app/static/images/logo/*.jpg
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Database files
+*.db
+*.sqlite
+*.sqlite3
+
+# Logs
+*.log
+logs/
+
+# Firebase
+*firebase*.json

DEMO_MODE_INSTRUCTIONS.md

@@ -0,0 +1,139 @@
+# Demo Mode Instructions
+
+This document provides instructions for using the demo mode feature that bypasses customer authentication for demonstration purposes.
+
+## Overview
+
+Demo mode allows seamless access to the customer interface without requiring phone authentication. When enabled, accessing `/customer` will automatically redirect to the menu page with pre-configured demo credentials.
+
+## Features
+
+- **Automatic Redirect**: Visiting `/customer` automatically redirects to the menu with demo credentials
+- **Demo Customer**: Uses hardcoded customer ID (999999) with username "Demo Customer"
+- **Demo Indicator**: Shows "🎭 DEMO MODE ACTIVE" badge in the menu header
+- **Preserved Functionality**: All menu features work normally (ordering, cart, etc.)
+- **Easy Toggle**: Simple configuration flag to enable/disable
+
+## How to Enable Demo Mode
+
+### 1. Frontend Configuration
+Edit `frontend/src/config/demoConfig.js`:
+
+```javascript
+export const DEMO_CONFIG = {
+  ENABLED: true,  // Set to true to enable demo mode
+  // ... rest of config
+};
+```
+
+### 2. Backend Configuration
+Edit `app/routers/customer.py`:
+
+```python
+DEMO_MODE_ENABLED = True  # Set to True to enable demo mode
+```
+
+## How to Disable Demo Mode
+
+### 1. Frontend Configuration
+Edit `frontend/src/config/demoConfig.js`:
+
+```javascript
+export const DEMO_CONFIG = {
+  ENABLED: false,  // Set to false to disable demo mode
+  // ... rest of config
+};
+```
+
+### 2. Backend Configuration
+Edit `app/routers/customer.py`:
+
+```python
+DEMO_MODE_ENABLED = False  # Set to False to disable demo mode
+```
+
+## Demo Credentials
+
+When demo mode is active, the following credentials are used:
+
+- **Customer ID**: 999999
+- **Username**: Demo Customer
+- **Phone**: +91-DEMO-USER
+- **Table Number**: 1
+- **Unique ID**: DEMO-SESSION-ID
+- **Visit Count**: 5 (shows as returning customer)
+
+## Usage Instructions
+
+### For Demos
+
+1. **Enable demo mode** using the configuration above
+2. **Start the application** (both frontend and backend)
+3. **Navigate to** `http://localhost:3000/customer`
+4. **Automatic redirect** to menu page with demo credentials
+5. **Demo indicator** will be visible in the header
+6. **Use normally** - all features work as expected
+
+### After Demo
+
+1. **Disable demo mode** using the configuration above
+2. **Restart the application** to apply changes
+3. **Normal authentication** will be required again
+
+## Technical Details
+
+### Files Modified
+
+- `frontend/src/config/demoConfig.js` - Demo configuration
+- `frontend/src/pages/customer/Login.js` - Auto-redirect logic
+- `frontend/src/pages/customer/components/HeroBanner.js` - Demo indicator
+- `frontend/src/services/api.js` - Demo login API
+- `app/routers/customer.py` - Demo login endpoint
+
+### API Endpoint
+
+- **POST** `/customer/api/demo-login`
+- Creates or returns demo customer with ID 999999
+- Only works when `DEMO_MODE_ENABLED = True`
+
+### Security Notes
+
+- Demo mode should **NEVER** be enabled in production
+- Demo customer ID (999999) is designed to avoid conflicts
+- All demo data is clearly marked and identifiable
+- Easy to clean up demo data if needed
+
+## Troubleshooting
+
+### Demo Mode Not Working
+
+1. Check both frontend and backend configuration flags
+2. Restart both frontend and backend servers
+3. Clear browser cache and localStorage
+4. Check browser console for errors
+
+### Demo Customer Not Created
+
+1. Ensure backend demo mode is enabled
+2. Check database connectivity
+3. Verify hotel/database selection is working
+4. Check backend logs for errors
+
+### Normal Authentication Still Required
+
+1. Verify frontend demo mode is enabled
+2. Check that `isDemoModeEnabled()` returns true
+3. Restart frontend development server
+4. Clear browser cache
+
+## Reverting Changes
+
+To completely remove demo mode functionality:
+
+1. Delete `frontend/src/config/demoConfig.js`
+2. Remove demo imports from Login.js and HeroBanner.js
+3. Remove demo login endpoint from customer.py
+4. Remove demo login method from api.js
+5. Restart both servers
+
+This ensures a clean codebase without any demo-related code.

DEPLOYMENT_SUMMARY.md

@@ -0,0 +1,139 @@
+# 🎯 Tabble-v3 Hugging Face Deployment Summary
+
+## ✅ Deployment Package Complete
+
+Your Tabble-v3 restaurant management system is now **ready for Hugging Face Spaces deployment**!
+
+### 📦 Created Files
+
+| File | Purpose | Status |
+|------|---------|--------|
+| `Dockerfile` | Docker configuration for HF Spaces | ✅ Ready |
+| `app.py` | Main entry point for the application | ✅ Ready |
+| `requirements.txt` | Updated Python dependencies | ✅ Ready |
+| `templates/` | Complete web interface templates | ✅ Ready |
+| `.dockerignore` | Docker build optimization | ✅ Ready |
+| `.env.example` | Environment variables template | ✅ Ready |
+| `README_HUGGINGFACE.md` | HF Space metadata | ✅ Ready |
+| `HUGGINGFACE_DEPLOYMENT_GUIDE.md` | Deployment instructions | ✅ Ready |
+
+### 🌟 Key Features Ready
+
+- **🍽️ Customer Interface**: QR code ordering with phone OTP
+- **👨‍🍳 Chef Dashboard**: Real-time order management
+- **🏨 Admin Panel**: Complete restaurant management
+- **📊 Analytics**: Built-in performance tracking
+- **🗄️ Multi-Database**: Support for multiple hotels
+- **📱 Responsive Design**: Works on all devices
+
+## 🚀 Quick Deploy Steps
+
+### 1. Repository Setup
+```bash
+# Your repository is ready with all required files
+# Just push to GitHub if you haven't already
+git add .
+git commit -m "Ready for Hugging Face Spaces deployment"
+git push origin main
+```
+
+### 2. Create Hugging Face Space
+1. Go to: https://huggingface.co/new-space
+2. Choose: **Docker SDK**
+3. Connect your GitHub repository
+4. Deploy automatically!
+
+### 3. Access Your App
+Once deployed, your app will be available at:
+```
+https://[your-username]-tabble-v3-[space-name].hf.space
+```
+
+## 🎮 Demo Credentials
+
+### For Testing
+- **Hotel Access Code**: `myhotel`
+- **Demo Database**: `tabble_new.db`
+- **Table Numbers**: 1-20
+- **Phone OTP**: Any 6 digits (demo mode)
+
+### Admin Panel
+- Go to `/admin`
+- Enter hotel code: `myhotel`
+- Manage dishes, orders, settings
+
+## 🔧 Production Customization
+
+### Add Your Restaurant
+1. Edit `hotels.csv`:
+```csv
+hotel_database,password
+your_restaurant.db,your_secure_password
+```
+
+2. Access admin panel and configure:
+   - Hotel information
+   - Menu items with images
+   - Pricing and categories
+   - Loyalty programs
+
+## 📊 What You Get
+
+### Customer Experience
+- **QR Code Ordering**: Scan table QR codes
+- **Phone Authentication**: Secure OTP login
+- **Real-time Cart**: Live order updates
+- **Payment Integration**: Ready for payment gateways
+
+### Staff Tools
+- **Chef Dashboard**: Live order notifications
+- **Admin Panel**: Complete management control
+- **Analytics**: Customer and sales insights
+- **Multi-Hotel**: Independent databases
+
+### Technical Features
+- **FastAPI Backend**: High-performance API
+- **SQLite Databases**: One per hotel
+- **Responsive Templates**: Mobile-friendly
+- **Real-time Updates**: Live order tracking
+
+## 🌍 Ready for Global Use
+
+Your system supports:
+- **Multiple Languages**: Easily customizable templates
+- **Different Currencies**: Update symbols in templates
+- **Local Regulations**: Configurable tax and pricing
+- **Custom Branding**: Upload logos and customize colors
+
+## 📈 Scaling Options
+
+### Hugging Face Spaces Tiers
+- **Free Tier**: Perfect for testing and small restaurants
+- **Pro Tier**: Enhanced performance and resources
+- **Enterprise**: Dedicated resources and support
+
+### External Integrations
+- **Payment Gateways**: Stripe, PayPal, local providers
+- **SMS Services**: Twilio, AWS SNS for real OTP
+- **Cloud Storage**: AWS S3 for dish images
+- **Analytics**: Google Analytics, custom tracking
+
+## 🆘 Support Resources
+
+- **API Documentation**: Available at `/docs` in your deployed app
+- **GitHub Repository**: Issues and discussions
+- **Deployment Guide**: `HUGGINGFACE_DEPLOYMENT_GUIDE.md`
+- **Technical Docs**: Complete README with all features
+
+## 🎉 Next Steps
+
+1. **Deploy**: Create your Hugging Face Space
+2. **Test**: Verify all interfaces work
+3. **Customize**: Add your restaurant details
+4. **Launch**: Start serving customers!
+
+---
+
+**Your modern restaurant management system is ready to revolutionize your business operations!** 
+
+Deploy now and start serving customers with cutting-edge technology! 🚀🍽️

Dockerfile

@@ -0,0 +1,44 @@
+# Use Python 3.11 slim image as base
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PORT=7860
+
+# Set work directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy the application code
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p app/static/images/dishes && \
+    mkdir -p templates && \
+    chmod 755 app/static/images
+
+# Initialize the database with sample data
+RUN python init_db.py
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Start the application
+CMD ["python", "app.py"]

HUGGINGFACE_DEPLOYMENT_GUIDE.md

@@ -0,0 +1,93 @@
+# 🤗 Hugging Face Spaces Deployment Guide for Tabble-v3
+
+## 🚀 Quick Deployment
+
+### Step 1: Prepare Repository
+```bash
+git clone https://github.com/your-username/tabble-v3.git
+cd tabble-v3
+
+# Verify required files exist:
+# ✓ Dockerfile, app.py, requirements.txt
+# ✓ templates/, app/, hotels.csv
+```
+
+### Step 2: Create Hugging Face Space
+1. Go to [https://huggingface.co/new-space](https://huggingface.co/new-space)
+2. Configure:
+   - **Space name**: `tabble-v3-restaurant`
+   - **SDK**: Docker
+   - **License**: MIT
+3. Connect your GitHub repository
+4. Add metadata to README.md:
+
+```yaml
+---
+title: Tabble-v3 Restaurant Management
+emoji: 🍽️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+license: mit
+tags: [restaurant, management, fastapi, qr-code]
+---
+```
+
+### Step 3: Monitor Build
+- Watch build logs in "Logs" tab
+- Wait for "Running on http://0.0.0.0:7860" message
+- Verify health check at `/health` endpoint
+
+## 📱 Using Your App
+
+### Access URLs
+- **Home**: `your-space-url/`
+- **Customer**: `your-space-url/customer`
+- **Chef**: `your-space-url/chef`  
+- **Admin**: `your-space-url/admin`
+- **API Docs**: `your-space-url/docs`
+
+### Demo Credentials
+- **Hotel Access Code**: `myhotel`
+- **Tables**: 1-20
+- **Phone OTP**: Any 6 digits
+
+## 🔧 Customization
+
+### Add Your Hotel
+Edit `hotels.csv`:
+```csv
+hotel_database,password
+your_restaurant.db,secure_password_123
+```
+
+### Menu Setup
+1. Access admin panel with hotel code
+2. Go to "Manage Dishes"
+3. Add menu items with images and pricing
+
+## 🚑 Troubleshooting
+
+### Common Issues
+1. **Build fails**: Check Dockerfile and requirements.txt
+2. **App won't start**: Verify port 7860 and database init
+3. **Templates missing**: Ensure templates/ directory exists
+
+### Debug Steps
+1. Check Space logs for errors
+2. Test `/health` endpoint
+3. Verify admin panel loads with demo credentials
+
+## 📊 Production Ready
+
+### Security
+- Update hotel passwords in `hotels.csv`
+- Set `SECRET_KEY` environment variable
+
+### Features
+- Upload menu images to `app/static/images/`
+- Customize branding in templates
+- Configure real SMS/payment services
+
+**Your restaurant management system is now live!** 🎉

README.md

@@ -1,10 +1,717 @@
+# Tabble-v3
+
+A modern restaurant management system built with Python FastAPI and React.
+A comprehensive restaurant management system built with FastAPI (backend) and React (frontend), featuring QR code-based table ordering, phone OTP authentication, real-time order management, and multi-database support for independent hotel operations.
+
+## 🚀 Quick Deploy on Hugging Face Spaces
+
+[![Deploy on Hugging Face Spaces](https://huggingface.co/datasets/huggingface/badges/raw/main/deploy-on-spaces-md.svg)](https://huggingface.co/new-space?template=your-username/tabble-v3)
+
+Tabble-v3 is now optimized for **Hugging Face Spaces** deployment! Deploy your restaurant management system with just a few clicks.
+
+### 🌐 Live Demo
+- **Demo URL**: [Your Space URL after deployment]
+- **Admin Panel**: `/admin` (use access code: `myhotel`)
+- **Chef Dashboard**: `/chef`
+- **Customer Interface**: `/customer`
+- **API Documentation**: `/docs`
+
+### 📦 One-Click Deployment
+
+1. **Fork this repository** to your GitHub account
+2. **Go to [Hugging Face Spaces](https://huggingface.co/new-space)**
+3. **Select "Docker" as the SDK**
+4. **Connect your GitHub repository**
+5. **Wait for automatic build and deployment**
+6. **Access your live restaurant management system!**
+
+That's it! Your restaurant management system will be live and accessible to the world.
+
+### 🔧 Environment Configuration
+
+The application comes pre-configured for Hugging Face Spaces with:
+- **Port**: 7860 (Hugging Face Spaces default)
+- **Demo Database**: Pre-loaded with sample data
+- **Sample Hotel**: "Demo Hotel" with access code `myhotel`
+- **Templates**: Complete web interface included
+
+### 🏨 Multi-Hotel Setup
+
+To add your own hotel:
+
+1. **Edit `hotels.csv`**:
+   ```csv
+   hotel_database,password
+   tabble_new.db,myhotel
+   your_hotel.db,your_password
+   ```
+
+2. **Create database** (optional - auto-created on first access):
+   ```bash
+   python create_empty_db.py
+   ```
+
+3. **Restart your Space** to apply changes
+
+### 📱 Usage Guide
+
+#### For Customers:
+1. Scan QR code at your table or visit `/customer`
+2. Select your hotel and enter access code
+3. Enter table number and phone number
+4. Verify OTP and start ordering!
+
+#### For Restaurant Staff:
+- **Chefs**: Visit `/chef` for order management
+- **Admins**: Visit `/admin` for complete restaurant control
+- **API**: Visit `/docs` for API documentation
+
+## 🌟 Key Features
+
+### 🍽️ Customer Interface
+- **Phone OTP Authentication**: Secure Firebase-based authentication
+- **Real-time Cart Management**: Live cart updates with special offers
+- **Today's Specials**: Dynamic special dish recommendations
+- **Payment Processing**: Integrated payment with loyalty discounts
+- **Order History**: Track past orders and preferences
+
+### 👨‍🍳 Chef Dashboard
+- **Real-time Order Management**: Live order notifications and updates
+- **Kitchen Operations**: Streamlined order acceptance and completion
+- **Order Status Updates**: Instant status changes reflected across all interfaces
+
+### 🏨 Admin Panel
+- **Complete Restaurant Management**: Full control over restaurant operations
+- **Dish Management**: Add, edit, and manage menu items with images
+- **Offers & Specials**: Create and manage promotional offers
+- **Table Management**: Monitor table occupancy and status
+- **Order Tracking**: Complete order lifecycle management
+- **Loyalty Program**: Configurable visit-based discount system
+- **Selection Offers**: Amount-based discount configuration
+- **Settings**: Hotel information and configuration management
+
+### 📊 Analytics Dashboard
+- **Customer Analysis**: Detailed customer behavior insights
+- **Dish Performance**: Menu item popularity and sales metrics
+- **Chef Performance**: Kitchen efficiency tracking
+- **Sales & Revenue**: Comprehensive financial reporting
+
+### 🗄️ Multi-Database Support
+- **Independent Hotel Operations**: Each hotel operates with its own database
+- **Database Authentication**: Secure database access with password protection
+- **Session-based Management**: Consistent database context across all interfaces
+- **Data Isolation**: Complete separation of hotel data for security and privacy
+
+## 📁 Project Structure
+
+```
+tabble/
+├── app/                           # Backend FastAPI application
+│   ├── database.py               # Database configuration and models
+│   ├── main.py                   # FastAPI application entry point
+│   ├── middleware/               # Custom middleware (CORS, session handling)
+│   ├── models/                   # SQLAlchemy database models
+│   ├── routers/                  # API route definitions
+│   │   ├── admin.py             # Admin panel endpoints
+│   │   ├── chef.py              # Chef dashboard endpoints
+│   │   ├── customer.py          # Customer interface endpoints
+│   │   └── analytics.py         # Analytics and reporting endpoints
+│   ├── services/                 # Business logic and external services
+│   │   ├── firebase_service.py  # Firebase authentication
+│   │   └── database_service.py  # Database operations
+│   ├── static/                   # Static file serving
+│   │   └── images/              # Dish and hotel logo images
+│   │       └── dishes/          # Organized by database name
+│   └── utils/                    # Utility functions and helpers
+├── frontend/                      # React frontend application
+│   ├── src/
+│   │   ├── components/          # Reusable React components
+│   │   │   ├── Layout.js        # Main layout wrapper
+│   │   │   ├── AdminLayout.js   # Admin panel layout
+│   │   │   └── ChefLayout.js    # Chef dashboard layout
+│   │   ├── pages/               # Page components
+│   │   │   ├── admin/           # Admin interface pages
+│   │   │   ├── chef/            # Chef dashboard pages
+│   │   │   ├── customer/        # Customer interface pages
+│   │   │   └── analysis/        # Analytics dashboard
+│   │   ├── services/            # API communication services
+│   │   │   └── api.js           # Axios configuration and API calls
+│   │   ├── App.js               # Main React application
+│   │   ├── index.js             # React DOM entry point
+│   │   └── global.css           # Global styling
+│   ├── public/                   # Static assets
+│   │   ├── index.html           # HTML template
+│   │   └── favicon.ico          # Application icon
+│   ├── package.json             # Node.js dependencies
+│   ├── .env.example             # Environment variables template
+│   └── .env                     # Environment configuration
+├── templates/                     # Report generation templates
+│   └── analysis/                # Analytics report templates
+├── hotels.csv                    # Database registry and passwords
+├── init_db.py                    # Database initialization with sample data
+├── create_empty_db.py            # Empty database creation utility
+├── requirements.txt              # Python dependencies
+├── run.py                        # Backend server launcher
+└── README.md                     # Project documentation
+```
+
+## 🚀 Quick Start Guide
+
+### Prerequisites
+
+#### For Windows:
+- **Python 3.8+**: Download from [python.org](https://www.python.org/downloads/)
+- **Node.js 16+**: Download from [nodejs.org](https://nodejs.org/downloads/)
+- **Git**: Download from [git-scm.com](https://git-scm.com/downloads)
+
+#### For macOS:
+- **Python 3.8+**: Install via Homebrew: `brew install python3`
+- **Node.js 16+**: Install via Homebrew: `brew install node`
+- **Git**: Install via Homebrew: `brew install git`
+
+### 🔧 Installation & Setup
+
+#### 1. Clone the Repository
+```bash
+git clone <repository-url>
+cd tabble
+```
+
+#### 2. Backend Setup
+
+##### Windows:
+```cmd
+# Create virtual environment
+python -m venv venv
+
+# Activate virtual environment
+venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+##### macOS/Linux:
+```bash
+# Create virtual environment
+python3 -m venv venv
+
+# Activate virtual environment
+source venv/bin/activate
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+#### 3. Frontend Setup
+
+##### Both Windows and macOS:
+```bash
+# Navigate to frontend directory
+cd frontend
+
+# Copy environment template
+cp .env.example .env
+
+# Install Node.js dependencies
+npm install
+```
+
+#### 4. Configure Environment Variables
+
+##### Backend (.env in root directory):
+```env
+SECRET_KEY=your_secret_key_here
+```
+
+##### Frontend (frontend/.env):
+```env
+# Backend API Configuration
+REACT_APP_API_BASE_URL=http://localhost:8000
+
+# Development settings
+NODE_ENV=development
+
+# Firebase Configuration (optional)
+# REACT_APP_FIREBASE_API_KEY=your_firebase_api_key
+# REACT_APP_FIREBASE_AUTH_DOMAIN=your_project.firebaseapp.com
+# REACT_APP_FIREBASE_PROJECT_ID=your_project_id
+```
+
+## 🗄️ Database Management
+
+### Understanding the Multi-Database System
+
+Tabble supports multiple independent hotel databases, allowing each hotel to operate with complete data isolation. Each database contains:
+
+- **Dishes**: Menu items with pricing, categories, and images
+- **Orders**: Customer orders and order items
+- **Persons**: Customer information and visit history
+- **Tables**: Table management and occupancy status
+- **Loyalty Program**: Visit-based discount tiers
+- **Selection Offers**: Amount-based promotional offers
+- **Settings**: Hotel-specific configuration
+- **Feedback**: Customer reviews and ratings
+
+### Database Registry (hotels.csv)
+
+The `hotels.csv` file serves as the central registry for all hotel databases:
+
+```csv
+hotel_database,password
+tabble_new.db,myhotel
+
+```
+
+### Creating a New Hotel Database
+
+#### Method 1: Using the create_empty_db.py Script
+
+##### Windows:
+```cmd
+# Activate virtual environment
+venv\Scripts\activate
+
+# Run the database creation script
+python create_empty_db.py
+```
+
+##### macOS/Linux:
+```bash
+# Activate virtual environment
+source venv/bin/activate
+
+# Run the database creation script
+python create_empty_db.py
+```
+
+**Interactive Process:**
+1. The script will prompt you for a database name
+2. Enter the hotel name (without .db extension)
+3. The script creates an empty database with proper schema
+4. Manually add the database entry to `hotels.csv`
+
+**Example:**
+```
+Creating a new empty database with the proper schema
+Enter name for the new database (without .db extension): newhotel
+
+Success! Created empty database 'newhotel.db' with the proper schema
+```
+
+Then add to `hotels.csv`:
+```csv
+newhotel.db,newhotel123
+```
+
+#### Method 2: Initialize with Sample Data
+
+##### Windows:
+```cmd
+# Create database with sample data
+python init_db.py
+```
+
+##### macOS/Linux:
+```bash
+# Create database with sample data
+python init_db.py
+```
+
+**Note:** This creates `tabble_new.db` with sample dishes, users, and configuration.
+
+### Database Schema Details
+
+The `create_empty_db.py` script creates the following tables:
+
+#### Core Tables:
+- **dishes**: Menu items with pricing, categories, offers, and visibility
+- **persons**: Customer profiles with visit tracking
+- **orders**: Order management with status tracking
+- **order_items**: Individual items within orders
+- **tables**: Table management and occupancy status
+
+#### Configuration Tables:
+- **loyalty_program**: Visit-based discount configuration
+- **selection_offers**: Amount-based promotional offers
+- **settings**: Hotel information and branding
+- **feedback**: Customer reviews and ratings
+
+### Running the Application
+
+#### Start Backend Server
+
+##### Windows:
+```cmd
+# Activate virtual environment
+venv\Scripts\activate
+
+# Start the FastAPI server
+python run.py
+```
+
+##### macOS/Linux:
+```bash
+# Activate virtual environment
+source venv/bin/activate
+
+# Start the FastAPI server
+python run.py
+```
+
+The backend will be available at `http://localhost:8000`
+
+#### Start Frontend Development Server
+
+##### Both Windows and macOS:
+```bash
+# Navigate to frontend directory
+cd frontend
+
+# Start React development server
+npm start
+```
+
+The frontend will be available at `http://localhost:3000`
+
+### 🔗 API Documentation
+
+Once the backend is running, access the interactive API documentation:
+- **Swagger UI**: `http://localhost:8000/docs`
+- **ReDoc**: `http://localhost:8000/redoc`
+
+## 🎯 Key Features Implementation
+
+### 🍽️ Table Management
+- **QR Code Generation**: Automatic QR code creation for each table
+- **Real-time Status Monitoring**: Live table occupancy tracking
+- **Session-based Occupancy**: Table status changes based on customer interaction
+- **Multi-database Support**: Table management per hotel database
+
+### 📱 Order Processing
+- **Real-time Order Tracking**: Live order status updates across all interfaces
+- **Kitchen Notifications**: Instant order notifications to chef dashboard
+- **Status Synchronization**: Order status changes reflect immediately
+- **Payment Integration**: Secure payment processing with loyalty discounts
+
+### 📊 Analytics and Reporting
+- **Custom Report Templates**: Configurable analytics reports
+- **PDF Generation**: Automated report exports
+- **Performance Metrics**: Comprehensive business intelligence
+- **Multi-dimensional Analysis**: Customer, dish, and chef performance tracking
+
+### 🔐 Authentication & Security
+- **Firebase Phone OTP**: Secure customer authentication
+- **Database Password Protection**: Hotel database access control
+- **Session Management**: Secure session handling across interfaces
+- **Data Isolation**: Complete separation of hotel data
+
+## 🚨 Troubleshooting
+
+### Common Issues
+
+#### Backend Issues:
+```bash
+# If you get "Module not found" errors
+pip install -r requirements.txt
+
+# If database connection fails
+python create_empty_db.py
+
+# If port 8000 is already in use
+# Edit run.py and change the port number
+```
+
+#### Frontend Issues:
+```bash
+# If npm install fails
+npm cache clean --force
+npm install
+
+# If environment variables aren't loading
+# Check that .env file exists in frontend directory
+cp .env.example .env
+
+# If API calls fail
+# Verify REACT_APP_API_BASE_URL in frontend/.env
+```
+
+#### Database Issues:
+```bash
+# If database schema is outdated
+python init_db.py --force-reset
+
+# If hotels.csv is missing entries
+# Manually add your database to hotels.csv
+```
+
+### Platform-Specific Notes
+
+#### Windows:
+- Use `venv\Scripts\activate` to activate virtual environment
+- Use `python` command (not `python3`)
+- Ensure Python is added to PATH during installation
+
+#### macOS:
+- Use `source venv/bin/activate` to activate virtual environment
+- Use `python3` command for Python 3.x
+- Install Xcode Command Line Tools if needed: `xcode-select --install`
+
+## 🔄 Development Workflow
+
+### Adding a New Hotel Database
+
+1. **Create Empty Database:**
+   ```bash
+   python create_empty_db.py
+   ```
+
+2. **Add to Registry:**
+   Edit `hotels.csv` and add your database entry:
+   ```csv
+   yourhotel.db,yourpassword123
+   ```
+
+3. **Configure Hotel Settings:**
+   - Access admin panel: `http://localhost:3000/admin`
+   - Navigate to Settings
+   - Configure hotel information
+
+4. **Add Menu Items:**
+   - Use admin panel to add dishes
+   - Upload dish images to `app/static/images/dishes/yourhotel/`
+
+### Deployment Considerations
+
+#### Production Environment Variables:
+```env
+# Backend
+SECRET_KEY=your_production_secret_key
+DATABASE_URL=your_production_database_url
+
+# Frontend
+REACT_APP_API_BASE_URL=https://your-domain.com/api
+NODE_ENV=production
+```
+
+#### Image Storage:
+- Images are stored in `app/static/images/dishes/{database_name}/`
+- Ensure proper directory permissions for image uploads
+- Consider using cloud storage for production deployments
+
+## 🤗 Hugging Face Spaces Deployment Guide
+
+### 🚀 Quick Deployment Steps
+
+#### 1. Prepare Your Repository
+```bash
+# Clone or fork this repository
+git clone https://github.com/your-username/tabble-v3.git
+cd tabble-v3
+
+# Ensure all required files are present:
+# ✓ Dockerfile
+# ✓ app.py
+# ✓ requirements.txt
+# ✓ templates/
+# ✓ app/
+```
+
+#### 2. Create Hugging Face Space
+
+1. **Go to**: [https://huggingface.co/new-space](https://huggingface.co/new-space)
+2. **Fill in details**:
+   - **Space name**: `tabble-v3-restaurant` (or your preferred name)
+   - **License**: MIT
+   - **SDK**: Docker
+   - **Visibility**: Public (or Private)
+3. **Connect Repository**: Link your GitHub repository
+4. **Create Space**
+
+#### 3. Configure Space Settings
+
+Add this to your Space's `README.md` header:
+```yaml
 ---
-title: Tableeee V3
-emoji: 📚
-colorFrom: purple
-colorTo: blue
+title: Tabble-v3 Restaurant Management
+emoji: 🍽️
+colorFrom: blue
+colorTo: purple
 sdk: docker
+app_port: 7860
 pinned: false
+license: mit
+short_description: Modern restaurant management system with QR ordering
+tags:
+- restaurant
+- management
+- fastapi
+- qr-code
+- ordering
 ---
+```
+
+#### 4. Automatic Build Process
+
+Hugging Face Spaces will automatically:
+1. ✅ Pull your repository
+2. ✅ Build Docker image using your Dockerfile
+3. ✅ Initialize database with sample data
+4. ✅ Start the application on port 7860
+5. ✅ Provide public URL for access
+
+### 📱 Using Your Deployed App
+
+#### 📋 Access Points
+
+| Interface | URL | Description |
+|-----------|-----|-------------|
+| **Home** | `/` | Main landing page with interface selection |
+| **Customer** | `/customer` | QR code ordering interface |
+| **Chef** | `/chef` | Kitchen order management |
+| **Admin** | `/admin` | Complete restaurant management |
+| **API Docs** | `/docs` | Interactive API documentation |
+| **Health** | `/health` | System health check |
+
+#### 🔑 Demo Credentials
+
+- **Hotel Access Code**: `myhotel`
+- **Demo Database**: `tabble_new.db`
+- **Sample Tables**: 1-20
+- **Phone OTP**: Any 6 digits (demo mode)
+
+### 🔧 Customization for Production
+
+#### 1. Hotel Configuration
+
+Edit `hotels.csv`:
+```csv
+hotel_database,password
+your_restaurant.db,secure_password_123
+another_hotel.db,different_password_456
+```
+
+#### 2. Environment Variables
+
+Create `.env` file:
+```env
+SECRET_KEY=your_production_secret_key
+HUGGINGFACE_SPACES=1
+PORT=7860
+LOG_LEVEL=INFO
+```
+
+#### 3. Database Initialization
+
+Create custom database:
+```python
+# Run this script to create your hotel database
+python create_empty_db.py
+```
+
+#### 4. Menu Setup
+
+1. Access admin panel: `your-space-url/admin`
+2. Enter your hotel access code
+3. Navigate to "Manage Dishes"
+4. Add your menu items with images
+5. Configure pricing and categories
+
+### 📊 Monitoring and Analytics
+
+#### Built-in Features
+- ✅ Real-time order tracking
+- ✅ Customer analytics dashboard
+- ✅ Sales performance metrics
+- ✅ Kitchen efficiency reports
+- ✅ Revenue analytics
+
+#### Health Monitoring
+- **Health Check**: `your-space-url/health`
+- **API Status**: Monitor via `/docs` endpoint
+- **Database Status**: Check via admin panel
+
+### 🚑 Troubleshooting
+
+#### Common Issues
+
+1. **Build Failures**:
+   ```bash
+   # Check Dockerfile syntax
+   # Verify requirements.txt dependencies
+   # Ensure all required files are present
+   ```
+
+2. **Database Issues**:
+   ```bash
+   # Check hotels.csv format
+   # Verify database permissions
+   # Run database initialization
+   ```
+
+3. **Template Loading**:
+   ```bash
+   # Ensure templates/ directory exists
+   # Check template file paths
+   # Verify Jinja2 syntax
+   ```
+
+#### Getting Help
+
+- **API Documentation**: `your-space-url/docs`
+- **System Status**: `your-space-url/health`
+- **Logs**: Check Hugging Face Spaces logs tab
+- **Issues**: Create issue in GitHub repository
+
+### 🔄 Updates and Maintenance
+
+#### Updating Your Space
+
+1. **Push changes** to your GitHub repository
+2. **Hugging Face Spaces** will auto-rebuild
+3. **Monitor build logs** in Spaces interface
+4. **Test functionality** after deployment
+
+#### Backup Strategies
+
+1. **Database Backup**:
+   ```python
+   # Use admin panel backup feature
+   # Or manually copy .db files
+   ```
+
+2. **Configuration Backup**:
+   ```bash
+   # Backup hotels.csv
+   # Backup custom templates
+   # Backup uploaded images
+   ```
+
+### 🎆 Advanced Features
+
+#### Multi-Language Support
+- Modify templates for your language
+- Update form labels and messages
+- Configure number and currency formats
+
+#### Custom Branding
+- Upload your logo to static files
+- Modify CSS in templates
+- Update color schemes and fonts
+
+#### Integration Options
+- **Payment Gateways**: Add payment processing
+- **SMS Services**: Integrate real OTP services
+- **Analytics**: Connect to external analytics tools
+- **POS Systems**: API integration capabilities
+
+---
+
+## 📞 Support and Community
+
+- **Documentation**: Complete API docs at `/docs`
+- **GitHub Issues**: Report bugs and request features
+- **Community**: Join discussions in GitHub Discussions
+- **Updates**: Follow repository for latest features
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**Ready to revolutionize your restaurant management? Deploy on Hugging Face Spaces now!** 🚀🍽️

README_HUGGINGFACE.md

@@ -0,0 +1,17 @@
+title: Tabble-v3 Restaurant Management System
+emoji: 🍽️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+short_description: Modern restaurant management system with QR ordering and real-time analytics
+tags:
+- restaurant
+- management
+- fastapi
+- qr-code
+- ordering
+- analytics
+- multi-database

TABLE_MANAGEMENT_IMPLEMENTATION.md

@@ -0,0 +1,162 @@
+# Table Management Implementation
+
+## Overview
+
+This document describes the implementation of database-specific table occupancy management based on user navigation between home page and customer pages.
+
+## Requirements Implemented
+
+1. **Database Selection**: Users first select database and verify password from hotels.csv
+2. **Table Occupancy Logic**: 
+   - `is_occupied = 0` when user is on home page (table free)
+   - `is_occupied = 1` when user is on customer page (table occupied)
+3. **Database Independence**: All table operations work within the selected database
+4. **Hotel Manager Visibility**: Table status is for hotel manager visibility only
+
+## Implementation Details
+
+### Backend Changes
+
+#### 1. New API Endpoint
+- **Endpoint**: `PUT /tables/number/{table_number}/free`
+- **Purpose**: Set table as free by table number
+- **Location**: `app/routers/table.py`
+
+```python
+@router.put("/number/{table_number}/free", response_model=Table)
+def set_table_free_by_number(table_number: int, db: Session = Depends(get_db)):
+    # Implementation details in the file
+```
+
+#### 2. Database Schema Update
+- **Added Field**: `last_occupied_at` to tables table
+- **Type**: `DATETIME`, nullable
+- **Purpose**: Track when table was last occupied
+- **Files Modified**: 
+  - `app/database.py` (SQLAlchemy model)
+  - `app/models/table.py` (Pydantic models)
+
+#### 3. Migration Support
+- **Script**: `migrate_table_schema.py`
+- **Purpose**: Add `last_occupied_at` column to existing databases
+- **Usage**: Run before starting the application with existing databases
+
+### Frontend Changes
+
+#### 1. API Service Updates
+- **File**: `frontend/src/services/api.js`
+- **New Methods**:
+  - `customerService.setTableFreeByNumber(tableNumber)`
+  - `adminService.setTableFreeByNumber(tableNumber)`
+
+#### 2. Home Page Updates
+- **File**: `frontend/src/pages/Home.js`
+- **Changes**:
+  - Added `freeTableOnHomeReturn()` function
+  - Automatically frees table when user returns to home page
+  - Uses selected database for table operations
+
+#### 3. Customer Menu Updates
+- **File**: `frontend/src/pages/customer/Menu.js`
+- **Changes**:
+  - Enhanced back-to-home button to free table before navigation
+  - Added `beforeunload` event listener for browser close/refresh
+  - Uses `navigator.sendBeacon` for reliable cleanup
+
+## Database Independence
+
+### How It Works
+1. **Database Selection**: Users select database on home page
+2. **Session Management**: Database credentials stored in localStorage
+3. **API Calls**: All table operations use the selected database
+4. **Isolation**: Each database maintains its own table occupancy state
+
+### Storage Keys
+- `customerSelectedDatabase`: Selected database name
+- `customerDatabasePassword`: Database password
+- `tableNumber`: Current table number
+
+## Table Occupancy Flow
+
+### User Journey
+1. **Home Page**: User selects database and table number
+   - Table status: `is_occupied = 0` (free)
+2. **Navigate to Customer Page**: User enters customer interface
+   - Table status: `is_occupied = 1` (occupied)
+   - API call: `PUT /tables/number/{table_number}/occupy`
+3. **Return to Home**: User clicks back button or navigates away
+   - Table status: `is_occupied = 0` (free)
+   - API call: `PUT /tables/number/{table_number}/free`
+
+### Cleanup Scenarios
+1. **Back Button**: Explicit table freeing before navigation
+2. **Browser Close**: `beforeunload` event with `navigator.sendBeacon`
+3. **Page Refresh**: `beforeunload` event with `navigator.sendBeacon`
+4. **Direct Navigation**: Home page automatically frees table on load
+
+## Testing
+
+### Test Script
+- **File**: `test_table_management.py`
+- **Purpose**: Verify table management functionality
+- **Tests**:
+  - Database selection
+  - Table creation
+  - Table occupation
+  - Table freeing
+  - Status retrieval
+
+### Running Tests
+```bash
+python test_table_management.py
+```
+
+## Migration
+
+### For Existing Databases
+```bash
+python migrate_table_schema.py
+```
+
+This will:
+- Find all .db files in current directory
+- Add `last_occupied_at` column if missing
+- Preserve existing data
+
+## API Endpoints Summary
+
+| Method | Endpoint | Purpose |
+|--------|----------|---------|
+| PUT | `/tables/number/{table_number}/occupy` | Set table as occupied |
+| PUT | `/tables/number/{table_number}/free` | Set table as free |
+| GET | `/tables/status/summary` | Get table status summary |
+| GET | `/tables/number/{table_number}` | Get table by number |
+
+## Error Handling
+
+- **Table Not Found**: Returns 404 error
+- **Database Connection**: Graceful fallback and error logging
+- **Network Issues**: Silent failure for cleanup operations
+- **Invalid Table Number**: Validation and error messages
+
+## Security Considerations
+
+- **Database Access**: Password-protected database selection
+- **Session Management**: Credentials stored in localStorage
+- **API Security**: Database switching requires authentication
+- **Data Isolation**: Complete separation between databases
+
+## Performance Optimizations
+
+- **Minimal API Calls**: Only when necessary
+- **Async Operations**: Non-blocking table updates
+- **Error Recovery**: Graceful handling of failed operations
+- **Cleanup Efficiency**: `navigator.sendBeacon` for reliable cleanup
+
+## Future Enhancements
+
+1. **Real-time Updates**: WebSocket for live table status
+2. **Table Reservations**: Advanced booking system
+3. **Analytics**: Table utilization tracking
+4. **Mobile Support**: Touch-optimized interface
+5. **Multi-language**: Internationalization support

app.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""
+Tabble-v3 Restaurant Management System
+Entry point for Hugging Face Spaces deployment
+"""
+
+import uvicorn
+import os
+import sys
+from pathlib import Path
+
+# Add the app directory to the Python path
+app_dir = Path(__file__).parent / "app"
+sys.path.insert(0, str(app_dir))
+
+def main():
+    """Main entry point for the application"""
+    
+    # Create static directories if they don't exist
+    os.makedirs("app/static/images/dishes", exist_ok=True)
+    os.makedirs("templates", exist_ok=True)
+    
+    # Set environment variables for Hugging Face Spaces
+    os.environ.setdefault("HUGGINGFACE_SPACES", "1")
+    
+    # Get port from environment (Hugging Face Spaces uses 7860)
+    port = int(os.environ.get("PORT", 7860))
+    host = os.environ.get("HOST", "0.0.0.0")
+    
+    print(f"🚀 Starting Tabble-v3 Restaurant Management System")
+    print(f"📡 Server: http://{host}:{port}")
+    print(f"📖 API Documentation: http://{host}:{port}/docs")
+    print(f"🏥 Health Check: http://{host}:{port}/health")
+    print("=" * 60)
+    
+    # Start the FastAPI application
+    uvicorn.run(
+        "app.main:app",
+        host=host,
+        port=port,
+        reload=False,  # Disable reload in production
+        log_level="info",
+        access_log=True
+    )
+
+if __name__ == "__main__":
+    main()

app/__init__.py

@@ -0,0 +1,8 @@
+"""
+Tabble-v3 Restaurant Management System
+Main application package
+"""
+
+__version__ = "3.1.0"
+__author__ = "Tabble Development Team"
+__description__ = "Modern restaurant management system with QR ordering and real-time analytics"

app/database.py

@@ -0,0 +1,473 @@
+from sqlalchemy import (
+    create_engine,
+    Column,
+    Integer,
+    String,
+    Float,
+    ForeignKey,
+    DateTime,
+    Text,
+    Boolean,
+    UniqueConstraint,
+)
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship, scoped_session
+from datetime import datetime, timezone
+import os
+import threading
+from typing import Dict, Optional
+import uuid
+
+# Base declarative class
+Base = declarative_base()
+
+# Session-based database manager with hotel context
+class DatabaseManager:
+    def __init__(self):
+        self.sessions: Dict[str, dict] = {}
+        self.lock = threading.Lock()
+        self.unified_database = "Tabble.db"
+
+    def get_session_id(self, request_headers: dict) -> str:
+        """Generate or retrieve session ID from request headers"""
+        session_id = request_headers.get('x-session-id')
+        if not session_id:
+            session_id = str(uuid.uuid4())
+        return session_id
+
+    def get_database_connection(self, session_id: str, hotel_id: Optional[int] = None) -> dict:
+        """Get or create database connection for session with hotel context"""
+        with self.lock:
+            if session_id not in self.sessions:
+                # Create new session with unified database
+                self.sessions[session_id] = self._create_connection(hotel_id)
+            elif hotel_id and self.sessions[session_id].get('hotel_id') != hotel_id:
+                # Update hotel context for existing session
+                self.sessions[session_id]['hotel_id'] = hotel_id
+
+            return self.sessions[session_id]
+
+    def _create_connection(self, hotel_id: Optional[int] = None) -> dict:
+        """Create a new database connection to unified database"""
+        database_url = f"sqlite:///./Tabble.db"
+        engine = create_engine(database_url, connect_args={"check_same_thread": False})
+        session_factory = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        session_local = scoped_session(session_factory)
+
+        # Create tables in the database if they don't exist
+        Base.metadata.create_all(bind=engine)
+
+        return {
+            'database_name': self.unified_database,
+            'database_url': database_url,
+            'engine': engine,
+            'session_local': session_local,
+            'hotel_id': hotel_id
+        }
+
+    def _dispose_connection(self, session_id: str):
+        """Dispose of database connection for session"""
+        if session_id in self.sessions:
+            connection = self.sessions[session_id]
+            connection['session_local'].remove()
+            connection['engine'].dispose()
+
+    def set_hotel_context(self, session_id: str, hotel_id: int) -> bool:
+        """Set hotel context for a specific session"""
+        try:
+            self.get_database_connection(session_id, hotel_id)
+            print(f"Session {session_id} set to hotel_id: {hotel_id}")
+            return True
+        except Exception as e:
+            print(f"Error setting hotel context for session {session_id}: {e}")
+            return False
+
+    def get_current_hotel_id(self, session_id: str) -> Optional[int]:
+        """Get current hotel_id for session"""
+        if session_id in self.sessions:
+            return self.sessions[session_id].get('hotel_id')
+        return None
+
+    def get_current_database(self, session_id: str) -> str:
+        """Get current database name for session (always Tabble.db)"""
+        return self.unified_database
+
+    def authenticate_hotel(self, hotel_name: str, password: str) -> Optional[int]:
+        """Authenticate hotel and return hotel_id"""
+        try:
+            # Use global engine to query hotels table
+            from sqlalchemy.orm import sessionmaker
+            Session = sessionmaker(bind=engine)
+            db = Session()
+
+            hotel = db.query(Hotel).filter(
+                Hotel.hotel_name == hotel_name,
+                Hotel.password == password
+            ).first()
+
+            db.close()
+
+            if hotel:
+                return hotel.id
+            return None
+        except Exception as e:
+            print(f"Error authenticating hotel {hotel_name}: {e}")
+            return None
+
+    def cleanup_session(self, session_id: str):
+        """Clean up session resources"""
+        with self.lock:
+            if session_id in self.sessions:
+                self._dispose_connection(session_id)
+                del self.sessions[session_id]
+
+# Global database manager instance
+db_manager = DatabaseManager()
+
+# Global variables for database connection (unified database)
+CURRENT_DATABASE = "Tabble.db"
+DATABASE_URL = f"sqlite:///./Tabble.db"  # Using the unified database
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+session_factory = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+SessionLocal = scoped_session(session_factory)
+
+# Lock for thread safety when switching databases
+db_lock = threading.Lock()
+
+
+# Database models
+class Hotel(Base):
+    __tablename__ = "hotels"
+
+    id = Column(Integer, primary_key=True, index=True)
+    hotel_name = Column(String, unique=True, index=True, nullable=False)
+    password = Column(String, nullable=False)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+    # Relationships
+    dishes = relationship("Dish", back_populates="hotel")
+    persons = relationship("Person", back_populates="hotel")
+    orders = relationship("Order", back_populates="hotel")
+    tables = relationship("Table", back_populates="hotel")
+    settings = relationship("Settings", back_populates="hotel")
+    feedback = relationship("Feedback", back_populates="hotel")
+    loyalty_tiers = relationship("LoyaltyProgram", back_populates="hotel")
+    selection_offers = relationship("SelectionOffer", back_populates="hotel")
+
+
+class Dish(Base):
+    __tablename__ = "dishes"
+
+    id = Column(Integer, primary_key=True, index=True)
+    hotel_id = Column(Integer, ForeignKey("hotels.id"), nullable=False, index=True)
+    name = Column(String, index=True)
+    description = Column(Text, nullable=True)
+    category = Column(String, index=True)  # Now stores JSON array for multiple categories
+    price = Column(Float)
+    quantity = Column(Integer, default=0)  # Made optional in forms, but keeps default
+    image_path = Column(String, nullable=True)
+    discount = Column(Float, default=0)  # Discount amount (percentage)
+    is_offer = Column(Integer, default=0)  # 0 = not an offer, 1 = is an offer
+    is_special = Column(Integer, default=0)  # 0 = not special, 1 = today's special
+    is_vegetarian = Column(Integer, default=1)  # 1 = vegetarian, 0 = non-vegetarian
+    visibility = Column(Integer, default=1)  # 1 = visible, 0 = hidden (soft delete)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+    # Relationships
+    hotel = relationship("Hotel", back_populates="dishes")
+
+    # Relationship with OrderItem
+    order_items = relationship("OrderItem", back_populates="dish")
+
+
+class Order(Base):
+    __tablename__ = "orders"
+
+    id = Column(Integer, primary_key=True, index=True)
+    hotel_id = Column(Integer, ForeignKey("hotels.id"), nullable=False, index=True)
+    table_number = Column(Integer)
+    unique_id = Column(String, index=True)
+    person_id = Column(Integer, ForeignKey("persons.id"), nullable=True)
+    status = Column(String, default="pending")  # pending, accepted, completed, paid
+    total_amount = Column(Float, nullable=True)  # Final amount paid after all discounts
+    subtotal_amount = Column(Float, nullable=True)  # Original amount before discounts
+    loyalty_discount_amount = Column(Float, default=0)  # Loyalty discount applied
+    selection_offer_discount_amount = Column(Float, default=0)  # Selection offer discount applied
+    loyalty_discount_percentage = Column(Float, default=0)  # Loyalty discount percentage applied
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+    # Relationships
+    hotel = relationship("Hotel", back_populates="orders")
+    items = relationship("OrderItem", back_populates="order")
+    person = relationship("Person", back_populates="orders")
+
+
+class Person(Base):
+    __tablename__ = "persons"
+
+    id = Column(Integer, primary_key=True, index=True)
+    hotel_id = Column(Integer, ForeignKey("hotels.id"), nullable=False, index=True)
+    username = Column(String, index=True)
+    password = Column(String)
+    phone_number = Column(String, index=True, nullable=True)  # Added phone number field
+    visit_count = Column(Integer, default=0)
+    last_visit = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+    # Unique constraints per hotel
+    __table_args__ = (
+        UniqueConstraint('hotel_id', 'username', name='uq_person_hotel_username'),
+        UniqueConstraint('hotel_id', 'phone_number', name='uq_person_hotel_phone'),
+    )
+
+    # Relationships
+    hotel = relationship("Hotel", back_populates="persons")
+    orders = relationship("Order", back_populates="person")
+
+
+class OrderItem(Base):
+    __tablename__ = "order_items"
+
+    id = Column(Integer, primary_key=True, index=True)
+    hotel_id = Column(Integer, ForeignKey("hotels.id"), nullable=False, index=True)
+    order_id = Column(Integer, ForeignKey("orders.id"))
+    dish_id = Column(Integer, ForeignKey("dishes.id"))
+    quantity = Column(Integer, default=1)
+    price = Column(Float, nullable=True)  # Price at time of order
+    remarks = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+    # Relationships
+    order = relationship("Order", back_populates="items")
+    dish = relationship("Dish", back_populates="order_items")
+
+
+class Feedback(Base):
+    __tablename__ = "feedback"
+
+    id = Column(Integer, primary_key=True, index=True)
+    hotel_id = Column(Integer, ForeignKey("hotels.id"), nullable=False, index=True)
+    order_id = Column(Integer, ForeignKey("orders.id"))
+    person_id = Column(Integer, ForeignKey("persons.id"), nullable=True)
+    rating = Column(Integer)  # 1-5 stars
+    comment = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+    # Relationships
+    hotel = relationship("Hotel", back_populates="feedback")
+    order = relationship("Order")
+    person = relationship("Person")
+
+
+class LoyaltyProgram(Base):
+    __tablename__ = "loyalty_tiers"
+
+    id = Column(Integer, primary_key=True, index=True)
+    hotel_id = Column(Integer, ForeignKey("hotels.id"), nullable=False, index=True)
+    visit_count = Column(Integer)  # Number of visits required
+    discount_percentage = Column(Float)  # Discount percentage
+    is_active = Column(Boolean, default=True)  # Whether this loyalty tier is active
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+    # Unique constraint per hotel
+    __table_args__ = (
+        UniqueConstraint('hotel_id', 'visit_count', name='uq_loyalty_hotel_visits'),
+    )
+
+    # Relationships
+    hotel = relationship("Hotel", back_populates="loyalty_tiers")
+
+
+class SelectionOffer(Base):
+    __tablename__ = "selection_offers"
+
+    id = Column(Integer, primary_key=True, index=True)
+    hotel_id = Column(Integer, ForeignKey("hotels.id"), nullable=False, index=True)
+    min_amount = Column(Float)  # Minimum order amount to qualify
+    discount_amount = Column(Float)  # Fixed discount amount to apply
+    is_active = Column(Boolean, default=True)  # Whether this offer is active
+    description = Column(String, nullable=True)  # Optional description of the offer
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+    # Relationships
+    hotel = relationship("Hotel", back_populates="selection_offers")
+
+
+class Table(Base):
+    __tablename__ = "tables"
+
+    id = Column(Integer, primary_key=True, index=True)
+    hotel_id = Column(Integer, ForeignKey("hotels.id"), nullable=False, index=True)
+    table_number = Column(Integer)  # Table number
+    is_occupied = Column(
+        Boolean, default=False
+    )  # Whether the table is currently occupied
+    current_order_id = Column(
+        Integer, ForeignKey("orders.id"), nullable=True
+    )  # Current active order
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+    # Unique constraint per hotel
+    __table_args__ = (
+        UniqueConstraint('hotel_id', 'table_number', name='uq_table_hotel_number'),
+    )
+
+    # Relationships
+    hotel = relationship("Hotel", back_populates="tables")
+    current_order = relationship("Order", foreign_keys=[current_order_id])
+
+
+class Settings(Base):
+    __tablename__ = "settings"
+
+    id = Column(Integer, primary_key=True, index=True)
+    hotel_id = Column(Integer, ForeignKey("hotels.id"), nullable=False, index=True)
+    hotel_name = Column(String, nullable=False, default="Tabble Hotel")
+    address = Column(String, nullable=True)
+    contact_number = Column(String, nullable=True)
+    email = Column(String, nullable=True)
+    tax_id = Column(String, nullable=True)
+    logo_path = Column(String, nullable=True)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+    # Unique constraint per hotel
+    __table_args__ = (
+        UniqueConstraint('hotel_id', name='uq_settings_hotel'),
+    )
+
+    # Relationships
+    hotel = relationship("Hotel", back_populates="settings")
+
+
+# Function to switch database
+def switch_database(database_name):
+    global CURRENT_DATABASE, DATABASE_URL, engine, SessionLocal
+
+    with db_lock:
+        if database_name == CURRENT_DATABASE:
+            return  # Already using this database
+
+        # Update global variables
+        CURRENT_DATABASE = database_name
+        DATABASE_URL = f"sqlite:///./tabble_new.db" if database_name == "tabble_new.db" else f"sqlite:///./{database_name}"
+
+        # Dispose of the old engine and create a new one
+        engine.dispose()
+        engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+
+        # Create a new session factory and scoped session
+        session_factory = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        SessionLocal.remove()
+        SessionLocal = scoped_session(session_factory)
+
+        # Create tables in the new database if they don't exist
+        create_tables()
+
+        print(f"Switched to database: {database_name}")
+
+
+# Get current database name
+def get_current_database():
+    return CURRENT_DATABASE
+
+
+# Create tables
+def create_tables():
+    # Create all tables (only creates tables that don't exist)
+    Base.metadata.create_all(bind=engine)
+    print("Database tables created/verified successfully")
+
+
+# Get database session (legacy)
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+# Session-aware database functions with hotel context
+def get_session_db(session_id: str, hotel_id: Optional[int] = None):
+    """Get database session for a specific session ID with hotel context"""
+    connection = db_manager.get_database_connection(session_id, hotel_id)
+    db = connection['session_local']()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def set_session_hotel_context(session_id: str, hotel_id: int) -> bool:
+    """Set hotel context for a specific session"""
+    return db_manager.set_hotel_context(session_id, hotel_id)
+
+
+def get_session_hotel_id(session_id: str) -> Optional[int]:
+    """Get current hotel_id for a session"""
+    return db_manager.get_current_hotel_id(session_id)
+
+
+def get_session_current_database(session_id: str) -> str:
+    """Get current database name for a session (always Tabble.db)"""
+    return db_manager.get_current_database(session_id)
+
+
+def authenticate_hotel_session(hotel_name: str, password: str) -> Optional[int]:
+    """Authenticate hotel and return hotel_id"""
+    return db_manager.authenticate_hotel(hotel_name, password)
+
+
+def cleanup_session_db(session_id: str):
+    """Clean up database resources for a session"""
+    db_manager.cleanup_session(session_id)
+
+
+# Helper function to get hotel_id from request
+def get_hotel_id_from_request(request) -> int:
+    """Get hotel_id from request session, raise HTTPException if not found"""
+    from fastapi import HTTPException
+    from .middleware import get_session_id
+
+    session_id = get_session_id(request)
+    hotel_id = get_session_hotel_id(session_id)
+
+    if not hotel_id:
+        raise HTTPException(status_code=400, detail="No hotel context set")
+
+    return hotel_id

app/main.py

@@ -0,0 +1,116 @@
+from fastapi import FastAPI, Request, Depends
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.responses import HTMLResponse, RedirectResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from sqlalchemy.orm import Session
+import uvicorn
+import os
+
+from .database import get_db, create_tables
+from .routers import chef, customer, admin, feedback, loyalty, selection_offer, table, analytics, settings
+from .middleware import SessionMiddleware
+
+# Create FastAPI app
+app = FastAPI(title="Tabble - Hotel Management App")
+
+# Add CORS middleware to allow cross-origin requests
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allow all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allow all methods
+    allow_headers=["*"],  # Allow all headers
+)
+
+# Add session middleware for database management
+app.add_middleware(SessionMiddleware, require_database=True)
+
+# Mount static files
+app.mount("/static", StaticFiles(directory="app/static"), name="static")
+
+# Setup templates
+templates = Jinja2Templates(directory="templates")
+
+# Include routers
+app.include_router(chef.router)
+app.include_router(customer.router)
+app.include_router(admin.router)
+app.include_router(feedback.router)
+app.include_router(loyalty.router)
+app.include_router(selection_offer.router)
+app.include_router(table.router)
+app.include_router(analytics.router)
+app.include_router(settings.router)
+
+# Create database tables
+create_tables()
+
+# Check if we have the React build folder
+react_build_dir = "frontend/build"
+has_react_build = os.path.isdir(react_build_dir)
+
+if has_react_build:
+    # Mount the React build folder
+    app.mount("/", StaticFiles(directory=react_build_dir, html=True), name="react")
+
+
+# Health check endpoint for Render
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "message": "Tabble API is running"}
+
+
+# Root route - serve React app in production, otherwise serve index.html template
+@app.get("/", response_class=HTMLResponse)
+async def root(request: Request):
+    if has_react_build:
+        return FileResponse(f"{react_build_dir}/index.html")
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+# Chef page
+@app.get("/chef", response_class=HTMLResponse)
+async def chef_page(request: Request):
+    return templates.TemplateResponse("chef/index.html", {"request": request})
+
+
+# Chef orders page
+@app.get("/chef/orders", response_class=HTMLResponse)
+async def chef_orders_page(request: Request):
+    return templates.TemplateResponse("chef/orders.html", {"request": request})
+
+
+# Customer login page
+@app.get("/customer", response_class=HTMLResponse)
+async def customer_login_page(request: Request):
+    return templates.TemplateResponse("customer/login.html", {"request": request})
+
+
+# Customer menu page
+@app.get("/customer/menu", response_class=HTMLResponse)
+async def customer_menu_page(request: Request, table_number: int, unique_id: str):
+    return templates.TemplateResponse(
+        "customer/menu.html",
+        {"request": request, "table_number": table_number, "unique_id": unique_id},
+    )
+
+
+# Admin page
+@app.get("/admin", response_class=HTMLResponse)
+async def admin_page(request: Request):
+    return templates.TemplateResponse("admin/index.html", {"request": request})
+
+
+# Admin dishes page
+@app.get("/admin/dishes", response_class=HTMLResponse)
+async def admin_dishes_page(request: Request):
+    return templates.TemplateResponse("admin/dishes.html", {"request": request})
+
+
+
+
+
+if __name__ == "__main__":
+    PORT = os.getenv("PORT", 8000)
+    uvicorn.run("app.main:app", host="0.0.0.0", port=PORT, reload=True)

app/middleware/__init__.py

@@ -0,0 +1,3 @@
+from .session_middleware import SessionMiddleware, get_session_id
+
+__all__ = ['SessionMiddleware', 'get_session_id']

app/middleware/session_middleware.py

@@ -0,0 +1,125 @@
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import JSONResponse
+import uuid
+from typing import Callable
+from ..database import db_manager
+
+
+class SessionMiddleware(BaseHTTPMiddleware):
+    """Middleware to handle session-based database management"""
+    
+    def __init__(self, app, require_database: bool = True):
+        super().__init__(app)
+        self.require_database = require_database
+        
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        # Skip validation for OPTIONS requests (CORS preflight)
+        if request.method == "OPTIONS":
+            response = await call_next(request)
+            return response
+
+        # Get or generate session ID
+        session_id = request.headers.get('x-session-id')
+        if not session_id:
+            session_id = str(uuid.uuid4())
+
+        # Add session ID to request state
+        request.state.session_id = session_id
+
+        # Check if this is a database-related endpoint
+        path = request.url.path
+        is_database_endpoint = (
+            path.startswith('/settings/') or
+            path.startswith('/customer/api/') or
+            path.startswith('/chef/') or
+            path.startswith('/admin/') or
+            path.startswith('/analytics/') or
+            path.startswith('/tables/') or
+            path.startswith('/feedback/') or
+            path.startswith('/loyalty/') or
+            path.startswith('/selection-offers/')
+        )
+
+        # Skip session validation for certain endpoints
+        skip_validation_endpoints = [
+            '/settings/databases',
+            '/settings/hotels',
+            '/settings/switch-database',
+            '/settings/switch-hotel',
+            '/settings/current-database',
+            '/settings/current-hotel'
+        ]
+
+        # Skip validation for admin and chef routes - they handle their own database selection
+        skip_validation_paths = [
+            '/admin/',
+            '/chef/'
+        ]
+
+        # Check if path should skip validation
+        should_skip_path = any(path.startswith(skip_path) for skip_path in skip_validation_paths)
+
+        should_validate = (
+            is_database_endpoint and
+            path not in skip_validation_endpoints and
+            not should_skip_path and
+            self.require_database
+        )
+        
+        if should_validate:
+            # Check if session has a valid hotel context
+            current_hotel_id = db_manager.get_current_hotel_id(session_id)
+            if not current_hotel_id:
+                # Check if there's stored hotel credentials in headers
+                stored_hotel_name = request.headers.get('x-hotel-name')
+                stored_password = request.headers.get('x-hotel-password')
+
+                if stored_hotel_name and stored_password:
+                    # Try to verify and set hotel context
+                    try:
+                        # Authenticate hotel using the database manager
+                        hotel_id = db_manager.authenticate_hotel(stored_hotel_name, stored_password)
+
+                        if hotel_id:
+                            # Valid credentials, set hotel context
+                            db_manager.set_hotel_context(session_id, hotel_id)
+                        else:
+                            # Invalid credentials
+                            return JSONResponse(
+                                status_code=401,
+                                content={
+                                    "detail": "Invalid hotel credentials",
+                                    "error_code": "HOTEL_AUTH_FAILED"
+                                }
+                            )
+                    except Exception as e:
+                        return JSONResponse(
+                            status_code=500,
+                            content={
+                                "detail": f"Hotel authentication failed: {str(e)}",
+                                "error_code": "HOTEL_VERIFICATION_ERROR"
+                            }
+                        )
+                else:
+                    # No hotel selected
+                    return JSONResponse(
+                        status_code=400,
+                        content={
+                            "detail": "No hotel selected. Please select a hotel first.",
+                            "error_code": "HOTEL_NOT_SELECTED"
+                        }
+                    )
+        
+        # Process the request
+        response = await call_next(request)
+        
+        # Add session ID to response headers
+        response.headers["x-session-id"] = session_id
+        
+        return response
+
+
+def get_session_id(request: Request) -> str:
+    """Helper function to get session ID from request"""
+    return getattr(request.state, 'session_id', str(uuid.uuid4()))

app/models/database_config.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+
+class DatabaseEntry(BaseModel):
+    database_name: str
+    password: str
+
+
+class DatabaseList(BaseModel):
+    databases: List[DatabaseEntry]
+
+
+class DatabaseSelectRequest(BaseModel):
+    database_name: str
+    password: str
+
+
+class DatabaseSelectResponse(BaseModel):
+    success: bool
+    message: str

app/models/dish.py

@@ -0,0 +1,42 @@
+from pydantic import BaseModel, validator, field_serializer
+from typing import Optional, List, Union
+from datetime import datetime
+import json
+
+class DishBase(BaseModel):
+    name: str
+    description: Optional[str] = None
+    category: str  # Keep as string - will store JSON array format
+    price: float
+    quantity: Optional[int] = 0  # Made optional for forms
+    discount: Optional[float] = 0
+    is_offer: Optional[int] = 0
+    is_special: Optional[int] = 0
+    is_vegetarian: Optional[int] = 1  # 1 = vegetarian, 0 = non-vegetarian
+    visibility: Optional[int] = 1
+
+class DishCreate(DishBase):
+    pass
+
+class DishUpdate(DishBase):
+    name: Optional[str] = None
+    description: Optional[str] = None
+    category: Optional[str] = None
+    price: Optional[float] = None
+    quantity: Optional[int] = None
+    image_path: Optional[str] = None
+    discount: Optional[float] = None
+    is_offer: Optional[int] = None
+    is_special: Optional[int] = None
+    is_vegetarian: Optional[int] = None
+    visibility: Optional[int] = None
+
+class Dish(DishBase):
+    id: int
+    image_path: Optional[str] = None
+    visibility: int = 1
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True  # Updated from orm_mode for Pydantic V2

app/models/feedback.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+
+class FeedbackBase(BaseModel):
+    order_id: int
+    rating: int
+    comment: Optional[str] = None
+    person_id: Optional[int] = None
+
+
+class FeedbackCreate(FeedbackBase):
+    pass
+
+
+class Feedback(FeedbackBase):
+    id: int
+    created_at: datetime
+
+    class Config:
+        from_attributes = True  # Updated from orm_mode for Pydantic V2

app/models/loyalty.py

@@ -0,0 +1,28 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+
+class LoyaltyProgramBase(BaseModel):
+    visit_count: int
+    discount_percentage: float
+    is_active: bool = True
+
+
+class LoyaltyProgramCreate(LoyaltyProgramBase):
+    pass
+
+
+class LoyaltyProgramUpdate(BaseModel):
+    visit_count: Optional[int] = None
+    discount_percentage: Optional[float] = None
+    is_active: Optional[bool] = None
+
+
+class LoyaltyProgram(LoyaltyProgramBase):
+    id: int
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True  # Updated from orm_mode for Pydantic V2

app/models/order.py

@@ -0,0 +1,65 @@
+from pydantic import BaseModel
+from typing import List, Optional
+from datetime import datetime
+from .dish import Dish
+
+
+class OrderItemBase(BaseModel):
+    dish_id: int
+    quantity: int = 1
+    remarks: Optional[str] = None
+
+
+class OrderItemCreate(OrderItemBase):
+    pass
+
+
+class OrderItem(OrderItemBase):
+    id: int
+    order_id: int
+    created_at: datetime
+    dish: Optional[Dish] = None
+
+    # Add dish_name property to ensure it's always available
+    @property
+    def dish_name(self) -> str:
+        if self.dish:
+            return self.dish.name
+        return "Unknown Dish"
+
+    class Config:
+        from_attributes = True  # Updated from orm_mode for Pydantic V2
+
+
+class OrderBase(BaseModel):
+    table_number: int
+    unique_id: str
+
+
+class OrderCreate(OrderBase):
+    items: List[OrderItemCreate]
+    username: Optional[str] = None
+    password: Optional[str] = None
+
+
+class OrderUpdate(BaseModel):
+    status: str
+
+
+class Order(OrderBase):
+    id: int
+    status: str
+    created_at: datetime
+    updated_at: datetime
+    items: List[OrderItem] = []
+    person_id: Optional[int] = None
+    person_name: Optional[str] = None
+    visit_count: Optional[int] = None
+    total_amount: Optional[float] = None
+    subtotal_amount: Optional[float] = None
+    loyalty_discount_amount: Optional[float] = 0
+    selection_offer_discount_amount: Optional[float] = 0
+    loyalty_discount_percentage: Optional[float] = 0
+
+    class Config:
+        from_attributes = True  # Updated from orm_mode for Pydantic V2

app/models/selection_offer.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+
+class SelectionOfferBase(BaseModel):
+    min_amount: float
+    discount_amount: float
+    is_active: bool = True
+    description: Optional[str] = None
+
+
+class SelectionOfferCreate(SelectionOfferBase):
+    pass
+
+
+class SelectionOfferUpdate(BaseModel):
+    min_amount: Optional[float] = None
+    discount_amount: Optional[float] = None
+    is_active: Optional[bool] = None
+    description: Optional[str] = None
+
+
+class SelectionOffer(SelectionOfferBase):
+    id: int
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True  # Updated from orm_mode for Pydantic V2

app/models/settings.py

@@ -0,0 +1,34 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+
+class SettingsBase(BaseModel):
+    hotel_name: str
+    address: Optional[str] = None
+    contact_number: Optional[str] = None
+    email: Optional[str] = None
+    tax_id: Optional[str] = None
+    logo_path: Optional[str] = None
+
+
+class SettingsCreate(SettingsBase):
+    pass
+
+
+class SettingsUpdate(BaseModel):
+    hotel_name: Optional[str] = None
+    address: Optional[str] = None
+    contact_number: Optional[str] = None
+    email: Optional[str] = None
+    tax_id: Optional[str] = None
+    logo_path: Optional[str] = None
+
+
+class Settings(SettingsBase):
+    id: int
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True  # Updated from orm_mode for Pydantic V2

app/models/table.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+
+class TableBase(BaseModel):
+    table_number: int
+    is_occupied: bool = False
+    current_order_id: Optional[int] = None
+
+
+class TableCreate(TableBase):
+    pass
+
+
+class TableUpdate(BaseModel):
+    is_occupied: Optional[bool] = None
+    current_order_id: Optional[int] = None
+
+
+class Table(TableBase):
+    id: int
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True  # Updated from orm_mode for Pydantic V2
+
+
+class TableStatus(BaseModel):
+    total_tables: int
+    occupied_tables: int
+    free_tables: int

app/models/user.py

@@ -0,0 +1,39 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+class PersonBase(BaseModel):
+    username: str
+
+class PersonCreate(PersonBase):
+    password: str
+    table_number: int
+    phone_number: Optional[str] = None
+
+class PersonLogin(PersonBase):
+    password: str
+    table_number: int
+
+class PhoneAuthRequest(BaseModel):
+    phone_number: str
+    table_number: int
+
+class PhoneVerifyRequest(BaseModel):
+    phone_number: str
+    verification_code: str
+    table_number: int
+
+class UsernameRequest(BaseModel):
+    phone_number: str
+    username: str
+    table_number: int
+
+class Person(PersonBase):
+    id: int
+    visit_count: int
+    last_visit: datetime
+    created_at: datetime
+    phone_number: Optional[str] = None
+
+    class Config:
+        from_attributes = True  # Updated from orm_mode for Pydantic V2

app/routers/admin.py

@@ -0,0 +1,643 @@
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Form, Request
+from fastapi.responses import StreamingResponse
+from sqlalchemy.orm import Session
+from typing import List, Optional
+import os
+import shutil
+from datetime import datetime, timezone
+from ..utils.pdf_generator import generate_bill_pdf, generate_multi_order_bill_pdf
+
+from ..database import get_db, Order, Dish, OrderItem, Person, Settings, get_session_db, get_session_current_database, get_hotel_id_from_request
+from ..models.order import Order as OrderModel
+from ..models.dish import Dish as DishModel, DishCreate, DishUpdate
+from ..middleware import get_session_id
+
+router = APIRouter(
+    prefix="/admin",
+    tags=["admin"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+# Dependency to get session-aware database
+def get_session_database(request: Request):
+    session_id = get_session_id(request)
+    return next(get_session_db(session_id))
+
+
+# Get all orders with customer information
+@router.get("/orders", response_model=List[OrderModel])
+def get_all_orders(request: Request, status: str = None, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    query = db.query(Order).filter(Order.hotel_id == hotel_id)
+
+    if status:
+        query = query.filter(Order.status == status)
+
+    # Order by most recent first
+    orders = query.order_by(Order.created_at.desc()).all()
+
+    # Load person information for each order
+    for order in orders:
+        if order.person_id:
+            person = db.query(Person).filter(
+                Person.hotel_id == hotel_id,
+                Person.id == order.person_id
+            ).first()
+            if person:
+                # Add person information to the order
+                order.person_name = person.username
+                order.visit_count = person.visit_count
+
+        # Load dish information for each order item
+        for item in order.items:
+            if not hasattr(item, "dish") or item.dish is None:
+                dish = db.query(Dish).filter(
+                    Dish.hotel_id == hotel_id,
+                    Dish.id == item.dish_id
+                ).first()
+                if dish:
+                    item.dish = dish
+
+    return orders
+
+
+# Get all dishes (only visible ones)
+@router.get("/api/dishes", response_model=List[DishModel])
+def get_all_dishes(
+    request: Request,
+    is_offer: Optional[int] = None,
+    is_special: Optional[int] = None,
+    db: Session = Depends(get_session_database),
+):
+    hotel_id = get_hotel_id_from_request(request)
+
+    query = db.query(Dish).filter(
+        Dish.hotel_id == hotel_id,
+        Dish.visibility == 1
+    )  # Only visible dishes for this hotel
+
+    if is_offer is not None:
+        query = query.filter(Dish.is_offer == is_offer)
+
+    if is_special is not None:
+        query = query.filter(Dish.is_special == is_special)
+
+    dishes = query.all()
+    return dishes
+
+
+# Get offer dishes (only visible ones)
+@router.get("/api/offers", response_model=List[DishModel])
+def get_offer_dishes(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    dishes = db.query(Dish).filter(
+        Dish.hotel_id == hotel_id,
+        Dish.is_offer == 1,
+        Dish.visibility == 1
+    ).all()
+    return dishes
+
+
+# Get special dishes (only visible ones)
+@router.get("/api/specials", response_model=List[DishModel])
+def get_special_dishes(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    dishes = db.query(Dish).filter(
+        Dish.hotel_id == hotel_id,
+        Dish.is_special == 1,
+        Dish.visibility == 1
+    ).all()
+    return dishes
+
+
+# Get dish by ID (only if visible)
+@router.get("/api/dishes/{dish_id}", response_model=DishModel)
+def get_dish(dish_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    dish = db.query(Dish).filter(
+        Dish.hotel_id == hotel_id,
+        Dish.id == dish_id,
+        Dish.visibility == 1
+    ).first()
+    if dish is None:
+        raise HTTPException(status_code=404, detail="Dish not found")
+    return dish
+
+
+# Get all categories
+@router.get("/api/categories")
+def get_all_categories(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    categories = db.query(Dish.category).filter(
+        Dish.hotel_id == hotel_id
+    ).distinct().all()
+
+    # Parse JSON categories and flatten them
+    import json
+    unique_categories = set()
+
+    for category_tuple in categories:
+        category_str = category_tuple[0]
+        if category_str:
+            try:
+                # Try to parse as JSON array
+                category_list = json.loads(category_str)
+                if isinstance(category_list, list):
+                    unique_categories.update(category_list)
+                else:
+                    unique_categories.add(category_str)
+            except (json.JSONDecodeError, TypeError):
+                # If not JSON, treat as single category
+                unique_categories.add(category_str)
+
+    return sorted(list(unique_categories))
+
+
+# Create new category
+@router.post("/api/categories")
+def create_category(request: Request, category_name: str = Form(...), db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Check if category already exists for this hotel
+    existing_category = (
+        db.query(Dish.category).filter(
+            Dish.hotel_id == hotel_id,
+            Dish.category == category_name
+        ).first()
+    )
+    if existing_category:
+        raise HTTPException(status_code=400, detail="Category already exists")
+
+    return {"message": "Category created successfully", "category": category_name}
+
+
+# Create new dish
+@router.post("/api/dishes", response_model=DishModel)
+async def create_dish(
+    request: Request,
+    name: str = Form(...),
+    description: Optional[str] = Form(None),
+    category: Optional[str] = Form(None),  # Made optional
+    new_category: Optional[str] = Form(None),  # New field for custom category
+    categories: Optional[str] = Form(None),  # JSON array of multiple categories
+    price: float = Form(...),
+    quantity: Optional[int] = Form(0),  # Made optional with default
+    discount: Optional[float] = Form(0),  # Discount amount (percentage)
+    is_offer: Optional[int] = Form(0),  # Whether this dish is part of offers
+    is_special: Optional[int] = Form(0),  # Whether this dish is today's special
+    is_vegetarian: int = Form(...),  # Required: 1 = vegetarian, 0 = non-vegetarian
+    image: Optional[UploadFile] = File(None),
+    db: Session = Depends(get_session_database),
+):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Handle categories - support both single and multiple categories
+    import json
+    final_category = None
+
+    if categories:
+        # Multiple categories provided as JSON array
+        try:
+            category_list = json.loads(categories)
+            final_category = json.dumps(category_list)  # Store as JSON string
+        except json.JSONDecodeError:
+            final_category = json.dumps([categories])  # Fallback to single category
+    elif new_category:
+        # Single new category
+        final_category = json.dumps([new_category])
+    elif category:
+        # Single existing category
+        final_category = json.dumps([category])
+    else:
+        # Default category if none provided
+        final_category = json.dumps(["Uncategorized"])
+
+    # Create dish object
+    db_dish = Dish(
+        hotel_id=hotel_id,
+        name=name,
+        description=description,
+        category=final_category,
+        price=price,
+        quantity=quantity,
+        discount=discount,
+        is_offer=is_offer,
+        is_special=is_special,
+        is_vegetarian=is_vegetarian,
+    )
+
+    # Save dish to database
+    db.add(db_dish)
+    db.commit()
+    db.refresh(db_dish)
+
+    # Handle image upload if provided
+    if image:
+        # Get hotel info for organizing images
+        from ..database import Hotel
+        hotel = db.query(Hotel).filter(Hotel.id == hotel_id).first()
+        hotel_name_for_path = hotel.hotel_name if hotel else f"hotel_{hotel_id}"
+
+        # Create directory structure: app/static/images/dishes/{hotel_name}
+        hotel_images_dir = f"app/static/images/dishes/{hotel_name_for_path}"
+        os.makedirs(hotel_images_dir, exist_ok=True)
+
+        # Save image with hotel-specific path
+        image_path = f"{hotel_images_dir}/{db_dish.id}_{image.filename}"
+        with open(image_path, "wb") as buffer:
+            shutil.copyfileobj(image.file, buffer)
+
+        # Update dish with image path (URL path for serving)
+        db_dish.image_path = f"/static/images/dishes/{hotel_name_for_path}/{db_dish.id}_{image.filename}"
+        db.commit()
+        db.refresh(db_dish)
+
+    return db_dish
+
+
+# Update dish
+@router.put("/api/dishes/{dish_id}", response_model=DishModel)
+async def update_dish(
+    dish_id: int,
+    request: Request,
+    name: Optional[str] = Form(None),
+    description: Optional[str] = Form(None),
+    category: Optional[str] = Form(None),
+    new_category: Optional[str] = Form(None),  # New field for custom category
+    categories: Optional[str] = Form(None),  # JSON array of multiple categories
+    price: Optional[float] = Form(None),
+    quantity: Optional[int] = Form(None),
+    discount: Optional[float] = Form(None),  # Discount amount (percentage)
+    is_offer: Optional[int] = Form(None),  # Whether this dish is part of offers
+    is_special: Optional[int] = Form(None),  # Whether this dish is today's special
+    is_vegetarian: Optional[int] = Form(None),  # 1 = vegetarian, 0 = non-vegetarian
+    image: Optional[UploadFile] = File(None),
+    db: Session = Depends(get_session_database),
+):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Get existing dish for this hotel
+    db_dish = db.query(Dish).filter(
+        Dish.hotel_id == hotel_id,
+        Dish.id == dish_id
+    ).first()
+    if db_dish is None:
+        raise HTTPException(status_code=404, detail="Dish not found")
+
+    # Update fields if provided
+    if name:
+        db_dish.name = name
+    if description:
+        db_dish.description = description
+
+    # Handle categories - support both single and multiple categories
+    import json
+    if categories:
+        # Multiple categories provided as JSON array
+        try:
+            category_list = json.loads(categories)
+            db_dish.category = json.dumps(category_list)
+        except json.JSONDecodeError:
+            db_dish.category = json.dumps([categories])
+    elif new_category:  # Use new category if provided
+        db_dish.category = json.dumps([new_category])
+    elif category:
+        db_dish.category = json.dumps([category])
+
+    if price:
+        db_dish.price = price
+    if quantity is not None:  # Allow 0 quantity
+        db_dish.quantity = quantity
+    if discount is not None:
+        db_dish.discount = discount
+    if is_offer is not None:
+        db_dish.is_offer = is_offer
+    if is_special is not None:
+        db_dish.is_special = is_special
+    if is_vegetarian is not None:
+        db_dish.is_vegetarian = is_vegetarian
+
+    # Handle image upload if provided
+    if image:
+        # Get current database name for organizing images
+        session_id = get_session_id(request)
+        current_db = get_session_current_database(session_id)
+
+        # Create directory structure: app/static/images/dishes/{db_name}
+        db_images_dir = f"app/static/images/dishes/{current_db}"
+        os.makedirs(db_images_dir, exist_ok=True)
+
+        # Save image with database-specific path
+        image_path = f"{db_images_dir}/{db_dish.id}_{image.filename}"
+        with open(image_path, "wb") as buffer:
+            shutil.copyfileobj(image.file, buffer)
+
+        # Update dish with image path (URL path for serving)
+        db_dish.image_path = f"/static/images/dishes/{current_db}/{db_dish.id}_{image.filename}"
+
+    # Update timestamp
+    db_dish.updated_at = datetime.now(timezone.utc)
+
+    # Save changes
+    db.commit()
+    db.refresh(db_dish)
+
+    return db_dish
+
+
+# Soft delete dish (set visibility to 0)
+@router.delete("/api/dishes/{dish_id}")
+def delete_dish(dish_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    db_dish = db.query(Dish).filter(
+        Dish.hotel_id == hotel_id,
+        Dish.id == dish_id,
+        Dish.visibility == 1
+    ).first()
+    if db_dish is None:
+        raise HTTPException(status_code=404, detail="Dish not found")
+
+    # Soft delete: set visibility to 0 instead of actually deleting
+    db_dish.visibility = 0
+    db_dish.updated_at = datetime.now(timezone.utc)
+    db.commit()
+
+    return {"message": "Dish deleted successfully"}
+
+
+# Get order statistics
+@router.get("/stats/orders")
+def get_order_stats(request: Request, db: Session = Depends(get_session_database)):
+    from sqlalchemy import func, and_
+
+    # Get today's date range (start and end of today in UTC)
+    today_start = datetime.now(timezone.utc).replace(hour=0, minute=0, second=0, microsecond=0)
+    today_end = datetime.now(timezone.utc).replace(hour=23, minute=59, second=59, microsecond=999999)
+
+    # Overall statistics
+    total_orders = db.query(Order).count()
+    pending_orders = db.query(Order).filter(Order.status == "pending").count()
+    completed_orders = db.query(Order).filter(Order.status == "completed").count()
+    payment_requested = (
+        db.query(Order).filter(Order.status == "payment_requested").count()
+    )
+    paid_orders = db.query(Order).filter(Order.status == "paid").count()
+
+    # Today's statistics
+    total_orders_today = db.query(Order).filter(
+        and_(Order.created_at >= today_start, Order.created_at <= today_end)
+    ).count()
+
+    pending_orders_today = db.query(Order).filter(
+        and_(
+            Order.status == "pending",
+            Order.created_at >= today_start,
+            Order.created_at <= today_end
+        )
+    ).count()
+
+    completed_orders_today = db.query(Order).filter(
+        and_(
+            Order.status == "completed",
+            Order.created_at >= today_start,
+            Order.created_at <= today_end
+        )
+    ).count()
+
+    paid_orders_today = db.query(Order).filter(
+        and_(
+            Order.status == "paid",
+            Order.created_at >= today_start,
+            Order.created_at <= today_end
+        )
+    ).count()
+
+    # Calculate today's revenue from paid orders
+    revenue_today_query = (
+        db.query(
+            func.sum(Dish.price * OrderItem.quantity).label("revenue_today")
+        )
+        .join(OrderItem, Dish.id == OrderItem.dish_id)
+        .join(Order, OrderItem.order_id == Order.id)
+        .filter(Order.status == "paid")
+        .filter(
+            and_(
+                Order.created_at >= today_start,
+                Order.created_at <= today_end
+            )
+        )
+    )
+
+    revenue_today_result = revenue_today_query.first()
+    revenue_today = revenue_today_result.revenue_today if revenue_today_result.revenue_today else 0
+
+    return {
+        "total_orders": total_orders,
+        "pending_orders": pending_orders,
+        "completed_orders": completed_orders,
+        "payment_requested": payment_requested,
+        "paid_orders": paid_orders,
+        "total_orders_today": total_orders_today,
+        "pending_orders_today": pending_orders_today,
+        "completed_orders_today": completed_orders_today,
+        "paid_orders_today": paid_orders_today,
+        "revenue_today": round(revenue_today, 2),
+    }
+
+
+# Mark order as paid
+@router.put("/orders/{order_id}/paid")
+def mark_order_paid(order_id: int, request: Request, db: Session = Depends(get_session_database)):
+    db_order = db.query(Order).filter(Order.id == order_id).first()
+    if db_order is None:
+        raise HTTPException(status_code=404, detail="Order not found")
+
+    # Allow marking as paid from any status
+    db_order.status = "paid"
+    db_order.updated_at = datetime.now(timezone.utc)
+
+    db.commit()
+
+    return {"message": "Order marked as paid"}
+
+
+# Generate bill PDF for a single order
+@router.get("/orders/{order_id}/bill")
+def generate_bill(order_id: int, request: Request, db: Session = Depends(get_session_database)):
+    # Get order with all details
+    db_order = db.query(Order).filter(Order.id == order_id).first()
+    if db_order is None:
+        raise HTTPException(status_code=404, detail="Order not found")
+
+    # Load person information if available
+    if db_order.person_id:
+        person = db.query(Person).filter(Person.id == db_order.person_id).first()
+        if person:
+            db_order.person_name = person.username
+
+    # Load dish information for each order item
+    for item in db_order.items:
+        if not hasattr(item, "dish") or item.dish is None:
+            dish = db.query(Dish).filter(Dish.id == item.dish_id).first()
+            if dish:
+                item.dish = dish
+
+    # Get hotel ID from request
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Get hotel settings for this specific hotel
+    settings = db.query(Settings).filter(Settings.hotel_id == hotel_id).first()
+    if not settings:
+        # Create default settings if none exist for this hotel
+        settings = Settings(
+            hotel_id=hotel_id,
+            hotel_name="Tabble Hotel",
+            address="123 Main Street, City",
+            contact_number="+1 123-456-7890",
+            email="[email protected]",
+        )
+        db.add(settings)
+        db.commit()
+        db.refresh(settings)
+
+    # Generate PDF
+    pdf_buffer = generate_bill_pdf(db_order, settings)
+
+    # Return PDF as a downloadable file
+    filename = f"bill_order_{order_id}_{datetime.now().strftime('%Y%m%d%H%M%S')}.pdf"
+
+    return StreamingResponse(
+        pdf_buffer,
+        media_type="application/pdf",
+        headers={"Content-Disposition": f"attachment; filename={filename}"}
+    )
+
+
+# Generate bill PDF for multiple orders
+@router.post("/orders/multi-bill")
+def generate_multi_bill(order_ids: List[int], request: Request, db: Session = Depends(get_session_database)):
+    if not order_ids:
+        raise HTTPException(status_code=400, detail="No order IDs provided")
+
+    orders = []
+
+    # Get all orders with details
+    for order_id in order_ids:
+        db_order = db.query(Order).filter(Order.id == order_id).first()
+        if db_order is None:
+            raise HTTPException(status_code=404, detail=f"Order {order_id} not found")
+
+        # Load person information if available
+        if db_order.person_id:
+            person = db.query(Person).filter(Person.id == db_order.person_id).first()
+            if person:
+                db_order.person_name = person.username
+
+        # Load dish information for each order item
+        for item in db_order.items:
+            if not hasattr(item, "dish") or item.dish is None:
+                dish = db.query(Dish).filter(Dish.id == item.dish_id).first()
+                if dish:
+                    item.dish = dish
+
+        orders.append(db_order)
+
+    # Get hotel ID from request
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Get hotel settings for this specific hotel
+    settings = db.query(Settings).filter(Settings.hotel_id == hotel_id).first()
+    if not settings:
+        # Create default settings if none exist for this hotel
+        settings = Settings(
+            hotel_id=hotel_id,
+            hotel_name="Tabble Hotel",
+            address="123 Main Street, City",
+            contact_number="+1 123-456-7890",
+            email="[email protected]",
+        )
+        db.add(settings)
+        db.commit()
+        db.refresh(settings)
+
+    # Generate PDF for multiple orders
+    pdf_buffer = generate_multi_order_bill_pdf(orders, settings)
+
+    # Create a filename with all order IDs
+    order_ids_str = "-".join([str(order_id) for order_id in order_ids])
+    filename = f"bill_orders_{order_ids_str}_{datetime.now().strftime('%Y%m%d%H%M%S')}.pdf"
+
+    return StreamingResponse(
+        pdf_buffer,
+        media_type="application/pdf",
+        headers={"Content-Disposition": f"attachment; filename={filename}"}
+    )
+
+
+# Merge two orders
+@router.post("/orders/merge")
+def merge_orders(source_order_id: int, target_order_id: int, request: Request, db: Session = Depends(get_session_database)):
+    # Get both orders
+    source_order = db.query(Order).filter(Order.id == source_order_id).first()
+    target_order = db.query(Order).filter(Order.id == target_order_id).first()
+
+    if not source_order:
+        raise HTTPException(status_code=404, detail=f"Source order {source_order_id} not found")
+
+    if not target_order:
+        raise HTTPException(status_code=404, detail=f"Target order {target_order_id} not found")
+
+    # Check if both orders are completed or paid
+    valid_statuses = ["completed", "paid"]
+    if source_order.status not in valid_statuses:
+        raise HTTPException(status_code=400, detail=f"Source order must be completed or paid, current status: {source_order.status}")
+
+    if target_order.status not in valid_statuses:
+        raise HTTPException(status_code=400, detail=f"Target order must be completed or paid, current status: {target_order.status}")
+
+    # Move all items from source order to target order
+    for item in source_order.items:
+        # Update the order_id to point to the target order
+        item.order_id = target_order.id
+
+    # Update the target order's updated_at timestamp
+    target_order.updated_at = datetime.now(timezone.utc)
+
+    # Delete the source order (but keep its items which now belong to the target order)
+    db.delete(source_order)
+
+    # Commit changes
+    db.commit()
+
+    # Refresh the target order to include the new items
+    db.refresh(target_order)
+
+    return {"message": f"Orders merged successfully. Items from order #{source_order_id} have been moved to order #{target_order_id}"}
+
+
+# Get completed orders for billing (paid orders)
+@router.get("/orders/completed-for-billing", response_model=List[OrderModel])
+def get_completed_orders_for_billing(request: Request, db: Session = Depends(get_session_database)):
+    # Get paid orders ordered by most recent first
+    orders = db.query(Order).filter(Order.status == "paid").order_by(Order.created_at.desc()).all()
+
+    # Load person information for each order
+    for order in orders:
+        if order.person_id:
+            person = db.query(Person).filter(Person.id == order.person_id).first()
+            if person:
+                # Add person information to the order
+                order.person_name = person.username
+                order.visit_count = person.visit_count
+
+        # Load dish information for each order item
+        for item in order.items:
+            if not hasattr(item, "dish") or item.dish is None:
+                dish = db.query(Dish).filter(Dish.id == item.dish_id).first()
+                if dish:
+                    item.dish = dish
+
+    return orders

app/routers/analytics.py

@@ -0,0 +1,573 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from sqlalchemy.orm import Session
+from sqlalchemy import func, desc, extract
+from typing import List, Dict, Any
+from datetime import datetime, timedelta, timezone
+import calendar
+
+from ..database import get_db, Dish, Order, OrderItem, Person, Table, Feedback, get_session_db
+from ..models.dish import Dish as DishModel
+from ..models.order import Order as OrderModel
+from ..models.user import Person as PersonModel
+from ..models.feedback import Feedback as FeedbackModel
+from ..middleware import get_session_id
+
+router = APIRouter(
+    prefix="/analytics",
+    tags=["analytics"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+# Dependency to get session-aware database
+def get_session_database(request: Request):
+    session_id = get_session_id(request)
+    return next(get_session_db(session_id))
+
+
+# Get overall dashboard statistics
+@router.get("/dashboard")
+def get_dashboard_stats(
+    request: Request,
+    start_date: str = None,
+    end_date: str = None,
+    db: Session = Depends(get_session_database)
+):
+    # Parse date strings to datetime objects if provided
+    start_datetime = None
+    end_datetime = None
+
+    if start_date:
+        try:
+            start_datetime = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid start_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+
+    if end_date:
+        try:
+            end_datetime = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid end_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+
+    # Base query for orders
+    orders_query = db.query(Order)
+
+    # Apply date filters if provided
+    if start_datetime:
+        orders_query = orders_query.filter(Order.created_at >= start_datetime)
+
+    if end_datetime:
+        orders_query = orders_query.filter(Order.created_at <= end_datetime)
+
+    # Total sales
+    total_sales_query = (
+        db.query(
+            func.sum(Dish.price * OrderItem.quantity).label("total_sales")
+        )
+        .join(OrderItem, Dish.id == OrderItem.dish_id)
+        .join(Order, OrderItem.order_id == Order.id)
+        .filter(Order.status == "paid")
+    )
+
+    # Apply date filters to sales query
+    if start_datetime:
+        total_sales_query = total_sales_query.filter(Order.created_at >= start_datetime)
+
+    if end_datetime:
+        total_sales_query = total_sales_query.filter(Order.created_at <= end_datetime)
+
+    total_sales_result = total_sales_query.first()
+    total_sales = total_sales_result.total_sales if total_sales_result.total_sales else 0
+
+    # Total customers (only count those who placed orders in the date range)
+    if start_datetime or end_datetime:
+        # Get unique person_ids from filtered orders
+        person_subquery = orders_query.with_entities(Order.person_id).distinct().subquery()
+        total_customers = db.query(Person).filter(Person.id.in_(person_subquery)).count()
+    else:
+        total_customers = db.query(Person).count()
+
+    # Total orders
+    total_orders = orders_query.count()
+
+    # Total dishes
+    total_dishes = db.query(Dish).count()
+
+    # Average order value
+    avg_order_value_query = (
+        db.query(
+            func.avg(
+                db.query(func.sum(Dish.price * OrderItem.quantity))
+                .join(OrderItem, Dish.id == OrderItem.dish_id)
+                .filter(OrderItem.order_id == Order.id)
+                .scalar_subquery()
+            ).label("avg_order_value")
+        )
+        .filter(Order.status == "paid")
+    )
+
+    # Apply date filters to avg order value query
+    if start_datetime:
+        avg_order_value_query = avg_order_value_query.filter(Order.created_at >= start_datetime)
+
+    if end_datetime:
+        avg_order_value_query = avg_order_value_query.filter(Order.created_at <= end_datetime)
+
+    avg_order_value_result = avg_order_value_query.first()
+    avg_order_value = avg_order_value_result.avg_order_value if avg_order_value_result.avg_order_value else 0
+
+    # Return all stats
+    return {
+        "total_sales": round(total_sales, 2),
+        "total_customers": total_customers,
+        "total_orders": total_orders,
+        "total_dishes": total_dishes,
+        "avg_order_value": round(avg_order_value, 2),
+        "date_range": {
+            "start_date": start_date,
+            "end_date": end_date
+        }
+    }
+
+
+# Get top customers by order count
+@router.get("/top-customers")
+def get_top_customers(request: Request, limit: int = 10, db: Session = Depends(get_session_database)):
+    # Get customers with most orders
+    top_customers_by_orders = (
+        db.query(
+            Person.id,
+            Person.username,
+            Person.visit_count,
+            Person.last_visit,
+            func.count(Order.id).label("order_count"),
+            func.sum(
+                db.query(func.sum(Dish.price * OrderItem.quantity))
+                .join(OrderItem, Dish.id == OrderItem.dish_id)
+                .filter(OrderItem.order_id == Order.id)
+                .scalar_subquery()
+            ).label("total_spent"),
+        )
+        .join(Order, Person.id == Order.person_id)
+        .group_by(Person.id)
+        .order_by(desc("order_count"))
+        .limit(limit)
+        .all()
+    )
+
+    # Format the results
+    result = []
+    for customer in top_customers_by_orders:
+        result.append({
+            "id": customer.id,
+            "username": customer.username,
+            "visit_count": customer.visit_count,
+            "last_visit": customer.last_visit,
+            "order_count": customer.order_count,
+            "total_spent": round(customer.total_spent, 2) if customer.total_spent else 0,
+            "avg_order_value": round(customer.total_spent / customer.order_count, 2) if customer.total_spent else 0,
+        })
+
+    return result
+
+
+# Get top selling dishes
+@router.get("/top-dishes")
+def get_top_dishes(request: Request, limit: int = 10, db: Session = Depends(get_session_database)):
+    # Get dishes with most orders
+    top_dishes = (
+        db.query(
+            Dish.id,
+            Dish.name,
+            Dish.category,
+            Dish.price,
+            func.sum(OrderItem.quantity).label("total_ordered"),
+            func.sum(Dish.price * OrderItem.quantity).label("total_revenue"),
+        )
+        .join(OrderItem, Dish.id == OrderItem.dish_id)
+        .join(Order, OrderItem.order_id == Order.id)
+        .filter(Order.status == "paid")
+        .group_by(Dish.id)
+        .order_by(desc("total_ordered"))
+        .limit(limit)
+        .all()
+    )
+
+    # Format the results
+    result = []
+    for dish in top_dishes:
+        result.append({
+            "id": dish.id,
+            "name": dish.name,
+            "category": dish.category,
+            "price": dish.price,
+            "total_ordered": dish.total_ordered,
+            "total_revenue": round(dish.total_revenue, 2),
+        })
+
+    return result
+
+
+# Get sales by category
+@router.get("/sales-by-category")
+def get_sales_by_category(request: Request, db: Session = Depends(get_session_database)):
+    # Get sales by category
+    sales_by_category = (
+        db.query(
+            Dish.category,
+            func.sum(OrderItem.quantity).label("total_ordered"),
+            func.sum(Dish.price * OrderItem.quantity).label("total_revenue"),
+        )
+        .join(OrderItem, Dish.id == OrderItem.dish_id)
+        .join(Order, OrderItem.order_id == Order.id)
+        .filter(Order.status == "paid")
+        .group_by(Dish.category)
+        .order_by(desc("total_revenue"))
+        .all()
+    )
+
+    # Format the results
+    result = []
+    for category in sales_by_category:
+        result.append({
+            "category": category.category,
+            "total_ordered": category.total_ordered,
+            "total_revenue": round(category.total_revenue, 2),
+        })
+
+    return result
+
+
+# Get sales over time (daily for the last 30 days)
+@router.get("/sales-over-time")
+def get_sales_over_time(request: Request, days: int = 30, db: Session = Depends(get_session_database)):
+    # Calculate the date range
+    end_date = datetime.now(timezone.utc)
+    start_date = end_date - timedelta(days=days)
+
+    # Get sales by day
+    sales_by_day = (
+        db.query(
+            func.date(Order.created_at).label("date"),
+            func.count(Order.id).label("order_count"),
+            func.sum(
+                db.query(func.sum(Dish.price * OrderItem.quantity))
+                .join(OrderItem, Dish.id == OrderItem.dish_id)
+                .filter(OrderItem.order_id == Order.id)
+                .scalar_subquery()
+            ).label("total_sales"),
+        )
+        .filter(Order.status == "paid")
+        .filter(Order.created_at >= start_date)
+        .filter(Order.created_at <= end_date)
+        .group_by(func.date(Order.created_at))
+        .order_by(func.date(Order.created_at))
+        .all()
+    )
+
+    # Create a dictionary with all dates in the range
+    date_range = {}
+    current_date = start_date
+    while current_date <= end_date:
+        date_str = current_date.strftime("%Y-%m-%d")
+        date_range[date_str] = {"order_count": 0, "total_sales": 0}
+        current_date += timedelta(days=1)
+
+    # Fill in the actual data
+    for day in sales_by_day:
+        date_str = day.date.strftime("%Y-%m-%d") if isinstance(day.date, datetime) else day.date
+        date_range[date_str] = {
+            "order_count": day.order_count,
+            "total_sales": round(day.total_sales, 2) if day.total_sales else 0,
+        }
+
+    # Convert to list format
+    result = []
+    for date_str, data in date_range.items():
+        result.append({
+            "date": date_str,
+            "order_count": data["order_count"],
+            "total_sales": data["total_sales"],
+        })
+
+    return result
+
+
+# Get chef performance metrics
+@router.get("/chef-performance")
+def get_chef_performance(request: Request, days: int = 30, db: Session = Depends(get_session_database)):
+    # Calculate the date range
+    end_date = datetime.now(timezone.utc)
+    start_date = end_date - timedelta(days=days)
+
+    # Get completed orders count and average time to complete
+    completed_orders = (
+        db.query(Order)
+        .filter(Order.status.in_(["completed", "paid"]))
+        .filter(Order.created_at >= start_date)
+        .filter(Order.created_at <= end_date)
+        .all()
+    )
+
+    total_completed = len(completed_orders)
+
+    # Calculate average items per order
+    avg_items_per_order_query = (
+        db.query(
+            func.avg(
+                db.query(func.count(OrderItem.id))
+                .filter(OrderItem.order_id == Order.id)
+                .scalar_subquery()
+            ).label("avg_items")
+        )
+        .filter(Order.status.in_(["completed", "paid"]))
+        .filter(Order.created_at >= start_date)
+        .filter(Order.created_at <= end_date)
+        .first()
+    )
+
+    avg_items_per_order = avg_items_per_order_query.avg_items if avg_items_per_order_query.avg_items else 0
+
+    # Get busiest day of week
+    busiest_day_query = (
+        db.query(
+            extract('dow', Order.created_at).label("day_of_week"),
+            func.count(Order.id).label("order_count")
+        )
+        .filter(Order.created_at >= start_date)
+        .filter(Order.created_at <= end_date)
+        .group_by(extract('dow', Order.created_at))
+        .order_by(desc("order_count"))
+        .first()
+    )
+
+    busiest_day = None
+    if busiest_day_query:
+        # Convert day number to day name (0 = Sunday, 1 = Monday, etc.)
+        day_names = list(calendar.day_name)
+        day_number = int(busiest_day_query.day_of_week)
+        busiest_day = day_names[day_number]
+
+    return {
+        "total_completed_orders": total_completed,
+        "avg_items_per_order": round(avg_items_per_order, 2),
+        "busiest_day": busiest_day,
+    }
+
+
+# Get table utilization statistics
+@router.get("/table-utilization")
+def get_table_utilization(request: Request, db: Session = Depends(get_session_database)):
+    # Get all tables
+    tables = db.query(Table).all()
+
+    # Get order count by table
+    table_orders = (
+        db.query(
+            Order.table_number,
+            func.count(Order.id).label("order_count"),
+            func.sum(
+                db.query(func.sum(Dish.price * OrderItem.quantity))
+                .join(OrderItem, Dish.id == OrderItem.dish_id)
+                .filter(OrderItem.order_id == Order.id)
+                .scalar_subquery()
+            ).label("total_revenue"),
+        )
+        .group_by(Order.table_number)
+        .all()
+    )
+
+    # Create a dictionary with all tables
+    table_stats = {}
+    for table in tables:
+        table_stats[table.table_number] = {
+            "table_number": table.table_number,
+            "is_occupied": table.is_occupied,
+            "order_count": 0,
+            "total_revenue": 0,
+        }
+
+    # Fill in the actual data
+    for table in table_orders:
+        if table.table_number in table_stats:
+            table_stats[table.table_number]["order_count"] = table.order_count
+            table_stats[table.table_number]["total_revenue"] = round(table.total_revenue, 2) if table.total_revenue else 0
+
+    # Convert to list format
+    result = list(table_stats.values())
+
+    # Sort by order count (descending)
+    result.sort(key=lambda x: x["order_count"], reverse=True)
+
+    return result
+
+
+# Get customer visit frequency analysis
+@router.get("/customer-frequency")
+def get_customer_frequency(
+    request: Request,
+    start_date: str = None,
+    end_date: str = None,
+    db: Session = Depends(get_session_database)
+):
+    # Parse date strings to datetime objects if provided
+    start_datetime = None
+    end_datetime = None
+
+    if start_date:
+        try:
+            start_datetime = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid start_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+
+    if end_date:
+        try:
+            end_datetime = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid end_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+
+    # Get visit count distribution
+    visit_counts_query = db.query(Person.visit_count)
+
+    # Apply date filters if provided
+    if start_datetime or end_datetime:
+        # Get person IDs who placed orders in the date range
+        orders_query = db.query(Order.person_id).distinct()
+
+        if start_datetime:
+            orders_query = orders_query.filter(Order.created_at >= start_datetime)
+
+        if end_datetime:
+            orders_query = orders_query.filter(Order.created_at <= end_datetime)
+
+        person_ids = [result[0] for result in orders_query.all() if result[0] is not None]
+        visit_counts_query = visit_counts_query.filter(Person.id.in_(person_ids))
+
+    visit_counts = visit_counts_query.all()
+
+    # Create frequency buckets
+    frequency_buckets = {
+        "1 visit": 0,
+        "2-3 visits": 0,
+        "4-5 visits": 0,
+        "6-10 visits": 0,
+        "11+ visits": 0,
+    }
+
+    # Fill the buckets
+    for visit in visit_counts:
+        count = visit.visit_count
+        if count == 1:
+            frequency_buckets["1 visit"] += 1
+        elif 2 <= count <= 3:
+            frequency_buckets["2-3 visits"] += 1
+        elif 4 <= count <= 5:
+            frequency_buckets["4-5 visits"] += 1
+        elif 6 <= count <= 10:
+            frequency_buckets["6-10 visits"] += 1
+        else:
+            frequency_buckets["11+ visits"] += 1
+
+    # Convert to list format
+    result = []
+    for bucket, count in frequency_buckets.items():
+        result.append({
+            "frequency": bucket,
+            "customer_count": count,
+        })
+
+    return result
+
+
+# Get feedback analysis
+@router.get("/feedback-analysis")
+def get_feedback_analysis(
+    request: Request,
+    start_date: str = None,
+    end_date: str = None,
+    db: Session = Depends(get_session_database)
+):
+    # Parse date strings to datetime objects if provided
+    start_datetime = None
+    end_datetime = None
+
+    if start_date:
+        try:
+            start_datetime = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid start_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+
+    if end_date:
+        try:
+            end_datetime = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid end_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+
+    # Base query for feedback
+    feedback_query = db.query(Feedback)
+
+    # Apply date filters if provided
+    if start_datetime:
+        feedback_query = feedback_query.filter(Feedback.created_at >= start_datetime)
+
+    if end_datetime:
+        feedback_query = feedback_query.filter(Feedback.created_at <= end_datetime)
+
+    # Get all feedback
+    all_feedback = feedback_query.all()
+
+    # Calculate average rating
+    total_ratings = len(all_feedback)
+    sum_ratings = sum(feedback.rating for feedback in all_feedback)
+    avg_rating = round(sum_ratings / total_ratings, 1) if total_ratings > 0 else 0
+
+    # Count ratings by score
+    rating_counts = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}
+    for feedback in all_feedback:
+        rating_counts[feedback.rating] = rating_counts.get(feedback.rating, 0) + 1
+
+    # Calculate rating percentages
+    rating_percentages = {}
+    for rating, count in rating_counts.items():
+        rating_percentages[rating] = round((count / total_ratings) * 100, 1) if total_ratings > 0 else 0
+
+    # Get recent feedback with comments
+    recent_feedback = (
+        db.query(Feedback, Person.username)
+        .outerjoin(Person, Feedback.person_id == Person.id)
+        .filter(Feedback.comment != None)
+        .filter(Feedback.comment != "")
+    )
+
+    # Apply date filters if provided
+    if start_datetime:
+        recent_feedback = recent_feedback.filter(Feedback.created_at >= start_datetime)
+
+    if end_datetime:
+        recent_feedback = recent_feedback.filter(Feedback.created_at <= end_datetime)
+
+    recent_feedback = recent_feedback.order_by(Feedback.created_at.desc()).limit(10).all()
+
+    # Format recent feedback
+    formatted_feedback = []
+    for feedback, username in recent_feedback:
+        formatted_feedback.append({
+            "id": feedback.id,
+            "rating": feedback.rating,
+            "comment": feedback.comment,
+            "username": username or "Anonymous",
+            "created_at": feedback.created_at.isoformat(),
+        })
+
+    # Return analysis
+    return {
+        "total_feedback": total_ratings,
+        "average_rating": avg_rating,
+        "rating_counts": rating_counts,
+        "rating_percentages": rating_percentages,
+        "recent_comments": formatted_feedback,
+        "date_range": {
+            "start_date": start_date,
+            "end_date": end_date
+        }
+    }

app/routers/chef.py

@@ -0,0 +1,93 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from sqlalchemy.orm import Session
+from typing import List
+from datetime import datetime, timezone
+
+from ..database import get_db, Dish, Order, OrderItem, get_session_db, get_hotel_id_from_request
+from ..models.dish import Dish as DishModel
+from ..models.order import Order as OrderModel
+from ..middleware import get_session_id
+
+router = APIRouter(
+    prefix="/chef",
+    tags=["chef"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+# Dependency to get session-aware database
+def get_session_database(request: Request):
+    session_id = get_session_id(request)
+    return next(get_session_db(session_id))
+
+# Add an API endpoint to get completed orders count
+@router.get("/api/completed-orders-count")
+def get_completed_orders_count(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    completed_orders = db.query(Order).filter(
+        Order.hotel_id == hotel_id,
+        Order.status == "completed"
+    ).count()
+    return {"count": completed_orders}
+
+# Get pending orders (orders that need to be accepted)
+@router.get("/orders/pending", response_model=List[OrderModel])
+def get_pending_orders(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    orders = db.query(Order).filter(
+        Order.hotel_id == hotel_id,
+        Order.status == "pending"
+    ).all()
+    return orders
+
+# Get accepted orders (orders that have been accepted but not completed)
+@router.get("/orders/accepted", response_model=List[OrderModel])
+def get_accepted_orders(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    orders = db.query(Order).filter(
+        Order.hotel_id == hotel_id,
+        Order.status == "accepted"
+    ).all()
+    return orders
+
+# Accept an order
+@router.put("/orders/{order_id}/accept")
+def accept_order(order_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    db_order = db.query(Order).filter(
+        Order.hotel_id == hotel_id,
+        Order.id == order_id
+    ).first()
+    if db_order is None:
+        raise HTTPException(status_code=404, detail="Order not found")
+
+    if db_order.status != "pending":
+        raise HTTPException(status_code=400, detail="Order is not in pending status")
+
+    db_order.status = "accepted"
+    db_order.updated_at = datetime.now(timezone.utc)
+
+    db.commit()
+
+    return {"message": "Order accepted successfully"}
+
+# Mark order as completed (only accepted orders can be completed)
+@router.put("/orders/{order_id}/complete")
+def complete_order(order_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    db_order = db.query(Order).filter(
+        Order.hotel_id == hotel_id,
+        Order.id == order_id
+    ).first()
+    if db_order is None:
+        raise HTTPException(status_code=404, detail="Order not found")
+
+    if db_order.status != "accepted":
+        raise HTTPException(status_code=400, detail="Order must be accepted before it can be completed")
+
+    db_order.status = "completed"
+    db_order.updated_at = datetime.now(timezone.utc)
+
+    db.commit()
+
+    return {"message": "Order marked as completed"}

app/routers/customer.py

@@ -0,0 +1,728 @@
+from fastapi import APIRouter, Depends, HTTPException, Request, status, Query
+from sqlalchemy.orm import Session
+from typing import List, Dict, Any
+import uuid
+from datetime import datetime, timezone, timedelta
+
+from ..database import get_db, Dish, Order, OrderItem, Person, get_session_db, get_hotel_id_from_request
+from ..models.dish import Dish as DishModel
+from ..models.order import OrderCreate, Order as OrderModel
+from ..models.user import (
+    PersonCreate,
+    PersonLogin,
+    Person as PersonModel,
+    PhoneAuthRequest,
+    PhoneVerifyRequest,
+    UsernameRequest
+)
+from ..services import firebase_auth
+from ..middleware import get_session_id
+
+# Demo mode configuration
+DEMO_MODE_ENABLED = True  # Set to False to disable demo mode
+DEMO_CUSTOMER_ID = 999999
+DEMO_CUSTOMER_USERNAME = "Demo Customer"
+DEMO_CUSTOMER_PHONE = "+91-DEMO-USER"
+
+router = APIRouter(
+    prefix="/customer",
+    tags=["customer"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+# Dependency to get session-aware database
+def get_session_database(request: Request):
+    session_id = get_session_id(request)
+    return next(get_session_db(session_id))
+
+
+# Demo mode endpoint - creates or returns demo customer
+@router.post("/api/demo-login", response_model=Dict[str, Any])
+def demo_login(request: Request, db: Session = Depends(get_session_database)):
+    """
+    Demo mode login - bypasses authentication and returns a demo customer
+    """
+    if not DEMO_MODE_ENABLED:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Demo mode is disabled"
+        )
+
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Check if demo customer already exists for this hotel
+    demo_user = db.query(Person).filter(
+        Person.hotel_id == hotel_id,
+        Person.id == DEMO_CUSTOMER_ID
+    ).first()
+
+    if not demo_user:
+        # Create demo customer
+        demo_user = Person(
+            id=DEMO_CUSTOMER_ID,
+            hotel_id=hotel_id,
+            username=DEMO_CUSTOMER_USERNAME,
+            password="demo",  # Demo password
+            phone_number=DEMO_CUSTOMER_PHONE,
+            visit_count=5,  # Show as returning customer
+            last_visit=datetime.now(timezone.utc),
+            created_at=datetime.now(timezone.utc)
+        )
+        db.add(demo_user)
+        db.commit()
+        db.refresh(demo_user)
+    else:
+        # Update last visit time
+        demo_user.last_visit = datetime.now(timezone.utc)
+        db.commit()
+
+    return {
+        "success": True,
+        "message": "Demo login successful",
+        "user_exists": True,
+        "user_id": demo_user.id,
+        "username": demo_user.username,
+        "demo_mode": True
+    }
+
+
+# Get all dishes for menu (only visible ones)
+@router.get("/api/menu", response_model=List[DishModel])
+def get_menu(request: Request, category: str = None, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    if category:
+        # Filter dishes that contain the specified category in their JSON array
+        import json
+        all_dishes = db.query(Dish).filter(
+            Dish.hotel_id == hotel_id,
+            Dish.visibility == 1
+        ).all()
+
+        filtered_dishes = []
+        for dish in all_dishes:
+            try:
+                dish_categories = json.loads(dish.category) if dish.category else []
+                if isinstance(dish_categories, list) and category in dish_categories:
+                    filtered_dishes.append(dish)
+                elif isinstance(dish_categories, str) and dish_categories == category:
+                    filtered_dishes.append(dish)
+            except (json.JSONDecodeError, TypeError):
+                # Backward compatibility: treat as single category
+                if dish.category == category:
+                    filtered_dishes.append(dish)
+
+        return filtered_dishes
+    else:
+        dishes = db.query(Dish).filter(
+            Dish.hotel_id == hotel_id,
+            Dish.visibility == 1
+        ).all()
+        return dishes
+
+
+# Get offer dishes (only visible ones)
+@router.get("/api/offers", response_model=List[DishModel])
+def get_offers(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    dishes = db.query(Dish).filter(
+        Dish.hotel_id == hotel_id,
+        Dish.is_offer == 1,
+        Dish.visibility == 1
+    ).all()
+    return dishes
+
+
+# Get special dishes (only visible ones)
+@router.get("/api/specials", response_model=List[DishModel])
+def get_specials(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    dishes = db.query(Dish).filter(
+        Dish.hotel_id == hotel_id,
+        Dish.is_special == 1,
+        Dish.visibility == 1
+    ).all()
+    return dishes
+
+
+# Get all dish categories (only from visible dishes)
+@router.get("/api/categories")
+def get_categories(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    categories = db.query(Dish.category).filter(
+        Dish.hotel_id == hotel_id,
+        Dish.visibility == 1
+    ).distinct().all()
+
+    # Parse JSON categories and flatten them
+    import json
+    unique_categories = set()
+
+    for category_tuple in categories:
+        category_str = category_tuple[0]
+        if category_str:
+            try:
+                # Try to parse as JSON array
+                category_list = json.loads(category_str)
+                if isinstance(category_list, list):
+                    unique_categories.update(category_list)
+                else:
+                    unique_categories.add(category_str)
+            except (json.JSONDecodeError, TypeError):
+                # If not JSON, treat as single category
+                unique_categories.add(category_str)
+
+    return sorted(list(unique_categories))
+
+
+# Register a new user or update existing user
+@router.post("/api/register", response_model=PersonModel)
+def register_user(user: PersonCreate, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Check if user already exists for this hotel
+    db_user = db.query(Person).filter(
+        Person.hotel_id == hotel_id,
+        Person.username == user.username
+    ).first()
+
+    if db_user:
+        # Update existing user's last visit time (visit count updated only when order is placed)
+        db_user.last_visit = datetime.now(timezone.utc)
+        db.commit()
+        db.refresh(db_user)
+        return db_user
+    else:
+        # Create new user (visit count will be incremented when first order is placed)
+        db_user = Person(
+            hotel_id=hotel_id,
+            username=user.username,
+            password=user.password,  # In a real app, you should hash this password
+            visit_count=0,
+            last_visit=datetime.now(timezone.utc),
+        )
+        db.add(db_user)
+        db.commit()
+        db.refresh(db_user)
+        return db_user
+
+
+# Login user
+@router.post("/api/login", response_model=Dict[str, Any])
+def login_user(user_data: PersonLogin, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Find user by username for this hotel
+    db_user = db.query(Person).filter(
+        Person.hotel_id == hotel_id,
+        Person.username == user_data.username
+    ).first()
+
+    if not db_user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid username"
+        )
+
+    # Check password (in a real app, you would verify hashed passwords)
+    if db_user.password != user_data.password:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid password"
+        )
+
+    # Update last visit time (but not visit count - that's only updated when order is placed)
+    db_user.last_visit = datetime.now(timezone.utc)
+    db.commit()
+
+    # Return user info and a success message
+    return {
+        "user": {
+            "id": db_user.id,
+            "username": db_user.username,
+            "visit_count": db_user.visit_count,
+        },
+        "message": "Login successful",
+    }
+
+
+# Create new order
+@router.post("/api/orders", response_model=OrderModel)
+def create_order(
+    order: OrderCreate, request: Request, person_id: int = Query(None), db: Session = Depends(get_session_database)
+):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # If person_id is not provided but we have a username/password, try to find or create the user
+    if not person_id and hasattr(order, "username") and hasattr(order, "password"):
+        # Check if user exists for this hotel
+        db_user = db.query(Person).filter(
+            Person.hotel_id == hotel_id,
+            Person.username == order.username
+        ).first()
+
+        if db_user:
+            # Update existing user's visit count
+            db_user.visit_count += 1
+            db_user.last_visit = datetime.now(timezone.utc)
+            db.commit()
+            person_id = db_user.id
+        else:
+            # Create new user (visit count starts at 1 since they're placing their first order)
+            db_user = Person(
+                hotel_id=hotel_id,
+                username=order.username,
+                password=order.password,
+                visit_count=1,
+                last_visit=datetime.now(timezone.utc),
+            )
+            db.add(db_user)
+            db.commit()
+            db.refresh(db_user)
+            person_id = db_user.id
+    elif person_id:
+        # If person_id is provided (normal flow), increment visit count for that user
+        db_user = db.query(Person).filter(
+            Person.hotel_id == hotel_id,
+            Person.id == person_id
+        ).first()
+        if db_user:
+            db_user.visit_count += 1
+            db_user.last_visit = datetime.now(timezone.utc)
+            db.commit()
+
+    # Create order
+    db_order = Order(
+        hotel_id=hotel_id,
+        table_number=order.table_number,
+        unique_id=order.unique_id,
+        person_id=person_id,  # Link order to person if provided
+        status="pending",
+    )
+    db.add(db_order)
+    db.commit()
+    db.refresh(db_order)
+
+    # Mark the table as occupied
+    from ..database import Table
+
+    db_table = db.query(Table).filter(
+        Table.hotel_id == hotel_id,
+        Table.table_number == order.table_number
+    ).first()
+    if db_table:
+        db_table.is_occupied = True
+        db_table.current_order_id = db_order.id
+        db.commit()
+
+    # Create order items
+    for item in order.items:
+        # Get the dish to include its information and verify it belongs to this hotel
+        dish = db.query(Dish).filter(
+            Dish.hotel_id == hotel_id,
+            Dish.id == item.dish_id
+        ).first()
+        if not dish:
+            continue  # Skip if dish doesn't exist or doesn't belong to this hotel
+
+        db_item = OrderItem(
+            hotel_id=hotel_id,
+            order_id=db_order.id,
+            dish_id=item.dish_id,
+            quantity=item.quantity,
+            price=dish.price,  # Store price at time of order
+            remarks=item.remarks,
+        )
+        db.add(db_item)
+
+    db.commit()
+    db.refresh(db_order)
+
+    return db_order
+
+
+# Get order status
+@router.get("/api/orders/{order_id}", response_model=OrderModel)
+def get_order(order_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Use joinedload to load the dish relationship for each order item
+    order = db.query(Order).filter(
+        Order.hotel_id == hotel_id,
+        Order.id == order_id
+    ).first()
+    if order is None:
+        raise HTTPException(status_code=404, detail="Order not found")
+
+    # Explicitly load dish information for each order item
+    for item in order.items:
+        if not hasattr(item, "dish") or item.dish is None:
+            dish = db.query(Dish).filter(
+                Dish.hotel_id == hotel_id,
+                Dish.id == item.dish_id
+            ).first()
+            if dish:
+                item.dish = dish
+
+    return order
+
+
+# Get orders by person_id
+@router.get("/api/person/{person_id}/orders", response_model=List[OrderModel])
+def get_person_orders(person_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Get all orders for a specific person in this hotel
+    orders = (
+        db.query(Order)
+        .filter(
+            Order.hotel_id == hotel_id,
+            Order.person_id == person_id
+        )
+        .order_by(Order.created_at.desc())
+        .all()
+    )
+
+    # Explicitly load dish information for each order item
+    for order in orders:
+        for item in order.items:
+            if not hasattr(item, "dish") or item.dish is None:
+                dish = db.query(Dish).filter(
+                    Dish.hotel_id == hotel_id,
+                    Dish.id == item.dish_id
+                ).first()
+                if dish:
+                    item.dish = dish
+
+    return orders
+
+
+# Request payment for order
+@router.put("/api/orders/{order_id}/payment")
+def request_payment(order_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    try:
+        # Check if order exists and is not already paid
+        db_order = db.query(Order).filter(
+            Order.hotel_id == hotel_id,
+            Order.id == order_id
+        ).first()
+        if db_order is None:
+            raise HTTPException(status_code=404, detail="Order not found")
+
+        # Check if order is already paid
+        if db_order.status == "paid":
+            return {"message": "Order is already paid"}
+
+        # Check if order is completed (ready for payment)
+        if db_order.status != "completed":
+            raise HTTPException(
+                status_code=400,
+                detail="Order must be completed before payment can be processed"
+            )
+
+        # Calculate order totals and apply discounts
+        from ..database import LoyaltyProgram, SelectionOffer, Person
+
+        # Calculate subtotal from order items
+        subtotal = 0
+        for item in db_order.items:
+            if item.dish:
+                subtotal += item.dish.price * item.quantity
+
+        # Initialize discount amounts
+        loyalty_discount_amount = 0
+        loyalty_discount_percentage = 0
+        selection_offer_discount_amount = 0
+
+        # Apply loyalty discount if customer is registered
+        if db_order.person_id:
+            person = db.query(Person).filter(Person.id == db_order.person_id).first()
+            if person:
+                # Get applicable loyalty discount
+                loyalty_tier = (
+                    db.query(LoyaltyProgram)
+                    .filter(
+                        LoyaltyProgram.hotel_id == hotel_id,
+                        LoyaltyProgram.visit_count == person.visit_count,
+                        LoyaltyProgram.is_active == True,
+                    )
+                    .first()
+                )
+
+                if loyalty_tier:
+                    loyalty_discount_percentage = loyalty_tier.discount_percentage
+                    loyalty_discount_amount = subtotal * (loyalty_discount_percentage / 100)
+
+        # Apply selection offer discount
+        selection_offer = (
+            db.query(SelectionOffer)
+            .filter(
+                SelectionOffer.hotel_id == hotel_id,
+                SelectionOffer.min_amount <= subtotal,
+                SelectionOffer.is_active == True,
+            )
+            .order_by(SelectionOffer.min_amount.desc())
+            .first()
+        )
+
+        if selection_offer:
+            selection_offer_discount_amount = selection_offer.discount_amount
+
+        # Calculate final total after discounts
+        final_total = subtotal - loyalty_discount_amount - selection_offer_discount_amount
+
+        # Ensure final total is not negative
+        final_total = max(0, final_total)
+
+        # Update order with calculated amounts
+        db_order.status = "paid"
+        db_order.subtotal_amount = subtotal
+        db_order.loyalty_discount_amount = loyalty_discount_amount
+        db_order.loyalty_discount_percentage = loyalty_discount_percentage
+        db_order.selection_offer_discount_amount = selection_offer_discount_amount
+        db_order.total_amount = final_total
+        db_order.updated_at = datetime.now(timezone.utc)
+
+        # Check if this is the last unpaid order for this table
+        from ..database import Table
+
+        # Get all orders for this table that are not paid
+        table_unpaid_orders = db.query(Order).filter(
+            Order.table_number == db_order.table_number,
+            Order.status != "paid",
+            Order.status != "cancelled"
+        ).all()
+
+        # If this is the only unpaid order, mark table as free
+        if len(table_unpaid_orders) == 1 and table_unpaid_orders[0].id == order_id:
+            db_table = db.query(Table).filter(Table.table_number == db_order.table_number).first()
+            if db_table:
+                db_table.is_occupied = False
+                db_table.current_order_id = None
+                db_table.updated_at = datetime.now(timezone.utc)
+
+        # Commit the transaction
+        db.commit()
+        db.refresh(db_order)
+
+        return {"message": "Payment completed successfully", "order_id": order_id}
+
+    except HTTPException:
+        # Re-raise HTTP exceptions
+        db.rollback()
+        raise
+    except Exception as e:
+        # Handle any other exceptions
+        db.rollback()
+        print(f"Error processing payment for order {order_id}: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing payment: {str(e)}"
+        )
+
+
+# Cancel order
+@router.put("/api/orders/{order_id}/cancel")
+def cancel_order(order_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    db_order = db.query(Order).filter(
+        Order.hotel_id == hotel_id,
+        Order.id == order_id
+    ).first()
+    if db_order is None:
+        raise HTTPException(status_code=404, detail="Order not found")
+
+    # Check if order is in pending status (not accepted or completed)
+    if db_order.status != "pending":
+        raise HTTPException(
+            status_code=400,
+            detail="Only pending orders can be cancelled. Orders that have been accepted by the chef cannot be cancelled."
+        )
+
+    # Update order status to cancelled
+    current_time = datetime.now(timezone.utc)
+    db_order.status = "cancelled"
+    db_order.updated_at = current_time
+
+    # Mark the table as free if this was the current order
+    from ..database import Table
+
+    db_table = db.query(Table).filter(Table.table_number == db_order.table_number).first()
+    if db_table and db_table.current_order_id == db_order.id:
+        db_table.is_occupied = False
+        db_table.current_order_id = None
+        db_table.updated_at = current_time
+
+    db.commit()
+
+    return {"message": "Order cancelled successfully"}
+
+
+# Get person details
+@router.get("/api/person/{person_id}", response_model=PersonModel)
+def get_person(person_id: int, request: Request, db: Session = Depends(get_session_database)):
+    person = db.query(Person).filter(Person.id == person_id).first()
+    if not person:
+        raise HTTPException(status_code=404, detail="Person not found")
+    return person
+
+
+# Phone authentication endpoints
+@router.post("/api/phone-auth", response_model=Dict[str, Any])
+def phone_auth(auth_request: PhoneAuthRequest, request: Request, db: Session = Depends(get_session_database)):
+    """
+    Initiate phone authentication by sending OTP
+    """
+    try:
+        # Validate phone number format
+        if not auth_request.phone_number.startswith("+91"):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Phone number must start with +91"
+            )
+
+        # Send OTP via Firebase
+        result = firebase_auth.verify_phone_number(auth_request.phone_number)
+
+        print(f"Phone auth initiated for: {auth_request.phone_number}, table: {auth_request.table_number}")
+
+        return {
+            "success": True,
+            "message": "Verification code sent successfully",
+            "session_info": result.get("sessionInfo", "firebase-verification-token")
+        }
+    except HTTPException as e:
+        print(f"HTTP Exception in phone_auth: {e.detail}")
+        raise e
+    except Exception as e:
+        print(f"Exception in phone_auth: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to send verification code: {str(e)}"
+        )
+
+
+@router.post("/api/verify-otp", response_model=Dict[str, Any])
+def verify_otp(verify_request: PhoneVerifyRequest, request: Request, db: Session = Depends(get_session_database)):
+    """
+    Verify OTP and authenticate user
+    """
+    try:
+        print(f"Verifying OTP for phone: {verify_request.phone_number}")
+
+        # Verify OTP via Firebase
+        # Note: The actual OTP verification is done on the client side with Firebase
+        # This is just a validation step
+        firebase_auth.verify_otp(
+            verify_request.phone_number,
+            verify_request.verification_code
+        )
+
+        # Check if user exists in database for this hotel
+        hotel_id = get_hotel_id_from_request(request)
+        user = db.query(Person).filter(
+            Person.hotel_id == hotel_id,
+            Person.phone_number == verify_request.phone_number
+        ).first()
+
+        if user:
+            print(f"Existing user found: {user.username}")
+            # Existing user - update last visit time (visit count updated only when order is placed)
+            user.last_visit = datetime.now(timezone.utc)
+            db.commit()
+            db.refresh(user)
+
+            return {
+                "success": True,
+                "message": "Authentication successful",
+                "user_exists": True,
+                "user_id": user.id,
+                "username": user.username
+            }
+        else:
+            print(f"New user with phone: {verify_request.phone_number}")
+            # New user - return flag to collect username
+            return {
+                "success": True,
+                "message": "Authentication successful, but user not found",
+                "user_exists": False
+            }
+
+    except HTTPException as e:
+        print(f"HTTP Exception in verify_otp: {e.detail}")
+        raise e
+    except Exception as e:
+        print(f"Exception in verify_otp: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to verify OTP: {str(e)}"
+        )
+
+
+@router.post("/api/register-phone-user", response_model=Dict[str, Any])
+def register_phone_user(user_request: UsernameRequest, request: Request, db: Session = Depends(get_session_database)):
+    """
+    Register a new user after phone authentication
+    """
+    try:
+        hotel_id = get_hotel_id_from_request(request)
+        print(f"Registering new user with phone: {user_request.phone_number}, username: {user_request.username}")
+
+        # Check if username already exists for this hotel
+        existing_user = db.query(Person).filter(
+            Person.hotel_id == hotel_id,
+            Person.username == user_request.username
+        ).first()
+        if existing_user:
+            print(f"Username already exists: {user_request.username}")
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Username already exists"
+            )
+
+        # Check if phone number already exists for this hotel
+        phone_user = db.query(Person).filter(
+            Person.hotel_id == hotel_id,
+            Person.phone_number == user_request.phone_number
+        ).first()
+        if phone_user:
+            print(f"Phone number already registered: {user_request.phone_number}")
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Phone number already registered"
+            )
+
+        # Create new user (visit count will be incremented when first order is placed)
+        new_user = Person(
+            hotel_id=hotel_id,
+            username=user_request.username,
+            password="",  # No password needed for phone auth
+            phone_number=user_request.phone_number,
+            visit_count=0,
+            last_visit=datetime.now(timezone.utc)
+        )
+
+        db.add(new_user)
+        db.commit()
+        db.refresh(new_user)
+
+        print(f"User registered successfully: {new_user.id}, {new_user.username}")
+
+        return {
+            "success": True,
+            "message": "User registered successfully",
+            "user_id": new_user.id,
+            "username": new_user.username
+        }
+
+    except HTTPException as e:
+        print(f"HTTP Exception in register_phone_user: {e.detail}")
+        raise e
+    except Exception as e:
+        print(f"Exception in register_phone_user: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to register user: {str(e)}"
+        )

app/routers/feedback.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, Depends, HTTPException, status, Request
+from sqlalchemy.orm import Session
+from typing import List
+from datetime import datetime, timezone
+
+from ..database import get_db, Feedback as FeedbackModel, Order, Person, get_session_db, get_hotel_id_from_request
+from ..models.feedback import Feedback, FeedbackCreate
+from ..middleware import get_session_id
+
+router = APIRouter(
+    prefix="/feedback",
+    tags=["feedback"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+# Dependency to get session-aware database
+def get_session_database(request: Request):
+    session_id = get_session_id(request)
+    return next(get_session_db(session_id))
+
+
+# Create new feedback
+@router.post("/", response_model=Feedback)
+def create_feedback(feedback: FeedbackCreate, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Check if order exists for this hotel
+    db_order = db.query(Order).filter(
+        Order.hotel_id == hotel_id,
+        Order.id == feedback.order_id
+    ).first()
+    if not db_order:
+        raise HTTPException(status_code=404, detail="Order not found")
+
+    # Check if person exists if person_id is provided
+    if feedback.person_id:
+        db_person = db.query(Person).filter(
+            Person.hotel_id == hotel_id,
+            Person.id == feedback.person_id
+        ).first()
+        if not db_person:
+            raise HTTPException(status_code=404, detail="Person not found")
+
+    # Create feedback
+    db_feedback = FeedbackModel(
+        hotel_id=hotel_id,
+        order_id=feedback.order_id,
+        person_id=feedback.person_id,
+        rating=feedback.rating,
+        comment=feedback.comment,
+        created_at=datetime.now(timezone.utc),
+    )
+    db.add(db_feedback)
+    db.commit()
+    db.refresh(db_feedback)
+    return db_feedback
+
+
+# Get all feedback
+@router.get("/", response_model=List[Feedback])
+def get_all_feedback(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    return db.query(FeedbackModel).filter(FeedbackModel.hotel_id == hotel_id).all()
+
+
+# Get feedback by order_id
+@router.get("/order/{order_id}", response_model=Feedback)
+def get_feedback_by_order(order_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    db_feedback = db.query(FeedbackModel).filter(
+        FeedbackModel.hotel_id == hotel_id,
+        FeedbackModel.order_id == order_id
+    ).first()
+    if not db_feedback:
+        raise HTTPException(status_code=404, detail="Feedback not found")
+    return db_feedback
+
+
+# Get feedback by person_id
+@router.get("/person/{person_id}", response_model=List[Feedback])
+def get_feedback_by_person(person_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    return db.query(FeedbackModel).filter(
+        FeedbackModel.hotel_id == hotel_id,
+        FeedbackModel.person_id == person_id
+    ).all()

app/routers/loyalty.py

@@ -0,0 +1,172 @@
+from fastapi import APIRouter, Depends, HTTPException, status, Request
+from sqlalchemy.orm import Session
+from typing import List
+from datetime import datetime, timezone
+
+from ..database import get_db, LoyaltyProgram as LoyaltyProgramModel, get_session_db, get_hotel_id_from_request
+from ..models.loyalty import LoyaltyProgram, LoyaltyProgramCreate, LoyaltyProgramUpdate
+from ..middleware import get_session_id
+
+router = APIRouter(
+    prefix="/loyalty",
+    tags=["loyalty"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+# Dependency to get session-aware database
+def get_session_database(request: Request):
+    session_id = get_session_id(request)
+    return next(get_session_db(session_id))
+
+
+# Get all loyalty program tiers
+@router.get("/", response_model=List[LoyaltyProgram])
+def get_all_loyalty_tiers(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    return db.query(LoyaltyProgramModel).filter(LoyaltyProgramModel.hotel_id == hotel_id).order_by(LoyaltyProgramModel.visit_count).all()
+
+
+# Get active loyalty program tiers
+@router.get("/active", response_model=List[LoyaltyProgram])
+def get_active_loyalty_tiers(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    return (
+        db.query(LoyaltyProgramModel)
+        .filter(
+            LoyaltyProgramModel.hotel_id == hotel_id,
+            LoyaltyProgramModel.is_active == True
+        )
+        .order_by(LoyaltyProgramModel.visit_count)
+        .all()
+    )
+
+
+# Get loyalty tier by ID
+@router.get("/{tier_id}", response_model=LoyaltyProgram)
+def get_loyalty_tier(tier_id: int, request: Request, db: Session = Depends(get_session_database)):
+    db_tier = (
+        db.query(LoyaltyProgramModel).filter(LoyaltyProgramModel.id == tier_id).first()
+    )
+    if not db_tier:
+        raise HTTPException(status_code=404, detail="Loyalty tier not found")
+    return db_tier
+
+
+# Create new loyalty tier
+@router.post("/", response_model=LoyaltyProgram)
+def create_loyalty_tier(tier: LoyaltyProgramCreate, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Check if a tier with this visit count already exists for this hotel
+    existing_tier = (
+        db.query(LoyaltyProgramModel)
+        .filter(
+            LoyaltyProgramModel.hotel_id == hotel_id,
+            LoyaltyProgramModel.visit_count == tier.visit_count
+        )
+        .first()
+    )
+    if existing_tier:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Loyalty tier with visit count {tier.visit_count} already exists",
+        )
+
+    # Create new tier
+    db_tier = LoyaltyProgramModel(
+        hotel_id=hotel_id,
+        visit_count=tier.visit_count,
+        discount_percentage=tier.discount_percentage,
+        is_active=tier.is_active,
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc),
+    )
+    db.add(db_tier)
+    db.commit()
+    db.refresh(db_tier)
+    return db_tier
+
+
+# Update loyalty tier
+@router.put("/{tier_id}", response_model=LoyaltyProgram)
+def update_loyalty_tier(
+    tier_id: int, tier_update: LoyaltyProgramUpdate, request: Request, db: Session = Depends(get_session_database)
+):
+    db_tier = (
+        db.query(LoyaltyProgramModel).filter(LoyaltyProgramModel.id == tier_id).first()
+    )
+    if not db_tier:
+        raise HTTPException(status_code=404, detail="Loyalty tier not found")
+
+    # Check if updating visit count and if it already exists
+    if (
+        tier_update.visit_count is not None
+        and tier_update.visit_count != db_tier.visit_count
+    ):
+        existing_tier = (
+            db.query(LoyaltyProgramModel)
+            .filter(
+                LoyaltyProgramModel.visit_count == tier_update.visit_count,
+                LoyaltyProgramModel.id != tier_id,
+            )
+            .first()
+        )
+        if existing_tier:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Loyalty tier with visit count {tier_update.visit_count} already exists",
+            )
+        db_tier.visit_count = tier_update.visit_count
+
+    # Update other fields if provided
+    if tier_update.discount_percentage is not None:
+        db_tier.discount_percentage = tier_update.discount_percentage
+    if tier_update.is_active is not None:
+        db_tier.is_active = tier_update.is_active
+
+    db_tier.updated_at = datetime.now(timezone.utc)
+    db.commit()
+    db.refresh(db_tier)
+    return db_tier
+
+
+# Delete loyalty tier
+@router.delete("/{tier_id}")
+def delete_loyalty_tier(tier_id: int, request: Request, db: Session = Depends(get_session_database)):
+    db_tier = (
+        db.query(LoyaltyProgramModel).filter(LoyaltyProgramModel.id == tier_id).first()
+    )
+    if not db_tier:
+        raise HTTPException(status_code=404, detail="Loyalty tier not found")
+
+    db.delete(db_tier)
+    db.commit()
+    return {"message": "Loyalty tier deleted successfully"}
+
+
+# Get applicable discount for a visit count
+@router.get("/discount/{visit_count}")
+def get_discount_for_visit_count(visit_count: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Find the tier that exactly matches the visit count for this hotel
+    applicable_tier = (
+        db.query(LoyaltyProgramModel)
+        .filter(
+            LoyaltyProgramModel.hotel_id == hotel_id,
+            LoyaltyProgramModel.visit_count == visit_count,
+            LoyaltyProgramModel.is_active == True,
+        )
+        .first()
+    )
+
+    if not applicable_tier:
+        return {"discount_percentage": 0, "message": "No applicable loyalty discount"}
+
+    return {
+        "discount_percentage": applicable_tier.discount_percentage,
+        "tier_id": applicable_tier.id,
+        "visit_count": applicable_tier.visit_count,
+        "message": f"Loyalty discount of {applicable_tier.discount_percentage}% applied for {visit_count} visits",
+    }

app/routers/selection_offer.py

@@ -0,0 +1,198 @@
+from fastapi import APIRouter, Depends, HTTPException, status, Request
+from sqlalchemy.orm import Session
+from typing import List
+from datetime import datetime, timezone
+
+from ..database import get_db, SelectionOffer as SelectionOfferModel, get_session_db, get_hotel_id_from_request
+from ..models.selection_offer import (
+    SelectionOffer,
+    SelectionOfferCreate,
+    SelectionOfferUpdate,
+)
+from ..middleware import get_session_id
+
+router = APIRouter(
+    prefix="/selection-offers",
+    tags=["selection-offers"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+# Dependency to get session-aware database
+def get_session_database(request: Request):
+    session_id = get_session_id(request)
+    return next(get_session_db(session_id))
+
+
+# Get all selection offers
+@router.get("/", response_model=List[SelectionOffer])
+def get_all_selection_offers(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    return db.query(SelectionOfferModel).filter(SelectionOfferModel.hotel_id == hotel_id).order_by(SelectionOfferModel.min_amount).all()
+
+
+# Get active selection offers
+@router.get("/active", response_model=List[SelectionOffer])
+def get_active_selection_offers(request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    return (
+        db.query(SelectionOfferModel)
+        .filter(
+            SelectionOfferModel.hotel_id == hotel_id,
+            SelectionOfferModel.is_active == True
+        )
+        .order_by(SelectionOfferModel.min_amount)
+        .all()
+    )
+
+
+# Get selection offer by ID
+@router.get("/{offer_id}", response_model=SelectionOffer)
+def get_selection_offer(offer_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+    db_offer = (
+        db.query(SelectionOfferModel).filter(
+            SelectionOfferModel.hotel_id == hotel_id,
+            SelectionOfferModel.id == offer_id
+        ).first()
+    )
+    if not db_offer:
+        raise HTTPException(status_code=404, detail="Selection offer not found")
+    return db_offer
+
+
+# Create new selection offer
+@router.post("/", response_model=SelectionOffer)
+def create_selection_offer(offer: SelectionOfferCreate, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Check if an offer with this min_amount already exists for this hotel
+    existing_offer = (
+        db.query(SelectionOfferModel)
+        .filter(
+            SelectionOfferModel.hotel_id == hotel_id,
+            SelectionOfferModel.min_amount == offer.min_amount
+        )
+        .first()
+    )
+    if existing_offer:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Selection offer with minimum amount {offer.min_amount} already exists",
+        )
+
+    # Create new offer
+    db_offer = SelectionOfferModel(
+        hotel_id=hotel_id,
+        min_amount=offer.min_amount,
+        discount_amount=offer.discount_amount,
+        is_active=offer.is_active,
+        description=offer.description,
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc),
+    )
+    db.add(db_offer)
+    db.commit()
+    db.refresh(db_offer)
+    return db_offer
+
+
+# Update selection offer
+@router.put("/{offer_id}", response_model=SelectionOffer)
+def update_selection_offer(
+    offer_id: int, offer_update: SelectionOfferUpdate, request: Request, db: Session = Depends(get_session_database)
+):
+    hotel_id = get_hotel_id_from_request(request)
+
+    db_offer = (
+        db.query(SelectionOfferModel).filter(
+            SelectionOfferModel.hotel_id == hotel_id,
+            SelectionOfferModel.id == offer_id
+        ).first()
+    )
+    if not db_offer:
+        raise HTTPException(status_code=404, detail="Selection offer not found")
+
+    # Check if updating min_amount and if it already exists for this hotel
+    if (
+        offer_update.min_amount is not None
+        and offer_update.min_amount != db_offer.min_amount
+    ):
+        existing_offer = (
+            db.query(SelectionOfferModel)
+            .filter(
+                SelectionOfferModel.hotel_id == hotel_id,
+                SelectionOfferModel.min_amount == offer_update.min_amount,
+                SelectionOfferModel.id != offer_id,
+            )
+            .first()
+        )
+        if existing_offer:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Selection offer with minimum amount {offer_update.min_amount} already exists",
+            )
+        db_offer.min_amount = offer_update.min_amount
+
+    # Update other fields if provided
+    if offer_update.discount_amount is not None:
+        db_offer.discount_amount = offer_update.discount_amount
+    if offer_update.is_active is not None:
+        db_offer.is_active = offer_update.is_active
+    if offer_update.description is not None:
+        db_offer.description = offer_update.description
+
+    db_offer.updated_at = datetime.now(timezone.utc)
+    db.commit()
+    db.refresh(db_offer)
+    return db_offer
+
+
+# Delete selection offer
+@router.delete("/{offer_id}")
+def delete_selection_offer(offer_id: int, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    db_offer = (
+        db.query(SelectionOfferModel).filter(
+            SelectionOfferModel.hotel_id == hotel_id,
+            SelectionOfferModel.id == offer_id
+        ).first()
+    )
+    if not db_offer:
+        raise HTTPException(status_code=404, detail="Selection offer not found")
+
+    db.delete(db_offer)
+    db.commit()
+    return {"message": "Selection offer deleted successfully"}
+
+
+# Get applicable discount for an order amount
+@router.get("/discount/{order_amount}")
+def get_discount_for_order_amount(order_amount: float, request: Request, db: Session = Depends(get_session_database)):
+    hotel_id = get_hotel_id_from_request(request)
+
+    # Find the highest tier that the order amount qualifies for this hotel
+    applicable_offer = (
+        db.query(SelectionOfferModel)
+        .filter(
+            SelectionOfferModel.hotel_id == hotel_id,
+            SelectionOfferModel.min_amount <= order_amount,
+            SelectionOfferModel.is_active == True,
+        )
+        .order_by(SelectionOfferModel.min_amount.desc())
+        .first()
+    )
+
+    if not applicable_offer:
+        return {
+            "discount_amount": 0,
+            "message": "No applicable selection offer discount",
+        }
+
+    return {
+        "discount_amount": applicable_offer.discount_amount,
+        "offer_id": applicable_offer.id,
+        "min_amount": applicable_offer.min_amount,
+        "message": f"Selection offer discount of ₹{applicable_offer.discount_amount} applied",
+    }

app/routers/settings.py

@@ -0,0 +1,207 @@
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Form, Request
+from sqlalchemy.orm import Session
+from typing import Optional, List
+import os
+import shutil
+import csv
+from datetime import datetime, timezone
+
+from ..database import (
+    get_db, Settings, Hotel, switch_database, get_current_database,
+    get_session_db, get_session_current_database, set_session_hotel_context,
+    get_session_hotel_id, authenticate_hotel_session
+)
+from ..models.settings import Settings as SettingsModel, SettingsUpdate
+from ..models.database_config import DatabaseEntry, DatabaseList, DatabaseSelectRequest, DatabaseSelectResponse
+from ..middleware import get_session_id
+
+router = APIRouter(
+    prefix="/settings",
+    tags=["settings"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+# Dependency to get session-aware database
+def get_session_database(request: Request):
+    session_id = get_session_id(request)
+    return next(get_session_db(session_id))
+
+
+# Get available hotels from hotels.csv
+@router.get("/hotels", response_model=DatabaseList)
+def get_hotels():
+    try:
+        hotels = []
+        with open("hotels.csv", "r") as file:
+            reader = csv.DictReader(file)
+            for row in reader:
+                hotels.append(DatabaseEntry(
+                    database_name=row["hotel_name"],  # Using hotel_name instead of hotel_database
+                    password=row["password"]
+                ))
+
+        # Return only hotel names, not passwords
+        return {"databases": [{"database_name": hotel.database_name, "password": "********"} for hotel in hotels]}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error reading hotel configuration: {str(e)}")
+
+
+# Legacy endpoint for backward compatibility
+@router.get("/databases", response_model=DatabaseList)
+def get_databases():
+    return get_hotels()
+
+
+# Get current hotel info
+@router.get("/current-hotel")
+def get_current_hotel(request: Request):
+    session_id = get_session_id(request)
+    hotel_id = get_session_hotel_id(session_id)
+    if hotel_id:
+        # Get hotel name from database
+        db = next(get_session_database(request))
+        hotel = db.query(Hotel).filter(Hotel.id == hotel_id).first()
+        if hotel:
+            return {"hotel_name": hotel.hotel_name, "hotel_id": hotel.id}
+    return {"hotel_name": None, "hotel_id": None}
+
+
+# Legacy endpoint for backward compatibility
+@router.get("/current-database")
+def get_current_db(request: Request):
+    session_id = get_session_id(request)
+    return {"database_name": get_session_current_database(session_id)}
+
+
+# Switch hotel
+@router.post("/switch-hotel", response_model=DatabaseSelectResponse)
+def select_hotel(request_data: DatabaseSelectRequest, request: Request):
+    try:
+        session_id = get_session_id(request)
+
+        # Authenticate hotel using hotel_name and password
+        hotel_id = authenticate_hotel_session(request_data.database_name, request_data.password)
+
+        if hotel_id:
+            # Set hotel context for this session
+            success = set_session_hotel_context(session_id, hotel_id)
+            if success:
+                return {
+                    "success": True,
+                    "message": f"Successfully switched to hotel: {request_data.database_name}"
+                }
+            else:
+                raise HTTPException(status_code=500, detail="Failed to set hotel context")
+        else:
+            raise HTTPException(status_code=401, detail="Invalid hotel credentials")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error switching hotel: {str(e)}")
+
+
+# Legacy endpoint for backward compatibility
+@router.post("/switch-database", response_model=DatabaseSelectResponse)
+def select_database(request_data: DatabaseSelectRequest, request: Request):
+    return select_hotel(request_data, request)
+
+
+# Get hotel settings
+@router.get("/", response_model=SettingsModel)
+def get_settings(request: Request, db: Session = Depends(get_session_database)):
+    session_id = get_session_id(request)
+    hotel_id = get_session_hotel_id(session_id)
+
+    if not hotel_id:
+        raise HTTPException(status_code=400, detail="No hotel context set")
+
+    # Get settings for the current hotel
+    settings = db.query(Settings).filter(Settings.hotel_id == hotel_id).first()
+
+    if not settings:
+        # Get hotel info for default settings
+        hotel = db.query(Hotel).filter(Hotel.id == hotel_id).first()
+        if not hotel:
+            raise HTTPException(status_code=404, detail="Hotel not found")
+
+        # Create default settings for this hotel
+        settings = Settings(
+            hotel_id=hotel_id,
+            hotel_name=hotel.hotel_name,
+            address="123 Main Street, City",
+            contact_number="+1 123-456-7890",
+            email="[email protected]",
+        )
+        db.add(settings)
+        db.commit()
+        db.refresh(settings)
+
+    return settings
+
+
+# Update hotel settings
+@router.put("/", response_model=SettingsModel)
+async def update_settings(
+    request: Request,
+    hotel_name: str = Form(...),
+    address: Optional[str] = Form(None),
+    contact_number: Optional[str] = Form(None),
+    email: Optional[str] = Form(None),
+    tax_id: Optional[str] = Form(None),
+    logo: Optional[UploadFile] = File(None),
+    db: Session = Depends(get_session_database)
+):
+    session_id = get_session_id(request)
+    hotel_id = get_session_hotel_id(session_id)
+
+    if not hotel_id:
+        raise HTTPException(status_code=400, detail="No hotel context set")
+
+    # Get existing settings for this hotel or create new
+    settings = db.query(Settings).filter(Settings.hotel_id == hotel_id).first()
+
+    if not settings:
+        settings = Settings(
+            hotel_id=hotel_id,
+            hotel_name=hotel_name,
+            address=address,
+            contact_number=contact_number,
+            email=email,
+            tax_id=tax_id,
+        )
+        db.add(settings)
+    else:
+        # Update fields
+        settings.hotel_name = hotel_name
+        settings.address = address
+        settings.contact_number = contact_number
+        settings.email = email
+        settings.tax_id = tax_id
+
+    # Handle logo upload if provided
+    if logo:
+        # Get hotel info for organizing logos
+        hotel = db.query(Hotel).filter(Hotel.id == hotel_id).first()
+        hotel_name_for_path = hotel.hotel_name if hotel else f"hotel_{hotel_id}"
+
+        # Create directory structure: app/static/images/logo/{hotel_name}
+        hotel_logo_dir = f"app/static/images/logo/{hotel_name_for_path}"
+        os.makedirs(hotel_logo_dir, exist_ok=True)
+
+        # Save logo with hotel-specific path
+        logo_path = f"{hotel_logo_dir}/hotel_logo_{logo.filename}"
+        with open(logo_path, "wb") as buffer:
+            shutil.copyfileobj(logo.file, buffer)
+
+        # Update settings with logo path (URL path for serving)
+        settings.logo_path = f"/static/images/logo/{hotel_name_for_path}/hotel_logo_{logo.filename}"
+
+    # Update timestamp
+    settings.updated_at = datetime.now(timezone.utc)
+
+    db.commit()
+    db.refresh(settings)
+
+    return settings

app/routers/table.py

@@ -0,0 +1,254 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from sqlalchemy.orm import Session
+from typing import List
+from datetime import datetime, timezone
+
+from ..database import get_db, Table as TableModel, Order, get_session_db
+from ..models.table import Table, TableCreate, TableUpdate, TableStatus
+from ..middleware import get_session_id
+
+router = APIRouter(
+    prefix="/tables",
+    tags=["tables"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+# Dependency to get session-aware database
+def get_session_database(request: Request):
+    session_id = get_session_id(request)
+    return next(get_session_db(session_id))
+
+
+# Get all tables
+@router.get("/", response_model=List[Table])
+def get_all_tables(request: Request, db: Session = Depends(get_session_database)):
+    return db.query(TableModel).order_by(TableModel.table_number).all()
+
+
+# Get table by ID
+@router.get("/{table_id}", response_model=Table)
+def get_table(table_id: int, request: Request, db: Session = Depends(get_session_database)):
+    db_table = db.query(TableModel).filter(TableModel.id == table_id).first()
+    if not db_table:
+        raise HTTPException(status_code=404, detail="Table not found")
+    return db_table
+
+
+# Get table by table number
+@router.get("/number/{table_number}", response_model=Table)
+def get_table_by_number(table_number: int, request: Request, db: Session = Depends(get_session_database)):
+    db_table = (
+        db.query(TableModel).filter(TableModel.table_number == table_number).first()
+    )
+    if not db_table:
+        raise HTTPException(status_code=404, detail="Table not found")
+    return db_table
+
+
+# Create new table
+@router.post("/", response_model=Table)
+def create_table(table: TableCreate, request: Request, db: Session = Depends(get_session_database)):
+    # Check if a table with this number already exists
+    existing_table = (
+        db.query(TableModel)
+        .filter(TableModel.table_number == table.table_number)
+        .first()
+    )
+    if existing_table:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Table with number {table.table_number} already exists",
+        )
+
+    # Create new table
+    db_table = TableModel(
+        table_number=table.table_number,
+        is_occupied=table.is_occupied,
+        current_order_id=table.current_order_id,
+        last_occupied_at=table.last_occupied_at,
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc),
+    )
+    db.add(db_table)
+    db.commit()
+    db.refresh(db_table)
+    return db_table
+
+
+# Update table
+@router.put("/{table_id}", response_model=Table)
+def update_table(
+    table_id: int, table_update: TableUpdate, request: Request, db: Session = Depends(get_session_database)
+):
+    db_table = db.query(TableModel).filter(TableModel.id == table_id).first()
+    if not db_table:
+        raise HTTPException(status_code=404, detail="Table not found")
+
+    # Update fields if provided
+    if table_update.is_occupied is not None:
+        db_table.is_occupied = table_update.is_occupied
+    if table_update.current_order_id is not None:
+        db_table.current_order_id = table_update.current_order_id
+
+    db_table.updated_at = datetime.now(timezone.utc)
+    db.commit()
+    db.refresh(db_table)
+    return db_table
+
+
+# Delete table
+@router.delete("/{table_id}")
+def delete_table(table_id: int, request: Request, db: Session = Depends(get_session_database)):
+    db_table = db.query(TableModel).filter(TableModel.id == table_id).first()
+    if not db_table:
+        raise HTTPException(status_code=404, detail="Table not found")
+
+    # Check if table is currently occupied
+    if db_table.is_occupied:
+        raise HTTPException(
+            status_code=400, detail="Cannot delete a table that is currently occupied"
+        )
+
+    db.delete(db_table)
+    db.commit()
+    return {"message": "Table deleted successfully"}
+
+
+# Get table status (total, occupied, free)
+@router.get("/status/summary", response_model=TableStatus)
+def get_table_status(request: Request, db: Session = Depends(get_session_database)):
+    total_tables = db.query(TableModel).count()
+    occupied_tables = (
+        db.query(TableModel).filter(TableModel.is_occupied == True).count()
+    )
+    free_tables = total_tables - occupied_tables
+
+    return {
+        "total_tables": total_tables,
+        "occupied_tables": occupied_tables,
+        "free_tables": free_tables,
+    }
+
+
+# Set table as occupied
+@router.put("/{table_id}/occupy", response_model=Table)
+def set_table_occupied(
+    table_id: int, order_id: int = None, request: Request = None, db: Session = Depends(get_session_database)
+):
+    db_table = db.query(TableModel).filter(TableModel.id == table_id).first()
+    if not db_table:
+        raise HTTPException(status_code=404, detail="Table not found")
+
+    # Check if table is already occupied
+    if db_table.is_occupied:
+        raise HTTPException(status_code=400, detail="Table is already occupied")
+
+    # Update table status
+    db_table.is_occupied = True
+
+    # Link to order if provided
+    if order_id:
+        # Verify order exists
+        order = db.query(Order).filter(Order.id == order_id).first()
+        if not order:
+            raise HTTPException(status_code=404, detail="Order not found")
+        db_table.current_order_id = order_id
+
+    db_table.updated_at = datetime.now(timezone.utc)
+    db.commit()
+    db.refresh(db_table)
+    return db_table
+
+
+# Set table as free
+@router.put("/{table_id}/free", response_model=Table)
+def set_table_free(table_id: int, request: Request, db: Session = Depends(get_session_database)):
+    db_table = db.query(TableModel).filter(TableModel.id == table_id).first()
+    if not db_table:
+        raise HTTPException(status_code=404, detail="Table not found")
+
+    # Check if table is already free
+    if not db_table.is_occupied:
+        raise HTTPException(status_code=400, detail="Table is already free")
+
+    # Update table status
+    db_table.is_occupied = False
+    db_table.current_order_id = None
+    db_table.updated_at = datetime.now(timezone.utc)
+    db.commit()
+    db.refresh(db_table)
+    return db_table
+
+
+# Set table as occupied by table number
+@router.put("/number/{table_number}/occupy", response_model=Table)
+def set_table_occupied_by_number(table_number: int, request: Request, db: Session = Depends(get_session_database)):
+    db_table = (
+        db.query(TableModel).filter(TableModel.table_number == table_number).first()
+    )
+    if not db_table:
+        raise HTTPException(status_code=404, detail="Table not found")
+
+    # Update table status (even if already occupied, just update the timestamp)
+    db_table.is_occupied = True
+    db_table.last_occupied_at = datetime.now(timezone.utc)
+    db_table.updated_at = datetime.now(timezone.utc)
+    db.commit()
+    db.refresh(db_table)
+    return db_table
+
+
+# Set table as free by table number
+@router.put("/number/{table_number}/free", response_model=Table)
+def set_table_free_by_number(table_number: int, request: Request, db: Session = Depends(get_session_database)):
+    db_table = (
+        db.query(TableModel).filter(TableModel.table_number == table_number).first()
+    )
+    if not db_table:
+        raise HTTPException(status_code=404, detail="Table not found")
+
+    # Update table status to free (don't check if already free, just update)
+    db_table.is_occupied = False
+    db_table.current_order_id = None
+    db_table.updated_at = datetime.now(timezone.utc)
+    db.commit()
+    db.refresh(db_table)
+    return db_table
+
+
+# Create multiple tables at once
+@router.post("/batch", response_model=List[Table])
+def create_tables_batch(num_tables: int, request: Request, db: Session = Depends(get_session_database)):
+    if num_tables <= 0:
+        raise HTTPException(
+            status_code=400, detail="Number of tables must be greater than 0"
+        )
+
+    # Get the highest existing table number
+    highest_table = (
+        db.query(TableModel).order_by(TableModel.table_number.desc()).first()
+    )
+    start_number = 1
+    if highest_table:
+        start_number = highest_table.table_number + 1
+
+    # Create tables
+    new_tables = []
+    for i in range(start_number, start_number + num_tables):
+        db_table = TableModel(
+            table_number=i,
+            is_occupied=False,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        )
+        db.add(db_table)
+        new_tables.append(db_table)
+
+    db.commit()
+
+    # Refresh all tables
+    for table in new_tables:
+        db.refresh(table)
+
+    return new_tables

app/services/__init__.py

@@ -0,0 +1 @@
+# Services package

app/services/firebase_auth.py

@@ -0,0 +1,100 @@
+import firebase_admin
+from firebase_admin import credentials, auth
+import os
+import json
+from fastapi import HTTPException, status
+
+# Initialize Firebase Admin SDK
+cred_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
+                         "app", "tabble-v1-firebase-adminsdk-fbsvc-8024adcbdf.json")
+
+# Global variable to track initialization
+firebase_initialized = False
+
+try:
+    # Check if Firebase is already initialized
+    try:
+        firebase_app = firebase_admin.get_app()
+        firebase_initialized = True
+        print("Firebase already initialized")
+    except ValueError:
+        # Initialize Firebase if not already initialized
+        cred = credentials.Certificate(cred_path)
+        firebase_app = firebase_admin.initialize_app(cred)
+        firebase_initialized = True
+        print("Firebase initialized successfully")
+except Exception as e:
+    print(f"Firebase initialization error: {e}")
+    # Continue without crashing, but authentication will fail
+
+# Firebase Authentication functions
+def verify_phone_number(phone_number):
+    """
+    Verify a phone number and send OTP
+    Returns a session info token that will be used to verify the OTP
+    """
+    try:
+        # Check if Firebase is initialized
+        if not firebase_initialized:
+            print("Firebase is not initialized, using mock verification")
+
+        # Validate phone number format (should start with +91)
+        if not phone_number.startswith("+91"):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Phone number must start with +91"
+            )
+
+        # In a real implementation with Firebase Admin SDK, we would use:
+        # session_info = auth.create_session_cookie(...)
+        # But for this implementation, we'll let the client-side Firebase handle the actual SMS sending
+
+        print(f"Phone verification requested for: {phone_number}")
+        return {"sessionInfo": "firebase-verification-token", "success": True}
+
+    except HTTPException as e:
+        # Re-raise HTTP exceptions
+        raise e
+    except Exception as e:
+        print(f"Error in verify_phone_number: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to send verification code: {str(e)}"
+        )
+
+def verify_otp(phone_number, otp, session_info=None):
+    """
+    Verify the OTP sent to the phone number
+    Returns a Firebase ID token if verification is successful
+
+    Note: In this implementation, the actual OTP verification is done on the client side
+    using Firebase Authentication. This function is just for validating the format and
+    returning a success response.
+    """
+    try:
+        # Check if Firebase is initialized
+        if not firebase_initialized:
+            print("Firebase is not initialized, using mock verification")
+
+        # Validate OTP format
+        if not otp.isdigit() or len(otp) != 6:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Invalid OTP format. Must be 6 digits."
+            )
+
+        # In a real implementation with Firebase Admin SDK, we would verify the OTP
+        # But for this implementation, we trust that the client-side Firebase has already verified it
+
+        print(f"OTP verification successful for: {phone_number}")
+        return {"idToken": "firebase-id-token", "phone_number": phone_number, "success": True}
+
+    except HTTPException as e:
+        # Re-raise HTTP exceptions
+        raise e
+    except Exception as e:
+        print(f"Error in verify_otp: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"Failed to verify OTP: {str(e)}"
+        )

app/services/optimized_queries.py

@@ -0,0 +1,313 @@
+"""
+Optimized database queries for better performance
+"""
+from sqlalchemy.orm import Session, joinedload, selectinload
+from sqlalchemy import and_, or_, func, text
+from typing import List, Optional, Dict, Any
+from datetime import datetime, timedelta
+import logging
+
+from ..database import Order, OrderItem, Dish, Person, Table
+
+logger = logging.getLogger(__name__)
+
+class OptimizedQueryService:
+    """Service for optimized database queries with caching and performance improvements"""
+    
+    def __init__(self):
+        self.query_cache = {}
+        self.cache_ttl = {
+            'menu': 300,  # 5 minutes
+            'categories': 900,  # 15 minutes
+            'specials': 300,  # 5 minutes
+            'offers': 300,  # 5 minutes
+        }
+    
+    def get_menu_optimized(self, db: Session, category: Optional[str] = None) -> List[Dict]:
+        """Optimized menu query with eager loading and caching"""
+        try:
+            # Build optimized query
+            query = db.query(Dish).filter(
+                Dish.is_visible == True
+            )
+            
+            if category and category != 'All':
+                query = query.filter(Dish.category == category)
+            
+            # Order by category and name for consistent results
+            query = query.order_by(Dish.category, Dish.name)
+            
+            # Execute query
+            dishes = query.all()
+            
+            # Convert to dict for JSON serialization
+            result = []
+            for dish in dishes:
+                dish_dict = {
+                    'id': dish.id,
+                    'name': dish.name,
+                    'description': dish.description,
+                    'price': float(dish.price),
+                    'category': dish.category,
+                    'image_path': dish.image_path,
+                    'is_offer': dish.is_offer,
+                    'discount': float(dish.discount) if dish.discount else 0,
+                    'is_visible': dish.is_visible,
+                    'created_at': dish.created_at.isoformat() if dish.created_at else None
+                }
+                result.append(dish_dict)
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error in get_menu_optimized: {str(e)}")
+            raise
+    
+    def get_orders_optimized(self, db: Session, person_id: Optional[int] = None, 
+                           table_number: Optional[int] = None, 
+                           status: Optional[str] = None) -> List[Dict]:
+        """Optimized order query with eager loading of related data"""
+        try:
+            # Build base query with eager loading
+            query = db.query(Order).options(
+                selectinload(Order.items).selectinload(OrderItem.dish),
+                joinedload(Order.person)
+            )
+            
+            # Apply filters
+            filters = []
+            if person_id:
+                filters.append(Order.person_id == person_id)
+            if table_number:
+                filters.append(Order.table_number == table_number)
+            if status:
+                filters.append(Order.status == status)
+            
+            if filters:
+                query = query.filter(and_(*filters))
+            
+            # Order by creation time (newest first)
+            query = query.order_by(Order.created_at.desc())
+            
+            # Execute query
+            orders = query.all()
+            
+            # Convert to dict with optimized serialization
+            result = []
+            for order in orders:
+                order_dict = {
+                    'id': order.id,
+                    'table_number': order.table_number,
+                    'unique_id': order.unique_id,
+                    'person_id': order.person_id,
+                    'status': order.status,
+                    'created_at': order.created_at.isoformat() if order.created_at else None,
+                    'updated_at': order.updated_at.isoformat() if order.updated_at else None,
+                    'items': []
+                }
+                
+                # Add order items
+                for item in order.items:
+                    item_dict = {
+                        'id': item.id,
+                        'dish_id': item.dish_id,
+                        'dish_name': item.dish.name if item.dish else 'Unknown',
+                        'quantity': item.quantity,
+                        'price': float(item.price),
+                        'remarks': item.remarks,
+                        'position': item.position
+                    }
+                    order_dict['items'].append(item_dict)
+                
+                result.append(order_dict)
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error in get_orders_optimized: {str(e)}")
+            raise
+    
+    def get_chef_orders_optimized(self, db: Session, status: str) -> List[Dict]:
+        """Optimized chef order query with minimal data transfer"""
+        try:
+            # Use raw SQL for better performance on chef queries
+            sql = text("""
+                SELECT 
+                    o.id,
+                    o.table_number,
+                    o.status,
+                    o.created_at,
+                    o.updated_at,
+                    COUNT(oi.id) as item_count,
+                    GROUP_CONCAT(
+                        CONCAT(d.name, ' (', oi.quantity, ')')
+                        SEPARATOR ', '
+                    ) as items_summary
+                FROM orders o
+                LEFT JOIN order_items oi ON o.id = oi.order_id
+                LEFT JOIN dishes d ON oi.dish_id = d.id
+                WHERE o.status = :status
+                GROUP BY o.id, o.table_number, o.status, o.created_at, o.updated_at
+                ORDER BY o.created_at ASC
+            """)
+            
+            result = db.execute(sql, {'status': status}).fetchall()
+            
+            # Convert to dict
+            orders = []
+            for row in result:
+                order_dict = {
+                    'id': row.id,
+                    'table_number': row.table_number,
+                    'status': row.status,
+                    'created_at': row.created_at.isoformat() if row.created_at else None,
+                    'updated_at': row.updated_at.isoformat() if row.updated_at else None,
+                    'item_count': row.item_count,
+                    'items_summary': row.items_summary or ''
+                }
+                orders.append(order_dict)
+            
+            return orders
+            
+        except Exception as e:
+            logger.error(f"Error in get_chef_orders_optimized: {str(e)}")
+            # Fallback to regular query
+            return self._get_chef_orders_fallback(db, status)
+    
+    def _get_chef_orders_fallback(self, db: Session, status: str) -> List[Dict]:
+        """Fallback method for chef orders if raw SQL fails"""
+        try:
+            orders = db.query(Order).options(
+                selectinload(Order.items).selectinload(OrderItem.dish)
+            ).filter(Order.status == status).order_by(Order.created_at.asc()).all()
+            
+            result = []
+            for order in orders:
+                items_summary = ', '.join([
+                    f"{item.dish.name if item.dish else 'Unknown'} ({item.quantity})"
+                    for item in order.items
+                ])
+                
+                order_dict = {
+                    'id': order.id,
+                    'table_number': order.table_number,
+                    'status': order.status,
+                    'created_at': order.created_at.isoformat() if order.created_at else None,
+                    'updated_at': order.updated_at.isoformat() if order.updated_at else None,
+                    'item_count': len(order.items),
+                    'items_summary': items_summary
+                }
+                result.append(order_dict)
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error in chef orders fallback: {str(e)}")
+            raise
+    
+    def get_table_status_optimized(self, db: Session) -> List[Dict]:
+        """Optimized table status query"""
+        try:
+            # Use raw SQL for better performance
+            sql = text("""
+                SELECT 
+                    t.table_number,
+                    t.is_occupied,
+                    t.current_order_id,
+                    t.updated_at,
+                    o.status as order_status,
+                    COUNT(oi.id) as item_count
+                FROM tables t
+                LEFT JOIN orders o ON t.current_order_id = o.id
+                LEFT JOIN order_items oi ON o.id = oi.order_id
+                GROUP BY t.table_number, t.is_occupied, t.current_order_id, t.updated_at, o.status
+                ORDER BY t.table_number
+            """)
+            
+            result = db.execute(sql).fetchall()
+            
+            tables = []
+            for row in result:
+                table_dict = {
+                    'table_number': row.table_number,
+                    'is_occupied': bool(row.is_occupied),
+                    'current_order_id': row.current_order_id,
+                    'updated_at': row.updated_at.isoformat() if row.updated_at else None,
+                    'order_status': row.order_status,
+                    'item_count': row.item_count or 0
+                }
+                tables.append(table_dict)
+            
+            return tables
+            
+        except Exception as e:
+            logger.error(f"Error in get_table_status_optimized: {str(e)}")
+            raise
+    
+    def get_analytics_data_optimized(self, db: Session, start_date: datetime, 
+                                   end_date: datetime) -> Dict[str, Any]:
+        """Optimized analytics query with aggregations"""
+        try:
+            # Use raw SQL for complex aggregations
+            sql = text("""
+                SELECT 
+                    DATE(o.created_at) as order_date,
+                    COUNT(DISTINCT o.id) as total_orders,
+                    COUNT(DISTINCT o.table_number) as unique_tables,
+                    SUM(oi.quantity * oi.price) as total_revenue,
+                    AVG(oi.quantity * oi.price) as avg_order_value,
+                    d.category,
+                    COUNT(oi.id) as items_sold
+                FROM orders o
+                JOIN order_items oi ON o.id = oi.order_id
+                JOIN dishes d ON oi.dish_id = d.id
+                WHERE o.created_at BETWEEN :start_date AND :end_date
+                    AND o.status = 'paid'
+                GROUP BY DATE(o.created_at), d.category
+                ORDER BY order_date DESC, d.category
+            """)
+            
+            result = db.execute(sql, {
+                'start_date': start_date,
+                'end_date': end_date
+            }).fetchall()
+            
+            # Process results
+            analytics = {
+                'daily_stats': {},
+                'category_stats': {},
+                'summary': {
+                    'total_orders': 0,
+                    'total_revenue': 0,
+                    'avg_order_value': 0
+                }
+            }
+            
+            for row in result:
+                date_str = row.order_date.isoformat()
+                
+                if date_str not in analytics['daily_stats']:
+                    analytics['daily_stats'][date_str] = {
+                        'orders': row.total_orders,
+                        'revenue': float(row.total_revenue),
+                        'avg_value': float(row.avg_order_value),
+                        'unique_tables': row.unique_tables
+                    }
+                
+                category = row.category
+                if category not in analytics['category_stats']:
+                    analytics['category_stats'][category] = {
+                        'items_sold': 0,
+                        'revenue': 0
+                    }
+                
+                analytics['category_stats'][category]['items_sold'] += row.items_sold
+            
+            return analytics
+            
+        except Exception as e:
+            logger.error(f"Error in get_analytics_data_optimized: {str(e)}")
+            raise
+
+# Create singleton instance
+optimized_queries = OptimizedQueryService()

app/static/images/README.md

@@ -0,0 +1,27 @@
+# Static Images Directory
+
+This directory contains dish images organized by database name.
+
+## Structure:
+```
+app/static/images/dishes/
+├── tabble_new/          # Demo hotel images
+│   ├── dish1.jpg
+│   ├── dish2.jpg
+│   └── ...
+└── your_hotel/          # Your hotel images
+    ├── dish1.jpg
+    ├── dish2.jpg
+    └── ...
+```
+
+## Upload Guidelines:
+- Use JPEG or PNG format
+- Recommended size: 400x300 pixels
+- Keep file size under 500KB for better performance
+- Use descriptive filenames
+
+## Access URLs:
+Images can be accessed at: `/static/images/dishes/{database_name}/{filename}`
+
+Example: `/static/images/dishes/tabble_new/chicken_biryani.jpg`

app/tabble-v1-firebase-adminsdk-fbsvc-8024adcbdf.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "tabble-v1",
+  "private_key_id": "8024adcbdf26bf1cac14997f39331ee88fb00a86",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDk0yMPULQZ95J0\n8Ksg5l8mg9VcpKs+tAGSGvVrmfLDHVaVIanYGmd6yJ+mZd8ZTXf5G38IlmBzK1nV\nwGsv7WPBQPSS5wDyJgj2iULuKNO09YxFXwEwzut5iQNlw81YB0K7UkIE3Psk6DY+\naaxRgToid0T3Ppbkav0FvrbU9/3/PEoIeL/i7bBo1lDnuzsAy1cycmueWA1ZdM3v\naKU6EjlXYfbo2kZPNfHplPg32JWknQy/SPeY26aBX9O07Qh/dT/DxET/OXpWaEJz\nQhuTuPHtIdFDXjIoYDQoBAKsvzxk0LnHKZ60MhkV2qoXQjPAAwah+Ki4bPEqmGRR\nsiZgoOXxAgMBAAECggEAKlJfuWkuil/3E1BhAlKBdjzrZTlin9QIt1ZrnmVomExQ\nk4AYqwrFKVk6Z/sO/p3MqwL6JaM0fxCdSrLOUFy6dseWBKabju3YegqsmaJs95rz\nwO/fp0CaHk4oVfXXQKkFH2LJKZ+ahrq5L6V5VNDPKQlAtO77Vw9vsVSS+cRNUtug\n3a8VgrBM8hDcD3Ej78XeEHI33kOgJQ4mL9Dp8zAJFrR0X3oTAI4NtYOPcgH5l2Ng\nYXZKmigQR1jIWXb5AiKaHnFdBaatyrAvWtvT1/Zsp0NYvaRoefdcfG5KIoZoRLpb\nA7sfOp1c/JPRlye1CdwggJzORLjwSbfiBbGaDvVb7QKBgQD+JfpGP95KoEO7v7hH\nPSwb9db/dzB5/3CRbq7/G9eq0J7Zl+/UeKMfJmIHQP3p9/GvPnQHn7pih9AcoMsb\nyhURGeJ5FnLVytWwPQDat4IlyTUhqaACcElogBHcgFbgJxQLfaQiQcyR6vOjAE8L\nlFEDTMFXf8LXrlkZ0H9XtXPwRQKBgQDmfe1giRIehboRqD9eS4BQtC1L5zbQx8lW\nmj8a/QXySWBMSHFKZjWChWrg1nfsGTSWGlE4uMznP+p2nuOS6jHAATf2GJZVBVm/\nPnYfcpfHGA94a3CJVWjaTp5cE1D4FRFnUS4HgY2w0T3sD9zzU8L8XQ+X2zsTviCT\n252VmJYnvQKBgQDXWICvg7CsVQ3viSzxGBFHA9EQGAM4bEwKvtmDCil88FaZE1fB\nFhNJ8rD/an97/36HOgkA6MP6dw/NIiXXvyyImAFBDtdw9fSI57fQm8uojsv5YQxW\n5KQe6t23k/uI5TPj5Krt6AkZ3xZgGIPh0OOwQxpUNMp5DJ8s83DjdbnubQKBgQC2\nyL5qg8j+s4XvYsF+AdnsJjaVrvJld0pPh1rsCCOjFFVtqTVOjud4bl1nmCzZ6tMt\nBgnLNaIo8SL6lt5aL6bsYQsD+lOdcPTPGLWMEtASbx41nN5NypGwLhCfbCIV2n9G\ns7YQ9chrpEO65ImP3akPgK1Q++ZJrckf+FVrwOmy8QKBgBv1rjNyXm3FplH0hq44\nfRcTJorvOk2ac3Hew5Czzk6ODJovIr+GPRQ2/9wF/NMBD9bfbwcvmp7vFqkTEl5f\nD/xJOwxZ06c3LBYi9tp5yrpuiqvfNZ0dUrCEY20KUktvNxfTigEGCgTmJ8+AEPlx\nFIJyQJtUD6yk6TGx7G9wYOPT\n-----END PRIVATE KEY-----\n",
+  "client_email": "[email protected]",
+  "client_id": "116848039876810333298",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-fbsvc%40tabble-v1.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

app/utils/__init__.py

@@ -0,0 +1 @@
+# Utils package

app/utils/pdf_generator.py

@@ -0,0 +1,285 @@
+from reportlab.lib import colors
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from io import BytesIO
+from datetime import datetime
+from typing import List
+
+def generate_bill_pdf(order, settings):
+    """
+    Generate a PDF bill for a single order
+
+    Args:
+        order: The order object with all details
+        settings: The hotel settings object
+
+    Returns:
+        BytesIO: A buffer containing the PDF data
+    """
+    # Convert single order to list and use the multi-order function
+    return generate_multi_order_bill_pdf([order], settings)
+
+def generate_multi_order_bill_pdf(orders: List, settings):
+    """
+    Generate a PDF bill for multiple orders in a receipt-like format
+
+    Args:
+        orders: List of order objects with all details
+        settings: The hotel settings object
+
+    Returns:
+        BytesIO: A buffer containing the PDF data
+    """
+    buffer = BytesIO()
+    # Use a narrower page size to mimic a receipt
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=(4*inch, 11*inch),  # Typical receipt width
+        rightMargin=10,
+        leftMargin=10,
+        topMargin=10,
+        bottomMargin=10
+    )
+
+    # Create styles
+    styles = getSampleStyleSheet()
+    styles.add(ParagraphStyle(
+        name='HotelName',
+        fontName='Helvetica-Bold',
+        fontSize=14,
+        alignment=1,  # Center alignment
+        spaceAfter=2
+    ))
+    styles.add(ParagraphStyle(
+        name='HotelTagline',
+        fontName='Helvetica',
+        fontSize=9,
+        alignment=1,  # Center alignment
+        spaceAfter=2
+    ))
+    styles.add(ParagraphStyle(
+        name='HotelAddress',
+        fontName='Helvetica',
+        fontSize=8,
+        alignment=1,  # Center alignment
+        spaceAfter=1
+    ))
+    styles.add(ParagraphStyle(
+        name='BillInfo',
+        fontName='Helvetica',
+        fontSize=8,
+        alignment=0,  # Left alignment
+        spaceAfter=1
+    ))
+    styles.add(ParagraphStyle(
+        name='BillInfoRight',
+        fontName='Helvetica',
+        fontSize=8,
+        alignment=2,  # Right alignment
+        spaceAfter=1
+    ))
+    styles.add(ParagraphStyle(
+        name='TableHeader',
+        fontName='Helvetica-Bold',
+        fontSize=8,
+        alignment=0
+    ))
+    styles.add(ParagraphStyle(
+        name='ItemName',
+        fontName='Helvetica',
+        fontSize=8,
+        alignment=0
+    ))
+    styles.add(ParagraphStyle(
+        name='ItemValue',
+        fontName='Helvetica',
+        fontSize=8,
+        alignment=2  # Right alignment
+    ))
+    styles.add(ParagraphStyle(
+        name='Total',
+        fontName='Helvetica-Bold',
+        fontSize=9,
+        alignment=1  # Center alignment
+    ))
+    styles.add(ParagraphStyle(
+        name='Footer',
+        fontName='Helvetica',
+        fontSize=7,
+        alignment=1,  # Center alignment
+        textColor=colors.black
+    ))
+
+    # Create content elements
+    elements = []
+
+    # We're not using the logo in this receipt-style bill
+    # Add hotel name and info
+    elements.append(Paragraph(settings.hotel_name.upper(), styles['HotelName']))
+
+    # Add tagline (if any, otherwise use a default)
+    tagline = "AN AUTHENTIC CUISINE SINCE 2000"
+    elements.append(Paragraph(tagline, styles['HotelTagline']))
+
+    # Add address with formatting similar to the image
+    if settings.address:
+        elements.append(Paragraph(settings.address, styles['HotelAddress']))
+
+    # Add contact info
+    if settings.contact_number:
+        elements.append(Paragraph(f"Contact: {settings.contact_number}", styles['HotelAddress']))
+
+    # Add tax ID (GSTIN)
+    if settings.tax_id:
+        elements.append(Paragraph(f"GSTIN: {settings.tax_id}", styles['HotelAddress']))
+
+    # Add a separator line
+    elements.append(Paragraph("_" * 50, styles['HotelAddress']))
+
+    # Add bill details in a more receipt-like format
+    # Use the first order for common details
+    first_order = orders[0]
+
+    # Create a table for the bill header info
+    # Get customer name if available
+    customer_name = ""
+    if hasattr(first_order, 'person_name') and first_order.person_name:
+        customer_name = first_order.person_name
+
+    bill_info_data = [
+        ["Name:", customer_name],
+        [f"Date: {datetime.now().strftime('%d/%m/%y')}", f"Dine In: {first_order.table_number}"],
+        [f"{datetime.now().strftime('%H:%M')}", f"Bill No.: {first_order.id}"]
+    ]
+
+    bill_info_table = Table(bill_info_data, colWidths=[doc.width/2-20, doc.width/2-20])
+    bill_info_table.setStyle(TableStyle([
+        ('FONT', (0, 0), (-1, -1), 'Helvetica', 8),
+        ('ALIGN', (0, 0), (0, -1), 'LEFT'),
+        ('ALIGN', (1, 0), (1, -1), 'RIGHT'),
+        ('LINEBELOW', (0, 0), (1, 0), 0.5, colors.black),
+    ]))
+
+    elements.append(bill_info_table)
+    elements.append(Paragraph("_" * 50, styles['HotelAddress']))
+
+    # Create header for items table
+    items_header = [["Item", "Qty.", "Price", "Amount"]]
+    items_header_table = Table(items_header, colWidths=[doc.width*0.4, doc.width*0.15, doc.width*0.2, doc.width*0.25])
+    items_header_table.setStyle(TableStyle([
+        ('FONT', (0, 0), (-1, -1), 'Helvetica-Bold', 8),
+        ('ALIGN', (0, 0), (0, -1), 'LEFT'),
+        ('ALIGN', (1, 0), (-1, -1), 'RIGHT'),
+        ('LINEBELOW', (0, 0), (-1, 0), 0.5, colors.black),
+    ]))
+
+    elements.append(items_header_table)
+
+    # Add all order items
+    total_items = 0
+    subtotal_amount = 0
+    total_loyalty_discount = 0
+    total_selection_discount = 0
+    grand_total = 0
+
+    for order in orders:
+        order_data = []
+
+        for item in order.items:
+            dish_name = item.dish.name if item.dish else "Unknown Dish"
+            price = item.dish.price if item.dish else 0
+            quantity = item.quantity
+            total = price * quantity
+            subtotal_amount += total
+            total_items += quantity
+
+            order_data.append([
+                dish_name,
+                str(quantity),
+                f"{price:.2f}",
+                f"{total:.2f}"
+            ])
+
+        # Accumulate discount amounts from order records
+        if hasattr(order, 'loyalty_discount_amount') and order.loyalty_discount_amount:
+            total_loyalty_discount += order.loyalty_discount_amount
+        if hasattr(order, 'selection_offer_discount_amount') and order.selection_offer_discount_amount:
+            total_selection_discount += order.selection_offer_discount_amount
+
+        # Use stored total_amount if available, otherwise calculate from subtotal
+        if hasattr(order, 'total_amount') and order.total_amount is not None:
+            grand_total += order.total_amount
+        else:
+            # Fallback to original calculation if no stored total
+            grand_total += subtotal_amount
+
+        # Create the table for this order's items
+        if order_data:
+            items_table = Table(order_data, colWidths=[doc.width*0.4, doc.width*0.15, doc.width*0.2, doc.width*0.25])
+            items_table.setStyle(TableStyle([
+                ('FONT', (0, 0), (-1, -1), 'Helvetica', 8),
+                ('ALIGN', (0, 0), (0, -1), 'LEFT'),
+                ('ALIGN', (1, 0), (-1, -1), 'RIGHT'),
+            ]))
+
+            elements.append(items_table)
+
+    # Add a separator line
+    elements.append(Paragraph("_" * 50, styles['HotelAddress']))
+
+    # Add totals section with discounts
+    totals_data = [
+        [f"Total Qty: {total_items}", f"Sub Total", f"${subtotal_amount:.2f}"],
+    ]
+
+    # Add loyalty discount if applicable
+    if total_loyalty_discount > 0:
+        totals_data.append(["", f"Loyalty Discount", f"-${total_loyalty_discount:.2f}"])
+
+    # Add selection offer discount if applicable
+    if total_selection_discount > 0:
+        totals_data.append(["", f"Offer Discount", f"-${total_selection_discount:.2f}"])
+
+    # Calculate amount after discounts
+    amount_after_discounts = subtotal_amount - total_loyalty_discount - total_selection_discount
+
+    # Calculate tax on discounted amount (assuming 5% CGST and 5% SGST)
+    tax_rate = 0.05  # 5%
+    cgst = amount_after_discounts * tax_rate
+    sgst = amount_after_discounts * tax_rate
+
+    # Add tax lines
+    totals_data.extend([
+        ["", f"CGST (5%)", f"${cgst:.2f}"],
+        ["", f"SGST (5%)", f"${sgst:.2f}"],
+    ])
+
+    # Calculate final total including tax
+    final_total = amount_after_discounts + cgst + sgst
+
+    totals_table = Table(totals_data, colWidths=[doc.width*0.4, doc.width*0.35, doc.width*0.25])
+    totals_table.setStyle(TableStyle([
+        ('FONT', (0, 0), (-1, -1), 'Helvetica', 8),
+        ('ALIGN', (0, 0), (0, -1), 'LEFT'),
+        ('ALIGN', (1, 0), (1, -1), 'RIGHT'),
+        ('ALIGN', (2, 0), (2, -1), 'RIGHT'),
+    ]))
+
+    elements.append(totals_table)
+
+    # Add grand total with emphasis
+    elements.append(Paragraph("_" * 50, styles['HotelAddress']))
+    elements.append(Paragraph(f"Grand Total    ${final_total:.2f}", styles['Total']))
+    elements.append(Paragraph("_" * 50, styles['HotelAddress']))
+
+    # Add license info and thank you message
+    elements.append(Spacer(1, 5))
+    elements.append(Paragraph("FSSAI Lic No: 12018033000205", styles['Footer']))
+    elements.append(Paragraph("!!! Thank You !!! Visit Again !!!", styles['Footer']))
+
+    # Build the PDF
+    doc.build(elements)
+    buffer.seek(0)
+
+    return buffer

hotels.csv

@@ -0,0 +1,6 @@
+hotel_name,password,hotel_id
+tabble_new,myhotel,1
+anifa,anifa123,2
+hotelgood,hotelgood123,3
+hotelmoon,moon123,4
+shine,shine123,5

init_db.py

@@ -0,0 +1,356 @@
+from app.database import (
+    create_tables,
+    SessionLocal,
+    Dish,
+    Person,
+    Base,
+    LoyaltyProgram,
+    SelectionOffer,
+    Table,
+)
+from sqlalchemy import create_engine
+from datetime import datetime, timezone
+import os
+import sys
+
+
+def init_db(force_reset=False):
+    # Check if force_reset is enabled
+    if force_reset:
+        # Drop all tables and recreate them
+        print("Forcing database reset...")
+        Base.metadata.drop_all(
+            bind=create_engine(
+                "sqlite:///./tabble_new.db", connect_args={"check_same_thread": False}
+            )
+        )
+
+    # Create tables
+    create_tables()
+
+    # Create a database session
+    db = SessionLocal()
+
+    # Check if dishes already exist
+    existing_dishes = db.query(Dish).count()
+    if existing_dishes > 0:
+        print("Database already contains data. Skipping initialization.")
+        return
+
+    # Add sample dishes
+    sample_dishes = [
+        # Regular dishes
+        Dish(
+            name="Margherita Pizza",
+            description="Classic pizza with tomato sauce, mozzarella, and basil",
+            category='["Main Course", "Italian"]',
+            price=12.99,
+            quantity=20,
+            image_path="/static/images/default-dish.jpg",
+            discount=0,
+            is_offer=0,
+            is_special=0,
+            is_vegetarian=1,
+        ),
+        Dish(
+            name="Caesar Salad",
+            description="Fresh romaine lettuce with Caesar dressing, croutons, and parmesan",
+            category='["Appetizer", "Salad"]',
+            price=8.99,
+            quantity=15,
+            image_path="/static/images/default-dish.jpg",
+            discount=0,
+            is_offer=0,
+            is_special=0,
+            is_vegetarian=1,
+        ),
+        Dish(
+            name="Chocolate Cake",
+            description="Rich chocolate cake with ganache frosting",
+            category="Dessert",
+            price=6.99,
+            quantity=10,
+            image_path="/static/images/default-dish.jpg",
+            discount=0,
+            is_offer=0,
+            is_special=0,
+        ),
+        Dish(
+            name="Iced Tea",
+            description="Refreshing iced tea with lemon",
+            category="Beverage",
+            price=3.99,
+            quantity=30,
+            image_path="/static/images/default-dish.jpg",
+            discount=0,
+            is_offer=0,
+            is_special=0,
+        ),
+        Dish(
+            name="Chicken Alfredo",
+            description="Fettuccine pasta with creamy Alfredo sauce and grilled chicken",
+            category="Main Course",
+            price=15.99,
+            quantity=12,
+            image_path="/static/images/default-dish.jpg",
+            discount=0,
+            is_offer=0,
+        ),
+        Dish(
+            name="Garlic Bread",
+            description="Toasted bread with garlic butter and herbs",
+            category="Appetizer",
+            price=4.99,
+            quantity=25,
+            image_path="/static/images/default-dish.jpg",
+            discount=0,
+            is_offer=0,
+            is_special=0,
+        ),
+        # Special offer dishes
+        Dish(
+            name="Weekend Special Pizza",
+            description="Deluxe pizza with premium toppings and extra cheese",
+            category="Main Course",
+            price=18.99,
+            quantity=15,
+            image_path="/static/images/default-dish.jpg",
+            discount=20,
+            is_offer=1,
+            is_special=0,
+        ),
+        Dish(
+            name="Seafood Pasta",
+            description="Fresh pasta with mixed seafood in a creamy sauce",
+            category="Main Course",
+            price=22.99,
+            quantity=10,
+            image_path="/static/images/default-dish.jpg",
+            discount=15,
+            is_offer=1,
+            is_special=0,
+        ),
+        Dish(
+            name="Tiramisu",
+            description="Classic Italian dessert with coffee-soaked ladyfingers and mascarpone cream",
+            category="Dessert",
+            price=9.99,
+            quantity=8,
+            image_path="/static/images/default-dish.jpg",
+            discount=25,
+            is_offer=1,
+            is_special=0,
+        ),
+        # Today's special dishes
+        Dish(
+            name="Chef's Special Steak",
+            description="Prime cut steak cooked to perfection with special house seasoning",
+            category="Main Course",
+            price=24.99,
+            quantity=12,
+            image_path="/static/images/default-dish.jpg",
+            discount=0,
+            is_offer=0,
+            is_special=1,
+        ),
+        Dish(
+            name="Truffle Mushroom Risotto",
+            description="Creamy risotto with wild mushrooms and truffle oil",
+            category="Main Course",
+            price=16.99,
+            quantity=10,
+            image_path="/static/images/default-dish.jpg",
+            discount=0,
+            is_offer=0,
+            is_special=1,
+        ),
+        Dish(
+            name="Chocolate Lava Cake",
+            description="Warm chocolate cake with a molten center, served with vanilla ice cream",
+            category="Dessert",
+            price=8.99,
+            quantity=15,
+            image_path="/static/images/default-dish.jpg",
+            discount=0,
+            is_offer=0,
+            is_special=1,
+        ),
+    ]
+
+    # Add dishes to database
+    for dish in sample_dishes:
+        db.add(dish)
+
+    # Add sample users
+    sample_users = [
+        Person(
+            username="john_doe",
+            password="password123",
+            visit_count=1,
+            last_visit=datetime.now(timezone.utc),
+        ),
+        Person(
+            username="jane_smith",
+            password="password456",
+            visit_count=3,
+            last_visit=datetime.now(timezone.utc),
+        ),
+        Person(
+            username="guest",
+            password="guest",
+            visit_count=5,
+            last_visit=datetime.now(timezone.utc),
+        ),
+    ]
+
+    # Add users to database
+    for user in sample_users:
+        db.add(user)
+
+    # Add sample loyalty program tiers
+    sample_loyalty_tiers = [
+        LoyaltyProgram(
+            visit_count=3,
+            discount_percentage=5.0,
+            is_active=True,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        LoyaltyProgram(
+            visit_count=5,
+            discount_percentage=10.0,
+            is_active=True,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        LoyaltyProgram(
+            visit_count=10,
+            discount_percentage=15.0,
+            is_active=True,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        LoyaltyProgram(
+            visit_count=20,
+            discount_percentage=20.0,
+            is_active=True,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+    ]
+
+    # Add loyalty tiers to database
+    for tier in sample_loyalty_tiers:
+        db.add(tier)
+
+    # Add sample selection offers
+    sample_selection_offers = [
+        SelectionOffer(
+            min_amount=50.0,
+            discount_amount=5.0,
+            is_active=True,
+            description="Spend $50, get $5 off",
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        SelectionOffer(
+            min_amount=100.0,
+            discount_amount=15.0,
+            is_active=True,
+            description="Spend $100, get $15 off",
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        SelectionOffer(
+            min_amount=150.0,
+            discount_amount=25.0,
+            is_active=True,
+            description="Spend $150, get $25 off",
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+    ]
+
+    # Add selection offers to database
+    for offer in sample_selection_offers:
+        db.add(offer)
+
+    # Add sample tables
+    sample_tables = [
+        Table(
+            table_number=1,
+            is_occupied=False,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        Table(
+            table_number=2,
+            is_occupied=False,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        Table(
+            table_number=3,
+            is_occupied=False,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        Table(
+            table_number=4,
+            is_occupied=False,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        Table(
+            table_number=5,
+            is_occupied=False,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        Table(
+            table_number=6,
+            is_occupied=False,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        Table(
+            table_number=7,
+            is_occupied=False,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+        Table(
+            table_number=8,
+            is_occupied=False,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        ),
+    ]
+
+    # Add tables to database
+    for table in sample_tables:
+        db.add(table)
+
+    # Commit changes
+    db.commit()
+
+    print("Database initialized with sample data:")
+    print("- Added", len(sample_dishes), "sample dishes")
+    print("- Added", len(sample_users), "sample users")
+    print("- Added", len(sample_loyalty_tiers), "loyalty program tiers")
+    print("- Added", len(sample_selection_offers), "selection offers")
+    print("- Added", len(sample_tables), "tables")
+
+    # Close session
+    db.close()
+
+
+if __name__ == "__main__":
+    # Create static/images directory if it doesn't exist
+    os.makedirs("app/static/images", exist_ok=True)
+
+    # Check for force reset flag
+    force_reset = "--force-reset" in sys.argv
+
+    # Initialize database
+    init_db(force_reset)

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "Tabble-v3",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

render.yaml

@@ -0,0 +1,14 @@
+services:
+  - type: web
+    name: tabble-backend
+    env: python
+    buildCommand: pip install -r requirements.txt
+    startCommand: python start.py
+    envVars:
+      - key: RENDER
+        value: "true"
+      - key: PYTHON_VERSION
+        value: "3.11.9"
+      - key: PORT
+        generateValue: true
+    healthCheckPath: /health

requirements.txt

@@ -0,0 +1,22 @@
+# Core FastAPI dependencies
+fastapi==0.104.1
+uvicorn[standard]==0.23.2
+
+# Database
+sqlalchemy==2.0.27
+
+# Web framework utilities
+python-multipart==0.0.6
+jinja2==3.1.2
+python-dotenv==1.0.0
+
+# PDF and image processing
+reportlab==4.0.7
+pillow==10.1.0
+
+# Firebase authentication
+firebase-admin
+
+# Additional dependencies for production
+requests==2.31.0
+aiofiles==23.2.1

run.py

@@ -0,0 +1,49 @@
+import uvicorn
+import os
+import socket
+
+
+def get_ip_address():
+    """Get the local IP address of the machine."""
+    try:
+        # Create a socket connection to an external server
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        # Doesn't need to be reachable
+        s.connect(("8.8.8.8", 80))
+        ip_address = s.getsockname()[0]
+        s.close()
+        return ip_address
+    except Exception as e:
+        print(f"Error getting IP address: {e}")
+        return "127.0.0.1"  # Return localhost if there's an error
+
+
+if __name__ == "__main__":
+    # Create static/images directory if it doesn't exist
+    os.makedirs("app/static/images", exist_ok=True)
+
+    # Check for force reset flag
+
+    # Get the IP address
+    ip_address = get_ip_address()
+
+    # Display access information
+    print("\n" + "=" * 50)
+
+    print(f"Access from other devices at: http://{ip_address}:8000")
+    print("=" * 50 + "\n")
+
+    # Get port from environment variable (for Render deployment) or default to 8000
+    port = int(os.environ.get("PORT", 8000))
+
+    # Check if running in production (Render sets this)
+    is_production = os.environ.get("RENDER") is not None
+
+    if is_production:
+        print(f"Starting production server on port {port}")
+        # Production mode - no reload, bind to 0.0.0.0
+        uvicorn.run("app.main:app", host="0.0.0.0", port=port, reload=False)
+    else:
+        # Development mode - Run the application on your IP address
+        # Using 0.0.0.0 allows connections from any IP
+        uvicorn.run("app.main:app", host="0.0.0.0", port=port, reload=True)