Files
mtusi2026lab2/src/chats.py
T

208 lines
8.5 KiB
Python

import base64
import json
import uuid
from datetime import datetime
from typing import List, Optional, Tuple
import asyncpg
from fastapi import APIRouter, Depends, Query, Request
from pydantic import BaseModel, ConfigDict, Field
from .auth import current_user
from .common import iso, make_error_response
router = APIRouter()
class StrictRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
class CreateChatRequest(StrictRequest):
title: str
member_ids: List[str] = Field(min_length=1, max_length=100)
class CreateMessageRequest(StrictRequest):
text: str
def _req_id(request: Request) -> str:
return request.state.request_id
# курсор: непрозрачная строка, привязанная к ресурсу (scope)
def encode_cursor(scope: str, created_at: datetime, row_id: uuid.UUID) -> str:
raw = json.dumps([scope, iso(created_at), str(row_id)]).encode()
return base64.urlsafe_b64encode(raw).decode()
def decode_cursor(cursor: str, scope: str) -> Tuple[datetime, uuid.UUID]:
"""ValueError, если курсор повреждён или выдан для другого ресурса."""
try:
sc, ts, rid = json.loads(base64.urlsafe_b64decode(cursor.encode()))
if sc != scope:
raise ValueError("scope mismatch")
return datetime.fromisoformat(ts), uuid.UUID(rid)
except Exception as exc:
raise ValueError("invalid cursor") from exc
def _bad_text(value: str) -> bool:
return not value.strip() or "\x00" in value # NUL нельзя хранить в PostgreSQL text
_CHAT_COLUMNS = (
"c.id, c.title, c.created_at, "
"array(SELECT m2.user_id FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.position) AS member_ids"
)
def chat_dict(row) -> dict:
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(m) for m in row["member_ids"]],
"created_at": iso(row["created_at"]),
}
def message_dict(row) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": iso(row["created_at"]),
}
def _check_limit(limit: int) -> bool:
return 1 <= limit <= 100
# чаты
@router.post("/chats", status_code=201)
async def create_chat(req: CreateChatRequest, request: Request, user=Depends(current_user)):
req_id = _req_id(request)
if not (1 <= len(req.title) <= 100) or _bad_text(req.title):
return make_error_response(400, "invalid_request", "Invalid title", req_id)
try:
members = [uuid.UUID(m) for m in req.member_ids]
except ValueError:
return make_error_response(400, "invalid_request", "Invalid member id", req_id)
if len(members) != len(set(members)):
return make_error_response(400, "invalid_request", "Duplicate members found", req_id)
if user["id"] not in members:
return make_error_response(400, "invalid_request", "Caller must be in member_ids", req_id)
chat_id = uuid.uuid4()
try:
async with request.app.state.pool.acquire() as conn:
# Чат и все участники - одна транзакция: неизвестный участник откатывает всё.
async with conn.transaction():
created_at = await conn.fetchval(
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, clock_timestamp()) RETURNING created_at",
chat_id, req.title,
)
await conn.execute(
"INSERT INTO chat_members (chat_id, user_id, position) "
"SELECT $1, t.u, (t.p - 1)::smallint FROM unnest($2::uuid[]) WITH ORDINALITY AS t(u, p)",
chat_id, members,
)
except asyncpg.ForeignKeyViolationError:
return make_error_response(400, "invalid_request", "Unknown member", req_id)
return {"id": str(chat_id), "title": req.title, "member_ids": [str(m) for m in members],
"created_at": iso(created_at)}
@router.get("/chats")
async def list_chats(request: Request, limit: int = 50,
cursor: Optional[str] = Query(default=None, min_length=1, max_length=512),
user=Depends(current_user)):
req_id = _req_id(request)
if not _check_limit(limit):
return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id)
scope = "chats:" + str(user["id"])
base = (f"SELECT {_CHAT_COLUMNS} FROM chats c "
"JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1 ")
if cursor is None:
rows = await request.app.state.pool.fetch(
base + "ORDER BY c.created_at, c.id LIMIT $2", user["id"], limit + 1)
else:
try:
ts, rid = decode_cursor(cursor, scope)
except ValueError:
return make_error_response(400, "invalid_request", "Invalid cursor", req_id)
rows = await request.app.state.pool.fetch(
base + "WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid) "
"ORDER BY c.created_at, c.id LIMIT $4",
user["id"], ts, rid, limit + 1)
items = rows[:limit]
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None
return {"items": [chat_dict(r) for r in items], "next_cursor": next_cursor}
@router.get("/chats/{chat_id}")
async def get_chat(chat_id: uuid.UUID, request: Request, user=Depends(current_user)):
row = await request.app.state.pool.fetchrow(
f"SELECT {_CHAT_COLUMNS} FROM chats c WHERE c.id = $1 "
"AND EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2)",
chat_id, user["id"],
)
if row is None:
return make_error_response(404, "not_found", "Chat not found", _req_id(request))
return chat_dict(row)
# сообщения
@router.post("/chats/{chat_id}/messages", status_code=201)
async def send_message(chat_id: uuid.UUID, req: CreateMessageRequest, request: Request,
user=Depends(current_user)):
req_id = _req_id(request)
if _bad_text(req.text):
return make_error_response(400, "invalid_request", "Empty message text", req_id)
if len(req.text) > 4000:
return make_error_response(400, "invalid_request", "Message text exceeds 4000 characters", req_id)
# Проверка членства и вставка - один атомарный оператор.
row = await request.app.state.pool.fetchrow(
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
"SELECT $1, $2, $3, $4, clock_timestamp() "
"WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3) "
"RETURNING id, chat_id, sender_id, text, created_at",
uuid.uuid4(), chat_id, user["id"], req.text,
)
if row is None:
return make_error_response(404, "not_found", "Chat not found", req_id)
return message_dict(row)
@router.get("/chats/{chat_id}/messages")
async def get_messages(chat_id: uuid.UUID, request: Request, limit: int = 50,
cursor: Optional[str] = Query(default=None, min_length=1, max_length=512),
user=Depends(current_user)):
req_id = _req_id(request)
if not _check_limit(limit):
return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id)
pool = request.app.state.pool
is_member = await pool.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", chat_id, user["id"])
if not is_member:
return make_error_response(404, "not_found", "Chat not found", req_id)
scope = "msgs:" + str(chat_id)
base = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 "
if cursor is None:
rows = await pool.fetch(base + "ORDER BY created_at, id LIMIT $2", chat_id, limit + 1)
else:
try:
ts, rid = decode_cursor(cursor, scope)
except ValueError:
return make_error_response(400, "invalid_request", "Invalid cursor", req_id)
rows = await pool.fetch(
base + "AND (created_at, id) > ($2::timestamptz, $3::uuid) ORDER BY created_at, id LIMIT $4",
chat_id, ts, rid, limit + 1)
items = rows[:limit]
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None
return {"items": [message_dict(r) for r in items], "next_cursor": next_cursor}