Erol Haagenrud
4c0fd666a4
Les add_participant, complete_round, friend_categorization-skjema for design
Design + skriv backend for tre rundevarsler (medspiller lagt til, venn starter synlig runde, tilkoblet runde fullført)
Scratch-verifiser alle tre varseltypene
Oppdater CLAUDE.md status + rull ut mot ekte systemer (med bekreftelse)
Live. Rundevarsler er nå koblet på, ren backend-endring (varslingssenteret hadde allerede round/result-typene klare, bare ingenting skrev dem):
Medspiller lagt til — varsel med lenke til /my-rounds/{id} (full tilgang)
En venn starter en synlig runde — varsel til aksepterte venner som faktisk kan se den (offentlig, eller riktig kategori), lenke til /watch/{id}
Tilkoblet runde fullført — medspillere og tredjeparts-venner varsles, aldri personen som selv fullførte
28/28 nye sjekker + full regresjon av tre eksisterende testsuiter (191 sjekker) grønt. Ingen migrasjon, kun teecup_api redeployet, teeoff.no upåvirket.
3239 lines
147 KiB
Python
3239 lines
147 KiB
Python
"""
|
||
Frittstående rundeføring med detaljert statistikk (ADR-033).
|
||
|
||
Eid av en BRUKER (`app_user.id`), ikke en organisasjon -- INGEN RLS på
|
||
`round`/`round_participant`/`round_hole`/`personal_course*` (Beslutning A).
|
||
Samme mønster som personlig profil/HCP-historikk/sekundær e-post: kun
|
||
`plain_connection()`, autorisasjon håndheves eksplisitt her med
|
||
`WHERE owner_user_id = $1` (eller via round_id -> owner-kjeden).
|
||
|
||
Banedata (Beslutning C): offisielle teeoff-baner slås opp LIVE ved hver
|
||
runde-opprettelse/deltaker-tilføyelse (ingen lokal kopi) via samme
|
||
`teeoff_client` som den org-scopede import-flyten i courses.py bruker --
|
||
men her INGEN `course`/`hole`/`tee`-rader skrives, kun et navn-snapshot
|
||
på selve runden og et rating-snapshot per deltaker.
|
||
|
||
v1-avgrensning (eksplisitt notert i ADR-033, ikke løst her): en deltaker
|
||
med `user_id` satt får IKKE egen tilgang til runden -- derfor støtter
|
||
DENNE runden av API-et kun GJEST-deltakere (fritekstnavn), ikke ekte
|
||
kontokobling. `round_participant.user_id`-kolonnen brukes fortsatt for
|
||
runde-EIEREN (alltid en ekte konto), bare ikke for andre i flighten ennå.
|
||
|
||
HCP: to atskilte tall (ADR-038). `app_user.handicap_index` er MANUELT
|
||
satt, uendret betydning (brukes til Course Handicap i enhver runde med
|
||
mindre eksplisitt overstyrt). `app_user.computed_handicap_index` er det
|
||
FAKTISKE, automatisk beregnede WHS Handicap Index (Rule 5.2) --
|
||
oppdateres av `_recompute_computed_handicap_index()` ved fullføring, ved
|
||
eksklusjons-endring på en allerede fullført runde, og ved fjerning/
|
||
sletting av en tellende deltaker/runde. Kun frittstående runder teller
|
||
med i v1 (se `_gather_qualifying_differentials` for skjøtepunktet mot en
|
||
fremtidig turnering-kilde, ADR-038 Beslutning E).
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import math
|
||
from datetime import date, datetime, timedelta
|
||
from typing import Literal
|
||
|
||
from fastapi import APIRouter, Depends, HTTPException, Query, WebSocket, WebSocketDisconnect
|
||
from pydantic import BaseModel, EmailStr, Field
|
||
|
||
from .. import teeoff_client
|
||
from ..auth import CurrentUser, get_current_user, get_current_user_from_websocket, get_current_user_optional
|
||
from ..db import plain_connection
|
||
from ..errors import app_error, translate_db_errors
|
||
from ..handicap import SIDE_IS_UNIT, parse_allowance_config
|
||
from ..realtime import broadcast_round_update, live_sockets_for_round
|
||
from .notifications import create_notification
|
||
from handicap_engine import (
|
||
HoleResult,
|
||
adjusted_gross_score,
|
||
allocate_over_played_holes,
|
||
allocate_strokes_by_index,
|
||
apply_index_caps,
|
||
compute_match_state,
|
||
compute_skins_detail,
|
||
course_handicap,
|
||
course_handicap_raw,
|
||
handicap_index_from_differentials,
|
||
low_handicap_index,
|
||
match_play_strokes,
|
||
round_counts_for_handicap,
|
||
round_half_up,
|
||
score_differential,
|
||
)
|
||
|
||
_RESULT_LABEL = {HoleResult.SIDE_A: "a", HoleResult.SIDE_B: "b", HoleResult.HALVED: "halved"}
|
||
|
||
# Samme faste kategori-sett som friends.py sin Category (ADR-036 fase 1),
|
||
# duplisert her fremfor importert for å unngå en tvers-router-avhengighet
|
||
# for én enkelt type -- samme pragmatiske valg som skjemaets doble CHECK.
|
||
_FriendCategory = Literal[
|
||
"spouse", "close_family", "extended_family", "close_friends",
|
||
"golf_friends", "colleagues", "business", "classmates",
|
||
"acquaintances", "other",
|
||
]
|
||
|
||
router = APIRouter(tags=["rounds"])
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Global banekatalog for egendefinerte (ikke-teeoff) baner
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class PersonalCourseHoleIn(BaseModel):
|
||
hole_number: int = Field(ge=1, le=18)
|
||
par: int = Field(ge=3, le=6)
|
||
stroke_index: int = Field(ge=1, le=18)
|
||
|
||
|
||
class PersonalCourseTeeRatingIn(BaseModel):
|
||
gender: Literal["m", "f"]
|
||
course_rating: float
|
||
slope_rating: int = Field(ge=55, le=155)
|
||
par: int
|
||
|
||
|
||
class PersonalCourseTeeIn(BaseModel):
|
||
name: str
|
||
ratings: list[PersonalCourseTeeRatingIn] = Field(min_length=1, max_length=2)
|
||
|
||
|
||
class PersonalCourseCreate(BaseModel):
|
||
name: str
|
||
holes: list[PersonalCourseHoleIn] = Field(min_length=18, max_length=18)
|
||
tees: list[PersonalCourseTeeIn] = Field(min_length=1)
|
||
|
||
|
||
class PersonalCourseOut(BaseModel):
|
||
id: str
|
||
name: str
|
||
|
||
|
||
class TeeOption(BaseModel):
|
||
name: str
|
||
genders: list[Literal["m", "f"]]
|
||
|
||
|
||
class PersonalCourseDetail(BaseModel):
|
||
id: str
|
||
name: str
|
||
tees: list[TeeOption]
|
||
|
||
|
||
@router.get("/personal-courses", response_model=list[PersonalCourseOut])
|
||
async def search_personal_courses(
|
||
q: str = "",
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> list[PersonalCourseOut]:
|
||
async with plain_connection() as conn:
|
||
rows = await conn.fetch(
|
||
"SELECT id::text AS id, name FROM personal_course WHERE name ILIKE $1 ORDER BY name LIMIT 20",
|
||
f"%{q.strip()}%",
|
||
)
|
||
return [PersonalCourseOut(**dict(r)) for r in rows]
|
||
|
||
|
||
@router.get("/personal-courses/{personal_course_id}", response_model=PersonalCourseDetail)
|
||
async def get_personal_course(
|
||
personal_course_id: str,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> PersonalCourseDetail:
|
||
async with plain_connection() as conn:
|
||
course_row = await conn.fetchrow("SELECT id::text AS id, name FROM personal_course WHERE id = $1", personal_course_id)
|
||
if course_row is None:
|
||
raise app_error(404, "NOT_FOUND", "Den egendefinerte banen finnes ikke.")
|
||
tee_rows = await conn.fetch(
|
||
"""
|
||
SELECT t.name AS tee_name, r.gender
|
||
FROM personal_course_tee t
|
||
JOIN personal_course_tee_rating r ON r.personal_course_tee_id = t.id
|
||
WHERE t.personal_course_id = $1
|
||
ORDER BY t.name
|
||
""",
|
||
personal_course_id,
|
||
)
|
||
tees: dict[str, list[str]] = {}
|
||
for r in tee_rows:
|
||
tees.setdefault(r["tee_name"], []).append(r["gender"])
|
||
return PersonalCourseDetail(
|
||
id=course_row["id"],
|
||
name=course_row["name"],
|
||
tees=[TeeOption(name=name, genders=genders) for name, genders in tees.items()],
|
||
)
|
||
|
||
|
||
@router.post("/personal-courses", response_model=PersonalCourseOut, status_code=201)
|
||
async def create_personal_course(
|
||
body: PersonalCourseCreate,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> PersonalCourseOut:
|
||
numbers = sorted(h.hole_number for h in body.holes)
|
||
indexes = sorted(h.stroke_index for h in body.holes)
|
||
if numbers != list(range(1, 19)) or indexes != list(range(1, 19)):
|
||
raise app_error(400, "VALIDATION_FAILED", "Alle 18 hullnumre og alle 18 stroke-indekser må være unike, 1-18.")
|
||
|
||
async with plain_connection() as conn, translate_db_errors():
|
||
async with conn.transaction():
|
||
course_row = await conn.fetchrow(
|
||
"INSERT INTO personal_course (name, created_by_user_id) VALUES ($1, $2) RETURNING id::text AS id, name",
|
||
body.name.strip(),
|
||
user.user_id,
|
||
)
|
||
for h in body.holes:
|
||
await conn.execute(
|
||
"INSERT INTO personal_course_hole (personal_course_id, hole_number, par, stroke_index) VALUES ($1, $2, $3, $4)",
|
||
course_row["id"],
|
||
h.hole_number,
|
||
h.par,
|
||
h.stroke_index,
|
||
)
|
||
for t in body.tees:
|
||
tee_row = await conn.fetchrow(
|
||
"INSERT INTO personal_course_tee (personal_course_id, name) VALUES ($1, $2) RETURNING id",
|
||
course_row["id"],
|
||
t.name.strip(),
|
||
)
|
||
for r in t.ratings:
|
||
await conn.execute(
|
||
"""
|
||
INSERT INTO personal_course_tee_rating
|
||
(personal_course_tee_id, gender, course_rating, slope_rating, par)
|
||
VALUES ($1, $2, $3, $4, $5)
|
||
""",
|
||
tee_row["id"],
|
||
r.gender,
|
||
r.course_rating,
|
||
r.slope_rating,
|
||
r.par,
|
||
)
|
||
return PersonalCourseOut(**dict(course_row))
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Offisiell bane fra teeoff (ADR-019/ADR-033 Beslutning C) -- IKKE org-scopet,
|
||
# ulikt courses.py sine tilsvarende endepunkter (frittstående runder har
|
||
# ingen organisasjon). Rent lese-søk, ingen import/persistering av banen.
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class OfficialFacility(BaseModel):
|
||
slug: str
|
||
name: str
|
||
city: str | None
|
||
county: str | None
|
||
|
||
|
||
class OfficialCourseOption(BaseModel):
|
||
teeoff_course_id: int
|
||
name: str
|
||
is_main_course: bool
|
||
tees: list[TeeOption]
|
||
|
||
|
||
class OfficialFacilityDetail(BaseModel):
|
||
slug: str
|
||
name: str
|
||
courses: list[OfficialCourseOption]
|
||
|
||
|
||
@router.get("/rounds/official-search", response_model=list[OfficialFacility])
|
||
async def search_official_courses_for_round(
|
||
q: str = "",
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> list[OfficialFacility]:
|
||
try:
|
||
facilities = await teeoff_client.search_facilities(q)
|
||
except teeoff_client.TeeoffUnavailableError:
|
||
raise app_error(502, "EXTERNAL_SERVICE_UNAVAILABLE", "Klarte ikke å hente baner fra teeoff akkurat nå.")
|
||
return [
|
||
OfficialFacility(slug=f["slug"], name=f["name"], city=f.get("city"), county=f.get("county"))
|
||
for f in facilities
|
||
]
|
||
|
||
|
||
class NearbyFacility(OfficialFacility):
|
||
distance_km: float
|
||
|
||
|
||
def _haversine_km(lat1: float, lng1: float, lat2: float, lng2: float) -> float:
|
||
r = 6371.0
|
||
phi1, phi2 = math.radians(lat1), math.radians(lat2)
|
||
dphi = math.radians(lat2 - lat1)
|
||
dlambda = math.radians(lng2 - lng1)
|
||
a = math.sin(dphi / 2) ** 2 + math.cos(phi1) * math.cos(phi2) * math.sin(dlambda / 2) ** 2
|
||
return 2 * r * math.asin(math.sqrt(a))
|
||
|
||
|
||
# MERK: MÅ registreres FØR /rounds/official-search/{slug} under, ellers
|
||
# tolker FastAPI "nearby" som en ugyldig slug-verdi til den ruten (samme
|
||
# lærdom som ADR-020s "by-code" måtte registreres før {tournament_id}).
|
||
@router.get("/rounds/official-search/nearby", response_model=list[NearbyFacility])
|
||
async def nearby_official_courses_for_round(
|
||
lat: float = Query(...),
|
||
lng: float = Query(...),
|
||
limit: int = Query(default=5, ge=1, le=20),
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> list[NearbyFacility]:
|
||
try:
|
||
facilities = await teeoff_client.search_facilities("")
|
||
except teeoff_client.TeeoffUnavailableError:
|
||
raise app_error(502, "EXTERNAL_SERVICE_UNAVAILABLE", "Klarte ikke å hente baner fra teeoff akkurat nå.")
|
||
with_coords = [f for f in facilities if f.get("lat") is not None and f.get("lng") is not None]
|
||
scored = sorted(with_coords, key=lambda f: _haversine_km(lat, lng, f["lat"], f["lng"]))
|
||
return [
|
||
NearbyFacility(
|
||
slug=f["slug"], name=f["name"], city=f.get("city"), county=f.get("county"),
|
||
distance_km=round(_haversine_km(lat, lng, f["lat"], f["lng"]), 1),
|
||
)
|
||
for f in scored[:limit]
|
||
]
|
||
|
||
|
||
@router.get("/rounds/official-search/{slug}", response_model=OfficialFacilityDetail)
|
||
async def get_official_facility_for_round(
|
||
slug: str,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> OfficialFacilityDetail:
|
||
try:
|
||
facility = await teeoff_client.get_facility(slug)
|
||
except teeoff_client.TeeoffNotFoundError:
|
||
raise app_error(404, "NOT_FOUND", "Anlegget finnes ikke i teeoff.")
|
||
except teeoff_client.TeeoffUnavailableError:
|
||
raise app_error(502, "EXTERNAL_SERVICE_UNAVAILABLE", "Klarte ikke å hente baneinfo fra teeoff akkurat nå.")
|
||
|
||
courses: list[OfficialCourseOption] = []
|
||
for c in facility.get("courses", []):
|
||
if len(c.get("holes") or []) != 18:
|
||
continue
|
||
tees: list[TeeOption] = []
|
||
for t in c.get("tees") or []:
|
||
genders: list[str] = []
|
||
if t.get("cr_men") is not None and t.get("slope_men") is not None:
|
||
genders.append("m")
|
||
if t.get("cr_women") is not None and t.get("slope_women") is not None:
|
||
genders.append("f")
|
||
if genders:
|
||
tees.append(TeeOption(name=t.get("name") or "Tee", genders=genders))
|
||
courses.append(
|
||
OfficialCourseOption(
|
||
teeoff_course_id=c["id"],
|
||
name=c["name"],
|
||
is_main_course=bool(c.get("is_main_course")),
|
||
tees=tees,
|
||
)
|
||
)
|
||
return OfficialFacilityDetail(slug=facility["slug"], name=facility["name"], courses=courses)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Banedata-oppslag (delt mellom opprett-runde og legg-til-deltaker)
|
||
# ---------------------------------------------------------------------------
|
||
#
|
||
# Returnerer (par_per_hole, stroke_index_per_hole, tee_names) og en
|
||
# funksjon for å slå opp (course_rating, slope_rating, par) for en gitt
|
||
# tee+kjønn -- felles for BÅDE teeoff (live) og personal_course (lagret).
|
||
|
||
class _ResolvedCourse:
|
||
def __init__(self, holes: list[tuple[int, int, int]], course_name: str):
|
||
# holes: liste av (hole_number, par, stroke_index), sortert 1..18
|
||
self.holes = holes
|
||
self.course_name = course_name
|
||
self._ratings: dict[tuple[str, str], tuple[float, int, int]] = {}
|
||
|
||
def add_rating(self, tee_name: str, gender: str, course_rating: float, slope_rating: int, par: int) -> None:
|
||
self._ratings[(tee_name, gender)] = (course_rating, slope_rating, par)
|
||
|
||
def rating_for(self, tee_name: str, gender: str) -> tuple[float, int, int] | None:
|
||
return self._ratings.get((tee_name, gender))
|
||
|
||
def tee_options(self) -> list["TeeOption"]:
|
||
names: dict[str, list[Literal["m", "f"]]] = {}
|
||
for tee_name, gender in self._ratings:
|
||
names.setdefault(tee_name, []).append(gender) # type: ignore[arg-type]
|
||
return [TeeOption(name=n, genders=sorted(g)) for n, g in names.items()]
|
||
|
||
|
||
async def _resolve_teeoff_course(facility_slug: str, teeoff_course_id: int) -> _ResolvedCourse:
|
||
try:
|
||
facility = await teeoff_client.get_facility(facility_slug)
|
||
except teeoff_client.TeeoffNotFoundError:
|
||
raise app_error(404, "NOT_FOUND", "Anlegget finnes ikke i teeoff.")
|
||
except teeoff_client.TeeoffUnavailableError:
|
||
raise app_error(502, "EXTERNAL_SERVICE_UNAVAILABLE", "Klarte ikke å hente baneinfo fra teeoff akkurat nå.")
|
||
|
||
course_data = next((c for c in facility.get("courses", []) if c.get("id") == teeoff_course_id), None)
|
||
if course_data is None:
|
||
raise app_error(404, "NOT_FOUND", "Banen finnes ikke på dette anlegget i teeoff.")
|
||
|
||
raw_holes = course_data.get("holes") or []
|
||
if len(raw_holes) != 18:
|
||
raise app_error(400, "EXTERNAL_DATA_INCOMPLETE", "Banen har ikke 18 registrerte hull i teeoff ennå.")
|
||
for h in raw_holes:
|
||
if h.get("par") is None or h.get("hcp_index") is None:
|
||
raise app_error(400, "EXTERNAL_DATA_INCOMPLETE", "Banen mangler par eller HCP-index på ett eller flere hull.")
|
||
|
||
# Samme "kun ett banenavn -- hopp over duplikat anleggsnavn"-regel som
|
||
# `courses.py` sin `import_official_course` (2026-07-25).
|
||
if len(facility.get("courses", [])) == 1:
|
||
course_name = facility.get("name") or "Bane"
|
||
else:
|
||
course_name = f"{facility.get('name')} – {course_data.get('name') or 'Bane'}"
|
||
resolved = _ResolvedCourse(
|
||
holes=sorted((h["hole_number"], h["par"], h["hcp_index"]) for h in raw_holes),
|
||
course_name=course_name,
|
||
)
|
||
for t in course_data.get("tees") or []:
|
||
name = t.get("name") or "Tee"
|
||
if t.get("cr_men") is not None and t.get("slope_men") is not None:
|
||
resolved.add_rating(name, "m", float(t["cr_men"]), int(t["slope_men"]), sum(h[1] for h in resolved.holes))
|
||
if t.get("cr_women") is not None and t.get("slope_women") is not None:
|
||
resolved.add_rating(name, "f", float(t["cr_women"]), int(t["slope_women"]), sum(h[1] for h in resolved.holes))
|
||
return resolved
|
||
|
||
|
||
async def _resolve_personal_course(personal_course_id: str) -> _ResolvedCourse:
|
||
async with plain_connection() as conn:
|
||
course_row = await conn.fetchrow("SELECT name FROM personal_course WHERE id = $1", personal_course_id)
|
||
if course_row is None:
|
||
raise app_error(404, "NOT_FOUND", "Den egendefinerte banen finnes ikke.")
|
||
hole_rows = await conn.fetch(
|
||
"SELECT hole_number, par, stroke_index FROM personal_course_hole WHERE personal_course_id = $1",
|
||
personal_course_id,
|
||
)
|
||
tee_rows = await conn.fetch(
|
||
"""
|
||
SELECT t.name AS tee_name, r.gender, r.course_rating, r.slope_rating, r.par
|
||
FROM personal_course_tee t
|
||
JOIN personal_course_tee_rating r ON r.personal_course_tee_id = t.id
|
||
WHERE t.personal_course_id = $1
|
||
""",
|
||
personal_course_id,
|
||
)
|
||
resolved = _ResolvedCourse(
|
||
holes=sorted((h["hole_number"], h["par"], h["stroke_index"]) for h in hole_rows),
|
||
course_name=course_row["name"],
|
||
)
|
||
for t in tee_rows:
|
||
resolved.add_rating(t["tee_name"], t["gender"], float(t["course_rating"]), t["slope_rating"], t["par"])
|
||
return resolved
|
||
|
||
|
||
async def _resolve_round_course(round_row) -> _ResolvedCourse:
|
||
if round_row["course_source"] == "teeoff":
|
||
return await _resolve_teeoff_course(round_row["teeoff_facility_slug"], int(round_row["teeoff_course_id"]))
|
||
return await _resolve_personal_course(round_row["personal_course_id"])
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Sider og match-play-håndtering (ADR-039) -- porterer det allerede
|
||
# bevisste, produksjonskjørte mønsteret fra `app/handicap.py` sin
|
||
# `compute_and_store_side_handicaps`/`relative_strokes_for_match`
|
||
# (org-scopede turnering-matcher) til frittstående runder. SAMME motor
|
||
# (handicap_engine.py), samme allowance-familie -- ingen ny regnelogikk
|
||
# for match/fourball/foursome/greensome/scramble, kun andre tabeller.
|
||
# Ingen allowance_override-støtte i v1 (kun DEFAULT_MATCHPLAY_ALLOWANCES).
|
||
# ---------------------------------------------------------------------------
|
||
|
||
async def _recompute_side_handicaps(conn, round_id: str, play_format: str) -> None:
|
||
"""Beregn og lagre round_participant.playing_handicap for begge sider.
|
||
|
||
Rører ALDRI course_handicap_snapshot (den absolutte, individuelle WHS-
|
||
verdien -- brukt uendret av slagspill-pipelinen) -- playing_handicap er
|
||
en egen, ny kolonne kun for den format-relative match-play-enheten.
|
||
"""
|
||
engine_format = _ROUND_FORMAT_TO_ENGINE_FORMAT[play_format]
|
||
config = parse_allowance_config(engine_format, None)
|
||
expected = _SIDE_PLAYER_COUNT[play_format]
|
||
|
||
sides = await conn.fetch("SELECT id::text AS id FROM round_side WHERE round_id = $1", round_id)
|
||
for side in sides:
|
||
participants = await conn.fetch(
|
||
"SELECT id::text AS id, course_handicap_snapshot FROM round_participant WHERE round_side_id = $1",
|
||
side["id"],
|
||
)
|
||
if len(participants) != expected or any(p["course_handicap_snapshot"] is None for p in participants):
|
||
continue # ikke komplett ennå, eller mangler HCP-sporing for noen
|
||
|
||
if not config.use_handicap:
|
||
for p in participants:
|
||
await conn.execute("UPDATE round_participant SET playing_handicap = 0 WHERE id = $1", p["id"])
|
||
continue
|
||
|
||
course_handicaps = [float(p["course_handicap_snapshot"]) for p in participants]
|
||
if engine_format in SIDE_IS_UNIT:
|
||
playing = config.strategy.playing_handicap(course_handicaps)
|
||
for p in participants:
|
||
await conn.execute("UPDATE round_participant SET playing_handicap = $1 WHERE id = $2", playing, p["id"])
|
||
else:
|
||
for p, ch in zip(participants, course_handicaps):
|
||
playing = config.strategy.playing_handicap([ch])
|
||
await conn.execute("UPDATE round_participant SET playing_handicap = $1 WHERE id = $2", playing, p["id"])
|
||
|
||
|
||
async def _relative_strokes_for_round(conn, round_id: str, play_format: str) -> dict[str, int]:
|
||
"""Relative slag per scoringsenhet (porterer relative_strokes_for_match).
|
||
|
||
Nøkkel = round_participant_id for match/fourball (fourball: begge sidene
|
||
samlet i ÉN liste før match_play_strokes, jf. R&A-regelen om at laveste
|
||
av alle fire spiller av scratch). Nøkkel = round_side_id for foursome/
|
||
greensome/scramble. Returnerer {} hvis playing_handicap ikke er klart
|
||
for én eller flere enheter ennå.
|
||
"""
|
||
engine_format = _ROUND_FORMAT_TO_ENGINE_FORMAT[play_format]
|
||
config = parse_allowance_config(engine_format, None)
|
||
|
||
if engine_format in SIDE_IS_UNIT:
|
||
rows = await conn.fetch(
|
||
"""
|
||
SELECT DISTINCT ON (round_side_id) round_side_id::text AS unit, playing_handicap
|
||
FROM round_participant WHERE round_id = $1 AND round_side_id IS NOT NULL
|
||
ORDER BY round_side_id
|
||
""",
|
||
round_id,
|
||
)
|
||
else:
|
||
rows = await conn.fetch(
|
||
"SELECT id::text AS unit, playing_handicap FROM round_participant "
|
||
"WHERE round_id = $1 AND round_side_id IS NOT NULL",
|
||
round_id,
|
||
)
|
||
|
||
if not rows or any(r["playing_handicap"] is None for r in rows):
|
||
return {}
|
||
|
||
absolutes = [r["playing_handicap"] for r in rows]
|
||
relative = match_play_strokes(absolutes) if config.use_matchplay_handicap else absolutes
|
||
return {r["unit"]: v for r, v in zip(rows, relative)}
|
||
|
||
|
||
async def _check_side_capacity(
|
||
conn, side_id: str, play_format: str, exclude_participant_id: str | None = None
|
||
) -> None:
|
||
"""Avvis tydelig FØR en deltaker tildeles en side som allerede har
|
||
forventet antall spillere for formatet (2026-07-28 oppfølging) -- i
|
||
stedet for å oppdage overtallet først ved fullføring. `exclude_
|
||
participant_id` unngår at en deltaker som allerede ER på siden (f.eks.
|
||
en no-op-reassignment til samme side) teller seg selv ut av plass."""
|
||
expected = _SIDE_PLAYER_COUNT[play_format]
|
||
current_count = await conn.fetchval(
|
||
"SELECT count(*) FROM round_participant WHERE round_side_id = $1 AND id != $2",
|
||
side_id, exclude_participant_id or "00000000-0000-0000-0000-000000000000",
|
||
)
|
||
if current_count >= expected:
|
||
raise app_error(
|
||
409, "SIDE_FULL",
|
||
f"Denne siden har allerede {expected} spiller(e) -- maks for {play_format}.",
|
||
)
|
||
|
||
|
||
async def _format_setup_status(conn, round_id: str, play_format: str) -> tuple[bool, str | None]:
|
||
"""Er rundens deltaker-/side-oppsett komplett for FORMATET (2026-07-28
|
||
oppfølging): match/skins/fourball/foursome/greensome/scramble krever
|
||
flere spillere enn slagspill -- ingenting fanget dette opp før nå.
|
||
Returnerer (komplett, forklarende melding hvis ikke)."""
|
||
if play_format == "stroke":
|
||
return True, None
|
||
|
||
if play_format == "skins":
|
||
total = await conn.fetchval("SELECT count(*) FROM round_participant WHERE round_id = $1", round_id)
|
||
if total < _SKINS_MIN_PARTICIPANTS:
|
||
return False, f"Skins krever minst {_SKINS_MIN_PARTICIPANTS} spillere -- runden har {total}."
|
||
return True, None
|
||
|
||
# To-sidede formater (match/fourball/foursome/greensome/scramble_*).
|
||
expected = _SIDE_PLAYER_COUNT[play_format]
|
||
sides = await conn.fetch("SELECT id::text AS id, label FROM round_side WHERE round_id = $1 ORDER BY id", round_id)
|
||
if len(sides) != 2:
|
||
return False, "Denne spilleformen krever nøyaktig to sider -- opprett begge før runden fullføres."
|
||
|
||
unassigned = await conn.fetchval(
|
||
"SELECT count(*) FROM round_participant WHERE round_id = $1 AND round_side_id IS NULL", round_id
|
||
)
|
||
if unassigned > 0:
|
||
return False, f"{unassigned} deltaker(e) er ikke tildelt noen side ennå."
|
||
|
||
for side in sides:
|
||
count = await conn.fetchval("SELECT count(*) FROM round_participant WHERE round_side_id = $1", side["id"])
|
||
if count != expected:
|
||
label = side["label"] or "En side"
|
||
return False, f"{label} har {count} spiller(e), men trenger nøyaktig {expected}."
|
||
return True, None
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Runder
|
||
# ---------------------------------------------------------------------------
|
||
|
||
# Statistikknivå per deltaker (2026-07-24): kun slag er strengt tatt
|
||
# nødvendig for resultat/HCP -- putter og "flere detaljer" er valgfritt,
|
||
# av som default. GIR krever putts og vises derfor ikke i strokes_only.
|
||
StatLevel = Literal["strokes_only", "strokes_and_putts", "full"]
|
||
|
||
# ADR-039: formater som bruker et to-siders-konsept (Beslutning A). "match"
|
||
# er rundens eget navn for singles match play -- mappes til motorens eget
|
||
# Format-enum-navn ("singles") kun når handicap_engine.py/app.handicap
|
||
# kalles, ikke noe sted ellers.
|
||
_TWO_SIDED_FORMATS = {"match", "fourball", "foursome", "greensome", "scramble_2", "scramble_4"}
|
||
_ROUND_FORMAT_TO_ENGINE_FORMAT = {
|
||
"match": "singles",
|
||
"fourball": "fourball",
|
||
"foursome": "foursome",
|
||
"greensome": "greensome",
|
||
"scramble_2": "scramble_2",
|
||
"scramble_4": "scramble_4",
|
||
}
|
||
# Antall SPILLERE forventet per side -- IKKE det samme som app.handicap sin
|
||
# FORMAT_UNIT_SIZE (som er HCP-BEREGNINGS-enheten: fourball beregnes
|
||
# individuelt der, men har likevel 2 spillere per side for selve
|
||
# matchresultat-sammenligningen).
|
||
_SIDE_PLAYER_COUNT = {"match": 1, "fourball": 2, "foursome": 2, "greensome": 2, "scramble_2": 2, "scramble_4": 4}
|
||
# Bekreftet av bruker (2026-07-28): 2 spillere gjør skins i praksis
|
||
# identisk med en vanlig match -- 3+ er der en oppsamlet, uavgjort pott
|
||
# faktisk gir mening som eget spillformat.
|
||
_SKINS_MIN_PARTICIPANTS = 3
|
||
|
||
|
||
class RoundCreate(BaseModel):
|
||
course_source: Literal["teeoff", "custom"]
|
||
teeoff_facility_slug: str | None = None
|
||
teeoff_course_id: int | None = None
|
||
personal_course_id: str | None = None
|
||
tee_name: str
|
||
# Valgfritt eget navn på runden (2026-07-25) -- mangler det, faller
|
||
# visningen tilbake til course_name_snapshot, som alltid er satt.
|
||
name: str | None = Field(default=None, max_length=200)
|
||
played_at: date
|
||
start_hole: int = Field(default=1, ge=1, le=18)
|
||
holes_planned: Literal[9, 18] = 18
|
||
stat_level: StatLevel = "strokes_only"
|
||
# Utslagstidspunkt (2026-07-24) -- valgfritt, brukt til å beregne
|
||
# tidsbruk (completed_at - started_at) når runden fullføres.
|
||
started_at: datetime | None = None
|
||
# Selvdeklarert spilleform (ADR-038 Beslutning D, utvidet ADR-039) --
|
||
# ingen egen "oppdag selv"-motor for frittstående runder, så dette taes
|
||
# brukerens ord for. match/fourball/foursome/greensome/scramble_*
|
||
# trenger sider (opprettes separat via POST .../sides, se ADR-039
|
||
# Beslutning A) -- IKKE noe som settes opp i selve opprett-kallet.
|
||
play_format: Literal[
|
||
"stroke", "match", "skins", "fourball", "foursome", "greensome", "scramble_2", "scramble_4"
|
||
] = "stroke"
|
||
# Frontend forhåndsutfyller denne til True når play_format='match'
|
||
# (anbefalt, men overstyrbart) -- eierens EGEN rad ved opprettelse.
|
||
exclude_owner_from_handicap: bool = False
|
||
# KUN meningsfulle (og påkrevd) når play_format='skins' -- ADR-039
|
||
# Beslutning D. Brukeren som setter opp runden velger begge uavhengig.
|
||
skins_scoring: Literal["net", "gross"] | None = None
|
||
skins_tie_handling: Literal["carry", "split"] | None = None
|
||
# ADR-036 Beslutning B (fase 2, 2026-07-28) -- styrer KUN tredjeparts
|
||
# innsyn (venner/offentligheten). Trygg standard 'private', samme
|
||
# filosofi som RLS-policyenes "se ingenting" ved manglende kontekst.
|
||
# En lagt-til medspiller ser ALLTID runden uansett, uendret av dette.
|
||
visibility_mode: Literal["public", "private", "friends"] = "private"
|
||
# KUN meningsfullt (og bør være ikke-tom) når visibility_mode='friends'
|
||
# -- hvilke av EGNE private kategorier (se friends.py sin Category) som
|
||
# får se runden. Tomt/utelatt for public/private.
|
||
visible_categories: list[_FriendCategory] = []
|
||
|
||
|
||
class RoundParticipantOut(BaseModel):
|
||
id: str
|
||
user_id: str | None
|
||
guest_name: str | None
|
||
# Valgfritt kontaktfelt, KUN for gjester (2026-07-26) -- ingen betydning
|
||
# for en lenket bruker, som allerede har sin egen kontos e-post.
|
||
guest_email: str | None
|
||
# Alltid utfylt -- guest_name for gjester, ellers en LEVENDE oppslått
|
||
# app_user.display_name for enhver lenket bruker (eier ELLER medspiller,
|
||
# ADR-036 fase 3-utvidelsen 2026-07-26) -- ikke en snapshot, samme
|
||
# "vis gjeldende navn"-mønster som org-medlemslister/chat-forfatter.
|
||
display_name: str
|
||
is_owner: bool
|
||
gender: str
|
||
# Per-deltaker utslagssted (2026-07-26) -- kan avvike fra en annen
|
||
# deltakers, f.eks. et kjønnsdelt utslag eller et bevisst enklere valg.
|
||
# Redigerbar av eieren via PATCH .../participants/{id}, kun for DENNE
|
||
# runden (endrer aldri spillerens profil).
|
||
tee_name_snapshot: str
|
||
handicap_index_snapshot: float | None
|
||
course_handicap_snapshot: int | None
|
||
counts_for_handicap: bool
|
||
score_differential: float | None
|
||
stat_level: StatLevel
|
||
# ADR-038 Beslutning C -- manuell opt-out, uavhengig av
|
||
# counts_for_handicap. Kontrolleres av DENNE deltakeren selv (eller
|
||
# runde-eieren), se update_participant.
|
||
exclude_from_handicap: bool
|
||
# ADR-039 Beslutning A -- hvilken side deltakeren er på (match/fourball/
|
||
# foursome/greensome/scramble_*), null for slagspill/skins (ingen sider).
|
||
round_side_id: str | None
|
||
# ADR-039 Beslutning B -- den format-avledede, RELATIVE match-play-
|
||
# enheten (fra AllowanceStrategy), IKKE samme som course_handicap_
|
||
# snapshot (som forblir den absolutte, individuelle WHS-verdien).
|
||
playing_handicap: int | None
|
||
|
||
|
||
class RoundSideOut(BaseModel):
|
||
id: str
|
||
label: str | None
|
||
|
||
|
||
class RoundOut(BaseModel):
|
||
id: str
|
||
course_source: str
|
||
name: str | None
|
||
course_name_snapshot: str
|
||
tee_name_snapshot: str
|
||
played_at: date
|
||
start_hole: int
|
||
holes_planned: int
|
||
play_format: str
|
||
skins_scoring: str | None
|
||
skins_tie_handling: str | None
|
||
started_at: str | None
|
||
completed_at: str | None
|
||
participants: list[RoundParticipantOut]
|
||
# ADR-039 Beslutning A -- tom liste for formater uten sider (slagspill/skins).
|
||
sides: list[RoundSideOut]
|
||
# 2026-07-28 oppfølging -- match/skins/fourball/foursome/greensome/
|
||
# scramble krever flere spillere enn slagspill, håndhevet i
|
||
# complete_round. setup_message er None når setup_complete er sann.
|
||
setup_complete: bool
|
||
setup_message: str | None
|
||
# Den SPØRRENDE brukerens (eier ELLER en lenket medspiller, ADR-036
|
||
# fase 3-utvidelsen 2026-07-26) egen fremdrift/score, utledet fra
|
||
# round_hole (aldri lagret) -- omdøpt fra `owner_*` til `my_*` samme
|
||
# dag, siden feltet nå er VIEWER-relativt, ikke alltid eierens.
|
||
# `my_score_to_par` er None helt til minst ett hull er registrert.
|
||
my_holes_played: int
|
||
my_total_score: int | None
|
||
my_score_to_par: int | None
|
||
# ADR-036 Beslutning B (fase 2, 2026-07-28) -- kun eieren (eller en
|
||
# medspiller, som ser dette som ren informasjon) trenger å se/endre
|
||
# disse -- eksponert her siden dette ER den autentiserte eier-/
|
||
# medspiller-endepunktet (GET /rounds/{id}), ikke tredjepartsvisningen.
|
||
visibility_mode: str
|
||
visible_categories: list[str]
|
||
|
||
|
||
async def _load_round_out(conn, round_id: str, viewer_user_id: str) -> RoundOut:
|
||
round_row = await conn.fetchrow(
|
||
"""
|
||
SELECT id::text AS id, course_source, name, course_name_snapshot, tee_name_snapshot,
|
||
played_at, start_hole, holes_planned, play_format, skins_scoring, skins_tie_handling,
|
||
started_at, completed_at, visibility_mode
|
||
FROM round WHERE id = $1
|
||
""",
|
||
round_id,
|
||
)
|
||
visible_category_rows = await conn.fetch(
|
||
"SELECT category FROM round_visible_category WHERE round_id = $1", round_id
|
||
)
|
||
participant_rows = await conn.fetch(
|
||
"""
|
||
SELECT rp.id::text AS id, rp.user_id::text AS user_id, rp.guest_name, rp.guest_email,
|
||
COALESCE(rp.guest_name, au.display_name, 'Medspiller') AS display_name,
|
||
rp.is_owner, rp.gender, rp.tee_name_snapshot,
|
||
rp.handicap_index_snapshot::float AS handicap_index_snapshot,
|
||
rp.course_handicap_snapshot, rp.counts_for_handicap,
|
||
rp.score_differential::float AS score_differential, rp.stat_level,
|
||
rp.exclude_from_handicap, rp.round_side_id::text AS round_side_id,
|
||
rp.playing_handicap
|
||
FROM round_participant rp
|
||
LEFT JOIN app_user au ON au.id = rp.user_id
|
||
WHERE rp.round_id = $1 ORDER BY rp.is_owner DESC, rp.created_at
|
||
""",
|
||
round_id,
|
||
)
|
||
side_rows = await conn.fetch(
|
||
"SELECT id::text AS id, label FROM round_side WHERE round_id = $1 ORDER BY id", round_id
|
||
)
|
||
# Viewer-relativt (ADR-036 fase 3-utvidelsen 2026-07-26): en lenket
|
||
# medspiller som ser SIN EGEN "Egne runder"-liste skal se SIN EGEN
|
||
# fremdrift her, ikke alltid eierens. Faller tilbake til eierens rad
|
||
# i det usannsynlige tilfellet spørreren ikke har noen egen
|
||
# deltaker-rad (bør ikke skje, siden tilgang allerede er gatet til
|
||
# eier-eller-deltaker av kallerne).
|
||
viewer_participant_id = next((r["id"] for r in participant_rows if r["user_id"] == viewer_user_id), None)
|
||
target_id = viewer_participant_id or next((r["id"] for r in participant_rows if r["is_owner"]), None)
|
||
viewer_agg = await conn.fetchrow(
|
||
"""
|
||
SELECT COUNT(*) FILTER (WHERE played) AS played_count,
|
||
COALESCE(SUM(score) FILTER (WHERE played), 0) AS total_score,
|
||
COALESCE(SUM(par) FILTER (WHERE played), 0) AS total_par
|
||
FROM round_hole WHERE round_participant_id = $1
|
||
""",
|
||
target_id,
|
||
)
|
||
my_holes_played = viewer_agg["played_count"] if viewer_agg else 0
|
||
my_total_score = viewer_agg["total_score"] if my_holes_played > 0 else None
|
||
my_score_to_par = (
|
||
viewer_agg["total_score"] - viewer_agg["total_par"] if my_holes_played > 0 else None
|
||
)
|
||
setup_complete, setup_message = await _format_setup_status(conn, round_id, round_row["play_format"])
|
||
return RoundOut(
|
||
id=round_row["id"],
|
||
course_source=round_row["course_source"],
|
||
name=round_row["name"],
|
||
course_name_snapshot=round_row["course_name_snapshot"],
|
||
tee_name_snapshot=round_row["tee_name_snapshot"],
|
||
played_at=round_row["played_at"],
|
||
start_hole=round_row["start_hole"],
|
||
holes_planned=round_row["holes_planned"],
|
||
play_format=round_row["play_format"],
|
||
skins_scoring=round_row["skins_scoring"],
|
||
skins_tie_handling=round_row["skins_tie_handling"],
|
||
started_at=round_row["started_at"].isoformat() if round_row["started_at"] else None,
|
||
completed_at=round_row["completed_at"].isoformat() if round_row["completed_at"] else None,
|
||
participants=[RoundParticipantOut(**dict(r)) for r in participant_rows],
|
||
sides=[RoundSideOut(**dict(r)) for r in side_rows],
|
||
setup_complete=setup_complete,
|
||
setup_message=setup_message,
|
||
my_holes_played=my_holes_played,
|
||
my_total_score=my_total_score,
|
||
my_score_to_par=my_score_to_par,
|
||
visibility_mode=round_row["visibility_mode"],
|
||
visible_categories=[r["category"] for r in visible_category_rows],
|
||
)
|
||
|
||
|
||
async def _create_participant(
|
||
conn,
|
||
round_id: str,
|
||
resolved: _ResolvedCourse,
|
||
tee_name: str,
|
||
*,
|
||
user_id: str | None,
|
||
guest_name: str | None,
|
||
is_owner: bool,
|
||
gender: str,
|
||
handicap_index: float | None,
|
||
stat_level: StatLevel = "strokes_only",
|
||
guest_email: str | None = None,
|
||
exclude_from_handicap: bool = False,
|
||
round_side_id: str | None = None,
|
||
individual_round_hole: bool = True,
|
||
) -> str:
|
||
rating = resolved.rating_for(tee_name, gender)
|
||
course_rating = slope_rating = tee_par = None
|
||
course_handicap_snapshot = None
|
||
if rating is not None:
|
||
course_rating, slope_rating, tee_par = rating
|
||
if handicap_index is not None:
|
||
course_handicap_snapshot = course_handicap(handicap_index, slope_rating, course_rating, tee_par)
|
||
|
||
participant_row = await conn.fetchrow(
|
||
"""
|
||
INSERT INTO round_participant
|
||
(round_id, user_id, guest_name, guest_email, is_owner, gender, tee_name_snapshot, handicap_index_snapshot,
|
||
course_rating_snapshot, slope_rating_snapshot, tee_par_snapshot, course_handicap_snapshot,
|
||
stat_level, exclude_from_handicap, round_side_id)
|
||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
|
||
RETURNING id::text AS id
|
||
""",
|
||
round_id,
|
||
user_id,
|
||
guest_name,
|
||
guest_email,
|
||
is_owner,
|
||
gender,
|
||
tee_name,
|
||
handicap_index,
|
||
course_rating,
|
||
slope_rating,
|
||
tee_par,
|
||
course_handicap_snapshot,
|
||
stat_level,
|
||
exclude_from_handicap,
|
||
round_side_id,
|
||
)
|
||
participant_id = participant_row["id"]
|
||
|
||
# ADR-039 Beslutning C -- delt-ball-formater (foursome/greensome/
|
||
# scramble) lagrer scoren PÅ SIDEN (round_hole.round_side_id, opprettet
|
||
# samtidig med selve siden, se create_round_side), ikke per deltaker --
|
||
# ingen individuelle round_hole-rader for disse.
|
||
if individual_round_hole:
|
||
for hole_number, par, stroke_index in resolved.holes:
|
||
await conn.execute(
|
||
"INSERT INTO round_hole (round_participant_id, hole_number, par, stroke_index) VALUES ($1, $2, $3, $4)",
|
||
participant_id,
|
||
hole_number,
|
||
par,
|
||
stroke_index,
|
||
)
|
||
return participant_id
|
||
|
||
|
||
@router.post("/rounds", response_model=RoundOut, status_code=201)
|
||
async def create_round(
|
||
body: RoundCreate,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> RoundOut:
|
||
if body.course_source == "teeoff":
|
||
if not body.teeoff_facility_slug or not body.teeoff_course_id:
|
||
raise app_error(400, "VALIDATION_FAILED", "teeoff_facility_slug og teeoff_course_id er påkrevd.")
|
||
resolved = await _resolve_teeoff_course(body.teeoff_facility_slug, body.teeoff_course_id)
|
||
else:
|
||
if not body.personal_course_id:
|
||
raise app_error(400, "VALIDATION_FAILED", "personal_course_id er påkrevd.")
|
||
resolved = await _resolve_personal_course(body.personal_course_id)
|
||
|
||
# ADR-039 Beslutning D -- skins-konfigurasjon er påkrevd for skins, og
|
||
# gir ikke mening for noe annet format.
|
||
if body.play_format == "skins":
|
||
if body.skins_scoring is None or body.skins_tie_handling is None:
|
||
raise app_error(
|
||
400, "VALIDATION_FAILED",
|
||
"skins_scoring og skins_tie_handling er påkrevd når play_format='skins'.",
|
||
)
|
||
elif body.skins_scoring is not None or body.skins_tie_handling is not None:
|
||
raise app_error(400, "VALIDATION_FAILED", "skins_scoring/skins_tie_handling gir kun mening for play_format='skins'.")
|
||
|
||
async with plain_connection() as conn:
|
||
owner_row = await conn.fetchrow(
|
||
"SELECT gender, handicap_index::float AS handicap_index FROM app_user WHERE id = $1",
|
||
user.user_id,
|
||
)
|
||
if owner_row is None or owner_row["gender"] is None:
|
||
raise app_error(400, "VALIDATION_FAILED", "Fullfør profilen din (kjønn/HCP) før du registrerer en runde.")
|
||
|
||
if resolved.rating_for(body.tee_name, owner_row["gender"]) is None:
|
||
raise app_error(
|
||
400, "VALIDATION_FAILED",
|
||
"Valgt utslag har ingen rating for ditt registrerte kjønn på denne banen.",
|
||
)
|
||
|
||
async with conn.transaction(), translate_db_errors():
|
||
round_row = await conn.fetchrow(
|
||
"""
|
||
INSERT INTO round
|
||
(owner_user_id, course_source, teeoff_facility_slug, teeoff_course_id,
|
||
personal_course_id, course_name_snapshot, tee_name_snapshot, played_at,
|
||
start_hole, holes_planned, started_at, name, play_format,
|
||
skins_scoring, skins_tie_handling, visibility_mode)
|
||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
|
||
RETURNING id::text AS id
|
||
""",
|
||
user.user_id,
|
||
body.course_source,
|
||
body.teeoff_facility_slug,
|
||
str(body.teeoff_course_id) if body.teeoff_course_id is not None else None,
|
||
body.personal_course_id,
|
||
resolved.course_name,
|
||
body.tee_name,
|
||
body.played_at,
|
||
body.start_hole,
|
||
body.holes_planned,
|
||
body.started_at,
|
||
body.name.strip() if body.name and body.name.strip() else None,
|
||
body.play_format,
|
||
body.skins_scoring,
|
||
body.skins_tie_handling,
|
||
body.visibility_mode,
|
||
)
|
||
round_id = round_row["id"]
|
||
|
||
await _create_participant(
|
||
conn, round_id, resolved, body.tee_name,
|
||
user_id=user.user_id, guest_name=None, is_owner=True,
|
||
gender=owner_row["gender"], handicap_index=owner_row["handicap_index"],
|
||
stat_level=body.stat_level,
|
||
exclude_from_handicap=body.exclude_owner_from_handicap,
|
||
individual_round_hole=body.play_format not in SIDE_IS_UNIT,
|
||
)
|
||
|
||
if body.visibility_mode == "friends" and body.visible_categories:
|
||
for category in sorted(set(body.visible_categories)):
|
||
await conn.execute(
|
||
"INSERT INTO round_visible_category (round_id, category) VALUES ($1, $2)",
|
||
round_id,
|
||
category,
|
||
)
|
||
|
||
# Rundevarsler (2026-07-28 oppfølging av ADR-036 fase 2) -- kun
|
||
# meningsfullt for 'public'/'friends' ('private' gir alltid en tom
|
||
# liste). Sendt EN GANG, her, ikke gjenberegnet ved hver visning.
|
||
if body.visibility_mode != "private":
|
||
watcher_ids = await _friends_who_can_see_round(conn, round_id, user.user_id)
|
||
if watcher_ids:
|
||
owner_name = await conn.fetchval("SELECT display_name FROM app_user WHERE id = $1", user.user_id)
|
||
round_label = (body.name.strip() if body.name and body.name.strip() else None) or resolved.course_name
|
||
for friend_id in watcher_ids:
|
||
await create_notification(
|
||
conn,
|
||
user_id=friend_id,
|
||
type="round",
|
||
message=f"{owner_name} startet en runde du kan følge ({round_label}).",
|
||
link_path=f"/watch/{round_id}",
|
||
)
|
||
|
||
return await _load_round_out(conn, round_id, user.user_id)
|
||
|
||
|
||
@router.get("/rounds", response_model=list[RoundOut])
|
||
async def list_rounds(user: CurrentUser = Depends(get_current_user)) -> list[RoundOut]:
|
||
async with plain_connection() as conn:
|
||
# ADR-036 fase 3-utvidelsen (2026-07-26): en lenket medspiller ser nå
|
||
# runden i SIN EGEN liste også, ikke bare eieren -- bekreftet av
|
||
# brukeren som ønsket allerede 2026-07-25.
|
||
ids = await conn.fetch(
|
||
"""
|
||
SELECT r.id::text AS id
|
||
FROM round r
|
||
WHERE r.owner_user_id = $1
|
||
OR EXISTS(SELECT 1 FROM round_participant WHERE round_id = r.id AND user_id = $1)
|
||
ORDER BY r.played_at DESC, r.created_at DESC
|
||
""",
|
||
user.user_id,
|
||
)
|
||
return [await _load_round_out(conn, r["id"], user.user_id) for r in ids]
|
||
|
||
|
||
class RoundStatsSummary(BaseModel):
|
||
rounds_completed: int
|
||
avg_score_to_par: float | None
|
||
avg_putts_per_18: float | None
|
||
putts_tracked_rounds: int
|
||
fairway_hit_pct: float | None
|
||
fairway_left_pct: float | None
|
||
fairway_right_pct: float | None
|
||
fairway_tracked_holes: int
|
||
gir_pct: float | None
|
||
gir_tracked_holes: int
|
||
green_miss_long_pct: float | None
|
||
green_miss_short_pct: float | None
|
||
green_miss_left_pct: float | None
|
||
green_miss_right_pct: float | None
|
||
green_miss_tracked_holes: int
|
||
one_putt_pct: float | None
|
||
putt_dist_one_pct: float | None
|
||
putt_dist_two_pct: float | None
|
||
putt_dist_three_plus_pct: float | None
|
||
scrambling_pct: float | None
|
||
sand_save_pct: float | None
|
||
avg_chip_per_round: float | None
|
||
avg_bunker_per_round: float | None
|
||
avg_penalty_per_round: float | None
|
||
avg_anyway_per_round: float | None
|
||
# Til-par splittet på om en hendelse inntraff på HULLET -- pooler
|
||
# enkelthull på tvers av alle runder (ikke per-runde-snitt, siden dette
|
||
# er hull-nivå-betingelser), samme formel som `round-stats.tsx` sin
|
||
# `avgToParWithGir`/`avgToParFairwayHit`/`avgToParWithBunker` bruker
|
||
# for én runde.
|
||
avg_to_par_with_gir: float | None
|
||
avg_to_par_without_gir: float | None
|
||
avg_to_par_fairway_hit: float | None
|
||
avg_to_par_fairway_miss: float | None
|
||
avg_to_par_with_bunker: float | None
|
||
avg_to_par_without_bunker: float | None
|
||
avg_to_par_with_anyway: float | None
|
||
avg_to_par_without_anyway: float | None
|
||
|
||
|
||
class RoundStatsWindowSummary(BaseModel):
|
||
window: str
|
||
current: RoundStatsSummary
|
||
previous: RoundStatsSummary
|
||
|
||
|
||
StatsWindow = Literal["last_round", "last_5", "last_10", "month", "year", "last_year", "all"]
|
||
|
||
|
||
def _resolve_stats_window(window: StatsWindow, ordered_rounds: list[tuple[str, date]]) -> tuple[set[str], set[str]]:
|
||
"""`ordered_rounds` er (round_id, played_at) sortert NYEST FØRST.
|
||
Returnerer (gjeldende periode, forrige periode) som round_id-mengder.
|
||
|
||
Forrige periode er ALLTID perioden av SAMME LENGDE rett før gjeldende
|
||
periodes start -- rullerende for antall-baserte vinduer (samme antall
|
||
runder rett før), rullerende for dato-baserte vinduer (samme antall
|
||
DAGER rett før startdatoen). Én ensartet regel for alle vindutyper,
|
||
ingen kalender-spesialtilfeller (unngår å måtte definere "forrige
|
||
måned"/"forrige år" ulikt fra "forrige periode" for et rullerende
|
||
vindu som "siste 365 dager").
|
||
"""
|
||
if window == "all":
|
||
return {r[0] for r in ordered_rounds}, set()
|
||
|
||
if window in ("last_round", "last_5", "last_10"):
|
||
n = {"last_round": 1, "last_5": 5, "last_10": 10}[window]
|
||
current = ordered_rounds[:n]
|
||
previous = ordered_rounds[n : 2 * n]
|
||
return {r[0] for r in current}, {r[0] for r in previous}
|
||
|
||
today = date.today()
|
||
if window == "month":
|
||
start = today.replace(day=1)
|
||
elif window == "year":
|
||
start = today.replace(month=1, day=1)
|
||
elif window == "last_year":
|
||
start = today - timedelta(days=365)
|
||
else:
|
||
raise ValueError(f"Ukjent vindu: {window}")
|
||
|
||
length_days = (today - start).days + 1
|
||
prev_end = start - timedelta(days=1)
|
||
prev_start = prev_end - timedelta(days=length_days - 1)
|
||
current = {r[0] for r in ordered_rounds if r[1] >= start}
|
||
previous = {r[0] for r in ordered_rounds if prev_start <= r[1] <= prev_end}
|
||
return current, previous
|
||
|
||
|
||
def _summarize_rounds(round_ids: set[str], by_round: dict[str, list], stat_level_by_round: dict[str, str]) -> RoundStatsSummary:
|
||
"""Samme formler som `round-stats.tsx` sin `computeStats()` bruker per
|
||
enkeltrunde, pooler kun holdene fra `round_ids` -- gjenbrukt for BÅDE
|
||
gjeldende og forrige periode (se `_resolve_stats_window`)."""
|
||
|
||
def avg(values: list[float]) -> float | None:
|
||
return sum(values) / len(values) if values else None
|
||
|
||
to_par_values: list[float] = []
|
||
putt_totals: list[float] = []
|
||
for round_id in round_ids:
|
||
holes = by_round.get(round_id, [])
|
||
played = [h for h in holes if h["played"] and h["score"] is not None]
|
||
if played:
|
||
to_par_values.append(sum(h["score"] - h["par"] for h in played))
|
||
if stat_level_by_round.get(round_id) != "strokes_only":
|
||
putt_totals.append(sum(h["putts"] if h["putts"] is not None else 2 for h in holes))
|
||
|
||
all_played = [h for rid in round_ids for h in by_round.get(rid, []) if h["played"] and h["score"] is not None]
|
||
|
||
fairway_tracked = [h for h in all_played if h["par"] != 3 and h["tee_shot_result"] is not None]
|
||
fairway_hit_pct = avg([100.0 if h["tee_shot_result"] == "fairway" else 0.0 for h in fairway_tracked])
|
||
fairway_left_pct = avg([100.0 if h["tee_shot_result"] == "left" else 0.0 for h in fairway_tracked])
|
||
fairway_right_pct = avg([100.0 if h["tee_shot_result"] == "right" else 0.0 for h in fairway_tracked])
|
||
|
||
def is_gir(h) -> bool:
|
||
return h["score"] - h["putts"] <= h["par"] - 2
|
||
|
||
gir_eligible = [h for h in all_played if h["putts"] is not None]
|
||
gir_pct = avg([100.0 if is_gir(h) else 0.0 for h in gir_eligible])
|
||
one_putt_pct = avg([100.0 if h["putts"] <= 1 else 0.0 for h in gir_eligible])
|
||
# Puttfordeling (donut-vennlig, 3 gjensidig utelukkende bøtter) -- egne
|
||
# eksakte grenser (==1/==2/>=3), SAMME bøtter som `round-stats.tsx` sin
|
||
# `puttCategories` bruker per enkeltrunde, ikke samme grense som
|
||
# `one_putt_pct` over (som bevisst bruker <=1 -- en litt annen,
|
||
# allerede etablert "hvor ofte putter du bra"-rate, ikke en distribusjon).
|
||
putt_dist_one_pct = avg([100.0 if h["putts"] == 1 else 0.0 for h in gir_eligible])
|
||
putt_dist_two_pct = avg([100.0 if h["putts"] == 2 else 0.0 for h in gir_eligible])
|
||
putt_dist_three_plus_pct = avg([100.0 if h["putts"] >= 3 else 0.0 for h in gir_eligible])
|
||
|
||
# Retning på bomskudd mot green -- eget spor (approach_result), ikke
|
||
# avledet av putte-basert GIR: en spiller kan registrere retning uten
|
||
# noensinne å registrere putter (og omvendt), samme uavhengighet som
|
||
# `round-stats.tsx` sin `missedGreen`/`missDir`.
|
||
green_missed = [h for h in all_played if h["approach_result"] is not None and h["approach_result"] != "hit"]
|
||
|
||
def miss_pct(direction: str) -> float | None:
|
||
return avg([100.0 if h["approach_result"] == direction else 0.0 for h in green_missed])
|
||
|
||
gir_missed = [h for h in gir_eligible if not is_gir(h)]
|
||
scrambling_pct = avg([100.0 if (h["score"] - h["par"]) <= 0 else 0.0 for h in gir_missed])
|
||
sand_eligible = [h for h in gir_missed if h["bunker_shot_count"] is not None and h["bunker_shot_count"] >= 1]
|
||
sand_save_pct = avg([100.0 if (h["score"] - h["par"]) <= 0 else 0.0 for h in sand_eligible])
|
||
|
||
# Til-par splittet på hull-nivå-hendelser (brukerens eksplisitte
|
||
# instruks 2026-07-28) -- pooler ENKELTHULL på tvers av alle runder i
|
||
# perioden, samme `diff()`-formel som `round-stats.tsx` sin
|
||
# `avgToParWithGir`/`avgToParFairwayHit`/`avgToParWithBunker` (portert
|
||
# uendret, anywayslag-splitten er en ny, konsekvent utvidelse av samme
|
||
# mønster -- fantes ikke fra før for enkeltrunder).
|
||
def diff(h) -> int:
|
||
return h["score"] - h["par"]
|
||
|
||
avg_to_par_with_gir = avg([diff(h) for h in gir_eligible if is_gir(h)])
|
||
avg_to_par_without_gir = avg([diff(h) for h in gir_eligible if not is_gir(h)])
|
||
|
||
avg_to_par_fairway_hit = avg([diff(h) for h in fairway_tracked if h["tee_shot_result"] == "fairway"])
|
||
avg_to_par_fairway_miss = avg([diff(h) for h in fairway_tracked if h["tee_shot_result"] in ("left", "right")])
|
||
|
||
bunker_eligible = [h for h in all_played if h["bunker_shot_count"] is not None]
|
||
avg_to_par_with_bunker = avg([diff(h) for h in bunker_eligible if h["bunker_shot_count"] >= 1])
|
||
avg_to_par_without_bunker = avg([diff(h) for h in bunker_eligible if h["bunker_shot_count"] == 0])
|
||
|
||
anyway_eligible = [h for h in all_played if h["anyway_strokes"] is not None]
|
||
avg_to_par_with_anyway = avg([diff(h) for h in anyway_eligible if h["anyway_strokes"] >= 1])
|
||
avg_to_par_without_anyway = avg([diff(h) for h in anyway_eligible if h["anyway_strokes"] == 0])
|
||
|
||
def avg_per_round(field: str) -> float | None:
|
||
totals = []
|
||
for round_id in round_ids:
|
||
eligible = [h for h in by_round.get(round_id, []) if h["played"] and h["score"] is not None and h[field] is not None]
|
||
if eligible:
|
||
totals.append(sum(h[field] for h in eligible))
|
||
return avg(totals)
|
||
|
||
return RoundStatsSummary(
|
||
rounds_completed=len(round_ids),
|
||
avg_score_to_par=avg(to_par_values),
|
||
avg_putts_per_18=avg(putt_totals),
|
||
putts_tracked_rounds=len(putt_totals),
|
||
fairway_hit_pct=fairway_hit_pct,
|
||
fairway_left_pct=fairway_left_pct,
|
||
fairway_right_pct=fairway_right_pct,
|
||
fairway_tracked_holes=len(fairway_tracked),
|
||
gir_pct=gir_pct,
|
||
gir_tracked_holes=len(gir_eligible),
|
||
green_miss_long_pct=miss_pct("long"),
|
||
green_miss_short_pct=miss_pct("short"),
|
||
green_miss_left_pct=miss_pct("left"),
|
||
green_miss_right_pct=miss_pct("right"),
|
||
green_miss_tracked_holes=len(green_missed),
|
||
one_putt_pct=one_putt_pct,
|
||
putt_dist_one_pct=putt_dist_one_pct,
|
||
putt_dist_two_pct=putt_dist_two_pct,
|
||
putt_dist_three_plus_pct=putt_dist_three_plus_pct,
|
||
scrambling_pct=scrambling_pct,
|
||
sand_save_pct=sand_save_pct,
|
||
avg_chip_per_round=avg_per_round("chip_count"),
|
||
avg_bunker_per_round=avg_per_round("bunker_shot_count"),
|
||
avg_penalty_per_round=avg_per_round("penalty_strokes"),
|
||
avg_anyway_per_round=avg_per_round("anyway_strokes"),
|
||
avg_to_par_with_gir=avg_to_par_with_gir,
|
||
avg_to_par_without_gir=avg_to_par_without_gir,
|
||
avg_to_par_fairway_hit=avg_to_par_fairway_hit,
|
||
avg_to_par_fairway_miss=avg_to_par_fairway_miss,
|
||
avg_to_par_with_bunker=avg_to_par_with_bunker,
|
||
avg_to_par_without_bunker=avg_to_par_without_bunker,
|
||
avg_to_par_with_anyway=avg_to_par_with_anyway,
|
||
avg_to_par_without_anyway=avg_to_par_without_anyway,
|
||
)
|
||
|
||
|
||
@router.get("/rounds/stats/summary", response_model=RoundStatsWindowSummary)
|
||
async def get_rounds_stats_summary(
|
||
window: StatsWindow = Query("all"),
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> RoundStatsWindowSummary:
|
||
"""Aggregert statistikk over brukerens fullførte runder (egen
|
||
deltaker-rad, ikke medspilleres), for et valgt tidsvindu -- pluss samme
|
||
tall for FORRIGE periode av samme lengde til sammenligning (se
|
||
`_resolve_stats_window`). Ingen paginering -- samme "hent alt, aggreger
|
||
i Python"-mønster som `list_rounds`, forsvarlig i volum siden
|
||
`round_hole` alltid har nøyaktig 18 rader per deltaker uansett
|
||
holes_planned (se `_create_participant`).
|
||
|
||
Putt/18-hull-regelen (brukerens eksplisitte instruks 2026-07-28): for
|
||
hver fullført runde der puttsporing faktisk var på (stat_level ≠
|
||
'strokes_only') telles ALLE 18 lagrede hull -- et hull uten registrert
|
||
putt-verdi (uspilt, eller utenfor et 9-hulls spilleomfang) telles som 2
|
||
putter. Runder uten puttsporing holdes helt utenfor putt-tallet.
|
||
Alle andre andelstall (fairway/GIR/én-putt/scrambling/sand save/miss-
|
||
retning) pooler kun FAKTISK registrerte hull -- samme formler som
|
||
`round-stats.tsx` sin `computeStats()` bruker per enkeltrunde (portert
|
||
hit, ikke en ny definisjon), ingen padding der brukeren ikke ba om det.
|
||
"""
|
||
async with plain_connection() as conn:
|
||
rows = await conn.fetch(
|
||
"""
|
||
SELECT rp.round_id::text AS round_id, rp.stat_level, r.played_at,
|
||
rh.par, rh.played, rh.score, rh.putts,
|
||
rh.tee_shot_result, rh.approach_result, rh.chip_count,
|
||
rh.bunker_shot_count, rh.penalty_strokes, rh.anyway_strokes
|
||
FROM round_participant rp
|
||
JOIN round r ON r.id = rp.round_id
|
||
JOIN round_hole rh ON rh.round_participant_id = rp.id
|
||
WHERE rp.user_id = $1 AND r.completed_at IS NOT NULL
|
||
ORDER BY r.played_at DESC, rh.hole_number
|
||
""",
|
||
user.user_id,
|
||
)
|
||
|
||
by_round: dict[str, list] = {}
|
||
stat_level_by_round: dict[str, str] = {}
|
||
played_at_by_round: dict[str, date] = {}
|
||
for r in rows:
|
||
by_round.setdefault(r["round_id"], []).append(r)
|
||
stat_level_by_round[r["round_id"]] = r["stat_level"]
|
||
played_at_by_round[r["round_id"]] = r["played_at"]
|
||
|
||
# Distinkte runder, nyest først -- rekkefølgen `rows` allerede har
|
||
# (ORDER BY r.played_at DESC) bevares siden Python-dicts er innsettings-
|
||
# ordnet, ingen ny sortering nødvendig.
|
||
ordered_rounds = [(rid, played_at_by_round[rid]) for rid in by_round]
|
||
|
||
current_ids, previous_ids = _resolve_stats_window(window, ordered_rounds)
|
||
|
||
return RoundStatsWindowSummary(
|
||
window=window,
|
||
current=_summarize_rounds(current_ids, by_round, stat_level_by_round),
|
||
previous=_summarize_rounds(previous_ids, by_round, stat_level_by_round),
|
||
)
|
||
|
||
|
||
async def _get_owned_round_or_404(conn, round_id: str, user_id: str):
|
||
"""Strengt eier-only -- for runde-forvaltning (rediger/slett metadata,
|
||
legge til/fjerne deltakere). IKKE for lesing/scoreregistrering, se
|
||
`_get_accessible_round_or_404`."""
|
||
row = await conn.fetchrow("SELECT owner_user_id::text AS owner_user_id FROM round WHERE id = $1", round_id)
|
||
if row is None:
|
||
raise app_error(404, "NOT_FOUND", "Runden finnes ikke.")
|
||
if row["owner_user_id"] != user_id:
|
||
raise app_error(403, "NOT_AUTHORIZED", "Du eier ikke denne runden.")
|
||
|
||
|
||
async def _get_accessible_round_or_404(conn, round_id: str, user_id: str):
|
||
"""Eier ELLER en lenket medspiller (round_participant.user_id) --
|
||
ADR-036 fase 3-utvidelsen (2026-07-26): en medspiller kan se runden og
|
||
registrere score for HELE flighten (bekreftet regel), men kan IKKE
|
||
forvalte runden (se `_get_owned_round_or_404` for det)."""
|
||
row = await conn.fetchrow(
|
||
"""
|
||
SELECT r.owner_user_id::text AS owner_user_id,
|
||
EXISTS(
|
||
SELECT 1 FROM round_participant
|
||
WHERE round_id = r.id AND user_id = $2
|
||
) AS is_linked_participant
|
||
FROM round r WHERE r.id = $1
|
||
""",
|
||
round_id,
|
||
user_id,
|
||
)
|
||
if row is None:
|
||
raise app_error(404, "NOT_FOUND", "Runden finnes ikke.")
|
||
if row["owner_user_id"] != user_id and not row["is_linked_participant"]:
|
||
raise app_error(403, "NOT_AUTHORIZED", "Du har ikke tilgang til denne runden.")
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Tredjeparts leseadgang (ADR-036 fase 2, 2026-07-28) -- venner/offentlig-
|
||
# heten sitt innsyn i en runde de IKKE selv er eier eller deltaker på.
|
||
# Bevisst ADSKILT fra _get_accessible_round_or_404 over: den dekker eier +
|
||
# faktisk medspiller (som alltid har full lese-/skrivetilgang uansett
|
||
# visibility_mode), denne dekker KUN lesing for alle andre, styrt av
|
||
# visibility_mode + (for 'friends') eierens private kategorisering av
|
||
# viewer. `viewer_user_id=None` er en gyldig, forventet verdi (anonym
|
||
# leser) -- gir tilgang KUN når visibility_mode='public'.
|
||
# ---------------------------------------------------------------------------
|
||
|
||
async def _can_view_round(conn, round_id: str, viewer_user_id: str | None) -> bool:
|
||
row = await conn.fetchrow(
|
||
"SELECT owner_user_id::text AS owner_user_id, visibility_mode FROM round WHERE id = $1",
|
||
round_id,
|
||
)
|
||
if row is None:
|
||
return False
|
||
if viewer_user_id is not None and row["owner_user_id"] == viewer_user_id:
|
||
return True
|
||
if viewer_user_id is not None:
|
||
is_participant = await conn.fetchval(
|
||
"SELECT EXISTS(SELECT 1 FROM round_participant WHERE round_id = $1 AND user_id = $2)",
|
||
round_id,
|
||
viewer_user_id,
|
||
)
|
||
if is_participant:
|
||
return True
|
||
if row["visibility_mode"] == "public":
|
||
return True
|
||
if row["visibility_mode"] == "private":
|
||
return False
|
||
# 'friends' -- krever et AKSEPTERT vennskap MED eieren OG at EIERENS
|
||
# kategorisering av viewer (ikke omvendt -- det er eieren som
|
||
# begrenser, basert på egen gruppering, ADR-036 Beslutning B) treffer
|
||
# minst én av rundens synlige kategorier.
|
||
if viewer_user_id is None:
|
||
return False
|
||
owner_id = row["owner_user_id"]
|
||
is_friend = await conn.fetchval(
|
||
"""
|
||
SELECT EXISTS(
|
||
SELECT 1 FROM friendship
|
||
WHERE status = 'accepted'
|
||
AND ((requester_user_id = $1 AND addressee_user_id = $2)
|
||
OR (requester_user_id = $2 AND addressee_user_id = $1))
|
||
)
|
||
""",
|
||
owner_id,
|
||
viewer_user_id,
|
||
)
|
||
if not is_friend:
|
||
return False
|
||
return await conn.fetchval(
|
||
"""
|
||
SELECT EXISTS(
|
||
SELECT 1 FROM friend_categorization fc
|
||
JOIN round_visible_category rvc ON rvc.category = fc.category
|
||
WHERE fc.owner_user_id = $1 AND fc.friend_user_id = $2 AND rvc.round_id = $3
|
||
)
|
||
""",
|
||
owner_id,
|
||
viewer_user_id,
|
||
round_id,
|
||
)
|
||
|
||
|
||
async def _get_viewable_round_or_404(conn, round_id: str, viewer_user_id: str | None) -> None:
|
||
exists = await conn.fetchval("SELECT 1 FROM round WHERE id = $1", round_id)
|
||
if exists is None:
|
||
raise app_error(404, "NOT_FOUND", "Runden finnes ikke.")
|
||
if not await _can_view_round(conn, round_id, viewer_user_id):
|
||
raise app_error(403, "NOT_AUTHORIZED", "Du har ikke tilgang til denne runden.")
|
||
|
||
|
||
async def _friends_who_can_see_round(conn, round_id: str, owner_user_id: str) -> list[str]:
|
||
"""Rundevarsler (FEATURE_BACKLOG.md, 2026-07-28 oppfølging av ADR-036
|
||
fase 2) -- aksepterte venner av EIEREN som kan se DENNE runden akkurat
|
||
nå (offentlig, eller riktig venne-kategori), brukt til fan-out-varsling
|
||
ved opprettelse OG ved fullføring. Bevisst GJENBEREGNET hver gang (ikke
|
||
en lagret mottakerliste) -- samme regel som selve tilgangskontrollen i
|
||
`_can_view_round`, aldri ute av synk med den."""
|
||
row = await conn.fetchrow("SELECT visibility_mode FROM round WHERE id = $1", round_id)
|
||
if row is None or row["visibility_mode"] == "private":
|
||
return []
|
||
friend_rows = await conn.fetch(
|
||
"""
|
||
SELECT (CASE WHEN requester_user_id = $1 THEN addressee_user_id ELSE requester_user_id END)::text AS friend_id
|
||
FROM friendship
|
||
WHERE status = 'accepted' AND (requester_user_id = $1 OR addressee_user_id = $1)
|
||
""",
|
||
owner_user_id,
|
||
)
|
||
friend_ids = [r["friend_id"] for r in friend_rows]
|
||
if not friend_ids:
|
||
return []
|
||
if row["visibility_mode"] == "public":
|
||
return friend_ids
|
||
matched = await conn.fetch(
|
||
"""
|
||
SELECT DISTINCT fc.friend_user_id::text AS friend_id
|
||
FROM friend_categorization fc
|
||
JOIN round_visible_category rvc ON rvc.category = fc.category
|
||
WHERE fc.owner_user_id = $1 AND rvc.round_id = $2
|
||
""",
|
||
owner_user_id,
|
||
round_id,
|
||
)
|
||
return [r["friend_id"] for r in matched]
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Faktisk (beregnet) HCP -- ADR-038. v1 KUN fra frittstående runder --
|
||
# `_gather_qualifying_differentials` er det bevisste skjøtepunktet for en
|
||
# fremtidig UNION mot turnering-/organisasjonsscoring (ADR-037), ikke bygget
|
||
# ennå. Ingen ny, generell "scoring record"-tabell -- for tidlig abstraksjon
|
||
# for en kilde som ikke finnes.
|
||
# ---------------------------------------------------------------------------
|
||
|
||
async def _gather_qualifying_differentials(conn, user_id: str) -> list[tuple[date, float]]:
|
||
rows = await conn.fetch(
|
||
"""
|
||
SELECT r.played_at, rp.score_differential::float AS score_differential
|
||
FROM round_participant rp
|
||
JOIN round r ON r.id = rp.round_id
|
||
WHERE rp.user_id = $1
|
||
AND rp.counts_for_handicap
|
||
AND NOT rp.exclude_from_handicap
|
||
AND rp.score_differential IS NOT NULL
|
||
ORDER BY r.played_at DESC
|
||
""",
|
||
user_id,
|
||
)
|
||
return [(row["played_at"], row["score_differential"]) for row in rows]
|
||
|
||
|
||
async def _recompute_computed_handicap_index(conn, user_id: str) -> None:
|
||
"""Rule 5.2 (beste 8-av-≤20) + Rule 5.7/5.8 (Low HI-cap). Ingen tidligere
|
||
'computed'-historikk å låse mot -- capping hoppes bevisst over (Low HI
|
||
er udefinert før en første indeks er etablert), ikke en feil."""
|
||
differentials = await _gather_qualifying_differentials(conn, user_id)
|
||
new_index = handicap_index_from_differentials([d for _, d in differentials][:20])
|
||
|
||
if new_index is None:
|
||
await conn.execute(
|
||
"UPDATE app_user SET computed_handicap_index = NULL, computed_handicap_index_updated_at = now() "
|
||
"WHERE id = $1",
|
||
user_id,
|
||
)
|
||
return
|
||
|
||
history_rows = await conn.fetch(
|
||
"""
|
||
SELECT recorded_at::date AS d, handicap_index::float AS idx
|
||
FROM handicap_history WHERE user_id = $1 AND source = 'computed'
|
||
ORDER BY recorded_at
|
||
""",
|
||
user_id,
|
||
)
|
||
low = low_handicap_index([(row["d"], row["idx"]) for row in history_rows], date.today())
|
||
final_index = apply_index_caps(new_index, low) if low is not None else new_index
|
||
|
||
await conn.execute(
|
||
"UPDATE app_user SET computed_handicap_index = $2, computed_handicap_index_updated_at = now() WHERE id = $1",
|
||
user_id, final_index,
|
||
)
|
||
await conn.execute(
|
||
"INSERT INTO handicap_history (user_id, handicap_index, source) VALUES ($1, $2, 'computed')",
|
||
user_id, final_index,
|
||
)
|
||
|
||
|
||
@router.get("/rounds/{round_id}", response_model=RoundOut)
|
||
async def get_round(round_id: str, user: CurrentUser = Depends(get_current_user)) -> RoundOut:
|
||
async with plain_connection() as conn:
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
return await _load_round_out(conn, round_id, user.user_id)
|
||
|
||
|
||
class RoundUpdate(BaseModel):
|
||
# Bane-bytte er ATOMISK -- enten oppgis course_source+tee_name (pluss de
|
||
# kildespesifikke feltene) sammen, eller ingen av dem. holes_planned/
|
||
# start_hole kan endres uavhengig, i samme kall eller alene -- disse
|
||
# rører aldri round_hole, kun visnings-/navigasjonsmetadata.
|
||
course_source: Literal["teeoff", "custom"] | None = None
|
||
teeoff_facility_slug: str | None = None
|
||
teeoff_course_id: int | None = None
|
||
personal_course_id: str | None = None
|
||
tee_name: str | None = None
|
||
# Rent metadata-felt -- kan endres/fjernes uansett fullført-status,
|
||
# samme begrunnelse som start_hole/started_at/completed_at under. Sendes
|
||
# feltet med tom streng, tolkes det som "fjern navnet" (NULL); mangler
|
||
# feltet i kallet, røres eksisterende navn ikke (samme mønster som de
|
||
# andre feltene her -- kun `None`/utelatt betyr "ikke rør").
|
||
name: str | None = Field(default=None, max_length=200)
|
||
holes_planned: Literal[9, 18] | None = None
|
||
start_hole: int | None = Field(default=None, ge=1, le=18)
|
||
# Ren metadata (ADR-038 Beslutning D) -- rører aldri AGS/differensial-
|
||
# matematikken selv, kan derfor endres uansett fullført-status.
|
||
play_format: Literal["stroke", "match"] | None = None
|
||
# Utslagstidspunkt og "Ferdig"-tidspunkt -- begge kan justeres i
|
||
# etterkant (f.eks. glemte å trykke "Fullfør runde" før flere timer
|
||
# senere, og vil rette opp tidsbruken). completed_at kan KUN settes på
|
||
# en runde som allerede er fullført (se validering under) -- denne
|
||
# PATCH-en fullfører aldri runden selv, kun korrigerer et tidspunkt som
|
||
# /complete allerede har satt.
|
||
started_at: datetime | None = None
|
||
completed_at: datetime | None = None
|
||
# ADR-036 Beslutning B (fase 2, 2026-07-28) -- ren metadata, endrer
|
||
# aldri HCP-beregningen, kan derfor justeres uansett fullført-status,
|
||
# samme begrunnelse som start_hole/started_at over.
|
||
# visible_categories er en FULL ERSTATNING av settet når sendt (samme
|
||
# "erstatt hele settet"-kontrakt som PUT /friends/{id}/categories) --
|
||
# utelatt/None rører ikke eksisterende kategorier, tom liste [] tømmer
|
||
# dem.
|
||
visibility_mode: Literal["public", "private", "friends"] | None = None
|
||
visible_categories: list[_FriendCategory] | None = None
|
||
|
||
|
||
@router.patch("/rounds/{round_id}", response_model=RoundOut)
|
||
async def update_round(
|
||
round_id: str,
|
||
body: RoundUpdate,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> RoundOut:
|
||
"""
|
||
Retter opp feil bane/utslag/antall hull/starthull ETTER at runden er
|
||
opprettet (2026-07-24) -- f.eks. hvis man oppdager underveis at feil
|
||
bane ble valgt, eller vil justere utslags-/fullført-tidspunktet i
|
||
etterkant. Endrer ALDRI allerede registrerte slag/putter/etc. i
|
||
round_hole -- kun rating-grunnlaget (par/stroke-index-snapshot +
|
||
course/slope-rating) hullene regnes ut fra. Bane-bytte og
|
||
holes_planned er bevisst avvist etter at runden er fullført
|
||
(differensialen er da allerede beregnet fra det gamle grunnlaget, og
|
||
en re-beregning etter fullføring er utenfor omfang her -- ulikt
|
||
tilsvarende bane-bytte for turnering-økter, som bevisst TILLATER dette
|
||
selv etter avgjørelse). start_hole/started_at/completed_at er derimot
|
||
ren metadata som ALDRI påvirker HCP-beregningen, og kan derfor justeres
|
||
uansett fullført-status.
|
||
"""
|
||
async with plain_connection() as conn:
|
||
await _get_owned_round_or_404(conn, round_id, user.user_id)
|
||
round_row = await conn.fetchrow("SELECT started_at, completed_at FROM round WHERE id = $1", round_id)
|
||
is_completed = round_row["completed_at"] is not None
|
||
|
||
if is_completed and (body.course_source is not None or body.holes_planned is not None):
|
||
raise app_error(
|
||
409, "ALREADY_COMPLETED",
|
||
"Runden er allerede fullført -- kan ikke endre bane eller antall hull i etterkant.",
|
||
)
|
||
|
||
if body.completed_at is not None and not is_completed:
|
||
raise app_error(
|
||
400, "VALIDATION_FAILED",
|
||
"Runden må fullføres via \"Fullfør runde\" først -- deretter kan tidspunktet justeres.",
|
||
)
|
||
|
||
effective_started_at = body.started_at if body.started_at is not None else round_row["started_at"]
|
||
effective_completed_at = body.completed_at if body.completed_at is not None else round_row["completed_at"]
|
||
if (
|
||
effective_started_at is not None
|
||
and effective_completed_at is not None
|
||
and effective_completed_at <= effective_started_at
|
||
):
|
||
raise app_error(400, "VALIDATION_FAILED", "Fullført-tidspunktet må være etter utslagstidspunktet.")
|
||
|
||
resolved: _ResolvedCourse | None = None
|
||
participants = None
|
||
if body.course_source is not None:
|
||
if not body.tee_name:
|
||
raise app_error(400, "VALIDATION_FAILED", "tee_name er påkrevd ved bane-bytte.")
|
||
if body.course_source == "teeoff":
|
||
if not body.teeoff_facility_slug or not body.teeoff_course_id:
|
||
raise app_error(400, "VALIDATION_FAILED", "teeoff_facility_slug og teeoff_course_id er påkrevd.")
|
||
resolved = await _resolve_teeoff_course(body.teeoff_facility_slug, body.teeoff_course_id)
|
||
else:
|
||
if not body.personal_course_id:
|
||
raise app_error(400, "VALIDATION_FAILED", "personal_course_id er påkrevd.")
|
||
resolved = await _resolve_personal_course(body.personal_course_id)
|
||
|
||
participants = await conn.fetch(
|
||
"""
|
||
SELECT id::text AS id, gender, handicap_index_snapshot::float AS handicap_index_snapshot
|
||
FROM round_participant WHERE round_id = $1
|
||
""",
|
||
round_id,
|
||
)
|
||
# Valider FOR ALLE deltakere FØR noe skrives -- hele bane-byttet
|
||
# avvises tydelig hvis ÉN eneste deltaker ville mistet HCP-
|
||
# sporing, ingen delvis anvendt endring.
|
||
for p in participants:
|
||
if resolved.rating_for(body.tee_name, p["gender"]) is None:
|
||
raise app_error(
|
||
400, "VALIDATION_FAILED",
|
||
"Den nye banen/utslaget mangler rating for én eller flere av deltakernes kjønn -- ingenting er endret.",
|
||
)
|
||
|
||
async with conn.transaction():
|
||
if body.holes_planned is not None:
|
||
await conn.execute("UPDATE round SET holes_planned = $2 WHERE id = $1", round_id, body.holes_planned)
|
||
if body.start_hole is not None:
|
||
await conn.execute("UPDATE round SET start_hole = $2 WHERE id = $1", round_id, body.start_hole)
|
||
if body.name is not None:
|
||
await conn.execute(
|
||
"UPDATE round SET name = $2 WHERE id = $1",
|
||
round_id,
|
||
body.name.strip() if body.name.strip() else None,
|
||
)
|
||
if body.play_format is not None:
|
||
await conn.execute("UPDATE round SET play_format = $2 WHERE id = $1", round_id, body.play_format)
|
||
if body.started_at is not None:
|
||
await conn.execute("UPDATE round SET started_at = $2 WHERE id = $1", round_id, body.started_at)
|
||
if body.completed_at is not None:
|
||
await conn.execute("UPDATE round SET completed_at = $2 WHERE id = $1", round_id, body.completed_at)
|
||
if body.visibility_mode is not None:
|
||
await conn.execute("UPDATE round SET visibility_mode = $2 WHERE id = $1", round_id, body.visibility_mode)
|
||
if body.visible_categories is not None:
|
||
await conn.execute("DELETE FROM round_visible_category WHERE round_id = $1", round_id)
|
||
for category in sorted(set(body.visible_categories)):
|
||
await conn.execute(
|
||
"INSERT INTO round_visible_category (round_id, category) VALUES ($1, $2)",
|
||
round_id,
|
||
category,
|
||
)
|
||
|
||
if resolved is not None and participants is not None:
|
||
await conn.execute(
|
||
"""
|
||
UPDATE round SET course_source = $2, teeoff_facility_slug = $3, teeoff_course_id = $4,
|
||
personal_course_id = $5, course_name_snapshot = $6, tee_name_snapshot = $7
|
||
WHERE id = $1
|
||
""",
|
||
round_id,
|
||
body.course_source,
|
||
body.teeoff_facility_slug,
|
||
str(body.teeoff_course_id) if body.teeoff_course_id is not None else None,
|
||
body.personal_course_id,
|
||
resolved.course_name,
|
||
body.tee_name,
|
||
)
|
||
par_by_hole = {h[0]: h[1] for h in resolved.holes}
|
||
index_by_hole = {h[0]: h[2] for h in resolved.holes}
|
||
for p in participants:
|
||
course_rating, slope_rating, tee_par = resolved.rating_for(body.tee_name, p["gender"])
|
||
course_handicap_snapshot = None
|
||
if p["handicap_index_snapshot"] is not None:
|
||
course_handicap_snapshot = course_handicap(
|
||
p["handicap_index_snapshot"], slope_rating, course_rating, tee_par
|
||
)
|
||
await conn.execute(
|
||
"""
|
||
UPDATE round_participant SET tee_name_snapshot = $2, course_rating_snapshot = $3,
|
||
slope_rating_snapshot = $4, tee_par_snapshot = $5, course_handicap_snapshot = $6
|
||
WHERE id = $1
|
||
""",
|
||
p["id"], body.tee_name, course_rating, slope_rating, tee_par, course_handicap_snapshot,
|
||
)
|
||
for hole_number in range(1, 19):
|
||
await conn.execute(
|
||
"""
|
||
UPDATE round_hole SET par = $3, stroke_index = $4
|
||
WHERE round_participant_id = $1 AND hole_number = $2
|
||
""",
|
||
p["id"], hole_number, par_by_hole[hole_number], index_by_hole[hole_number],
|
||
)
|
||
|
||
result = await _load_round_out(conn, round_id, user.user_id)
|
||
|
||
await broadcast_round_update(round_id)
|
||
return result
|
||
|
||
|
||
@router.delete("/rounds/{round_id}", status_code=204)
|
||
async def delete_round(round_id: str, user: CurrentUser = Depends(get_current_user)) -> None:
|
||
async with plain_connection() as conn:
|
||
await _get_owned_round_or_404(conn, round_id, user.user_id)
|
||
# Fanges FØR sletting -- kaskaden fjerner round_participant-radene,
|
||
# så de tellende brukerne må hentes ut nå for å kunne regnes på nytt.
|
||
affected_users = await conn.fetch(
|
||
"SELECT user_id::text AS user_id FROM round_participant "
|
||
"WHERE round_id = $1 AND user_id IS NOT NULL AND counts_for_handicap",
|
||
round_id,
|
||
)
|
||
await conn.execute("DELETE FROM round WHERE id = $1", round_id)
|
||
for row in affected_users:
|
||
await _recompute_computed_handicap_index(conn, row["user_id"])
|
||
# Varsler evt. tilkoblede medspillere om at runden er borte -- deres
|
||
# neste refetch vil da naturlig treffe 404 og vise en tydelig feil.
|
||
await broadcast_round_update(round_id)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Medspillere (flighten) -- enten en EKTE TeeCup-bruker (funnet via det
|
||
# delte tiered personsøket, /people/search, ADR-036) eller en gjest uten
|
||
# konto (fritekstnavn). ADR-036 fase 3-utvidelsen (2026-07-26) -- inntil da
|
||
# var alle deltakere utenom eieren gjester.
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class ParticipantCreate(BaseModel):
|
||
# Nøyaktig én av user_id/guest_name.
|
||
user_id: str | None = None
|
||
guest_name: str | None = Field(default=None, min_length=1, max_length=100)
|
||
# Kun brukt for guest_name-varianten -- for user_id hentes kjønn/HCP fra
|
||
# personens egen profil (samme kilde som eierens egen deltaker-rad).
|
||
gender: Literal["m", "f", "x"] | None = None
|
||
handicap_index: float | None = Field(default=None, ge=-10, le=54)
|
||
# Valgfritt kontaktfelt for en gjest (2026-07-26) -- avvist hvis oppgitt
|
||
# sammen med user_id (en lenket bruker har allerede sin egen e-post).
|
||
guest_email: EmailStr | None = None
|
||
# Utslagssted for DENNE deltakeren (2026-07-26) -- valgfritt, faller
|
||
# tilbake til rundens eget utslag (samme som før) hvis utelatt. Kan
|
||
# avvike fra de andre deltakerne, f.eks. et kjønnsdelt utslag.
|
||
tee_name: str | None = None
|
||
stat_level: StatLevel = "strokes_only"
|
||
# ADR-038 Beslutning C/D -- kun meningsfullt for user_id-varianten (en
|
||
# gjest har ingen computed_handicap_index å beskytte). Frontend
|
||
# forhåndsutfyller True når rundens play_format='match'.
|
||
exclude_from_handicap: bool = False
|
||
# ADR-039 Beslutning A -- valgfritt, kun gyldig når rundens play_format
|
||
# bruker sider (match/fourball/foursome/greensome/scramble_*). Kan også
|
||
# settes/endres senere via PATCH .../participants/{id}.
|
||
round_side_id: str | None = None
|
||
|
||
|
||
@router.post("/rounds/{round_id}/participants", response_model=RoundParticipantOut, status_code=201)
|
||
async def add_participant(
|
||
round_id: str,
|
||
body: ParticipantCreate,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> RoundParticipantOut:
|
||
if (body.user_id is not None) == (body.guest_name is not None):
|
||
raise app_error(400, "VALIDATION_FAILED", "Oppgi enten user_id (funnet via søk) eller guest_name, ikke begge/ingen.")
|
||
if body.user_id is not None and body.guest_email is not None:
|
||
raise app_error(400, "VALIDATION_FAILED", "guest_email gir ikke mening sammen med user_id -- en lenket bruker har allerede sin egen konto-e-post.")
|
||
|
||
async with plain_connection() as conn:
|
||
round_row = await conn.fetchrow(
|
||
"SELECT owner_user_id::text AS owner_user_id, course_source, teeoff_facility_slug, "
|
||
"teeoff_course_id, personal_course_id, tee_name_snapshot, play_format, completed_at, "
|
||
"name, course_name_snapshot "
|
||
"FROM round WHERE id = $1",
|
||
round_id,
|
||
)
|
||
if round_row is None:
|
||
raise app_error(404, "NOT_FOUND", "Runden finnes ikke.")
|
||
if round_row["owner_user_id"] != user.user_id:
|
||
raise app_error(403, "NOT_AUTHORIZED", "Du eier ikke denne runden.")
|
||
|
||
if body.round_side_id is not None:
|
||
if round_row["play_format"] not in _TWO_SIDED_FORMATS:
|
||
raise app_error(400, "VALIDATION_FAILED", "Denne spilleformen bruker ikke sider.")
|
||
side_exists = await conn.fetchval(
|
||
"SELECT 1 FROM round_side WHERE id = $1 AND round_id = $2", body.round_side_id, round_id
|
||
)
|
||
if not side_exists:
|
||
raise app_error(404, "NOT_FOUND", "Siden finnes ikke på denne runden.")
|
||
await _check_side_capacity(conn, body.round_side_id, round_row["play_format"])
|
||
|
||
resolved = await _resolve_round_course(round_row)
|
||
|
||
if body.user_id is not None:
|
||
if body.user_id == round_row["owner_user_id"]:
|
||
raise app_error(400, "VALIDATION_FAILED", "Du er allerede med i runden som eier.")
|
||
target = await conn.fetchrow(
|
||
"SELECT gender, handicap_index::float AS handicap_index FROM app_user WHERE id = $1",
|
||
body.user_id,
|
||
)
|
||
if target is None:
|
||
raise app_error(404, "NOT_FOUND", "Fant ikke brukeren.")
|
||
if target["gender"] is None:
|
||
raise app_error(
|
||
400, "VALIDATION_FAILED",
|
||
"Spilleren du valgte har ikke fullført profilen sin (mangler kjønn) og kan ikke legges til ennå.",
|
||
)
|
||
gender = target["gender"]
|
||
handicap_index = target["handicap_index"]
|
||
guest_name = None
|
||
linked_user_id = body.user_id
|
||
else:
|
||
gender = body.gender
|
||
handicap_index = body.handicap_index
|
||
guest_name = body.guest_name.strip()
|
||
linked_user_id = None
|
||
if gender is None:
|
||
raise app_error(400, "VALIDATION_FAILED", "gender er påkrevd for en gjest uten konto.")
|
||
|
||
tee_name = body.tee_name or round_row["tee_name_snapshot"]
|
||
if resolved.rating_for(tee_name, gender) is None and handicap_index is not None:
|
||
raise app_error(
|
||
400, "VALIDATION_FAILED",
|
||
"Valgt utslag har ingen rating for dette kjønnet -- HCP-sporing er ikke mulig for denne deltakeren.",
|
||
)
|
||
|
||
async with conn.transaction(), translate_db_errors():
|
||
participant_id = await _create_participant(
|
||
conn, round_id, resolved, tee_name,
|
||
user_id=linked_user_id, guest_name=guest_name, is_owner=False,
|
||
gender=gender, handicap_index=handicap_index,
|
||
stat_level=body.stat_level,
|
||
guest_email=body.guest_email,
|
||
exclude_from_handicap=body.exclude_from_handicap,
|
||
round_side_id=body.round_side_id,
|
||
individual_round_hole=round_row["play_format"] not in SIDE_IS_UNIT,
|
||
)
|
||
if body.round_side_id is not None:
|
||
await _recompute_side_handicaps(conn, round_id, round_row["play_format"])
|
||
|
||
if linked_user_id is not None:
|
||
owner_name = await conn.fetchval("SELECT display_name FROM app_user WHERE id = $1", user.user_id)
|
||
round_label = (round_row["name"] or "").strip() or round_row["course_name_snapshot"]
|
||
await create_notification(
|
||
conn,
|
||
user_id=linked_user_id,
|
||
type="round",
|
||
message=f"{owner_name} la deg til som medspiller på en runde ({round_label}).",
|
||
link_path=f"/my-rounds/{round_id}",
|
||
)
|
||
row = await conn.fetchrow(
|
||
"""
|
||
SELECT rp.id::text AS id, rp.user_id::text AS user_id, rp.guest_name, rp.guest_email,
|
||
COALESCE(rp.guest_name, au.display_name, 'Medspiller') AS display_name,
|
||
rp.is_owner, rp.gender, rp.tee_name_snapshot,
|
||
rp.handicap_index_snapshot::float AS handicap_index_snapshot,
|
||
rp.course_handicap_snapshot, rp.counts_for_handicap,
|
||
rp.score_differential::float AS score_differential, rp.stat_level,
|
||
rp.exclude_from_handicap, rp.round_side_id::text AS round_side_id,
|
||
rp.playing_handicap
|
||
FROM round_participant rp
|
||
LEFT JOIN app_user au ON au.id = rp.user_id
|
||
WHERE rp.id = $1
|
||
""",
|
||
participant_id,
|
||
)
|
||
await broadcast_round_update(round_id)
|
||
return RoundParticipantOut(**dict(row))
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Sider (ADR-039 Beslutning A) -- nøyaktig to per runde, kun for formater
|
||
# som faktisk bruker sider. Håndhevet i app-laget (samme mønster som
|
||
# ADR-011s to-lags-grense for org-turneringer), ikke en DB-constraint.
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class RoundSideCreate(BaseModel):
|
||
label: str | None = Field(default=None, max_length=100)
|
||
|
||
|
||
@router.post("/rounds/{round_id}/sides", response_model=RoundSideOut, status_code=201)
|
||
async def create_round_side(
|
||
round_id: str,
|
||
body: RoundSideCreate,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> RoundSideOut:
|
||
async with plain_connection() as conn:
|
||
await _get_owned_round_or_404(conn, round_id, user.user_id)
|
||
round_row = await conn.fetchrow(
|
||
"SELECT play_format, course_source, teeoff_facility_slug, teeoff_course_id, "
|
||
"personal_course_id, completed_at FROM round WHERE id = $1",
|
||
round_id,
|
||
)
|
||
if round_row["play_format"] not in _TWO_SIDED_FORMATS:
|
||
raise app_error(400, "VALIDATION_FAILED", "Denne spilleformen bruker ikke sider.")
|
||
if round_row["completed_at"] is not None:
|
||
raise app_error(409, "ALREADY_COMPLETED", "Runden er allerede fullført.")
|
||
existing_count = await conn.fetchval("SELECT count(*) FROM round_side WHERE round_id = $1", round_id)
|
||
if existing_count >= 2:
|
||
raise app_error(409, "LIMIT_REACHED", "En runde kan maks ha to sider.")
|
||
|
||
async with conn.transaction():
|
||
side_row = await conn.fetchrow(
|
||
"INSERT INTO round_side (round_id, label) VALUES ($1, $2) RETURNING id::text AS id, label",
|
||
round_id, body.label,
|
||
)
|
||
# Delt-ball-formater (ADR-039 Beslutning C): siden får sine
|
||
# round_hole-rader med en gang -- rating trengs ikke her, kun
|
||
# par/stroke-index-snapshot, uavhengig av om siden har fått
|
||
# noen deltakere ennå.
|
||
engine_format = _ROUND_FORMAT_TO_ENGINE_FORMAT[round_row["play_format"]]
|
||
if engine_format in SIDE_IS_UNIT:
|
||
resolved = await _resolve_round_course(round_row)
|
||
for hole_number, par, stroke_index in resolved.holes:
|
||
await conn.execute(
|
||
"INSERT INTO round_hole (round_side_id, hole_number, par, stroke_index) VALUES ($1, $2, $3, $4)",
|
||
side_row["id"], hole_number, par, stroke_index,
|
||
)
|
||
await broadcast_round_update(round_id)
|
||
return RoundSideOut(**dict(side_row))
|
||
|
||
|
||
@router.delete("/rounds/{round_id}/sides/{side_id}", status_code=204)
|
||
async def delete_round_side(
|
||
round_id: str,
|
||
side_id: str,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> None:
|
||
async with plain_connection() as conn:
|
||
await _get_owned_round_or_404(conn, round_id, user.user_id)
|
||
round_row = await conn.fetchrow("SELECT completed_at FROM round WHERE id = $1", round_id)
|
||
if round_row["completed_at"] is not None:
|
||
raise app_error(409, "ALREADY_COMPLETED", "Runden er allerede fullført.")
|
||
side_exists = await conn.fetchval(
|
||
"SELECT 1 FROM round_side WHERE id = $1 AND round_id = $2", side_id, round_id
|
||
)
|
||
if not side_exists:
|
||
raise app_error(404, "NOT_FOUND", "Siden finnes ikke.")
|
||
# Kaskade fjerner sidens round_hole-rader; deltakere som var på
|
||
# denne siden faller tilbake til round_side_id = NULL (ON DELETE
|
||
# SET NULL) -- de forblir i runden, bare uten side-tilhørighet.
|
||
await conn.execute("DELETE FROM round_side WHERE id = $1", side_id)
|
||
await broadcast_round_update(round_id)
|
||
|
||
|
||
@router.get("/rounds/{round_id}/tee-options", response_model=list[TeeOption])
|
||
async def get_round_tee_options(round_id: str, user: CurrentUser = Depends(get_current_user)) -> list[TeeOption]:
|
||
"""Utslagene tilgjengelig på RUNDENS bane -- brukt av 'rediger spiller'-
|
||
panelet til å la eieren velge et annet utslag enn rundens default for en
|
||
enkelt deltaker (f.eks. et kjønnsdelt utslag). Tilgjengelig for eier
|
||
ELLER en lenket medspiller (samme lese-tilgang som resten av runden)."""
|
||
async with plain_connection() as conn:
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
round_row = await conn.fetchrow(
|
||
"SELECT course_source, teeoff_facility_slug, teeoff_course_id, personal_course_id FROM round WHERE id = $1",
|
||
round_id,
|
||
)
|
||
if round_row["course_source"] == "teeoff":
|
||
resolved = await _resolve_teeoff_course(round_row["teeoff_facility_slug"], int(round_row["teeoff_course_id"]))
|
||
else:
|
||
resolved = await _resolve_personal_course(round_row["personal_course_id"])
|
||
return resolved.tee_options()
|
||
|
||
|
||
class ParticipantUpdate(BaseModel):
|
||
# Vanlig exclude_unset-PATCH-semantikk, som resten av appen -- et
|
||
# utelatt felt endres ikke. `handicap_index` kan sendes eksplisitt som
|
||
# `null` for å fjerne HCP-sporing for denne deltakeren (samme mønster
|
||
# som profil-PATCH-en).
|
||
stat_level: StatLevel | None = None
|
||
# Utslagssted OG HCP er begge KUN et snapshot for DENNE runden (2026-07-26)
|
||
# -- endrer aldri spillerens faktiske profil, samme reproduserbarhets-
|
||
# prinsipp som resten av round_participant. Bevisst avvist etter at
|
||
# runden er fullført, samme presedens som bane-bytte i RoundUpdate
|
||
# (differensialen er da allerede beregnet fra det gamle grunnlaget).
|
||
tee_name: str | None = None
|
||
handicap_index: float | None = Field(default=None, ge=-10, le=54)
|
||
# KUN gyldig for en gjest (user_id IS NULL) -- gir ingen mening for en
|
||
# lenket bruker, som allerede har sin egen kontos navn/kjønn/e-post.
|
||
# `gender` er en del av rating-bunten under (påvirker hvilken utslags-
|
||
# rating som er gyldig), `guest_name`/`guest_email` er rene metadata.
|
||
guest_name: str | None = Field(default=None, min_length=1, max_length=100)
|
||
gender: Literal["m", "f", "x"] | None = None
|
||
guest_email: EmailStr | None = None
|
||
# ADR-038 Beslutning C -- eneste feltet en IKKE-eier (en lenket
|
||
# medspiller som redigerer SIN EGEN rad) får sende her.
|
||
exclude_from_handicap: bool | None = None
|
||
# ADR-039 Beslutning A -- (re)tildel/fjern en deltakers side. Sendes som
|
||
# `null` for å fjerne fra en side. Eier-only (se _OWNER_ONLY_
|
||
# PARTICIPANT_FIELDS under).
|
||
round_side_id: str | None = None
|
||
|
||
|
||
# Felt en ikke-eier ALDRI kan sende her, uansett hvilken rad det gjelder --
|
||
# eier-only, se update_participant sin autorisasjonssjekk.
|
||
_OWNER_ONLY_PARTICIPANT_FIELDS = {
|
||
"stat_level", "tee_name", "handicap_index", "guest_name", "gender", "guest_email", "round_side_id",
|
||
}
|
||
|
||
|
||
@router.patch("/rounds/{round_id}/participants/{participant_id}", response_model=RoundParticipantOut)
|
||
async def update_participant(
|
||
round_id: str,
|
||
participant_id: str,
|
||
body: ParticipantUpdate,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> RoundParticipantOut:
|
||
updates = body.model_dump(exclude_unset=True)
|
||
if not updates:
|
||
raise app_error(400, "VALIDATION_FAILED", "Ingen felt å oppdatere.")
|
||
|
||
async with plain_connection() as conn:
|
||
# Eier ELLER en lenket medspiller (som kun får røre SIN EGEN
|
||
# eksklusjons-flagg, se under) -- ikke strengt eier-only lenger.
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
current = await conn.fetchrow(
|
||
"""
|
||
SELECT rp.user_id::text AS user_id, rp.gender, rp.tee_name_snapshot,
|
||
rp.handicap_index_snapshot::float AS handicap_index_snapshot,
|
||
rp.counts_for_handicap,
|
||
r.owner_user_id::text AS round_owner_user_id,
|
||
r.completed_at, r.course_source, r.teeoff_facility_slug,
|
||
r.teeoff_course_id, r.personal_course_id, r.play_format
|
||
FROM round_participant rp
|
||
JOIN round r ON r.id = rp.round_id
|
||
WHERE rp.id = $1 AND rp.round_id = $2
|
||
""",
|
||
participant_id, round_id,
|
||
)
|
||
if current is None:
|
||
raise app_error(404, "NOT_FOUND", "Deltakeren finnes ikke på denne runden.")
|
||
|
||
is_owner = current["round_owner_user_id"] == user.user_id
|
||
if not is_owner:
|
||
if _OWNER_ONLY_PARTICIPANT_FIELDS & updates.keys():
|
||
raise app_error(
|
||
403, "NOT_AUTHORIZED",
|
||
"Du kan kun endre om DIN egen deltakelse skal telle mot ditt faktiske HCP her.",
|
||
)
|
||
if current["user_id"] != user.user_id:
|
||
raise app_error(403, "NOT_AUTHORIZED", "Du kan kun endre dette for din egen deltakelse.")
|
||
|
||
guest_only_fields = {"guest_name", "gender", "guest_email"}
|
||
if current["user_id"] is not None and guest_only_fields & updates.keys():
|
||
raise app_error(
|
||
400, "VALIDATION_FAILED",
|
||
"Navn/kjønn/e-post kan ikke endres her for en spiller med egen konto -- kun for en gjest.",
|
||
)
|
||
|
||
rating_changed = "tee_name" in updates or "handicap_index" in updates or "gender" in updates
|
||
if rating_changed and current["completed_at"] is not None:
|
||
raise app_error(
|
||
409, "ALREADY_COMPLETED",
|
||
"Runden er allerede fullført -- kan ikke endre utslag, HCP eller kjønn i etterkant.",
|
||
)
|
||
|
||
set_clauses: list[str] = []
|
||
values: list[object] = []
|
||
|
||
if "stat_level" in updates:
|
||
values.append(updates["stat_level"])
|
||
set_clauses.append(f"stat_level = ${len(values)}")
|
||
if "guest_name" in updates:
|
||
values.append(updates["guest_name"].strip())
|
||
set_clauses.append(f"guest_name = ${len(values)}")
|
||
if "guest_email" in updates:
|
||
values.append(updates["guest_email"])
|
||
set_clauses.append(f"guest_email = ${len(values)}")
|
||
if "exclude_from_handicap" in updates:
|
||
values.append(updates["exclude_from_handicap"])
|
||
set_clauses.append(f"exclude_from_handicap = ${len(values)}")
|
||
if "round_side_id" in updates:
|
||
new_side_id = updates["round_side_id"]
|
||
if new_side_id is not None:
|
||
if current["play_format"] not in _TWO_SIDED_FORMATS:
|
||
raise app_error(400, "VALIDATION_FAILED", "Denne spilleformen bruker ikke sider.")
|
||
side_exists = await conn.fetchval(
|
||
"SELECT 1 FROM round_side WHERE id = $1 AND round_id = $2", new_side_id, round_id
|
||
)
|
||
if not side_exists:
|
||
raise app_error(404, "NOT_FOUND", "Siden finnes ikke på denne runden.")
|
||
await _check_side_capacity(conn, new_side_id, current["play_format"], exclude_participant_id=participant_id)
|
||
values.append(new_side_id)
|
||
set_clauses.append(f"round_side_id = ${len(values)}")
|
||
|
||
if rating_changed:
|
||
if current["course_source"] == "teeoff":
|
||
resolved = await _resolve_teeoff_course(
|
||
current["teeoff_facility_slug"], int(current["teeoff_course_id"])
|
||
)
|
||
else:
|
||
resolved = await _resolve_personal_course(current["personal_course_id"])
|
||
|
||
new_tee_name = updates.get("tee_name") or current["tee_name_snapshot"]
|
||
new_gender = updates.get("gender") or current["gender"]
|
||
new_handicap_index = (
|
||
updates["handicap_index"] if "handicap_index" in updates else current["handicap_index_snapshot"]
|
||
)
|
||
rating = resolved.rating_for(new_tee_name, new_gender)
|
||
if rating is None:
|
||
raise app_error(
|
||
400, "VALIDATION_FAILED",
|
||
"Valgt utslag har ingen rating for spillerens (nye) kjønn.",
|
||
)
|
||
course_rating, slope_rating, tee_par = rating
|
||
course_handicap_snapshot = (
|
||
course_handicap(new_handicap_index, slope_rating, course_rating, tee_par)
|
||
if new_handicap_index is not None else None
|
||
)
|
||
|
||
values.append(new_tee_name)
|
||
set_clauses.append(f"tee_name_snapshot = ${len(values)}")
|
||
values.append(new_handicap_index)
|
||
set_clauses.append(f"handicap_index_snapshot = ${len(values)}")
|
||
values.append(course_rating)
|
||
set_clauses.append(f"course_rating_snapshot = ${len(values)}")
|
||
values.append(slope_rating)
|
||
set_clauses.append(f"slope_rating_snapshot = ${len(values)}")
|
||
values.append(tee_par)
|
||
set_clauses.append(f"tee_par_snapshot = ${len(values)}")
|
||
values.append(course_handicap_snapshot)
|
||
set_clauses.append(f"course_handicap_snapshot = ${len(values)}")
|
||
if "gender" in updates:
|
||
values.append(new_gender)
|
||
set_clauses.append(f"gender = ${len(values)}")
|
||
|
||
values.append(participant_id)
|
||
updated_id = await conn.fetchval(
|
||
f"UPDATE round_participant SET {', '.join(set_clauses)} WHERE id = ${len(values)} RETURNING id",
|
||
*values,
|
||
)
|
||
|
||
# Side-tildeling endret (ADR-039) -- regn playing_handicap for begge
|
||
# sider på nytt FØR raden under leses, slik at responsen reflekterer
|
||
# den ferske verdien (billig no-op hvis fortsatt ikke komplett).
|
||
if "round_side_id" in updates and current["play_format"] in _TWO_SIDED_FORMATS:
|
||
await _recompute_side_handicaps(conn, round_id, current["play_format"])
|
||
|
||
row = await conn.fetchrow(
|
||
"""
|
||
SELECT rp.id::text AS id, rp.user_id::text AS user_id, rp.guest_name, rp.guest_email,
|
||
COALESCE(rp.guest_name, au.display_name, 'Medspiller') AS display_name,
|
||
rp.is_owner, rp.gender, rp.tee_name_snapshot,
|
||
rp.handicap_index_snapshot::float AS handicap_index_snapshot,
|
||
rp.course_handicap_snapshot, rp.counts_for_handicap,
|
||
rp.score_differential::float AS score_differential, rp.stat_level,
|
||
rp.exclude_from_handicap, rp.round_side_id::text AS round_side_id,
|
||
rp.playing_handicap
|
||
FROM round_participant rp
|
||
LEFT JOIN app_user au ON au.id = rp.user_id
|
||
WHERE rp.id = $1
|
||
""",
|
||
updated_id,
|
||
)
|
||
|
||
# En eksklusjons-endring på en ALLEREDE FULLFØRT, tellende runde
|
||
# endrer umiddelbart hvilke differensialer faktisk HCP skal regnes
|
||
# fra -- regn på nytt med en gang, ikke vent til neste fullføring.
|
||
if (
|
||
"exclude_from_handicap" in updates
|
||
and current["user_id"] is not None
|
||
and current["completed_at"] is not None
|
||
):
|
||
await _recompute_computed_handicap_index(conn, current["user_id"])
|
||
await broadcast_round_update(round_id)
|
||
return RoundParticipantOut(**dict(row))
|
||
|
||
|
||
@router.delete("/rounds/{round_id}/participants/{participant_id}", status_code=204)
|
||
async def remove_guest_participant(
|
||
round_id: str,
|
||
participant_id: str,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> None:
|
||
async with plain_connection() as conn:
|
||
await _get_owned_round_or_404(conn, round_id, user.user_id)
|
||
row = await conn.fetchrow(
|
||
"SELECT is_owner, user_id::text AS user_id, counts_for_handicap FROM round_participant "
|
||
"WHERE id = $1 AND round_id = $2",
|
||
participant_id, round_id,
|
||
)
|
||
if row is None:
|
||
raise app_error(404, "NOT_FOUND", "Deltakeren finnes ikke.")
|
||
if row["is_owner"]:
|
||
raise app_error(400, "VALIDATION_FAILED", "Kan ikke fjerne runde-eieren.")
|
||
await conn.execute("DELETE FROM round_participant WHERE id = $1", participant_id)
|
||
|
||
# Fjerner en tellende differensial fra grunnlaget -- regn faktisk
|
||
# HCP på nytt for den fjernede spilleren (ikke eieren, som er igjen).
|
||
if row["user_id"] is not None and row["counts_for_handicap"]:
|
||
await _recompute_computed_handicap_index(conn, row["user_id"])
|
||
await broadcast_round_update(round_id)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Hull-for-hull-registrering
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class RoundHoleOut(BaseModel):
|
||
hole_number: int
|
||
par: int
|
||
stroke_index: int
|
||
played: bool
|
||
score: int | None
|
||
putts: int | None
|
||
club_off_tee: str | None
|
||
tee_shot_result: str | None
|
||
approach_result: str | None
|
||
chip_count: int | None
|
||
bunker_shot_count: int | None
|
||
penalty_strokes: int | None
|
||
first_putt_distance_bucket: str | None
|
||
anyway_strokes: int | None
|
||
# Slag mottatt på dette hullet, utledet fra course_handicap_snapshot
|
||
# (samme allokeringsalgoritme som resten av appen) -- kun til visning
|
||
# av netto-score i en oversiktstabell, aldri lagret. None hvis
|
||
# deltakeren ikke har en beregnet course handicap (f.eks. gjest uten
|
||
# HCP).
|
||
strokes_received: int | None
|
||
|
||
|
||
async def _build_participant_holes(conn, round_id: str, participant_id: str) -> list[RoundHoleOut]:
|
||
"""Delt mellom den autentiserte GET og den offentlige/venn-gatede
|
||
/public/rounds-varianten (ADR-036 fase 2) -- selve dataen er identisk,
|
||
kun autorisasjonssjekken FØR dette kalles skiller de to."""
|
||
participant_row = await conn.fetchrow(
|
||
"SELECT course_handicap_snapshot FROM round_participant WHERE id = $1 AND round_id = $2",
|
||
participant_id, round_id,
|
||
)
|
||
if participant_row is None:
|
||
raise app_error(404, "NOT_FOUND", "Deltakeren finnes ikke på denne runden.")
|
||
rows = await conn.fetch(
|
||
"""
|
||
SELECT hole_number, par, stroke_index, played, score, putts, club_off_tee,
|
||
tee_shot_result, approach_result, chip_count, bunker_shot_count,
|
||
penalty_strokes, first_putt_distance_bucket, anyway_strokes
|
||
FROM round_hole WHERE round_participant_id = $1 ORDER BY hole_number
|
||
""",
|
||
participant_id,
|
||
)
|
||
|
||
strokes_received_by_hole: dict[int, int] | None = None
|
||
if participant_row["course_handicap_snapshot"] is not None:
|
||
allocation = allocate_strokes_by_index(
|
||
participant_row["course_handicap_snapshot"], [r["stroke_index"] for r in rows]
|
||
)
|
||
strokes_received_by_hole = {r["hole_number"]: a for r, a in zip(rows, allocation)}
|
||
|
||
return [
|
||
RoundHoleOut(
|
||
**dict(r),
|
||
strokes_received=strokes_received_by_hole[r["hole_number"]] if strokes_received_by_hole else None,
|
||
)
|
||
for r in rows
|
||
]
|
||
|
||
|
||
@router.get(
|
||
"/rounds/{round_id}/participants/{participant_id}/holes",
|
||
response_model=list[RoundHoleOut],
|
||
)
|
||
async def list_holes(
|
||
round_id: str,
|
||
participant_id: str,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> list[RoundHoleOut]:
|
||
async with plain_connection() as conn:
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
return await _build_participant_holes(conn, round_id, participant_id)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Delt-ball-scoring (ADR-039 Beslutning C) -- foursome/greensome/scramble
|
||
# lagrer ÉN score PER SIDE per hull, ikke per spiller. Ingen av de andre
|
||
# detalj-feltene (kølle/retning/chip/bunker/straffeslag/putt-lengde) gir
|
||
# entydig mening for en delt ball -- kun selve slagtallet.
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class RoundSideHoleOut(BaseModel):
|
||
hole_number: int
|
||
par: int
|
||
stroke_index: int
|
||
played: bool
|
||
score: int | None
|
||
# Slag mottatt av SIDEN (kombinert playing_handicap, samme for begge
|
||
# partnere på siden) på dette hullet -- samme allokeringsalgoritme og
|
||
# samme "kun til visning av netto"-begrunnelse som RoundHoleOut sin
|
||
# strokes_received. None hvis siden ikke har en beregnet playing
|
||
# handicap ennå (f.eks. kun én av to partnere tildelt).
|
||
strokes_received: int | None = None
|
||
|
||
|
||
async def _build_side_holes(conn, round_id: str, side_id: str) -> list[RoundSideHoleOut]:
|
||
"""Delt mellom den autentiserte GET og /public/rounds (ADR-036 fase 2)
|
||
-- se _build_participant_holes over for samme begrunnelse."""
|
||
side_exists = await conn.fetchval("SELECT 1 FROM round_side WHERE id = $1 AND round_id = $2", side_id, round_id)
|
||
if not side_exists:
|
||
raise app_error(404, "NOT_FOUND", "Siden finnes ikke.")
|
||
rows = await conn.fetch(
|
||
"SELECT hole_number, par, stroke_index, played, score FROM round_hole "
|
||
"WHERE round_side_id = $1 ORDER BY hole_number",
|
||
side_id,
|
||
)
|
||
playing_handicap = await conn.fetchval(
|
||
"SELECT playing_handicap FROM round_participant WHERE round_side_id = $1 LIMIT 1", side_id
|
||
)
|
||
|
||
strokes_received_by_hole: dict[int, int] | None = None
|
||
if playing_handicap is not None:
|
||
allocation = allocate_strokes_by_index(playing_handicap, [r["stroke_index"] for r in rows])
|
||
strokes_received_by_hole = {r["hole_number"]: a for r, a in zip(rows, allocation)}
|
||
|
||
return [
|
||
RoundSideHoleOut(
|
||
**dict(r),
|
||
strokes_received=strokes_received_by_hole[r["hole_number"]] if strokes_received_by_hole else None,
|
||
)
|
||
for r in rows
|
||
]
|
||
|
||
|
||
@router.get("/rounds/{round_id}/sides/{side_id}/holes", response_model=list[RoundSideHoleOut])
|
||
async def list_side_holes(
|
||
round_id: str,
|
||
side_id: str,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> list[RoundSideHoleOut]:
|
||
async with plain_connection() as conn:
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
return await _build_side_holes(conn, round_id, side_id)
|
||
|
||
|
||
class SideHoleUpdate(BaseModel):
|
||
played: bool = True
|
||
score: int | None = Field(default=None, ge=1, le=20)
|
||
|
||
|
||
@router.patch("/rounds/{round_id}/sides/{side_id}/holes/{hole_number}", response_model=RoundSideHoleOut)
|
||
async def update_side_hole(
|
||
round_id: str,
|
||
side_id: str,
|
||
hole_number: int,
|
||
body: SideHoleUpdate,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> RoundSideHoleOut:
|
||
async with plain_connection() as conn:
|
||
# Samme begrunnelse som update_hole -- en medspiller som fører
|
||
# score for flighten skal også kunne føre for en delt-ball-side.
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
side_exists = await conn.fetchval("SELECT 1 FROM round_side WHERE id = $1 AND round_id = $2", side_id, round_id)
|
||
if not side_exists:
|
||
raise app_error(404, "NOT_FOUND", "Siden finnes ikke.")
|
||
row = await conn.fetchrow(
|
||
"""
|
||
UPDATE round_hole SET played = $3, score = $4
|
||
WHERE round_side_id = $1 AND hole_number = $2
|
||
RETURNING hole_number, par, stroke_index, played, score
|
||
""",
|
||
side_id, hole_number, body.played, body.score,
|
||
)
|
||
if row is None:
|
||
raise app_error(404, "NOT_FOUND", "Hullet finnes ikke på denne siden.")
|
||
await broadcast_round_update(round_id)
|
||
return RoundSideHoleOut(**dict(row))
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Format-resultat (ADR-039) -- løpende matchstatus (match/fourball/foursome/
|
||
# greensome/scramble) eller skins-tavle, avledet ved LESING (aldri lagret),
|
||
# samme "cache aldri det som kan regnes ut fra rå data"-filosofi som resten
|
||
# av appen. Slagspill trenger ingen egen visning her -- eksisterende
|
||
# scorekort/leaderboard dekker det allerede.
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class FormatHoleEntry(BaseModel):
|
||
"""Én "enhet" sitt tall på ett hull -- en deltaker for individuell-ball-
|
||
formater (match/fourball/skins), eller en SIDE for delt-ball-formater
|
||
(foursome/greensome/scramble, ADR-039 Beslutning C: én score for hele
|
||
siden, ingen individuell deltaker-rad å vise i stedet)."""
|
||
|
||
id: str # participant_id, eller round_side_id for delt-ball
|
||
label: str
|
||
side: Literal["a", "b"] | None = None # kun to-sidede formater
|
||
gross: int | None = None
|
||
net: int | None = None # None hvis ingen course handicap er klart (eller skins_scoring="gross")
|
||
strokes_received: int | None = None
|
||
# Fourball: KUN den ene av de to partnernes netto teller for siden det
|
||
# hullet (R&A-regelen: laveste netto blant lagets spillere) -- markerer
|
||
# HVILKEN, slik at "hvorfor vant siden" er synlig uten egen forklarende
|
||
# tekst. Alltid sann for formater med kun én enhet per side (match,
|
||
# foursome/greensome/scramble sin ene side-rad).
|
||
counted: bool = True
|
||
|
||
|
||
class FormatHoleOut(BaseModel):
|
||
hole_number: int
|
||
par: int
|
||
stroke_index: int
|
||
entries: list[FormatHoleEntry]
|
||
result: str | None = None # to-sidede formater: "a"/"b"/"halved"
|
||
winner_ids: list[str] | None = None # skins: hvem vant (evt. delte) hullets skin(s)
|
||
carried: bool | None = None # skins: hullet var uavgjort og potten rullet videre
|
||
|
||
|
||
class RoundFormatResultOut(BaseModel):
|
||
play_format: str
|
||
ready: bool # False = handicap ikke klart for én eller begge sider ennå
|
||
# Match/fourball/foursome/greensome/scramble:
|
||
match_lead: int | None = None
|
||
match_holes_played: int | None = None
|
||
match_holes_remaining: int | None = None
|
||
match_is_closed: bool | None = None
|
||
match_is_dormie: bool | None = None
|
||
match_status_text: str | None = None
|
||
hole_results: list[str] | None = None # "a"/"b"/"halved" per avgjort hull, i spillerekkefølge
|
||
# Skins:
|
||
skins_won: dict[str, float] | None = None
|
||
# Hull-for-hull-forløp (2026-07-28, "hvorfor ble resultatet som det ble" --
|
||
# brutto/netto/slag-mottatt per enhet, ikke bare et vinn/tap-merke).
|
||
# None når ready=False (to-sidede formater) -- ellers alltid satt,
|
||
# inkl. skins (som ikke har noe eget "ready"-konsept).
|
||
holes: list[FormatHoleOut] | None = None
|
||
|
||
|
||
def _round_hole_order(start_hole: int, holes_planned: int) -> list[int]:
|
||
"""Samme sirkulære spillerekkefølge som frontend allerede bruker
|
||
(round-detail.tsx) -- starter på start_hole, ruller rundt 1-18."""
|
||
return [((start_hole - 1 + i) % 18) + 1 for i in range(holes_planned)]
|
||
|
||
|
||
async def _build_format_result(conn, round_id: str) -> RoundFormatResultOut:
|
||
"""Delt mellom den autentiserte GET og den offentlige/venn-gatede
|
||
/public/rounds-varianten (ADR-036 fase 2) -- selve dataen er identisk,
|
||
kun autorisasjonssjekken FØR dette kalles skiller de to."""
|
||
round_row = await conn.fetchrow(
|
||
"SELECT play_format, skins_scoring, skins_tie_handling, start_hole, holes_planned "
|
||
"FROM round WHERE id = $1",
|
||
round_id,
|
||
)
|
||
play_format = round_row["play_format"]
|
||
|
||
if play_format in _TWO_SIDED_FORMATS:
|
||
relative = await _relative_strokes_for_round(conn, round_id, play_format)
|
||
if not relative:
|
||
return RoundFormatResultOut(play_format=play_format, ready=False)
|
||
|
||
engine_format = _ROUND_FORMAT_TO_ENGINE_FORMAT[play_format]
|
||
play_order = _round_hole_order(round_row["start_hole"], round_row["holes_planned"])
|
||
|
||
if engine_format in SIDE_IS_UNIT:
|
||
# Delt ball -- én rad per SIDE per hull. "Enheten" ER siden,
|
||
# så label = side.label (fallback "Side A"/"Side B" avgjøres
|
||
# under, samme sortert-på-id-konvensjon som frontend bruker
|
||
# for match_status_text sin bokstavelige "(A)"/"(B)").
|
||
rows = await conn.fetch(
|
||
"""
|
||
SELECT rh.round_side_id::text AS unit, rh.hole_number, rh.par, rh.stroke_index, rh.played, rh.score
|
||
FROM round_hole rh
|
||
JOIN round_side rs ON rs.id = rh.round_side_id
|
||
WHERE rs.round_id = $1
|
||
""",
|
||
round_id,
|
||
)
|
||
side_label_rows = await conn.fetch(
|
||
"SELECT id::text AS id, label FROM round_side WHERE round_id = $1", round_id
|
||
)
|
||
unit_label = {r["id"]: r["label"] for r in side_label_rows}
|
||
unit_to_side: dict[str, str] | None = None
|
||
else:
|
||
# Individuell ball -- nøkkelen ("unit") er DELTAKEREN selv
|
||
# (samme som _relative_strokes_for_round sin nøkkel for
|
||
# disse formatene). Henter navn+side-tilhørighet i samme
|
||
# spørring (én rundtur, ikke to).
|
||
rows = await conn.fetch(
|
||
"""
|
||
SELECT rp.id::text AS unit, rh.hole_number, rh.par, rh.stroke_index, rh.played, rh.score
|
||
FROM round_hole rh
|
||
JOIN round_participant rp ON rp.id = rh.round_participant_id
|
||
WHERE rp.round_id = $1 AND rp.round_side_id IS NOT NULL
|
||
""",
|
||
round_id,
|
||
)
|
||
participant_label_rows = await conn.fetch(
|
||
"""
|
||
SELECT rp.id::text AS id, rp.round_side_id::text AS side_id,
|
||
COALESCE(rp.guest_name, au.display_name, 'Medspiller') AS label
|
||
FROM round_participant rp LEFT JOIN app_user au ON au.id = rp.user_id
|
||
WHERE rp.round_id = $1
|
||
""",
|
||
round_id,
|
||
)
|
||
unit_label = {r["id"]: r["label"] for r in participant_label_rows}
|
||
unit_to_side = {r["id"]: r["side_id"] for r in participant_label_rows}
|
||
|
||
by_unit_hole: dict[tuple[str, int], list] = {}
|
||
stroke_index_by_hole: dict[int, int] = {}
|
||
par_by_hole: dict[int, int] = {}
|
||
for r in rows:
|
||
if r["played"] and r["score"] is not None:
|
||
by_unit_hole.setdefault((r["unit"], r["hole_number"]), []).append(r["score"])
|
||
stroke_index_by_hole[r["hole_number"]] = r["stroke_index"]
|
||
par_by_hole[r["hole_number"]] = r["par"]
|
||
all_18_si = [stroke_index_by_hole[h] for h in range(1, 19)] if len(stroke_index_by_hole) == 18 else None
|
||
|
||
if engine_format in SIDE_IS_UNIT:
|
||
side_ids = sorted(relative.keys())
|
||
else:
|
||
side_ids = sorted({s for s in unit_to_side.values() if s is not None})
|
||
|
||
if len(side_ids) != 2 or all_18_si is None:
|
||
return RoundFormatResultOut(play_format=play_format, ready=False)
|
||
|
||
strokes_per_hole = {
|
||
unit: dict(zip(range(1, 19), allocate_over_played_holes(v, all_18_si, list(range(1, 19)))))
|
||
for unit, v in relative.items()
|
||
}
|
||
side_a_id, side_b_id = side_ids
|
||
side_label_of: dict[str, Literal["a", "b"]] = {side_a_id: "a", side_b_id: "b"}
|
||
expected_players = _SIDE_PLAYER_COUNT[play_format]
|
||
|
||
def units_for_side(side_id: str) -> list[str]:
|
||
if engine_format in SIDE_IS_UNIT:
|
||
return [side_id]
|
||
return [uid for uid, sid in unit_to_side.items() if sid == side_id]
|
||
|
||
# Delt ball -- siden ER enheten (nøyaktig én per side), uansett
|
||
# hvor mange SPILLERE formatet krever. "expected_players" (2 for
|
||
# foursome/greensome, 2 eller 4 for scramble) er PLAYER-antallet,
|
||
# ikke UNIT-antallet -- bruk kun for individuell ball, der hver
|
||
# spiller er sin egen enhet.
|
||
required_units = 1 if engine_format in SIDE_IS_UNIT else expected_players
|
||
|
||
def side_net(hole_number: int, side_id: str) -> int | None:
|
||
nets = []
|
||
for unit_id in units_for_side(side_id):
|
||
scores = by_unit_hole.get((unit_id, hole_number), [])
|
||
if len(scores) != 1:
|
||
return None
|
||
per_hole = strokes_per_hole.get(unit_id)
|
||
if per_hole is None:
|
||
return None
|
||
nets.append(scores[0] - per_hole[hole_number])
|
||
if len(nets) != required_units:
|
||
return None
|
||
return min(nets)
|
||
|
||
hole_results: list[HoleResult] = []
|
||
# Hull-for-hull-forløp (2026-07-28) -- samme sannhetskilde/
|
||
# trunkering som hole_results: kun hull som er FERDIG avgjort
|
||
# (begge sider komplette) tas med, i samme rekkefølge. Et
|
||
# ufullstendig hull (noen har registrert, andre ikke) vises
|
||
# ikke her ennå -- samme "vent til begge er ferdig"-prinsipp
|
||
# som resten av match-motoren.
|
||
holes: list[FormatHoleOut] = []
|
||
for hole_number in play_order:
|
||
net_a = side_net(hole_number, side_a_id)
|
||
net_b = side_net(hole_number, side_b_id)
|
||
if net_a is None or net_b is None:
|
||
break
|
||
if net_a < net_b:
|
||
hole_results.append(HoleResult.SIDE_A)
|
||
elif net_b < net_a:
|
||
hole_results.append(HoleResult.SIDE_B)
|
||
else:
|
||
hole_results.append(HoleResult.HALVED)
|
||
|
||
entries: list[FormatHoleEntry] = []
|
||
for side_id, side_net_value in ((side_a_id, net_a), (side_b_id, net_b)):
|
||
for unit_id in units_for_side(side_id):
|
||
gross = by_unit_hole[(unit_id, hole_number)][0]
|
||
strokes = strokes_per_hole[unit_id][hole_number]
|
||
net = gross - strokes
|
||
entries.append(
|
||
FormatHoleEntry(
|
||
id=unit_id,
|
||
label=unit_label.get(unit_id, "Ukjent"),
|
||
side=side_label_of[side_id],
|
||
gross=gross,
|
||
net=net,
|
||
strokes_received=strokes,
|
||
# Fourball: kun laveste av de to partnernes
|
||
# netto teller for siden -- markerer HVILKEN,
|
||
# slik at "hvorfor vant siden" er synlig uten
|
||
# egen forklarende tekst (R&A-regelen, samme
|
||
# side_net()-funksjon over).
|
||
counted=(net == side_net_value),
|
||
)
|
||
)
|
||
holes.append(
|
||
FormatHoleOut(
|
||
hole_number=hole_number,
|
||
par=par_by_hole[hole_number],
|
||
stroke_index=stroke_index_by_hole[hole_number],
|
||
entries=entries,
|
||
result=_RESULT_LABEL[hole_results[-1]],
|
||
)
|
||
)
|
||
|
||
state = compute_match_state(hole_results, total_holes=round_row["holes_planned"])
|
||
return RoundFormatResultOut(
|
||
play_format=play_format,
|
||
ready=True,
|
||
match_lead=state.lead,
|
||
match_holes_played=state.holes_played,
|
||
match_holes_remaining=state.holes_remaining,
|
||
match_is_closed=state.is_closed,
|
||
match_is_dormie=state.is_dormie,
|
||
match_status_text=state.describe(),
|
||
hole_results=[_RESULT_LABEL[r] for r in hole_results],
|
||
holes=holes,
|
||
)
|
||
|
||
if play_format == "skins":
|
||
participant_rows = await conn.fetch(
|
||
"""
|
||
SELECT rp.id::text AS id, rp.course_handicap_snapshot,
|
||
COALESCE(rp.guest_name, au.display_name, 'Medspiller') AS label
|
||
FROM round_participant rp LEFT JOIN app_user au ON au.id = rp.user_id
|
||
WHERE rp.round_id = $1
|
||
""",
|
||
round_id,
|
||
)
|
||
label_by_participant = {p["id"]: p["label"] for p in participant_rows}
|
||
hole_rows = await conn.fetch(
|
||
"""
|
||
SELECT rp.id::text AS participant_id, rh.hole_number, rh.par, rh.stroke_index, rh.played, rh.score
|
||
FROM round_hole rh JOIN round_participant rp ON rp.id = rh.round_participant_id
|
||
WHERE rp.round_id = $1
|
||
ORDER BY rh.hole_number
|
||
""",
|
||
round_id,
|
||
)
|
||
strokes_by_participant: dict[str, dict[int, int]] = {}
|
||
if round_row["skins_scoring"] == "net":
|
||
by_participant_holes: dict[str, list] = {}
|
||
for r in hole_rows:
|
||
by_participant_holes.setdefault(r["participant_id"], []).append(r)
|
||
ch_by_participant = {p["id"]: p["course_handicap_snapshot"] for p in participant_rows}
|
||
for pid, holes_for_participant in by_participant_holes.items():
|
||
ch = ch_by_participant.get(pid)
|
||
if ch is None:
|
||
continue
|
||
allocation = allocate_strokes_by_index(ch, [h["stroke_index"] for h in holes_for_participant])
|
||
strokes_by_participant[pid] = {h["hole_number"]: a for h, a in zip(holes_for_participant, allocation)}
|
||
|
||
is_net_mode = round_row["skins_scoring"] == "net"
|
||
gross_by_hole_number: dict[int, dict[str, int]] = {}
|
||
par_by_hole: dict[int, int] = {}
|
||
si_by_hole: dict[int, int] = {}
|
||
scores_by_hole_number: dict[int, list[tuple[str, int]]] = {}
|
||
for r in hole_rows:
|
||
par_by_hole[r["hole_number"]] = r["par"]
|
||
si_by_hole[r["hole_number"]] = r["stroke_index"]
|
||
if not r["played"] or r["score"] is None:
|
||
continue
|
||
gross_by_hole_number.setdefault(r["hole_number"], {})[r["participant_id"]] = r["score"]
|
||
if is_net_mode:
|
||
per_hole = strokes_by_participant.get(r["participant_id"])
|
||
if per_hole is None:
|
||
continue
|
||
value = r["score"] - per_hole[r["hole_number"]]
|
||
else:
|
||
value = r["score"]
|
||
scores_by_hole_number.setdefault(r["hole_number"], []).append((r["participant_id"], value))
|
||
|
||
play_order = _round_hole_order(round_row["start_hole"], round_row["holes_planned"])
|
||
scores_by_hole = [scores_by_hole_number.get(h, []) for h in play_order]
|
||
skins_won, hole_log = compute_skins_detail(scores_by_hole, tie_handling=round_row["skins_tie_handling"])
|
||
|
||
# Hull-for-hull-forløp -- kun hull der minst én deltaker faktisk
|
||
# har registrert en score tas med (et helt tomt hull har
|
||
# ingenting å vise frem).
|
||
holes = []
|
||
for hole_number, log_entry in zip(play_order, hole_log):
|
||
if not log_entry.values:
|
||
continue
|
||
gross_this_hole = gross_by_hole_number.get(hole_number, {})
|
||
entries = [
|
||
FormatHoleEntry(
|
||
id=pid,
|
||
label=label_by_participant.get(pid, "Ukjent"),
|
||
gross=gross_this_hole.get(pid),
|
||
net=value if is_net_mode else None,
|
||
strokes_received=strokes_by_participant.get(pid, {}).get(hole_number) if is_net_mode else None,
|
||
)
|
||
for pid, value in log_entry.values.items()
|
||
]
|
||
holes.append(
|
||
FormatHoleOut(
|
||
hole_number=hole_number,
|
||
par=par_by_hole[hole_number],
|
||
stroke_index=si_by_hole[hole_number],
|
||
entries=entries,
|
||
winner_ids=list(log_entry.awarded.keys()),
|
||
carried=log_entry.carried,
|
||
)
|
||
)
|
||
return RoundFormatResultOut(play_format=play_format, ready=True, skins_won=skins_won, holes=holes)
|
||
|
||
return RoundFormatResultOut(play_format=play_format, ready=True)
|
||
|
||
|
||
@router.get("/rounds/{round_id}/format-result", response_model=RoundFormatResultOut)
|
||
async def get_round_format_result(
|
||
round_id: str,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> RoundFormatResultOut:
|
||
async with plain_connection() as conn:
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
return await _build_format_result(conn, round_id)
|
||
|
||
|
||
class LeaderboardHoleOut(BaseModel):
|
||
hole_number: int
|
||
par: int
|
||
stroke_index: int
|
||
played: bool
|
||
score: int | None
|
||
# None når deltakeren ikke har noen beregnet course handicap (2026-07-26,
|
||
# samme betingelse som net_score_to_par/total_points under).
|
||
strokes_received: int | None
|
||
|
||
|
||
class LeaderboardEntryOut(BaseModel):
|
||
participant_id: str
|
||
display_name: str
|
||
is_owner: bool
|
||
holes_played: int
|
||
total_score: int | None
|
||
score_to_par: int | None
|
||
# None når deltakeren ikke har noen beregnet course handicap (f.eks.
|
||
# gjest uten registrert HCP) -- samme begrensning som strokes_received
|
||
# i RoundHoleOut/list_holes, samme algoritme (allocate_strokes_by_index).
|
||
net_score_to_par: int | None
|
||
# Stableford-poengsum (2026-07-26, etterspurt av bruker) -- samme
|
||
# betingelse/algoritme som net_score_to_par (krever course handicap),
|
||
# summert over spilte hull med Math.max(0, par - netto + 2) per hull.
|
||
total_points: int | None
|
||
# Hullscorer (2026-07-26, etterspurt av bruker) -- samme rader som
|
||
# allerede ble hentet for å beregne total_score/net_score_to_par over,
|
||
# bare også eksponert rått slik at leaderboardet kan vise dem per hull.
|
||
holes: list[LeaderboardHoleOut]
|
||
|
||
|
||
class LeaderboardOut(BaseModel):
|
||
holes_planned: int
|
||
completed: bool
|
||
entries: list[LeaderboardEntryOut]
|
||
|
||
|
||
async def _build_leaderboard(conn, round_id: str) -> LeaderboardOut:
|
||
"""Delt mellom den autentiserte GET og den offentlige/venn-gatede
|
||
/public/rounds-varianten (ADR-036 fase 2)."""
|
||
round_row = await conn.fetchrow(
|
||
"SELECT holes_planned, completed_at FROM round WHERE id = $1", round_id
|
||
)
|
||
participant_rows = await conn.fetch(
|
||
"""
|
||
SELECT rp.id::text AS id, rp.is_owner, rp.guest_name, rp.course_handicap_snapshot,
|
||
au.display_name AS linked_display_name
|
||
FROM round_participant rp
|
||
LEFT JOIN app_user au ON au.id = rp.user_id
|
||
WHERE rp.round_id = $1
|
||
ORDER BY rp.is_owner DESC, rp.created_at
|
||
""",
|
||
round_id,
|
||
)
|
||
|
||
entries: list[LeaderboardEntryOut] = []
|
||
for p in participant_rows:
|
||
hole_rows = await conn.fetch(
|
||
"SELECT hole_number, par, stroke_index, played, score FROM round_hole WHERE round_participant_id = $1 ORDER BY hole_number",
|
||
p["id"],
|
||
)
|
||
played_holes = [h for h in hole_rows if h["played"] and h["score"] is not None]
|
||
holes_played = len(played_holes)
|
||
total_score = sum(h["score"] for h in played_holes) if holes_played else None
|
||
total_par = sum(h["par"] for h in played_holes) if holes_played else None
|
||
score_to_par = total_score - total_par if total_score is not None else None
|
||
|
||
# Beregnes uavhengig av om noen hull faktisk er spilt ennå --
|
||
# brukt BÅDE for net_score_to_par/total_points under OG for
|
||
# strokes_received per hull i den rå hull-listen som returneres.
|
||
strokes_received_by_hole: dict[int, int] = {}
|
||
if p["course_handicap_snapshot"] is not None:
|
||
allocation = allocate_strokes_by_index(
|
||
p["course_handicap_snapshot"], [h["stroke_index"] for h in hole_rows]
|
||
)
|
||
strokes_received_by_hole = {h["hole_number"]: a for h, a in zip(hole_rows, allocation)}
|
||
|
||
net_score_to_par = None
|
||
total_points = None
|
||
if total_score is not None and strokes_received_by_hole:
|
||
strokes_received_total = sum(strokes_received_by_hole[h["hole_number"]] for h in played_holes)
|
||
net_score_to_par = score_to_par - strokes_received_total
|
||
# Samme stableford-formel som round-scorecard.tsx sin
|
||
# stablefordPoints(): 2 poeng for netto par, +/-1 per slag,
|
||
# gulvet på 0.
|
||
total_points = sum(
|
||
max(0, h["par"] - (h["score"] - strokes_received_by_hole[h["hole_number"]]) + 2)
|
||
for h in played_holes
|
||
)
|
||
|
||
# Aldri "Deg" her -- leaderboardet kan nå ses av flere (eier
|
||
# OG lenkede medspillere, ADR-036 fase 3-utvidelsen), så et
|
||
# viewer-relativt "Deg" ville vært feil for de andre som ser på.
|
||
display_name = p["guest_name"] or p["linked_display_name"] or "Medspiller"
|
||
entries.append(
|
||
LeaderboardEntryOut(
|
||
participant_id=p["id"],
|
||
display_name=display_name,
|
||
is_owner=p["is_owner"],
|
||
holes_played=holes_played,
|
||
total_score=total_score,
|
||
score_to_par=score_to_par,
|
||
net_score_to_par=net_score_to_par,
|
||
total_points=total_points,
|
||
holes=[
|
||
LeaderboardHoleOut(
|
||
hole_number=h["hole_number"],
|
||
par=h["par"],
|
||
stroke_index=h["stroke_index"],
|
||
played=h["played"],
|
||
score=h["score"],
|
||
strokes_received=strokes_received_by_hole.get(h["hole_number"]),
|
||
)
|
||
for h in hole_rows
|
||
],
|
||
)
|
||
)
|
||
|
||
entries.sort(key=lambda e: (e.score_to_par is None, e.score_to_par))
|
||
|
||
return LeaderboardOut(
|
||
holes_planned=round_row["holes_planned"],
|
||
completed=round_row["completed_at"] is not None,
|
||
entries=entries,
|
||
)
|
||
|
||
|
||
@router.get("/rounds/{round_id}/leaderboard", response_model=LeaderboardOut)
|
||
async def get_leaderboard(round_id: str, user: CurrentUser = Depends(get_current_user)) -> LeaderboardOut:
|
||
async with plain_connection() as conn:
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
return await _build_leaderboard(conn, round_id)
|
||
|
||
|
||
class HoleUpdate(BaseModel):
|
||
played: bool = True
|
||
score: int | None = Field(default=None, ge=1, le=20)
|
||
putts: int | None = Field(default=None, ge=0, le=10)
|
||
club_off_tee: str | None = Field(default=None, max_length=50)
|
||
tee_shot_result: Literal["fairway", "left", "right"] | None = None
|
||
approach_result: Literal["hit", "long", "short", "left", "right"] | None = None
|
||
chip_count: int | None = Field(default=None, ge=0)
|
||
bunker_shot_count: int | None = Field(default=None, ge=0)
|
||
penalty_strokes: int | None = Field(default=None, ge=0)
|
||
first_putt_distance_bucket: Literal["<1m", "<2m", "<3m", "<5m", "<8m", "8m+"] | None = None
|
||
anyway_strokes: int | None = Field(default=None, ge=0)
|
||
|
||
|
||
@router.patch(
|
||
"/rounds/{round_id}/participants/{participant_id}/holes/{hole_number}",
|
||
response_model=RoundHoleOut,
|
||
)
|
||
async def update_hole(
|
||
round_id: str,
|
||
participant_id: str,
|
||
hole_number: int,
|
||
body: HoleUpdate,
|
||
user: CurrentUser = Depends(get_current_user),
|
||
) -> RoundHoleOut:
|
||
async with plain_connection() as conn:
|
||
# ADR-036 fase 3-utvidelsen (2026-07-26): en lenket medspiller kan
|
||
# registrere score for HELE flighten (bekreftet regel), ikke bare
|
||
# sin egen rad -- derfor accessible-sjekk, ikke owner-only, og
|
||
# INGEN participant_id == viewer-sjekk under.
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
participant_row = await conn.fetchrow(
|
||
"SELECT course_handicap_snapshot FROM round_participant WHERE id = $1 AND round_id = $2",
|
||
participant_id, round_id,
|
||
)
|
||
if participant_row is None:
|
||
raise app_error(404, "NOT_FOUND", "Deltakeren finnes ikke på denne runden.")
|
||
|
||
async with translate_db_errors():
|
||
row = await conn.fetchrow(
|
||
"""
|
||
UPDATE round_hole SET
|
||
played = $3, score = $4, putts = $5, club_off_tee = $6,
|
||
tee_shot_result = $7, approach_result = $8, chip_count = $9,
|
||
bunker_shot_count = $10, penalty_strokes = $11, first_putt_distance_bucket = $12,
|
||
anyway_strokes = $13
|
||
WHERE round_participant_id = $1 AND hole_number = $2
|
||
RETURNING hole_number, par, stroke_index, played, score, putts, club_off_tee,
|
||
tee_shot_result, approach_result, chip_count, bunker_shot_count,
|
||
penalty_strokes, first_putt_distance_bucket, anyway_strokes
|
||
""",
|
||
participant_id, hole_number,
|
||
body.played, body.score, body.putts, body.club_off_tee,
|
||
body.tee_shot_result, body.approach_result, body.chip_count,
|
||
body.bunker_shot_count, body.penalty_strokes, body.first_putt_distance_bucket,
|
||
body.anyway_strokes,
|
||
)
|
||
if row is None:
|
||
raise app_error(404, "NOT_FOUND", "Hullet finnes ikke på denne deltakeren.")
|
||
|
||
# strokes_received er utledet av HELE rundens stroke-indeks-rekkefølge
|
||
# (samme allokeringsalgoritme som list_holes/GET), ikke bare dette ene
|
||
# hullet -- må derfor hente alle 18 sin stroke_index for å plassere
|
||
# riktig antall mottatte slag på nøyaktig dette hullet.
|
||
strokes_received = None
|
||
if participant_row["course_handicap_snapshot"] is not None:
|
||
all_indexes = await conn.fetch(
|
||
"SELECT hole_number, stroke_index FROM round_hole WHERE round_participant_id = $1 ORDER BY hole_number",
|
||
participant_id,
|
||
)
|
||
allocation = allocate_strokes_by_index(
|
||
participant_row["course_handicap_snapshot"], [r["stroke_index"] for r in all_indexes]
|
||
)
|
||
by_hole = {r["hole_number"]: a for r, a in zip(all_indexes, allocation)}
|
||
strokes_received = by_hole[hole_number]
|
||
|
||
await broadcast_round_update(round_id)
|
||
return RoundHoleOut(**dict(row), strokes_received=strokes_received)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Fullføring -- Adjusted Gross Score / Score Differential (ADR-033 Beslutning G)
|
||
# ---------------------------------------------------------------------------
|
||
|
||
@router.post("/rounds/{round_id}/complete", response_model=RoundOut)
|
||
async def complete_round(round_id: str, user: CurrentUser = Depends(get_current_user)) -> RoundOut:
|
||
async with plain_connection() as conn:
|
||
# Samme begrunnelse som update_hole -- en medspiller som fører
|
||
# score for flighten skal også kunne markere runden ferdig.
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
round_row = await conn.fetchrow(
|
||
"SELECT holes_planned, play_format, owner_user_id::text AS owner_user_id, name, course_name_snapshot "
|
||
"FROM round WHERE id = $1",
|
||
round_id,
|
||
)
|
||
|
||
# 2026-07-28 oppfølging: match/skins/fourball/foursome/greensome/
|
||
# scramble krever flere spillere enn slagspill -- ingenting fanget
|
||
# dette opp før nå. Avvis tydelig FØR noe regnes ut, i stedet for å
|
||
# stille fullføre en runde som er strukturelt umulig for formatet.
|
||
setup_complete, setup_message = await _format_setup_status(conn, round_id, round_row["play_format"])
|
||
if not setup_complete:
|
||
raise app_error(409, "SETUP_INCOMPLETE", setup_message)
|
||
|
||
participants = await conn.fetch(
|
||
"""
|
||
SELECT id::text AS id, user_id::text AS user_id,
|
||
handicap_index_snapshot::float AS handicap_index_snapshot,
|
||
course_rating_snapshot::float AS course_rating_snapshot,
|
||
slope_rating_snapshot, tee_par_snapshot
|
||
FROM round_participant WHERE round_id = $1
|
||
""",
|
||
round_id,
|
||
)
|
||
|
||
for p in participants:
|
||
holes = await conn.fetch(
|
||
"""
|
||
SELECT hole_number, par, stroke_index, played, score
|
||
FROM round_hole WHERE round_participant_id = $1 ORDER BY hole_number
|
||
""",
|
||
p["id"],
|
||
)
|
||
played_count = sum(1 for h in holes if h["played"])
|
||
counts = round_counts_for_handicap(played_count, round_row["holes_planned"])
|
||
differential = None
|
||
|
||
if counts and p["handicap_index_snapshot"] is not None and p["course_rating_snapshot"] is not None:
|
||
pars = [h["par"] for h in holes]
|
||
strokes_received = allocate_strokes_by_index(
|
||
_course_handicap_from_row(p),
|
||
[h["stroke_index"] for h in holes],
|
||
)
|
||
scores = [h["score"] if h["played"] else None for h in holes]
|
||
ags = adjusted_gross_score(scores, pars, strokes_received)
|
||
differential = score_differential(ags, p["course_rating_snapshot"], p["slope_rating_snapshot"])
|
||
|
||
await conn.execute(
|
||
"UPDATE round_participant SET counts_for_handicap = $2, score_differential = $3 WHERE id = $1",
|
||
p["id"], counts, differential,
|
||
)
|
||
|
||
await conn.execute("UPDATE round SET completed_at = now() WHERE id = $1", round_id)
|
||
|
||
# Faktisk HCP (ADR-038) -- alle differensialer for runden er nå
|
||
# skrevet, regn på nytt for hver deltaker med egen konto (gjester
|
||
# har ingen computed_handicap_index å oppdatere).
|
||
for p in participants:
|
||
if p["user_id"] is not None:
|
||
await _recompute_computed_handicap_index(conn, p["user_id"])
|
||
|
||
# Rundevarsler (2026-07-28 oppfølging av ADR-036 fase 2) -- to
|
||
# atskilte mottakergrupper med ulik lenke, siden de har ulik
|
||
# tilgang: lenkede medspillere ser den fulle autentiserte siden,
|
||
# tredjeparts-venner kun tredjeparts-/spectator-visningen.
|
||
actor_name = await conn.fetchval("SELECT display_name FROM app_user WHERE id = $1", user.user_id)
|
||
round_label = (round_row["name"] or "").strip() or round_row["course_name_snapshot"]
|
||
message = f"{actor_name} fullførte runden ({round_label})."
|
||
|
||
linked_ids = {p["user_id"] for p in participants if p["user_id"] is not None}
|
||
linked_ids.discard(user.user_id)
|
||
for uid in linked_ids:
|
||
await create_notification(
|
||
conn, user_id=uid, type="result", message=message, link_path=f"/my-rounds/{round_id}",
|
||
)
|
||
|
||
watcher_ids = set(await _friends_who_can_see_round(conn, round_id, round_row["owner_user_id"]))
|
||
watcher_ids -= linked_ids
|
||
watcher_ids.discard(user.user_id)
|
||
for uid in watcher_ids:
|
||
await create_notification(
|
||
conn, user_id=uid, type="result", message=message, link_path=f"/watch/{round_id}",
|
||
)
|
||
|
||
result = await _load_round_out(conn, round_id, user.user_id)
|
||
|
||
await broadcast_round_update(round_id)
|
||
return result
|
||
|
||
|
||
def _course_handicap_from_row(p) -> int:
|
||
return course_handicap(
|
||
p["handicap_index_snapshot"], p["slope_rating_snapshot"], p["course_rating_snapshot"], p["tee_par_snapshot"]
|
||
)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Sanntid (2026-07-26, oppfølging av ADR-027) -- "noe endret seg, hent på
|
||
# nytt"-signal for round-detail.tsx/round-stats.tsx/round-scorecard.tsx.
|
||
# Denne PRIVATE varianten krever alltid en ekte, autorisert sesjon (eier
|
||
# ELLER lenket medspiller) -- en anonym/tredjeparts-venn kan ikke bruke
|
||
# denne, se `/ws/public/rounds/{round_id}/live` under (ADR-036 fase 2,
|
||
# 2026-07-28) for den offentlige/venn-gatede varianten.
|
||
# ---------------------------------------------------------------------------
|
||
|
||
@router.websocket("/ws/rounds/{round_id}/live")
|
||
async def round_live_ws(websocket: WebSocket, round_id: str) -> None:
|
||
user = await get_current_user_from_websocket(websocket)
|
||
if user is None:
|
||
await websocket.close(code=4401)
|
||
return
|
||
async with plain_connection() as conn:
|
||
try:
|
||
await _get_accessible_round_or_404(conn, round_id, user.user_id)
|
||
except HTTPException as exc:
|
||
await websocket.close(code=4404 if exc.status_code == 404 else 4403)
|
||
return
|
||
|
||
await websocket.accept()
|
||
sockets = live_sockets_for_round(round_id)
|
||
sockets.add(websocket)
|
||
try:
|
||
while True:
|
||
await websocket.receive_text()
|
||
except WebSocketDisconnect:
|
||
pass
|
||
finally:
|
||
sockets.discard(websocket)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Tredjeparts/offentlig lesevisning (ADR-036 fase 2, 2026-07-28) -- en venn
|
||
# (i en synlig kategori) eller alle (visibility_mode='public') kan følge en
|
||
# runde live UTEN å være eier/deltaker. Samme "egen /public-prefiks,
|
||
# get_current_user_optional"-mønster som turneringers offentlige side
|
||
# (ADR-018/026/027) -- egne, leaner response-modeller (aldri guest_email,
|
||
# som er PII, og aldri my_*/setup_*, som kun gir mening for eier/deltaker),
|
||
# men gjenbruker de SAMME underliggende dataleserne
|
||
# (_build_participant_holes/_build_side_holes/_build_leaderboard/
|
||
# _build_format_result) som de autentiserte endepunktene over, for å unngå
|
||
# to implementasjoner av samme forretningslogikk.
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class PublicRoundParticipantOut(BaseModel):
|
||
id: str
|
||
display_name: str
|
||
is_owner: bool
|
||
gender: str
|
||
tee_name_snapshot: str
|
||
handicap_index_snapshot: float | None
|
||
course_handicap_snapshot: int | None
|
||
round_side_id: str | None
|
||
playing_handicap: int | None
|
||
|
||
|
||
class PublicRoundOut(BaseModel):
|
||
id: str
|
||
name: str | None
|
||
course_name_snapshot: str
|
||
tee_name_snapshot: str
|
||
played_at: date
|
||
start_hole: int
|
||
holes_planned: int
|
||
play_format: str
|
||
completed_at: str | None
|
||
owner_display_name: str
|
||
participants: list[PublicRoundParticipantOut]
|
||
sides: list[RoundSideOut]
|
||
|
||
|
||
async def _build_public_round_out(conn, round_id: str) -> PublicRoundOut:
|
||
round_row = await conn.fetchrow(
|
||
"""
|
||
SELECT id::text AS id, name, course_name_snapshot, tee_name_snapshot,
|
||
played_at, start_hole, holes_planned, play_format, completed_at,
|
||
owner_user_id::text AS owner_user_id
|
||
FROM round WHERE id = $1
|
||
""",
|
||
round_id,
|
||
)
|
||
owner_display_name = await conn.fetchval(
|
||
"SELECT display_name FROM app_user WHERE id = $1", round_row["owner_user_id"]
|
||
)
|
||
participant_rows = await conn.fetch(
|
||
"""
|
||
SELECT rp.id::text AS id,
|
||
COALESCE(rp.guest_name, au.display_name, 'Medspiller') AS display_name,
|
||
rp.is_owner, rp.gender, rp.tee_name_snapshot,
|
||
rp.handicap_index_snapshot::float AS handicap_index_snapshot,
|
||
rp.course_handicap_snapshot, rp.round_side_id::text AS round_side_id,
|
||
rp.playing_handicap
|
||
FROM round_participant rp
|
||
LEFT JOIN app_user au ON au.id = rp.user_id
|
||
WHERE rp.round_id = $1 ORDER BY rp.is_owner DESC, rp.created_at
|
||
""",
|
||
round_id,
|
||
)
|
||
side_rows = await conn.fetch(
|
||
"SELECT id::text AS id, label FROM round_side WHERE round_id = $1 ORDER BY id", round_id
|
||
)
|
||
return PublicRoundOut(
|
||
id=round_row["id"],
|
||
name=round_row["name"],
|
||
course_name_snapshot=round_row["course_name_snapshot"],
|
||
tee_name_snapshot=round_row["tee_name_snapshot"],
|
||
played_at=round_row["played_at"],
|
||
start_hole=round_row["start_hole"],
|
||
holes_planned=round_row["holes_planned"],
|
||
play_format=round_row["play_format"],
|
||
completed_at=round_row["completed_at"].isoformat() if round_row["completed_at"] else None,
|
||
owner_display_name=owner_display_name or "Ukjent",
|
||
participants=[PublicRoundParticipantOut(**dict(r)) for r in participant_rows],
|
||
sides=[RoundSideOut(**dict(r)) for r in side_rows],
|
||
)
|
||
|
||
|
||
@router.get("/public/rounds/{round_id}", response_model=PublicRoundOut)
|
||
async def get_public_round(
|
||
round_id: str,
|
||
user: CurrentUser | None = Depends(get_current_user_optional),
|
||
) -> PublicRoundOut:
|
||
async with plain_connection() as conn:
|
||
await _get_viewable_round_or_404(conn, round_id, user.user_id if user else None)
|
||
return await _build_public_round_out(conn, round_id)
|
||
|
||
|
||
@router.get(
|
||
"/public/rounds/{round_id}/participants/{participant_id}/holes",
|
||
response_model=list[RoundHoleOut],
|
||
)
|
||
async def get_public_participant_holes(
|
||
round_id: str,
|
||
participant_id: str,
|
||
user: CurrentUser | None = Depends(get_current_user_optional),
|
||
) -> list[RoundHoleOut]:
|
||
async with plain_connection() as conn:
|
||
await _get_viewable_round_or_404(conn, round_id, user.user_id if user else None)
|
||
return await _build_participant_holes(conn, round_id, participant_id)
|
||
|
||
|
||
@router.get("/public/rounds/{round_id}/sides/{side_id}/holes", response_model=list[RoundSideHoleOut])
|
||
async def get_public_side_holes(
|
||
round_id: str,
|
||
side_id: str,
|
||
user: CurrentUser | None = Depends(get_current_user_optional),
|
||
) -> list[RoundSideHoleOut]:
|
||
async with plain_connection() as conn:
|
||
await _get_viewable_round_or_404(conn, round_id, user.user_id if user else None)
|
||
return await _build_side_holes(conn, round_id, side_id)
|
||
|
||
|
||
@router.get("/public/rounds/{round_id}/leaderboard", response_model=LeaderboardOut)
|
||
async def get_public_leaderboard(
|
||
round_id: str,
|
||
user: CurrentUser | None = Depends(get_current_user_optional),
|
||
) -> LeaderboardOut:
|
||
async with plain_connection() as conn:
|
||
await _get_viewable_round_or_404(conn, round_id, user.user_id if user else None)
|
||
return await _build_leaderboard(conn, round_id)
|
||
|
||
|
||
@router.get("/public/rounds/{round_id}/format-result", response_model=RoundFormatResultOut)
|
||
async def get_public_format_result(
|
||
round_id: str,
|
||
user: CurrentUser | None = Depends(get_current_user_optional),
|
||
) -> RoundFormatResultOut:
|
||
async with plain_connection() as conn:
|
||
await _get_viewable_round_or_404(conn, round_id, user.user_id if user else None)
|
||
return await _build_format_result(conn, round_id)
|
||
|
||
|
||
@router.websocket("/ws/public/rounds/{round_id}/live")
|
||
async def public_round_live_ws(websocket: WebSocket, round_id: str) -> None:
|
||
user = await get_current_user_from_websocket(websocket)
|
||
async with plain_connection() as conn:
|
||
try:
|
||
await _get_viewable_round_or_404(conn, round_id, user.user_id if user else None)
|
||
except HTTPException as exc:
|
||
await websocket.close(code=4404 if exc.status_code == 404 else 4403)
|
||
return
|
||
|
||
await websocket.accept()
|
||
sockets = live_sockets_for_round(round_id)
|
||
sockets.add(websocket)
|
||
try:
|
||
while True:
|
||
await websocket.receive_text()
|
||
except WebSocketDisconnect:
|
||
pass
|
||
finally:
|
||
sockets.discard(websocket)
|
||
|
||
|
||
class PublicPersonRoundOut(BaseModel):
|
||
id: str
|
||
name: str | None
|
||
course_name_snapshot: str
|
||
played_at: date
|
||
completed_at: str | None
|
||
play_format: str
|
||
|
||
|
||
@router.get("/public/people/{user_id}/rounds", response_model=list[PublicPersonRoundOut])
|
||
async def list_public_person_rounds(
|
||
user_id: str,
|
||
user: CurrentUser | None = Depends(get_current_user_optional),
|
||
) -> list[PublicPersonRoundOut]:
|
||
"""Brukes av vennprofil-siden (ADR-036 fase 2) -- lister EIERENS runder
|
||
som SPØRREREN har lov til å se (public alltid, friends kun med riktig
|
||
kategori-match, private aldri) -- egen lenket medspiller-runde vises
|
||
ikke her (det er "Mine runder", en annen sak). Pågående
|
||
(completed_at IS NULL) alltid øverst, deretter nyeste fullførte."""
|
||
async with plain_connection() as conn:
|
||
person_exists = await conn.fetchval("SELECT 1 FROM app_user WHERE id = $1", user_id)
|
||
if person_exists is None:
|
||
raise app_error(404, "NOT_FOUND", "Fant ikke brukeren.")
|
||
rows = await conn.fetch(
|
||
"""
|
||
SELECT id::text AS id, name, course_name_snapshot, played_at, completed_at, play_format
|
||
FROM round WHERE owner_user_id = $1
|
||
ORDER BY (completed_at IS NULL) DESC, played_at DESC, created_at DESC
|
||
""",
|
||
user_id,
|
||
)
|
||
viewer_id = user.user_id if user else None
|
||
visible = [r for r in rows if await _can_view_round(conn, r["id"], viewer_id)]
|
||
return [
|
||
PublicPersonRoundOut(
|
||
id=r["id"],
|
||
name=r["name"],
|
||
course_name_snapshot=r["course_name_snapshot"],
|
||
played_at=r["played_at"],
|
||
completed_at=r["completed_at"].isoformat() if r["completed_at"] else None,
|
||
play_format=r["play_format"],
|
||
)
|
||
for r in visible
|
||
]
|