forked from mtusi2026/mtusi2026lab3
213 lines
7.2 KiB
Python
213 lines
7.2 KiB
Python
"""Бизнес-логика lab3 (DIP: зависит от Database/SessionStore)."""
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
import uuid
|
|
from typing import List, Optional
|
|
|
|
from app import cursor as cursor_util
|
|
from app.auth import BASIC_CHALLENGE, parse_basic
|
|
from app.db import Database
|
|
from app.errors import conflict, invalid_request, not_found, unauthorized
|
|
from app.models import Chat, Message, User
|
|
from app.password import hash_password, verify_password
|
|
from app.sessions import SessionStore
|
|
from app.timefmt import now_utc
|
|
from app.validation import (
|
|
parse_limit,
|
|
parse_uuid,
|
|
reject_unknown,
|
|
require_display_name,
|
|
require_idempotency_key,
|
|
require_keys,
|
|
require_message_text,
|
|
require_object,
|
|
require_password,
|
|
require_title,
|
|
require_username,
|
|
)
|
|
|
|
|
|
class UserService:
|
|
def __init__(self, db: Database) -> None:
|
|
self.db = db
|
|
|
|
def create(self, body: object) -> dict:
|
|
data = require_object(body)
|
|
reject_unknown(data, {"username", "display_name", "password"})
|
|
require_keys(data, ("username", "display_name", "password"))
|
|
username = require_username(data["username"])
|
|
display_name = require_display_name(data["display_name"])
|
|
password = require_password(data["password"])
|
|
user = User(
|
|
id=str(uuid.uuid4()),
|
|
username=username,
|
|
display_name=display_name,
|
|
created_at=now_utc(),
|
|
password_hash=hash_password(password),
|
|
)
|
|
try:
|
|
self.db.add_user(user)
|
|
except KeyError as exc:
|
|
raise conflict("username уже занят") from exc
|
|
return user.to_dict()
|
|
|
|
|
|
class AuthService:
|
|
def __init__(self, db: Database, sessions: SessionStore) -> None:
|
|
self.db = db
|
|
self.sessions = sessions
|
|
|
|
def create_session(self, authorization: Optional[str]) -> dict:
|
|
username, password = parse_basic(authorization)
|
|
user = self.db.get_user_by_username(username)
|
|
if user is None or not verify_password(user.password_hash, password):
|
|
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE)
|
|
token, expires_at = self.sessions.create(user.id)
|
|
return {
|
|
"token": token,
|
|
"token_type": "Bearer",
|
|
"expires_at": expires_at,
|
|
"user": user.to_dict(),
|
|
}
|
|
|
|
def logout(self, token: str) -> None:
|
|
self.sessions.revoke(token)
|
|
|
|
|
|
class ChatService:
|
|
def __init__(self, db: Database) -> None:
|
|
self.db = db
|
|
|
|
def create(self, actor: User, body: object) -> dict:
|
|
data = require_object(body)
|
|
reject_unknown(data, {"title", "member_ids"})
|
|
require_keys(data, ("title", "member_ids"))
|
|
title = require_title(data["title"])
|
|
raw_members = data["member_ids"]
|
|
if not isinstance(raw_members, list):
|
|
raise invalid_request("member_ids должен быть массивом")
|
|
if len(raw_members) < 1 or len(raw_members) > 100:
|
|
raise invalid_request("member_ids: от 1 до 100 участников")
|
|
member_ids: List[str] = []
|
|
seen = set()
|
|
for item in raw_members:
|
|
mid = parse_uuid(item, "member_ids")
|
|
if mid in seen:
|
|
raise invalid_request("member_ids содержит дубликаты")
|
|
seen.add(mid)
|
|
member_ids.append(mid)
|
|
if actor.id not in seen:
|
|
raise invalid_request("Вызывающий должен быть в member_ids")
|
|
if not self.db.users_exist(member_ids):
|
|
raise invalid_request("Неизвестный участник")
|
|
chat = Chat(
|
|
id=str(uuid.uuid4()),
|
|
title=title,
|
|
member_ids=member_ids,
|
|
created_at=now_utc(),
|
|
)
|
|
try:
|
|
self.db.add_chat(chat)
|
|
except ValueError as exc:
|
|
raise invalid_request("Неизвестный участник") from exc
|
|
return chat.to_dict()
|
|
|
|
def get_for_member(self, actor: User, chat_id: str) -> Chat:
|
|
cid = parse_uuid(chat_id, "chat_id")
|
|
chat = self.db.get_chat(cid)
|
|
if chat is None or actor.id not in chat.member_ids:
|
|
raise not_found()
|
|
return chat
|
|
|
|
def list_for_user(self, actor: User, limit_raw: Optional[str], cursor_raw: Optional[str]) -> dict:
|
|
limit = parse_limit(limit_raw)
|
|
chats = self.db.list_chats_for(actor.id)
|
|
start = 0
|
|
if cursor_raw:
|
|
created_at, item_id = cursor_util.decode(cursor_raw, actor.id)
|
|
start = 0
|
|
for i, chat in enumerate(chats):
|
|
if (chat.created_at, chat.id) > (created_at, item_id):
|
|
start = i
|
|
break
|
|
else:
|
|
start = len(chats)
|
|
page = chats[start : start + limit]
|
|
next_cursor = None
|
|
if start + limit < len(chats) and page:
|
|
last = page[-1]
|
|
next_cursor = cursor_util.encode(actor.id, last.created_at, last.id)
|
|
return {"items": [c.to_dict() for c in page], "next_cursor": next_cursor}
|
|
|
|
|
|
def _message_request_hash(text: str) -> str:
|
|
# Canonical body: text only (attachment_ids absent == [] for lab3).
|
|
canonical = json.dumps({"text": text}, ensure_ascii=False, separators=(",", ":"), sort_keys=True)
|
|
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
|
|
|
|
|
|
class MessageService:
|
|
def __init__(self, db: Database) -> None:
|
|
self.db = db
|
|
|
|
def create(
|
|
self,
|
|
actor: User,
|
|
chat: Chat,
|
|
body: object,
|
|
*,
|
|
idempotency_key: Optional[str],
|
|
method: str,
|
|
path: str,
|
|
) -> dict:
|
|
data = require_object(body)
|
|
reject_unknown(data, {"text"})
|
|
require_keys(data, ("text",))
|
|
text = require_message_text(data["text"])
|
|
key = require_idempotency_key(idempotency_key)
|
|
message = Message(
|
|
id=str(uuid.uuid4()),
|
|
chat_id=chat.id,
|
|
sender_id=actor.id,
|
|
text=text,
|
|
created_at=now_utc(),
|
|
)
|
|
payload, _created = self.db.create_message_idempotent(
|
|
message,
|
|
user_id=actor.id,
|
|
method=method,
|
|
path=path,
|
|
idem_key=key,
|
|
request_hash=_message_request_hash(text),
|
|
)
|
|
return payload
|
|
|
|
def list_for_chat(
|
|
self,
|
|
chat: Chat,
|
|
limit_raw: Optional[str],
|
|
cursor_raw: Optional[str],
|
|
) -> dict:
|
|
limit = parse_limit(limit_raw)
|
|
after_created_at = None
|
|
after_id = None
|
|
if cursor_raw:
|
|
created_at, item_id = cursor_util.decode(cursor_raw, chat.id)
|
|
parse_uuid(item_id, "cursor.id")
|
|
after_created_at = created_at
|
|
after_id = item_id
|
|
rows = self.db.list_messages_page(
|
|
chat.id,
|
|
limit + 1,
|
|
after_created_at=after_created_at,
|
|
after_id=after_id,
|
|
)
|
|
page = rows[:limit]
|
|
next_cursor = None
|
|
if len(rows) > limit and page:
|
|
last = page[-1]
|
|
next_cursor = cursor_util.encode(chat.id, last.created_at, last.id)
|
|
return {"items": [m.to_dict() for m in page], "next_cursor": next_cursor}
|