Anthony Correa
e8bf313f53
- Added 'react-bootstrap' to frontend dependencies for improved UI components.
- Updated bid placement mechanics: backend now stores bids as a list of {user, amount}; frontend displays live bid leaderboard, including highest bid.
- Implemented bid placement form and UI in participant draft screen.
- Used React-Bootstrap Collapse for nominee menu accordion behavior.
- Expanded DraftStateManager and websocket consumers to broadcast bid updates in the new format.
- Added missing 'bids' syncing to all relevant state handling code.
- Improved styling for bidding, panel headers, and pick lists in SCSS; leveraged Bootstrap variables/utilities more extensively.
- Other minor JS, Python, and style tweaks for better stability and robustness.
255 lines
8.1 KiB
Python
255 lines
8.1 KiB
Python
from django.core.cache import cache
|
|
import json
|
|
from datetime import datetime, timedelta
|
|
from boxofficefantasy.models import Movie
|
|
from django.contrib.auth.models import User
|
|
from draft.constants import DraftPhase
|
|
from draft.models import DraftSession
|
|
import time
|
|
from dataclasses import dataclass
|
|
from typing import Any, Dict, List, Literal, Optional, Sequence, Tuple
|
|
import random
|
|
|
|
class DraftStateException(Exception):
|
|
"""Raised when an action is not allowed due to the current draft state or phase."""
|
|
pass
|
|
|
|
class DraftCacheKeys:
|
|
def __init__(self, id):
|
|
self.prefix = f"draft:{id}"
|
|
|
|
@property
|
|
def admins(self):
|
|
return f"{self.prefix}:admins"
|
|
|
|
@property
|
|
def participants(self):
|
|
return f"{self.prefix}:participants"
|
|
|
|
@property
|
|
def users(self):
|
|
return f"{self.prefix}:users"
|
|
|
|
@property
|
|
def connected_users(self):
|
|
return f"{self.prefix}:connected_users"
|
|
|
|
@property
|
|
def phase(self):
|
|
return f"{self.prefix}:phase"
|
|
|
|
@property
|
|
def draft_order(self):
|
|
return f"{self.prefix}:draft_order"
|
|
|
|
@property
|
|
def draft_index(self):
|
|
return f"{self.prefix}:draft_index"
|
|
|
|
@property
|
|
def current_movie(self):
|
|
return f"{self.prefix}:current_movie"
|
|
|
|
# @property
|
|
# def state(self):
|
|
# return f"{self.prefix}:state"
|
|
|
|
# @property
|
|
# def current_movie(self):
|
|
# return f"{self.prefix}:current_movie"
|
|
|
|
@property
|
|
def bids(self):
|
|
return f"{self.prefix}:bids"
|
|
|
|
# @property
|
|
# def participants(self):
|
|
# return f"{self.prefix}:participants"
|
|
|
|
@property
|
|
def bid_timer_end(self):
|
|
return f"{self.prefix}:bid_timer_end"
|
|
@property
|
|
def bid_timer_start(self):
|
|
return f"{self.prefix}:bid_timer_start"
|
|
|
|
# def user_status(self, user_id):
|
|
# return f"{self.prefix}:user:{user_id}:status"
|
|
|
|
# def user_channel(self, user_id):
|
|
# return f"{self.prefix}:user:{user_id}:channel"
|
|
|
|
class DraftStateManager:
|
|
def __init__(self, session: DraftSession):
|
|
self.session_id = session.hashid
|
|
self.cache = cache
|
|
self.cache_keys = DraftCacheKeys(self.session_id)
|
|
self._initial_phase = self.cache.get(self.cache_keys.phase, DraftPhase.WAITING.value)
|
|
self.settings = session.settings
|
|
self.participants = list(session.participants.all())
|
|
|
|
# === Phase Management ===
|
|
@property
|
|
def phase(self) -> str:
|
|
return str(self.cache.get(self.cache_keys.phase, self._initial_phase))
|
|
|
|
@phase.setter
|
|
def phase(self, new_phase: DraftPhase):
|
|
self.cache.set(self.cache_keys.phase, new_phase.value)
|
|
|
|
# === Connected Users ===
|
|
@property
|
|
def connected_participants(self) -> list[str]:
|
|
return json.loads(self.cache.get(self.cache_keys.connected_users) or "[]")
|
|
|
|
def connect_participant(self, username: str):
|
|
users = set(self.connected_participants)
|
|
users.add(username)
|
|
self.cache.set(self.cache_keys.connected_users, json.dumps(list(users)))
|
|
|
|
def disconnect_participant(self, username: str):
|
|
users = set(self.connected_participants)
|
|
users.discard(username)
|
|
self.cache.set(self.cache_keys.connected_users, json.dumps(list(users)))
|
|
|
|
# === Draft Order ===
|
|
@property
|
|
def draft_order(self):
|
|
return json.loads(self.cache.get(self.cache_keys.draft_order,"[]"))
|
|
|
|
@draft_order.setter
|
|
def draft_order(self, draft_order: list[str]):
|
|
if not isinstance(draft_order, list):
|
|
return
|
|
self.cache.set(self.cache_keys.draft_order,json.dumps(draft_order))
|
|
|
|
def determine_draft_order(self) -> List[User]:
|
|
self.phase = DraftPhase.DETERMINE_ORDER
|
|
self.draft_index = 0
|
|
draft_order = random.sample(
|
|
self.participants, len(self.participants)
|
|
)
|
|
self.draft_order = [user.username for user in draft_order]
|
|
return self.draft_order
|
|
|
|
@property
|
|
def draft_index(self):
|
|
return self.cache.get(self.cache_keys.draft_index,0)
|
|
|
|
@draft_index.setter
|
|
def draft_index(self, draft_index: int):
|
|
self.cache.set(self.cache_keys.draft_index, int(draft_index))
|
|
|
|
def draft_index_advance(self, n: int = 1):
|
|
self.draft_index += n
|
|
return self.draft_index
|
|
|
|
def next_picks(
|
|
self,
|
|
*,
|
|
from_overall: int | None = None,
|
|
count: int | None = None,
|
|
include_current: bool = False,
|
|
) -> List[dict]:
|
|
"""
|
|
Convenience: return the next `count` picks starting after `from_overall`
|
|
(or after current draft_index if omitted). Each item:
|
|
{overall, round, pick_in_round, participant}
|
|
"""
|
|
if not self.draft_order:
|
|
return []
|
|
n = len(self.draft_order)
|
|
count = count if count else len(self.draft_order)
|
|
start = self.draft_index if from_overall is None else int(from_overall)
|
|
start = start if include_current else start + 1
|
|
|
|
out: List[dict] = []
|
|
for overall in range(start, start + count):
|
|
r, p = _round_and_pick(overall, n)
|
|
order_type = "snake"
|
|
order = _round_order(r, order_type, self.draft_order)
|
|
out.append({
|
|
"overall": overall,
|
|
"round": r,
|
|
"pick_in_round": p,
|
|
"participant": order[p - 1],
|
|
})
|
|
return out
|
|
|
|
# === Current Nomination / Bid ===
|
|
def start_nomination(self, movie_id: int):
|
|
self.cache.set(self.cache_keys.current_movie, movie_id)
|
|
self.cache.delete(self.cache_keys.bids)
|
|
|
|
def place_bid(self, user: User, amount: int|str):
|
|
if isinstance(amount, str):
|
|
amount = int(amount)
|
|
bids = self.get_bids()
|
|
bids.append({"user":user.username, "amount":amount})
|
|
self.cache.set(self.cache_keys.bids, json.dumps(bids))
|
|
|
|
def get_bids(self) -> dict:
|
|
return json.loads(self.cache.get(self.cache_keys.bids) or "[]")
|
|
|
|
def current_movie(self) -> Movie | None:
|
|
movie_id = self.cache.get(self.cache_keys.current_movie)
|
|
return Movie.objects.filter(pk=movie_id).first() if movie_id else None
|
|
|
|
def start_bidding(self):
|
|
|
|
seconds = self.settings.bidding_duration
|
|
start_time = time.time()
|
|
end_time = start_time + seconds
|
|
self.cache.set(self.cache_keys.bid_timer_end, end_time)
|
|
self.cache.set(self.cache_keys.bid_timer_start, start_time)
|
|
|
|
def get_timer_end(self) -> str | None:
|
|
return self.cache.get(self.cache_keys.bid_timer_end)
|
|
|
|
def get_timer_start(self) -> str | None:
|
|
return self.cache.get(self.cache_keys.bid_timer_start)
|
|
|
|
# === Sync Snapshot ===
|
|
def to_dict(self) -> dict:
|
|
picks = self.next_picks(include_current=True)
|
|
return {
|
|
"phase": self.phase,
|
|
"draft_order": self.draft_order,
|
|
"draft_index": self.draft_index,
|
|
"connected_participants": self.connected_participants,
|
|
"current_movie": self.cache.get(self.cache_keys.current_movie),
|
|
"bids": self.get_bids(),
|
|
"bidding_timer_end": self.get_timer_end(),
|
|
"bidding_timer_start": self.get_timer_start(),
|
|
"current_pick": picks[0] if picks else None,
|
|
"next_picks": picks[1:] if picks else []
|
|
}
|
|
|
|
# def __dict__(self):
|
|
# return self.get_summary()
|
|
|
|
def keys(self):
|
|
# return an iterable of keys
|
|
return self.to_dict().keys()
|
|
|
|
def __getitem__(self, key):
|
|
return self.to_dict()[key]
|
|
|
|
def __iter__(self):
|
|
# used for `dict(self.draft_state)` and iteration
|
|
return iter(self.to_dict())
|
|
|
|
def __len__(self):
|
|
return len(self.to_dict())
|
|
|
|
OrderType = Literal["snake", "linear"]
|
|
def _round_and_pick(overall: int, n: int) -> Tuple[int, int]:
|
|
"""overall -> (round_1_based, pick_in_round_1_based)"""
|
|
r = overall // n + 1
|
|
p = overall % n + 1
|
|
return r, p
|
|
|
|
def _round_order(round_num: int, order_type: OrderType, r1: Sequence[Any]) -> Sequence[Any]:
|
|
if order_type == "linear" or (round_num % 2 == 1):
|
|
return r1
|
|
return list(reversed(r1)) # even rounds in snake |