forked from mtusi2026/mtusi2026lab3
250 lines
9.5 KiB
Python
250 lines
9.5 KiB
Python
"""Запросы к PostgreSQL через SQLAlchemy с параметрами.
|
|
|
|
Изменяющие функции -- одна транзакция: commit в конце, rollback при ошибке.
|
|
"""
|
|
|
|
import hashlib
|
|
import uuid
|
|
from datetime import datetime, timedelta
|
|
from typing import Dict, List, Optional, Tuple
|
|
|
|
from sqlalchemy import Select, delete, func, insert, select, tuple_
|
|
from sqlalchemy.exc import IntegrityError
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from .models import Chat, ChatMember, Message, MessageRequest, SessionRow, User
|
|
|
|
UNIQUE_VIOLATION = "23505"
|
|
FOREIGN_KEY_VIOLATION = "23503"
|
|
|
|
Position = Tuple[datetime, uuid.UUID]
|
|
|
|
|
|
class UsernameTaken(Exception):
|
|
"""Username уже занят."""
|
|
|
|
|
|
class IdempotencyConflict(Exception):
|
|
"""Ключ уже использован с другим телом запроса."""
|
|
|
|
|
|
class UnknownMember(Exception):
|
|
"""Среди участников чата есть несуществующий пользователь."""
|
|
|
|
|
|
def sqlstate(error: IntegrityError) -> Optional[str]:
|
|
"""Код SQLSTATE из исключения SQLAlchemy."""
|
|
original = error.orig
|
|
code = getattr(original, "sqlstate", None)
|
|
if code is None:
|
|
code = getattr(getattr(original, "__cause__", None), "sqlstate", None)
|
|
return code
|
|
|
|
|
|
async def create_user(
|
|
session: AsyncSession, username: str, display_name: str, password_hash: str
|
|
) -> User:
|
|
"""Создать пользователя; дубликат username -> UsernameTaken."""
|
|
statement = (
|
|
insert(User)
|
|
.values(
|
|
id=uuid.uuid4(),
|
|
username=username,
|
|
display_name=display_name,
|
|
password_hash=password_hash,
|
|
)
|
|
.returning(User)
|
|
)
|
|
try:
|
|
user = (await session.execute(statement)).scalar_one()
|
|
await session.commit()
|
|
except IntegrityError as error:
|
|
await session.rollback()
|
|
if sqlstate(error) == UNIQUE_VIOLATION:
|
|
raise UsernameTaken(username)
|
|
raise
|
|
return user
|
|
|
|
|
|
async def get_user_by_username(session: AsyncSession, username: str) -> Optional[User]:
|
|
"""Пользователь по username или None."""
|
|
return (
|
|
await session.execute(select(User).where(User.username == username))
|
|
).scalar_one_or_none()
|
|
|
|
|
|
async def create_session(
|
|
session: AsyncSession, user_id: uuid.UUID, token_hash: str, ttl_seconds: int
|
|
) -> datetime:
|
|
"""Удалить истёкшие сессии пользователя, создать новую, вернуть expires_at."""
|
|
await session.execute(
|
|
delete(SessionRow).where(
|
|
SessionRow.user_id == user_id, SessionRow.expires_at < func.now()
|
|
)
|
|
)
|
|
statement = (
|
|
insert(SessionRow)
|
|
.values(
|
|
token_hash=token_hash,
|
|
user_id=user_id,
|
|
expires_at=func.now() + timedelta(seconds=ttl_seconds),
|
|
)
|
|
.returning(SessionRow.expires_at)
|
|
)
|
|
expires_at = (await session.execute(statement)).scalar_one()
|
|
await session.commit()
|
|
return expires_at
|
|
|
|
|
|
async def get_user_by_token(
|
|
session: AsyncSession, token_hash: str
|
|
) -> Optional[Tuple[User, float]]:
|
|
"""(User, секунд до истечения) для действующей сессии или None."""
|
|
statement = (
|
|
select(User, func.extract("epoch", SessionRow.expires_at - func.now()))
|
|
.join(SessionRow, SessionRow.user_id == User.id)
|
|
.where(SessionRow.token_hash == token_hash, SessionRow.expires_at > func.now())
|
|
)
|
|
row = (await session.execute(statement)).one_or_none()
|
|
if row is None:
|
|
return None
|
|
return row[0], float(row[1])
|
|
|
|
|
|
async def session_is_active(session: AsyncSession, token_hash: str) -> bool:
|
|
"""Проверить наличие неистёкшей сессии без загрузки пользователя."""
|
|
statement = select(
|
|
select(SessionRow.token_hash)
|
|
.where(SessionRow.token_hash == token_hash, SessionRow.expires_at > func.now())
|
|
.exists()
|
|
)
|
|
return (await session.execute(statement)).scalar_one()
|
|
|
|
|
|
async def delete_session(session: AsyncSession, token_hash: str) -> None:
|
|
"""Удалить сессию по хешу токена."""
|
|
await session.execute(delete(SessionRow).where(SessionRow.token_hash == token_hash))
|
|
await session.commit()
|
|
|
|
|
|
async def create_chat(
|
|
session: AsyncSession, title: str, member_ids: List[uuid.UUID]
|
|
) -> Tuple[Chat, List[uuid.UUID]]:
|
|
"""Атомарно создать чат и участников; неизвестный участник -> UnknownMember."""
|
|
chat_statement = insert(Chat).values(id=uuid.uuid4(), title=title).returning(Chat)
|
|
try:
|
|
chat = (await session.execute(chat_statement)).scalar_one()
|
|
await session.execute(
|
|
insert(ChatMember),
|
|
[{"chat_id": chat.id, "user_id": user_id} for user_id in member_ids],
|
|
)
|
|
await session.commit()
|
|
except IntegrityError as error:
|
|
await session.rollback()
|
|
if sqlstate(error) == FOREIGN_KEY_VIOLATION:
|
|
raise UnknownMember()
|
|
raise
|
|
return chat, member_ids
|
|
|
|
|
|
async def get_chat_for_member(
|
|
session: AsyncSession, chat_id: uuid.UUID, user_id: uuid.UUID
|
|
) -> Optional[Chat]:
|
|
"""Чат, если пользователь в нём состоит, иначе None."""
|
|
statement = (
|
|
select(Chat)
|
|
.join(ChatMember, ChatMember.chat_id == Chat.id)
|
|
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
|
|
)
|
|
return (await session.execute(statement)).scalar_one_or_none()
|
|
|
|
|
|
async def get_member_ids(
|
|
session: AsyncSession, chat_ids: List[uuid.UUID]
|
|
) -> Dict[uuid.UUID, List[uuid.UUID]]:
|
|
"""Участники нескольких чатов одним запросом: {chat_id: [user_id]}."""
|
|
result: Dict[uuid.UUID, List[uuid.UUID]] = {chat_id: [] for chat_id in chat_ids}
|
|
if chat_ids:
|
|
statement = (
|
|
select(ChatMember.chat_id, ChatMember.user_id)
|
|
.where(ChatMember.chat_id.in_(chat_ids))
|
|
.order_by(ChatMember.chat_id, ChatMember.user_id)
|
|
)
|
|
for chat_id, user_id in (await session.execute(statement)).all():
|
|
result[chat_id].append(user_id)
|
|
return result
|
|
|
|
|
|
async def list_chats(
|
|
session: AsyncSession, user_id: uuid.UUID, after: Optional[Position], limit: int
|
|
) -> Tuple[List[Chat], bool]:
|
|
"""Страница чатов пользователя по (created_at, id) и признак следующей страницы."""
|
|
statement = (
|
|
select(Chat)
|
|
.join(ChatMember, ChatMember.chat_id == Chat.id)
|
|
.where(ChatMember.user_id == user_id)
|
|
)
|
|
if after is not None:
|
|
statement = statement.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after))
|
|
statement = statement.order_by(Chat.created_at, Chat.id).limit(limit + 1)
|
|
rows = list((await session.execute(statement)).scalars())
|
|
return rows[:limit], len(rows) > limit
|
|
|
|
|
|
async def create_message_idempotent(
|
|
session: AsyncSession, chat_id: uuid.UUID, sender_id: uuid.UUID, text: str, key: str
|
|
) -> Message:
|
|
"""Атомарно сохранить сообщение и результат на 24 часа во всех API-репликах."""
|
|
scope = f"{sender_id}:{chat_id}:{key}".encode("utf-8")
|
|
lock_id = int.from_bytes(hashlib.sha256(scope).digest()[:8], "big", signed=True)
|
|
match = (
|
|
MessageRequest.user_id == sender_id,
|
|
MessageRequest.chat_id == chat_id,
|
|
MessageRequest.key == key,
|
|
)
|
|
try:
|
|
await session.execute(select(func.pg_advisory_xact_lock(lock_id)))
|
|
previous = (await session.execute(
|
|
select(MessageRequest).where(*match, MessageRequest.expires_at > func.clock_timestamp())
|
|
)).scalar_one_or_none()
|
|
if previous is not None:
|
|
if previous.request_text != text:
|
|
raise IdempotencyConflict()
|
|
message = (await session.execute(
|
|
select(Message).where(Message.id == previous.message_id)
|
|
)).scalar_one()
|
|
else:
|
|
await session.execute(delete(MessageRequest).where(*match))
|
|
message = (await session.execute(
|
|
insert(Message).values(
|
|
id=uuid.uuid4(), chat_id=chat_id, sender_id=sender_id, text=text
|
|
).returning(Message)
|
|
)).scalar_one()
|
|
await session.execute(insert(MessageRequest).values(
|
|
user_id=sender_id, chat_id=chat_id, key=key, request_text=text,
|
|
message_id=message.id, expires_at=func.clock_timestamp() + timedelta(hours=24),
|
|
))
|
|
await session.commit()
|
|
return message
|
|
except BaseException:
|
|
await session.rollback()
|
|
raise
|
|
|
|
|
|
def history_query(chat_id: uuid.UUID, after: Optional[Position], limit: int) -> Select:
|
|
"""SELECT страницы истории по курсору (created_at, id); идёт по индексу чата."""
|
|
statement = select(Message).where(Message.chat_id == chat_id)
|
|
if after is not None:
|
|
statement = statement.where(
|
|
tuple_(Message.created_at, Message.id) > tuple_(*after)
|
|
)
|
|
return statement.order_by(Message.created_at, Message.id).limit(limit + 1)
|
|
|
|
|
|
async def list_messages(
|
|
session: AsyncSession, chat_id: uuid.UUID, after: Optional[Position], limit: int
|
|
) -> Tuple[List[Message], bool]:
|
|
"""Страница истории чата и признак следующей страницы."""
|
|
rows = list((await session.execute(history_query(chat_id, after, limit))).scalars())
|
|
return rows[:limit], len(rows) > limit
|