woggioni
3583c411c3
Repo is now a monorepo:
- server/: the kaya backend, unchanged in behaviour, plus:
- GET /api/me for SPA session detection
- last_move recorded on every play and broadcast in the game state, so
clients can show who played which card the moment they play it
- legal_moves per hand card for the player on turn (rules stay
server-side)
- static catch-all route serving the compiled SPA with index.html
fallback; Tortoise context now bound only for /api/* requests
- configurable OIDC post-login/logout redirects for dev against trunk
- web/: Sycamore 0.9 + WASM frontend (trunk): login via the OIDC flow,
lobby (create match / join by code), live game page over websocket with
card images (CC0 woodcut napoletane deck), capture picker, move banner,
game-over overlay, match history and leaderboard pages
- server/Dockerfile gains a rust+trunk stage building web/dist; the single
app image serves the SPA; compose builds from the repo root with
overridable ports/OIDC env
Verified end-to-end against the compose stack: four OIDC logins, game
creation, three joins by code, websocket play with broadcasts to all
players and out-of-turn rejection. 51 backend tests, mypy and cargo tests
all green.
58 lines
1.8 KiB
Python
58 lines
1.8 KiB
Python
"""Copy finished match results from Redis into Postgres.
|
|
|
|
Called once when a game reaches the finished phase (guarded by the
|
|
``stats_saved`` flag on the state). The write is transactional so a match
|
|
never appears with only some of its players.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import uuid
|
|
from datetime import datetime, timezone
|
|
from typing import Optional
|
|
|
|
from tortoise.transactions import in_transaction
|
|
|
|
from .game.state import PHASE_FINISHED, TEAM_NAMES, GameState
|
|
|
|
|
|
def _parse_timestamp(value: Optional[str]) -> datetime:
|
|
if value:
|
|
try:
|
|
return datetime.fromisoformat(value)
|
|
except ValueError:
|
|
pass
|
|
return datetime.now(timezone.utc)
|
|
|
|
|
|
async def save_match_result(state: GameState) -> None:
|
|
"""Persist ``state`` to Postgres if it is finished and not yet saved."""
|
|
if state.stats_saved or state.phase != PHASE_FINISHED or state.winner is None:
|
|
return
|
|
|
|
from .models import Match, MatchPlayer
|
|
|
|
started_at = _parse_timestamp(state.created_at)
|
|
finished_at = _parse_timestamp(state.finished_at)
|
|
async with in_transaction():
|
|
match = await Match.create(
|
|
id=uuid.uuid4(),
|
|
team_a_score=state.scores[0],
|
|
team_b_score=state.scores[1],
|
|
winner_team=TEAM_NAMES[state.winner],
|
|
target_score=state.target_score,
|
|
hands_played=state.hand_number,
|
|
started_at=started_at,
|
|
finished_at=finished_at,
|
|
)
|
|
for player in state.players:
|
|
await MatchPlayer.create(
|
|
id=uuid.uuid4(),
|
|
match=match,
|
|
user_sub=player.sub,
|
|
display_name=player.name,
|
|
seat=player.seat,
|
|
team=TEAM_NAMES[player.team],
|
|
won=player.team == state.winner,
|
|
)
|
|
state.stats_saved = True
|