208 lines
8.5 KiB
Python
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} |