Files
mtusi2026lab3/app/store.py
T
2026-11-06 13:32:02 +03:00

205 lines
7.8 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Хранилище на 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