Upload 82 files

app/api/analytics.py

@@ -1,11 +1,11 @@
 from fastapi import APIRouter, Depends, Query, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, func, cast, Date, and_
+from sqlalchemy import select, func, cast, Date, and_, distinct
 from datetime import datetime, timedelta
 from typing import Dict, Any, Optional
 from ..core.dependencies import get_current_active_user
 from ..db.database import get_db
-from ..db.models import Order, Product, User
+from ..db.models import Order, Product, User, Brand
 
 router = APIRouter()
 
@@ -198,35 +198,153 @@ async def get_customer_analytics(
     }
 
 @router.get("/dashboard")
-async def get_dashboard_analytics(
-    branch_id: Optional[int] = Query(None, description="Filter analytics by branch"),
+async def get_dashboard_metrics(
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
     current_user: User = Depends(get_current_active_user),
     db: AsyncSession = Depends(get_db)
 ) -> Dict[str, Any]:
-    """Get a comprehensive dashboard with key metrics"""
-    # Get last 30 days of sales data
-    start_date = datetime.now() - timedelta(days=30)
-    end_date = datetime.now()
+    # Parse dates or use last 30 days as default
+    end = datetime.now() if not end_date else datetime.fromisoformat(end_date)
+    start = (end - timedelta(days=30)) if not start_date else datetime.fromisoformat(start_date)
     
-    sales_data = await get_sales_analytics(start_date, end_date, branch_id, current_user, db)
-    product_data = await get_product_analytics(branch_id, current_user, db)
-    customer_data = await get_customer_analytics(branch_id, current_user, db)
+    # Get current period metrics
+    current_metrics = await get_period_metrics(db, start, end, current_user)
     
-    return {
-        "sales_summary": {
-            "total_revenue": sales_data["total_revenue"],
-            "total_orders": sales_data["total_orders"],
-            "average_order_value": sales_data["average_order_value"],
-            "daily_sales": sales_data["daily_sales"][-7:]  # Last 7 days
+    # Get previous period metrics for comparison
+    prev_start = start - timedelta(days=30)
+    prev_end = end - timedelta(days=30)
+    prev_metrics = await get_period_metrics(db, prev_start, prev_end, current_user)
+    
+    # Calculate deltas and trends
+    metrics = {
+        "revenue": {
+            "total": current_metrics["revenue"],
+            "delta": calculate_delta(current_metrics["revenue"], prev_metrics["revenue"]),
+            "trend": "up" if current_metrics["revenue"] > prev_metrics["revenue"] else "down"
         },
-        "product_summary": {
-            "total_products": product_data["total_products"],
-            "low_stock_products": product_data["low_stock_products"],
-            "top_selling_products": product_data["top_products"][:5]  # Top 5 products
+        "orders": {
+            "total": current_metrics["orders"],
+            "delta": calculate_delta(current_metrics["orders"], prev_metrics["orders"]),
+            "trend": "up" if current_metrics["orders"] > prev_metrics["orders"] else "down"
         },
-        "customer_summary": {
-            "total_customers": customer_data["total_customers"],
-            "average_customer_value": customer_data["average_customer_value"],
-            "customer_segments": customer_data["customer_segments"]
+        "voids": {
+            "total": current_metrics["voids"],
+            "delta": calculate_delta(current_metrics["voids"], prev_metrics["voids"]),
+            "trend": "up" if current_metrics["voids"] > prev_metrics["voids"] else "down"
+        },
+        "stock": {
+            "total": current_metrics["stock_total"],
+            "items_below_threshold": current_metrics["stock_low"]
+        }
+    }
+
+    # Get traffic sources data
+    traffic_sources = {
+        "direct": {"value": 45, "trend": "up", "delta": 12.5},
+        "social": {"value": 25, "trend": "down", "delta": -5.0},
+        "marketing": {"value": 20, "trend": "up", "delta": 8.2},
+        "affiliates": {"value": 10, "trend": "down", "delta": -2.1}
+    }
+
+    # Get financial overview
+    overview = {
+        "revenue": {"value": current_metrics["revenue"], "trend": "up" if current_metrics["revenue"] > prev_metrics["revenue"] else "down"},
+        "expenses": {"value": current_metrics["expenses"], "trend": "up" if current_metrics["expenses"] > prev_metrics["expenses"] else "down"},
+        "investment": {"value": current_metrics["investment"]},
+        "savings": {"value": current_metrics["savings"]}
+    }
+
+    return {
+        "metrics": metrics,
+        "traffic_sources": traffic_sources,
+        "overview": overview
+    }
+
+@router.get("/brands")
+async def get_brands_analytics(
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> Dict[str, Any]:
+    # Get brands with their associated metrics
+    query = select(
+        Brand,
+        func.count(Product.id).label("product_count"),
+        func.count(distinct(Product.branch_id)).label("store_count")
+    ).outerjoin(Product).group_by(Brand.id)
+    
+    result = await db.execute(query)
+    brands_data = result.all()
+    
+    # Calculate totals
+    total_brands = len(brands_data)
+    active_brands = sum(1 for row in brands_data if row.Brand.is_active)
+    
+    # Format brand details
+    brands = [
+        {
+            "name": row.Brand.name,
+            "category": row.Brand.category,
+            "established": row.Brand.established_date.strftime("%Y-%m-%d"),
+            "stores": row.store_count,
+            "products": row.product_count,
+            "status": "Active" if row.Brand.is_active else "Inactive"
         }
-    }
+        for row in brands_data
+    ]
+    
+    return {
+        "total": total_brands,
+        "active": active_brands,
+        "brands": brands
+    }
+
+async def get_period_metrics(
+    db: AsyncSession,
+    start_date: datetime,
+    end_date: datetime,
+    current_user: User
+) -> Dict[str, Any]:
+    # Base query conditions
+    conditions = [
+        Order.created_at.between(start_date, end_date)
+    ]
+    
+    if not current_user.is_superuser:
+        conditions.append(Order.branch_id == current_user.branch_id)
+
+    # Get revenue and orders metrics
+    metrics_query = select(
+        func.sum(Order.total_amount).label("revenue"),
+        func.count().label("orders"),
+        func.sum(case((Order.status == "void", 1), else_=0)).label("voids"),
+        func.sum(Order.expenses).label("expenses")
+    ).where(and_(*conditions))
+    
+    result = await db.execute(metrics_query)
+    row = result.first()
+
+    # Get stock metrics
+    stock_query = select(
+        func.count(Product.id).label("total"),
+        func.sum(case((Product.stock_level < Product.reorder_threshold, 1), else_=0)).label("low_stock")
+    )
+    
+    stock_result = await db.execute(stock_query)
+    stock_row = stock_result.first()
+
+    return {
+        "revenue": float(row.revenue or 0),
+        "orders": int(row.orders or 0),
+        "voids": int(row.voids or 0),
+        "expenses": float(row.expenses or 0),
+        "investment": 50000.00,  # Example fixed value, replace with actual calculation
+        "savings": 25000.00,     # Example fixed value, replace with actual calculation
+        "stock_total": int(stock_row.total or 0),
+        "stock_low": int(stock_row.low_stock or 0)
+    }
+
+def calculate_delta(current: float, previous: float) -> float:
+    if previous == 0:
+        return 100 if current > 0 else 0
+    return ((current - previous) / previous) * 100

app/api/auth.py

@@ -1,82 +1,82 @@
-from fastapi import APIRouter, Depends, HTTPException, status, Form, Body
-from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
-from sqlalchemy.orm import selectinload
-from ..core.security import create_access_token, verify_password, get_password_hash
-from ..db.database import get_db
-from ..db.models import User
-from ..db.schemas import UserCreate, UserInDB, LoginData
-from datetime import timedelta
-from typing import Any
-
-router = APIRouter()
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-@router.post("/login/form")
-async def login_form(
-    form_data: OAuth2PasswordRequestForm = Depends(),
-    db: AsyncSession = Depends(get_db)
-) -> Any:
-    return await authenticate_user(db, form_data.username, form_data.password)
-
-@router.post("/login")
-async def login_json(
-    login_data: LoginData,
-    db: AsyncSession = Depends(get_db)
-) -> Any:
-    return await authenticate_user(db, login_data.email, login_data.password)
-
-async def authenticate_user(db: AsyncSession, email: str, password: str) -> dict:
-    stmt = select(User).where(User.email == email)
-    result = await db.execute(stmt)
-    user = result.scalar_one_or_none()
-    
-    if not user:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Incorrect email or password",
-        )
-    
-    if not verify_password(password, user.hashed_password):
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Incorrect email or password",
-        )
-    
-    access_token = create_access_token(user.id)
-    return {"access_token": access_token, "token_type": "bearer"}
-
-@router.post("/register", response_model=UserInDB)
-async def register(
-    user_data: UserCreate,
-    db: AsyncSession = Depends(get_db)
-) -> Any:
-    # Check if user exists by email
-    stmt = select(User).where(User.email == user_data.email)
-    result = await db.execute(stmt)
-    if result.scalar_one_or_none():
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Email already registered",
-        )
-
-    # Create new user
-    user = User(
-        email=user_data.email,
-        full_name=user_data.full_name,
-        hashed_password=get_password_hash(user_data.password),
-        is_active=user_data.is_active,
-        is_superuser=user_data.is_superuser,
-        branch_id=user_data.branch_id
-    )
-
-    db.add(user)
-    await db.commit()
-    
-    # Refresh user with roles relationship loaded
-    stmt = select(User).options(selectinload(User.roles)).where(User.id == user.id)
-    result = await db.execute(stmt)
-    user = result.scalar_one()
-
-    return user
+from fastapi import APIRouter, Depends, HTTPException, status, Form, Body
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from sqlalchemy.orm import selectinload
+from ..core.security import create_access_token, verify_password, get_password_hash
+from ..db.database import get_db
+from ..db.models import User
+from ..db.schemas import UserCreate, UserInDB, LoginData
+from datetime import timedelta
+from typing import Any
+
+router = APIRouter()
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+@router.post("/login/form")
+async def login_form(
+    form_data: OAuth2PasswordRequestForm = Depends(),
+    db: AsyncSession = Depends(get_db)
+) -> Any:
+    return await authenticate_user(db, form_data.username, form_data.password)
+
+@router.post("/login")
+async def login_json(
+    login_data: LoginData,
+    db: AsyncSession = Depends(get_db)
+) -> Any:
+    return await authenticate_user(db, login_data.email, login_data.password)
+
+async def authenticate_user(db: AsyncSession, email: str, password: str) -> dict:
+    stmt = select(User).where(User.email == email)
+    result = await db.execute(stmt)
+    user = result.scalar_one_or_none()
+    
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+        )
+    
+    if not verify_password(password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+        )
+    
+    access_token = create_access_token(user.id)
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@router.post("/register", response_model=UserInDB)
+async def register(
+    user_data: UserCreate,
+    db: AsyncSession = Depends(get_db)
+) -> Any:
+    # Check if user exists by email
+    stmt = select(User).where(User.email == user_data.email)
+    result = await db.execute(stmt)
+    if result.scalar_one_or_none():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Email already registered",
+        )
+
+    # Create new user
+    user = User(
+        email=user_data.email,
+        full_name=user_data.full_name,
+        hashed_password=get_password_hash(user_data.password),
+        is_active=user_data.is_active,
+        is_superuser=user_data.is_superuser,
+        branch_id=user_data.branch_id
+    )
+
+    db.add(user)
+    await db.commit()
+    
+    # Refresh user with roles relationship loaded
+    stmt = select(User).options(selectinload(User.roles)).where(User.id == user.id)
+    result = await db.execute(stmt)
+    user = result.scalar_one()
+
+    return user

app/api/maintenance.py

@@ -3,10 +3,13 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, delete, func
 from typing import Dict, Any, List
 from datetime import datetime, timedelta
-from ..core.dependencies import get_current_active_user
+from ..core.dependencies import get_current_active_user, get_db
 from ..db.database import get_db
 from ..db.models import User, Order, Notification, Event
 from ..utils.logger import logger
+from ..services.maintenance import maintenance_service
+from ..services.pos_analytics import pos_analytics
+import asyncio
 
 router = APIRouter()
 
@@ -130,4 +133,91 @@ async def perform_db_maintenance(
         raise HTTPException(
             status_code=500,
             detail=f"Database maintenance failed: {str(e)}"
-        )
+        )
+
+@router.get("/health")
+async def health_check() -> Dict[str, Any]:
+    """Public health check endpoint that doesn't require authentication"""
+    return {
+        "status": "healthy",
+        "timestamp": maintenance_service.get_timestamp()
+    }
+
+@router.get("/system-status")
+async def get_system_status(
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> Dict[str, Any]:
+    """Get detailed system status including POS integration health"""
+    if not current_user.is_superuser:
+        raise HTTPException(
+            status_code=403,
+            detail="Only superusers can access system status"
+        )
+
+    # Check database connectivity
+    db_status = await maintenance_service.check_database()
+    
+    # Check POS integration
+    pos_status = await pos_analytics.health_check()
+    
+    # Check Redis connectivity
+    redis_status = await maintenance_service.check_redis()
+    
+    # Check background tasks
+    tasks_status = await maintenance_service.check_background_tasks()
+    
+    return {
+        "status": "healthy",
+        "timestamp": maintenance_service.get_timestamp(),
+        "components": {
+            "database": db_status,
+            "redis": redis_status,
+            "background_tasks": tasks_status,
+            "pos_integration": pos_status
+        }
+    }
+
+@router.post("/sync/pos-metrics")
+async def trigger_pos_sync(
+    current_user: User = Depends(get_current_active_user)
+) -> Dict[str, Any]:
+    """Manually trigger POS metrics synchronization"""
+    if not current_user.is_superuser:
+        raise HTTPException(
+            status_code=403,
+            detail="Only superusers can trigger manual sync"
+        )
+    
+    try:
+        success = await pos_analytics.sync_all_metrics()
+        return {
+            "status": "success" if success else "partial_failure",
+            "message": "POS metrics sync completed successfully" if success else "Some metrics failed to sync"
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to sync POS metrics: {str(e)}"
+        )
+
+@router.get("/sync/status")
+async def get_sync_status(
+    current_user: User = Depends(get_current_active_user)
+) -> Dict[str, Any]:
+    """Get status of background sync tasks"""
+    if not current_user.is_superuser:
+        raise HTTPException(
+            status_code=403,
+            detail="Only superusers can view sync status"
+        )
+    
+    tasks_status = await maintenance_service.check_background_tasks()
+    pos_health = await pos_analytics.health_check()
+    
+    return {
+        "background_tasks": tasks_status,
+        "pos_integration": pos_health,
+        "last_sync_timestamp": maintenance_service.get_last_sync_time(),
+        "next_sync_due": maintenance_service.get_next_sync_time()
+    }

app/api/orders.py

@@ -1,209 +1,209 @@
-from fastapi import APIRouter, HTTPException, status, Depends, Query
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
-from typing import List, Optional
-from ..core.dependencies import get_current_active_user
-from ..db.database import get_db
-from ..db.models import Order, Product, OrderItem, User
-from ..db.schemas import OrderCreate, OrderInDB
-from ..services.pos_client import get_orders, OrderSchema
-from datetime import datetime
-
-router = APIRouter()
-
-@router.post("/", response_model=OrderInDB)
-async def create_order(
-    order: OrderCreate,
-    current_user: User = Depends(get_current_active_user),
-    db: AsyncSession = Depends(get_db)
-) -> OrderInDB:
-    # Ensure user belongs to the branch they're creating the order for
-    if current_user.branch_id != order.branch_id and not current_user.is_superuser:
-        raise HTTPException(
-            status_code=403,
-            detail="You can only create orders for your own branch"
-        )
-
-    # Calculate total and validate products
-    total = 0
-    order_items = []
-    
-    for item in order.items:
-        # Get product
-        stmt = select(Product).where(
-            Product.id == item.product_id,
-            Product.branch_id == order.branch_id  # Ensure product belongs to the same branch
-        )
-        result = await db.execute(stmt)
-        product = result.scalar_one_or_none()
-        
-        if not product:
-            raise HTTPException(
-                status_code=404, 
-                detail=f"Product {item.product_id} not found in this branch"
-            )
-        
-        if product.inventory_count < item.quantity:
-            raise HTTPException(
-                status_code=400, 
-                detail=f"Insufficient inventory for product {item.product_id}"
-            )
-        
-        # Update inventory
-        product.inventory_count -= item.quantity
-        total += product.price * item.quantity
-        
-        # Create order item
-        order_item = OrderItem(
-            product_id=item.product_id,
-            quantity=item.quantity,
-            price=product.price
-        )
-        order_items.append(order_item)
-    
-    # Create order
-    db_order = Order(
-        customer_id=order.customer_id,
-        branch_id=order.branch_id,
-        total_amount=total,
-        status="pending",
-        items=order_items
-    )
-    
-    db.add(db_order)
-    await db.commit()
-    await db.refresh(db_order)
-    return db_order
-
-@router.get("/", response_model=List[OrderInDB])
-async def list_orders(
-    skip: int = 0,
-    limit: int = 10,
-    status: Optional[str] = None,
-    branch_id: Optional[int] = Query(None, description="Filter orders by branch"),
-    current_user: User = Depends(get_current_active_user),
-    db: AsyncSession = Depends(get_db)
-) -> List[OrderInDB]:
-    query = select(Order)
-    
-    # Filter by status if provided
-    if status:
-        query = query.where(Order.status == status)
-    
-    # Filter by branch if provided, otherwise use user's branch
-    if branch_id:
-        if not current_user.is_superuser and branch_id != current_user.branch_id:
-            raise HTTPException(
-                status_code=403,
-                detail="You can only view orders from your own branch"
-            )
-        query = query.where(Order.branch_id == branch_id)
-    elif not current_user.is_superuser:
-        # Non-superusers can only see orders from their branch
-        query = query.where(Order.branch_id == current_user.branch_id)
-    
-    query = query.offset(skip).limit(limit)
-    result = await db.execute(query)
-    return result.scalars().all()
-
-@router.get("/{order_id}", response_model=OrderInDB)
-async def get_order(
-    order_id: int,
-    current_user: User = Depends(get_current_active_user),
-    db: AsyncSession = Depends(get_db)
-) -> OrderInDB:
-    stmt = select(Order).where(Order.id == order_id)
-    result = await db.execute(stmt)
-    order = result.scalar_one_or_none()
-    
-    if not order:
-        raise HTTPException(status_code=404, detail="Order not found")
-    
-    # Check if user has access to this order's branch
-    if not current_user.is_superuser and order.branch_id != current_user.branch_id:
-        raise HTTPException(status_code=403, detail="You cannot access orders from other branches")
-    
-    return order
-
-@router.put("/{order_id}/status", response_model=OrderInDB)
-async def update_order_status(
-    order_id: int,
-    status: str,
-    current_user: User = Depends(get_current_active_user),
-    db: AsyncSession = Depends(get_db)
-) -> OrderInDB:
-    valid_statuses = ["pending", "processing", "shipped", "delivered", "cancelled"]
-    if status not in valid_statuses:
-        raise HTTPException(status_code=400, detail="Invalid status")
-    
-    stmt = select(Order).where(Order.id == order_id)
-    result = await db.execute(stmt)
-    order = result.scalar_one_or_none()
-    
-    if not order:
-        raise HTTPException(status_code=404, detail="Order not found")
-    
-    # Check if user has access to this order's branch
-    if not current_user.is_superuser and order.branch_id != current_user.branch_id:
-        raise HTTPException(status_code=403, detail="You cannot modify orders from other branches")
-    
-    order.status = status
-    order.updated_at = datetime.utcnow()
-    
-    await db.commit()
-    await db.refresh(order)
-    return order
-
-@router.delete("/{order_id}")
-async def delete_order(
-    order_id: int,
-    current_user: User = Depends(get_current_active_user),
-    db: AsyncSession = Depends(get_db)
-):
-    # Get the order
-    stmt = select(Order).where(Order.id == order_id)
-    result = await db.execute(stmt)
-    order = result.scalar_one_or_none()
-    
-    if not order:
-        raise HTTPException(status_code=404, detail="Order not found")
-    
-    # Check if user has access to this order's branch
-    if not current_user.is_superuser and order.branch_id != current_user.branch_id:
-        raise HTTPException(status_code=403, detail="You cannot delete orders from other branches")
-    
-    # Restore inventory for each product
-    for item in order.items:
-        product_stmt = select(Product).where(Product.id == item.product_id)
-        product_result = await db.execute(product_stmt)
-        product = product_result.scalar_one_or_none()
-        
-        if product:
-            product.inventory_count += item.quantity
-    
-    await db.delete(order)
-    await db.commit()
-    
-    return {"status": "success", "message": "Order deleted and inventory restored"}
-
-@router.get("/admin/orders", response_model=List[OrderSchema])
-async def list_admin_orders(
-    current_user: User = Depends(get_current_active_user)
-) -> List[OrderSchema]:
-    """
-    Get POS system orders for the current user's branch.
-    Requires authenticated user.
-    """
-    if not current_user.branch_id:
-        raise HTTPException(
-            status_code=400,
-            detail="User does not belong to any branch"
-        )
-    
-    try:
-        return await get_orders(str(current_user.branch_id))
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to fetch POS orders: {str(e)}"
+from fastapi import APIRouter, HTTPException, status, Depends, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from typing import List, Optional
+from ..core.dependencies import get_current_active_user
+from ..db.database import get_db
+from ..db.models import Order, Product, OrderItem, User
+from ..db.schemas import OrderCreate, OrderInDB
+from ..services.pos_client import get_orders, OrderSchema
+from datetime import datetime
+
+router = APIRouter()
+
+@router.post("/", response_model=OrderInDB)
+async def create_order(
+    order: OrderCreate,
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> OrderInDB:
+    # Ensure user belongs to the branch they're creating the order for
+    if current_user.branch_id != order.branch_id and not current_user.is_superuser:
+        raise HTTPException(
+            status_code=403,
+            detail="You can only create orders for your own branch"
+        )
+
+    # Calculate total and validate products
+    total = 0
+    order_items = []
+    
+    for item in order.items:
+        # Get product
+        stmt = select(Product).where(
+            Product.id == item.product_id,
+            Product.branch_id == order.branch_id  # Ensure product belongs to the same branch
+        )
+        result = await db.execute(stmt)
+        product = result.scalar_one_or_none()
+        
+        if not product:
+            raise HTTPException(
+                status_code=404, 
+                detail=f"Product {item.product_id} not found in this branch"
+            )
+        
+        if product.inventory_count < item.quantity:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Insufficient inventory for product {item.product_id}"
+            )
+        
+        # Update inventory
+        product.inventory_count -= item.quantity
+        total += product.price * item.quantity
+        
+        # Create order item
+        order_item = OrderItem(
+            product_id=item.product_id,
+            quantity=item.quantity,
+            price=product.price
+        )
+        order_items.append(order_item)
+    
+    # Create order
+    db_order = Order(
+        customer_id=order.customer_id,
+        branch_id=order.branch_id,
+        total_amount=total,
+        status="pending",
+        items=order_items
+    )
+    
+    db.add(db_order)
+    await db.commit()
+    await db.refresh(db_order)
+    return db_order
+
+@router.get("/", response_model=List[OrderInDB])
+async def list_orders(
+    skip: int = 0,
+    limit: int = 10,
+    status: Optional[str] = None,
+    branch_id: Optional[int] = Query(None, description="Filter orders by branch"),
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> List[OrderInDB]:
+    query = select(Order)
+    
+    # Filter by status if provided
+    if status:
+        query = query.where(Order.status == status)
+    
+    # Filter by branch if provided, otherwise use user's branch
+    if branch_id:
+        if not current_user.is_superuser and branch_id != current_user.branch_id:
+            raise HTTPException(
+                status_code=403,
+                detail="You can only view orders from your own branch"
+            )
+        query = query.where(Order.branch_id == branch_id)
+    elif not current_user.is_superuser:
+        # Non-superusers can only see orders from their branch
+        query = query.where(Order.branch_id == current_user.branch_id)
+    
+    query = query.offset(skip).limit(limit)
+    result = await db.execute(query)
+    return result.scalars().all()
+
+@router.get("/{order_id}", response_model=OrderInDB)
+async def get_order(
+    order_id: int,
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> OrderInDB:
+    stmt = select(Order).where(Order.id == order_id)
+    result = await db.execute(stmt)
+    order = result.scalar_one_or_none()
+    
+    if not order:
+        raise HTTPException(status_code=404, detail="Order not found")
+    
+    # Check if user has access to this order's branch
+    if not current_user.is_superuser and order.branch_id != current_user.branch_id:
+        raise HTTPException(status_code=403, detail="You cannot access orders from other branches")
+    
+    return order
+
+@router.put("/{order_id}/status", response_model=OrderInDB)
+async def update_order_status(
+    order_id: int,
+    status: str,
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> OrderInDB:
+    valid_statuses = ["pending", "processing", "shipped", "delivered", "cancelled"]
+    if status not in valid_statuses:
+        raise HTTPException(status_code=400, detail="Invalid status")
+    
+    stmt = select(Order).where(Order.id == order_id)
+    result = await db.execute(stmt)
+    order = result.scalar_one_or_none()
+    
+    if not order:
+        raise HTTPException(status_code=404, detail="Order not found")
+    
+    # Check if user has access to this order's branch
+    if not current_user.is_superuser and order.branch_id != current_user.branch_id:
+        raise HTTPException(status_code=403, detail="You cannot modify orders from other branches")
+    
+    order.status = status
+    order.updated_at = datetime.utcnow()
+    
+    await db.commit()
+    await db.refresh(order)
+    return order
+
+@router.delete("/{order_id}")
+async def delete_order(
+    order_id: int,
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+):
+    # Get the order
+    stmt = select(Order).where(Order.id == order_id)
+    result = await db.execute(stmt)
+    order = result.scalar_one_or_none()
+    
+    if not order:
+        raise HTTPException(status_code=404, detail="Order not found")
+    
+    # Check if user has access to this order's branch
+    if not current_user.is_superuser and order.branch_id != current_user.branch_id:
+        raise HTTPException(status_code=403, detail="You cannot delete orders from other branches")
+    
+    # Restore inventory for each product
+    for item in order.items:
+        product_stmt = select(Product).where(Product.id == item.product_id)
+        product_result = await db.execute(product_stmt)
+        product = product_result.scalar_one_or_none()
+        
+        if product:
+            product.inventory_count += item.quantity
+    
+    await db.delete(order)
+    await db.commit()
+    
+    return {"status": "success", "message": "Order deleted and inventory restored"}
+
+@router.get("/admin/orders", response_model=List[OrderSchema])
+async def list_admin_orders(
+    current_user: User = Depends(get_current_active_user)
+) -> List[OrderSchema]:
+    """
+    Get POS system orders for the current user's branch.
+    Requires authenticated user.
+    """
+    if not current_user.branch_id:
+        raise HTTPException(
+            status_code=400,
+            detail="User does not belong to any branch"
+        )
+    
+    try:
+        return await get_orders(str(current_user.branch_id))
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to fetch POS orders: {str(e)}"
         )

app/api/sessions.py

@@ -0,0 +1,31 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import Any, Dict
+
+from app.db.database import get_db
+from app.db import models, schemas
+from app.core.auth import get_current_active_user
+
+router = APIRouter(
+    prefix="/api/sessions",
+    tags=["sessions"]
+)
+
+@router.put("/iteration-status")
+def update_iteration_status(
+    session_update: schemas.SessionUpdate,
+    current_user: models.User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+) -> Dict[str, bool]:
+    """Update the iteration status of the current session."""
+    session = db.query(models.Session).filter(
+        models.Session.user_id == current_user.id
+    ).first()
+    
+    if not session:
+        raise HTTPException(status_code=404, detail="Active session not found")
+    
+    session.iteration_active = session_update.iteration_active
+    db.commit()
+    
+    return {"iteration_active": session.iteration_active}

app/api/staff_analytics.py

@@ -0,0 +1,191 @@
+from fastapi import APIRouter, Depends, Query, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+from ..core.dependencies import get_current_active_user, get_db
+from ..db.models import User, ActivityType
+from ..services.analytics import staff_analytics
+from ..services.staff_reports import staff_reports
+from ..db.schemas import (
+    StaffActivityCreate,
+    StaffActivityInDB,
+    StaffPerformanceReport,
+    RealtimeStaffMetrics
+)
+
+router = APIRouter()
+
+@router.post("/activity", response_model=Dict[str, Any])
+async def record_staff_activity(
+    activity: StaffActivityCreate,
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> Dict[str, Any]:
+    """Record a staff activity"""
+    if not current_user.branch_id:
+        raise HTTPException(status_code=400, detail="User is not associated with a branch")
+    
+    recorded_activity = await staff_analytics.record_activity(
+        user_id=current_user.id,
+        branch_id=current_user.branch_id,
+        activity_type=activity.activity_type,
+        details=activity.details,
+        duration=activity.duration
+    )
+    
+    return {
+        "status": "success",
+        "activity_id": recorded_activity.id,
+        "performance_score": recorded_activity.performance_score
+    }
+
+@router.get("/performance", response_model=StaffPerformanceReport)
+async def get_staff_performance(
+    branch_id: Optional[int] = Query(None, description="Filter by branch ID"),
+    user_id: Optional[int] = Query(None, description="Filter by user ID"),
+    start_date: Optional[datetime] = Query(None, description="Start date for analysis"),
+    end_date: Optional[datetime] = Query(None, description="End date for analysis"),
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> Dict[str, Any]:
+    """Get staff performance metrics"""
+    # Check permissions
+    if not current_user.is_superuser and (
+        (branch_id and branch_id != current_user.branch_id) or
+        (user_id and user_id != current_user.id)
+    ):
+        raise HTTPException(
+            status_code=403,
+            detail="You can only view performance metrics for your own branch"
+        )
+    
+    # Non-superusers can only view their branch
+    if not current_user.is_superuser:
+        branch_id = current_user.branch_id
+    
+    return await staff_analytics.get_staff_performance(
+        branch_id=branch_id,
+        user_id=user_id,
+        start_date=start_date,
+        end_date=end_date
+    )
+
+@router.get("/metrics/summary")
+async def get_performance_summary(
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> Dict[str, Any]:
+    """Get a summary of current user's performance metrics"""
+    metrics = await staff_analytics.get_staff_performance(
+        user_id=current_user.id,
+        branch_id=current_user.branch_id
+    )
+    
+    # Get user's performance data
+    user_metrics = next(
+        (p for p in metrics["staff_performance"] if p["user_id"] == current_user.id),
+        None
+    )
+    
+    if not user_metrics:
+        return {
+            "message": "No performance metrics available",
+            "metrics": None
+        }
+    
+    # Get comparison with branch averages
+    comparison = await staff_reports.generate_staff_comparison(
+        user_id=current_user.id,
+        branch_id=current_user.branch_id
+    )
+    
+    return {
+        "metrics": user_metrics["metrics"],
+        "comparison": comparison,
+        "period": metrics["date_range"]
+    }
+
+@router.get("/realtime", response_model=RealtimeStaffMetrics)
+async def get_realtime_activity(
+    branch_id: Optional[int] = Query(None, description="Filter by branch ID"),
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> Dict[str, Any]:
+    """Get real-time staff activity for the current day"""
+    if not current_user.is_superuser and branch_id != current_user.branch_id:
+        raise HTTPException(
+            status_code=403,
+            detail="You can only view real-time activity for your own branch"
+        )
+    
+    today = datetime.utcnow()
+    today_start = today.replace(hour=0, minute=0, second=0, microsecond=0)
+    
+    metrics = await staff_analytics.get_staff_performance(
+        branch_id=branch_id or current_user.branch_id,
+        start_date=today_start,
+        end_date=today
+    )
+    
+    # Calculate real-time metrics
+    active_staff = [
+        staff for staff in metrics["staff_performance"]
+        if staff["metrics"]["total_login_time"] > 0
+    ]
+    
+    total_sales_today = sum(
+        staff["metrics"]["total_sales"] for staff in metrics["staff_performance"]
+    )
+    total_transactions = sum(
+        staff["metrics"]["transaction_count"] for staff in metrics["staff_performance"]
+    )
+    
+    return {
+        "active_staff_count": len(active_staff),
+        "total_sales_today": total_sales_today,
+        "total_transactions": total_transactions,
+        "staff_metrics": active_staff,
+        "last_updated": datetime.utcnow().isoformat()
+    }
+
+@router.get("/reports/performance")
+async def get_performance_report(
+    branch_id: Optional[int] = Query(None, description="Filter by branch ID"),
+    start_date: Optional[datetime] = Query(None, description="Start date for report"),
+    end_date: Optional[datetime] = Query(None, description="End date for report"),
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> Dict[str, Any]:
+    """Generate comprehensive performance report with insights"""
+    # Check permissions
+    if not current_user.is_superuser and branch_id != current_user.branch_id:
+        raise HTTPException(
+            status_code=403,
+            detail="You can only view reports for your own branch"
+        )
+    
+    return await staff_reports.generate_performance_report(
+        branch_id=branch_id or current_user.branch_id,
+        start_date=start_date,
+        end_date=end_date
+    )
+
+@router.get("/reports/comparison")
+async def get_staff_comparison(
+    user_id: Optional[int] = Query(None, description="User ID to compare (defaults to current user)"),
+    date: Optional[datetime] = Query(None, description="Date for comparison"),
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+) -> Dict[str, Any]:
+    """Get performance comparison against branch averages"""
+    if not current_user.is_superuser and user_id != current_user.id:
+        raise HTTPException(
+            status_code=403,
+            detail="You can only view your own performance comparison"
+        )
+    
+    return await staff_reports.generate_staff_comparison(
+        user_id=user_id or current_user.id,
+        branch_id=current_user.branch_id,
+        date=date
+    )

app/core/config.py

@@ -1,39 +1,41 @@
-from pydantic_settings import BaseSettings
-from typing import ClassVar
-
-
-class Settings(BaseSettings):
-    API_V1_STR: str = "/api/v1"
-    PROJECT_NAME: str = "Admin Dashboard"
-    VERSION: str = "1.0.0"
-
-    # Service Authentication
-    SERVICE_TOKEN: str = "6f9aee88d5b94b0190c317abcbf4e6e7834cc2c7f02e45693e123456789abcde"
-    POS_API_URL: str = "https://fred808-desk-back2.hf.space"  # Default value, should be overridden in environment
-
-    # PostgreSQL Database settings
-    DATABASE_URL: ClassVar[str] = "postgresql+asyncpg://postgres.juycnkjuzylnbruwaqmp:Lovyelias5584.@aws-0-eu-central-1.pooler.supabase.com:5432/postgres"
-
-    # JWT Settings
-    SECRET_KEY: str = "your-secret-key-here"
-    ALGORITHM: str = "HS256"
-    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
-
-    # Redis settings
-    REDIS_URL: str = f"redis://redis:6379/0"
-
-    # Email settings
-    MAIL_USERNAME: str = "yungdml31@gmail.com"
-    MAIL_PASSWORD: str = ""
-    MAIL_FROM: str = "admin@angelo.com"
-    MAIL_PORT: int = 587
-    MAIL_SERVER: str = "smtp.gmail.com"
-
-    # Frontend URL
-    FRONTEND_URL: str = "http://localhost:3000"
-
-    class Config:
-        case_sensitive = True
-
-
-settings = Settings()
+from pydantic_settings import BaseSettings
+from typing import ClassVar
+
+
+class Settings(BaseSettings):
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "Admin Dashboard"
+    VERSION: str = "1.0.0"
+
+    # Service Authentication
+    SERVICE_TOKEN: str = "6f9aee88d5b94b0190c317abcbf4e6e7834cc2c7f02e45693e123456789abcde"
+    POS_API_URL: str = "https://fred808-desk-back2.hf.space"  # Default value, should be overridden in environment
+
+    # PostgreSQL Database settings
+    DATABASE_URL: ClassVar[str] = "postgresql+asyncpg://postgres.juycnkjuzylnbruwaqmp:Lovyelias5584.@aws-0-eu-central-1.pooler.supabase.com:5432/postgres"
+
+    # JWT Settings
+    SECRET_KEY: str = "your-secret-key-here"
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+
+    # Redis settings
+    REDIS_HOST: str = "localhost"
+    REDIS_PORT: int = 6379
+    REDIS_URL: str = f"redis://{REDIS_HOST}:{REDIS_PORT}"
+
+    # Email settings
+    MAIL_USERNAME: str = "yungdml31@gmail.com"
+    MAIL_PASSWORD: str = ""
+    MAIL_FROM: str = "admin@angelo.com"
+    MAIL_PORT: int = 587
+    MAIL_SERVER: str = "smtp.gmail.com"
+
+    # Frontend URL
+    FRONTEND_URL: str = "http://localhost:3000"
+
+    class Config:
+        case_sensitive = True
+
+
+settings = Settings()

app/core/dependencies.py

@@ -1,53 +1,53 @@
-from fastapi import Depends, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
-from sqlalchemy.orm import selectinload
-from jose import JWTError, jwt
-from ..db.database import get_db
-from ..db.models import User
-from ..core.config import settings
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"{settings.API_V1_STR}/auth/login")
-
-async def get_current_user(
-    token: str = Depends(oauth2_scheme),
-    db: AsyncSession = Depends(get_db)
-):
-    credentials_exception = HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Could not validate credentials",
-        headers={"WWW-Authenticate": "Bearer"},
-    )
-    
-    try:
-        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
-        user_id: str = payload.get("sub")
-        if user_id is None:
-            raise credentials_exception
-    except JWTError:
-        raise credentials_exception
-    
-    stmt = select(User).options(selectinload(User.roles)).where(User.id == int(user_id))
-    result = await db.execute(stmt)
-    user = result.scalar_one_or_none()
-    
-    if user is None:
-        raise credentials_exception
-    return user
-
-async def get_current_active_user(
-    current_user: User = Depends(get_current_user)
-):
-    if not current_user.is_active:
-        raise HTTPException(status_code=400, detail="Inactive user")
-    return current_user
-
-async def get_current_superuser(
-    current_user: User = Depends(get_current_user)
-):
-    if not current_user.is_superuser:
-        raise HTTPException(
-            status_code=403, detail="The user doesn't have enough privileges"
-        )
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from sqlalchemy.orm import selectinload
+from jose import JWTError, jwt
+from ..db.database import get_db
+from ..db.models import User
+from ..core.config import settings
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"{settings.API_V1_STR}/auth/login")
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: AsyncSession = Depends(get_db)
+):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    
+    stmt = select(User).options(selectinload(User.roles)).where(User.id == int(user_id))
+    result = await db.execute(stmt)
+    user = result.scalar_one_or_none()
+    
+    if user is None:
+        raise credentials_exception
+    return user
+
+async def get_current_active_user(
+    current_user: User = Depends(get_current_user)
+):
+    if not current_user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user
+
+async def get_current_superuser(
+    current_user: User = Depends(get_current_user)
+):
+    if not current_user.is_superuser:
+        raise HTTPException(
+            status_code=403, detail="The user doesn't have enough privileges"
+        )
     return current_user

app/db/models.py

@@ -1,9 +1,10 @@
-from sqlalchemy import Column, Integer, String, Boolean, DateTime, Float, ForeignKey, ARRAY, JSON, Table
+from sqlalchemy import Column, Integer, String, Boolean, DateTime, Float, ForeignKey, ARRAY, JSON, Table, Enum
 from sqlalchemy.orm import relationship, mapped_column, Mapped
 from sqlalchemy.dialects.postgresql import JSONB
 from datetime import datetime
 from typing import List, Optional
 from .database import Base
+import enum
 
 # Association tables for many-to-many relationships
 user_roles = Table(
@@ -44,6 +45,8 @@ class Branch(Base):
     users = relationship("User", back_populates="branch")
     products = relationship("Product", back_populates="branch")
     orders = relationship("Order", back_populates="branch")
+    staff_activities = relationship("StaffActivity", back_populates="branch")
+    staff_metrics = relationship("PerformanceMetric", back_populates="branch")
 
 class User(Base):
     __tablename__ = "users"
@@ -67,6 +70,8 @@ class User(Base):
     orders = relationship("Order", back_populates="customer")
     notifications = relationship("Notification", back_populates="user")
     sessions = relationship("Session", back_populates="user", cascade="all, delete-orphan")
+    activities = relationship("StaffActivity", back_populates="user")
+    performance_metrics = relationship("PerformanceMetric", back_populates="user")
 
 class Product(Base):
     __tablename__ = "products"
@@ -181,6 +186,51 @@ class Session(Base):
     created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
     expires_at: Mapped[datetime] = mapped_column(DateTime)
     is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    iteration_active: Mapped[bool] = mapped_column(Boolean, default=True)
 
     # Relationship
-    user = relationship("User", back_populates="sessions")
+    user = relationship("User", back_populates="sessions")
+
+class ActivityType(str, enum.Enum):
+    LOGIN = "login"
+    LOGOUT = "logout"
+    SALE = "sale"
+    VOID = "void"
+    REFUND = "refund"
+    INVENTORY = "inventory"
+    CUSTOMER_SERVICE = "customer_service"
+
+class StaffActivity(Base):
+    __tablename__ = "staff_activities"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
+    branch_id: Mapped[int] = mapped_column(ForeignKey("branches.id"))
+    activity_type: Mapped[str] = mapped_column(String)
+    details: Mapped[dict] = mapped_column(JSON)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
+    duration: Mapped[Optional[float]] = mapped_column(Float, nullable=True)  # Duration in minutes if applicable
+    performance_score: Mapped[Optional[float]] = mapped_column(Float, nullable=True)  # Score based on activity type
+
+    # Relationships
+    user = relationship("User", back_populates="activities")
+    branch = relationship("Branch", back_populates="staff_activities")
+
+class PerformanceMetric(Base):
+    __tablename__ = "performance_metrics"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
+    branch_id: Mapped[int] = mapped_column(ForeignKey("branches.id"))
+    metric_date: Mapped[datetime] = mapped_column(DateTime)
+    total_sales: Mapped[float] = mapped_column(Float, default=0)
+    transaction_count: Mapped[int] = mapped_column(Integer, default=0)
+    average_transaction_value: Mapped[float] = mapped_column(Float, default=0)
+    void_count: Mapped[int] = mapped_column(Integer, default=0)
+    customer_interaction_count: Mapped[int] = mapped_column(Integer, default=0)
+    login_time: Mapped[float] = mapped_column(Float, default=0)  # Total minutes logged in
+    efficiency_score: Mapped[float] = mapped_column(Float, default=0)  # Calculated score based on metrics
+
+    # Relationships
+    user = relationship("User", back_populates="performance_metrics")
+    branch = relationship("Branch", back_populates="staff_metrics")

app/db/schemas.py

@@ -1,318 +1,387 @@
-from sqlalchemy.orm import validates
-from sqlalchemy import event
-from datetime import datetime
-from typing import List, Optional, Dict
-from pydantic import BaseModel, EmailStr, validator
-from .models import User, Product, Order, Event, Notification, Session
-import re
-
-# Role schemas
-class RoleBase(BaseModel):
-    name: str
-    description: str
-    permissions: List[str] = []
-
-class RoleCreate(RoleBase):
-    pass
-
-class RoleUpdate(RoleBase):
-    name: Optional[str] = None
-    description: Optional[str] = None
-    permissions: Optional[List[str]] = None
-
-class RoleInDB(RoleBase):
-    id: int
-    created_at: datetime
-    updated_at: Optional[datetime] = None
-
-    class Config:
-        from_attributes = True
-
-class BranchBase(BaseModel):
-    name: str
-    address: str
-    phone: str
-    email: EmailStr
-    is_active: bool = True
-
-class BranchCreate(BranchBase):
-    pass
-
-class BranchInDB(BranchBase):
-    id: int
-    created_at: datetime
-    updated_at: Optional[datetime] = None
-
-    class Config:
-        from_attributes = True
-
-# Update User schemas
-class UserBase(BaseModel):
-    email: EmailStr
-    username: str
-    full_name: str
-    is_active: bool = True
-    is_superuser: bool = False
-    branch_id: Optional[int] = None
-
-class UserCreate(UserBase):
-    password: str
-    role_ids: Optional[List[int]] = None  # IDs of roles to assign
-
-class UserUpdate(BaseModel):
-    email: Optional[EmailStr] = None
-    username: Optional[str] = None
-    full_name: Optional[str] = None
-    is_active: Optional[bool] = None
-    is_superuser: Optional[bool] = None
-    password: Optional[str] = None
-    branch_id: Optional[int] = None
-    role_ids: Optional[List[int]] = None
-
-class UserInDB(UserBase):
-    id: int
-    created_at: datetime
-    roles: List[RoleInDB]
-
-    class Config:
-        from_attributes = True
-
-class ProductBase(BaseModel):
-    name: str
-    description: str
-    price: float
-    category: str
-    inventory_count: int
-    seller_id: int
-    branch_id: int
-
-class ProductCreate(ProductBase):
-    pass
-
-class ProductInDB(ProductBase):
-    id: int
-    created_at: datetime
-    updated_at: Optional[datetime] = None
-
-    class Config:
-        from_attributes = True
-
-class OrderItemBase(BaseModel):
-    product_id: int
-    quantity: int
-    price: float
-
-class OrderItemCreate(OrderItemBase):
-    pass
-
-class OrderItemInDB(OrderItemBase):
-    id: int
-    order_id: int
-
-    class Config:
-        from_attributes = True
-
-class OrderBase(BaseModel):
-    customer_id: int
-    branch_id: int
-    total_amount: float
-    status: str = "pending"
-    items: List[OrderItemCreate]
-
-class OrderCreate(OrderBase):
-    pass
-
-class OrderInDB(OrderBase):
-    id: int
-    created_at: datetime
-    updated_at: Optional[datetime] = None
-    items: List[OrderItemInDB]
-
-    class Config:
-        from_attributes = True
-
-class NotificationBase(BaseModel):
-    user_id: int
-    title: str
-    message: str
-    type: str
-    data: Optional[dict] = None
-    read: bool = False
-
-class NotificationCreate(NotificationBase):
-    pass
-
-class NotificationInDB(NotificationBase):
-    id: int
-    created_at: datetime
-
-    class Config:
-        from_attributes = True
-
-class EventBase(BaseModel):
-    title: str
-    description: str
-    start_time: datetime
-    end_time: datetime
-    is_all_day: bool = False
-    reminder_minutes: int = 30
-
-    @validator('end_time')
-    def end_time_after_start_time(cls, v, values):
-        if 'start_time' in values and v <= values['start_time']:
-            raise ValueError('end_time must be after start_time')
-        return v
-
-    @validator('reminder_minutes')
-    def valid_reminder_minutes(cls, v):
-        if v < 0:
-            raise ValueError('reminder_minutes cannot be negative')
-        return v
-
-class EventCreate(EventBase):
-    attendees: List[str] = []
-
-class EventUpdate(BaseModel):
-    title: Optional[str] = None
-    description: Optional[str] = None
-    start_time: Optional[datetime] = None
-    end_time: Optional[datetime] = None
-    is_all_day: Optional[bool] = None
-    reminder_minutes: Optional[int] = None
-    attendees: Optional[List[str]] = None
-
-    @validator('reminder_minutes')
-    def valid_reminder_minutes(cls, v):
-        if v is not None and v < 0:
-            raise ValueError('reminder_minutes cannot be negative')
-        return v
-
-class EventInDB(EventBase):
-    id: int
-    user_id: int
-    attendees: List[str]
-    status: str
-    attendee_responses: Dict[str, str]
-    created_at: datetime
-    updated_at: Optional[datetime] = None
-    reminder_sent: bool = False
-    is_recurring: bool = False
-    recurrence_group: Optional[str] = None
-    parent_event_id: Optional[int] = None
-    sequence_number: Optional[int] = None
-
-    class Config:
-        from_attributes = True
-
-class RecurringEventCreate(EventCreate):
-    recurrence_pattern: str
-    recurrence_end_date: Optional[datetime] = None
-
-    @validator('recurrence_pattern')
-    def valid_recurrence_pattern(cls, v):
-        valid_patterns = ['daily', 'weekly', 'monthly', 'yearly']
-        if v not in valid_patterns:
-            raise ValueError(f'recurrence_pattern must be one of: {", ".join(valid_patterns)}')
-        return v
-
-    @validator('recurrence_end_date')
-    def end_date_after_start_time(cls, v, values):
-        if v is not None and 'start_time' in values and v <= values['start_time']:
-            raise ValueError('recurrence_end_date must be after start_time')
-        return v
-
-class RecurringEventUpdate(EventUpdate):
-    recurrence_pattern: Optional[str] = None
-    recurrence_end_date: Optional[datetime] = None
-
-    @validator('recurrence_pattern')
-    def valid_recurrence_pattern(cls, v):
-        if v is not None:
-            valid_patterns = ['daily', 'weekly', 'monthly', 'yearly']
-            if v not in valid_patterns:
-                raise ValueError(f'recurrence_pattern must be one of: {", ".join(valid_patterns)}')
-        return v
-
-class SessionBase(BaseModel):
-    user_id: int
-    session_token: str
-    expires_at: datetime
-    is_active: bool = True
-
-class SessionCreate(SessionBase):
-    pass
-
-class SessionUpdate(BaseModel):
-    last_activity: Optional[datetime] = None
-    expires_at: Optional[datetime] = None
-    is_active: Optional[bool] = None
-
-class SessionInDB(SessionBase):
-    id: int
-    created_at: datetime
-    last_activity: datetime
-
-    class Config:
-        from_attributes = True
-
-class LoginData(BaseModel):
-    email: str
-    password: str
-
-@validates('email')
-def validate_email(self, key, email):
-    if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', email):
-        raise ValueError('Invalid email address')
-    return email
-
-@validates('username')
-def validate_username(self, key, username):
-    if len(username) < 3:
-        raise ValueError('Username must be at least 3 characters long')
-    return username
-
-@validates('inventory_count')
-def validate_inventory(self, key, count):
-    if count < 0:
-        raise ValueError('Inventory count cannot be negative')
-    return count
-
-@validates('price')
-def validate_price(self, key, price):
-    if price < 0:
-        raise ValueError('Price cannot be negative')
-    return price
-
-# Event listeners for automatic timestamps
-@event.listens_for(Product, 'before_insert')
-def set_created_at(mapper, connection, target):
-    target.created_at = datetime.utcnow()
-    target.updated_at = datetime.utcnow()
-
-@event.listens_for(Product, 'before_update')
-def set_updated_at(mapper, connection, target):
-    target.updated_at = datetime.utcnow()
-
-@event.listens_for(Order, 'before_insert')
-def set_order_created_at(mapper, connection, target):
-    target.created_at = datetime.utcnow()
-    target.updated_at = datetime.utcnow()
-
-@event.listens_for(Order, 'before_update')
-def set_order_updated_at(mapper, connection, target):
-    target.updated_at = datetime.utcnow()
-
-@event.listens_for(Event, 'before_insert')
-def set_event_created_at(mapper, connection, target):
-    target.created_at = datetime.utcnow()
-    target.updated_at = datetime.utcnow()
-
-@event.listens_for(Event, 'before_update')
-def set_event_updated_at(mapper, connection, target):
-    target.updated_at = datetime.utcnow()
-
-# Add validators to models
-User.validate_email = validate_email
-User.validate_username = validate_username
-Product.validate_inventory = validate_inventory
-Product.validate_price = validate_price
+from sqlalchemy.orm import validates
+from sqlalchemy import event
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, EmailStr, validator
+from .models import User, Product, Order, Event, Notification, Session, ActivityType
+import re
+
+# Role schemas
+class RoleBase(BaseModel):
+    name: str
+    description: str
+    permissions: List[str] = []
+
+class RoleCreate(RoleBase):
+    pass
+
+class RoleUpdate(RoleBase):
+    name: Optional[str] = None
+    description: Optional[str] = None
+    permissions: Optional[List[str]] = None
+
+class RoleInDB(RoleBase):
+    id: int
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+class BranchBase(BaseModel):
+    name: str
+    address: str
+    phone: str
+    email: EmailStr
+    is_active: bool = True
+
+class BranchCreate(BranchBase):
+    pass
+
+class BranchInDB(BranchBase):
+    id: int
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+# Update User schemas
+class UserBase(BaseModel):
+    email: EmailStr
+    username: str
+    full_name: str
+    is_active: bool = True
+    is_superuser: bool = False
+    branch_id: Optional[int] = None
+
+class UserCreate(UserBase):
+    password: str
+    role_ids: Optional[List[int]] = None  # IDs of roles to assign
+
+class UserUpdate(BaseModel):
+    email: Optional[EmailStr] = None
+    username: Optional[str] = None
+    full_name: Optional[str] = None
+    is_active: Optional[bool] = None
+    is_superuser: Optional[bool] = None
+    password: Optional[str] = None
+    branch_id: Optional[int] = None
+    role_ids: Optional[List[int]] = None
+
+class UserInDB(UserBase):
+    id: int
+    created_at: datetime
+    roles: List[RoleInDB]
+
+    class Config:
+        from_attributes = True
+
+class ProductBase(BaseModel):
+    name: str
+    description: str
+    price: float
+    category: str
+    inventory_count: int
+    seller_id: int
+    branch_id: int
+
+class ProductCreate(ProductBase):
+    pass
+
+class ProductInDB(ProductBase):
+    id: int
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+class OrderItemBase(BaseModel):
+    product_id: int
+    quantity: int
+    price: float
+
+class OrderItemCreate(OrderItemBase):
+    pass
+
+class OrderItemInDB(OrderItemBase):
+    id: int
+    order_id: int
+
+    class Config:
+        from_attributes = True
+
+class OrderBase(BaseModel):
+    customer_id: int
+    branch_id: int
+    total_amount: float
+    status: str = "pending"
+    items: List[OrderItemCreate]
+
+class OrderCreate(OrderBase):
+    pass
+
+class OrderInDB(OrderBase):
+    id: int
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+    items: List[OrderItemInDB]
+
+    class Config:
+        from_attributes = True
+
+class NotificationBase(BaseModel):
+    user_id: int
+    title: str
+    message: str
+    type: str
+    data: Optional[dict] = None
+    read: bool = False
+
+class NotificationCreate(NotificationBase):
+    pass
+
+class NotificationInDB(NotificationBase):
+    id: int
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+class EventBase(BaseModel):
+    title: str
+    description: str
+    start_time: datetime
+    end_time: datetime
+    is_all_day: bool = False
+    reminder_minutes: int = 30
+
+    @validator('end_time')
+    def end_time_after_start_time(cls, v, values):
+        if 'start_time' in values and v <= values['start_time']:
+            raise ValueError('end_time must be after start_time')
+        return v
+
+    @validator('reminder_minutes')
+    def valid_reminder_minutes(cls, v):
+        if v < 0:
+            raise ValueError('reminder_minutes cannot be negative')
+        return v
+
+class EventCreate(EventBase):
+    attendees: List[str] = []
+
+class EventUpdate(BaseModel):
+    title: Optional[str] = None
+    description: Optional[str] = None
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    is_all_day: Optional[bool] = None
+    reminder_minutes: Optional[int] = None
+    attendees: Optional[List[str]] = None
+
+    @validator('reminder_minutes')
+    def valid_reminder_minutes(cls, v):
+        if v is not None and v < 0:
+            raise ValueError('reminder_minutes cannot be negative')
+        return v
+
+class EventInDB(EventBase):
+    id: int
+    user_id: int
+    attendees: List[str]
+    status: str
+    attendee_responses: Dict[str, str]
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+    reminder_sent: bool = False
+    is_recurring: bool = False
+    recurrence_group: Optional[str] = None
+    parent_event_id: Optional[int] = None
+    sequence_number: Optional[int] = None
+
+    class Config:
+        from_attributes = True
+
+class RecurringEventCreate(EventCreate):
+    recurrence_pattern: str
+    recurrence_end_date: Optional[datetime] = None
+
+    @validator('recurrence_pattern')
+    def valid_recurrence_pattern(cls, v):
+        valid_patterns = ['daily', 'weekly', 'monthly', 'yearly']
+        if v not in valid_patterns:
+            raise ValueError(f'recurrence_pattern must be one of: {", ".join(valid_patterns)}')
+        return v
+
+    @validator('recurrence_end_date')
+    def end_date_after_start_time(cls, v, values):
+        if v is not None and 'start_time' in values and v <= values['start_time']:
+            raise ValueError('recurrence_end_date must be after start_time')
+        return v
+
+class RecurringEventUpdate(EventUpdate):
+    recurrence_pattern: Optional[str] = None
+    recurrence_end_date: Optional[datetime] = None
+
+    @validator('recurrence_pattern')
+    def valid_recurrence_pattern(cls, v):
+        if v is not None:
+            valid_patterns = ['daily', 'weekly', 'monthly', 'yearly']
+            if v not in valid_patterns:
+                raise ValueError(f'recurrence_pattern must be one of: {", ".join(valid_patterns)}')
+        return v
+
+class SessionBase(BaseModel):
+    user_id: int
+    session_token: str
+    expires_at: datetime
+    is_active: bool = True
+    iteration_active: bool = False
+
+class SessionCreate(SessionBase):
+    pass
+
+class SessionUpdate(BaseModel):
+    last_activity: Optional[datetime] = None
+    expires_at: Optional[datetime] = None
+    is_active: Optional[bool] = None
+    iteration_active: Optional[bool] = None
+
+class SessionInDB(SessionBase):
+    id: int
+    created_at: datetime
+    last_activity: datetime
+
+    class Config:
+        from_attributes = True
+
+class LoginData(BaseModel):
+    email: str
+    password: str
+
+@validates('email')
+def validate_email(self, key, email):
+    if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', email):
+        raise ValueError('Invalid email address')
+    return email
+
+@validates('username')
+def validate_username(self, key, username):
+    if len(username) < 3:
+        raise ValueError('Username must be at least 3 characters long')
+    return username
+
+@validates('inventory_count')
+def validate_inventory(self, key, count):
+    if count < 0:
+        raise ValueError('Inventory count cannot be negative')
+    return count
+
+@validates('price')
+def validate_price(self, key, price):
+    if price < 0:
+        raise ValueError('Price cannot be negative')
+    return price
+
+# Event listeners for automatic timestamps
+@event.listens_for(Product, 'before_insert')
+def set_created_at(mapper, connection, target):
+    target.created_at = datetime.utcnow()
+    target.updated_at = datetime.utcnow()
+
+@event.listens_for(Product, 'before_update')
+def set_updated_at(mapper, connection, target):
+    target.updated_at = datetime.utcnow()
+
+@event.listens_for(Order, 'before_insert')
+def set_order_created_at(mapper, connection, target):
+    target.created_at = datetime.utcnow()
+    target.updated_at = datetime.utcnow()
+
+@event.listens_for(Order, 'before_update')
+def set_order_updated_at(mapper, connection, target):
+    target.updated_at = datetime.utcnow()
+
+@event.listens_for(Event, 'before_insert')
+def set_event_created_at(mapper, connection, target):
+    target.created_at = datetime.utcnow()
+    target.updated_at = datetime.utcnow()
+
+@event.listens_for(Event, 'before_update')
+def set_event_updated_at(mapper, connection, target):
+    target.updated_at = datetime.utcnow()
+
+# Add validators to models
+User.validate_email = validate_email
+User.validate_username = validate_username
+Product.validate_inventory = validate_inventory
+Product.validate_price = validate_price
+
+# Staff analytics schemas
+class StaffActivityBase(BaseModel):
+    activity_type: ActivityType
+    details: Dict[str, Any]
+    duration: Optional[float] = None
+
+class StaffActivityCreate(StaffActivityBase):
+    user_id: int
+    branch_id: int
+
+class StaffActivityInDB(StaffActivityBase):
+    id: int
+    user_id: int
+    branch_id: int
+    created_at: datetime
+    performance_score: Optional[float] = None
+
+    class Config:
+        from_attributes = True
+
+class PerformanceMetricBase(BaseModel):
+    total_sales: float = 0
+    transaction_count: int = 0
+    average_transaction_value: float = 0
+    void_count: int = 0
+    customer_interaction_count: int = 0
+    login_time: float = 0
+    efficiency_score: float = 0
+
+class PerformanceMetricCreate(PerformanceMetricBase):
+    user_id: int
+    branch_id: int
+    metric_date: datetime
+
+class PerformanceMetricInDB(PerformanceMetricBase):
+    id: int
+    user_id: int
+    branch_id: int
+    metric_date: datetime
+
+    class Config:
+        from_attributes = True
+
+class StaffPerformanceResponse(BaseModel):
+    user_id: int
+    username: str
+    full_name: str
+    metrics: PerformanceMetricBase
+
+class BranchAverages(BaseModel):
+    average_daily_sales: float
+    average_daily_transactions: float
+    average_transaction_value: float
+    average_efficiency_score: float
+
+class StaffPerformanceReport(BaseModel):
+    staff_performance: List[StaffPerformanceResponse]
+    branch_averages: Optional[BranchAverages]
+    date_range: Dict[str, str]
+
+class RealtimeStaffMetrics(BaseModel):
+    active_staff_count: int
+    total_sales_today: float
+    total_transactions: int
+    staff_metrics: List[StaffPerformanceResponse]
+    last_updated: str

app/main.py

@@ -1,137 +1,146 @@
-from fastapi import FastAPI, Request, WebSocket
-from fastapi.middleware.cors import CORSMiddleware
-from .core.config import settings
-from .db.database import async_engine as engine, Base
-from .api import auth, products, orders, users, analytics, files, notifications, calendar, scheduler, maintenance
-from .utils.rate_limiter import rate_limiter
-from .utils.logger import log_api_request
-from .utils.tasks import run_periodic_tasks
-from .services.websocket import connect, disconnect
-from .realtime.subscriber import subscribe_order_events
-from .routes.websocket import websocket_endpoint, manager
-import socketio
-import time
-import logging
-import asyncio
-from typing import List, Dict
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Create Socket.IO server
-sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
-socket_app = socketio.ASGIApp(sio)
-
-app = FastAPI(title=settings.PROJECT_NAME, version=settings.VERSION)
-
-# Store background tasks
-background_tasks = set()
-
-# Configure CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Configure appropriately for production
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Socket.IO event handlers
-@sio.event
-async def connect(sid, environ):
-    logger.info(f"Client connected: {sid}")
-
-@sio.event
-async def disconnect(sid):
-    logger.info(f"Client disconnected: {sid}")
-
-@sio.event
-async def message(sid, data):
-    logger.info(f"Message from {sid}: {data}")
-    await sio.emit('message', {'response': 'Message received'}, room=sid)
-
-# Mount Socket.IO app
-app.mount("/socket.io", socket_app)
-
-@app.get("/api/v1/health")
-async def health_check() -> Dict[str, str]:
-    """Public health check endpoint that doesn't require authentication"""
-    return {
-        "status": "healthy",
-        "version": settings.VERSION,
-        "service": settings.PROJECT_NAME
-    }
-
-# WebSocket endpoint
-@app.websocket("/ws")
-async def websocket_endpoint(websocket: WebSocket):
-    await connect(websocket)
-    try:
-        while True:
-            data = await websocket.receive_text()
-    except:
-        await disconnect(websocket)
-
-@app.websocket("/ws/orders")
-async def orders_websocket_endpoint(websocket: WebSocket):
-    await websocket_endpoint(websocket)
-
-# Request logging and rate limiting middleware
-@app.middleware("http")
-async def middleware(request: Request, call_next):
-    await rate_limiter.check_rate_limit(request)
-    start_time = time.time()
-    response = await call_next(request)
-    end_time = time.time()
-    duration = end_time - start_time
-    log_api_request(
-        method=request.method,
-        path=request.url.path,
-        status_code=response.status_code,
-        duration=duration
-    )
-    return response
-
-# Application startup and shutdown events
-@app.on_event("startup")
-async def startup_event():
-    # Create all database tables
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-    
-    # Start Redis subscriber in background
-    task = asyncio.create_task(subscribe_order_events(manager))
-    background_tasks.add(task)
-    task.add_done_callback(background_tasks.discard)
-
-    # Start periodic tasks
-    task = asyncio.create_task(run_periodic_tasks())
-    background_tasks.add(task)
-    task.add_done_callback(background_tasks.discard)
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    # Cancel background tasks
-    for task in background_tasks:
-        task.cancel()
-
-# Include routers
-app.include_router(auth.router, prefix=f"{settings.API_V1_STR}/auth", tags=["auth"])
-app.include_router(users.router, prefix=f"{settings.API_V1_STR}/users", tags=["users"])
-app.include_router(products.router, prefix=f"{settings.API_V1_STR}/products", tags=["products"])
-app.include_router(orders.router, prefix=f"{settings.API_V1_STR}/orders", tags=["orders"])
-app.include_router(analytics.router, prefix=f"{settings.API_V1_STR}/analytics", tags=["analytics"])
-app.include_router(files.router, prefix=f"{settings.API_V1_STR}/files", tags=["files"])
-app.include_router(notifications.router, prefix=f"{settings.API_V1_STR}/notifications", tags=["notifications"])
-app.include_router(calendar.router, prefix=f"{settings.API_V1_STR}/calendar", tags=["calendar"])
-app.include_router(scheduler.router, prefix=f"{settings.API_V1_STR}/scheduler", tags=["scheduler"])
-app.include_router(maintenance.router, prefix=f"{settings.API_V1_STR}/maintenance", tags=["maintenance"])
-
-@app.get("/")
-async def root():
-    return {
-        "message": f"Welcome to {settings.PROJECT_NAME} v{settings.VERSION}",
-        "docs_url": "/docs",
-        "openapi_url": "/openapi.json"
+from fastapi import FastAPI, Request, WebSocket
+from fastapi.middleware.cors import CORSMiddleware
+from .core.config import settings
+from .db.database import async_engine as engine, Base
+from .api import auth, products, orders, users, analytics, files, notifications, calendar, scheduler, maintenance, branches, staff_analytics, sessions
+from .utils.rate_limiter import rate_limiter
+from .utils.logger import log_api_request
+from .utils.tasks import run_periodic_tasks, sync_pos_metrics_task
+from .services.websocket import connect, disconnect
+from .realtime.subscriber import subscribe_order_events
+from .routes.websocket import websocket_endpoint, manager, router as websocket_router
+import socketio
+import time
+import logging
+import asyncio
+from typing import List, Dict
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create Socket.IO server
+sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
+socket_app = socketio.ASGIApp(sio)
+
+app = FastAPI(title=settings.PROJECT_NAME, version=settings.VERSION, openapi_url=f"{settings.API_V1_STR}/openapi.json")
+
+# Store background tasks
+background_tasks = set()
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Socket.IO event handlers
+@sio.event
+async def connect(sid, environ):
+    logger.info(f"Client connected: {sid}")
+
+@sio.event
+async def disconnect(sid):
+    logger.info(f"Client disconnected: {sid}")
+
+@sio.event
+async def message(sid, data):
+    logger.info(f"Message from {sid}: {data}")
+    await sio.emit('message', {'response': 'Message received'}, room=sid)
+
+# Mount Socket.IO app
+app.mount("/socket.io", socket_app)
+
+@app.get("/api/v1/health")
+async def health_check() -> Dict[str, str]:
+    """Public health check endpoint that doesn't require authentication"""
+    return {
+        "status": "healthy",
+        "version": settings.VERSION,
+        "service": settings.PROJECT_NAME
+    }
+
+# WebSocket endpoint
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await connect(websocket)
+    try:
+        while True:
+            data = await websocket.receive_text()
+    except:
+        await disconnect(websocket)
+
+@app.websocket("/ws/orders")
+async def orders_websocket_endpoint(websocket: WebSocket):
+    await websocket_endpoint(websocket)
+
+# Request logging and rate limiting middleware
+@app.middleware("http")
+async def middleware(request: Request, call_next):
+    await rate_limiter.check_rate_limit(request)
+    start_time = time.time()
+    response = await call_next(request)
+    end_time = time.time()
+    duration = end_time - start_time
+    log_api_request(
+        method=request.method,
+        path=request.url.path,
+        status_code=response.status_code,
+        duration=duration
+    )
+    return response
+
+# Application startup and shutdown events
+@app.on_event("startup")
+async def startup_event():
+    # Create all database tables
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    
+    # Start Redis subscriber in background
+    task = asyncio.create_task(subscribe_order_events(manager))
+    background_tasks.add(task)
+    task.add_done_callback(background_tasks.discard)
+
+    # Start periodic tasks
+    task = asyncio.create_task(run_periodic_tasks())
+    background_tasks.add(task)
+    task.add_done_callback(background_tasks.discard)
+
+    # Start POS metrics sync task
+    task = asyncio.create_task(sync_pos_metrics_task())
+    background_tasks.add(task)
+    task.add_done_callback(background_tasks.discard)
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    # Cancel background tasks
+    for task in background_tasks:
+        task.cancel()
+
+# Include routers
+app.include_router(auth.router, prefix=f"{settings.API_V1_STR}/auth", tags=["auth"])
+app.include_router(users.router, prefix=f"{settings.API_V1_STR}/users", tags=["users"])
+app.include_router(products.router, prefix=f"{settings.API_V1_STR}/products", tags=["products"])
+app.include_router(orders.router, prefix=f"{settings.API_V1_STR}/orders", tags=["orders"])
+app.include_router(analytics.router, prefix=f"{settings.API_V1_STR}/analytics", tags=["analytics"])
+app.include_router(files.router, prefix=f"{settings.API_V1_STR}/files", tags=["files"])
+app.include_router(notifications.router, prefix=f"{settings.API_V1_STR}/notifications", tags=["notifications"])
+app.include_router(calendar.router, prefix=f"{settings.API_V1_STR}/calendar", tags=["calendar"])
+app.include_router(scheduler.router, prefix=f"{settings.API_V1_STR}/scheduler", tags=["scheduler"])
+app.include_router(maintenance.router, prefix=f"{settings.API_V1_STR}/maintenance", tags=["maintenance"])
+app.include_router(branches.router, prefix=f"{settings.API_V1_STR}/branches", tags=["branches"])
+app.include_router(staff_analytics.router, prefix=f"{settings.API_V1_STR}/staff", tags=["staff"])
+app.include_router(sessions.router, prefix=f"{settings.API_V1_STR}/sessions", tags=["sessions"])
+app.include_router(websocket_router)
+
+@app.get("/")
+async def root():
+    return {
+        "message": f"Welcome to {settings.PROJECT_NAME} v{settings.VERSION}",
+        "docs_url": "/docs",
+        "openapi_url": "/openapi.json"
     }

app/realtime/subscriber.py

@@ -1,58 +0,0 @@
-import json
-import asyncio
-from redis.asyncio import Redis
-from typing import Optional, Dict
-from ..core.config import settings
-from ..utils.logger import logger
-
-# Singleton Redis connection
-_redis: Optional[Redis] = None
-
-async def get_redis() -> Redis:
-    """Get or create Redis connection"""
-    global _redis
-    if _redis is None:
-        _redis = Redis.from_url(settings.REDIS_URL, decode_responses=True)
-    return _redis
-
-async def _handle_message(channel: str, data: str, manager: "OrderWebSocketManager"):
-    """Handle incoming Redis messages"""
-    try:
-        message = json.loads(data)
-        await manager.broadcast_to_branch(message["branch_id"], {
-            "type": "order.new",
-            "data": message
-        })
-    except Exception as e:
-        logger.error(f"Error handling Redis message: {str(e)}")
-
-async def subscribe_order_events(manager: "OrderWebSocketManager"):
-    """Subscribe to order events from Redis"""
-    redis = await get_redis()
-    pubsub = redis.pubsub()
-    
-    try:
-        await pubsub.subscribe("order:new")
-        logger.info("Subscribed to order events channel")
-        
-        while True:
-            try:
-                message = await pubsub.get_message(ignore_subscribe_messages=True)
-                if message and message["type"] == "message":
-                    await _handle_message(
-                        message["channel"],
-                        message["data"],
-                        manager
-                    )
-            except Exception as e:
-                logger.error(f"Error processing message: {str(e)}")
-                await asyncio.sleep(1)  # Avoid tight loop on errors
-            
-            await asyncio.sleep(0.1)  # Avoid busy waiting
-            
-    except Exception as e:
-        logger.error(f"Redis subscription error: {str(e)}")
-        raise
-    finally:
-        await pubsub.unsubscribe("order:new")
-        await redis.close()

app/routes/websocket.py

@@ -1,82 +1,76 @@
-from fastapi import WebSocket, WebSocketDisconnect, HTTPException, Depends
-from typing import Dict, List, Optional
-from ..core.dependencies import get_current_user
-from ..db.models import User
+from fastapi import WebSocket, WebSocketDisconnect, APIRouter
+from typing import Dict, Set, List, Any
+import json
+from ..services.analytics import staff_analytics
+from ..core.config import settings
 from ..utils.logger import logger
-import asyncio
 
-class OrderWebSocketManager:
+router = APIRouter()
+
+class ConnectionManager:
     def __init__(self):
-        # Map of branch_id -> List[WebSocket]
-        self.active_connections: Dict[str, List[WebSocket]] = {}
+        self.active_connections: Dict[str, Set[WebSocket]] = {
+            "orders": set(),
+            "notifications": set(),
+            "staff_metrics": set()
+        }
 
-    async def connect(self, websocket: WebSocket, branch_id: str):
-        """Register new WebSocket connection for a branch"""
+    async def connect(self, websocket: WebSocket, channel: str):
         await websocket.accept()
-        if branch_id not in self.active_connections:
-            self.active_connections[branch_id] = []
-        self.active_connections[branch_id].append(websocket)
+        if channel not in self.active_connections:
+            self.active_connections[channel] = set()
+        self.active_connections[channel].add(websocket)
 
-    async def disconnect(self, websocket: WebSocket, branch_id: str):
-        """Remove WebSocket connection"""
-        if branch_id in self.active_connections:
-            try:
-                self.active_connections[branch_id].remove(websocket)
-                if not self.active_connections[branch_id]:
-                    del self.active_connections[branch_id]
-            except ValueError:
-                pass
+    def disconnect(self, websocket: WebSocket, channel: str):
+        self.active_connections[channel].remove(websocket)
 
-    async def broadcast_to_branch(self, branch_id: str, message: dict):
-        """Send message to all connections for a branch"""
-        if branch_id not in self.active_connections:
+    async def broadcast(self, message: Dict[str, Any], channel: str):
+        if channel not in self.active_connections:
             return
             
-        disconnected = []
-        for connection in self.active_connections[branch_id]:
+        for connection in self.active_connections[channel]:
             try:
                 await connection.send_json(message)
-            except:
-                disconnected.append(connection)
-        
-        # Clean up disconnected clients
-        for connection in disconnected:
-            await self.disconnect(connection, branch_id)
+            except Exception as e:
+                logger.error(f"Error broadcasting to websocket: {str(e)}")
+                await self.disconnect(connection, channel)
 
-# Global WebSocket manager instance
-manager = OrderWebSocketManager()
+    async def broadcast_staff_metrics(self, metrics: Dict[str, Any]):
+        """Broadcast staff performance metrics update"""
+        await self.broadcast(
+            {
+                "type": "staff_metrics_update",
+                "data": metrics
+            },
+            "staff_metrics"
+        )
 
-async def get_websocket_user(websocket: WebSocket) -> Optional[User]:
-    """Authenticate WebSocket connection using token from query params"""
-    try:
-        token = websocket.query_params.get("token")
-        if not token:
-            return None
-        
-        # Use existing auth dependency
-        user = await get_current_user(token)
-        if not user or not user.is_active:
-            return None
-            
-        return user
-    except Exception as e:
-        logger.error(f"WebSocket auth error: {str(e)}")
-        return None
-
-async def websocket_endpoint(websocket: WebSocket):
-    """WebSocket endpoint for order events"""
-    user = await get_websocket_user(websocket)
-    if not user or not user.branch_id:
-        await websocket.close(code=4001)
-        return
+manager = ConnectionManager()
 
+@router.websocket("/ws/staff")
+async def staff_metrics_websocket(websocket: WebSocket):
+    await manager.connect(websocket, "staff_metrics")
     try:
-        await manager.connect(websocket, str(user.branch_id))
         while True:
-            # Keep connection alive and handle client messages if needed
             data = await websocket.receive_text()
+            try:
+                message = json.loads(data)
+                if message.get("type") == "subscribe" and message.get("branch_id"):
+                    # Get real-time metrics for the branch
+                    metrics = await staff_analytics.get_staff_performance(
+                        branch_id=message["branch_id"]
+                    )
+                    await websocket.send_json({
+                        "type": "staff_metrics_update",
+                        "data": metrics
+                    })
+            except json.JSONDecodeError:
+                logger.error("Invalid WebSocket message format")
+            except Exception as e:
+                logger.error(f"Error processing WebSocket message: {str(e)}")
     except WebSocketDisconnect:
-        await manager.disconnect(websocket, str(user.branch_id))
-    except Exception as e:
-        logger.error(f"WebSocket error: {str(e)}")
-        await manager.disconnect(websocket, str(user.branch_id))
+        manager.disconnect(websocket, "staff_metrics")
+
+async def broadcast_staff_update(metrics: Dict[str, Any]):
+    """Broadcast staff performance update to all connected clients"""
+    await manager.broadcast_staff_metrics(metrics)

app/services/analytics.py

@@ -1,7 +1,12 @@
 from datetime import datetime, timedelta
+from sqlalchemy import func, and_, select, extract
 from ..db.database import db
 from ..utils.cache import cache
-from typing import Dict, List, Any
+from ..db.models import StaffActivity, PerformanceMetric, User, ActivityType
+from ..services.performance_notifications import performance_notifications
+from typing import Dict, List, Any, Optional
+import numpy as np
+from collections import defaultdict
 
 class AnalyticsService:
     @staticmethod
@@ -128,4 +133,284 @@ class AnalyticsService:
         await cache.set_cache(cache_key, result, expire=3600)  # Cache for 1 hour
         return result
 
-analytics = AnalyticsService()
+class StaffAnalyticsService:
+    @staticmethod
+    async def record_activity(
+        user_id: int,
+        branch_id: int,
+        activity_type: ActivityType,
+        details: dict,
+        duration: Optional[float] = None
+    ) -> StaffActivity:
+        """Record a staff activity with performance scoring and notifications"""
+        
+        # Calculate performance score based on activity type and details
+        score = None
+        if activity_type == ActivityType.SALE:
+            # Score based on sale amount and speed
+            amount = details.get('amount', 0)
+            duration = details.get('duration', 0)  # duration in minutes
+            if duration > 0:
+                score = min((amount / 100) * (5 / duration), 10)  # Max score of 10
+        elif activity_type == ActivityType.CUSTOMER_SERVICE:
+            # Score based on interaction quality
+            satisfaction = details.get('customer_satisfaction', 0)
+            resolution_time = details.get('resolution_time', 0)
+            if resolution_time > 0:
+                score = min((satisfaction * 2) * (10 / resolution_time), 10)
+
+        async with db() as session:
+            activity = StaffActivity(
+                user_id=user_id,
+                branch_id=branch_id,
+                activity_type=activity_type,
+                details=details,
+                duration=duration,
+                performance_score=score
+            )
+            session.add(activity)
+            await session.commit()
+            await session.refresh(activity)
+            
+            # Get current metrics before update
+            prev_metrics = await StaffAnalyticsService._get_current_metrics(user_id, branch_id)
+            
+            # Update daily performance metrics
+            new_metrics = await StaffAnalyticsService._update_performance_metrics(
+                user_id, branch_id, activity
+            )
+            
+            # Check and send notifications based on new metrics
+            await performance_notifications.check_and_notify_performance(
+                user_id=user_id,
+                branch_id=branch_id,
+                metrics=new_metrics
+            )
+            
+            # Check for realtime alerts by comparing with previous metrics
+            if prev_metrics:
+                await performance_notifications.notify_realtime_alerts(
+                    branch_id=branch_id,
+                    current_metrics=new_metrics,
+                    previous_metrics=prev_metrics
+                )
+            
+            return activity
+
+    @staticmethod
+    async def _get_current_metrics(user_id: int, branch_id: int) -> Optional[Dict[str, Any]]:
+        """Get current day's metrics for a user"""
+        today = datetime.utcnow().date()
+        
+        async with db() as session:
+            stmt = select(PerformanceMetric).where(
+                and_(
+                    PerformanceMetric.user_id == user_id,
+                    PerformanceMetric.branch_id == branch_id,
+                    func.date(PerformanceMetric.metric_date) == today
+                )
+            )
+            result = await session.execute(stmt)
+            metric = result.scalar_one_or_none()
+            
+            if metric:
+                return {
+                    "total_sales": metric.total_sales,
+                    "transaction_count": metric.transaction_count,
+                    "void_count": metric.void_count,
+                    "efficiency_score": metric.efficiency_score,
+                    "customer_interaction_count": metric.customer_interaction_count
+                }
+            return None
+
+    @staticmethod
+    async def _update_performance_metrics(
+        user_id: int,
+        branch_id: int,
+        activity: StaffActivity
+    ) -> Dict[str, Any]:
+        """Update daily performance metrics based on new activity"""
+        today = datetime.utcnow().date()
+        
+        async with db() as session:
+            # Get or create today's metrics
+            stmt = select(PerformanceMetric).where(
+                and_(
+                    PerformanceMetric.user_id == user_id,
+                    PerformanceMetric.branch_id == branch_id,
+                    func.date(PerformanceMetric.metric_date) == today
+                )
+            )
+            result = await session.execute(stmt)
+            metric = result.scalar_one_or_none()
+            
+            if not metric:
+                metric = PerformanceMetric(
+                    user_id=user_id,
+                    branch_id=branch_id,
+                    metric_date=datetime.utcnow()
+                )
+                session.add(metric)
+
+            # Update metrics based on activity type
+            if activity.activity_type == ActivityType.SALE:
+                metric.total_sales += activity.details.get('amount', 0)
+                metric.transaction_count += 1
+                metric.average_transaction_value = metric.total_sales / metric.transaction_count
+            elif activity.activity_type == ActivityType.VOID:
+                metric.void_count += 1
+            elif activity.activity_type == ActivityType.CUSTOMER_SERVICE:
+                metric.customer_interaction_count += 1
+            elif activity.activity_type in [ActivityType.LOGIN, ActivityType.LOGOUT]:
+                if activity.duration:
+                    metric.login_time += activity.duration
+
+            # Calculate efficiency score
+            # Weight different factors in the score
+            weights = {
+                'sales': 0.4,
+                'speed': 0.2,
+                'accuracy': 0.2,
+                'customer_service': 0.2
+            }
+            
+            # Calculate component scores
+            sales_score = min((metric.total_sales / 1000) * 10, 10)  # Scale sales to 0-10
+            speed_score = 10 * (1 - (metric.login_time / (8 * 60)))  # Assuming 8-hour day
+            accuracy_score = 10 * (1 - (metric.void_count / max(metric.transaction_count, 1)))
+            cs_score = min((metric.customer_interaction_count / 10) * 10, 10)
+            
+            metric.efficiency_score = (
+                (sales_score * weights['sales']) +
+                (speed_score * weights['speed']) +
+                (accuracy_score * weights['accuracy']) +
+                (cs_score * weights['customer_service'])
+            )
+
+            await session.commit()
+            await session.refresh(metric)
+            
+            return {
+                "total_sales": metric.total_sales,
+                "transaction_count": metric.transaction_count,
+                "average_transaction_value": metric.average_transaction_value,
+                "void_count": metric.void_count,
+                "customer_interaction_count": metric.customer_interaction_count,
+                "login_time": metric.login_time,
+                "efficiency_score": metric.efficiency_score
+            }
+
+    @staticmethod
+    async def get_staff_performance(
+        branch_id: Optional[int] = None,
+        user_id: Optional[int] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None
+    ) -> Dict[str, Any]:
+        """Get comprehensive staff performance metrics"""
+        if not start_date:
+            start_date = datetime.utcnow() - timedelta(days=30)
+        if not end_date:
+            end_date = datetime.utcnow()
+
+        cache_key = f"staff_performance:{branch_id}:{user_id}:{start_date.date()}:{end_date.date()}"
+        cached_data = await cache.get_cache(cache_key)
+        if cached_data:
+            return cached_data
+
+        async with db() as session:
+            # Base query conditions
+            conditions = [
+                PerformanceMetric.metric_date.between(start_date, end_date)
+            ]
+            if branch_id:
+                conditions.append(PerformanceMetric.branch_id == branch_id)
+            if user_id:
+                conditions.append(PerformanceMetric.user_id == user_id)
+
+            # Get aggregated metrics
+            metrics_stmt = select(
+                PerformanceMetric.user_id,
+                func.sum(PerformanceMetric.total_sales).label('total_sales'),
+                func.sum(PerformanceMetric.transaction_count).label('transaction_count'),
+                func.avg(PerformanceMetric.average_transaction_value).label('avg_transaction_value'),
+                func.sum(PerformanceMetric.void_count).label('void_count'),
+                func.sum(PerformanceMetric.customer_interaction_count).label('customer_interactions'),
+                func.sum(PerformanceMetric.login_time).label('total_login_time'),
+                func.avg(PerformanceMetric.efficiency_score).label('avg_efficiency_score')
+            ).where(
+                and_(*conditions)
+            ).group_by(
+                PerformanceMetric.user_id
+            )
+
+            result = await session.execute(metrics_stmt)
+            metrics_data = result.all()
+
+            # Get user details
+            user_ids = [m.user_id for m in metrics_data]
+            users_stmt = select(User).where(User.id.in_(user_ids))
+            users = (await session.execute(users_stmt)).scalars().all()
+            users_dict = {u.id: u for u in users}
+
+            # Format response data
+            performance_data = []
+            for metric in metrics_data:
+                user = users_dict.get(metric.user_id)
+                if user:
+                    performance_data.append({
+                        "user_id": user.id,
+                        "username": user.username,
+                        "full_name": user.full_name,
+                        "metrics": {
+                            "total_sales": metric.total_sales,
+                            "transaction_count": metric.transaction_count,
+                            "average_transaction_value": metric.avg_transaction_value,
+                            "void_count": metric.void_count,
+                            "customer_interactions": metric.customer_interactions,
+                            "total_login_time": metric.total_login_time,
+                            "efficiency_score": metric.avg_efficiency_score
+                        }
+                    })
+
+            # Calculate branch averages if branch_id is specified
+            branch_averages = None
+            if branch_id:
+                avg_stmt = select(
+                    func.avg(PerformanceMetric.total_sales).label('avg_sales'),
+                    func.avg(PerformanceMetric.transaction_count).label('avg_transactions'),
+                    func.avg(PerformanceMetric.average_transaction_value).label('avg_transaction_value'),
+                    func.avg(PerformanceMetric.efficiency_score).label('avg_efficiency')
+                ).where(
+                    and_(
+                        PerformanceMetric.branch_id == branch_id,
+                        PerformanceMetric.metric_date.between(start_date, end_date)
+                    )
+                )
+                
+                avg_result = await session.execute(avg_stmt)
+                branch_avg = avg_result.one()
+                branch_averages = {
+                    "average_daily_sales": branch_avg.avg_sales,
+                    "average_daily_transactions": branch_avg.avg_transactions,
+                    "average_transaction_value": branch_avg.avg_transaction_value,
+                    "average_efficiency_score": branch_avg.avg_efficiency
+                }
+
+            response = {
+                "staff_performance": performance_data,
+                "date_range": {
+                    "start_date": start_date.isoformat(),
+                    "end_date": end_date.isoformat()
+                }
+            }
+
+            if branch_averages:
+                response["branch_averages"] = branch_averages
+
+            # Cache the response for 1 hour
+            await cache.set_cache(cache_key, response, expire=3600)
+            return response
+
+analytics = AnalyticsService()
+staff_analytics = StaffAnalyticsService()

app/services/maintenance.py

@@ -9,8 +9,214 @@ from ..utils.logger import logger
 from ..core.config import settings
 from ..services.websocket import create_and_broadcast_notification
 from ..db.models import User, Order, Notification, Session
+from ..utils.cache import cache
+from sqlalchemy import text
+import aioredis
+import asyncio
+from ..utils.retry import retry_with_backoff, circuit_breaker, CircuitBreaker
 
 class MaintenanceService:
+    def __init__(self):
+        self._last_sync_time = None
+        self._background_tasks = {}
+        self.last_health_check = None
+        self.last_maintenance = None
+        self.circuit_breaker = CircuitBreaker(
+            failure_threshold=5,
+            reset_timeout=60
+        )
+
+    def get_timestamp(self) -> str:
+        """Get current timestamp in ISO format"""
+        return datetime.utcnow().isoformat()
+
+    def get_last_sync_time(self) -> str:
+        """Get last sync timestamp"""
+        return self._last_sync_time or "Never"
+
+    def get_next_sync_time(self) -> str:
+        """Calculate next scheduled sync time"""
+        if not self._last_sync_time:
+            return "Not scheduled"
+        
+        last_sync = datetime.fromisoformat(self._last_sync_time)
+        next_sync = last_sync + timedelta(minutes=15)  # 15-minute sync interval
+        return next_sync.isoformat()
+
+    @retry_with_backoff(max_retries=3, initial_delay=1.0)
+    async def check_database(self) -> Dict[str, Any]:
+        """Check database connectivity and performance metrics"""
+        try:
+            async with db() as session:
+                # Check basic connectivity
+                await session.execute(select(1))
+                
+                # Check database stats
+                result = await session.execute(
+                    text("""
+                        SELECT 
+                            (SELECT count(*) FROM pg_stat_activity) as active_connections,
+                            (SELECT count(*) FROM pg_stat_activity WHERE state = 'active') as active_queries,
+                            (SELECT count(*) FROM pg_stat_activity WHERE state = 'idle') as idle_connections,
+                            (SELECT round(sum(blks_hit)*100/sum(blks_hit + blks_read), 2)
+                             FROM pg_stat_database) as cache_hit_ratio
+                    """)
+                )
+                stats = result.mappings().one()
+
+                return {
+                    "status": "healthy",
+                    "active_connections": stats["active_connections"],
+                    "active_queries": stats["active_queries"],
+                    "idle_connections": stats["idle_connections"],
+                    "cache_hit_ratio": stats["cache_hit_ratio"]
+                }
+
+        except Exception as e:
+            logger.error(f"Database health check error: {str(e)}")
+            return {
+                "status": "unhealthy",
+                "error": str(e)
+            }
+
+    @retry_with_backoff(max_retries=2, initial_delay=0.5)
+    async def check_redis(self) -> Dict[str, Any]:
+        """Check Redis connectivity and performance"""
+        try:
+            # Test Redis connection
+            await cache.redis.ping()
+            
+            # Get Redis info
+            info = await cache.redis.info()
+            
+            return {
+                "status": "healthy",
+                "connected_clients": info["connected_clients"],
+                "used_memory_human": info["used_memory_human"],
+                "total_connections_received": info["total_connections_received"],
+                "uptime_in_seconds": info["uptime_in_seconds"]
+            }
+
+        except Exception as e:
+            logger.error(f"Redis health check error: {str(e)}")
+            return {
+                "status": "unhealthy",
+                "error": str(e)
+            }
+
+    @circuit_breaker(failure_threshold=5, reset_timeout=300.0)
+    async def check_background_tasks(self) -> Dict[str, Any]:
+        """Check status of background tasks"""
+        active_tasks = []
+        completed_tasks = []
+        failed_tasks = []
+
+        for task_id, task_info in self._background_tasks.items():
+            status = {
+                "id": task_id,
+                "name": task_info["name"],
+                "started_at": task_info["started_at"].isoformat(),
+                "last_updated": task_info["last_updated"].isoformat()
+            }
+
+            if task_info["task"].done():
+                if task_info["task"].exception():
+                    failed_tasks.append({
+                        **status,
+                        "error": str(task_info["task"].exception())
+                    })
+                else:
+                    completed_tasks.append(status)
+            else:
+                active_tasks.append(status)
+
+        return {
+            "status": "healthy" if not failed_tasks else "warning",
+            "active_tasks": active_tasks,
+            "completed_tasks": completed_tasks,
+            "failed_tasks": failed_tasks
+        }
+
+    async def register_background_task(
+        self,
+        task: asyncio.Task,
+        name: str
+    ) -> str:
+        """Register a new background task for monitoring"""
+        task_id = f"{name}_{datetime.utcnow().timestamp()}"
+        self._background_tasks[task_id] = {
+            "task": task,
+            "name": name,
+            "started_at": datetime.utcnow(),
+            "last_updated": datetime.utcnow()
+        }
+        return task_id
+
+    async def update_task_status(self, task_id: str):
+        """Update last_updated timestamp for a task"""
+        if task_id in self._background_tasks:
+            self._background_tasks[task_id]["last_updated"] = datetime.utcnow()
+
+    async def cleanup_completed_tasks(self):
+        """Remove completed tasks older than 24 hours"""
+        current_time = datetime.utcnow()
+        to_remove = []
+
+        for task_id, task_info in self._background_tasks.items():
+            if task_info["task"].done():
+                age = current_time - task_info["last_updated"]
+                if age > timedelta(hours=24):
+                    to_remove.append(task_id)
+
+        for task_id in to_remove:
+            del self._background_tasks[task_id]
+
+    async def perform_maintenance(self) -> Dict[str, Any]:
+        """Perform system maintenance tasks"""
+        async with self.circuit_breaker:
+            try:
+                # Clean up old background tasks
+                await self.cleanup_completed_tasks()
+                
+                # Clean up expired cache entries
+                await cache.cleanup_expired()
+                
+                # Run database maintenance
+                async with db() as session:
+                    # Clean up old sessions
+                    await session.execute(
+                        text("DELETE FROM sessions WHERE last_activity < NOW() - INTERVAL '7 days'")
+                    )
+                    
+                    # Clean up old notifications
+                    await session.execute(
+                        text("""
+                            DELETE FROM notifications 
+                            WHERE created_at < NOW() - INTERVAL '30 days'
+                            AND read = true
+                        """)
+                    )
+                    
+                    # Analyze tables for query optimization
+                    await session.execute(text("ANALYZE"))
+                    
+                    await session.commit()
+
+                return {
+                    "status": "success",
+                    "message": "Maintenance completed successfully",
+                    "timestamp": self.get_timestamp()
+                }
+
+            except Exception as e:
+                logger.error(f"Maintenance error: {str(e)}")
+                return {
+                    "status": "error",
+                    "message": f"Maintenance failed: {str(e)}",
+                    "timestamp": self.get_timestamp()
+                }
+
+    @retry_with_backoff(max_retries=2)
     async def cleanup_expired_sessions(self) -> int:
         """Clean up expired sessions"""
         try:
@@ -95,6 +301,7 @@ class MaintenanceService:
             logger.error(f"Health check error: {str(e)}")
             return {"status": "unhealthy", "error": str(e)}
 
+    @retry_with_backoff(max_retries=2, initial_delay=1.0)
     async def monitor_system_resources(self) -> Dict[str, Any]:
         """Monitor system resources"""
         try:
@@ -174,6 +381,7 @@ class MaintenanceService:
         except Exception as e:
             logger.error(f"Log rotation error: {str(e)}")
 
+    @retry_with_backoff(max_retries=3)
     async def manage_storage_quotas(self) -> Dict[str, Any]:
         """Manage storage quotas and cleanup"""
         try:
@@ -214,4 +422,17 @@ class MaintenanceService:
             logger.error(f"Storage quota management error: {str(e)}")
             return {"error": str(e)}
 
-maintenance = MaintenanceService()
+    def _calculate_storage_usage(self, storage_type: str) -> Dict[str, Any]:
+        """Helper method to calculate storage usage"""
+        base_path = settings.UPLOAD_DIR / storage_type
+        total_size = sum(f.stat().st_size for f in base_path.glob('**/*') if f.is_file())
+        quota = getattr(settings, f"{storage_type.upper()}_QUOTA_BYTES")
+        usage_percent = (total_size / quota) * 100 if quota > 0 else 0
+        
+        return {
+            "current_size": total_size,
+            "quota": quota,
+            "usage_percent": round(usage_percent, 2)
+        }
+
+maintenance_service = MaintenanceService()

app/services/performance_notifications.py

@@ -0,0 +1,195 @@
+from datetime import datetime
+from typing import Dict, Any, List, Optional
+from ..services.notifications import create_and_broadcast_notification
+from ..services.analytics import staff_analytics
+from ..db.models import ActivityType
+from ..utils.logger import logger
+
+class PerformanceNotificationService:
+    # Performance thresholds for notifications
+    THRESHOLDS = {
+        "high_efficiency": 9.0,  # Notify for efficiency scores above 9
+        "low_efficiency": 5.0,   # Warn for efficiency scores below 5
+        "sales_milestone": 10000, # Notify for sales milestones (every 10k)
+        "high_void_rate": 0.1,   # Warn when void rate exceeds 10%
+        "customer_service": 20,   # Notify for high customer service interactions
+    }
+
+    @staticmethod
+    async def check_and_notify_performance(
+        user_id: int,
+        branch_id: int,
+        metrics: Dict[str, Any]
+    ):
+        """Check performance metrics and send notifications if thresholds are met"""
+        try:
+            notifications = []
+
+            # Check efficiency score
+            if metrics["efficiency_score"] >= PerformanceNotificationService.THRESHOLDS["high_efficiency"]:
+                notifications.append({
+                    "title": "Outstanding Performance!",
+                    "message": "Your efficiency score is exceptional. Keep up the great work!",
+                    "type": "performance_achievement",
+                    "data": {
+                        "metric": "efficiency_score",
+                        "value": metrics["efficiency_score"]
+                    }
+                })
+            elif metrics["efficiency_score"] <= PerformanceNotificationService.THRESHOLDS["low_efficiency"]:
+                notifications.append({
+                    "title": "Performance Alert",
+                    "message": "Your efficiency score needs improvement. Contact your supervisor for support.",
+                    "type": "performance_alert",
+                    "data": {
+                        "metric": "efficiency_score",
+                        "value": metrics["efficiency_score"]
+                    }
+                })
+
+            # Check sales milestones
+            milestone = PerformanceNotificationService.THRESHOLDS["sales_milestone"]
+            if metrics["total_sales"] > 0 and metrics["total_sales"] % milestone < 100:
+                notifications.append({
+                    "title": "Sales Milestone Achieved!",
+                    "message": f"Congratulations! You've reached {int(metrics['total_sales'] / 1000)}k in sales.",
+                    "type": "sales_milestone",
+                    "data": {
+                        "metric": "total_sales",
+                        "value": metrics["total_sales"]
+                    }
+                })
+
+            # Check void rate
+            if metrics["transaction_count"] > 0:
+                void_rate = metrics["void_count"] / metrics["transaction_count"]
+                if void_rate > PerformanceNotificationService.THRESHOLDS["high_void_rate"]:
+                    notifications.append({
+                        "title": "High Void Rate Alert",
+                        "message": "Your void transaction rate is above average. Please review procedures.",
+                        "type": "void_rate_alert",
+                        "data": {
+                            "metric": "void_rate",
+                            "value": void_rate
+                        }
+                    })
+
+            # Check customer service interactions
+            if metrics["customer_interaction_count"] >= PerformanceNotificationService.THRESHOLDS["customer_service"]:
+                notifications.append({
+                    "title": "Customer Service Achievement",
+                    "message": "Great job handling customer interactions today!",
+                    "type": "customer_service_achievement",
+                    "data": {
+                        "metric": "customer_interactions",
+                        "value": metrics["customer_interaction_count"]
+                    }
+                })
+
+            # Send all notifications
+            for notif in notifications:
+                await create_and_broadcast_notification(
+                    user_id=str(user_id),
+                    title=notif["title"],
+                    message=notif["message"],
+                    notification_type=notif["type"],
+                    data=notif["data"]
+                )
+
+                # If it's an alert, also notify supervisor
+                if "alert" in notif["type"]:
+                    await create_and_broadcast_notification(
+                        user_id="supervisor",
+                        title=f"Staff Alert: {notif['title']}",
+                        message=f"Staff member {user_id} in branch {branch_id}: {notif['message']}",
+                        notification_type=f"supervisor_{notif['type']}",
+                        data={
+                            **notif["data"],
+                            "staff_id": user_id,
+                            "branch_id": branch_id
+                        }
+                    )
+
+        except Exception as e:
+            logger.error(f"Error in performance notifications: {str(e)}")
+
+    @staticmethod
+    async def notify_performance_insights(
+        branch_id: int,
+        insights: List[Dict[str, Any]]
+    ):
+        """Send notifications for performance insights"""
+        try:
+            for insight in insights:
+                if insight["type"] in ["warning", "positive"]:
+                    await create_and_broadcast_notification(
+                        user_id="supervisor",
+                        title=f"Branch Performance Insight",
+                        message=insight["message"],
+                        notification_type=f"performance_insight_{insight['type']}",
+                        data={
+                            "branch_id": branch_id,
+                            "category": insight["category"],
+                            "insight_type": insight["type"]
+                        }
+                    )
+
+        except Exception as e:
+            logger.error(f"Error in insight notifications: {str(e)}")
+
+    @staticmethod
+    async def notify_realtime_alerts(
+        branch_id: int,
+        current_metrics: Dict[str, Any],
+        previous_metrics: Optional[Dict[str, Any]] = None
+    ):
+        """Send notifications for significant real-time changes"""
+        try:
+            if not previous_metrics:
+                return
+
+            alerts = []
+
+            # Check for significant drops in performance
+            if (previous_metrics["efficiency_score"] - current_metrics["efficiency_score"]) > 2:
+                alerts.append({
+                    "title": "Sudden Performance Drop",
+                    "message": "Notable decrease in staff performance detected.",
+                    "type": "realtime_performance_alert"
+                })
+
+            # Check for unusual void patterns
+            current_void_rate = (
+                current_metrics["void_count"] / current_metrics["transaction_count"]
+                if current_metrics["transaction_count"] > 0 else 0
+            )
+            previous_void_rate = (
+                previous_metrics["void_count"] / previous_metrics["transaction_count"]
+                if previous_metrics["transaction_count"] > 0 else 0
+            )
+
+            if current_void_rate > previous_void_rate * 2:
+                alerts.append({
+                    "title": "Unusual Void Pattern",
+                    "message": "Significant increase in void transactions detected.",
+                    "type": "realtime_void_alert"
+                })
+
+            # Send alerts
+            for alert in alerts:
+                await create_and_broadcast_notification(
+                    user_id="supervisor",
+                    title=alert["title"],
+                    message=alert["message"],
+                    notification_type=alert["type"],
+                    data={
+                        "branch_id": branch_id,
+                        "current_metrics": current_metrics,
+                        "previous_metrics": previous_metrics
+                    }
+                )
+
+        except Exception as e:
+            logger.error(f"Error in realtime alert notifications: {str(e)}")
+
+performance_notifications = PerformanceNotificationService()

app/services/pos_analytics.py

@@ -0,0 +1,376 @@
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+from ..core.config import settings
+from ..utils.logger import logger, log_health_check
+from ..services.analytics import staff_analytics
+from ..db.models import ActivityType
+from ..routes.websocket import broadcast_staff_update
+from ..utils.retry import with_retry, retry_with_backoff
+import httpx
+import asyncio
+import aiohttp
+
+class POSAnalyticsService:
+    def __init__(self):
+        self.pos_api_url = settings.POS_API_URL
+        self.service_token = settings.SERVICE_TOKEN
+        self._headers = {
+            "Authorization": f"Bearer {self.service_token}",
+            "Content-Type": "application/json"
+        }
+        self._last_sync_time = None
+        self._metrics_cache = {}
+        self._failed_operations = []
+        self._last_error = None
+
+    @with_retry(max_retries=3, delay=1.0, exceptions=(httpx.HTTPError, asyncio.TimeoutError))
+    async def sync_pos_activity(self, pos_data: Dict[str, Any]) -> bool:
+        """
+        Sync staff activity data from POS system with retry mechanism
+        """
+        try:
+            # Map POS activity types to our ActivityType enum
+            activity_mapping = {
+                "sale": ActivityType.SALE,
+                "void": ActivityType.VOID,
+                "refund": ActivityType.REFUND,
+                "inventory": ActivityType.INVENTORY,
+                "customer_service": ActivityType.CUSTOMER_SERVICE,
+                "login": ActivityType.LOGIN,
+                "logout": ActivityType.LOGOUT
+            }
+
+            activity_type = activity_mapping.get(pos_data["activity_type"].lower())
+            if not activity_type:
+                logger.warning(f"Unknown POS activity type: {pos_data['activity_type']}")
+                return False
+
+            # Record the activity in our system
+            await staff_analytics.record_activity(
+                user_id=pos_data["user_id"],
+                branch_id=pos_data["branch_id"],
+                activity_type=activity_type,
+                details=pos_data["details"],
+                duration=pos_data.get("duration")
+            )
+
+            # Get updated metrics for the branch and broadcast
+            metrics = await staff_analytics.get_staff_performance(
+                branch_id=pos_data["branch_id"],
+                start_date=datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
+            )
+            await broadcast_staff_update(metrics)
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Error syncing POS activity: {str(e)}")
+            raise
+
+    @with_retry(max_retries=3, delay=1.0, exceptions=(httpx.HTTPError, asyncio.TimeoutError))
+    async def get_pos_metrics(self, user_id: int, branch_id: int, date: datetime) -> Optional[Dict[str, Any]]:
+        """Fetch staff metrics from POS system with retry mechanism"""
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{self.pos_api_url}/api/v1/staff/metrics",
+                    headers=self._headers,
+                    params={
+                        "user_id": user_id,
+                        "branch_id": branch_id,
+                        "date": date.date().isoformat()
+                    },
+                    timeout=10.0
+                )
+                
+                response.raise_for_status()
+                return response.json()
+
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error fetching POS metrics: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"Error fetching POS metrics: {str(e)}")
+            return None
+
+    @with_retry(max_retries=3, delay=2.0, exceptions=(httpx.HTTPError, asyncio.TimeoutError))
+    async def sync_all_metrics(self, branch_id: Optional[int] = None) -> bool:
+        """
+        Sync all staff metrics from POS system with retry mechanism
+        """
+        try:
+            today = datetime.utcnow()
+            params = {"date": today.date().isoformat()}
+            if branch_id:
+                params["branch_id"] = branch_id
+
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{self.pos_api_url}/api/v1/staff/metrics/daily",
+                    headers=self._headers,
+                    params=params,
+                    timeout=30.0
+                )
+                
+                response.raise_for_status()
+                metrics_data = response.json()
+                sync_tasks = []
+                processed_branches = set()
+
+                for metric in metrics_data:
+                    activities = self._convert_metrics_to_activities(metric)
+                    processed_branches.add(metric["branch_id"])
+                    
+                    for activity in activities:
+                        sync_tasks.append(self.sync_pos_activity(activity))
+
+                # Run all sync tasks concurrently with individual retries
+                results = await asyncio.gather(*sync_tasks, return_exceptions=True)
+                
+                # Broadcast updates for each affected branch
+                for branch_id in processed_branches:
+                    metrics = await staff_analytics.get_staff_performance(branch_id=branch_id)
+                    await broadcast_staff_update(metrics)
+
+                # Check for any failures
+                success = all(
+                    result is True if not isinstance(result, Exception) else False
+                    for result in results
+                )
+
+                if not success:
+                    logger.warning("Some metrics failed to sync")
+
+                return success
+
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error in sync_all_metrics: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"Error in sync_all_metrics: {str(e)}")
+            return False
+
+    def _convert_metrics_to_activities(self, metric: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Convert POS metrics into individual activity records"""
+        activities = []
+        timestamp = datetime.utcnow().isoformat()
+
+        # Convert sales metrics
+        if metric.get("sales_amount"):
+            activities.append({
+                "user_id": metric["user_id"],
+                "branch_id": metric["branch_id"],
+                "activity_type": "sale",
+                "details": {
+                    "amount": metric["sales_amount"],
+                    "transaction_count": metric["transaction_count"]
+                },
+                "timestamp": timestamp
+            })
+
+        # Convert void transactions
+        if metric.get("void_count"):
+            activities.append({
+                "user_id": metric["user_id"],
+                "branch_id": metric["branch_id"],
+                "activity_type": "void",
+                "details": {
+                    "count": metric["void_count"],
+                    "amount": metric.get("void_amount", 0)
+                },
+                "timestamp": timestamp
+            })
+
+        # Convert customer service interactions
+        if metric.get("customer_interactions"):
+            activities.append({
+                "user_id": metric["user_id"],
+                "branch_id": metric["branch_id"],
+                "activity_type": "customer_service",
+                "details": {
+                    "interaction_count": metric["customer_interactions"],
+                    "satisfaction_score": metric.get("customer_satisfaction", 0)
+                },
+                "timestamp": timestamp
+            })
+
+        # Convert login time
+        if metric.get("login_duration"):
+            activities.append({
+                "user_id": metric["user_id"],
+                "branch_id": metric["branch_id"],
+                "activity_type": "login",
+                "details": {
+                    "session_type": "pos",
+                    "login_time": metric["login_duration"]
+                },
+                "timestamp": timestamp,
+                "duration": metric["login_duration"]
+            })
+
+        return activities
+
+    async def health_check(self) -> Dict[str, Any]:
+        """Check POS integration health status"""
+        try:
+            status = "healthy"
+            details = {
+                "last_sync": self._last_sync_time,
+                "failed_operations": len(self._failed_operations),
+                "cache_size": len(self._metrics_cache)
+            }
+
+            if self._last_error:
+                details["last_error"] = str(self._last_error)
+                if (datetime.utcnow() - self._last_sync_time) > timedelta(minutes=30):
+                    status = "warning"
+
+            if len(self._failed_operations) > 5:
+                status = "degraded"
+                
+            # Check POS API connectivity
+            try:
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(
+                        f"{settings.POS_API_URL}/health",
+                        timeout=5
+                    ) as response:
+                        if response.status == 200:
+                            details["api_status"] = "connected"
+                        else:
+                            details["api_status"] = "error"
+                            status = "unhealthy"
+            except Exception as e:
+                details["api_status"] = "connection_failed"
+                details["api_error"] = str(e)
+                status = "unhealthy"
+
+            log_health_check("pos_integration", status, details)
+            return {
+                "status": status,
+                "details": details
+            }
+
+        except Exception as e:
+            logger.error(f"POS health check failed: {str(e)}")
+            return {
+                "status": "error",
+                "details": {"error": str(e)}
+            }
+
+    @retry_with_backoff(max_retries=3)
+    async def sync_all_metrics(self) -> bool:
+        """Sync all metrics from POS system"""
+        try:
+            # Reset failed operations list
+            self._failed_operations = []
+            
+            # Sync various metrics
+            tasks = [
+                self._sync_sales_metrics(),
+                self._sync_inventory_metrics(),
+                self._sync_staff_metrics(),
+                self._sync_customer_metrics()
+            ]
+            
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            # Check for failures
+            for result in results:
+                if isinstance(result, Exception):
+                    self._failed_operations.append(str(result))
+                    logger.error(f"Metric sync failed: {str(result)}")
+            
+            self._last_sync_time = datetime.utcnow()
+            self._last_error = None if not self._failed_operations else self._failed_operations[-1]
+            
+            return len(self._failed_operations) == 0
+
+        except Exception as e:
+            self._last_error = str(e)
+            logger.error(f"Failed to sync metrics: {str(e)}")
+            return False
+
+    @retry_with_backoff(max_retries=2)
+    async def _sync_sales_metrics(self) -> Dict[str, Any]:
+        """Sync sales metrics from POS"""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{settings.POS_API_URL}/metrics/sales",
+                headers=self._get_auth_headers()
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    self._metrics_cache["sales"] = data
+                    return data
+                else:
+                    raise Exception(f"Failed to sync sales metrics: {response.status}")
+
+    @retry_with_backoff(max_retries=2)
+    async def _sync_inventory_metrics(self) -> Dict[str, Any]:
+        """Sync inventory metrics from POS"""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{settings.POS_API_URL}/metrics/inventory",
+                headers=self._get_auth_headers()
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    self._metrics_cache["inventory"] = data
+                    return data
+                else:
+                    raise Exception(f"Failed to sync inventory metrics: {response.status}")
+
+    @retry_with_backoff(max_retries=2)
+    async def _sync_staff_metrics(self) -> Dict[str, Any]:
+        """Sync staff performance metrics from POS"""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{settings.POS_API_URL}/metrics/staff",
+                headers=self._get_auth_headers()
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    self._metrics_cache["staff"] = data
+                    return data
+                else:
+                    raise Exception(f"Failed to sync staff metrics: {response.status}")
+
+    @retry_with_backoff(max_retries=2)
+    async def _sync_customer_metrics(self) -> Dict[str, Any]:
+        """Sync customer metrics from POS"""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{settings.POS_API_URL}/metrics/customers",
+                headers=self._get_auth_headers()
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    self._metrics_cache["customers"] = data
+                    return data
+                else:
+                    raise Exception(f"Failed to sync customer metrics: {response.status}")
+
+    def _get_auth_headers(self) -> Dict[str, str]:
+        """Get authentication headers for POS API"""
+        return {
+            "Authorization": f"Bearer {settings.POS_API_KEY}",
+            "X-API-Version": settings.POS_API_VERSION
+        }
+
+    def get_cached_metrics(self, metric_type: str) -> Optional[Dict[str, Any]]:
+        """Get cached metrics by type"""
+        return self._metrics_cache.get(metric_type)
+
+    def get_sync_status(self) -> Dict[str, Any]:
+        """Get current sync status"""
+        return {
+            "last_sync": self._last_sync_time,
+            "failed_operations": self._failed_operations,
+            "cache_status": {
+                k: "cached" for k in self._metrics_cache.keys()
+            },
+            "last_error": self._last_error
+        }
+
+pos_analytics = POSAnalyticsService()

app/services/scheduler.py

@@ -5,9 +5,11 @@ from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from apscheduler.triggers.cron import CronTrigger
 from ..db.database import db
 from ..utils.cache import cache
-from ..utils.logger import logger
+from ..utils.logger import logger, log_health_check, log_maintenance_activity
 from ..services.calendar import calendar
-from ..services.maintenance import maintenance
+from ..services.maintenance import maintenance_service
+from ..services.pos_analytics import pos_analytics
+from ..core.config import settings
 
 class SchedulerService:
     def __init__(self):
@@ -15,80 +17,123 @@ class SchedulerService:
         self._setup_maintenance_jobs()
 
     def _setup_maintenance_jobs(self):
-        """Setup all maintenance related scheduled jobs"""
-        # Daily database maintenance at 2 AM
+        """Set up scheduled maintenance and health check jobs"""
+        # Health checks every 5 minutes
         self.scheduler.add_job(
-            maintenance.perform_database_maintenance,
-            CronTrigger(hour=2),
-            id="daily_db_maintenance",
+            self._run_health_checks,
+            trigger=CronTrigger(minute='*/5'),
+            id='health_checks',
             replace_existing=True
         )
 
-        # Session cleanup every 6 hours
+        # System maintenance daily at 2 AM
         self.scheduler.add_job(
-            maintenance.cleanup_expired_sessions,
-            CronTrigger(hour="*/6"),
-            id="session_cleanup",
+            self._run_maintenance,
+            trigger=CronTrigger(hour=2),
+            id='daily_maintenance',
             replace_existing=True
         )
 
-        # System health check every 15 minutes
+        # POS metrics sync every 15 minutes
         self.scheduler.add_job(
-            maintenance.monitor_system_resources,
-            CronTrigger(minute="*/15"),
-            id="health_check",
+            self._sync_pos_metrics,
+            trigger=CronTrigger(minute='*/15'),
+            id='pos_sync',
             replace_existing=True
         )
 
-        # Daily backup at 1 AM
+        # Resource monitoring every minute
         self.scheduler.add_job(
-            maintenance.perform_scheduled_backup,
-            CronTrigger(hour=1),
-            id="daily_backup",
+            self._monitor_resources,
+            trigger=CronTrigger(minute='*'),
+            id='resource_monitoring',
             replace_existing=True
         )
 
-        # Daily log rotation at 3 AM
-        self.scheduler.add_job(
-            maintenance.rotate_log_files,
-            CronTrigger(hour=3),
-            id="log_rotation",
-            replace_existing=True
-        )
+    async def _run_health_checks(self):
+        """Run comprehensive system health checks"""
+        try:
+            # Check database health
+            db_health = await maintenance_service.check_database()
+            log_health_check("database", db_health["status"], db_health)
 
-        # Storage quota check every 2 hours
-        self.scheduler.add_job(
-            maintenance.manage_storage_quotas,
-            CronTrigger(hour="*/2"),
-            id="storage_quota_check",
-            replace_existing=True
-        )
+            # Check Redis health
+            redis_health = await maintenance_service.check_redis()
+            log_health_check("redis", redis_health["status"], redis_health)
 
-        # Monthly data archiving at 4 AM on the 1st of each month
-        self.scheduler.add_job(
-            maintenance.archive_old_data,
-            CronTrigger(day=1, hour=4),
-            id="monthly_archiving",
-            replace_existing=True
-        )
+            # Check POS integration
+            pos_health = await pos_analytics.health_check()
+            log_health_check("pos_integration", pos_health["status"], pos_health)
+
+            # Check background tasks
+            tasks_health = await maintenance_service.check_background_tasks()
+            log_health_check("background_tasks", tasks_health["status"], tasks_health)
+
+        except Exception as e:
+            logger.error(f"Health check failed: {str(e)}", exc_info=True)
+
+    async def _run_maintenance(self):
+        """Run daily system maintenance tasks"""
+        try:
+            # Perform system maintenance
+            maintenance_result = await maintenance_service.perform_maintenance()
+            log_maintenance_activity("system", maintenance_result["status"], maintenance_result)
+
+            # Clean up expired sessions
+            sessions_cleaned = await maintenance_service.cleanup_expired_sessions()
+            log_maintenance_activity("session_cleanup", "completed", {"cleaned": sessions_cleaned})
+
+            # Archive old data
+            archive_result = await maintenance_service.archive_old_data()
+            if archive_result:
+                log_maintenance_activity("data_archiving", "completed", archive_result)
+
+            # Rotate log files
+            await maintenance_service.rotate_log_files()
+            log_maintenance_activity("log_rotation", "completed")
+
+            # Manage storage quotas
+            quota_result = await maintenance_service.manage_storage_quotas()
+            log_maintenance_activity("storage_quotas", "completed", quota_result)
+
+        except Exception as e:
+            logger.error(f"Maintenance tasks failed: {str(e)}", exc_info=True)
+
+    async def _sync_pos_metrics(self):
+        """Sync POS metrics data"""
+        try:
+            success = await pos_analytics.sync_all_metrics()
+            status = "success" if success else "partial_failure"
+            log_maintenance_activity("pos_sync", status)
+
+        except Exception as e:
+            logger.error(f"POS metrics sync failed: {str(e)}", exc_info=True)
+            log_maintenance_activity("pos_sync", "failed", {"error": str(e)})
+
+    async def _monitor_resources(self):
+        """Monitor system resources"""
+        try:
+            resources = await maintenance_service.monitor_system_resources()
+            if "error" not in resources:
+                log_health_check("resources", "healthy", resources)
+            else:
+                log_health_check("resources", "warning", resources)
+
+        except Exception as e:
+            logger.error(f"Resource monitoring failed: {str(e)}", exc_info=True)
+            log_health_check("resources", "error", {"error": str(e)})
 
     def start(self):
         """Start the scheduler"""
-        try:
+        if not self.scheduler.running:
             self.scheduler.start()
-            logger.info("Scheduler started successfully")
-        except Exception as e:
-            logger.error(f"Failed to start scheduler: {str(e)}")
-            raise
+            logger.info("Scheduler started - Maintenance and health check tasks initialized")
 
     def shutdown(self):
         """Shutdown the scheduler"""
-        try:
+        if self.scheduler.running:
             self.scheduler.shutdown()
-            logger.info("Scheduler shutdown successfully")
-        except Exception as e:
-            logger.error(f"Error during scheduler shutdown: {str(e)}")
-            raise
+            logger.info("Scheduler shutdown - Maintenance and health check tasks stopped")
 
     def get_jobs(self):
         """Get all scheduled jobs"""
@@ -240,4 +285,4 @@ class SchedulerService:
 
         return sorted(events, key=lambda x: x["start_time"])
 
-scheduler = SchedulerService()
+scheduler_service = SchedulerService()

app/services/staff_reports.py

@@ -0,0 +1,329 @@
+from datetime import datetime, timedelta
+from typing import Dict, Any, List, Optional
+from sqlalchemy import func, and_, select
+from ..db.database import db
+from ..db.models import StaffActivity, PerformanceMetric, User, ActivityType
+from ..utils.cache import cache
+import numpy as np
+from collections import defaultdict
+
+class StaffReportService:
+    @staticmethod
+    async def generate_performance_report(
+        branch_id: Optional[int] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None
+    ) -> Dict[str, Any]:
+        """Generate comprehensive performance report with insights"""
+        if not start_date:
+            start_date = datetime.utcnow() - timedelta(days=30)
+        if not end_date:
+            end_date = datetime.utcnow()
+
+        cache_key = f"performance_report:{branch_id}:{start_date.date()}:{end_date.date()}"
+        cached_data = await cache.get_cache(cache_key)
+        if cached_data:
+            return cached_data
+
+        async with db() as session:
+            # Base query conditions
+            conditions = [PerformanceMetric.metric_date.between(start_date, end_date)]
+            if branch_id:
+                conditions.append(PerformanceMetric.branch_id == branch_id)
+
+            # Get daily metrics for trend analysis
+            daily_metrics = await session.execute(
+                select(
+                    PerformanceMetric.user_id,
+                    PerformanceMetric.metric_date,
+                    PerformanceMetric.total_sales,
+                    PerformanceMetric.transaction_count,
+                    PerformanceMetric.efficiency_score
+                ).where(and_(*conditions))
+            )
+            daily_data = daily_metrics.all()
+
+            # Calculate trends and patterns
+            trends = await StaffReportService._analyze_trends(daily_data)
+            
+            # Get top performers
+            top_performers = await session.execute(
+                select(
+                    PerformanceMetric.user_id,
+                    func.avg(PerformanceMetric.efficiency_score).label('avg_efficiency'),
+                    func.sum(PerformanceMetric.total_sales).label('total_sales'),
+                    func.count().label('days_worked')
+                ).where(
+                    and_(*conditions)
+                ).group_by(
+                    PerformanceMetric.user_id
+                ).order_by(
+                    func.avg(PerformanceMetric.efficiency_score).desc()
+                ).limit(5)
+            )
+            top_performers_data = top_performers.all()
+
+            # Get user details for top performers
+            user_ids = [p.user_id for p in top_performers_data]
+            users = await session.execute(
+                select(User).where(User.id.in_(user_ids))
+            )
+            users_dict = {u.id: u for u in users.scalars().all()}
+
+            # Format top performers data
+            top_performers_list = [{
+                "user_id": p.user_id,
+                "username": users_dict[p.user_id].username,
+                "full_name": users_dict[p.user_id].full_name,
+                "average_efficiency": round(p.avg_efficiency, 2),
+                "total_sales": round(p.total_sales, 2),
+                "days_worked": p.days_worked
+            } for p in top_performers_data]
+
+            # Get activity distribution
+            activities = await session.execute(
+                select(
+                    StaffActivity.activity_type,
+                    func.count().label('count')
+                ).where(
+                    and_(
+                        StaffActivity.created_at.between(start_date, end_date),
+                        branch_id is None or StaffActivity.branch_id == branch_id
+                    )
+                ).group_by(
+                    StaffActivity.activity_type
+                )
+            )
+            activity_dist = {
+                str(a.activity_type): a.count 
+                for a in activities.all()
+            }
+
+            # Generate insights
+            insights = await StaffReportService._generate_insights(
+                trends, 
+                activity_dist,
+                top_performers_list
+            )
+
+            report = {
+                "period": {
+                    "start_date": start_date.isoformat(),
+                    "end_date": end_date.isoformat()
+                },
+                "trends": trends,
+                "top_performers": top_performers_list,
+                "activity_distribution": activity_dist,
+                "insights": insights
+            }
+
+            # Cache report for 1 hour
+            await cache.set_cache(cache_key, report, expire=3600)
+            return report
+
+    @staticmethod
+    async def _analyze_trends(daily_data: List[Any]) -> Dict[str, Any]:
+        """Analyze daily metrics for trends"""
+        if not daily_data:
+            return {}
+
+        # Group data by date
+        daily_stats = defaultdict(lambda: {
+            "total_sales": 0,
+            "transaction_count": 0,
+            "efficiency_scores": []
+        })
+
+        for record in daily_data:
+            date = record.metric_date.date()
+            daily_stats[date]["total_sales"] += record.total_sales
+            daily_stats[date]["transaction_count"] += record.transaction_count
+            daily_stats[date]["efficiency_scores"].append(record.efficiency_score)
+
+        # Convert to lists for analysis
+        dates = sorted(daily_stats.keys())
+        sales = [daily_stats[d]["total_sales"] for d in dates]
+        transactions = [daily_stats[d]["transaction_count"] for d in dates]
+        efficiency = [
+            np.mean(daily_stats[d]["efficiency_scores"]) 
+            for d in dates
+        ]
+
+        # Calculate trends
+        trends = {
+            "sales_trend": StaffReportService._calculate_trend(sales),
+            "transaction_trend": StaffReportService._calculate_trend(transactions),
+            "efficiency_trend": StaffReportService._calculate_trend(efficiency),
+            "daily_data": [
+                {
+                    "date": date.isoformat(),
+                    "sales": daily_stats[date]["total_sales"],
+                    "transactions": daily_stats[date]["transaction_count"],
+                    "avg_efficiency": np.mean(daily_stats[date]["efficiency_scores"])
+                }
+                for date in dates
+            ]
+        }
+
+        return trends
+
+    @staticmethod
+    def _calculate_trend(values: List[float]) -> str:
+        """Calculate trend direction and magnitude"""
+        if not values or len(values) < 2:
+            return "stable"
+
+        # Calculate percentage change
+        start_avg = np.mean(values[:3]) if len(values) >= 3 else values[0]
+        end_avg = np.mean(values[-3:]) if len(values) >= 3 else values[-1]
+        
+        if start_avg == 0:
+            return "stable"
+
+        change = ((end_avg - start_avg) / start_avg) * 100
+
+        if change > 10:
+            return "strongly_increasing"
+        elif change > 5:
+            return "increasing"
+        elif change < -10:
+            return "strongly_decreasing"
+        elif change < -5:
+            return "decreasing"
+        else:
+            return "stable"
+
+    @staticmethod
+    async def _generate_insights(
+        trends: Dict[str, Any],
+        activity_dist: Dict[str, int],
+        top_performers: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        """Generate actionable insights from the data"""
+        insights = []
+
+        # Analyze sales trend
+        if trends.get("sales_trend") in ["strongly_increasing", "increasing"]:
+            insights.append({
+                "type": "positive",
+                "category": "sales",
+                "message": "Sales are showing a positive trend. Keep up the good work!"
+            })
+        elif trends.get("sales_trend") in ["strongly_decreasing", "decreasing"]:
+            insights.append({
+                "type": "warning",
+                "category": "sales",
+                "message": "Sales are declining. Consider reviewing sales strategies and providing additional training."
+            })
+
+        # Analyze efficiency trends
+        if trends.get("efficiency_trend") in ["strongly_decreasing", "decreasing"]:
+            insights.append({
+                "type": "warning",
+                "category": "efficiency",
+                "message": "Staff efficiency is declining. Consider investigating potential bottlenecks or training needs."
+            })
+
+        # Analyze activity distribution
+        total_activities = sum(activity_dist.values())
+        if total_activities > 0:
+            void_ratio = activity_dist.get("void", 0) / total_activities
+            if void_ratio > 0.1:  # More than 10% voids
+                insights.append({
+                    "type": "warning",
+                    "category": "operations",
+                    "message": "High number of void transactions detected. Review transaction procedures and provide additional training if needed."
+                })
+
+        # Analyze top performers
+        if top_performers:
+            top_efficiency = top_performers[0]["average_efficiency"]
+            if top_efficiency > 8.5:  # Very high efficiency
+                insights.append({
+                    "type": "suggestion",
+                    "category": "training",
+                    "message": f"Consider having {top_performers[0]['full_name']} share best practices with the team."
+                })
+
+        return insights
+
+    @staticmethod
+    async def generate_staff_comparison(
+        user_id: int,
+        branch_id: int,
+        date: Optional[datetime] = None
+    ) -> Dict[str, Any]:
+        """Generate performance comparison against branch averages"""
+        if not date:
+            date = datetime.utcnow()
+
+        cache_key = f"staff_comparison:{user_id}:{branch_id}:{date.date()}"
+        cached_data = await cache.get_cache(cache_key)
+        if cached_data:
+            return cached_data
+
+        async with db() as session:
+            # Get user's metrics
+            user_metrics = await session.execute(
+                select(PerformanceMetric).where(
+                    and_(
+                        PerformanceMetric.user_id == user_id,
+                        PerformanceMetric.branch_id == branch_id,
+                        func.date(PerformanceMetric.metric_date) == date.date()
+                    )
+                )
+            )
+            user_data = user_metrics.scalar_one_or_none()
+
+            if not user_data:
+                return {
+                    "message": "No metrics available for the specified date",
+                    "comparison": None
+                }
+
+            # Get branch averages
+            branch_avg = await session.execute(
+                select(
+                    func.avg(PerformanceMetric.total_sales).label('avg_sales'),
+                    func.avg(PerformanceMetric.transaction_count).label('avg_transactions'),
+                    func.avg(PerformanceMetric.efficiency_score).label('avg_efficiency')
+                ).where(
+                    and_(
+                        PerformanceMetric.branch_id == branch_id,
+                        func.date(PerformanceMetric.metric_date) == date.date()
+                    )
+                )
+            )
+            branch_data = branch_avg.one()
+
+            comparison = {
+                "metrics": {
+                    "total_sales": user_data.total_sales,
+                    "transaction_count": user_data.transaction_count,
+                    "efficiency_score": user_data.efficiency_score
+                },
+                "branch_averages": {
+                    "avg_sales": float(branch_data.avg_sales),
+                    "avg_transactions": float(branch_data.avg_transactions),
+                    "avg_efficiency": float(branch_data.avg_efficiency)
+                },
+                "comparisons": {
+                    "sales_percentage": (
+                        ((user_data.total_sales / branch_data.avg_sales) - 1) * 100
+                        if branch_data.avg_sales else 0
+                    ),
+                    "transactions_percentage": (
+                        ((user_data.transaction_count / branch_data.avg_transactions) - 1) * 100
+                        if branch_data.avg_transactions else 0
+                    ),
+                    "efficiency_percentage": (
+                        ((user_data.efficiency_score / branch_data.avg_efficiency) - 1) * 100
+                        if branch_data.avg_efficiency else 0
+                    )
+                }
+            }
+
+            await cache.set_cache(cache_key, comparison, expire=3600)
+            return comparison
+
+staff_reports = StaffReportService()

app/utils/cache.py

@@ -1,177 +1,177 @@
-import redis
-import json
-import inspect
-import functools
-from ..core.config import settings
-from typing import Any, Optional, Callable, TypeVar
-from ..utils.logger import logger
-
-T = TypeVar('T')
-
-def cached(ttl_seconds: int):
-    """
-    Cache decorator that stores function results in Redis.
-    Works with both sync and async functions.
-    
-    Args:
-        ttl_seconds: Time to live in seconds for cached results
-        
-    Example:
-        @cached(300)  # Cache for 5 minutes
-        async def get_user(user_id: int):
-            return await db.fetch_user(user_id)
-    """
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
-        is_async = inspect.iscoroutinefunction(func)
-        
-        def get_cache_key(*args, **kwargs) -> str:
-            """Generate cache key from function name and arguments"""
-            # Sort kwargs to ensure consistent key generation
-            sorted_kwargs = sorted(kwargs.items())
-            args_str = ":".join(str(arg) for arg in args)
-            kwargs_str = ":".join(f"{k}={v}" for k, v in sorted_kwargs)
-            return f"cache:{func.__module__}:{func.__name__}:{args_str}:{kwargs_str}"
-
-        if is_async:
-            @functools.wraps(func)
-            async def async_wrapper(*args, **kwargs) -> T:
-                cache_key = get_cache_key(*args, **kwargs)
-                
-                # Try to get from cache
-                cached_value = await cache.get_cache(cache_key)
-                if cached_value is not None:
-                    return cached_value
-                
-                # Call function and cache result
-                result = await func(*args, **kwargs)
-                await cache.set_cache(cache_key, result, ttl_seconds)
-                return result
-            return async_wrapper
-        else:
-            @functools.wraps(func)
-            def sync_wrapper(*args, **kwargs) -> T:
-                cache_key = get_cache_key(*args, **kwargs)
-                
-                # Try to get from cache
-                try:
-                    cached_value = cache.redis_client.get(cache_key)
-                    if cached_value:
-                        return json.loads(cached_value)
-                except:
-                    if cache.is_connected:
-                        logger.error("Redis error in sync cache access")
-                    return cache.fallback_cache.get(cache_key)
-                
-                # Call function and cache result
-                result = func(*args, **kwargs)
-                try:
-                    if cache.is_connected:
-                        cache.redis_client.setex(
-                            cache_key,
-                            ttl_seconds,
-                            json.dumps(result)
-                        )
-                    else:
-                        cache.fallback_cache[cache_key] = result
-                except Exception as e:
-                    logger.error(f"Cache set error in sync wrapper: {str(e)}")
-                return result
-            return sync_wrapper
-            
-    return decorator
-
-class RedisCache:
-    _instance = None
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(RedisCache, cls).__new__(cls)
-            cls._instance.initialize()
-        return cls._instance
-
-    def initialize(self):
-        """Initialize Redis connection with fallback to dummy cache"""
-        try:
-            self.redis_client = redis.Redis(
-                host=settings.REDIS_HOST,
-                port=settings.REDIS_PORT,
-                decode_responses=True,
-                socket_timeout=1  # 1 second timeout
-            )
-            self.redis_client.ping()  # Test connection
-            self.is_connected = True
-            logger.info("Redis cache initialized successfully")
-        except Exception as e:
-            self.is_connected = False
-            self.fallback_cache = {}
-            logger.warning(f"Redis connection failed, using in-memory fallback: {str(e)}")
-
-    async def set_cache(self, key: str, value: Any, expire: int = 3600):
-        """Set a cache entry with optional expiration time (default 1 hour)"""
-        try:
-            if not self.is_connected:
-                self.fallback_cache[key] = value
-                return True
-
-            return bool(self.redis_client.setex(
-                key,
-                expire,
-                json.dumps(value)
-            ))
-        except Exception as e:
-            logger.error(f"Cache set error: {str(e)}")
-            return False
-
-    async def get_cache(self, key: str) -> Optional[Any]:
-        """Get a cached value by key"""
-        try:
-            if not self.is_connected:
-                return self.fallback_cache.get(key)
-
-            value = self.redis_client.get(key)
-            return json.loads(value) if value else None
-        except Exception as e:
-            logger.error(f"Cache get error: {str(e)}")
-            return None
-
-    async def delete_cache(self, key: str) -> bool:
-        """Delete a cache entry by key"""
-        try:
-            if not self.is_connected:
-                self.fallback_cache.pop(key, None)
-                return True
-
-            return bool(self.redis_client.delete(key))
-        except Exception as e:
-            logger.error(f"Cache delete error: {str(e)}")
-            return False
-
-    async def clear_cache_pattern(self, pattern: str) -> bool:
-        """Clear all cache entries matching a pattern"""
-        try:
-            if not self.is_connected:
-                # Simple pattern matching for fallback cache
-                keys_to_delete = [k for k in self.fallback_cache if pattern in k]
-                for k in keys_to_delete:
-                    del self.fallback_cache[k]
-                return True
-
-            keys = self.redis_client.keys(pattern)
-            if keys:
-                return bool(self.redis_client.delete(*keys))
-            return True
-        except Exception as e:
-            logger.error(f"Cache clear error: {str(e)}")
-            return False
-
-    def check_connection(self) -> bool:
-        """Check if Redis connection is alive"""
-        try:
-            self.redis_client.ping()
-            self.is_connected = True
-            return True
-        except:
-            self.is_connected = False
-            return False
-
+import redis
+import json
+import inspect
+import functools
+from ..core.config import settings
+from typing import Any, Optional, Callable, TypeVar
+from ..utils.logger import logger
+
+T = TypeVar('T')
+
+def cached(ttl_seconds: int):
+    """
+    Cache decorator that stores function results in Redis.
+    Works with both sync and async functions.
+    
+    Args:
+        ttl_seconds: Time to live in seconds for cached results
+        
+    Example:
+        @cached(300)  # Cache for 5 minutes
+        async def get_user(user_id: int):
+            return await db.fetch_user(user_id)
+    """
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        is_async = inspect.iscoroutinefunction(func)
+        
+        def get_cache_key(*args, **kwargs) -> str:
+            """Generate cache key from function name and arguments"""
+            # Sort kwargs to ensure consistent key generation
+            sorted_kwargs = sorted(kwargs.items())
+            args_str = ":".join(str(arg) for arg in args)
+            kwargs_str = ":".join(f"{k}={v}" for k, v in sorted_kwargs)
+            return f"cache:{func.__module__}:{func.__name__}:{args_str}:{kwargs_str}"
+
+        if is_async:
+            @functools.wraps(func)
+            async def async_wrapper(*args, **kwargs) -> T:
+                cache_key = get_cache_key(*args, **kwargs)
+                
+                # Try to get from cache
+                cached_value = await cache.get_cache(cache_key)
+                if cached_value is not None:
+                    return cached_value
+                
+                # Call function and cache result
+                result = await func(*args, **kwargs)
+                await cache.set_cache(cache_key, result, ttl_seconds)
+                return result
+            return async_wrapper
+        else:
+            @functools.wraps(func)
+            def sync_wrapper(*args, **kwargs) -> T:
+                cache_key = get_cache_key(*args, **kwargs)
+                
+                # Try to get from cache
+                try:
+                    cached_value = cache.redis_client.get(cache_key)
+                    if cached_value:
+                        return json.loads(cached_value)
+                except:
+                    if cache.is_connected:
+                        logger.error("Redis error in sync cache access")
+                    return cache.fallback_cache.get(cache_key)
+                
+                # Call function and cache result
+                result = func(*args, **kwargs)
+                try:
+                    if cache.is_connected:
+                        cache.redis_client.setex(
+                            cache_key,
+                            ttl_seconds,
+                            json.dumps(result)
+                        )
+                    else:
+                        cache.fallback_cache[cache_key] = result
+                except Exception as e:
+                    logger.error(f"Cache set error in sync wrapper: {str(e)}")
+                return result
+            return sync_wrapper
+            
+    return decorator
+
+class RedisCache:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(RedisCache, cls).__new__(cls)
+            cls._instance.initialize()
+        return cls._instance
+
+    def initialize(self):
+        """Initialize Redis connection with fallback to dummy cache"""
+        try:
+            self.redis_client = redis.Redis(
+                host=settings.REDIS_HOST,
+                port=settings.REDIS_PORT,
+                decode_responses=True,
+                socket_timeout=1  # 1 second timeout
+            )
+            self.redis_client.ping()  # Test connection
+            self.is_connected = True
+            logger.info("Redis cache initialized successfully")
+        except Exception as e:
+            self.is_connected = False
+            self.fallback_cache = {}
+            logger.warning(f"Redis connection failed, using in-memory fallback: {str(e)}")
+
+    async def set_cache(self, key: str, value: Any, expire: int = 3600):
+        """Set a cache entry with optional expiration time (default 1 hour)"""
+        try:
+            if not self.is_connected:
+                self.fallback_cache[key] = value
+                return True
+
+            return bool(self.redis_client.setex(
+                key,
+                expire,
+                json.dumps(value)
+            ))
+        except Exception as e:
+            logger.error(f"Cache set error: {str(e)}")
+            return False
+
+    async def get_cache(self, key: str) -> Optional[Any]:
+        """Get a cached value by key"""
+        try:
+            if not self.is_connected:
+                return self.fallback_cache.get(key)
+
+            value = self.redis_client.get(key)
+            return json.loads(value) if value else None
+        except Exception as e:
+            logger.error(f"Cache get error: {str(e)}")
+            return None
+
+    async def delete_cache(self, key: str) -> bool:
+        """Delete a cache entry by key"""
+        try:
+            if not self.is_connected:
+                self.fallback_cache.pop(key, None)
+                return True
+
+            return bool(self.redis_client.delete(key))
+        except Exception as e:
+            logger.error(f"Cache delete error: {str(e)}")
+            return False
+
+    async def clear_cache_pattern(self, pattern: str) -> bool:
+        """Clear all cache entries matching a pattern"""
+        try:
+            if not self.is_connected:
+                # Simple pattern matching for fallback cache
+                keys_to_delete = [k for k in self.fallback_cache if pattern in k]
+                for k in keys_to_delete:
+                    del self.fallback_cache[k]
+                return True
+
+            keys = self.redis_client.keys(pattern)
+            if keys:
+                return bool(self.redis_client.delete(*keys))
+            return True
+        except Exception as e:
+            logger.error(f"Cache clear error: {str(e)}")
+            return False
+
+    def check_connection(self) -> bool:
+        """Check if Redis connection is alive"""
+        try:
+            self.redis_client.ping()
+            self.is_connected = True
+            return True
+        except:
+            self.is_connected = False
+            return False
+
 cache = RedisCache()

app/utils/logger.py

@@ -1,59 +1,245 @@
 import logging
 import sys
+import json
+import time
+import uuid
+import traceback
 from datetime import datetime
 from pathlib import Path
-from logging.handlers import RotatingFileHandler
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+from typing import Optional, Dict, Any, Union
+from contextvars import ContextVar
+from functools import wraps
 from ..core.config import settings
 
 # Create logs directory if it doesn't exist
 logs_dir = Path("logs")
 logs_dir.mkdir(exist_ok=True)
 
-# Configure logging format
-log_format = logging.Formatter(
-    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
+# Correlation ID context
+correlation_id: ContextVar[str] = ContextVar('correlation_id', default='')
 
-def setup_logger(name: str) -> logging.Logger:
+class StructuredFormatter(logging.Formatter):
+    """Custom formatter that outputs logs in JSON format"""
+    
+    def __init__(self):
+        super().__init__()
+        self.default_fields = {
+            'hostname': settings.PROJECT_NAME,
+            'version': settings.VERSION
+        }
+
+    def format(self, record: logging.LogRecord) -> str:
+        message = {
+            'timestamp': datetime.utcfromtimestamp(record.created).isoformat(),
+            'level': record.levelname,
+            'logger': record.name,
+            'message': record.getMessage(),
+            'correlation_id': correlation_id.get(),
+            **self.default_fields
+        }
+
+        if hasattr(record, 'duration'):
+            message['duration'] = f"{record.duration:.3f}s"
+
+        if hasattr(record, 'request_id'):
+            message['request_id'] = record.request_id
+
+        if record.exc_info:
+            message['exception'] = {
+                'type': record.exc_info[0].__name__,
+                'message': str(record.exc_info[1]),
+                'stacktrace': traceback.format_exception(*record.exc_info)
+            }
+
+        # Add any extra fields
+        if hasattr(record, 'extra_fields'):
+            message.update(record.extra_fields)
+
+        return json.dumps(message)
+
+class CustomLogger(logging.Logger):
+    """Enhanced logger with additional functionality"""
+    
+    def __init__(self, name: str):
+        super().__init__(name)
+        self.metrics: Dict[str, Dict[str, Union[int, float]]] = {
+            'requests': {'count': 0, 'total_duration': 0},
+            'errors': {'count': 0},
+            'database': {'operations': 0, 'failures': 0}
+        }
+
+    def log_with_context(self, level: int, msg: str, extra_fields: Optional[Dict[str, Any]] = None, **kwargs):
+        """Log message with additional context"""
+        if extra_fields:
+            kwargs['extra'] = {'extra_fields': extra_fields}
+        self.log(level, msg, **kwargs)
+
+    def start_operation(self, operation_name: str) -> float:
+        """Start timing an operation"""
+        return time.time()
+
+    def end_operation(self, start_time: float, operation_name: str, success: bool = True):
+        """End timing an operation and log its duration"""
+        duration = time.time() - start_time
+        self.info(
+            f"Operation completed: {operation_name}",
+            extra={'extra_fields': {
+                'operation': operation_name,
+                'duration': duration,
+                'success': success
+            }}
+        )
+        return duration
+
+class HealthCheckFilter(logging.Filter):
+    """Filter to add health check information to log records"""
+    def filter(self, record):
+        record.health_check = getattr(record, 'health_check', False)
+        return True
+
+def setup_logger(name: str) -> CustomLogger:
+    """Set up enhanced logger with multiple handlers and formatters"""
+    # Use custom logger class
+    logging.setLoggerClass(CustomLogger)
     logger = logging.getLogger(name)
     logger.setLevel(logging.INFO)
 
-    # Console handler
+    # Structured JSON formatter for file logs
+    json_formatter = StructuredFormatter()
+
+    # Console handler with standard formatting
     console_handler = logging.StreamHandler(sys.stdout)
-    console_handler.setFormatter(log_format)
+    console_handler.setFormatter(logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    ))
     logger.addHandler(console_handler)
 
-    # File handler with rotation
-    file_handler = RotatingFileHandler(
+    # File handler with JSON formatting and daily rotation
+    daily_handler = TimedRotatingFileHandler(
         logs_dir / f"{name}.log",
+        when="midnight",
+        interval=1,
+        backupCount=30,  # Keep a month of logs
+        encoding="utf-8"
+    )
+    daily_handler.setFormatter(json_formatter)
+    logger.addHandler(daily_handler)
+
+    # Error file handler for error-level logs
+    error_handler = RotatingFileHandler(
+        logs_dir / f"{name}_error.log",
         maxBytes=10485760,  # 10MB
-        backupCount=5
+        backupCount=10
+    )
+    error_handler.setLevel(logging.ERROR)
+    error_handler.setFormatter(json_formatter)
+    logger.addHandler(error_handler)
+
+    # Add health check filter
+    logger.addFilter(HealthCheckFilter())
+
+    # Separate file handler for health check logs
+    health_handler = TimedRotatingFileHandler(
+        logs_dir / f"{name}_health_checks.log",
+        when='midnight',
+        interval=1,
+        backupCount=30
+    )
+    health_handler.setLevel(logging.INFO)
+    health_format = logging.Formatter(
+        '%(asctime)s - %(levelname)s - %(message)s - Health: %(health_check)s'
     )
-    file_handler.setFormatter(log_format)
-    logger.addHandler(file_handler)
+    health_handler.setFormatter(health_format)
+    health_handler.addFilter(lambda record: getattr(record, 'health_check', False))
+    logger.addHandler(health_handler)
 
     return logger
 
 # Create main application logger
 logger = setup_logger("admin_dashboard")
 
+def with_correlation_id():
+    """Decorator to add correlation ID to context"""
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            correlation = str(uuid.uuid4())
+            token = correlation_id.set(correlation)
+            try:
+                return await func(*args, **kwargs)
+            finally:
+                correlation_id.reset(token)
+        return wrapper
+    return decorator
+
 def log_api_request(method: str, path: str, status_code: int, duration: float):
-    """Log API request details"""
+    """Log API request details with enhanced context"""
     logger.info(
-        f"API Request - Method: {method}, Path: {path}, "
-        f"Status: {status_code}, Duration: {duration:.3f}s"
+        "API Request",
+        extra={'extra_fields': {
+            'method': method,
+            'path': path,
+            'status_code': status_code,
+            'duration': duration,
+            'timestamp': datetime.utcnow().isoformat()
+        }}
     )
+    # Update metrics
+    logger.metrics['requests']['count'] += 1
+    logger.metrics['requests']['total_duration'] += duration
 
-def log_error(error: Exception, context: dict = None):
-    """Log error with context"""
+def log_error(error: Exception, context: Optional[Dict] = None):
+    """Log error with enhanced context and tracking"""
     logger.error(
-        f"Error: {str(error)}, Type: {type(error).__name__}, "
-        f"Context: {context or {}}"
+        f"Error occurred: {str(error)}",
+        exc_info=True,
+        extra={'extra_fields': {
+            'error_type': type(error).__name__,
+            'context': context or {},
+            'timestamp': datetime.utcnow().isoformat()
+        }}
     )
+    logger.metrics['errors']['count'] += 1
 
-def log_database_operation(operation: str, collection: str, success: bool):
-    """Log database operations"""
+def log_database_operation(operation: str, collection: str, success: bool, duration: Optional[float] = None):
+    """Log database operations with performance metrics"""
     logger.info(
-        f"Database Operation - Type: {operation}, Collection: {collection}, "
-        f"Success: {success}"
-    )
+        "Database Operation",
+        extra={'extra_fields': {
+            'operation_type': operation,
+            'collection': collection,
+            'success': success,
+            'duration': duration,
+            'timestamp': datetime.utcnow().isoformat()
+        }}
+    )
+    logger.metrics['database']['operations'] += 1
+    if not success:
+        logger.metrics['database']['failures'] += 1
+
+def log_health_check(component: str, status: str, details: dict = None):
+    """Log health check results"""
+    msg = f"Health Check - {component}: {status}"
+    if details:
+        msg += f" - Details: {details}"
+    logger.info(msg, extra={'health_check': True})
+
+def log_maintenance_activity(activity: str, result: str, details: dict = None):
+    """Log maintenance activities"""
+    msg = f"Maintenance - {activity}: {result}"
+    if details:
+        msg += f" - Details: {details}"
+    logger.info(msg)
+
+def get_metrics() -> Dict[str, Dict[str, Union[int, float]]]:
+    """Get current logging metrics"""
+    return logger.metrics
+
+def reset_metrics():
+    """Reset all logging metrics"""
+    logger.metrics = {
+        'requests': {'count': 0, 'total_duration': 0},
+        'errors': {'count': 0},
+        'database': {'operations': 0, 'failures': 0}
+    }

app/utils/retry.py

@@ -0,0 +1,164 @@
+import asyncio
+import functools
+from typing import Type, Tuple, Optional, TypeVar, Callable, Any
+from ..utils.logger import logger
+
+T = TypeVar('T')
+
+def with_retry(
+    max_retries: int = 3,
+    delay: float = 1.0,
+    backoff_factor: float = 2.0,
+    exceptions: Tuple[Type[Exception], ...] = (Exception,)
+) -> Callable:
+    """
+    Decorator that implements retry logic with exponential backoff
+    
+    Args:
+        max_retries (int): Maximum number of retry attempts
+        delay (float): Initial delay between retries in seconds
+        backoff_factor (float): Multiplier for delay after each retry
+        exceptions (tuple): Tuple of exceptions to catch and retry on
+    """
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @functools.wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            last_exception = None
+            current_delay = delay
+
+            # Initial attempt plus retries
+            for attempt in range(max_retries + 1):
+                try:
+                    return await func(*args, **kwargs)
+                except exceptions as e:
+                    last_exception = e
+                    
+                    # Don't sleep on the last attempt
+                    if attempt < max_retries:
+                        logger.warning(
+                            f"Attempt {attempt + 1} failed for {func.__name__}: {str(e)}. "
+                            f"Retrying in {current_delay} seconds..."
+                        )
+                        await asyncio.sleep(current_delay)
+                        current_delay *= backoff_factor
+                    else:
+                        logger.error(
+                            f"All {max_retries + 1} attempts failed for {func.__name__}: {str(e)}"
+                        )
+
+            raise last_exception
+
+        return wrapper
+    return decorator
+
+def retry_with_backoff(
+    max_retries: int = 3,
+    initial_delay: float = 1.0,
+    max_delay: float = 30.0,
+    backoff_factor: float = 2.0,
+    exceptions: Optional[Tuple[Type[Exception], ...]] = None
+) -> Callable:
+    """
+    More advanced retry decorator with capped exponential backoff and jitter
+    
+    Args:
+        max_retries (int): Maximum number of retry attempts
+        initial_delay (float): Initial delay between retries in seconds
+        max_delay (float): Maximum delay between retries in seconds
+        backoff_factor (float): Multiplier for delay after each retry
+        exceptions (tuple): Tuple of exceptions to catch and retry on
+    """
+    if exceptions is None:
+        exceptions = (Exception,)
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @functools.wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            retry_count = 0
+            current_delay = initial_delay
+            operation_name = func.__name__
+
+            while True:
+                try:
+                    return await func(*args, **kwargs)
+
+                except exceptions as e:
+                    retry_count += 1
+                    if retry_count > max_retries:
+                        logger.error(
+                            f"Operation {operation_name} failed after {max_retries} retries: {str(e)}"
+                        )
+                        raise
+
+                    # Add jitter to prevent thundering herd
+                    jitter = (asyncio.get_event_loop().time() * 1000) % 1.0
+                    sleep_time = min(current_delay + jitter, max_delay)
+
+                    logger.warning(
+                        f"Operation {operation_name} failed (attempt {retry_count}/{max_retries}): "
+                        f"{str(e)}. Retrying in {sleep_time:.2f} seconds..."
+                    )
+
+                    await asyncio.sleep(sleep_time)
+                    current_delay = min(current_delay * backoff_factor, max_delay)
+
+        return wrapper
+    return decorator
+
+def circuit_breaker(
+    failure_threshold: int = 5,
+    reset_timeout: float = 60.0
+) -> Callable:
+    """
+    Circuit breaker decorator to prevent repeated calls to failing services
+    
+    Args:
+        failure_threshold (int): Number of failures before opening circuit
+        reset_timeout (float): Time in seconds before attempting to close circuit
+    """
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        # State for the circuit breaker
+        state = {
+            'failures': 0,
+            'last_failure_time': 0,
+            'is_open': False
+        }
+
+        @functools.wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            current_time = asyncio.get_event_loop().time()
+
+            # Check if circuit is open
+            if state['is_open']:
+                if current_time - state['last_failure_time'] > reset_timeout:
+                    # Try to close the circuit
+                    state['is_open'] = False
+                    state['failures'] = 0
+                else:
+                    raise Exception(
+                        f"Circuit breaker is open for {func.__name__}. "
+                        f"Try again in {reset_timeout - (current_time - state['last_failure_time']):.1f} seconds"
+                    )
+
+            try:
+                result = await func(*args, **kwargs)
+                # Success - reset failure count
+                state['failures'] = 0
+                return result
+
+            except Exception as e:
+                # Record failure
+                state['failures'] += 1
+                state['last_failure_time'] = current_time
+
+                # Check if we need to open the circuit
+                if state['failures'] >= failure_threshold:
+                    state['is_open'] = True
+                    logger.error(
+                        f"Circuit breaker opened for {func.__name__} after {failure_threshold} failures"
+                    )
+
+                raise
+
+        return wrapper
+    return decorator

app/utils/tasks.py

@@ -6,6 +6,7 @@ from ..services.websocket import create_and_broadcast_notification
 import asyncio
 from sqlalchemy import select, delete
 from ..db.models import Event, User, Notification
+from ..services.pos_analytics import pos_analytics
 
 async def check_event_reminders():
     """Check and send event reminders"""
@@ -118,6 +119,21 @@ async def perform_weekly_maintenance():
     except Exception as e:
         logger.error(f"Error in weekly maintenance: {str(e)}")
 
+async def sync_pos_metrics_task():
+    """Background task to sync POS metrics every 5 minutes"""
+    while True:
+        try:
+            success = await pos_analytics.sync_all_metrics()
+            if success:
+                logger.info("Successfully synced POS metrics")
+            else:
+                logger.error("Failed to sync POS metrics")
+        except Exception as e:
+            logger.error(f"Error in POS metrics sync task: {str(e)}")
+        
+        # Wait for 5 minutes before next sync
+        await asyncio.sleep(300)
+
 async def run_periodic_tasks():
     """Run periodic maintenance tasks"""
     daily_maintenance_run = False