205 lines
7.8 KiB
Python
205 lines
7.8 KiB
Python
"""Хранилище на PostgreSQL: пользователи, чаты, участники, сообщения."""
|
||
import uuid
|
||
from datetime import datetime, timezone
|
||
from typing import Any
|
||
|
||
import psycopg
|
||
from psycopg_pool import ConnectionPool
|
||
|
||
|
||
def utc_now() -> str:
|
||
"""RFC 3339 UTC с суффиксом Z, секунды — как в примерах контракта."""
|
||
return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
|
||
|
||
|
||
def new_id() -> str:
|
||
return str(uuid.uuid4())
|
||
|
||
|
||
def _iso(dt: datetime) -> str:
|
||
"""RFC 3339 UTC с суффиксом Z, микросекунды сохраняются для keyset-пагинации."""
|
||
return dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
||
|
||
|
||
def _user_row(row: tuple) -> dict[str, Any]:
|
||
uid, username, display_name, created_at = row
|
||
return {
|
||
"id": str(uid),
|
||
"username": username,
|
||
"display_name": display_name,
|
||
"created_at": _iso(created_at),
|
||
}
|
||
|
||
|
||
def _chat_row(row: tuple, member_ids: list[str]) -> dict[str, Any]:
|
||
cid, title, created_at = row
|
||
return {
|
||
"id": str(cid),
|
||
"title": title,
|
||
"member_ids": member_ids,
|
||
"created_at": _iso(created_at),
|
||
}
|
||
|
||
|
||
def _message_row(row: tuple) -> dict[str, Any]:
|
||
mid, chat_id, sender_id, text, created_at = row
|
||
return {
|
||
"id": str(mid),
|
||
"chat_id": str(chat_id),
|
||
"sender_id": str(sender_id),
|
||
"text": text,
|
||
"created_at": _iso(created_at),
|
||
}
|
||
|
||
|
||
class Store:
|
||
"""Все данные в PostgreSQL; соединения берутся из пула."""
|
||
|
||
def __init__(self, pool: ConnectionPool) -> None:
|
||
self.pool = pool
|
||
|
||
# --- пользователи -----------------------------------------------------
|
||
def create_user(
|
||
self, username: str, display_name: str, password_hash: str
|
||
) -> dict[str, Any] | None:
|
||
user_id = new_id()
|
||
try:
|
||
with self.pool.connection() as conn:
|
||
with conn.cursor() as cur:
|
||
cur.execute(
|
||
"INSERT INTO users(id, username, display_name, password_hash, created_at)"
|
||
" VALUES (%s, %s, %s, %s, now())"
|
||
" RETURNING id, username, display_name, created_at",
|
||
(user_id, username, display_name, password_hash),
|
||
)
|
||
row = cur.fetchone()
|
||
conn.commit()
|
||
except psycopg.errors.UniqueViolation:
|
||
return None
|
||
return _user_row(row)
|
||
|
||
def get_user(self, user_id: str) -> dict[str, Any] | None:
|
||
with self.pool.connection() as conn:
|
||
with conn.cursor() as cur:
|
||
cur.execute(
|
||
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
|
||
(user_id,),
|
||
)
|
||
row = cur.fetchone()
|
||
return _user_row(row) if row else None
|
||
|
||
def get_user_by_username(self, username: str) -> tuple[dict[str, Any], str] | None:
|
||
with self.pool.connection() as conn:
|
||
with conn.cursor() as cur:
|
||
cur.execute(
|
||
"SELECT id, username, display_name, created_at, password_hash"
|
||
" FROM users WHERE username = %s",
|
||
(username,),
|
||
)
|
||
row = cur.fetchone()
|
||
if row is None:
|
||
return None
|
||
return _user_row(row[:4]), row[4]
|
||
|
||
# --- чаты -------------------------------------------------------------
|
||
def create_chat(self, title: str, member_ids: list[str]) -> dict[str, Any]:
|
||
chat_id = new_id()
|
||
with self.pool.connection() as conn:
|
||
with conn.transaction():
|
||
with conn.cursor() as cur:
|
||
cur.execute(
|
||
"INSERT INTO chats(id, title, created_at) VALUES (%s, %s, now())"
|
||
" RETURNING id, title, created_at",
|
||
(chat_id, title),
|
||
)
|
||
row = cur.fetchone()
|
||
cur.executemany(
|
||
"INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)",
|
||
[(chat_id, mid) for mid in member_ids],
|
||
)
|
||
return _chat_row(row, list(member_ids))
|
||
|
||
def _members(self, cur, chat_id: str) -> list[str]:
|
||
cur.execute(
|
||
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id",
|
||
(chat_id,),
|
||
)
|
||
return [str(r[0]) for r in cur.fetchall()]
|
||
|
||
def get_chat(self, chat_id: str) -> dict[str, Any] | None:
|
||
with self.pool.connection() as conn:
|
||
with conn.cursor() as cur:
|
||
cur.execute(
|
||
"SELECT id, title, created_at FROM chats WHERE id = %s", (chat_id,)
|
||
)
|
||
row = cur.fetchone()
|
||
if row is None:
|
||
return None
|
||
members = self._members(cur, chat_id)
|
||
return _chat_row(row, members)
|
||
|
||
def is_member(self, chat_id: str, user_id: str) -> bool:
|
||
with self.pool.connection() as conn:
|
||
with conn.cursor() as cur:
|
||
cur.execute(
|
||
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
||
(chat_id, user_id),
|
||
)
|
||
return cur.fetchone() is not None
|
||
|
||
def list_chats_for(
|
||
self, user_id: str, limit: int, after: tuple[str, str] | None
|
||
) -> tuple[list[dict[str, Any]], bool]:
|
||
with self.pool.connection() as conn:
|
||
with conn.cursor() as cur:
|
||
sql = (
|
||
"SELECT c.id, c.title, c.created_at FROM chats c"
|
||
" JOIN chat_members m ON m.chat_id = c.id"
|
||
" WHERE m.user_id = %s"
|
||
)
|
||
params: list[Any] = [user_id]
|
||
if after is not None:
|
||
sql += " AND (c.created_at, c.id) > (%s, %s)"
|
||
params.extend(after)
|
||
sql += " ORDER BY c.created_at, c.id LIMIT %s"
|
||
params.append(limit + 1)
|
||
cur.execute(sql, params)
|
||
rows = cur.fetchall()
|
||
items = []
|
||
for row in rows[:limit]:
|
||
items.append(_chat_row(row, self._members(cur, str(row[0]))))
|
||
return items, len(rows) > limit
|
||
|
||
# --- сообщения --------------------------------------------------------
|
||
def add_message(self, chat_id: str, sender_id: str, text: str) -> dict[str, Any]:
|
||
with self.pool.connection() as conn:
|
||
with conn.cursor() as cur:
|
||
cur.execute(
|
||
"INSERT INTO messages(id, chat_id, sender_id, text, created_at)"
|
||
" VALUES (%s, %s, %s, %s, now())"
|
||
" RETURNING id, chat_id, sender_id, text, created_at",
|
||
(new_id(), chat_id, sender_id, text),
|
||
)
|
||
row = cur.fetchone()
|
||
conn.commit()
|
||
return _message_row(row)
|
||
|
||
def list_messages(
|
||
self, chat_id: str, limit: int, after: tuple[str, str] | None
|
||
) -> tuple[list[dict[str, Any]], bool]:
|
||
with self.pool.connection() as conn:
|
||
with conn.cursor() as cur:
|
||
sql = (
|
||
"SELECT id, chat_id, sender_id, text, created_at FROM messages"
|
||
" WHERE chat_id = %s"
|
||
)
|
||
params: list[Any] = [chat_id]
|
||
if after is not None:
|
||
sql += " AND (created_at, id) > (%s, %s)"
|
||
params.extend(after)
|
||
sql += " ORDER BY created_at, id LIMIT %s"
|
||
params.append(limit + 1)
|
||
cur.execute(sql, params)
|
||
rows = cur.fetchall()
|
||
return [_message_row(r) for r in rows[:limit]], len(rows) > limit
|