950 lines
34 KiB
Python
950 lines
34 KiB
Python
import asyncio
|
|
import base64
|
|
from contextlib import asynccontextmanager
|
|
import datetime as dt
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import uuid
|
|
from typing import Any
|
|
|
|
import asyncpg
|
|
import redis.asyncio as redis
|
|
|
|
import io
|
|
import boto3
|
|
import botocore.exceptions
|
|
from PIL import Image
|
|
|
|
from app.auth import generate_session_token, hash_password, verify_password
|
|
from app.config import (
|
|
CACHE_URL,
|
|
DATABASE_URL,
|
|
SESSION_TTL_SECONDS,
|
|
S3_ENDPOINT,
|
|
S3_REGION,
|
|
S3_BUCKET,
|
|
S3_ACCESS_KEY_ID,
|
|
S3_SECRET_ACCESS_KEY,
|
|
MAX_UPLOAD_BYTES,
|
|
MAX_IMAGE_PIXELS,
|
|
)
|
|
from app.errors import (
|
|
ConflictError,
|
|
InvalidRequestError,
|
|
NotFoundError,
|
|
PayloadTooLargeError,
|
|
UnauthorizedError,
|
|
UnsupportedMediaTypeError,
|
|
)
|
|
from app.schemas import (
|
|
AttachmentResponse,
|
|
ChatResponse,
|
|
MessageResponse,
|
|
SessionResponse,
|
|
UserResponse,
|
|
VariantResponse,
|
|
now_utc_iso,
|
|
)
|
|
|
|
logger = logging.getLogger("app.storage")
|
|
|
|
|
|
def encode_cursor(data: dict) -> str:
|
|
raw = json.dumps(data, separators=(",", ":")).encode("utf-8")
|
|
return base64.urlsafe_b64encode(raw).decode("utf-8").rstrip("=")
|
|
|
|
|
|
def decode_cursor(cursor_str: str) -> dict:
|
|
if not isinstance(cursor_str, str) or not cursor_str.strip():
|
|
raise InvalidRequestError("Некорректный курсор")
|
|
try:
|
|
padded = cursor_str + "=" * (-len(cursor_str) % 4)
|
|
raw = base64.urlsafe_b64decode(padded.encode("utf-8"))
|
|
data = json.loads(raw.decode("utf-8"))
|
|
if not isinstance(data, dict):
|
|
raise InvalidRequestError("Некорректный курсор")
|
|
return data
|
|
except InvalidRequestError:
|
|
raise
|
|
except Exception as exc:
|
|
raise InvalidRequestError("Некорректный курсор") from exc
|
|
|
|
|
|
def _format_dt(d: dt.datetime) -> str:
|
|
if d.tzinfo is None:
|
|
d = d.replace(tzinfo=dt.timezone.utc)
|
|
return d.astimezone(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
|
|
|
|
|
def _to_text(val: Any) -> str:
|
|
if isinstance(val, (bytes, bytearray, memoryview)):
|
|
return bytes(val).decode("utf-8")
|
|
return str(val)
|
|
|
|
|
|
class PostgresStorage:
|
|
def __init__(self) -> None:
|
|
self.pg_pool: asyncpg.Pool | None = None
|
|
self.redis_client: redis.Redis | None = None
|
|
self.s3_client: Any = None
|
|
|
|
@asynccontextmanager
|
|
async def acquire_conn(self, timeout: float = 2.0):
|
|
if self.pg_pool is None:
|
|
raise asyncpg.InterfaceError("Пул подключений к PostgreSQL не инициализирован")
|
|
async with asyncio.timeout(3.0):
|
|
async with self.pg_pool.acquire(timeout=timeout) as conn:
|
|
yield conn
|
|
|
|
async def connect(self) -> None:
|
|
logger.info("Подключение к PostgreSQL: %s", DATABASE_URL.split("@")[-1])
|
|
self.pg_pool = await asyncpg.create_pool(
|
|
DATABASE_URL,
|
|
min_size=2,
|
|
max_size=20,
|
|
command_timeout=3.0,
|
|
timeout=2.0,
|
|
)
|
|
|
|
logger.info("Подключение к Redis: %s", CACHE_URL.split("@")[-1])
|
|
self.redis_client = redis.from_url(
|
|
CACHE_URL,
|
|
decode_responses=True,
|
|
socket_connect_timeout=2.0,
|
|
socket_timeout=2.0,
|
|
)
|
|
|
|
logger.info("Подключение к S3 (MinIO): %s, bucket: %s", S3_ENDPOINT, S3_BUCKET)
|
|
self.s3_client = boto3.client(
|
|
"s3",
|
|
endpoint_url=S3_ENDPOINT,
|
|
aws_access_key_id=S3_ACCESS_KEY_ID,
|
|
aws_secret_access_key=S3_SECRET_ACCESS_KEY,
|
|
region_name=S3_REGION,
|
|
)
|
|
await self._ensure_bucket()
|
|
|
|
async def _ensure_bucket(self) -> None:
|
|
def _init():
|
|
try:
|
|
self.s3_client.head_bucket(Bucket=S3_BUCKET)
|
|
except Exception:
|
|
try:
|
|
self.s3_client.create_bucket(Bucket=S3_BUCKET)
|
|
logger.info("Создан приватный бакет S3: %s", S3_BUCKET)
|
|
except Exception as e:
|
|
logger.warning("Не удалось создать бакет S3 %s: %s", S3_BUCKET, e)
|
|
|
|
await asyncio.to_thread(_init)
|
|
|
|
async def disconnect(self) -> None:
|
|
if self.pg_pool:
|
|
await self.pg_pool.close()
|
|
self.pg_pool = None
|
|
if self.redis_client:
|
|
await self.redis_client.close()
|
|
self.redis_client = None
|
|
self.s3_client = None
|
|
|
|
async def check_health(self) -> bool:
|
|
if not self.pg_pool or not self.redis_client or not self.s3_client:
|
|
return False
|
|
try:
|
|
async with asyncio.timeout(2.5):
|
|
async with self.acquire_conn(timeout=1.5) as conn:
|
|
await conn.fetchval("SELECT 1")
|
|
await self.redis_client.ping()
|
|
await asyncio.to_thread(self.s3_client.head_bucket, Bucket=S3_BUCKET)
|
|
return True
|
|
except Exception as exc:
|
|
logger.warning("Ошибка проверки health: %s", exc)
|
|
return False
|
|
|
|
# ------------------ Пользователи и аутентификация ------------------
|
|
|
|
async def create_user(
|
|
self, username: str, display_name: str, password: str
|
|
) -> UserResponse:
|
|
user_id = uuid.uuid4()
|
|
now = dt.datetime.now(dt.timezone.utc)
|
|
pwd_hash = await asyncio.to_thread(hash_password, password)
|
|
|
|
try:
|
|
async with self.acquire_conn() as conn:
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
""",
|
|
user_id,
|
|
username,
|
|
display_name,
|
|
pwd_hash,
|
|
now,
|
|
)
|
|
except asyncpg.UniqueViolationError:
|
|
raise ConflictError("Имя пользователя уже занято")
|
|
|
|
return UserResponse(
|
|
id=str(user_id),
|
|
username=username,
|
|
display_name=display_name,
|
|
created_at=_format_dt(now),
|
|
)
|
|
|
|
async def authenticate_user(
|
|
self, username: str, password: str
|
|
) -> UserResponse | None:
|
|
async with self.acquire_conn() as conn:
|
|
row = await conn.fetchrow(
|
|
"""
|
|
SELECT id, username, display_name, password_hash, created_at
|
|
FROM users
|
|
WHERE username = $1
|
|
""",
|
|
username,
|
|
)
|
|
|
|
if not row:
|
|
return None
|
|
|
|
is_valid = await asyncio.to_thread(verify_password, row["password_hash"], password)
|
|
if not is_valid:
|
|
return None
|
|
|
|
return UserResponse(
|
|
id=str(row["id"]),
|
|
username=row["username"],
|
|
display_name=_to_text(row["display_name"]),
|
|
created_at=_format_dt(row["created_at"]),
|
|
)
|
|
|
|
async def get_user_by_id(self, user_id: str) -> UserResponse | None:
|
|
try:
|
|
uid = uuid.UUID(user_id)
|
|
except ValueError:
|
|
return None
|
|
|
|
async with self.acquire_conn() as conn:
|
|
row = await conn.fetchrow(
|
|
"""
|
|
SELECT id, username, display_name, created_at
|
|
FROM users
|
|
WHERE id = $1
|
|
""",
|
|
uid,
|
|
)
|
|
|
|
if not row:
|
|
return None
|
|
|
|
return UserResponse(
|
|
id=str(row["id"]),
|
|
username=row["username"],
|
|
display_name=_to_text(row["display_name"]),
|
|
created_at=_format_dt(row["created_at"]),
|
|
)
|
|
|
|
# ------------------ Сессии (Redis) ------------------
|
|
|
|
async def create_session(self, user: UserResponse) -> SessionResponse:
|
|
assert self.redis_client is not None
|
|
token = generate_session_token()
|
|
now = dt.datetime.now(dt.timezone.utc)
|
|
expires_at = now + dt.timedelta(seconds=SESSION_TTL_SECONDS)
|
|
expires_at_str = _format_dt(expires_at)
|
|
|
|
session_data = json.dumps(
|
|
{
|
|
"user_id": user.id,
|
|
"expires_at": expires_at_str,
|
|
}
|
|
)
|
|
|
|
key = f"session:{token}"
|
|
await self.redis_client.set(key, session_data, ex=SESSION_TTL_SECONDS)
|
|
|
|
return SessionResponse(
|
|
token=token,
|
|
token_type="Bearer",
|
|
expires_at=expires_at_str,
|
|
user=user,
|
|
)
|
|
|
|
async def get_session_user(self, token: str) -> UserResponse | None:
|
|
if not token or not self.redis_client:
|
|
return None
|
|
|
|
key = f"session:{token}"
|
|
raw = await self.redis_client.get(key)
|
|
if not raw:
|
|
return None
|
|
|
|
try:
|
|
data = json.loads(raw)
|
|
user_id = data.get("user_id")
|
|
except Exception:
|
|
return None
|
|
|
|
if not user_id:
|
|
return None
|
|
|
|
return await self.get_user_by_id(user_id)
|
|
|
|
async def delete_session(self, token: str) -> bool:
|
|
if not token or not self.redis_client:
|
|
return False
|
|
key = f"session:{token}"
|
|
res = await self.redis_client.delete(key)
|
|
return res > 0
|
|
|
|
# ------------------ Чаты ------------------
|
|
|
|
async def create_chat(
|
|
self, caller_id: str, title: str, member_ids: list[str]
|
|
) -> ChatResponse:
|
|
if caller_id not in member_ids:
|
|
raise InvalidRequestError("Создатель чата должен быть в списке участников")
|
|
|
|
chat_id = uuid.uuid4()
|
|
now = dt.datetime.now(dt.timezone.utc)
|
|
|
|
member_uuids = [uuid.UUID(m) for m in member_ids]
|
|
|
|
async with self.acquire_conn() as conn:
|
|
# Проверяем существование всех участников
|
|
found = await conn.fetch(
|
|
"SELECT id FROM users WHERE id = ANY($1::uuid[])", member_uuids
|
|
)
|
|
if len(found) != len(member_uuids):
|
|
raise InvalidRequestError(
|
|
"Один или несколько участников чата не найдены"
|
|
)
|
|
|
|
async with conn.transaction():
|
|
await conn.execute(
|
|
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)",
|
|
chat_id,
|
|
title,
|
|
now,
|
|
)
|
|
member_records = [(chat_id, m) for m in member_uuids]
|
|
await conn.executemany(
|
|
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
|
|
member_records,
|
|
)
|
|
|
|
return ChatResponse(
|
|
id=str(chat_id),
|
|
title=title,
|
|
member_ids=member_ids,
|
|
created_at=_format_dt(now),
|
|
)
|
|
|
|
async def get_chat(self, caller_id: str, chat_id: str) -> ChatResponse:
|
|
try:
|
|
cid = uuid.UUID(chat_id)
|
|
c_caller = uuid.UUID(caller_id)
|
|
except ValueError:
|
|
raise NotFoundError("Чат не найден")
|
|
|
|
async with self.acquire_conn() as conn:
|
|
# Проверяем членство вызывающего
|
|
is_member = await conn.fetchval(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
|
cid,
|
|
c_caller,
|
|
)
|
|
if not is_member:
|
|
raise NotFoundError("Чат не найден")
|
|
|
|
chat_row = await conn.fetchrow(
|
|
"SELECT id, title, created_at FROM chats WHERE id = $1", cid
|
|
)
|
|
if not chat_row:
|
|
raise NotFoundError("Чат не найден")
|
|
|
|
members_rows = await conn.fetch(
|
|
"SELECT user_id FROM chat_members WHERE chat_id = $1", cid
|
|
)
|
|
member_ids = [str(r["user_id"]) for r in members_rows]
|
|
|
|
return ChatResponse(
|
|
id=str(chat_row["id"]),
|
|
title=_to_text(chat_row["title"]),
|
|
member_ids=member_ids,
|
|
created_at=_format_dt(chat_row["created_at"]),
|
|
)
|
|
|
|
async def list_chats(
|
|
self, caller_id: str, limit: int = 50, cursor: str | None = None
|
|
) -> tuple[list[ChatResponse], str | None]:
|
|
try:
|
|
c_caller = uuid.UUID(caller_id)
|
|
except ValueError:
|
|
return [], None
|
|
|
|
c_created: dt.datetime | None = None
|
|
c_id: uuid.UUID | None = None
|
|
|
|
if cursor is not None:
|
|
c_data = decode_cursor(cursor)
|
|
if c_data.get("type") != "chats":
|
|
raise InvalidRequestError("Недействительный тип курсора")
|
|
c_created_str = c_data.get("created_at")
|
|
c_id_str = c_data.get("id")
|
|
if (
|
|
not isinstance(c_created_str, str)
|
|
or not isinstance(c_id_str, str)
|
|
or not c_created_str.strip()
|
|
or not c_id_str.strip()
|
|
):
|
|
raise InvalidRequestError("Поврежденный курсор")
|
|
try:
|
|
c_created = dt.datetime.fromisoformat(
|
|
c_created_str.replace("Z", "+00:00")
|
|
)
|
|
c_id = uuid.UUID(c_id_str)
|
|
except Exception:
|
|
raise InvalidRequestError("Некорректные параметры курсора")
|
|
|
|
async with self.acquire_conn() as conn:
|
|
query = """
|
|
SELECT c.id, c.title, c.created_at, array_agg(cm.user_id::text) as member_ids
|
|
FROM chats c
|
|
JOIN chat_members my_m ON c.id = my_m.chat_id AND my_m.user_id = $1
|
|
JOIN chat_members cm ON c.id = cm.chat_id
|
|
WHERE ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2::timestamptz, $3::uuid))
|
|
GROUP BY c.id, c.title, c.created_at
|
|
ORDER BY c.created_at ASC, c.id ASC
|
|
LIMIT $4
|
|
"""
|
|
rows = await conn.fetch(query, c_caller, c_created, c_id, limit + 1)
|
|
|
|
has_next = len(rows) > limit
|
|
items_rows = rows[:limit]
|
|
|
|
items = [
|
|
ChatResponse(
|
|
id=str(r["id"]),
|
|
title=_to_text(r["title"]),
|
|
member_ids=list(r["member_ids"]),
|
|
created_at=_format_dt(r["created_at"]),
|
|
)
|
|
for r in items_rows
|
|
]
|
|
|
|
next_cursor = None
|
|
if has_next and items:
|
|
last = items[-1]
|
|
next_cursor = encode_cursor(
|
|
{
|
|
"type": "chats",
|
|
"created_at": last.created_at,
|
|
"id": last.id,
|
|
}
|
|
)
|
|
|
|
return items, next_cursor
|
|
|
|
# ------------------ Сообщения ------------------
|
|
|
|
@staticmethod
|
|
def compute_request_hash(text: str, attachment_ids: list[str] | None = None) -> str:
|
|
norm_attachments = [str(x) for x in (attachment_ids or [])]
|
|
canonical = json.dumps(
|
|
{"attachment_ids": norm_attachments, "text": text},
|
|
sort_keys=True,
|
|
ensure_ascii=False,
|
|
)
|
|
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
|
|
|
|
async def send_message(
|
|
self,
|
|
caller_id: str,
|
|
chat_id: str,
|
|
text: str,
|
|
idempotency_key: str,
|
|
attachment_ids: list[str] | None = None,
|
|
) -> MessageResponse:
|
|
try:
|
|
cid = uuid.UUID(chat_id)
|
|
c_caller = uuid.UUID(caller_id)
|
|
except ValueError:
|
|
raise NotFoundError("Чат не найден")
|
|
|
|
norm_attachments = [str(x) for x in (attachment_ids or [])]
|
|
req_hash = self.compute_request_hash(text, norm_attachments)
|
|
|
|
async with self.acquire_conn() as conn:
|
|
is_member = await conn.fetchval(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
|
cid,
|
|
c_caller,
|
|
)
|
|
if not is_member:
|
|
raise NotFoundError("Чат не найден")
|
|
|
|
# Валидация прикрепляемых вложений
|
|
att_uuids: list[uuid.UUID] = []
|
|
if norm_attachments:
|
|
for att_str in norm_attachments:
|
|
try:
|
|
att_uuids.append(uuid.UUID(att_str))
|
|
except ValueError:
|
|
raise NotFoundError("Вложение не найдено")
|
|
|
|
rows = await conn.fetch(
|
|
"SELECT id, chat_id, status FROM attachments WHERE id = ANY($1::uuid[])",
|
|
att_uuids,
|
|
)
|
|
if len(rows) != len(att_uuids):
|
|
raise NotFoundError("Одно или несколько вложений не найдены")
|
|
|
|
for r in rows:
|
|
if r["chat_id"] != cid:
|
|
raise NotFoundError("Вложение принадлежит другому чату")
|
|
if r["status"] != "ready":
|
|
raise ConflictError("Вложение еще не готово или повреждено")
|
|
|
|
# 1. Проверяем, обрабатывался ли уже этот idempotency_key
|
|
existing = await conn.fetchrow(
|
|
"""
|
|
SELECT ik.message_id, ik.request_hash, m.text, m.attachment_ids, m.created_at AS msg_created_at
|
|
FROM idempotency_keys ik
|
|
JOIN messages m ON m.id = ik.message_id
|
|
WHERE ik.user_id = $1 AND ik.chat_id = $2 AND ik.idempotency_key = $3
|
|
""",
|
|
c_caller,
|
|
cid,
|
|
idempotency_key,
|
|
)
|
|
if existing:
|
|
if existing["request_hash"] == req_hash:
|
|
raw_text = existing["text"]
|
|
msg_text = (
|
|
raw_text.decode("utf-8")
|
|
if isinstance(raw_text, (bytes, bytearray))
|
|
else str(raw_text)
|
|
)
|
|
res_attachments = [
|
|
str(a) for a in (existing["attachment_ids"] or [])
|
|
]
|
|
return MessageResponse(
|
|
id=str(existing["message_id"]),
|
|
chat_id=chat_id,
|
|
sender_id=caller_id,
|
|
text=msg_text,
|
|
attachment_ids=res_attachments,
|
|
created_at=_format_dt(existing["msg_created_at"]),
|
|
)
|
|
else:
|
|
raise ConflictError("Ключ идемпотентности уже использован с другим телом запроса")
|
|
|
|
msg_id = uuid.uuid4()
|
|
now = dt.datetime.now(dt.timezone.utc)
|
|
text_bytes = text.encode("utf-8")
|
|
|
|
try:
|
|
async with conn.transaction():
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO messages (id, chat_id, sender_id, text, attachment_ids, created_at)
|
|
VALUES ($1, $2, $3, $4, $5, $6)
|
|
""",
|
|
msg_id,
|
|
cid,
|
|
c_caller,
|
|
text_bytes,
|
|
att_uuids,
|
|
now,
|
|
)
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO idempotency_keys (user_id, chat_id, idempotency_key, message_id, request_hash, created_at)
|
|
VALUES ($1, $2, $3, $4, $5, $6)
|
|
""",
|
|
c_caller,
|
|
cid,
|
|
idempotency_key,
|
|
msg_id,
|
|
req_hash,
|
|
now,
|
|
)
|
|
except asyncpg.UniqueViolationError:
|
|
winner = await conn.fetchrow(
|
|
"""
|
|
SELECT ik.message_id, ik.request_hash, m.text, m.attachment_ids, m.created_at AS msg_created_at
|
|
FROM idempotency_keys ik
|
|
JOIN messages m ON m.id = ik.message_id
|
|
WHERE ik.user_id = $1 AND ik.chat_id = $2 AND ik.idempotency_key = $3
|
|
""",
|
|
c_caller,
|
|
cid,
|
|
idempotency_key,
|
|
)
|
|
if winner:
|
|
if winner["request_hash"] == req_hash:
|
|
raw_text = winner["text"]
|
|
msg_text = (
|
|
raw_text.decode("utf-8")
|
|
if isinstance(raw_text, (bytes, bytearray))
|
|
else str(raw_text)
|
|
)
|
|
res_attachments = [
|
|
str(a) for a in (winner["attachment_ids"] or [])
|
|
]
|
|
return MessageResponse(
|
|
id=str(winner["message_id"]),
|
|
chat_id=chat_id,
|
|
sender_id=caller_id,
|
|
text=msg_text,
|
|
attachment_ids=res_attachments,
|
|
created_at=_format_dt(winner["msg_created_at"]),
|
|
)
|
|
else:
|
|
raise ConflictError("Ключ идемпотентности уже использован с другим телом запроса")
|
|
raise
|
|
|
|
return MessageResponse(
|
|
id=str(msg_id),
|
|
chat_id=chat_id,
|
|
sender_id=caller_id,
|
|
text=text,
|
|
attachment_ids=norm_attachments,
|
|
created_at=_format_dt(now),
|
|
)
|
|
|
|
async def list_messages(
|
|
self, caller_id: str, chat_id: str, limit: int = 50, cursor: str | None = None
|
|
) -> tuple[list[MessageResponse], str | None]:
|
|
try:
|
|
cid = uuid.UUID(chat_id)
|
|
c_caller = uuid.UUID(caller_id)
|
|
except ValueError:
|
|
raise NotFoundError("Чат не найден")
|
|
|
|
async with self.acquire_conn() as conn:
|
|
is_member = await conn.fetchval(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
|
cid,
|
|
c_caller,
|
|
)
|
|
if not is_member:
|
|
raise NotFoundError("Чат не найден")
|
|
|
|
c_created: dt.datetime | None = None
|
|
c_id: uuid.UUID | None = None
|
|
|
|
if cursor is not None:
|
|
c_data = decode_cursor(cursor)
|
|
if c_data.get("type") != "messages" or c_data.get("chat_id") != chat_id:
|
|
raise InvalidRequestError(
|
|
"Курсор принадлежит другому чату или недействителен"
|
|
)
|
|
c_created_str = c_data.get("created_at")
|
|
c_id_str = c_data.get("id")
|
|
if (
|
|
not isinstance(c_created_str, str)
|
|
or not isinstance(c_id_str, str)
|
|
or not c_created_str.strip()
|
|
or not c_id_str.strip()
|
|
):
|
|
raise InvalidRequestError("Поврежденный курсор")
|
|
try:
|
|
c_created = dt.datetime.fromisoformat(
|
|
c_created_str.replace("Z", "+00:00")
|
|
)
|
|
c_id = uuid.UUID(c_id_str)
|
|
except Exception:
|
|
raise InvalidRequestError("Некорректные параметры курсора")
|
|
|
|
query = """
|
|
SELECT id, chat_id, sender_id, text, attachment_ids, created_at
|
|
FROM messages
|
|
WHERE chat_id = $1
|
|
AND ($2::timestamptz IS NULL OR (created_at, id) > ($2::timestamptz, $3::uuid))
|
|
ORDER BY created_at ASC, id ASC
|
|
LIMIT $4
|
|
"""
|
|
rows = await conn.fetch(query, cid, c_created, c_id, limit + 1)
|
|
|
|
has_next = len(rows) > limit
|
|
items_rows = rows[:limit]
|
|
|
|
def _to_text(val: Any) -> str:
|
|
if isinstance(val, (bytes, bytearray, memoryview)):
|
|
return bytes(val).decode("utf-8")
|
|
return str(val)
|
|
|
|
items = [
|
|
MessageResponse(
|
|
id=str(r["id"]),
|
|
chat_id=str(r["chat_id"]),
|
|
sender_id=str(r["sender_id"]),
|
|
text=_to_text(r["text"]),
|
|
attachment_ids=[str(a) for a in (r["attachment_ids"] or [])],
|
|
created_at=_format_dt(r["created_at"]),
|
|
)
|
|
for r in items_rows
|
|
]
|
|
|
|
next_cursor = None
|
|
if has_next and items:
|
|
last = items[-1]
|
|
next_cursor = encode_cursor(
|
|
{
|
|
"type": "messages",
|
|
"chat_id": chat_id,
|
|
"created_at": last.created_at,
|
|
"id": last.id,
|
|
}
|
|
)
|
|
|
|
return items, next_cursor
|
|
|
|
# ------------------ Вложения (Attachments) ------------------
|
|
|
|
async def upload_attachment(
|
|
self,
|
|
caller_id: str,
|
|
chat_id: str,
|
|
filename: str,
|
|
content_type: str,
|
|
data: bytes,
|
|
) -> AttachmentResponse:
|
|
try:
|
|
cid = uuid.UUID(chat_id)
|
|
c_caller = uuid.UUID(caller_id)
|
|
except ValueError:
|
|
raise NotFoundError("Чат не найден")
|
|
|
|
# 1. Валидация filename
|
|
if not filename or len(filename) > 255:
|
|
raise InvalidRequestError("Некорректная длина имени файла (1-255 символов)")
|
|
if any(c in filename for c in ("/", "\\", "\0")) or any(
|
|
ord(c) < 32 for c in filename
|
|
):
|
|
raise InvalidRequestError("Имя файла содержит недопустимые символы")
|
|
|
|
# 2. Проверка прав (ACL)
|
|
async with self.acquire_conn() as conn:
|
|
is_member = await conn.fetchval(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
|
cid,
|
|
c_caller,
|
|
)
|
|
if not is_member:
|
|
raise NotFoundError("Чат не найден")
|
|
|
|
# 3. Валидация Content-Type
|
|
ct_clean = content_type.split(";")[0].strip().lower()
|
|
if ct_clean not in ("image/png", "image/jpeg"):
|
|
raise UnsupportedMediaTypeError(
|
|
"Поддерживаются только форматы image/png и image/jpeg"
|
|
)
|
|
|
|
# 4. Валидация размера данных
|
|
size_bytes = len(data)
|
|
if size_bytes > MAX_UPLOAD_BYTES:
|
|
raise PayloadTooLargeError(
|
|
f"Размер файла {size_bytes} байт превышает допустимый лимит {MAX_UPLOAD_BYTES} байт"
|
|
)
|
|
|
|
# 5. Проверка магических байтов (сигнатуры MIME)
|
|
if ct_clean == "image/png":
|
|
if not data.startswith(b"\x89PNG\r\n\x1a\n"):
|
|
raise UnsupportedMediaTypeError("Содержимое файла не соответствует формату PNG")
|
|
elif ct_clean == "image/jpeg":
|
|
if not (data.startswith(b"\xff\xd8\xff")):
|
|
raise UnsupportedMediaTypeError("Содержимое файла не соответствует формату JPEG")
|
|
|
|
# 6. Проверка разрешения (лимит 40 млн пикселей) и целостности растра
|
|
def _check_dimensions():
|
|
try:
|
|
with Image.open(io.BytesIO(data)) as img:
|
|
w, h = img.size
|
|
if w * h > MAX_IMAGE_PIXELS:
|
|
return False
|
|
# Проверяем целостность растровых данных и фильтров строк:
|
|
img.load()
|
|
return True
|
|
except Exception:
|
|
raise UnsupportedMediaTypeError("Поврежденное изображение")
|
|
|
|
try:
|
|
within_limits = await asyncio.to_thread(_check_dimensions)
|
|
if not within_limits:
|
|
raise PayloadTooLargeError(
|
|
f"Разрешение изображения превышает лимит {MAX_IMAGE_PIXELS} пикселей"
|
|
)
|
|
except (UnsupportedMediaTypeError, PayloadTooLargeError):
|
|
raise
|
|
except Exception as e:
|
|
logger.warning("upload_attachment check_dimensions unexpected: %s (%s)", type(e), e)
|
|
raise UnsupportedMediaTypeError("Поврежденное изображение") from e
|
|
|
|
# 7. Генерация идентификаторов
|
|
att_id = uuid.uuid4()
|
|
s3_key = f"chats/{chat_id}/{att_id}/{filename}"
|
|
sha256_hash = hashlib.sha256(data).hexdigest()
|
|
now = dt.datetime.now(dt.timezone.utc)
|
|
|
|
# 8. Загрузка файла в S3
|
|
def _put_to_s3():
|
|
self.s3_client.put_object(
|
|
Bucket=S3_BUCKET,
|
|
Key=s3_key,
|
|
Body=data,
|
|
ContentType=ct_clean,
|
|
)
|
|
|
|
await asyncio.to_thread(_put_to_s3)
|
|
|
|
# 9. Сохранение метаданных в PostgreSQL (с компенсацией удаления из S3 при ошибке)
|
|
try:
|
|
async with self.acquire_conn() as conn:
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO attachments (
|
|
id, chat_id, owner_id, filename, content_type,
|
|
size_bytes, sha256, s3_key, status, error_code,
|
|
created_at, updated_at
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'ready', NULL, $9, $9)
|
|
""",
|
|
att_id,
|
|
cid,
|
|
c_caller,
|
|
filename,
|
|
ct_clean,
|
|
size_bytes,
|
|
sha256_hash,
|
|
s3_key,
|
|
now,
|
|
)
|
|
except Exception as db_err:
|
|
logger.error("Ошибка записи метаданных в БД, компенсация S3: %s", db_err)
|
|
try:
|
|
await asyncio.to_thread(
|
|
self.s3_client.delete_object, Bucket=S3_BUCKET, Key=s3_key
|
|
)
|
|
except Exception as del_err:
|
|
logger.error("Ошибка удаления S3 объекта при компенсации: %s", del_err)
|
|
raise
|
|
|
|
return AttachmentResponse(
|
|
id=str(att_id),
|
|
chat_id=str(cid),
|
|
owner_id=str(c_caller),
|
|
filename=filename,
|
|
content_type=ct_clean,
|
|
size_bytes=size_bytes,
|
|
sha256=sha256_hash,
|
|
status="ready",
|
|
variants=[],
|
|
error_code=None,
|
|
created_at=_format_dt(now),
|
|
updated_at=_format_dt(now),
|
|
)
|
|
|
|
async def get_attachment(
|
|
self, caller_id: str, attachment_id: str
|
|
) -> AttachmentResponse:
|
|
try:
|
|
aid = uuid.UUID(attachment_id)
|
|
c_caller = uuid.UUID(caller_id)
|
|
except ValueError:
|
|
raise NotFoundError("Вложение не найдено")
|
|
|
|
async with self.acquire_conn() as conn:
|
|
row = await conn.fetchrow(
|
|
"""
|
|
SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type,
|
|
a.size_bytes, a.sha256, a.status, a.error_code, a.created_at, a.updated_at
|
|
FROM attachments a
|
|
WHERE a.id = $1
|
|
""",
|
|
aid,
|
|
)
|
|
if not row:
|
|
raise NotFoundError("Вложение не найдено")
|
|
|
|
is_member = await conn.fetchval(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
|
row["chat_id"],
|
|
c_caller,
|
|
)
|
|
if not is_member:
|
|
raise NotFoundError("Вложение не найдено")
|
|
|
|
return AttachmentResponse(
|
|
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=row["error_code"],
|
|
created_at=_format_dt(row["created_at"]),
|
|
updated_at=_format_dt(row["updated_at"]),
|
|
)
|
|
|
|
async def get_attachment_content(
|
|
self, caller_id: str, attachment_id: str, variant: str | None = None
|
|
) -> tuple[bytes, str]:
|
|
try:
|
|
aid = uuid.UUID(attachment_id)
|
|
c_caller = uuid.UUID(caller_id)
|
|
except ValueError:
|
|
raise NotFoundError("Вложение не найдено")
|
|
|
|
if variant not in (None, "", "original"):
|
|
raise NotFoundError("Вариант не найден")
|
|
|
|
async with self.acquire_conn() as conn:
|
|
row = await conn.fetchrow(
|
|
"""
|
|
SELECT a.chat_id, a.content_type, a.s3_key, a.status
|
|
FROM attachments a
|
|
WHERE a.id = $1
|
|
""",
|
|
aid,
|
|
)
|
|
if not row:
|
|
raise NotFoundError("Вложение не найдено")
|
|
|
|
is_member = await conn.fetchval(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
|
row["chat_id"],
|
|
c_caller,
|
|
)
|
|
if not is_member:
|
|
raise NotFoundError("Вложение не найдено")
|
|
|
|
if row["status"] != "ready":
|
|
raise ConflictError("Вложение повреждено или еще не готово")
|
|
|
|
s3_key = row["s3_key"]
|
|
content_type = row["content_type"]
|
|
|
|
def _get_from_s3():
|
|
resp = self.s3_client.get_object(Bucket=S3_BUCKET, Key=s3_key)
|
|
return resp["Body"].read()
|
|
|
|
try:
|
|
data = await asyncio.to_thread(_get_from_s3)
|
|
except Exception as e:
|
|
logger.error("Ошибка чтения объекта из S3 %s: %s", s3_key, e)
|
|
raise NotFoundError("Файл не найден в хранилище") from e
|
|
|
|
return data, content_type
|
|
|
|
|
|
# Глобальный экземпляр хранилища
|
|
storage = PostgresStorage()
|