feat: tournament events, shifts, and season events

backend/alembic/versions/d3e4f5a6b7c8_tournament_events_backend_rewrite.py

@@ -0,0 +1,202 @@
+"""tournament events backend rewrite
+
+Revision ID: d3e4f5a6b7c8
+Revises: c7b3f4a9d2e1
+Create Date: 2026-08-13 00:00:00.000000
+
+Single migration for the tournament-events backend rewrite, built up
+incrementally as the rewrite progresses:
+
+  - tournament_memberships: drop `assigned_event_id` column (and its FK to
+    tournament_events)
+  - tournament_memberships: drop `schedule` column
+  No backfill — this data is not being preserved or migrated anywhere.
+
+  - tournament_shifts: new table — tournament-scoped time windows
+  - tournament_event_shifts: new bridge table — TournamentEvent <-> TournamentShift
+
+  - tournament_events: drop `blocks` and `category` columns (no migration
+    path — old free-text categories don't reliably match canonical
+    category names, and the old block-scheduling system is gone, not
+    migrated to shifts)
+  - tournament_events: `division` and `name` made nullable (`name` is now
+    custom-event-only display text — catalog-linked events display the
+    joined Event.name instead)
+  - tournament_events: add `event_id` FK to events (SET NULL), nullable
+  - tournament_events: add `start_time`/`end_time`, both nullable. No backfill for
+    existing rows; they simply stay NULL. Frontend is expected to warn on
+    unset times, not block on them.
+  - tournament_events: drop `uq_tournament_event_division`, add a partial
+    unique index on (tournament_id, event_id, division) WHERE event_id IS
+    NOT NULL — custom (event_id-less) events have no uniqueness constraint
+  - tournament_events: `volunteers_needed` made nullable, default dropped
+    (no more implicit "2" — unset means genuinely unset, not a guess)
+
+  - season_events: new table — admin-curated per-year/division active
+    event list, drives the tournament events bulk-load default list. No
+    backfill, starts empty.
+
+  - tournaments: add `timezone` (IANA name), NOT NULL. Set once at
+    creation from the creator's browser timezone, immutable after —
+    no update path. Existing rows backfilled to "America/Los_Angeles".
+"""
+from typing import Sequence, Union
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import text
+
+
+revision: str = "d3e4f5a6b7c8"
+down_revision: Union[str, None] = "c7b3f4a9d2e1"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ------------------------------------------------------------------
+    # tournament_memberships — drop assigned_event_id + schedule
+    # ------------------------------------------------------------------
+    op.drop_constraint(
+        "memberships_assigned_event_id_fkey",
+        "tournament_memberships",
+        type_="foreignkey",
+    )
+    op.drop_column("tournament_memberships", "assigned_event_id")
+    op.drop_column("tournament_memberships", "schedule")
+
+    # ------------------------------------------------------------------
+    # tournament_shifts + tournament_event_shifts — new tables
+    # ------------------------------------------------------------------
+    op.create_table(
+        "tournament_shifts",
+        sa.Column("id", sa.Integer(), primary_key=True, index=True),
+        sa.Column("tournament_id", sa.Integer(), sa.ForeignKey("tournaments.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("label", sa.String(length=255), nullable=False),
+        sa.Column("start", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("end", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=True),
+    )
+    op.create_table(
+        "tournament_event_shifts",
+        sa.Column("tournament_event_id", sa.Integer(), sa.ForeignKey("tournament_events.id", ondelete="CASCADE"), primary_key=True),
+        sa.Column("tournament_shift_id", sa.Integer(), sa.ForeignKey("tournament_shifts.id", ondelete="CASCADE"), primary_key=True),
+    )
+
+    # ------------------------------------------------------------------
+    # tournament_events — drop blocks/category, add event_id, add
+    # start_time/end_time (nullable, no backfill), relax division, swap
+    # the unique constraint for a partial unique index scoped to
+    # catalog-linked rows
+    # ------------------------------------------------------------------
+    op.drop_constraint("uq_tournament_event_division", "tournament_events", type_="unique")
+    op.alter_column("tournament_events", "division", existing_type=sa.String(length=4), nullable=True)
+    op.alter_column("tournament_events", "name", existing_type=sa.String(length=255), nullable=True)
+
+    op.drop_column("tournament_events", "blocks")
+    op.drop_column("tournament_events", "category")
+
+    op.add_column(
+        "tournament_events",
+        sa.Column("event_id", sa.Integer(), sa.ForeignKey("events.id", ondelete="SET NULL"), nullable=True),
+    )
+    op.add_column("tournament_events", sa.Column("start_time", sa.DateTime(timezone=True), nullable=True))
+    op.add_column("tournament_events", sa.Column("end_time", sa.DateTime(timezone=True), nullable=True))
+
+    op.create_index(
+        "uq_tournament_event_catalog_division",
+        "tournament_events",
+        ["tournament_id", "event_id", "division"],
+        unique=True,
+        postgresql_where=text("event_id IS NOT NULL"),
+    )
+
+    op.alter_column("tournament_events", "volunteers_needed", existing_type=sa.Integer(), nullable=True)
+
+    # ------------------------------------------------------------------
+    # season_events — new table
+    # ------------------------------------------------------------------
+    op.create_table(
+        "season_events",
+        sa.Column("id", sa.Integer(), primary_key=True, index=True),
+        sa.Column("event_id", sa.Integer(), sa.ForeignKey("events.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("year", sa.Integer(), nullable=False),
+        sa.Column("division", sa.String(length=4), nullable=False),
+        sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.false()),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=True),
+        sa.UniqueConstraint("event_id", "year", "division", name="uq_season_event"),
+    )
+
+    # ------------------------------------------------------------------
+    # tournaments — add timezone (backfilled, then locked to NOT NULL)
+    # ------------------------------------------------------------------
+    op.add_column(
+        "tournaments",
+        sa.Column("timezone", sa.String(length=64), nullable=False, server_default="America/Los_Angeles"),
+    )
+    op.alter_column("tournaments", "timezone", server_default=None)
+
+
+def downgrade() -> None:
+    # ------------------------------------------------------------------
+    # tournaments — drop timezone
+    # ------------------------------------------------------------------
+    op.drop_column("tournaments", "timezone")
+
+    # ------------------------------------------------------------------
+    # season_events — drop new table
+    # ------------------------------------------------------------------
+    op.drop_table("season_events")
+
+    # ------------------------------------------------------------------
+    # tournament_events — restore blocks/category/old unique constraint,
+    # drop event_id/start_time/end_time
+    # NOTE: data will be lost on downgrade (event_id links, start/end times).
+    # ------------------------------------------------------------------
+    op.drop_index("uq_tournament_event_catalog_division", table_name="tournament_events")
+
+    # Any rows with NULL volunteers_needed get 2 (the old default) so the
+    # NOT NULL constraint below doesn't fail.
+    op.execute("UPDATE tournament_events SET volunteers_needed = 2 WHERE volunteers_needed IS NULL")
+    op.alter_column("tournament_events", "volunteers_needed", existing_type=sa.Integer(), nullable=False)
+
+    op.drop_column("tournament_events", "end_time")
+    op.drop_column("tournament_events", "start_time")
+    op.drop_column("tournament_events", "event_id")
+
+    op.add_column("tournament_events", sa.Column("category", sa.String(length=255), nullable=True))
+    op.add_column("tournament_events", sa.Column("blocks", sa.JSON(), nullable=False, server_default="[]"))
+    op.alter_column("tournament_events", "blocks", server_default=None)
+
+    op.alter_column("tournament_events", "division", existing_type=sa.String(length=4), nullable=False)
+    op.alter_column("tournament_events", "name", existing_type=sa.String(length=255), nullable=False)
+    op.create_unique_constraint(
+        "uq_tournament_event_division", "tournament_events", ["tournament_id", "name", "division"]
+    )
+
+    # ------------------------------------------------------------------
+    # tournament_shifts + tournament_event_shifts — drop new tables
+    # ------------------------------------------------------------------
+    op.drop_table("tournament_event_shifts")
+    op.drop_table("tournament_shifts")
+
+    # ------------------------------------------------------------------
+    # tournament_memberships — restore assigned_event_id + schedule
+    # NOTE: data will be lost on downgrade.
+    # ------------------------------------------------------------------
+    op.add_column(
+        "tournament_memberships",
+        sa.Column("schedule", sa.JSON(), nullable=True),
+    )
+    op.add_column(
+        "tournament_memberships",
+        sa.Column("assigned_event_id", sa.Integer(), nullable=True),
+    )
+    op.create_foreign_key(
+        "memberships_assigned_event_id_fkey",
+        "tournament_memberships",
+        "tournament_events",
+        ["assigned_event_id"],
+        ["id"],
+        ondelete="SET NULL",
+    )

backend/app/api/routes/events.py

@@ -12,6 +12,11 @@
 
 router = APIRouter(tags=["events"])
 
+# Admin-only writes live under /admin/, matching app/api/routes/tournament/admin.py
+# and app/api/routes/season_event.py — the public GET routes above stay
+# unprefixed and unauthenticated.
+admin_router = APIRouter(prefix="/admin", tags=["events"])
+
 
 # ---------------------------------------------------------------------------
 # GET /events/ — list all events
@@ -22,9 +27,9 @@ def list_events(db: Session = Depends(get_db)):
 
 
 # ---------------------------------------------------------------------------
-# POST /events/ — admin only, create a new event
+# POST /admin/events/ — admin only, create a new event
 # ---------------------------------------------------------------------------
-@router.post("/events/", response_model=EventResponse, status_code=status.HTTP_201_CREATED)
+@admin_router.post("/events/", response_model=EventResponse, status_code=status.HTTP_201_CREATED)
 def create_event(body: EventCreate, db: Session = Depends(get_db), _: User = Depends(require_admin)):
     category = db.get(EventCategory, body.category_id)
     if not category:
@@ -38,9 +43,9 @@ def create_event(body: EventCreate, db: Session = Depends(get_db), _: User = Dep
 
 
 # ---------------------------------------------------------------------------
-# PATCH /events/{id}/ — admin only, partial update
+# PATCH /admin/events/{id}/ — admin only, partial update
 # ---------------------------------------------------------------------------
-@router.patch("/events/{event_id}/", response_model=EventResponse)
+@admin_router.patch("/events/{event_id}/", response_model=EventResponse)
 def update_event(event_id: int, body: EventUpdate, db: Session = Depends(get_db), _: User = Depends(require_admin)):
     event = db.get(Event, event_id)
     if not event:
@@ -62,9 +67,9 @@ def update_event(event_id: int, body: EventUpdate, db: Session = Depends(get_db)
 
 
 # ---------------------------------------------------------------------------
-# DELETE /events/{id}/ — admin only, hard delete blocked if experience entries exist
+# DELETE /admin/events/{id}/ — admin only, hard delete blocked if experience entries exist
 # ---------------------------------------------------------------------------
-@router.delete("/events/{event_id}/", status_code=status.HTTP_204_NO_CONTENT)
+@admin_router.delete("/events/{event_id}/", status_code=status.HTTP_204_NO_CONTENT)
 def delete_event(event_id: int, db: Session = Depends(get_db), _: User = Depends(require_admin)):
     event = db.get(Event, event_id)
     if not event:
@@ -90,9 +95,9 @@ def list_event_categories(db: Session = Depends(get_db)):
 
 
 # ---------------------------------------------------------------------------
-# POST /event-categories/ — admin only, create a new category
+# POST /admin/event-categories/ — admin only, create a new category
 # ---------------------------------------------------------------------------
-@router.post("/event-categories/", response_model=EventCategoryResponse, status_code=status.HTTP_201_CREATED)
+@admin_router.post("/event-categories/", response_model=EventCategoryResponse, status_code=status.HTTP_201_CREATED)
 def create_event_category(body: EventCategoryCreate, db: Session = Depends(get_db), _: User = Depends(require_admin)):
     category = EventCategory(name=body.name)
     db.add(category)
@@ -102,9 +107,9 @@ def create_event_category(body: EventCategoryCreate, db: Session = Depends(get_d
 
 
 # ---------------------------------------------------------------------------
-# PATCH /event-categories/{id}/ — admin only, partial update
+# PATCH /admin/event-categories/{id}/ — admin only, partial update
 # ---------------------------------------------------------------------------
-@router.patch("/event-categories/{category_id}/", response_model=EventCategoryResponse)
+@admin_router.patch("/event-categories/{category_id}/", response_model=EventCategoryResponse)
 def update_event_category(
     category_id: int,
     body: EventCategoryUpdate,
@@ -124,10 +129,10 @@ def update_event_category(
 
 
 # ---------------------------------------------------------------------------
-# DELETE /event-categories/{id}/ — admin only, cascades to delete its events
+# DELETE /admin/event-categories/{id}/ — admin only, cascades to delete its events
 # (blocked if any of those events has experience entries — see delete_event note)
 # ---------------------------------------------------------------------------
-@router.delete("/event-categories/{category_id}/", status_code=status.HTTP_204_NO_CONTENT)
+@admin_router.delete("/event-categories/{category_id}/", status_code=status.HTTP_204_NO_CONTENT)
 def delete_event_category(category_id: int, db: Session = Depends(get_db), _: User = Depends(require_admin)):
     category = db.get(EventCategory, category_id)
     if not category:
@@ -141,4 +146,4 @@ def delete_event_category(category_id: int, db: Session = Depends(get_db), _: Us
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT,
             detail="Cannot delete category: one or more of its events has associated experience entries",
-        )
+        )

backend/app/api/routes/season_event.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session, joinedload
+
+from app.core.auth import require_admin
+from app.db.session import get_db
+from app.models.models import SeasonEvent, User
+from app.schemas.season_event import SeasonEventCreate, SeasonEventRead, SeasonEventUpdate
+
+# GET is public/unauthenticated, matching the canonical Event/EventCategory
+# split (app/api/routes/events.py) — writes are admin-only, under /admin/.
+router = APIRouter(prefix="/season-events", tags=["season-events"])
+admin_router = APIRouter(prefix="/admin/season-events", tags=["season-events"])
+
+
+# ---------------------------------------------------------------------------
+# GET /season-events/ — filterable by year, and by one or more divisions
+# (repeat the query param, e.g. ?division=B&division=C)
+# ---------------------------------------------------------------------------
+@router.get("/", response_model=list[SeasonEventRead])
+def list_season_events(
+    year: int | None = Query(None),
+    division: list[str] | None = Query(None),
+    db: Session = Depends(get_db),
+):
+    query = db.query(SeasonEvent).options(joinedload(SeasonEvent.event))
+    if year is not None:
+        query = query.filter(SeasonEvent.year == year)
+    if division:
+        query = query.filter(SeasonEvent.division.in_(division))
+    return query.order_by(SeasonEvent.year.desc(), SeasonEvent.division).all()
+
+
+# ---------------------------------------------------------------------------
+# POST /admin/season-events/ — admin only
+# ---------------------------------------------------------------------------
+@admin_router.post("/", response_model=SeasonEventRead, status_code=status.HTTP_201_CREATED)
+def create_season_event(
+    payload: SeasonEventCreate,
+    db: Session = Depends(get_db),
+    _: User = Depends(require_admin),
+):
+    season_event = SeasonEvent(**payload.model_dump())
+    db.add(season_event)
+    try:
+        db.commit()
+    except IntegrityError:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="A season event for this event/year/division already exists",
+        )
+    db.refresh(season_event)
+    return season_event
+
+
+# ---------------------------------------------------------------------------
+# PATCH /admin/season-events/{id}/ — admin only, primarily used to toggle is_active
+# ---------------------------------------------------------------------------
+@admin_router.patch("/{season_event_id}/", response_model=SeasonEventRead)
+def update_season_event(
+    season_event_id: int,
+    payload: SeasonEventUpdate,
+    db: Session = Depends(get_db),
+    _: User = Depends(require_admin),
+):
+    season_event = db.get(SeasonEvent, season_event_id)
+    if not season_event:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Season event not found")
+
+    for field, value in payload.model_dump(exclude_unset=True).items():
+        setattr(season_event, field, value)
+
+    try:
+        db.commit()
+    except IntegrityError:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="A season event for this event/year/division already exists",
+        )
+    db.refresh(season_event)
+    return season_event
+
+
+# ---------------------------------------------------------------------------
+# DELETE /admin/season-events/{id}/ — admin only
+# ---------------------------------------------------------------------------
+@admin_router.delete("/{season_event_id}/", status_code=status.HTTP_204_NO_CONTENT)
+def delete_season_event(
+    season_event_id: int,
+    db: Session = Depends(get_db),
+    _: User = Depends(require_admin),
+):
+    season_event = db.get(SeasonEvent, season_event_id)
+    if not season_event:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Season event not found")
+
+    db.delete(season_event)
+    db.commit()