Upload 77 files

__init__.py

@@ -0,0 +1,3 @@
+"""
+POS Backend Package
+"""

app/__init__.py

@@ -0,0 +1,3 @@
+"""
+POS Backend Application Package
+"""

app/api/__init__.py

@@ -0,0 +1 @@
+# Empty file to mark directory as Python package

app/api/api_v1/__init__.py

@@ -0,0 +1 @@
+# Empty file to mark directory as Python package

app/api/api_v1/api.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+from app.api.api_v1.endpoints import auth, menu, orders, payments, reports
+
+api_router = APIRouter()
+
+api_router.include_router(auth.router, prefix="/auth", tags=["auth"])
+api_router.include_router(menu.router, prefix="/menu", tags=["menu"])
+api_router.include_router(orders.router, prefix="/orders", tags=["orders"])
+api_router.include_router(payments.router, prefix="/payments", tags=["payments"])
+api_router.include_router(reports.router, prefix="/reports", tags=["reports"])

app/api/api_v1/endpoints/__init__.py

@@ -0,0 +1 @@
+# Empty file to mark directory as Python package

app/api/api_v1/endpoints/auth.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter, Depends, HTTPException
+from app.services.auth_service import authenticate_user, create_access_token
+from app.models.auth import LoginRequest, LoginResponse
+
+router = APIRouter()
+
+@router.post("/login", response_model=LoginResponse)
+async def login(user_data: LoginRequest):
+    user = await authenticate_user(user_data.email, user_data.password)
+    if not user:
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+    access_token = create_access_token(data={"sub": user.email})
+    return LoginResponse(access_token=access_token, token_type="bearer", user=user)

app/api/api_v1/endpoints/menu.py

@@ -0,0 +1,19 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from app.services.menu_service import MenuService
+from app.models.menu import MenuItem, Category
+from typing import List
+
+router = APIRouter()
+menu_service = MenuService()
+
+@router.get("/items", response_model=List[MenuItem])
+async def get_menu_items():
+    return await menu_service.get_menu_items()
+
+@router.post("/items", response_model=MenuItem, status_code=status.HTTP_201_CREATED)
+async def create_menu_item(item: MenuItem):
+    return await menu_service.create_menu_item(item)
+
+@router.get("/categories", response_model=List[Category])
+async def get_categories():
+    return await menu_service.get_categories()

app/api/api_v1/endpoints/orders.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter, HTTPException, status, Depends
+from app.services.order_service import OrderService
+from app.models.orders import Order, OrderStatus
+from typing import List
+
+router = APIRouter()
+
+@router.post("/", response_model=Order, status_code=status.HTTP_201_CREATED)
+async def create_order(order: Order, service: OrderService = Depends(OrderService)):
+    return await service.create_order(order)
+
+@router.get("/{order_id}", response_model=Order)
+async def get_order(order_id: int, service: OrderService = Depends(OrderService)):
+    return await service.get_order(order_id)
+
+@router.put("/{order_id}/status", response_model=Order)
+async def update_order_status(
+    order_id: int, 
+    status: OrderStatus,
+    service: OrderService = Depends(OrderService)
+):
+    return await service.update_status(order_id, status)
+
+@router.get("/status/{status}", response_model=List[Order])
+async def get_orders_by_status(
+    status: OrderStatus,
+    service: OrderService = Depends(OrderService)
+):
+    return await service.get_orders_by_status(status)
+
+@router.get("/daily/{date}", response_model=List[Order])
+async def get_daily_orders(
+    date: str,
+    service: OrderService = Depends(OrderService)
+):
+    return await service.get_daily_orders(date)

app/api/api_v1/endpoints/payments.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter, HTTPException, status, Depends
+from app.services.payment_service import PaymentService
+from app.models.payment import Payment, PaymentStatus
+
+router = APIRouter()
+
+@router.post("/", response_model=Payment, status_code=status.HTTP_201_CREATED)
+async def process_payment(
+    payment: Payment,
+    service: PaymentService = Depends(PaymentService)
+):
+    return await service.process_payment(payment)
+
+@router.get("/{payment_id}", response_model=Payment)
+async def get_payment(
+    payment_id: int,
+    service: PaymentService = Depends(PaymentService)
+):
+    return await service.get_payment(payment_id)
+
+@router.put("/{payment_id}/status", response_model=Payment)
+async def update_payment_status(
+    payment_id: int,
+    status: PaymentStatus,
+    service: PaymentService = Depends(PaymentService)
+):
+    return await service.update_status(payment_id, status)

app/api/api_v1/endpoints/reports.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter, Depends
+from app.services.report_service import ReportService
+from app.models.reports import DailyReport, WeeklyReport
+from datetime import date
+from fastapi.responses import JSONResponse
+from fastapi import HTTPException, status
+
+router = APIRouter()
+
+@router.get("/daily/{date}", response_model=DailyReport)
+async def get_daily_report(
+    date: date,
+    service: ReportService = Depends(ReportService)
+):
+    try:
+        return await service.generate_daily_report(date.isoformat())
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to generate daily report: {str(e)}"
+        )
+
+@router.get("/weekly", response_model=WeeklyReport)
+async def get_weekly_report(
+    end_date: date = None,
+    service: ReportService = Depends(ReportService)
+):
+    try:
+        return await service.generate_weekly_report(
+            end_date.isoformat() if end_date else None
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to generate weekly report: {str(e)}"
+        )

app/core/config.py

@@ -0,0 +1,15 @@
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "POS Backend"
+    API_V1_STR: str = "/api/v1"
+    SECRET_KEY: str = "your-secret-key-here"
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+    REFRESH_TOKEN_EXPIRE_DAYS: int = 7
+    DATABASE_URL: str = "postgresql+asyncpg://postgres.juycnkjuzylnbruwaqmp:Lovyelias5584.@aws-0-eu-central-1.pooler.supabase.com:5432/postgres"
+
+    class Config:
+        env_file = ".env"
+
+settings = Settings()

app/db/crud.py

@@ -0,0 +1,200 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, delete, and_, func
+from sqlalchemy.orm import selectinload
+from ..models.database import MenuItem, Order, Payment, User, Category, OrderItem
+from ..models.orders import OrderStatus
+from ..models.payment import PaymentStatus
+from typing import List, Optional, Dict
+from datetime import datetime
+
+# User Operations
+async def get_user_by_email(db: AsyncSession, email: str) -> Optional[User]:
+    result = await db.execute(select(User).where(User.email == email))
+    return result.scalar_one_or_none()
+
+async def create_user(db: AsyncSession, user: User) -> User:
+    db.add(user)
+    await db.commit()
+    await db.refresh(user)
+    return user
+
+# Menu Operations
+async def get_menu_items(db: AsyncSession) -> List[MenuItem]:
+    result = await db.execute(
+        select(MenuItem).options(selectinload(MenuItem.category))
+    )
+    return result.scalars().all()
+
+async def get_menu_item_by_id(db: AsyncSession, item_id: int) -> Optional[MenuItem]:
+    result = await db.execute(
+        select(MenuItem)
+        .options(selectinload(MenuItem.category))
+        .where(MenuItem.id == item_id)
+    )
+    return result.scalar_one_or_none()
+
+async def create_menu_item_db(db: AsyncSession, item: MenuItem) -> MenuItem:
+    db.add(item)
+    await db.commit()
+    await db.refresh(item)
+    return item
+
+async def update_menu_item_db(db: AsyncSession, item_id: int, item: MenuItem) -> Optional[MenuItem]:
+    query = update(MenuItem).where(MenuItem.id == item_id).values(**item.dict(exclude={'id'}))
+    await db.execute(query)
+    await db.commit()
+    return await get_menu_item_by_id(db, item_id)
+
+async def delete_menu_item_db(db: AsyncSession, item_id: int) -> bool:
+    query = delete(MenuItem).where(MenuItem.id == item_id)
+    result = await db.execute(query)
+    await db.commit()
+    return result.rowcount > 0
+
+async def get_categories_db(db: AsyncSession) -> List[Category]:
+    result = await db.execute(select(Category))
+    return result.scalars().all()
+
+# Order Operations
+async def create_order_db(db: AsyncSession, order: Order) -> Order:
+    db.add(order)
+    await db.commit()
+    await db.refresh(order)
+    return order
+
+async def get_order_by_id(db: AsyncSession, order_id: int) -> Optional[Order]:
+    result = await db.execute(
+        select(Order)
+        .options(selectinload(Order.items))
+        .where(Order.id == order_id)
+    )
+    return result.scalar_one_or_none()
+
+async def update_order_status(db: AsyncSession, order_id: int, new_status: OrderStatus) -> Order:
+    """Update the status of an order."""
+    query = update(Order).where(Order.id == order_id).values(status=new_status)
+    await db.execute(query)
+    await db.commit()
+    return await get_order_by_id(db, order_id)
+
+async def get_orders_by_status(db: AsyncSession, status: OrderStatus) -> List[Order]:
+    """Get all orders with a specific status."""
+    result = await db.execute(
+        select(Order)
+        .options(selectinload(Order.items))
+        .where(Order.status == status)
+        .order_by(Order.created_at.desc())
+    )
+    return result.scalars().all()
+
+async def get_orders_by_date_range(db: AsyncSession, start_date: str, end_date: str) -> List[Order]:
+    """Get orders within a date range."""
+    start = datetime.strptime(start_date, "%Y-%m-%d")
+    end = datetime.strptime(end_date, "%Y-%m-%d").replace(hour=23, minute=59, second=59)
+    
+    result = await db.execute(
+        select(Order)
+        .options(selectinload(Order.items))
+        .where(and_(Order.created_at >= start, Order.created_at <= end))
+        .order_by(Order.created_at.desc())
+    )
+    return result.scalars().all()
+
+# Payment Operations
+async def create_payment_db(db: AsyncSession, payment: Payment) -> Payment:
+    db.add(payment)
+    await db.commit()
+    await db.refresh(payment)
+    return payment
+
+async def get_payment_by_id(db: AsyncSession, payment_id: int) -> Optional[Payment]:
+    result = await db.execute(select(Payment).where(Payment.id == payment_id))
+    return result.scalar_one_or_none()
+
+async def update_payment_status(db: AsyncSession, payment_id: int, new_status: PaymentStatus) -> Optional[Payment]:
+    """Update the status of a payment transaction."""
+    query = (
+        update(Payment)
+        .where(Payment.id == payment_id)
+        .values(
+            status=new_status,
+            updated_at=datetime.utcnow()
+        )
+    )
+    await db.execute(query)
+    await db.commit()
+    return await get_payment_by_id(db, payment_id)
+
+# Report Operations
+async def get_sales_by_date_range(db: AsyncSession, start_date: str, end_date: str) -> List[Order]:
+    """Get all sales within a date range."""
+    start = datetime.fromisoformat(start_date)
+    end = datetime.fromisoformat(end_date).replace(hour=23, minute=59, second=59)
+    
+    result = await db.execute(
+        select(Order)
+        .options(selectinload(Order.items))
+        .where(
+            and_(
+                Order.created_at >= start,
+                Order.created_at <= end,
+                Order.status == OrderStatus.COMPLETED
+            )
+        )
+        .order_by(Order.created_at.desc())
+    )
+    return result.scalars().all()
+
+async def get_top_selling_items(db: AsyncSession, date: str, limit: int = 5) -> List[Dict]:
+    """Get top selling items for a specific date."""
+    day_start = datetime.fromisoformat(date)
+    day_end = day_start.replace(hour=23, minute=59, second=59)
+    
+    result = await db.execute(
+        select(
+            MenuItem.name,
+            func.sum(OrderItem.quantity).label('total_quantity'),
+            func.sum(OrderItem.quantity * OrderItem.unit_price).label('total_revenue')
+        )
+        .join(OrderItem, MenuItem.id == OrderItem.menu_item_id)
+        .join(Order, OrderItem.order_id == Order.id)
+        .where(
+            and_(
+                Order.created_at >= day_start,
+                Order.created_at <= day_end,
+                Order.status == OrderStatus.COMPLETED
+            )
+        )
+        .group_by(MenuItem.id, MenuItem.name)
+        .order_by(func.sum(OrderItem.quantity).desc())
+        .limit(limit)
+    )
+    
+    return [
+        {
+            "item_name": row[0],
+            "quantity_sold": row[1],
+            "total_revenue": row[2]
+        }
+        for row in result.all()
+    ]
+
+async def get_daily_revenue(db: AsyncSession, date: str) -> float:
+    """Get total revenue for a specific date."""
+    day_start = datetime.fromisoformat(date)
+    day_end = day_start.replace(hour=23, minute=59, second=59)
+    
+    result = await db.execute(
+        select(func.sum(Payment.amount))
+        .join(Order, Payment.order_id == Order.id)
+        .where(
+            and_(
+                Payment.created_at >= day_start,
+                Payment.created_at <= day_end,
+                Payment.status == PaymentStatus.COMPLETED
+            )
+        )
+    )
+    
+    total = result.scalar_one_or_none()
+    return float(total) if total is not None else 0.0

app/db/database.py

@@ -0,0 +1,83 @@
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy import text
+from ..core.config import settings
+import logging
+import ssl
+import platform
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+def get_ssl_context():
+    """Create an SSL context for database connection."""
+    ssl_context = ssl.create_default_context()
+    ssl_context.check_hostname = False
+    ssl_context.verify_mode = ssl.CERT_NONE
+    return ssl_context
+
+# Configure Windows-specific event loop policy
+if platform.system() == 'Windows':
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+# Create async engine with connection pooling
+engine = create_async_engine(
+    settings.DATABASE_URL,
+    echo=True,
+    pool_pre_ping=True,
+    pool_size=20,
+    max_overflow=10,
+    pool_timeout=30,
+    connect_args={
+        "ssl": get_ssl_context(),
+        "server_settings": {
+            "application_name": "pos_backend",
+            "statement_timeout": "60000",  # 60 seconds
+        }
+    }
+)
+
+# Create async session maker with pooling configuration
+async_session_maker = async_sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autocommit=False,
+    autoflush=False
+)
+
+class Base(DeclarativeBase):
+    pass
+
+async def verify_connection():
+    try:
+        async with engine.connect() as conn:
+            await conn.execute(text("SELECT 1"))
+            logger.info("Database connection verified successfully")
+            return True
+    except Exception as e:
+        logger.error(f"Database connection failed: {str(e)}")
+        raise
+
+async def get_db():
+    async with async_session_maker() as session:
+        try:
+            await verify_connection()
+            yield session
+            await session.commit()
+        except Exception as e:
+            logger.error(f"Database session error: {str(e)}")
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+
+async def init_db():
+    try:
+        await verify_connection()
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        logger.info("Database initialized successfully")
+    except Exception as e:
+        logger.error(f"Database initialization failed: {str(e)}")
+        raise

app/main.py

@@ -0,0 +1,72 @@
+import os
+import sys
+from pathlib import Path
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from .core.config import settings
+from .api.api_v1.api import api_router
+from .db.database import init_db
+import logging
+import asyncio
+
+# Set up Python path
+BASE_DIR = Path(__file__).resolve().parent.parent
+sys.path.append(str(BASE_DIR))
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title=settings.PROJECT_NAME,
+        openapi_url=f"{settings.API_V1_STR}/openapi.json"
+    )
+
+    # Configure CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include API router
+    app.include_router(api_router, prefix=settings.API_V1_STR)
+
+    @app.exception_handler(HTTPException)
+    async def http_exception_handler(request, exc):
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={"detail": exc.detail}
+        )
+
+    @app.get("/")
+    async def root():
+        return {"message": "POS Backend API", "version": "1.0.0"}
+
+    @app.on_event("startup")
+    async def startup_event():
+        try:
+            await init_db()
+            logger.info("Database initialized successfully")
+        except Exception as e:
+            logger.error(f"Failed to initialize database: {e}")
+            raise
+
+    return app
+
+app = create_app()
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    uvicorn.run(
+        "app.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )

app/models/auth.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel, EmailStr, Field
+from typing import Optional
+
+class LoginRequest(BaseModel):
+    email: EmailStr
+    password: str = Field(..., min_length=6)
+
+class LoginResponse(BaseModel):
+    access_token: str
+    token_type: str
+    user: 'UserProfile'
+
+class UserProfile(BaseModel):
+    id: Optional[int] = None
+    email: EmailStr
+    full_name: str
+    role: str

app/models/database.py

@@ -0,0 +1,72 @@
+from sqlalchemy import Column, Integer, String, Float, ForeignKey, DateTime, Boolean, JSON, Enum
+from sqlalchemy.orm import relationship
+from datetime import datetime
+from .menu import CategoryType
+from ..db.database import Base
+
+class User(Base):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True)
+    full_name = Column(String)
+    hashed_password = Column(String)
+    role = Column(String)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+class Category(Base):
+    __tablename__ = "categories"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, index=True)
+    type = Column(Enum(CategoryType))
+    description = Column(String, nullable=True)
+    items = relationship("MenuItem", back_populates="category")
+
+class MenuItem(Base):
+    __tablename__ = "menu_items"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, index=True)
+    description = Column(String, nullable=True)
+    price = Column(Float)
+    category_id = Column(Integer, ForeignKey("categories.id"))
+    image_url = Column(String, nullable=True)
+    is_available = Column(Boolean, default=True)
+    allergens = Column(JSON, nullable=True)
+    preparation_time = Column(Integer, nullable=True)
+    category = relationship("Category", back_populates="items")
+
+class Order(Base):
+    __tablename__ = "orders"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    total_amount = Column(Float)
+    status = Column(String)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    items = relationship("OrderItem", back_populates="order")
+    payment = relationship("Payment", back_populates="order")
+
+class OrderItem(Base):
+    __tablename__ = "order_items"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    order_id = Column(Integer, ForeignKey("orders.id"))
+    menu_item_id = Column(Integer, ForeignKey("menu_items.id"))
+    quantity = Column(Integer)
+    unit_price = Column(Float)
+    order = relationship("Order", back_populates="items")
+    menu_item = relationship("MenuItem")
+
+class Payment(Base):
+    __tablename__ = "payments"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    order_id = Column(Integer, ForeignKey("orders.id"))
+    amount = Column(Float)
+    method = Column(String)
+    status = Column(String)
+    transaction_id = Column(String, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    order = relationship("Order", back_populates="payment")

app/models/menu.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from decimal import Decimal
+from enum import Enum
+
+class CategoryType(str, Enum):
+    SOUPS = "soups"              # For Egusi, Efo riro, Ogbono, etc.
+    SWALLOW = "swallow"          # For Pounded yam, Amala, Eba, etc.
+    RICE_DISHES = "rice_dishes"  # For Jollof rice, Fried rice, Native rice
+    PROTEINS = "proteins"        # For Suya, Asun, Grilled fish, etc.
+    SMALL_CHOPS = "small_chops"  # For Puff puff, Samosa, Spring rolls
+    PEPPER_SOUP = "pepper_soup"  # For various pepper soup varieties
+    SIDES = "sides"              # For Plantains, Moin moin, etc.
+    DRINKS = "drinks"            # For Nigerian drinks and beverages
+
+class Category(BaseModel):
+    id: Optional[int] = None
+    name: str
+    type: CategoryType
+    description: Optional[str] = None
+    
+class MenuItem(BaseModel):
+    id: Optional[int] = None
+    name: str
+    description: Optional[str] = None
+    price: Decimal = Field(..., gt=0)
+    category_id: int
+    image_url: Optional[str] = None
+    is_available: bool = True
+    allergens: Optional[List[str]] = None
+    preparation_time: Optional[int] = None  # in minutes
+    calories: Optional[int] = None

app/models/orders.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel
+from typing import List, Optional
+from datetime import datetime
+from enum import Enum
+
+class OrderStatus(str, Enum):
+    PENDING = "pending"
+    PREPARING = "preparing"
+    READY = "ready"
+    DELIVERED = "delivered"
+    CANCELLED = "cancelled"
+
+class OrderItem(BaseModel):
+    menu_item_id: int
+    quantity: int
+    unit_price: float
+    notes: Optional[str] = None
+
+class Order(BaseModel):
+    id: Optional[int] = None
+    customer_id: int
+    items: List[OrderItem]
+    total_amount: float
+    status: OrderStatus
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+class OrderDetails(Order):
+    payment_status: str
+    server_name: str
+    table_number: Optional[int] = None
+
+class OrderStats(BaseModel):
+    total_orders: int
+    total_revenue: float
+    average_order_value: float
+    orders_by_status: dict[OrderStatus, int]

app/models/payment.py

@@ -0,0 +1,24 @@
+from enum import Enum
+from pydantic import BaseModel, Field
+from datetime import datetime
+from typing import Optional
+
+class PaymentMethod(str, Enum):
+    CASH = "cash"
+    CARD = "card"
+
+class PaymentStatus(str, Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+class Payment(BaseModel):
+    id: Optional[int] = None
+    order_id: int
+    amount: float = Field(..., gt=0)
+    method: PaymentMethod
+    status: PaymentStatus = PaymentStatus.PENDING
+    transaction_id: Optional[str] = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: Optional[datetime] = None

app/models/payments.py

@@ -0,0 +1,42 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+from decimal import Decimal
+from enum import Enum
+
+class PaymentMethod(str, Enum):
+    CASH = "cash"
+    CREDIT_CARD = "credit_card"
+    DEBIT_CARD = "debit_card"
+    MOBILE_PAYMENT = "mobile_payment"
+
+class PaymentStatus(str, Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    REFUNDED = "refunded"
+
+class PaymentSession(BaseModel):
+    id: str
+    order_id: int
+    amount: Decimal
+    payment_method: PaymentMethod
+    status: PaymentStatus
+    created_at: datetime
+
+class PaymentVerification(BaseModel):
+    payment_id: str
+    verification_code: str
+    status: PaymentStatus
+    message: Optional[str] = None
+
+class Transaction(BaseModel):
+    id: str
+    order_id: int
+    amount: Decimal
+    payment_method: PaymentMethod
+    status: PaymentStatus
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+    reference_id: Optional[str] = None

app/models/reports.py

@@ -0,0 +1,50 @@
+from pydantic import BaseModel
+from typing import Dict, List
+from datetime import datetime
+from decimal import Decimal
+
+class TopSellingItem(BaseModel):
+    item_name: str
+    quantity_sold: int
+    total_revenue: float
+
+class DailyReport(BaseModel):
+    date: str
+    total_sales: int
+    total_revenue: float
+    top_selling_items: List[TopSellingItem]
+
+class DailyBreakdown(BaseModel):
+    date: str
+    revenue: float
+
+class WeeklyReport(BaseModel):
+    period: str
+    total_sales: int
+    daily_breakdown: List[DailyBreakdown]
+
+# Future report models
+class SalesReport(BaseModel):
+    total_sales: Decimal
+    sales_by_category: Dict[str, Decimal]
+    sales_by_item: Dict[str, Decimal]
+    sales_by_hour: Dict[int, Decimal]
+    average_order_value: Decimal
+    peak_hours: List[int]
+    period_start: datetime
+    period_end: datetime
+
+class InventoryReport(BaseModel):
+    items_in_stock: Dict[str, int]
+    low_stock_items: List[str]
+    out_of_stock_items: List[str]
+    total_inventory_value: Decimal
+    last_updated: datetime
+
+class PerformanceMetrics(BaseModel):
+    order_fulfillment_time: Dict[str, float]  # avg time in minutes by order type
+    server_performance: Dict[str, Dict[str, float]]  # metrics by server
+    customer_satisfaction: float
+    busy_periods: List[Dict[str, str]]
+    period_start: datetime
+    period_end: datetime

app/routes/auth.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.security import OAuth2PasswordRequestForm
+from ..models.auth import LoginRequest, LoginResponse, UserProfile
+from ..core.auth import get_current_user
+from ..services.auth_service import authenticate_user, create_access_token
+
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+@router.post("/login", response_model=LoginResponse)
+async def login(form_data: OAuth2PasswordRequestForm = Depends()):
+    user = await authenticate_user(form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(status_code=401, detail="Incorrect email or password")
+    access_token = create_access_token(data={"sub": user.email})
+    return LoginResponse(access_token=access_token)
+
+@router.post("/logout")
+async def logout(current_user = Depends(get_current_user)):
+    # TODO: Implement token blacklisting or session invalidation
+    return {"message": "Successfully logged out"}
+
+@router.get("/profile", response_model=UserProfile)
+async def get_profile(current_user = Depends(get_current_user)):
+    return current_user

app/routes/menu.py

@@ -0,0 +1,52 @@
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List
+from ..models.menu import MenuItem, Category
+from ..core.auth import get_current_user
+from ..services.menu_service import MenuService
+
+router = APIRouter(prefix="/api/menu", tags=["menu"])
+
+@router.get("", response_model=List[MenuItem])
+async def get_menu_items(
+    current_user = Depends(get_current_user),
+    menu_service: MenuService = Depends()
+):
+    return await menu_service.get_menu_items()
+
+@router.post("", response_model=MenuItem)
+async def create_menu_item(
+    item: MenuItem,
+    current_user = Depends(get_current_user),
+    menu_service: MenuService = Depends()
+):
+    return await menu_service.create_menu_item(item)
+
+@router.put("/{item_id}", response_model=MenuItem)
+async def update_menu_item(
+    item_id: int,
+    item: MenuItem,
+    current_user = Depends(get_current_user),
+    menu_service: MenuService = Depends()
+):
+    updated_item = await menu_service.update_menu_item(item_id, item)
+    if not updated_item:
+        raise HTTPException(status_code=404, detail="Menu item not found")
+    return updated_item
+
+@router.delete("/{item_id}")
+async def delete_menu_item(
+    item_id: int,
+    current_user = Depends(get_current_user),
+    menu_service: MenuService = Depends()
+):
+    success = await menu_service.delete_menu_item(item_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Menu item not found")
+    return {"message": "Menu item deleted successfully"}
+
+@router.get("/categories", response_model=List[Category])
+async def get_categories(
+    current_user = Depends(get_current_user),
+    menu_service: MenuService = Depends()
+):
+    return await menu_service.get_categories()

app/routes/orders.py

@@ -0,0 +1,63 @@
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List
+from ..models.orders import Order, OrderDetails, OrderStats
+from ..core.auth import get_current_user
+from ..services.order_service import OrderService
+
+router = APIRouter(prefix="/api/orders", tags=["orders"])
+
+@router.get("", response_model=List[Order])
+async def get_orders(
+    current_user = Depends(get_current_user),
+    order_service: OrderService = Depends()
+):
+    return await order_service.get_orders()
+
+@router.post("", response_model=Order)
+async def create_order(
+    order: Order,
+    current_user = Depends(get_current_user),
+    order_service: OrderService = Depends()
+):
+    return await order_service.create_order(order)
+
+@router.get("/{order_id}", response_model=OrderDetails)
+async def get_order(
+    order_id: int,
+    current_user = Depends(get_current_user),
+    order_service: OrderService = Depends()
+):
+    order = await order_service.get_order(order_id)
+    if not order:
+        raise HTTPException(status_code=404, detail="Order not found")
+    return order
+
+@router.put("/{order_id}", response_model=Order)
+async def update_order(
+    order_id: int,
+    order: Order,
+    current_user = Depends(get_current_user),
+    order_service: OrderService = Depends()
+):
+    updated_order = await order_service.update_order(order_id, order)
+    if not updated_order:
+        raise HTTPException(status_code=404, detail="Order not found")
+    return updated_order
+
+@router.delete("/{order_id}")
+async def delete_order(
+    order_id: int,
+    current_user = Depends(get_current_user),
+    order_service: OrderService = Depends()
+):
+    success = await order_service.delete_order(order_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Order not found")
+    return {"message": "Order deleted successfully"}
+
+@router.get("/stats", response_model=OrderStats)
+async def get_order_stats(
+    current_user = Depends(get_current_user),
+    order_service: OrderService = Depends()
+):
+    return await order_service.get_stats()