Initial commit with Git LFS

.gitattributes

@@ -0,0 +1,39 @@
+*.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
+*.db filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+.venv/
+/frontend/node_modules/

Dockerfile

@@ -0,0 +1,32 @@
+# Use Python 3.10 slim image as base
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /code
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY app app/
+COPY templates templates/
+COPY run.py .
+COPY tabble_new.db .
+
+# Set environment variables
+ENV PORT=7860
+ENV HOST=0.0.0.0
+
+# Expose the port
+EXPOSE 7860
+
+# Command to run the application
+CMD ["python", "run.py"]

HUGGINGFACE_README.md

@@ -0,0 +1,75 @@
+# Deploying to Hugging Face Spaces
+
+This guide explains how to deploy the FastAPI backend to Hugging Face Spaces using Docker.
+
+## Prerequisites
+
+1. A Hugging Face account
+2. Git installed on your machine
+3. Docker installed (for local testing)
+
+## Steps to Deploy
+
+1. Create a new Space on Hugging Face:
+   - Go to https://huggingface.co/spaces
+   - Click "Create new Space"
+   - Select "Docker" as the SDK
+   - Choose a name for your space
+   - Set visibility (public/private)
+
+2. Clone the new Space repository:
+```bash
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+```
+
+3. Copy the following files to the cloned repository:
+   - `Dockerfile`
+   - `requirements.txt`
+   - `app/` directory
+   - `templates/` directory
+   - `run.py`
+   - `tabble_new.db`
+
+4. Update your environment variables:
+   - Go to your Space's Settings
+   - Add any necessary environment variables
+   - Make sure to add any sensitive information as secrets
+
+5. Commit and push your changes:
+```bash
+git add .
+git commit -m "Initial commit"
+git push
+```
+
+## Local Testing
+
+Before deploying to Hugging Face, you can test locally using Docker Compose:
+
+1. Build and run the container:
+```bash
+docker-compose up --build
+```
+
+2. Access the API at `http://localhost:7860`
+
+## Important Notes
+
+1. The Dockerfile uses port 7860 as required by Hugging Face Spaces
+2. Make sure your database is properly initialized before deployment
+3. Static files and images should be stored in the appropriate directories
+4. Any changes to the code require a new commit and push to update the Space
+
+## Monitoring
+
+- Monitor your Space's logs through the Hugging Face interface
+- Check the Space's metrics for usage statistics
+- Use the Space's terminal for debugging if needed
+
+## Troubleshooting
+
+If you encounter issues:
+1. Check the Space's logs for error messages
+2. Verify all environment variables are set correctly
+3. Ensure all required files are present in the repository
+4. Test the application locally using Docker Compose before deploying

app/database.py

@@ -0,0 +1,204 @@
+from sqlalchemy import (
+    create_engine,
+    Column,
+    Integer,
+    String,
+    Float,
+    ForeignKey,
+    DateTime,
+    Text,
+    Boolean,
+)
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship
+from datetime import datetime, timezone
+import os
+
+# Database connection - Using SQLite
+DATABASE_URL = "sqlite:///./tabble_new.db"  # Using the new database with offers feature
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+
+# Database models
+class Dish(Base):
+    __tablename__ = "dishes"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, index=True)
+    description = Column(Text, nullable=True)
+    category = Column(String, index=True)
+    price = Column(Float)
+    quantity = Column(Integer, default=0)
+    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
+    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),
+    )
+
+    # Relationship with OrderItem
+    order_items = relationship("OrderItem", back_populates="dish")
+
+
+class Order(Base):
+    __tablename__ = "orders"
+
+    id = Column(Integer, primary_key=True, 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, completed, paid
+    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
+    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)
+    username = Column(String, unique=True, index=True)
+    password = Column(String)
+    phone_number = Column(String, unique=True, index=True, nullable=True)  # Added phone number field
+    visit_count = Column(Integer, default=1)
+    last_visit = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+    # Relationship with Order
+    orders = relationship("Order", back_populates="person")
+
+
+class OrderItem(Base):
+    __tablename__ = "order_items"
+
+    id = Column(Integer, primary_key=True, index=True)
+    order_id = Column(Integer, ForeignKey("orders.id"))
+    dish_id = Column(Integer, ForeignKey("dishes.id"))
+    quantity = Column(Integer, default=1)
+    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)
+    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
+    order = relationship("Order")
+    person = relationship("Person")
+
+
+class LoyaltyProgram(Base):
+    __tablename__ = "loyalty_program"
+
+    id = Column(Integer, primary_key=True, index=True)
+    visit_count = Column(Integer, unique=True)  # 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),
+    )
+
+
+class SelectionOffer(Base):
+    __tablename__ = "selection_offers"
+
+    id = Column(Integer, primary_key=True, 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),
+    )
+
+
+class Table(Base):
+    __tablename__ = "tables"
+
+    id = Column(Integer, primary_key=True, index=True)
+    table_number = Column(Integer, unique=True)  # 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),
+    )
+
+    # Relationship to current order
+    current_order = relationship("Order", foreign_keys=[current_order_id])
+
+
+class Settings(Base):
+    __tablename__ = "settings"
+
+    id = Column(Integer, primary_key=True, 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),
+    )
+
+
+# Create tables
+def create_tables():
+    # Drop the selection_offers table if it exists to force recreation
+    try:
+        SelectionOffer.__table__.drop(engine)
+        print("Dropped selection_offers table to recreate it with the correct schema")
+    except:
+        print("Could not drop selection_offers table, it might not exist yet")
+
+    # Create all tables
+    Base.metadata.create_all(bind=engine)
+
+
+# Get database session
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/main.py

@@ -0,0 +1,126 @@
+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
+
+# 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
+)
+
+# 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")
+
+
+# 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})
+
+
+# Analysis page
+@app.get("/analysis", response_class=HTMLResponse)
+async def analysis_page(request: Request):
+    return templates.TemplateResponse("analysis/index.html", {"request": request})
+
+
+# Chef analysis page
+@app.get("/analysis/chef", response_class=HTMLResponse)
+async def chef_analysis_page(request: Request):
+    return templates.TemplateResponse("analysis/chef.html", {"request": request})
+
+
+# Customer analysis page
+@app.get("/analysis/customer", response_class=HTMLResponse)
+async def customer_analysis_page(request: Request):
+    return templates.TemplateResponse("analysis/customer.html", {"request": request})
+
+
+# Dish analysis page
+@app.get("/analysis/dish", response_class=HTMLResponse)
+async def dish_analysis_page(request: Request):
+    return templates.TemplateResponse("analysis/dish.html", {"request": request})
+
+
+if __name__ == "__main__":
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True)

app/models/dish.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+class DishBase(BaseModel):
+    name: str
+    description: Optional[str] = None
+    category: str
+    price: float
+    quantity: int
+    discount: Optional[float] = 0
+    is_offer: Optional[int] = 0
+    is_special: Optional[int] = 0
+
+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
+
+class Dish(DishBase):
+    id: int
+    image_path: Optional[str] = None
+    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,60 @@
+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
+
+    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