forked from mtusi2026/mtusi2026lab2
264 lines
9.2 KiB
Python
264 lines
9.2 KiB
Python
from datetime import datetime, timezone
|
|
from typing import Optional, Dict, List
|
|
from uuid import uuid4
|
|
import asyncio
|
|
from pydantic import BaseModel, Field, field_validator
|
|
import re
|
|
|
|
|
|
class CreateUserRequest(BaseModel):
|
|
username: str = Field(..., min_length=3, max_length=32)
|
|
display_name: str = Field(..., min_length=1, max_length=100)
|
|
|
|
@field_validator('username')
|
|
@classmethod
|
|
def validate_username(cls, v):
|
|
if not re.match(r'^[a-z0-9_]{3,32}$', v):
|
|
raise ValueError('username должен содержать только a-z, 0-9, _ (3-32 символа)')
|
|
return v
|
|
|
|
@field_validator('display_name')
|
|
@classmethod
|
|
def validate_display_name(cls, v):
|
|
if not v.strip():
|
|
raise ValueError('display_name не может состоять только из пробелов')
|
|
return v
|
|
|
|
class CreateChatRequest(BaseModel):
|
|
title: str = Field(..., min_length=1, max_length=100)
|
|
member_ids: List[str] = Field(..., min_length=1, max_length=100)
|
|
|
|
@field_validator('title')
|
|
@classmethod
|
|
def validate_title(cls, v):
|
|
if not v.strip():
|
|
raise ValueError('title не может состоять только из пробелов')
|
|
return v
|
|
|
|
class CreateMessageRequest(BaseModel):
|
|
text: str = Field(..., min_length=1, max_length=4000)
|
|
|
|
@field_validator('text')
|
|
@classmethod
|
|
def validate_text(cls, v):
|
|
if not v.strip():
|
|
raise ValueError('text не может состоять только из пробелов')
|
|
return v
|
|
|
|
|
|
class UserResponse(BaseModel):
|
|
id: str
|
|
username: str
|
|
display_name: str
|
|
created_at: str
|
|
|
|
class ChatResponse(BaseModel):
|
|
id: str
|
|
title: str
|
|
member_ids: List[str]
|
|
created_at: str
|
|
|
|
class MessageResponse(BaseModel):
|
|
id: str
|
|
chat_id: str
|
|
sender_id: str
|
|
text: str
|
|
created_at: str
|
|
|
|
class ChatPage(BaseModel):
|
|
items: List[ChatResponse]
|
|
next_cursor: Optional[str] = None
|
|
|
|
class MessagePage(BaseModel):
|
|
items: List[MessageResponse]
|
|
next_cursor: Optional[str] = None
|
|
|
|
class HealthResponse(BaseModel):
|
|
status: str = "ok"
|
|
|
|
class ErrorResponse(BaseModel):
|
|
error: dict
|
|
|
|
|
|
class InMemoryStore:
|
|
def __init__(self):
|
|
self._lock = asyncio.Lock()
|
|
self.users: Dict[str, dict] = {} # id -> user
|
|
self.chats: Dict[str, dict] = {} # id -> chat
|
|
self.messages: Dict[str, List[dict]] = {} # chat_id -> [messages]
|
|
self.usernames: Dict[str, str] = {} # username -> user_id (для проверки уникальности)
|
|
|
|
|
|
async def create_user(self, username: str, display_name: str) -> dict:
|
|
async with self._lock:
|
|
if username in self.usernames:
|
|
raise ValueError("username_already_exists")
|
|
|
|
user_id = str(uuid4())
|
|
now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
|
|
|
|
user = {
|
|
"id": user_id,
|
|
"username": username,
|
|
"display_name": display_name,
|
|
"created_at": now
|
|
}
|
|
|
|
self.users[user_id] = user
|
|
self.usernames[username] = user_id
|
|
|
|
return user
|
|
|
|
async def get_user(self, user_id: str) -> Optional[dict]:
|
|
async with self._lock:
|
|
return self.users.get(user_id)
|
|
|
|
async def get_user_by_username(self, username: str) -> Optional[dict]:
|
|
async with self._lock:
|
|
user_id = self.usernames.get(username)
|
|
if user_id:
|
|
return self.users.get(user_id)
|
|
return None
|
|
|
|
|
|
async def create_chat(self, title: str, member_ids: List[str], creator_id: str) -> dict:
|
|
async with self._lock:
|
|
# Проверяем, что все участники существуют
|
|
for member_id in member_ids:
|
|
if member_id not in self.users:
|
|
raise ValueError("user_not_found")
|
|
|
|
# Проверяем, что создатель входит в список участников
|
|
if creator_id not in member_ids:
|
|
raise ValueError("creator_not_in_members")
|
|
|
|
# Проверяем уникальность member_ids
|
|
if len(member_ids) != len(set(member_ids)):
|
|
raise ValueError("duplicate_members")
|
|
|
|
chat_id = str(uuid4())
|
|
now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
|
|
|
|
chat = {
|
|
"id": chat_id,
|
|
"title": title,
|
|
"member_ids": member_ids,
|
|
"created_at": now
|
|
}
|
|
|
|
self.chats[chat_id] = chat
|
|
self.messages[chat_id] = []
|
|
|
|
return chat
|
|
|
|
async def get_chat(self, chat_id: str, user_id: str) -> Optional[dict]:
|
|
async with self._lock:
|
|
chat = self.chats.get(chat_id)
|
|
if not chat:
|
|
return None
|
|
|
|
# Проверяем, что пользователь является участником
|
|
if user_id not in chat["member_ids"]:
|
|
return None
|
|
|
|
return chat
|
|
|
|
async def list_chats(self, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> tuple:
|
|
async with self._lock:
|
|
# Получаем все чаты пользователя
|
|
user_chats = [
|
|
chat for chat in self.chats.values()
|
|
if user_id in chat["member_ids"]
|
|
]
|
|
|
|
# Сортируем по (created_at, id)
|
|
user_chats.sort(key=lambda c: (c["created_at"], c["id"]))
|
|
|
|
# Применяем cursor
|
|
if cursor:
|
|
# cursor — это "created_at,id" последнего элемента предыдущей страницы
|
|
cursor_parts = cursor.split(",", 1)
|
|
if len(cursor_parts) == 2:
|
|
cursor_time, cursor_id = cursor_parts
|
|
user_chats = [
|
|
c for c in user_chats
|
|
if (c["created_at"], c["id"]) > (cursor_time, cursor_id)
|
|
]
|
|
|
|
# Ограничиваем количество
|
|
has_more = len(user_chats) > limit
|
|
page = user_chats[:limit]
|
|
|
|
# Формируем next_cursor
|
|
next_cursor = None
|
|
if has_more and page:
|
|
last_item = page[-1]
|
|
next_cursor = f"{last_item['created_at']},{last_item['id']}"
|
|
|
|
return page, next_cursor
|
|
|
|
|
|
async def create_message(self, chat_id: str, sender_id: str, text: str) -> dict:
|
|
async with self._lock:
|
|
# Проверяем, что чат существует
|
|
if chat_id not in self.chats:
|
|
raise ValueError("chat_not_found")
|
|
|
|
# Проверяем, что отправитель является участником чата
|
|
chat = self.chats[chat_id]
|
|
if sender_id not in chat["member_ids"]:
|
|
raise ValueError("sender_not_in_chat")
|
|
|
|
message_id = str(uuid4())
|
|
now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
|
|
|
|
message = {
|
|
"id": message_id,
|
|
"chat_id": chat_id,
|
|
"sender_id": sender_id,
|
|
"text": text,
|
|
"created_at": now
|
|
}
|
|
|
|
self.messages[chat_id].append(message)
|
|
|
|
return message
|
|
|
|
async def list_messages(self, chat_id: str, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> tuple:
|
|
async with self._lock:
|
|
# Проверяем, что чат существует и пользователь является участником
|
|
chat = self.chats.get(chat_id)
|
|
if not chat:
|
|
raise ValueError("chat_not_found")
|
|
|
|
if user_id not in chat["member_ids"]:
|
|
raise ValueError("user_not_in_chat")
|
|
|
|
messages = self.messages.get(chat_id, [])
|
|
|
|
# Сортируем по (created_at, id)
|
|
messages.sort(key=lambda m: (m["created_at"], m["id"]))
|
|
|
|
# Применяем cursor
|
|
if cursor:
|
|
cursor_parts = cursor.split(",", 1)
|
|
if len(cursor_parts) == 2:
|
|
cursor_time, cursor_id = cursor_parts
|
|
messages = [
|
|
m for m in messages
|
|
if (m["created_at"], m["id"]) > (cursor_time, cursor_id)
|
|
]
|
|
|
|
# Ограничиваем количество
|
|
has_more = len(messages) > limit
|
|
page = messages[:limit]
|
|
|
|
# Формируем next_cursor
|
|
next_cursor = None
|
|
if has_more and page:
|
|
last_item = page[-1]
|
|
next_cursor = f"{last_item['created_at']},{last_item['id']}"
|
|
|
|
return page, next_cursor
|
|
|
|
store = InMemoryStore() |