Files
mtusi2026lab3/app/services.py

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}