forked from mtusi2026/mtusi2026lab2
187 lines
7.7 KiB
Python
187 lines
7.7 KiB
Python
from datetime import timezone
|
|
|
|
from psycopg import errors
|
|
from psycopg.rows import dict_row
|
|
from psycopg_pool import ConnectionPool
|
|
|
|
import config
|
|
|
|
|
|
class UsernameTaken(Exception):
|
|
pass
|
|
|
|
|
|
class UnknownMember(Exception):
|
|
pass
|
|
|
|
|
|
def timestamp(value) -> str:
|
|
# ширина строки фиксированная: 6 знаков микросекунд, столько же хранит timestamptz
|
|
return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
|
|
|
|
|
def user_json(row) -> dict:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"username": row["username"],
|
|
"display_name": row["display_name"],
|
|
"created_at": timestamp(row["created_at"]),
|
|
}
|
|
|
|
|
|
def chat_json(row) -> dict:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"title": row["title"],
|
|
"member_ids": [str(member) for member in row["member_ids"]],
|
|
"created_at": timestamp(row["created_at"]),
|
|
}
|
|
|
|
|
|
def message_json(row) -> dict:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"chat_id": str(row["chat_id"]),
|
|
"sender_id": str(row["sender_id"]),
|
|
"text": row["text"],
|
|
"created_at": timestamp(row["created_at"]),
|
|
}
|
|
|
|
|
|
CHAT_COLUMNS = """
|
|
c.id, c.title, c.created_at,
|
|
(SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids
|
|
"""
|
|
|
|
|
|
class Store:
|
|
"""Все данные мессенджера в PostgreSQL. Значения в запросы попадают только через параметры %s."""
|
|
|
|
def __init__(self, url: str):
|
|
self.pool = ConnectionPool(
|
|
url,
|
|
min_size=config.DB_POOL_MIN_SIZE,
|
|
max_size=config.DB_POOL_MAX_SIZE,
|
|
timeout=config.DB_POOL_TIMEOUT, # сколько запрос ждёт свободное соединение
|
|
kwargs={
|
|
"connect_timeout": config.DB_CONNECT_TIMEOUT,
|
|
"options": f"-c statement_timeout={config.DB_STATEMENT_TIMEOUT * 1000}",
|
|
"row_factory": dict_row,
|
|
},
|
|
# перед выдачей соединение проверяется, поэтому после перезапуска БД мёртвые соединения не достаются запросам
|
|
check=ConnectionPool.check_connection,
|
|
open=False,
|
|
)
|
|
|
|
def open(self) -> None:
|
|
# не ждём БД: если она недоступна, сервер стартует и отвечает 503
|
|
self.pool.open(wait=False)
|
|
|
|
def close(self) -> None:
|
|
self.pool.close()
|
|
|
|
def ping(self) -> None:
|
|
with self.pool.connection() as conn:
|
|
conn.execute("SELECT 1")
|
|
|
|
def create_user(self, username: str, display_name: str, password_hash: str) -> dict:
|
|
with self.pool.connection() as conn:
|
|
try:
|
|
row = conn.execute(
|
|
"INSERT INTO users (username, display_name, password_hash) VALUES (%s, %s, %s) "
|
|
"RETURNING id, username, display_name, created_at",
|
|
(username, display_name, password_hash),
|
|
).fetchone()
|
|
except errors.UniqueViolation:
|
|
# уникальность проверяет сама БД, поэтому два одновременных запроса не создадут двух пользователей
|
|
raise UsernameTaken()
|
|
return user_json(row)
|
|
|
|
def get_user(self, user_id: str):
|
|
with self.pool.connection() as conn:
|
|
row = conn.execute(
|
|
"SELECT id, username, display_name, created_at FROM users WHERE id = %s", (user_id,)
|
|
).fetchone()
|
|
return user_json(row) if row else None
|
|
|
|
def get_credentials(self, username: str):
|
|
"""Пользователь и hash его пароля или (None, None)."""
|
|
with self.pool.connection() as conn:
|
|
row = conn.execute(
|
|
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
|
|
(username,),
|
|
).fetchone()
|
|
if row is None:
|
|
return None, None
|
|
return user_json(row), row["password_hash"]
|
|
|
|
def create_chat(self, title: str, member_ids: list) -> dict:
|
|
# блок with — одна транзакция: commit при выходе, rollback при любом исключении
|
|
with self.pool.connection() as conn:
|
|
chat = conn.execute(
|
|
"INSERT INTO chats (title) VALUES (%s) RETURNING id, title, created_at", (title,)
|
|
).fetchone()
|
|
try:
|
|
with conn.cursor() as cursor:
|
|
cursor.executemany(
|
|
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
|
|
[(chat["id"], member, position) for position, member in enumerate(member_ids)],
|
|
)
|
|
except errors.ForeignKeyViolation:
|
|
# участника нет в users: транзакция откатывается вместе с уже вставленным чатом
|
|
raise UnknownMember()
|
|
return chat_json({**chat, "member_ids": member_ids})
|
|
|
|
def get_chat(self, chat_id: str, user_id: str):
|
|
with self.pool.connection() as conn:
|
|
row = conn.execute(
|
|
f"SELECT {CHAT_COLUMNS} FROM chats c "
|
|
"JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s WHERE c.id = %s",
|
|
(user_id, chat_id),
|
|
).fetchone()
|
|
return chat_json(row) if row else None
|
|
|
|
def list_chats(self, user_id: str, after, limit: int):
|
|
query = f"SELECT {CHAT_COLUMNS} FROM chats c JOIN chat_members me ON me.chat_id = c.id WHERE me.user_id = %s"
|
|
params = [user_id]
|
|
if after:
|
|
query += " AND (c.created_at, c.id) > (%s, %s)"
|
|
params += after
|
|
query += " ORDER BY c.created_at, c.id LIMIT %s"
|
|
with self.pool.connection() as conn:
|
|
rows = conn.execute(query, params + [limit + 1]).fetchall()
|
|
return [chat_json(row) for row in rows[:limit]], len(rows) > limit
|
|
|
|
def add_message(self, chat_id: str, sender_id: str, text: str):
|
|
with self.pool.connection() as conn:
|
|
if not self._is_member(conn, chat_id, sender_id):
|
|
return None
|
|
row = conn.execute(
|
|
"INSERT INTO messages (chat_id, sender_id, text) VALUES (%s, %s, %s) "
|
|
"RETURNING id, chat_id, sender_id, text, created_at",
|
|
(chat_id, sender_id, text),
|
|
).fetchone()
|
|
return message_json(row)
|
|
|
|
def list_messages(self, chat_id: str, user_id: str, after, limit: int):
|
|
query = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s"
|
|
params = [chat_id]
|
|
if after:
|
|
# keyset: продолжаем с записи после cursor, а не пропускаем N строк
|
|
query += " AND (created_at, id) > (%s, %s)"
|
|
params += after
|
|
query += " ORDER BY created_at, id LIMIT %s"
|
|
with self.pool.connection() as conn:
|
|
if not self._is_member(conn, chat_id, user_id):
|
|
return None
|
|
# limit + 1: лишняя строка показывает, есть ли следующая страница
|
|
rows = conn.execute(query, params + [limit + 1]).fetchall()
|
|
return [message_json(row) for row in rows[:limit]], len(rows) > limit
|
|
|
|
@staticmethod
|
|
def _is_member(conn, chat_id: str, user_id: str) -> bool:
|
|
row = conn.execute(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id)
|
|
).fetchone()
|
|
return row is not None
|