Files
mtusi2026lab4/app/logic.py
T

793 lines
30 KiB
Python

"""Users, sessions, chats, messages, and synchronous attachment upload."""
import base64
import hashlib
import json
import logging
import os
import re
import secrets
import tempfile
import uuid
from datetime import datetime, timezone
import asyncpg
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError
from app.config import Settings
from app.db import pool
from app.errors import ApiError, unauthorized
from app.images import validate_image
from app import s3client
logger = logging.getLogger("messenger")
_HASHER = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
_DUMMY_HASH = _HASHER.hash("timing-only-not-a-login-secret")
_USERNAME = re.compile(r"^[a-z0-9_]{3,32}$")
_IDEMPOTENCY = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
_CONTROLS = set(range(32))
def iso(value: datetime) -> str:
if value.tzinfo is None:
value = value.replace(tzinfo=timezone.utc)
else:
value = value.astimezone(timezone.utc)
return value.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def parse_iso(value: str) -> datetime:
if not isinstance(value, str) or not value.endswith("Z"):
raise ValueError("timestamp")
return datetime.fromisoformat(value[:-1] + "+00:00")
def parse_uuid(value: str) -> str:
try:
return str(uuid.UUID(str(value)))
except (ValueError, AttributeError, TypeError) as exc:
raise ApiError(400, "invalid_request", "Некорректный идентификатор") from exc
def _code_points(value: str) -> int:
return len(value)
def _require_object(data, allowed: set[str], required: set[str]) -> None:
if not isinstance(data, dict):
raise ApiError(400, "invalid_request", "Ожидается JSON-объект")
extra = set(data) - allowed
if extra:
raise ApiError(400, "invalid_request", "Неизвестные поля")
missing = required - set(data)
if missing:
raise ApiError(400, "invalid_request", "Отсутствуют обязательные поля")
def _nonblank(value: str) -> bool:
return value.strip() != ""
def _lock_keys(scope: str) -> tuple[int, int]:
digest = hashlib.sha256(scope.encode("utf-8")).digest()
return int.from_bytes(digest[0:4], "big") & 0x7FFFFFFF, int.from_bytes(digest[4:8], "big") & 0x7FFFFFFF
def _cursor_encode(payload: dict) -> str:
raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
def _cursor_decode(raw: str) -> dict:
if not isinstance(raw, str) or raw == "":
raise ApiError(400, "invalid_request", "Некорректный cursor")
padding = "=" * (-len(raw) % 4)
try:
data = json.loads(base64.urlsafe_b64decode(raw + padding).decode("utf-8"))
except (ValueError, UnicodeError, json.JSONDecodeError) as exc:
raise ApiError(400, "invalid_request", "Некорректный cursor") from exc
if not isinstance(data, dict):
raise ApiError(400, "invalid_request", "Некорректный cursor")
return data
def user_dict(row) -> dict:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": iso(row["created_at"]),
}
def message_dict(row, attachment_ids: list[str]) -> 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"]),
"attachment_ids": attachment_ids,
}
def attachment_dict(row) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"owner_id": str(row["owner_id"]),
"filename": row["filename"],
"content_type": row["content_type"],
"size_bytes": row["size_bytes"],
"sha256": row["sha256"],
"status": row["status"],
"variants": [],
"error_code": None,
"created_at": iso(row["created_at"]),
"updated_at": iso(row["updated_at"]),
}
async def _attachments_for(conn, message_ids: list) -> dict[str, list[str]]:
grouped: dict[str, list[str]] = {str(item): [] for item in message_ids}
if not message_ids:
return grouped
rows = await conn.fetch(
"""
SELECT message_id, attachment_id
FROM message_attachments
WHERE message_id = ANY($1::uuid[])
ORDER BY message_id, position
""",
message_ids,
)
for row in rows:
grouped.setdefault(str(row["message_id"]), []).append(str(row["attachment_id"]))
return grouped
async def _members_for(conn, chat_ids: list) -> dict[str, list[str]]:
grouped: dict[str, list[str]] = {str(item): [] for item in chat_ids}
if not chat_ids:
return grouped
rows = await conn.fetch(
"""
SELECT chat_id, user_id
FROM chat_members
WHERE chat_id = ANY($1::uuid[])
ORDER BY chat_id, position
""",
chat_ids,
)
for row in rows:
grouped.setdefault(str(row["chat_id"]), []).append(str(row["user_id"]))
return grouped
def chat_dict(row, member_ids: list[str]) -> dict:
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": member_ids,
"created_at": iso(row["created_at"]),
}
async def register_user(body: dict) -> dict:
_require_object(body, {"username", "display_name", "password"}, {"username", "display_name", "password"})
username = body["username"]
display_name = body["display_name"]
password = body["password"]
if not isinstance(username, str) or _USERNAME.fullmatch(username) is None:
raise ApiError(400, "invalid_request", "Некорректное имя пользователя")
if not isinstance(display_name, str) or not _nonblank(display_name) or _code_points(display_name) > 100:
raise ApiError(400, "invalid_request", "Некорректное отображаемое имя")
if not isinstance(password, str) or not (12 <= _code_points(password) <= 128) or "\x00" in password:
raise ApiError(400, "invalid_request", "Некорректный пароль")
password_hash = _HASHER.hash(password)
try:
row = await pool().fetchrow(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, $2, $3, $4, clock_timestamp())
RETURNING id, username, display_name, created_at
""",
uuid.uuid4(),
username,
display_name,
password_hash,
)
except asyncpg.UniqueViolationError as exc:
raise ApiError(409, "conflict", "Имя пользователя занято") from exc
return user_dict(row)
async def create_session(username: str, password: str, settings: Settings) -> dict:
if not isinstance(username, str) or _USERNAME.fullmatch(username) is None:
raise unauthorized("basic")
if not isinstance(password, str) or "\x00" in password:
raise unauthorized("basic")
row = await pool().fetchrow(
"""
SELECT id, username, display_name, created_at, password_hash
FROM users
WHERE username = $1
""",
username,
)
if row is None:
try:
_HASHER.verify(_DUMMY_HASH, password)
except (VerifyMismatchError, VerificationError, InvalidHashError):
pass
raise unauthorized("basic")
try:
ok = _HASHER.verify(row["password_hash"], password)
except (VerifyMismatchError, VerificationError, InvalidHashError):
ok = False
if not ok:
raise unauthorized("basic")
token = secrets.token_urlsafe(32)
token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
expires = await pool().fetchval(
"""
INSERT INTO sessions (token_hash, user_id, expires_at)
VALUES ($1, $2, clock_timestamp() + make_interval(secs => $3::int))
RETURNING expires_at
""",
token_hash,
row["id"],
settings.session_ttl_seconds,
)
return {
"token": token,
"token_type": "Bearer",
"expires_at": iso(expires),
"user": user_dict(row),
}
async def authenticate(token: str) -> dict:
if not token:
raise unauthorized("bearer")
token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
row = await pool().fetchrow(
"""
SELECT u.id, u.username, u.display_name, u.created_at
FROM sessions s
JOIN users u ON u.id = s.user_id
WHERE s.token_hash = $1
AND s.revoked_at IS NULL
AND s.expires_at > clock_timestamp()
""",
token_hash,
)
if row is None:
raise unauthorized("bearer")
return user_dict(row)
async def revoke_session(token: str) -> None:
token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
await pool().execute(
"""
UPDATE sessions
SET revoked_at = clock_timestamp()
WHERE token_hash = $1 AND revoked_at IS NULL
""",
token_hash,
)
async def create_chat(user_id: str, body: dict) -> dict:
_require_object(body, {"title", "member_ids"}, {"title", "member_ids"})
title = body["title"]
member_ids = body["member_ids"]
if not isinstance(title, str) or not _nonblank(title) or _code_points(title) > 100 or "\x00" in title:
raise ApiError(400, "invalid_request", "Некорректное название чата")
if not isinstance(member_ids, list) or not (1 <= len(member_ids) <= 100):
raise ApiError(400, "invalid_request", "Некорректный список участников")
canonical = []
for item in member_ids:
if not isinstance(item, str):
raise ApiError(400, "invalid_request", "Некорректный список участников")
canonical.append(parse_uuid(item))
if len(canonical) != len(set(canonical)):
raise ApiError(400, "invalid_request", "Список участников содержит дубликаты")
if user_id not in canonical:
raise ApiError(400, "invalid_request", "Создатель должен входить в список участников")
member_uuids = [uuid.UUID(item) for item in canonical]
async with pool().acquire() as conn:
async with conn.transaction():
found = await conn.fetch("SELECT id FROM users WHERE id = ANY($1::uuid[])", member_uuids)
if len(found) != len(canonical):
raise ApiError(400, "invalid_request", "Участник не найден")
row = await conn.fetchrow(
"""
INSERT INTO chats (id, title, created_at)
VALUES ($1, $2, clock_timestamp())
RETURNING id, title, created_at
""",
uuid.uuid4(),
title,
)
for position, member_id in enumerate(member_uuids):
await conn.execute(
"""
INSERT INTO chat_members (chat_id, user_id, position)
VALUES ($1, $2, $3)
""",
row["id"],
member_id,
position,
)
return chat_dict(row, canonical)
def parse_limit(raw: str | None) -> int:
if raw is None:
return 50
if not re.fullmatch(r"[1-9][0-9]*", raw):
raise ApiError(400, "invalid_request", "Некорректный limit")
value = int(raw)
if value > 100:
raise ApiError(400, "invalid_request", "Некорректный limit")
return value
async def list_chats(user_id: str, limit: int, cursor: str | None) -> dict:
created_at = None
cursor_id = None
if cursor is not None:
payload = _cursor_decode(cursor)
if payload.get("kind") != "chat" or payload.get("user_id") != user_id:
raise ApiError(400, "invalid_request", "Некорректный cursor")
try:
created_at = parse_iso(payload["created_at"])
cursor_id = uuid.UUID(parse_uuid(payload["id"]))
except (KeyError, ValueError, TypeError) as exc:
raise ApiError(400, "invalid_request", "Некорректный cursor") from exc
rows = await pool().fetch(
"""
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = $1
WHERE ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2, $3))
ORDER BY c.created_at, c.id
LIMIT $4
""",
uuid.UUID(user_id),
created_at,
cursor_id,
limit + 1,
)
has_more = len(rows) > limit
rows = rows[:limit]
members = await _members_for(pool(), [row["id"] for row in rows])
items = [chat_dict(row, members.get(str(row["id"]), [])) for row in rows]
next_cursor = None
if has_more and rows:
last = rows[-1]
next_cursor = _cursor_encode(
{
"v": 1,
"kind": "chat",
"user_id": user_id,
"created_at": iso(last["created_at"]),
"id": str(last["id"]),
}
)
return {"items": items, "next_cursor": next_cursor}
async def get_chat(user_id: str, chat_id: str) -> dict:
chat_uuid = uuid.UUID(parse_uuid(chat_id))
row = await pool().fetchrow(
"""
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = $2
WHERE c.id = $1
""",
chat_uuid,
uuid.UUID(user_id),
)
if row is None:
raise ApiError(404, "not_found", "Объект не найден")
members = await _members_for(pool(), [row["id"]])
return chat_dict(row, members.get(str(row["id"]), []))
def _message_parts(body: dict) -> tuple[str, list[str]]:
_require_object(body, {"text", "attachment_ids"}, {"text"})
text = body["text"]
if not isinstance(text, str) or "\x00" in text or _code_points(text) > 4000:
raise ApiError(400, "invalid_request", "Некорректный текст сообщения")
raw_ids = body.get("attachment_ids", [])
if raw_ids is None or not isinstance(raw_ids, list) or len(raw_ids) > 10:
raise ApiError(400, "invalid_request", "Некорректный список вложений")
attachment_ids = []
for item in raw_ids:
if not isinstance(item, str):
raise ApiError(400, "invalid_request", "Некорректный список вложений")
attachment_ids.append(parse_uuid(item))
if len(attachment_ids) != len(set(attachment_ids)):
raise ApiError(400, "invalid_request", "Список вложений содержит дубликаты")
if not _nonblank(text) and not attachment_ids:
raise ApiError(400, "invalid_request", "Пустое сообщение")
return text, attachment_ids
def _canonical_hash(text: str, attachment_ids: list[str]) -> str:
payload = json.dumps(
{"attachment_ids": attachment_ids, "text": text},
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
)
return hashlib.sha256(payload.encode("utf-8")).hexdigest()
async def create_message(user_id: str, chat_id: str, body: dict, idem_key: str | None, settings: Settings) -> dict:
chat_id = parse_uuid(chat_id)
if idem_key is None or _IDEMPOTENCY.fullmatch(idem_key) is None:
raise ApiError(400, "invalid_request", "Требуется корректный Idempotency-Key")
text, attachment_ids = _message_parts(body)
request_hash = _canonical_hash(text, attachment_ids)
path = f"/api/v1/chats/{chat_id}/messages"
k1, k2 = _lock_keys(f"{user_id}|POST|{path}|{idem_key}")
async with pool().acquire() as conn:
async with conn.transaction():
await conn.execute("SELECT pg_advisory_xact_lock($1::int, $2::int)", k1, k2)
member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
uuid.UUID(chat_id),
uuid.UUID(user_id),
)
if member is None:
raise ApiError(404, "not_found", "Объект не найден")
existing = await conn.fetchrow(
"""
SELECT request_hash, response_json,
created_at > clock_timestamp() - make_interval(secs => $4::int) AS fresh
FROM idempotency
WHERE user_id = $1 AND http_method = 'POST' AND path = $2 AND idem_key = $3
""",
uuid.UUID(user_id),
path,
idem_key,
settings.idempotency_ttl_seconds,
)
if existing is not None and existing["fresh"]:
if existing["request_hash"] != request_hash:
raise ApiError(409, "conflict", "Ключ идемпотентности уже использован")
stored = existing["response_json"]
if isinstance(stored, str):
stored = json.loads(stored)
return stored
if existing is not None and not existing["fresh"]:
await conn.execute(
"""
DELETE FROM idempotency
WHERE user_id = $1 AND http_method = 'POST' AND path = $2 AND idem_key = $3
""",
uuid.UUID(user_id),
path,
idem_key,
)
if attachment_ids:
found = await conn.fetch(
"SELECT id, chat_id, status FROM attachments WHERE id = ANY($1::uuid[])",
[uuid.UUID(item) for item in attachment_ids],
)
by_id = {str(row["id"]): row for row in found}
if len(by_id) != len(attachment_ids):
raise ApiError(404, "not_found", "Объект не найден")
for attachment_id in attachment_ids:
row = by_id[attachment_id]
if str(row["chat_id"]) != chat_id or row["status"] != "ready":
if str(row["chat_id"]) != chat_id:
raise ApiError(404, "not_found", "Объект не найден")
raise ApiError(409, "conflict", "Вложение нельзя прикрепить")
message = await conn.fetchrow(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1, $2, $3, $4, clock_timestamp())
RETURNING id, chat_id, sender_id, text, created_at
""",
uuid.uuid4(),
uuid.UUID(chat_id),
uuid.UUID(user_id),
text,
)
for position, attachment_id in enumerate(attachment_ids):
await conn.execute(
"""
INSERT INTO message_attachments (message_id, attachment_id, position)
VALUES ($1, $2, $3)
""",
message["id"],
uuid.UUID(attachment_id),
position,
)
payload = message_dict(message, attachment_ids)
await conn.execute(
"""
INSERT INTO idempotency (
user_id, http_method, path, idem_key, request_hash, status_code, response_json, created_at
)
VALUES ($1, 'POST', $2, $3, $4, 201, $5::jsonb, clock_timestamp())
""",
uuid.UUID(user_id),
path,
idem_key,
request_hash,
payload,
)
return payload
async def list_messages(user_id: str, chat_id: str, limit: int, cursor: str | None) -> dict:
chat_id = parse_uuid(chat_id)
member = await pool().fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
uuid.UUID(chat_id),
uuid.UUID(user_id),
)
if member is None:
raise ApiError(404, "not_found", "Объект не найден")
created_at = None
cursor_id = None
if cursor is not None:
payload = _cursor_decode(cursor)
if payload.get("kind") != "message" or payload.get("chat_id") != chat_id:
raise ApiError(400, "invalid_request", "Некорректный cursor")
try:
created_at = parse_iso(payload["created_at"])
cursor_id = uuid.UUID(parse_uuid(payload["id"]))
except (KeyError, ValueError, TypeError) as exc:
raise ApiError(400, "invalid_request", "Некорректный cursor") from exc
rows = await pool().fetch(
"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
AND ($2::timestamptz IS NULL OR (created_at, id) > ($2, $3))
ORDER BY created_at, id
LIMIT $4
""",
uuid.UUID(chat_id),
created_at,
cursor_id,
limit + 1,
)
has_more = len(rows) > limit
rows = rows[:limit]
grouped = await _attachments_for(pool(), [row["id"] for row in rows])
items = [message_dict(row, grouped.get(str(row["id"]), [])) for row in rows]
next_cursor = None
if has_more and rows:
last = rows[-1]
next_cursor = _cursor_encode(
{
"v": 1,
"kind": "message",
"chat_id": chat_id,
"created_at": iso(last["created_at"]),
"id": str(last["id"]),
}
)
return {"items": items, "next_cursor": next_cursor}
def validate_filename(filename: str | None) -> str:
if filename is None:
raise ApiError(400, "invalid_request", "Требуется filename")
if not isinstance(filename, str) or not (1 <= _code_points(filename) <= 255):
raise ApiError(400, "invalid_request", "Некорректное имя файла")
if not _nonblank(filename) or filename in {".", ".."}:
raise ApiError(400, "invalid_request", "Некорректное имя файла")
for char in filename:
code = ord(char)
if char in {"/", "\\"} or code in _CONTROLS or code == 127:
raise ApiError(400, "invalid_request", "Некорректное имя файла")
return filename
def _media_type(value: str | None) -> str:
if not value:
raise ApiError(415, "unsupported_media_type", "Требуется image/png или image/jpeg")
media = value.split(";", 1)[0].strip().lower()
if media not in {"image/png", "image/jpeg"}:
raise ApiError(415, "unsupported_media_type", "Поддерживаются только image/png и image/jpeg")
return media
async def _mark_ledger(key: str, state: str) -> None:
await pool().execute(
"""
UPDATE object_ledger
SET state = $2, updated_at = clock_timestamp()
WHERE object_key = $1
""",
key,
state,
)
async def _compensate(settings: Settings, key: str) -> None:
"""Drop a staged object after a failed metadata commit. A failed delete stays for the reconciler."""
try:
await _to_thread(s3client.delete_object, settings, key)
await _mark_ledger(key, "aborted")
except Exception:
logger.exception("compensation failed for staged object; reconciler will retry after the grace period")
async def _to_thread(func, *args):
import asyncio
return await asyncio.to_thread(func, *args)
async def upload_attachment(
user_id: str,
chat_id: str,
filename: str | None,
content_type_header: str | None,
content_length: str | None,
byte_iter,
settings: Settings,
) -> dict:
chat_id = parse_uuid(chat_id)
member = await pool().fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
uuid.UUID(chat_id),
uuid.UUID(user_id),
)
if member is None:
raise ApiError(404, "not_found", "Объект не найден")
filename = validate_filename(filename)
media = _media_type(content_type_header)
if content_length is not None and not re.fullmatch(r"\d+", content_length):
raise ApiError(400, "invalid_request", "Некорректный Content-Length")
attachment_id = str(uuid.uuid4())
object_key = f"o/{attachment_id}"
os.makedirs("/tmp/uploads", exist_ok=True)
fd, temp_path = tempfile.mkstemp(prefix="up-", dir="/tmp/uploads")
os.close(fd)
digest = hashlib.sha256()
size = 0
try:
with open(temp_path, "wb") as handle:
async for chunk in byte_iter:
if not chunk:
continue
size += len(chunk)
if size > settings.max_upload_bytes:
raise ApiError(413, "payload_too_large", "Файл превышает 10 МиБ")
digest.update(chunk)
handle.write(chunk)
if size < 1:
raise ApiError(415, "unsupported_media_type", "Пустой файл")
await _to_thread(
validate_image,
temp_path,
media,
settings.max_image_pixels,
settings.full_decode_pixels,
)
sha256 = digest.hexdigest()
await pool().execute(
"""
INSERT INTO object_ledger (
object_key, attachment_id, chat_id, state, note, size_bytes, created_at, updated_at
)
VALUES ($1, $2, $3, 'staging', 'upload', $4, clock_timestamp(), clock_timestamp())
""",
object_key,
uuid.UUID(attachment_id),
uuid.UUID(chat_id),
size,
)
try:
await _to_thread(s3client.put_file, settings, object_key, temp_path, media, size)
except Exception:
await _compensate(settings, object_key)
raise
try:
async with pool().acquire() as conn:
async with conn.transaction():
row = await conn.fetchrow(
"""
INSERT INTO attachments (
id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
status, object_key, error_code, created_at, updated_at
)
VALUES (
$1, $2, $3, $4, $5, $6, $7, 'ready', $8, NULL,
clock_timestamp(), clock_timestamp()
)
RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
status, created_at, updated_at
""",
uuid.UUID(attachment_id),
uuid.UUID(chat_id),
uuid.UUID(user_id),
filename,
media,
size,
sha256,
object_key,
)
updated = await conn.execute(
"""
UPDATE object_ledger
SET state = 'committed', updated_at = clock_timestamp()
WHERE object_key = $1 AND state = 'staging'
""",
object_key,
)
if not updated.endswith("1"):
raise RuntimeError("ledger was not in staging state")
except Exception:
logger.exception("metadata commit failed after object upload")
await _compensate(settings, object_key)
raise ApiError(503, "unavailable", "Не удалось сохранить метаданные вложения")
return attachment_dict(row)
finally:
try:
os.remove(temp_path)
except OSError:
pass
async def get_attachment(user_id: str, attachment_id: str) -> dict:
attachment_id = parse_uuid(attachment_id)
row = await pool().fetchrow(
"""
SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256,
a.status, a.created_at, a.updated_at
FROM attachments a
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
WHERE a.id = $1
""",
uuid.UUID(attachment_id),
uuid.UUID(user_id),
)
if row is None:
raise ApiError(404, "not_found", "Объект не найден")
return attachment_dict(row)
async def download_attachment(user_id: str, attachment_id: str, variant: str | None, settings: Settings) -> tuple[bytes, str]:
if variant not in {None, "original"}:
raise ApiError(400, "invalid_request", "Некорректный variant")
attachment_id = parse_uuid(attachment_id)
row = await pool().fetchrow(
"""
SELECT a.object_key, a.content_type, a.size_bytes
FROM attachments a
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
WHERE a.id = $1
""",
uuid.UUID(attachment_id),
uuid.UUID(user_id),
)
if row is None:
raise ApiError(404, "not_found", "Объект не найден")
data = await _to_thread(s3client.get_bytes, settings, row["object_key"], settings.max_upload_bytes)
if len(data) != row["size_bytes"]:
raise ApiError(404, "not_found", "Объект не найден")
return data, row["content_type"]
async def ready(settings: Settings) -> None:
try:
await pool().fetchval("SELECT 1")
except Exception as exc:
raise ApiError(503, "unavailable", "База данных недоступна") from exc
await _to_thread(s3client.head_bucket, settings)