Refactor authentication and session management

- Removed session-based user retrieval from dependencies.py and main.py.
- Eliminated SessionMiddleware and related session handling code.
- Updated dashboard and team views to directly query user data from the database.
- Simplified redeem and team management views to remove authentication checks.
- Adjusted templates to reflect changes in user context handling.
- Added camera selection feature in scan_qr.html for improved QR code scanning.
- Cleaned up Docker configuration and requirements for better deployment.

app/main.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python3
-from fastapi import FastAPI, Request, status, Depends
+from fastapi import FastAPI, Request, status
 from fastapi.responses import HTMLResponse, RedirectResponse
-from starlette.middleware.sessions import SessionMiddleware
 from datetime import datetime
 import os
 
@@ -10,8 +9,6 @@ from . import models
 from .templates_config import templates
 from .views import qr, redeem, teams, admin, leaderboard, dashboard
 from .db_init import seed_db
-from .auth import router as auth_router
-from .dependencies import get_user_from_session
 
 # Create tables on startup
 init_db()
@@ -20,94 +17,23 @@ init_db()
 # In a production app, you would handle this differently
 seed_db()
 
-# Initialize FastAPI app
 app = FastAPI()
 
-# Configure session middleware settings
-secret_key = os.environ.get("SECRET_KEY", "a-default-secret-key-for-sessions-please-change-this")
-if len(secret_key) < 32:
-    print(f"WARNING: Secret key is too short ({len(secret_key)} chars). Recommended: 32+ chars")
-
-# IMPORTANT: Add SessionMiddleware before anything else
-# This must be the FIRST middleware in the stack
-app.add_middleware(
-    SessionMiddleware,
-    secret_key=secret_key,
-    max_age=int(os.environ.get("SESSION_MAX_AGE", "86400")),  # 24 hours by default
-    same_site="lax",
-    https_only=os.environ.get("COOKIE_SECURE", "False").lower() == "true",
-    session_cookie="league_ledger_session",
-)
-
-# Debug middleware - ADDED AFTER SessionMiddleware
+# User context middleware to make template globals available
 @app.middleware("http")
-async def debug_session_middleware(request, call_next):
-    """Debug middleware to track session state"""
+async def add_template_globals(request: Request, call_next):
+    """Add template globals"""
     try:
-        session_cookie = request.cookies.get("league_ledger_session")
-        
-        print(f"Request path: {request.url.path}")
-        # First check if the session attribute exists properly
-        has_session = hasattr(request, "session")
-        is_dict = has_session and isinstance(request.session, dict)
-        print(f"Has session attribute: {has_session}")
-        print(f"Session is dict: {is_dict}")
-        print(f"Has session cookie: {session_cookie is not None}")
-        
-        # Safely check session data
-        if has_session and is_dict:
-            print(f"Session data before: {dict(request.session)}")
-    except Exception as e:
-        print(f"Error in debug middleware (pre): {str(e)}")
-    
-    response = await call_next(request)
-    
-    try:
-        if hasattr(request, "session"):
-            print(f"Session data after: {dict(request.session)}")
-    except Exception as e:
-        print(f"Error in debug middleware (post): {str(e)}")
-    
-    return response
-
-# User context middleware
-@app.middleware("http")
-async def add_user_to_request(request: Request, call_next):
-    """Add user to request state and update template globals"""
-    try:
-        # Get database connection from context
-        from .db import SessionLocal
-        db = SessionLocal()
-        
-        # Get user from session with safer approach
-        user = None
-        try:
-            user = get_user_from_session(request, db)
-        except Exception as e:
-            print(f"Error getting user for request context: {str(e)}")
-        
-        # Store user in request.state for route handlers
-        request.state.user = user
-        
         # Update template globals for all templates
-        templates.env.globals["current_user"] = user
-        
-        # Debug output to check user and admin status
-        if user:
-            print(f"User in context: {user.username}, Admin: {getattr(user, 'is_admin', False)}")
+        templates.env.globals["current_user"] = None
     except Exception as e:
-        print(f"Error setting user context: {str(e)}")
-    finally:
-        # Always close the DB connection
-        if 'db' in locals():
-            db.close()
+        print(f"Error setting template globals: {str(e)}")
     
     # Process the request
     response = await call_next(request)
     return response
 
-# Routers - include after middleware setup is complete
-app.include_router(auth_router, prefix="/auth", tags=["Auth"])
+# Routers - auth router removed
 app.include_router(qr.router, prefix="/qr", tags=["QR"])
 app.include_router(redeem.router, prefix="/redeem", tags=["Redeem"])
 app.include_router(teams.router, prefix="/teams", tags=["Teams"])