905 lines
35 KiB
Python
905 lines
35 KiB
Python
"""
|
|
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_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
|
|
from .round_messages import ALLOWED_REACTION_EMOJIS, CommentIn, ReactionIn, ReactionSummary
|
|
|
|
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
|
|
reactions: list[ReactionSummary] = []
|
|
comment_count: int = 0
|
|
|
|
|
|
def _row_to_message(
|
|
row, reactions: list[ReactionSummary] | None = None, comment_count: int = 0
|
|
) -> 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(),
|
|
reactions=reactions or [],
|
|
comment_count=comment_count,
|
|
)
|
|
|
|
|
|
# --- Reaksjoner/kommentarer (ADR-046) -- delt mellom lag-chat og ---------
|
|
# --- oppslagstavle, siden begge lagrer i `message` med scope-diskriminator.
|
|
|
|
_MESSAGE_COMMENT_COLUMNS = """
|
|
id::text, message_id::text, parent_comment_id::text, author_user_id::text,
|
|
author_display_name, body, created_at
|
|
"""
|
|
|
|
|
|
class CommentOut(BaseModel):
|
|
id: str
|
|
message_id: str
|
|
parent_comment_id: str | None
|
|
author_user_id: str
|
|
author_display_name: str
|
|
body: str
|
|
created_at: str
|
|
|
|
|
|
def _row_to_message_comment(row) -> CommentOut:
|
|
return CommentOut(
|
|
id=row["id"],
|
|
message_id=row["message_id"],
|
|
parent_comment_id=row["parent_comment_id"],
|
|
author_user_id=row["author_user_id"],
|
|
author_display_name=row["author_display_name"],
|
|
body=row["body"],
|
|
created_at=row["created_at"].isoformat(),
|
|
)
|
|
|
|
|
|
async def _message_reactions(
|
|
conn, message_ids: list[str], viewer_user_id: str | None
|
|
) -> dict[str, list[ReactionSummary]]:
|
|
if not message_ids:
|
|
return {}
|
|
rows = await conn.fetch(
|
|
"""
|
|
SELECT mr.message_id::text AS message_id, mr.emoji, count(*) AS count,
|
|
COALESCE(bool_or(mr.user_id = $2), false) AS reacted_by_me,
|
|
array_agg(
|
|
COALESCE(p.display_name, split_part(au.email, '@', 1))
|
|
ORDER BY mr.created_at
|
|
) AS reactors
|
|
FROM message_reaction mr
|
|
JOIN app_user au ON au.id = mr.user_id
|
|
LEFT JOIN player p ON p.organization_id = mr.organization_id AND p.user_id = mr.user_id
|
|
WHERE mr.message_id = ANY($1::uuid[])
|
|
GROUP BY mr.message_id, mr.emoji
|
|
""",
|
|
message_ids,
|
|
viewer_user_id,
|
|
)
|
|
result: dict[str, list[ReactionSummary]] = {}
|
|
for r in rows:
|
|
result.setdefault(r["message_id"], []).append(
|
|
ReactionSummary(
|
|
emoji=r["emoji"],
|
|
count=r["count"],
|
|
reacted_by_me=r["reacted_by_me"],
|
|
reactors=list(r["reactors"]),
|
|
)
|
|
)
|
|
return result
|
|
|
|
|
|
async def _message_comment_counts(conn, message_ids: list[str]) -> dict[str, int]:
|
|
if not message_ids:
|
|
return {}
|
|
rows = await conn.fetch(
|
|
"""
|
|
SELECT message_id::text AS message_id, count(*) AS count
|
|
FROM message_comment
|
|
WHERE message_id = ANY($1::uuid[])
|
|
GROUP BY message_id
|
|
""",
|
|
message_ids,
|
|
)
|
|
return {r["message_id"]: r["count"] for r in rows}
|
|
|
|
|
|
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"
|
|
|
|
|
|
# --- 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,
|
|
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.")
|
|
# Nyeste øverst (2026-08-06, brukerens eksplisitte ønske -- "over
|
|
# alt", samme rekkefølge som round_message og tournament_feed nå).
|
|
rows = await conn.fetch(
|
|
f"""
|
|
SELECT {_MESSAGE_COLUMNS} FROM message
|
|
WHERE team_id = $1 AND scope = 'team'
|
|
ORDER BY created_at DESC
|
|
""",
|
|
team_id,
|
|
)
|
|
message_ids = [r["id"] for r in rows]
|
|
reactions_by_id = await _message_reactions(conn, message_ids, user.user_id)
|
|
comment_counts = await _message_comment_counts(conn, message_ids)
|
|
return [
|
|
_row_to_message(r, reactions_by_id.get(r["id"]), comment_counts.get(r["id"], 0))
|
|
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,
|
|
organization_id: str,
|
|
body: str | None = Form(default=None),
|
|
image: UploadFile | None = File(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 storage.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,
|
|
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)
|
|
|
|
|
|
# --- Reaksjoner/kommentarer på lag-chat-meldinger (ADR-046) ---------------
|
|
# Samme "hvem kan poste = hvem kan reagere/kommentere"-modell som selve
|
|
# meldingen (rostret på laget); sletting av kommentar er kun forfatteren,
|
|
# samme "ekte privat rom" begrunnelse som `delete_team_message`.
|
|
|
|
|
|
async def _get_team_message_or_404(conn, team_id: str, message_id: str) -> None:
|
|
exists = await conn.fetchval(
|
|
"SELECT id FROM message WHERE id = $1 AND team_id = $2 AND scope = 'team'",
|
|
message_id,
|
|
team_id,
|
|
)
|
|
if exists is None:
|
|
raise app_error(404, "NOT_FOUND", "Meldingen finnes ikke.")
|
|
|
|
|
|
@router.put(
|
|
"/orgs/{organization_id}/teams/{team_id}/messages/{message_id}/reaction",
|
|
response_model=list[ReactionSummary],
|
|
)
|
|
async def set_team_message_reaction(
|
|
team_id: str,
|
|
organization_id: str,
|
|
message_id: str,
|
|
payload: ReactionIn,
|
|
user: CurrentUser = Depends(get_current_user),
|
|
) -> list[ReactionSummary]:
|
|
if payload.emoji not in ALLOWED_REACTION_EMOJIS:
|
|
raise app_error(400, "VALIDATION_FAILED", "Ugyldig emoji.")
|
|
async with org_connection(organization_id) as conn:
|
|
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.")
|
|
await _get_team_message_or_404(conn, team_id, message_id)
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO message_reaction (organization_id, message_id, user_id, emoji)
|
|
VALUES ($1, $2, $3, $4)
|
|
ON CONFLICT (message_id, user_id) DO UPDATE SET emoji = EXCLUDED.emoji, created_at = now()
|
|
""",
|
|
organization_id,
|
|
message_id,
|
|
user.user_id,
|
|
payload.emoji,
|
|
)
|
|
summaries = await _message_reactions(conn, [message_id], user.user_id)
|
|
return summaries.get(message_id, [])
|
|
|
|
|
|
@router.delete(
|
|
"/orgs/{organization_id}/teams/{team_id}/messages/{message_id}/reaction",
|
|
response_model=list[ReactionSummary],
|
|
)
|
|
async def remove_team_message_reaction(
|
|
team_id: str,
|
|
organization_id: str,
|
|
message_id: str,
|
|
user: CurrentUser = Depends(get_current_user),
|
|
) -> list[ReactionSummary]:
|
|
async with org_connection(organization_id) as conn:
|
|
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.")
|
|
await _get_team_message_or_404(conn, team_id, message_id)
|
|
await conn.execute(
|
|
"DELETE FROM message_reaction WHERE message_id = $1 AND user_id = $2",
|
|
message_id,
|
|
user.user_id,
|
|
)
|
|
summaries = await _message_reactions(conn, [message_id], user.user_id)
|
|
return summaries.get(message_id, [])
|
|
|
|
|
|
@router.get(
|
|
"/orgs/{organization_id}/teams/{team_id}/messages/{message_id}/comments",
|
|
response_model=list[CommentOut],
|
|
)
|
|
async def list_team_message_comments(
|
|
team_id: str,
|
|
organization_id: str,
|
|
message_id: str,
|
|
user: CurrentUser = Depends(get_current_user),
|
|
) -> list[CommentOut]:
|
|
async with org_connection(organization_id) as conn:
|
|
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.")
|
|
await _get_team_message_or_404(conn, team_id, message_id)
|
|
rows = await conn.fetch(
|
|
f"""
|
|
SELECT {_MESSAGE_COMMENT_COLUMNS} FROM message_comment
|
|
WHERE message_id = $1 ORDER BY created_at ASC
|
|
""",
|
|
message_id,
|
|
)
|
|
return [_row_to_message_comment(r) for r in rows]
|
|
|
|
|
|
@router.post(
|
|
"/orgs/{organization_id}/teams/{team_id}/messages/{message_id}/comments",
|
|
response_model=CommentOut,
|
|
status_code=201,
|
|
)
|
|
async def post_team_message_comment(
|
|
team_id: str,
|
|
organization_id: str,
|
|
message_id: str,
|
|
payload: CommentIn,
|
|
user: CurrentUser = Depends(get_current_user),
|
|
) -> CommentOut:
|
|
body = payload.body.strip()
|
|
if not body:
|
|
raise app_error(400, "VALIDATION_FAILED", "Kommentaren kan ikke være tom.")
|
|
async with org_connection(organization_id) as conn, translate_db_errors():
|
|
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.")
|
|
await _get_team_message_or_404(conn, team_id, message_id)
|
|
if payload.parent_comment_id is not None:
|
|
parent_exists = await conn.fetchval(
|
|
"SELECT id FROM message_comment WHERE id = $1 AND message_id = $2",
|
|
payload.parent_comment_id,
|
|
message_id,
|
|
)
|
|
if parent_exists is None:
|
|
raise app_error(404, "NOT_FOUND", "Kommentaren du svarer på finnes ikke.")
|
|
|
|
display_name = await _resolve_author_display_name(conn, organization_id, user.user_id)
|
|
row = await conn.fetchrow(
|
|
f"""
|
|
INSERT INTO message_comment
|
|
(organization_id, message_id, parent_comment_id, author_user_id, author_display_name, body)
|
|
VALUES ($1, $2, $3, $4, $5, $6)
|
|
RETURNING {_MESSAGE_COMMENT_COLUMNS}
|
|
""",
|
|
organization_id,
|
|
message_id,
|
|
payload.parent_comment_id,
|
|
user.user_id,
|
|
display_name,
|
|
body,
|
|
)
|
|
return _row_to_message_comment(row)
|
|
|
|
|
|
@router.delete(
|
|
"/orgs/{organization_id}/teams/{team_id}/messages/{message_id}/comments/{comment_id}",
|
|
status_code=204,
|
|
)
|
|
async def delete_team_message_comment(
|
|
team_id: str,
|
|
organization_id: str,
|
|
message_id: str,
|
|
comment_id: str,
|
|
user: CurrentUser = Depends(get_current_user),
|
|
) -> None:
|
|
"""Kun forfatteren selv, INGEN unntak -- samme "ekte privat rom"-
|
|
begrunnelse som `delete_team_message`."""
|
|
async with org_connection(organization_id) as conn:
|
|
row = await conn.fetchrow(
|
|
"""
|
|
SELECT author_user_id::text AS author_user_id FROM message_comment
|
|
WHERE id = $1 AND message_id = $2
|
|
""",
|
|
comment_id,
|
|
message_id,
|
|
)
|
|
if row is None:
|
|
raise app_error(404, "NOT_FOUND", "Kommentaren finnes ikke.")
|
|
if row["author_user_id"] != user.user_id:
|
|
raise app_error(403, "NOT_COMMENT_AUTHOR", "Du kan kun slette dine egne kommentarer.")
|
|
await conn.execute("DELETE FROM message_comment WHERE id = $1", comment_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)
|
|
|
|
# Nyeste øverst (2026-08-06, brukerens eksplisitte ønske -- "over
|
|
# alt", samme rekkefølge som round_message og lag-chatten nå).
|
|
rows = await conn.fetch(
|
|
f"""
|
|
SELECT {_MESSAGE_COLUMNS} FROM message
|
|
WHERE tournament_id = $1 AND scope = 'tournament_feed'
|
|
ORDER BY created_at DESC
|
|
""",
|
|
tournament_id,
|
|
)
|
|
message_ids = [r["id"] for r in rows]
|
|
reactions_by_id = await _message_reactions(conn, message_ids, user.user_id if user else None)
|
|
comment_counts = await _message_comment_counts(conn, message_ids)
|
|
return [
|
|
_row_to_message(r, reactions_by_id.get(r["id"]), comment_counts.get(r["id"], 0))
|
|
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 storage.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)
|
|
|
|
|
|
# --- Reaksjoner/kommentarer på oppslagstavle-innlegg (ADR-046) -----------
|
|
# Samme "hvem kan poste = hvem kan reagere/kommentere"-modell som selve
|
|
# innlegget (`_may_post_to_feed`); sletting av kommentar er forfatter
|
|
# ELLER org-admin, samme moderasjonsvei som `delete_feed_message`.
|
|
|
|
|
|
async def _get_feed_message_or_404(conn, tournament_id: str, message_id: str) -> None:
|
|
exists = await conn.fetchval(
|
|
"SELECT id FROM message WHERE id = $1 AND tournament_id = $2 AND scope = 'tournament_feed'",
|
|
message_id,
|
|
tournament_id,
|
|
)
|
|
if exists is None:
|
|
raise app_error(404, "NOT_FOUND", "Meldingen finnes ikke.")
|
|
|
|
|
|
@public_router.put("/{tournament_id}/feed/{message_id}/reaction", response_model=list[ReactionSummary])
|
|
async def set_feed_message_reaction(
|
|
tournament_id: str,
|
|
message_id: str,
|
|
payload: ReactionIn,
|
|
user: CurrentUser = Depends(get_current_user),
|
|
) -> list[ReactionSummary]:
|
|
if payload.emoji not in ALLOWED_REACTION_EMOJIS:
|
|
raise app_error(400, "VALIDATION_FAILED", "Ugyldig emoji.")
|
|
organization_id = await resolve_org(tournament_id)
|
|
async with org_connection(organization_id) as conn:
|
|
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 å reagere.",
|
|
)
|
|
await _get_feed_message_or_404(conn, tournament_id, message_id)
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO message_reaction (organization_id, message_id, user_id, emoji)
|
|
VALUES ($1, $2, $3, $4)
|
|
ON CONFLICT (message_id, user_id) DO UPDATE SET emoji = EXCLUDED.emoji, created_at = now()
|
|
""",
|
|
organization_id,
|
|
message_id,
|
|
user.user_id,
|
|
payload.emoji,
|
|
)
|
|
summaries = await _message_reactions(conn, [message_id], user.user_id)
|
|
return summaries.get(message_id, [])
|
|
|
|
|
|
@public_router.delete("/{tournament_id}/feed/{message_id}/reaction", response_model=list[ReactionSummary])
|
|
async def remove_feed_message_reaction(
|
|
tournament_id: str,
|
|
message_id: str,
|
|
user: CurrentUser = Depends(get_current_user),
|
|
) -> list[ReactionSummary]:
|
|
organization_id = await resolve_org(tournament_id)
|
|
async with org_connection(organization_id) as conn:
|
|
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 å reagere.",
|
|
)
|
|
await _get_feed_message_or_404(conn, tournament_id, message_id)
|
|
await conn.execute(
|
|
"DELETE FROM message_reaction WHERE message_id = $1 AND user_id = $2",
|
|
message_id,
|
|
user.user_id,
|
|
)
|
|
summaries = await _message_reactions(conn, [message_id], user.user_id)
|
|
return summaries.get(message_id, [])
|
|
|
|
|
|
@public_router.get("/{tournament_id}/feed/{message_id}/comments", response_model=list[CommentOut])
|
|
async def list_feed_message_comments(
|
|
tournament_id: str,
|
|
message_id: str,
|
|
code: str | None = None,
|
|
user: CurrentUser | None = Depends(get_current_user_optional),
|
|
) -> list[CommentOut]:
|
|
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)
|
|
await _get_feed_message_or_404(conn, tournament_id, message_id)
|
|
rows = await conn.fetch(
|
|
f"""
|
|
SELECT {_MESSAGE_COMMENT_COLUMNS} FROM message_comment
|
|
WHERE message_id = $1 ORDER BY created_at ASC
|
|
""",
|
|
message_id,
|
|
)
|
|
return [_row_to_message_comment(r) for r in rows]
|
|
|
|
|
|
@public_router.post("/{tournament_id}/feed/{message_id}/comments", response_model=CommentOut, status_code=201)
|
|
async def post_feed_message_comment(
|
|
tournament_id: str,
|
|
message_id: str,
|
|
payload: CommentIn,
|
|
code: str | None = None,
|
|
user: CurrentUser = Depends(get_current_user),
|
|
) -> CommentOut:
|
|
body = payload.body.strip()
|
|
if not body:
|
|
raise app_error(400, "VALIDATION_FAILED", "Kommentaren kan ikke være tom.")
|
|
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 å kommentere.",
|
|
)
|
|
await _get_feed_message_or_404(conn, tournament_id, message_id)
|
|
if payload.parent_comment_id is not None:
|
|
parent_exists = await conn.fetchval(
|
|
"SELECT id FROM message_comment WHERE id = $1 AND message_id = $2",
|
|
payload.parent_comment_id,
|
|
message_id,
|
|
)
|
|
if parent_exists is None:
|
|
raise app_error(404, "NOT_FOUND", "Kommentaren du svarer på finnes ikke.")
|
|
|
|
display_name = await _resolve_author_display_name(conn, organization_id, user.user_id)
|
|
inserted = await conn.fetchrow(
|
|
f"""
|
|
INSERT INTO message_comment
|
|
(organization_id, message_id, parent_comment_id, author_user_id, author_display_name, body)
|
|
VALUES ($1, $2, $3, $4, $5, $6)
|
|
RETURNING {_MESSAGE_COMMENT_COLUMNS}
|
|
""",
|
|
organization_id,
|
|
message_id,
|
|
payload.parent_comment_id,
|
|
user.user_id,
|
|
display_name,
|
|
body,
|
|
)
|
|
return _row_to_message_comment(inserted)
|
|
|
|
|
|
@public_router.delete("/{tournament_id}/feed/{message_id}/comments/{comment_id}", status_code=204)
|
|
async def delete_feed_message_comment(
|
|
tournament_id: str,
|
|
message_id: str,
|
|
comment_id: str,
|
|
user: CurrentUser = Depends(get_current_user),
|
|
) -> None:
|
|
"""Forfatteren selv, ELLER org-eier/admin -- samme moderasjonsvei som
|
|
`delete_feed_message`."""
|
|
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_comment
|
|
WHERE id = $1 AND message_id = $2
|
|
""",
|
|
comment_id,
|
|
message_id,
|
|
)
|
|
if row is None:
|
|
raise app_error(404, "NOT_FOUND", "Kommentaren 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_COMMENT_AUTHOR",
|
|
"Du kan kun slette dine egne kommentarer (eller som organisasjonsadministrator).",
|
|
)
|
|
await conn.execute("DELETE FROM message_comment WHERE id = $1", comment_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)
|