2025-07-26

draft/admin.py

@@ -0,0 +1,10 @@
+from django.contrib import admin
+from draft.models import DraftSession, DraftParticipant, DraftMoviePool, DraftPick
+
+# Register your models here.
+class DraftSessionAdmin(admin.ModelAdmin):
+  readonly_fields = ('hashed_id',)
+admin.site.register(DraftSession, DraftSessionAdmin)
+admin.site.register(DraftParticipant)
+admin.site.register(DraftMoviePool)
+admin.site.register(DraftPick)

draft/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class DraftConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'draft'

draft/consumers.py

@@ -0,0 +1,151 @@
+from channels.generic.websocket import AsyncJsonWebsocketConsumer
+from channels.db import database_sync_to_async
+from django.core.exceptions import PermissionDenied
+from boxofficefantasy.models import League, Season
+from boxofficefantasy.views import parse_season_slug
+from draft.models import DraftSession, DraftPick, DraftMoviePool, DraftParticipant
+
+import random
+
+class DraftConsumer(AsyncJsonWebsocketConsumer):
+    async def connect(self):
+        draft_session_id_hashed = self.scope["url_route"]["kwargs"].get("draft_session_id_hashed")
+        league_slug = self.scope["url_route"]["kwargs"].get("league_slug")
+        season_slug = self.scope["url_route"]["kwargs"].get("season_slug")
+
+        self.draft_session = await self.get_draft_session(draft_session_id_hashed=draft_session_id_hashed, league_slug=league_slug, season_slug=season_slug)
+
+        self.room_group_name = f"draft_{self.draft_session.season.league.slug}_{self.draft_session.season.slug}"
+
+        # Auth check (optional)
+        user = self.scope["user"]
+        if not user.is_authenticated:
+            await self.close()
+            return
+
+        await self.channel_layer.group_add(self.room_group_name, self.channel_name)
+        await self.accept()
+        await self.send_json({"type": "connection.accepted", "user": user.username})
+
+        # Notify others (optional)
+        await self.channel_layer.group_send(
+            self.room_group_name,
+            {
+                "type": "user.joined",
+                "user": user.username,
+            }
+        )
+
+    async def disconnect(self, close_code):
+        await self.channel_layer.group_discard(self.room_group_name, self.channel_name)
+
+    async def receive_json(self, content):
+        event_type = content.get("type")
+        user = self.scope["user"]
+        
+        if event_type == "start_draft":
+            if user.is_staff:
+                await self.start_draft()
+            else:
+                await self.send_json({
+                    "type": "error",
+                    "message": "insufficient privelleges"
+                })
+        elif event_type == "nominate":
+            await self.nominate(content.get("movie"))
+        elif event_type == "bid":
+            await self.place_bid(content.get("amount"), self.scope["user"].username)
+        elif event_type == "message":
+            await self.channel_layer.group_send(
+                self.room_group_name,
+                {
+                    "type": "chat.message",
+                    "user": self.scope["user"].username,
+                    "message": content.get("message"),
+                },
+            )
+
+    # === Broadcast handlers ===
+
+    async def user_joined(self, event):
+        await self.send_json({
+            "type": "user.joined",
+            "user": event["user"]
+        })
+
+    async def chat_message(self, event):
+        await self.send_json({
+            "type": "chat.message",
+            "user": event["user"],
+            "message": event["message"],
+        })
+
+    async def draft_update(self, event):
+        await self.send_json({
+            "type": "draft.update",
+            "state": event["state"],
+        })
+
+    # === Draft logic (stubbed for now) ===
+
+    async def start_draft(self):
+        # Example: shuffle draft order
+        players = await self.get_draft_users()
+        draft_order = random.sample(players, len(players))
+
+        await self.channel_layer.group_send(
+            self.room_group_name,
+            {
+                "type": "draft.update",
+                "state": {
+                    "status": "started",
+                    "order": [p.user.username for p in draft_order],
+                }
+            }
+        )
+
+    async def nominate(self, movie_title):
+        await self.channel_layer.group_send(
+            self.room_group_name,
+            {
+                "type": "draft.update",
+                "state": {
+                    "status": "nominating",
+                    "movie": movie_title,
+                }
+            }
+        )
+
+    async def place_bid(self, amount, user):
+        await self.channel_layer.group_send(
+            self.room_group_name,
+            {
+                "type": "draft.update",
+                "state": {
+                    "status": "bidding",
+                    "bid": {"amount": amount, "user": user}
+                }
+            }
+        )
+
+    # === Example DB Access ===
+
+    @database_sync_to_async
+    def get_draft_users(self):
+        # Replace this with real queryset to fetch users in draft
+        return list(DraftParticipant.objects.select_related('user').filter(draft=self.draft_session).all())
+        return ["alice", "bob", "carol"]
+    
+    @database_sync_to_async
+    def get_draft_session(self, draft_session_id_hashed, league_slug, season_slug):
+        draft_session_id = DraftSession.decode_id(draft_session_id_hashed)
+        if draft_session_id:
+            draft_session = DraftSession.objects.select_related('season', 'season__league').get(pk=draft_session_id)
+        elif league_slug and season_slug:
+            label, year = parse_season_slug(season_slug)
+            season = Season.objects.filter(label=label, year=year).first()
+            draft_session = DraftSession.objects.select_related('season', 'season__league').filter(season=season).first()
+        else:
+            raise Exception()
+        
+        return draft_session

draft/migrations/0001_initial.py

@@ -0,0 +1,56 @@
+# Generated by Django 5.2.4 on 2025-07-26 13:41
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('boxofficefantasy', '0009_alter_moviemetric_value_alter_pick_bid_amount_and_more'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='DraftSession',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('is_active', models.BooleanField()),
+                ('current_nomination_index', models.IntegerField()),
+                ('season', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='boxofficefantasy.season')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='DraftPick',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('bid_amount', models.IntegerField()),
+                ('nomination_order', models.IntegerField()),
+                ('movie', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='boxofficefantasy.movie')),
+                ('winner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+                ('draft', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='draft.draftsession')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='DraftParticipant',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('budget', models.IntegerField()),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+                ('draft', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='draft.draftsession')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='DraftMoviePool',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('nominated', models.BooleanField()),
+                ('movie', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='boxofficefantasy.movie')),
+                ('draft', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='draft.draftsession')),
+            ],
+        ),
+    ]

draft/models.py

@@ -0,0 +1,34 @@
+from django.db.models import ForeignKey, Model, IntegerField, BooleanField, CASCADE, PROTECT
+from boxofficefantasy.models import Season, User, Movie
+from boxofficefantasy_project.utils import encode_id, decode_id
+
+# Create your models here.
+class DraftSession(Model):
+    season = ForeignKey(Season, on_delete=CASCADE)
+    is_active = BooleanField()
+    current_nomination_index = IntegerField()
+
+    @property
+    def hashed_id(self):
+        return f"{encode_id(self.pk)}"
+    
+    @classmethod
+    def decode_id(cls, hashed_id:str) -> id:
+        return decode_id(hashed_id)
+
+class DraftParticipant(Model):
+    draft = ForeignKey(DraftSession, on_delete=CASCADE)
+    user = ForeignKey(User, on_delete=CASCADE)
+    budget = IntegerField()
+
+class DraftMoviePool(Model):
+    draft = ForeignKey(DraftSession, on_delete=CASCADE)
+    movie = ForeignKey(Movie, on_delete=CASCADE)
+    nominated = BooleanField()
+
+class DraftPick(Model):
+    draft = ForeignKey(DraftSession, on_delete=CASCADE)
+    movie = ForeignKey(Movie, on_delete=CASCADE)
+    winner = ForeignKey(User, on_delete=CASCADE)
+    bid_amount = IntegerField()
+    nomination_order = IntegerField()

draft/routing.py

@@ -0,0 +1,7 @@
+from django.urls import path
+from . import consumers
+
+websocket_urlpatterns = [
+    path(r"ws/draft/session/<str:draft_session_id_hashed>/", consumers.DraftConsumer.as_asgi()),
+    # path(r"ws/draft/<slug:league_slug>/<slug:season_slug>/", consumers.DraftConsumer.as_asgi()),
+]

draft/templates/draft/room.dj.html

@@ -0,0 +1,8 @@
+<h1>Draft Room: {{ league.name }} – {{ season.label }} {{ season.year }}</h1>
+{%load static%}
+<div id="draft-app" data-draft-id="{{draft_id_hashed}}" data-room-name="{{ room_name }}"></div>
+{% if DEBUG %}
+<script src="http://localhost:3000/dist/bundle.js"></script>
+{% else %}
+<script src="{% static 'bundle.js' %}"></script>
+{% endif %}

draft/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

draft/urls.py

@@ -0,0 +1,10 @@
+from django.urls import path
+from . import views
+
+app_name = "draft"
+
+urlpatterns = [
+    # path("", views.draft_room, name="room"),
+    path("session/<str:draft_session_id_hashed>/", views.draft_room, name="session"),
+    # path("<slug:league_slug>/<slug:season_slug>/", views.draft_room_list, name="room"),
+]

draft/views.py

@@ -0,0 +1,28 @@
+from django.shortcuts import render, get_object_or_404
+from boxofficefantasy.models import League, Season
+from draft.models import DraftSession
+from boxofficefantasy.views import parse_season_slug
+from django.contrib.auth.decorators import login_required
+from boxofficefantasy_project.utils import decode_id
+
+# @login_required(login_url='/login/')
+def draft_room(request, league_slug=None, season_slug=None, draft_session_id_hashed=None):
+
+    if draft_session_id_hashed:
+        draft_session_id = decode_id(draft_session_id_hashed)
+        draft_session = get_object_or_404(DraftSession, id=draft_session_id)
+        league = draft_session.season.league
+        season = draft_session.season
+    elif league_slug and season_slug:
+        raise NotImplementedError
+        league = get_object_or_404(League, slug=league_slug)
+        label, year = parse_season_slug(season_slug)
+        season = get_object_or_404(Season, league=league, label__iexact=label, year=year)
+        draft_session = get_object_or_404(DraftSession, season=season)
+
+    return render(request, "draft/room.dj.html", {
+        "draft_id_hashed": draft_session.hashed_id,
+        "league": league,
+        "season": season,
+        "room_name": f"{league.slug}-{season.slug}"
+    })