Delete pos_backend

pos_backend/__init__.py

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

pos_backend/app/__init__.py

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

pos_backend/app/api/__init__.py

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

pos_backend/app/api/api_v1/__init__.py

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

pos_backend/app/api/api_v1/api.py

@@ -1,10 +0,0 @@
-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"])

pos_backend/app/api/api_v1/endpoints/__init__.py

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

pos_backend/app/api/api_v1/endpoints/auth.py

@@ -1,13 +0,0 @@
-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)

pos_backend/app/api/api_v1/endpoints/menu.py

@@ -1,19 +0,0 @@
-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()

pos_backend/app/api/api_v1/endpoints/orders.py

@@ -1,36 +0,0 @@
-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)

pos_backend/app/api/api_v1/endpoints/payments.py

@@ -1,27 +0,0 @@
-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)

pos_backend/app/api/api_v1/endpoints/reports.py

@@ -1,36 +0,0 @@
-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)}"
-        )

pos_backend/app/core/config.py

@@ -1,15 +0,0 @@
-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()

pos_backend/app/db/crud.py

@@ -1,200 +0,0 @@
-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

pos_backend/app/db/database.py

@@ -1,83 +0,0 @@
-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

pos_backend/app/main.py

@@ -1,72 +0,0 @@
-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"
-    )

pos_backend/app/models/auth.py

@@ -1,17 +0,0 @@
-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

pos_backend/app/models/database.py

@@ -1,72 +0,0 @@
-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")

pos_backend/app/models/menu.py

@@ -1,32 +0,0 @@
-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

pos_backend/app/models/orders.py

@@ -1,37 +0,0 @@
-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]

pos_backend/app/models/payment.py

@@ -1,24 +0,0 @@
-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

pos_backend/app/models/payments.py

@@ -1,42 +0,0 @@
-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

pos_backend/app/models/reports.py

@@ -1,50 +0,0 @@
-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

pos_backend/app/routes/auth.py

@@ -1,24 +0,0 @@
-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

pos_backend/app/routes/menu.py

@@ -1,52 +0,0 @@
-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()

pos_backend/app/routes/orders.py

@@ -1,63 +0,0 @@
-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()