""" Kommunikasjon (ADR-025): lag-intern chat («det hemmelige rommet») og offentlig runde-feed («Banter Board»). Delt `message`-tabell (migrasjon 013) med en scope-diskriminator, men to helt ulike autorisasjonsmodeller: - Lag-chat (`router`, /orgs/...): org-medlemskap (get_authorized_org) + `user_is_rostered_on_team` -- BEVISST INGEN org-admin-unntak, ulikt resten av appen. Ekte privat. - Offentlig feed (`public_router`, /public/tournaments/...): LESING gjenbruker registration.py sitt trenivå-visibility-mønster uendret (inkl. anonym tilgang for `public`-synlige turneringer). POSTING/SLETTING er strengere -- krever ekte innlogging OG org-medlemskap ELLER faktisk deltakelse i akkurat denne turneringen (ikke bare "kan se den"). Sanntid via WebSockets (ADR-025 Beslutning B): et rent in-memory tilkoblingsregister PER PROSESS -- trygt med dagens ene `teecup_api`- container, men deles IKKE på tvers av flere prosesser/containere (samme klasse begrensning som den allerede aksepterte in-memory-cachen, se ARCHITECTURE_DECISIONS.md sine "Åpne spørsmål"). WS-rutene kan ikke bruke get_current_user/get_authorized_org direkte (de er Request-typet, ikke WebSocket-kompatible via Depends()) -- egne, minimale kopier av samme sjekker brukes i stedet. """ from collections import defaultdict from fastapi import APIRouter, Depends, File, Form, UploadFile, WebSocket, WebSocketDisconnect from pydantic import BaseModel from ..auth import CurrentUser, get_authorized_org, get_current_user, get_current_user_optional from ..auth import get_current_user_from_websocket from ..db import org_connection, plain_connection from ..errors import app_error, translate_db_errors from ..realtime import live_sockets_for from ..team_authz import is_org_admin, user_is_rostered_on_team from .. import storage from .registration import check_visibility, code_matches, is_participant, resolve_org router = APIRouter(tags=["messaging"]) public_router = APIRouter(prefix="/public/tournaments", tags=["public-messaging"]) _MESSAGE_COLUMNS = """ id::text, author_user_id::text, author_display_name, body, image_key, created_at """ class MessageOut(BaseModel): id: str author_user_id: str author_display_name: str body: str | None image_url: str | None created_at: str def _row_to_message(row) -> MessageOut: return MessageOut( id=row["id"], author_user_id=row["author_user_id"], author_display_name=row["author_display_name"], body=row["body"], image_url=storage.public_url(row["image_key"]) if row["image_key"] else None, created_at=row["created_at"].isoformat(), ) async def _resolve_author_display_name(conn, organization_id: str, user_id: str) -> str: """Fryses ved skrivetidspunkt (samme prinsipp som handicap_index_snapshot, ADR-007) -- avsenderens player.display_name i DENNE org-en hvis den finnes, ellers e-postens lokaldel (dekker org-ansatte uten egen spillerprofil som poster i den offentlige feeden).""" name = await conn.fetchval( "SELECT display_name FROM player WHERE organization_id = $1 AND user_id = $2 LIMIT 1", organization_id, user_id, ) if name: return name async with plain_connection() as plain: email = await plain.fetchval("SELECT email FROM app_user WHERE id = $1", user_id) return email.split("@")[0] if email else "Ukjent" async def _read_optional_image(image: UploadFile | None) -> bytes | None: if image is None: return None if image.content_type not in storage.ALLOWED_INPUT_CONTENT_TYPES: raise app_error(400, "VALIDATION_FAILED", "Ustøttet bildeformat.") raw = await image.read(storage.MAX_UPLOAD_BYTES + 1) if len(raw) > storage.MAX_UPLOAD_BYTES: raise app_error(400, "VALIDATION_FAILED", "Bildet er for stort (maks 8 MB).") return raw # --- Sanntid: in-memory tilkoblingsregister (se moduldocstring) ------------ _team_sockets: dict[str, set[WebSocket]] = defaultdict(set) _feed_sockets: dict[str, set[WebSocket]] = defaultdict(set) async def _broadcast(sockets: set[WebSocket], payload: dict) -> None: dead = [] for ws in list(sockets): try: await ws.send_json(payload) except Exception: dead.append(ws) for ws in dead: sockets.discard(ws) async def _is_org_member(user_id: str, organization_id: str) -> bool: """WS-variant av get_authorized_org sin medlemskapssjekk -- samme grunn som get_current_user_from_websocket: ingen HTTP Request å binde Depends() til i en WS-scope.""" async with plain_connection() as conn: return bool( await conn.fetchval( "SELECT EXISTS (SELECT 1 FROM organization_membership WHERE user_id = $1 AND organization_id = $2)", user_id, organization_id, ) ) # --------------------------------------------------------------------------- # Lag-chat (privat) -- /orgs/... # --------------------------------------------------------------------------- @router.get("/orgs/{organization_id}/teams/{team_id}/messages", response_model=list[MessageOut]) async def list_team_messages( team_id: str, organization_id: str = Depends(get_authorized_org), user: CurrentUser = Depends(get_current_user), ) -> list[MessageOut]: async with org_connection(organization_id) as conn: exists = await conn.fetchval("SELECT id FROM team WHERE id = $1", team_id) if exists is None: raise app_error(404, "NOT_FOUND", "Laget finnes ikke.") if not await user_is_rostered_on_team(conn, team_id, user.user_id): raise app_error(403, "NOT_ROSTERED_ON_TEAM", "Du er ikke rostret på dette laget.") rows = await conn.fetch( f""" SELECT {_MESSAGE_COLUMNS} FROM message WHERE team_id = $1 AND scope = 'team' ORDER BY created_at """, team_id, ) return [_row_to_message(r) for r in rows] @router.post( "/orgs/{organization_id}/teams/{team_id}/messages", response_model=MessageOut, status_code=201 ) async def send_team_message( team_id: str, body: str | None = Form(default=None), image: UploadFile | None = File(default=None), organization_id: str = Depends(get_authorized_org), user: CurrentUser = Depends(get_current_user), ) -> MessageOut: if not body and image is None: raise app_error(400, "VALIDATION_FAILED", "Meldingen må ha tekst eller bilde.") raw = await _read_optional_image(image) async with org_connection(organization_id) as conn, translate_db_errors(): team = await conn.fetchrow( "SELECT tournament_id::text AS tournament_id FROM team WHERE id = $1", team_id ) if team is None: raise app_error(404, "NOT_FOUND", "Laget finnes ikke.") if not await user_is_rostered_on_team(conn, team_id, user.user_id): raise app_error(403, "NOT_ROSTERED_ON_TEAM", "Du er ikke rostret på dette laget.") image_key = None if raw is not None: try: image_key = await storage.upload_image("messages", team_id, raw) except storage.InvalidImageError: raise app_error(400, "VALIDATION_FAILED", "Filen er ikke et gyldig bilde.") display_name = await _resolve_author_display_name(conn, organization_id, user.user_id) row = await conn.fetchrow( f""" INSERT INTO message (organization_id, scope, tournament_id, team_id, author_user_id, author_display_name, body, image_key) VALUES ($1, 'team', $2, $3, $4, $5, $6, $7) RETURNING {_MESSAGE_COLUMNS} """, organization_id, team["tournament_id"], team_id, user.user_id, display_name, body, image_key, ) message = _row_to_message(row) await _broadcast(_team_sockets[team_id], message.model_dump()) return message @router.delete( "/orgs/{organization_id}/teams/{team_id}/messages/{message_id}", status_code=204 ) async def delete_team_message( team_id: str, message_id: str, organization_id: str = Depends(get_authorized_org), user: CurrentUser = Depends(get_current_user), ) -> None: """Kun forfatteren selv -- INGEN org-admin-unntak (samme begrunnelse som lesetilgangen: et ekte privat rom har ingen ekstern moderator).""" async with org_connection(organization_id) as conn: row = await conn.fetchrow( """ SELECT author_user_id::text AS author_user_id FROM message WHERE id = $1 AND team_id = $2 AND scope = 'team' """, message_id, team_id, ) if row is None: raise app_error(404, "NOT_FOUND", "Meldingen finnes ikke.") if row["author_user_id"] != user.user_id: raise app_error(403, "NOT_MESSAGE_AUTHOR", "Du kan kun slette dine egne meldinger.") await conn.execute("DELETE FROM message WHERE id = $1", message_id) @router.websocket("/ws/orgs/{organization_id}/teams/{team_id}/messages") async def team_chat_ws(websocket: WebSocket, organization_id: str, team_id: str) -> None: user = await get_current_user_from_websocket(websocket) if user is None: await websocket.close(code=4401) return if not await _is_org_member(user.user_id, organization_id): await websocket.close(code=4403) return async with org_connection(organization_id) as conn: allowed = await user_is_rostered_on_team(conn, team_id, user.user_id) if not allowed: await websocket.close(code=4403) return await websocket.accept() _team_sockets[team_id].add(websocket) try: while True: # Klienten sender ingenting -- denne løkken finnes kun for å # oppdage disconnect (receive() kaster WebSocketDisconnect da). await websocket.receive_text() except WebSocketDisconnect: pass finally: _team_sockets[team_id].discard(websocket) # --------------------------------------------------------------------------- # Offentlig runde-feed -- /public/tournaments/... # --------------------------------------------------------------------------- async def _may_post_to_feed(conn, user: CurrentUser, organization_id: str, tournament_id: str) -> bool: """Strengere enn LESING (check_visibility): en 'public'-synlig turnering kan leses helt anonymt, men posting krever alltid ekte innlogging OG tilknytning -- org-medlem ELLER faktisk deltaker/registrert i NØYAKTIG denne turneringen. Hindrer at en helt urelatert innlogget bruker (konto et helt annet sted i systemet) kan poste på en fremmed offentlig side.""" is_member = await conn.fetchval( "SELECT EXISTS (SELECT 1 FROM organization_membership WHERE user_id = $1 AND organization_id = $2)", user.user_id, organization_id, ) if is_member: return True return await is_participant(conn, user.user_id, organization_id, tournament_id) @public_router.get("/{tournament_id}/feed", response_model=list[MessageOut]) async def get_feed( tournament_id: str, code: str | None = None, user: CurrentUser | None = Depends(get_current_user_optional), ) -> list[MessageOut]: organization_id = await resolve_org(tournament_id) async with org_connection(organization_id) as conn: row = await conn.fetchrow( "SELECT visibility, join_code FROM tournament WHERE id = $1", tournament_id ) if row is None: raise app_error(404, "NOT_FOUND", "Turneringen finnes ikke.") if not code_matches(row["join_code"], code): await check_visibility(conn, row["visibility"], organization_id, tournament_id, user) rows = await conn.fetch( f""" SELECT {_MESSAGE_COLUMNS} FROM message WHERE tournament_id = $1 AND scope = 'tournament_feed' ORDER BY created_at """, tournament_id, ) return [_row_to_message(r) for r in rows] @public_router.post("/{tournament_id}/feed", response_model=MessageOut, status_code=201) async def post_to_feed( tournament_id: str, body: str | None = Form(default=None), image: UploadFile | None = File(default=None), code: str | None = Form(default=None), user: CurrentUser = Depends(get_current_user), ) -> MessageOut: if not body and image is None: raise app_error(400, "VALIDATION_FAILED", "Meldingen må ha tekst eller bilde.") raw = await _read_optional_image(image) organization_id = await resolve_org(tournament_id) async with org_connection(organization_id) as conn, translate_db_errors(): row = await conn.fetchrow( "SELECT visibility, join_code FROM tournament WHERE id = $1", tournament_id ) if row is None: raise app_error(404, "NOT_FOUND", "Turneringen finnes ikke.") if not code_matches(row["join_code"], code): await check_visibility(conn, row["visibility"], organization_id, tournament_id, user) if not await _may_post_to_feed(conn, user, organization_id, tournament_id): raise app_error( 403, "NOT_A_PARTICIPANT", "Du må være medlem av organisasjonen eller delta i turneringen for å poste.", ) image_key = None if raw is not None: try: image_key = await storage.upload_image("messages", tournament_id, raw) except storage.InvalidImageError: raise app_error(400, "VALIDATION_FAILED", "Filen er ikke et gyldig bilde.") display_name = await _resolve_author_display_name(conn, organization_id, user.user_id) inserted = await conn.fetchrow( f""" INSERT INTO message (organization_id, scope, tournament_id, team_id, author_user_id, author_display_name, body, image_key) VALUES ($1, 'tournament_feed', $2, NULL, $3, $4, $5, $6) RETURNING {_MESSAGE_COLUMNS} """, organization_id, tournament_id, user.user_id, display_name, body, image_key, ) message = _row_to_message(inserted) await _broadcast(_feed_sockets[tournament_id], message.model_dump()) return message @public_router.delete("/{tournament_id}/feed/{message_id}", status_code=204) async def delete_feed_message( tournament_id: str, message_id: str, user: CurrentUser = Depends(get_current_user), ) -> None: """Forfatteren selv, ELLER org-eier/admin (moderering) -- ulikt lag- chatten, siden feeden er offentlig og derfor trenger en reell moderasjonsvei.""" organization_id = await resolve_org(tournament_id) async with org_connection(organization_id) as conn: row = await conn.fetchrow( """ SELECT author_user_id::text AS author_user_id FROM message WHERE id = $1 AND tournament_id = $2 AND scope = 'tournament_feed' """, message_id, tournament_id, ) if row is None: raise app_error(404, "NOT_FOUND", "Meldingen finnes ikke.") if row["author_user_id"] != user.user_id and not await is_org_admin( conn, organization_id, user.user_id ): raise app_error( 403, "NOT_MESSAGE_AUTHOR", "Du kan kun slette dine egne meldinger (eller som organisasjonsadministrator)." ) await conn.execute("DELETE FROM message WHERE id = $1", message_id) @router.websocket("/ws/public/tournaments/{tournament_id}/feed") async def feed_ws(websocket: WebSocket, tournament_id: str, code: str | None = None) -> None: user = await get_current_user_from_websocket(websocket) organization_id = await resolve_org(tournament_id) async with org_connection(organization_id) as conn: row = await conn.fetchrow( "SELECT visibility, join_code FROM tournament WHERE id = $1", tournament_id ) if row is None: await websocket.close(code=4404) return if not code_matches(row["join_code"], code): try: await check_visibility(conn, row["visibility"], organization_id, tournament_id, user) except Exception: await websocket.close(code=4403) return await websocket.accept() _feed_sockets[tournament_id].add(websocket) try: while True: await websocket.receive_text() except WebSocketDisconnect: pass finally: _feed_sockets[tournament_id].discard(websocket) @router.websocket("/ws/public/tournaments/{tournament_id}/live") async def tournament_live_ws(websocket: WebSocket, tournament_id: str, code: str | None = None) -> None: """ADR-027: "Følg live"-siden (leaderboard/matcher/scorekort, registration.py) sin sanntid. Sender kun et "noe endret seg"-signal -- se app/realtime.py sin moduldocstring for hvorfor -- klienten reagerer ved å hente de vanlige REST-endepunktene på nytt. Samme visibility-sjekk som selve de offentlige lese-endepunktene den speiler.""" user = await get_current_user_from_websocket(websocket) organization_id = await resolve_org(tournament_id) async with org_connection(organization_id) as conn: row = await conn.fetchrow( "SELECT visibility, join_code FROM tournament WHERE id = $1", tournament_id ) if row is None: await websocket.close(code=4404) return if not code_matches(row["join_code"], code): try: await check_visibility(conn, row["visibility"], organization_id, tournament_id, user) except Exception: await websocket.close(code=4403) return await websocket.accept() sockets = live_sockets_for(tournament_id) sockets.add(websocket) try: while True: await websocket.receive_text() except WebSocketDisconnect: pass finally: sockets.discard(websocket)