302 lines
9.9 KiB
Python
302 lines
9.9 KiB
Python
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
|
|
from django.core.cache import cache
|
|
from draft.constants import DraftMessage, DraftPhase, DraftGroupChannelNames
|
|
|
|
import random
|
|
|
|
class DraftConsumerBase(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,
|
|
)
|
|
|
|
self.draft_group_names = f"draft_admin_{self.draft_session.hashed_id}"
|
|
self.draft_participant_group_channels = DraftGroupChannelNames(draft_session_id_hashed)
|
|
|
|
self.user = self.scope["user"]
|
|
if not self.user.is_authenticated:
|
|
await self.close()
|
|
return
|
|
else:
|
|
await self.accept()
|
|
|
|
async def receive_json(self, content):
|
|
event_type = content.get("type")
|
|
user = self.scope["user"]
|
|
|
|
async def user_joined(self, event):
|
|
await self.send_json(
|
|
{
|
|
"type": "user.joined",
|
|
"user": event["user"].username,
|
|
"user_type": event["user_type"],
|
|
"users": event["users"],
|
|
}
|
|
)
|
|
|
|
async def send_draft_summary(self):
|
|
state = cache.get(self.draft_status_cache_key, {})
|
|
await self.send_json(
|
|
{
|
|
"type": "draft_summary",
|
|
"phase": state.get("phase", "not started"),
|
|
"movie": state.get("movie"),
|
|
"current_bid": state.get("current_bid"),
|
|
"time_remaining": state.get("time_remaining"),
|
|
"you_are_next": state.get("you_are_next", False),
|
|
}
|
|
)
|
|
|
|
# === Broadcast handlers ===
|
|
async def draft_status(self, event):
|
|
await self.send_json(
|
|
{
|
|
"type": "draft.status",
|
|
"status": event["status"],
|
|
}
|
|
)
|
|
|
|
# === DB Access ===
|
|
@database_sync_to_async
|
|
def get_draft_session(
|
|
self, draft_session_id_hashed, league_slug, season_slug
|
|
) -> DraftSession:
|
|
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
|
|
|
|
@database_sync_to_async
|
|
def get_draft_participants(self) -> list[DraftParticipant]:
|
|
# Replace this with real queryset to fetch users in draft
|
|
participants = DraftParticipant.objects.select_related("user").filter(
|
|
draft=self.draft_session
|
|
)
|
|
connected_ids = cache.get(self.draft_connected_participants_cache_key, set())
|
|
for p in participants:
|
|
p.is_connected = p in connected_ids
|
|
return list(participants.all())
|
|
|
|
|
|
class DraftAdminConsumer(DraftConsumerBase):
|
|
async def connect(self):
|
|
await super().connect()
|
|
if not self.user.is_staff:
|
|
await self.close()
|
|
return
|
|
|
|
await self.channel_layer.group_add(
|
|
self.draft_admin_group_name, self.channel_name
|
|
)
|
|
|
|
# await self.channel_layer.group_send(
|
|
# self.draft_participant_group_name,
|
|
# {"type": "user.joined", "user": self.user, "user_type": "admin"},
|
|
# )
|
|
await self.channel_layer.group_send(
|
|
self.draft_admin_group_name,
|
|
{"type": "user.joined", "user": self.user, "user_type": "admin"},
|
|
)
|
|
|
|
async def receive_json(self, content):
|
|
await super().receive_json(content)
|
|
event_type = content.get("type")
|
|
user = self.scope["user"]
|
|
|
|
if event_type == "start.draft":
|
|
await self.start_draft()
|
|
elif event_type == "user.joined":
|
|
pass
|
|
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.draft_participant_group_name,
|
|
{
|
|
"type": "chat.message",
|
|
"user": self.scope["user"].username,
|
|
"message": content.get("message"),
|
|
},
|
|
)
|
|
|
|
# === Draft logic (stubbed for now) ===
|
|
|
|
async def start_draft(self):
|
|
# Example: shuffle draft order
|
|
participants = await self.get_draft_participants()
|
|
draft_order = random.sample(participants, len(participants))
|
|
connected_participants = cache.get(
|
|
self.draft_connected_participants_cache_key, ()
|
|
)
|
|
|
|
initial_state = {
|
|
"phase": "nominating",
|
|
"current_nominee": None,
|
|
"current_bid": None,
|
|
"participants": [
|
|
{"user": p.user.username, "is_connected": p in connected_participants}
|
|
for p in await self.get_draft_participants()
|
|
],
|
|
"draft_order": [p.user.username for p in draft_order],
|
|
"current_turn_index": 0,
|
|
"picks": [],
|
|
}
|
|
cache.set(self.draft_status_cache_key, initial_state)
|
|
|
|
for group_name in [
|
|
self.draft_admin_group_name,
|
|
self.draft_participant_group_name,
|
|
]:
|
|
# await self.channel_layer.group_send(
|
|
# group_name,
|
|
# {
|
|
# "type": "draft.start"
|
|
# }
|
|
# )
|
|
await self.channel_layer.group_send(
|
|
group_name,
|
|
{
|
|
"type": "draft.status",
|
|
"status": cache.get(self.draft_status_cache_key),
|
|
},
|
|
)
|
|
|
|
|
|
class DraftParticipantConsumer(DraftConsumerBase):
|
|
async def connect(self):
|
|
await super().connect()
|
|
|
|
await self.channel_layer.group_add(
|
|
self.draft_participant_group_name, self.channel_name
|
|
)
|
|
|
|
try:
|
|
await self.add_draft_participant()
|
|
except Exception as e:
|
|
await self.close()
|
|
return
|
|
|
|
await self.send_json(
|
|
{
|
|
"type": "connection.accepted",
|
|
"user": self.user.username,
|
|
"is_staff": self.user.is_staff,
|
|
}
|
|
)
|
|
|
|
await self.channel_layer.group_send(
|
|
self.draft_participant_group_name,
|
|
{
|
|
"type": "user.joined",
|
|
"user": self.user,
|
|
"user_type": "participant",
|
|
"participants": [],
|
|
},
|
|
)
|
|
await self.channel_layer.group_send(
|
|
self.draft_admin_group_name,
|
|
{"type": "user.joined", "user": self.user, "user_type": "participant"},
|
|
)
|
|
|
|
async def disconnect(self, close_code):
|
|
await self.channel_layer.group_discard(
|
|
self.draft_participant_group_name, self.channel_name
|
|
)
|
|
|
|
async def receive_json(self, content):
|
|
event_type = content.get("type")
|
|
user = self.scope["user"]
|
|
|
|
if event_type == "user.joined":
|
|
pass
|
|
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.draft_participant_group_name,
|
|
{
|
|
"type": "chat.message",
|
|
"user": self.scope["user"].username,
|
|
"message": content.get("message"),
|
|
},
|
|
)
|
|
|
|
# === Broadcast handlers ===
|
|
|
|
async def chat_message(self, event):
|
|
await self.send_json(
|
|
{
|
|
"type": "chat.message",
|
|
"user": event["user"],
|
|
}
|
|
)
|
|
|
|
async def draft_update(self, event):
|
|
await self.send_json(
|
|
{
|
|
"type": "draft.update",
|
|
"state": event["state"],
|
|
}
|
|
)
|
|
|
|
# === Draft logic (stubbed for now) ===
|
|
|
|
async def nominate(self, movie_title):
|
|
await self.channel_layer.group_send(
|
|
self.draft_participant_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.draft_participant_group_name,
|
|
{
|
|
"type": "draft.update",
|
|
"state": {"status": "bidding", "bid": {"amount": amount, "user": user}},
|
|
},
|
|
)
|
|
|
|
# === Example DB Access ===
|
|
|
|
@database_sync_to_async
|
|
def add_draft_participant(self):
|
|
self.participant, _ = DraftParticipant.objects.get_or_create(
|
|
user=self.user,
|
|
draft=self.draft_session,
|
|
defaults={"budget": self.draft_session.settings.starting_budget},
|
|
)
|