diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..b513a6a
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,28 @@
+# Use Python 3.11 (or whichever version you prefer)
+FROM python:3.11-slim
+
+# Create working directory
+WORKDIR /app
+
+# Install system dependencies needed for mysqlclient
+RUN apt-get update && apt-get install -y \
+ pkg-config \
+ default-libmysqlclient-dev \
+ build-essential \
+ && apt-get clean \
+ && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first (for caching)
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the code
+COPY . .
+
+# Expose port
+EXPOSE 8000
+
+# Run the FastAPI app with Uvicorn
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
diff --git a/app/auth.py b/app/auth.py
new file mode 100644
index 0000000..ae11efc
--- /dev/null
+++ b/app/auth.py
@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+"""
+Skeleton for authentication logic.
+Placeholder for OAuth or password-based login.
+"""
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from .db import SessionLocal
+from . import models
+from passlib.context import CryptContext
+
+router = APIRouter()
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def get_db():
+ db = SessionLocal()
+ try:
+ yield db
+ finally:
+ db.close()
+
+# Add routes for login, logout, register, etc.
diff --git a/app/db.py b/app/db.py
new file mode 100644
index 0000000..dec61c4
--- /dev/null
+++ b/app/db.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+import os
+from sqlalchemy import create_engine, inspect, text
+from sqlalchemy.orm import sessionmaker, declarative_base
+
+DB_HOST = os.getenv("DB_HOST", "localhost")
+DB_PORT = os.getenv("DB_PORT", "3306")
+DB_NAME = os.getenv("DB_NAME", "pubquiz_db")
+DB_USER = os.getenv("DB_USER", "pubquiz_user")
+DB_PASS = os.getenv("DB_PASS", "pubquiz_pass")
+
+SQLALCHEMY_DATABASE_URL = (
+ f"mysql://{DB_USER}:{DB_PASS}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+)
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL, pool_pre_ping=True)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def init_db():
+ """Initialize the database with all tables."""
+ # Import all models to ensure they're loaded
+ from . import models
+
+ # Create all tables if they don't exist
+ Base.metadata.create_all(bind=engine)
+
+ # Check for missing columns and add them
+ print("Checking for schema updates...")
+ migrate_schema()
+
+def migrate_schema():
+ """Apply schema migrations for existing tables."""
+ try:
+ connection = engine.connect()
+ inspector = inspect(engine)
+
+ # Check User table
+ if 'users' in inspector.get_table_names():
+ columns = [col['name'] for col in inspector.get_columns('users')]
+
+ # Add all missing columns for User table
+ user_columns = {
+ 'created_at': "ALTER TABLE users ADD COLUMN created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
+ 'is_active': "ALTER TABLE users ADD COLUMN is_active BOOLEAN DEFAULT TRUE",
+ 'is_verified': "ALTER TABLE users ADD COLUMN is_verified BOOLEAN DEFAULT FALSE",
+ 'verification_token': "ALTER TABLE users ADD COLUMN verification_token VARCHAR(255)",
+ 'reset_token': "ALTER TABLE users ADD COLUMN reset_token VARCHAR(255)",
+ 'reset_token_expires_at': "ALTER TABLE users ADD COLUMN reset_token_expires_at TIMESTAMP NULL",
+ 'last_login': "ALTER TABLE users ADD COLUMN last_login TIMESTAMP NULL",
+ 'is_admin': "ALTER TABLE users ADD COLUMN is_admin BOOLEAN DEFAULT FALSE" # Add is_admin column
+ }
+
+ for col_name, sql in user_columns.items():
+ if col_name not in columns:
+ print(f"Adding {col_name} column to users table")
+ try:
+ connection.execute(text(sql))
+ connection.commit()
+ except Exception as e:
+ print(f"Error adding column {col_name}: {e}")
+
+ # Check Team table
+ if 'teams' in inspector.get_table_names():
+ columns = [col['name'] for col in inspector.get_columns('teams')]
+ if 'is_public' not in columns:
+ print("Adding is_public column to teams table")
+ connection.execute(text(
+ "ALTER TABLE teams ADD COLUMN is_public BOOLEAN DEFAULT FALSE"
+ ))
+ if 'created_at' not in columns:
+ print("Adding created_at column to teams table")
+ connection.execute(text(
+ "ALTER TABLE teams ADD COLUMN created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
+ ))
+ if 'description' not in columns:
+ print("Adding description column to teams table")
+ connection.execute(text(
+ "ALTER TABLE teams ADD COLUMN description TEXT"
+ ))
+
+ # Check TeamMembership table
+ if 'team_membership' in inspector.get_table_names():
+ columns = [col['name'] for col in inspector.get_columns('team_membership')]
+ if 'joined_at' not in columns:
+ print("Adding joined_at column to team_membership table")
+ connection.execute(text(
+ "ALTER TABLE team_membership ADD COLUMN joined_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
+ ))
+
+ # Check QRTicket table
+ if 'qr_tickets' in inspector.get_table_names():
+ columns = [col['name'] for col in inspector.get_columns('qr_tickets')]
+ if 'created_at' not in columns:
+ print("Adding created_at column to qr_tickets table")
+ connection.execute(text(
+ "ALTER TABLE qr_tickets ADD COLUMN created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
+ ))
+ if 'redeemed_at' not in columns:
+ print("Adding redeemed_at column to qr_tickets table")
+ connection.execute(text(
+ "ALTER TABLE qr_tickets ADD COLUMN redeemed_at TIMESTAMP NULL"
+ ))
+ if 'event_name' not in columns:
+ print("Adding event_name column to qr_tickets table")
+ connection.execute(text(
+ "ALTER TABLE qr_tickets ADD COLUMN event_name VARCHAR(255)"
+ ))
+
+ # Create OAuthAccount table if it doesn't exist
+ if 'oauth_accounts' not in inspector.get_table_names():
+ print("Creating oauth_accounts table")
+ connection.execute(text("""
+ CREATE TABLE oauth_accounts (
+ id INT AUTO_INCREMENT PRIMARY KEY,
+ user_id INT,
+ provider VARCHAR(50),
+ provider_user_id VARCHAR(255),
+ access_token VARCHAR(255),
+ expires_at TIMESTAMP NULL,
+ refresh_token VARCHAR(255),
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (user_id) REFERENCES users(id)
+ )
+ """))
+
+ # Create TeamAchievement table if it doesn't exist
+ if 'team_achievements' not in inspector.get_table_names():
+ print("Creating team_achievements table")
+ connection.execute(text("""
+ CREATE TABLE team_achievements (
+ id INT AUTO_INCREMENT PRIMARY KEY,
+ team_id INT,
+ name VARCHAR(255) NOT NULL,
+ event_name VARCHAR(255),
+ description TEXT,
+ achieved_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (team_id) REFERENCES teams(id)
+ )
+ """))
+
+ connection.commit()
+ print("Schema migrations completed successfully")
+ except Exception as e:
+ print(f"Error during schema migration: {e}")
+ finally:
+ connection.close()
diff --git a/app/db_init.py b/app/db_init.py
new file mode 100644
index 0000000..03ec4ea
--- /dev/null
+++ b/app/db_init.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+Seed the database with initial testing data.
+"""
+import random
+from datetime import datetime, timedelta
+from sqlalchemy import inspect
+from sqlalchemy.orm import Session
+
+from .models import User, Team, TeamMembership, QRTicket
+from .db import SessionLocal
+
+def table_has_column(engine, table_name, column_name):
+ """Check if a table has a specific column."""
+ inspector = inspect(engine)
+ if table_name not in inspector.get_table_names():
+ return False
+ columns = [col['name'] for col in inspector.get_columns(table_name)]
+ return column_name in columns
+
+def seed_db():
+ """Seed the database with test data."""
+ db = SessionLocal()
+
+ try:
+ # Only seed if tables are empty
+ if db.query(User).count() > 0:
+ print("Database already has data. Skipping seeding.")
+ return
+
+ # Create users
+ users = [
+ User(username="john_quizmaster", email="john@example.com", hashed_password="password123"),
+ User(username="sarah_johnson", email="sarah@example.com", hashed_password="password123"),
+ User(username="mike_peters", email="mike@example.com", hashed_password="password123"),
+ User(username="emma_wilson", email="emma@example.com", hashed_password="password123"),
+ User(username="robert_brown", email="robert@example.com", hashed_password="password123"),
+ ]
+ db.add_all(users)
+ db.commit()
+
+ # Create teams
+ has_is_public = table_has_column(db.bind, 'teams', 'is_public')
+ has_created_at = table_has_column(db.bind, 'teams', 'created_at')
+ has_description = table_has_column(db.bind, 'teams', 'description')
+
+ teams = []
+ for i, name in enumerate(["Quiz Wizards", "Trivia Titans", "Beer Brainiacs", "Knowledge Knights"]):
+ team_attrs = {"name": name}
+ if has_is_public:
+ team_attrs["is_public"] = i % 2 == 1 # Alternate public/private
+ if has_description:
+ team_attrs["description"] = f"A team of quiz enthusiasts called {name}"
+ teams.append(Team(**team_attrs))
+
+ db.add_all(teams)
+ db.commit()
+
+ # Create team memberships
+ has_joined_at = table_has_column(db.bind, 'team_membership', 'joined_at')
+
+ memberships = []
+ membership_data = [
+ # Quiz Wizards
+ (1, 1, True, 160),
+ (2, 1, False, 155),
+ (3, 1, False, 130),
+ (4, 1, False, 90),
+ (5, 1, False, 45),
+ # Trivia Titans
+ (2, 2, True, 150),
+ (1, 2, False, 145),
+ # Beer Brainiacs
+ (3, 3, True, 120),
+ ]
+
+ for user_id, team_id, is_admin, days_ago in membership_data:
+ membership_attrs = {
+ "user_id": user_id,
+ "team_id": team_id,
+ "is_admin": is_admin
+ }
+ if has_joined_at:
+ membership_attrs["joined_at"] = datetime.now() - timedelta(days=days_ago)
+ memberships.append(TeamMembership(**membership_attrs))
+
+ db.add_all(memberships)
+ db.commit()
+
+ # Create QR tickets
+ has_created_at = table_has_column(db.bind, 'qr_tickets', 'created_at')
+ has_redeemed_at = table_has_column(db.bind, 'qr_tickets', 'redeemed_at')
+ has_event_name = table_has_column(db.bind, 'qr_tickets', 'event_name')
+
+ event_names = [
+ "Music Trivia Night",
+ "History Night",
+ "Movie Trivia Night",
+ "Sports Quiz",
+ "General Knowledge"
+ ]
+
+ # Create some basic tickets
+ tickets = []
+ for i in range(15):
+ points = random.choice([5, 10, 15, 20, 25])
+ team_id = random.randint(1, len(teams))
+ user_id = random.randint(1, len(users))
+
+ ticket_attrs = {
+ "code": f"TICKET{i:03d}",
+ "points": points,
+ "redeemed_by": user_id,
+ "redeemed_at_team": team_id,
+ "used": True
+ }
+
+ if has_event_name:
+ ticket_attrs["event_name"] = random.choice(event_names)
+
+ tickets.append(QRTicket(**ticket_attrs))
+
+ db.add_all(tickets)
+ db.commit()
+
+ print("Database seeded successfully!")
+
+ except Exception as e:
+ print(f"Error seeding database: {e}")
+ finally:
+ db.close()
+
+if __name__ == "__main__":
+ seed_db()
diff --git a/app/dependencies.py b/app/dependencies.py
new file mode 100644
index 0000000..00ab546
--- /dev/null
+++ b/app/dependencies.py
@@ -0,0 +1,110 @@
+from fastapi import Depends, HTTPException, status, Request
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+from sqlalchemy.orm import Session
+from sqlalchemy import inspect
+from typing import Optional
+from datetime import datetime
+
+from .db import SessionLocal, engine
+from .models import User
+from .security import SECRET_KEY, ALGORITHM
+from .templates_config import templates
+
+# OAuth2 scheme for token authentication
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token", auto_error=False)
+
+def get_db():
+ """Database dependency."""
+ db = SessionLocal()
+ try:
+ yield db
+ finally:
+ db.close()
+
+# Check if all required user columns exist
+def get_available_user_columns():
+ inspector = inspect(engine)
+ if 'users' in inspector.get_table_names():
+ return [col['name'] for col in inspector.get_columns('users')]
+ return []
+
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+ """Get the current authenticated user based on the access token."""
+ credentials_exception = HTTPException(
+ status_code=status.HTTP_401_UNAUTHORIZED,
+ detail="Could not validate credentials",
+ headers={"WWW-Authenticate": "Bearer"},
+ )
+
+ # If no token, return None (not authenticated)
+ if not token:
+ return None
+
+ try:
+ payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+ username: str = payload.get("sub")
+ if username is None:
+ raise credentials_exception
+ except JWTError:
+ raise credentials_exception
+
+ user = db.query(User).filter(User.username == username).first()
+ if user is None:
+ raise credentials_exception
+
+ # Update last login time if column exists
+ columns = get_available_user_columns()
+ if 'last_login' in columns and hasattr(user, 'last_login'):
+ user.last_login = datetime.utcnow()
+ db.commit()
+
+ return user
+
+async def get_current_active_user(current_user: User = Depends(get_current_user)):
+ """Check if the current user is active."""
+ if not current_user:
+ return None
+
+ columns = get_available_user_columns()
+ if 'is_active' in columns and hasattr(current_user, 'is_active') and not current_user.is_active:
+ raise HTTPException(status_code=400, detail="Inactive user")
+
+ return current_user
+
+# Improved session-based user lookup with better error handling and logging
+async def get_user_from_session(request: Request):
+ """Get current user from session with improved error handling"""
+ try:
+ if not hasattr(request, "session"):
+ print("No session attribute in request")
+ return None
+
+ user_id = request.session.get("user_id")
+ if not user_id:
+ print("No user_id in session")
+ return None
+
+ print(f"Looking up user with ID: {user_id}")
+ # Manually get a database session from get_db
+ db = next(get_db())
+ try:
+ user = db.query(User).filter(User.id == user_id).first()
+ if not user:
+ print(f"User with ID {user_id} not found in database")
+ # Clear invalid session data
+ request.session.clear()
+ return None
+ return user
+ finally:
+ db.close()
+
+ except Exception as e:
+ print(f"Error getting user from session: {str(e)}")
+ return None
+
+# Template context processor to add user to all templates
+async def add_user_to_templates(request: Request):
+ """Add current user to all template contexts."""
+ user = await get_user_from_session(request)
+ return {"current_user": user}
diff --git a/app/main.py b/app/main.py
new file mode 100644
index 0000000..41ebd61
--- /dev/null
+++ b/app/main.py
@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+from fastapi import FastAPI, Request, status
+from fastapi.responses import HTMLResponse, RedirectResponse
+from starlette.middleware.sessions import SessionMiddleware
+from datetime import datetime
+import os
+
+from .db import init_db, engine
+from . import models
+from .templates_config import templates
+from .views import qr, redeem, teams, admin, leaderboard, dashboard, auth
+from .db_init import seed_db
+from .dependencies import get_user_from_session
+
+# Create tables on startup
+init_db()
+
+# Seed database with initial test data
+# In a production app, you would handle this differently
+seed_db()
+
+app = FastAPI()
+
+# IMPORTANT: Add SessionMiddleware FIRST before any other middleware
+# This ensures session data is available to all other middleware and route handlers
+app.add_middleware(
+ SessionMiddleware,
+ secret_key=os.environ.get("SECRET_KEY", "a-default-secret-key-for-sessions"),
+ max_age=int(os.environ.get("SESSION_MAX_AGE", 86400)), # 24 hours
+ same_site="lax", # Important for security while allowing redirects
+ https_only=os.environ.get("COOKIE_SECURE", "False").lower() == "true",
+ session_cookie="league_ledger_session", # Custom cookie name for clarity
+)
+
+# Add debugging middleware to help track sessions
+@app.middleware("http")
+async def debug_session_middleware(request, call_next):
+ """Debug middleware to track session state"""
+ session_cookie = request.cookies.get("league_ledger_session")
+
+ print(f"Request path: {request.url.path}")
+ print(f"Has session attribute: {'session' in request.scope}")
+ print(f"Has session cookie: {session_cookie is not None}")
+
+ if "session" in request.scope:
+ print(f"Session data before: {dict(request.session)}")
+
+ response = await call_next(request)
+
+ if "session" in request.scope:
+ print(f"Session data after: {dict(request.session)}")
+
+ return response
+
+# Update the template globals at app startup to access the request
+@app.middleware("http")
+async def add_user_to_request(request: Request, call_next):
+ # Print debugging information
+ print(f"Processing request to: {request.url.path}")
+
+ # Add user to request state so templates can access it
+ try:
+ if "session" in request.scope:
+ print("Session found in request scope")
+ if "user_id" in request.session:
+ print(f"User ID in session: {request.session['user_id']}")
+ # Get user from session
+ user = await get_user_from_session(request)
+ request.state.user = user
+ else:
+ print("No user_id in session")
+ request.state.user = None
+ else:
+ print("No session in request scope")
+ request.state.user = None
+ except Exception as e:
+ print(f"Error in middleware: {e}")
+ request.state.user = None
+
+ # Update template context with current user before processing the request
+ templates.env.globals["current_user"] = request.state.user
+
+ # Process the request
+ response = await call_next(request)
+ return response
+
+# Routers
+app.include_router(auth.router, prefix="/auth", tags=["Auth"]) # Auth router should be first
+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"])
+app.include_router(admin.router, prefix="/admin", tags=["Admin"])
+app.include_router(leaderboard.router, prefix="/leaderboard", tags=["Leaderboard"])
+app.include_router(dashboard.router, prefix="/dashboard", tags=["Dashboard"])
+
+@app.get("/", response_class=HTMLResponse)
+def index(request: Request):
+ return templates.TemplateResponse("index.html", {
+ "request": request,
+ "now": datetime.now,
+ "current_user": getattr(request.state, "user", None)
+ })
+
+@app.get("/about", response_class=HTMLResponse)
+def about(request: Request):
+ return templates.TemplateResponse("about.html", {
+ "request": request,
+ "current_user": getattr(request.state, "user", None)
+ })
+
+@app.get("/contact", response_class=HTMLResponse)
+def contact(request: Request):
+ return templates.TemplateResponse("contact.html", {
+ "request": request,
+ "current_user": getattr(request.state, "user", None)
+ })
+
+@app.get("/privacy", response_class=HTMLResponse)
+def privacy(request: Request):
+ return templates.TemplateResponse("privacy.html", {
+ "request": request,
+ "current_user": getattr(request.state, "user", None)
+ })
+
+@app.get("/terms", response_class=HTMLResponse)
+def terms(request: Request):
+ return templates.TemplateResponse("terms.html", {
+ "request": request,
+ "current_user": getattr(request.state, "user", None)
+ })
diff --git a/app/models.py b/app/models.py
new file mode 100644
index 0000000..1cdacfc
--- /dev/null
+++ b/app/models.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+from sqlalchemy import Column, Integer, String, ForeignKey, Boolean, DateTime, Text, Table
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from .db import Base
+
+class User(Base):
+ __tablename__ = "users"
+ id = Column(Integer, primary_key=True, index=True)
+ username = Column(String(50), unique=True, index=True, nullable=False)
+ email = Column(String(255), unique=True, index=True, nullable=False)
+ hashed_password = Column(String(255), nullable=True)
+ created_at = Column(DateTime, server_default=func.now())
+ is_active = Column(Boolean, default=True)
+ is_verified = Column(Boolean, default=False)
+ verification_token = Column(String(255), nullable=True)
+ reset_token = Column(String(255), nullable=True)
+ reset_token_expires_at = Column(DateTime, nullable=True)
+ last_login = Column(DateTime, nullable=True)
+
+ # Relationship to teams
+ memberships = relationship("TeamMembership", back_populates="user")
+
+
+class OAuthAccount(Base):
+ __tablename__ = "oauth_accounts"
+ id = Column(Integer, primary_key=True, index=True)
+ user_id = Column(Integer, ForeignKey("users.id"))
+ provider = Column(String(50)) # e.g., "google", "facebook"
+ provider_user_id = Column(String(255))
+ access_token = Column(String(255))
+ expires_at = Column(DateTime, nullable=True)
+ refresh_token = Column(String(255), nullable=True)
+ created_at = Column(DateTime, server_default=func.now())
+
+ user = relationship("User")
+
+
+class Team(Base):
+ __tablename__ = "teams"
+ id = Column(Integer, primary_key=True, index=True)
+ name = Column(String(100), unique=True, nullable=False)
+
+ # Add fields for team detail view
+ is_public = Column(Boolean, default=False) # For team privacy setting
+ created_at = Column(DateTime, server_default=func.now()) # For team founded date
+ description = Column(Text, nullable=True) # Optional team description
+
+ # Relationship to memberships
+ memberships = relationship("TeamMembership", back_populates="team")
+
+
+class TeamMembership(Base):
+ __tablename__ = "team_membership"
+ id = Column(Integer, primary_key=True, index=True)
+ user_id = Column(Integer, ForeignKey("users.id"))
+ team_id = Column(Integer, ForeignKey("teams.id"))
+ is_admin = Column(Boolean, default=False)
+
+ # Add joined_at to track when members joined
+ joined_at = Column(DateTime, server_default=func.now())
+
+ user = relationship("User", back_populates="memberships")
+ team = relationship("Team", back_populates="memberships")
+
+
+class QRTicket(Base):
+ __tablename__ = "qr_tickets"
+ id = Column(Integer, primary_key=True, index=True)
+ code = Column(String(128), unique=True, index=True) # Unique token
+ points = Column(Integer, default=0)
+ redeemed_by = Column(Integer, ForeignKey("users.id"), nullable=True)
+ redeemed_at_team = Column(Integer, ForeignKey("teams.id"), nullable=True)
+ used = Column(Boolean, default=False)
+
+ # Add timestamps to track when tickets were created and redeemed
+ created_at = Column(DateTime, server_default=func.now())
+ redeemed_at = Column(DateTime, nullable=True)
+
+ # Add event name to track which quiz event this ticket belongs to
+ event_name = Column(String(255), nullable=True)
+
+
+# New model for team achievements
+class TeamAchievement(Base):
+ __tablename__ = "team_achievements"
+ id = Column(Integer, primary_key=True, index=True)
+ team_id = Column(Integer, ForeignKey("teams.id"))
+ name = Column(String(255), nullable=False) # e.g., "1st Place"
+ event_name = Column(String(255), nullable=True) # e.g., "History Night"
+ description = Column(Text, nullable=True)
+ achieved_at = Column(DateTime, server_default=func.now())
+
+ team = relationship("Team")
diff --git a/app/models/user.py b/app/models/user.py
new file mode 100644
index 0000000..e0eae7a
--- /dev/null
+++ b/app/models/user.py
@@ -0,0 +1,18 @@
+# Add is_admin field to User model if it's missing
+
+from sqlalchemy import Column, Integer, String, Boolean
+# ...existing imports...
+
+class User(Base):
+ __tablename__ = "users"
+
+ # ...existing fields...
+ id = Column(Integer, primary_key=True, index=True)
+ username = Column(String(50), unique=True, index=True)
+ email = Column(String(100), unique=True, index=True)
+ password = Column(String(255))
+
+ # Add is_admin field if it doesn't exist
+ is_admin = Column(Boolean, default=False)
+
+ # ...existing methods...
diff --git a/app/schemas.py b/app/schemas.py
new file mode 100644
index 0000000..41303c2
--- /dev/null
+++ b/app/schemas.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+from pydantic import BaseModel, EmailStr, Field, field_validator
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+# User schemas
+class UserBase(BaseModel):
+ username: str
+ email: EmailStr
+
+class UserCreate(UserBase):
+ password: str
+
+ # Validators could be added here, like:
+ @field_validator('password')
+ def password_must_be_strong(cls, v):
+ if len(v) < 8:
+ raise ValueError('Password must be at least 8 characters')
+ return v
+
+class UserLogin(BaseModel):
+ username_or_email: str
+ password: str
+ remember_me: bool = False
+
+class UserUpdate(BaseModel):
+ username: Optional[str] = None
+ email: Optional[EmailStr] = None
+
+class UserOut(BaseModel):
+ id: int
+ username: str
+ email: EmailStr
+ created_at: datetime
+ is_active: bool
+ is_verified: bool
+ last_login: Optional[datetime] = None
+
+ class Config:
+ from_attributes = True
+
+class Token(BaseModel):
+ access_token: str
+ token_type: str
+ user_id: int
+ username: str
+
+class TokenData(BaseModel):
+ username: Optional[str] = None
+
+class PasswordChange(BaseModel):
+ current_password: str
+ new_password: str
+ confirm_password: str
+
+class PasswordReset(BaseModel):
+ token: str
+ new_password: str
+ confirm_password: str
+
+# Team schemas
+class TeamCreate(BaseModel):
+ name: str
+
+class TeamOut(BaseModel):
+ id: int
+ name: str
+
+ class Config:
+ from_attributes = True
+
+class TeamMembershipCreate(BaseModel):
+ user_id: int
+ team_id: int
+ is_admin: bool = False
+
+ # Validator to handle form data conversion
+ @field_validator('is_admin')
+ def parse_boolean(cls, v):
+ if isinstance(v, str):
+ return v.lower() in ('true', 'yes', 'y', '1', 'on', 'checked')
+ return v
diff --git a/app/security.py b/app/security.py
new file mode 100644
index 0000000..4ca8acd
--- /dev/null
+++ b/app/security.py
@@ -0,0 +1,39 @@
+from passlib.context import CryptContext
+from jose import JWTError, jwt
+from datetime import datetime, timedelta
+import secrets
+import string
+import bcrypt
+
+# Password hashing
+# Use a simpler CryptContext configuration to avoid bcrypt.__about__ error
+pwd_context = CryptContext(schemes=["bcrypt"])
+
+# JWT settings
+SECRET_KEY = "CHANGE_THIS_TO_A_STRONG_SECRET_KEY_IN_PRODUCTION"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+def verify_password(plain_password, hashed_password):
+ """Verify if the plain password matches the hashed one."""
+ return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+ """Hash a password for storing."""
+ return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: timedelta = None):
+ """Create JWT access token."""
+ to_encode = data.copy()
+ if expires_delta:
+ expire = datetime.utcnow() + expires_delta
+ else:
+ expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+ to_encode.update({"exp": expire})
+ encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+ return encoded_jwt
+
+def generate_token(length=32):
+ """Generate a random token for email verification or password reset."""
+ alphabet = string.ascii_letters + string.digits
+ return ''.join(secrets.choice(alphabet) for i in range(length))
diff --git a/app/templates/about.html b/app/templates/about.html
new file mode 100644
index 0000000..5bf701d
--- /dev/null
+++ b/app/templates/about.html
@@ -0,0 +1,23 @@
+{% extends "base.html" %}
+{% block content %}
+
+
About LeagueLedger
+
+ LeagueLedger is your ultimate companion for tracking pub quiz team achievements. We aim to provide a fun and engaging platform for quiz enthusiasts to connect, compete, and celebrate their knowledge.
+
+
+ As a pub quiz master, you can generate printout QR codes for your top-ranking teams, distribute them, and let teams redeem them for points on our website.
+
+
+ As a pub quiz team member, you can redeem QR codes, create a team name, invite other members, and use social logins for easy access.
+
+
Our Mission
+
+ To enhance the pub quiz experience by providing a seamless and intuitive platform for tracking team progress, fostering friendly competition, and celebrating the spirit of trivia.
+
+
Our Team
+
+ LeagueLedger is an Open-Source initiative and part of the KaufDeinQuiz platform. It is brought to you by Christian Louis IT Beratung und Medienproduktion, a team of dedicated quiz enthusiasts and software developers passionate about creating innovative solutions for the pub quiz community.
+
+ Your privacy is important to us. This Privacy Policy outlines how LeagueLedger collects, uses, and protects your information.
+
+
Information We Collect
+
+
Email addresses
+
Usernames
+
Team names
+
Quiz scores and points
+
+
How We Use Your Information
+
+ We use your information to:
+
+
+
Track leaderboard rankings
+
Send notifications about team activities
+
Improve our services and user experience
+
+
Data Sharing
+
+ We do not share your personal information with third parties except as required by law.
+
+
+ Christian Louis IT Beratung und Medienproduktion, as the operator of this platform, takes data privacy seriously and implements measures to protect your personal information.
+
+