Files
mtusi2026lab2/src/models.py
T

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()