Files
mtusi2026lab2-fork/app/api.py

170 lines
5.1 KiB
Python

"""HTTP-слой: тонкие обработчики (SRP: только транспорт)."""
import logging
from typing import Optional
from fastapi import APIRouter, Depends, Header, Query, Request, Response
from app.auth import require_actor
from app.db import Database
from app.errors import unavailable, unsupported_media
from app.schemas import CreateChatBody, CreateMessageBody, CreateUserBody
from app.services import AuthService, ChatService, MessageService, UserService
from app.sessions import SessionStore
logger = logging.getLogger("messenger")
router = APIRouter()
def _state(request: Request):
db: Database = request.app.state.db
sessions: SessionStore = request.app.state.sessions
return db, sessions
def require_json_content_type(request: Request) -> None:
content_type = request.headers.get("content-type", "")
media = content_type.split(";")[0].strip().lower()
if media != "application/json":
raise unsupported_media()
def _require_accepting(db: Database) -> None:
if not db.accepting:
raise unavailable("Сервер завершает работу")
@router.get("/health/live")
def live():
return {"status": "ok"}
@router.get("/health/ready")
def ready(request: Request):
db, sessions = _state(request)
if not db.ready or not db.accepting:
raise unavailable("Не готов принимать трафик")
if not db.ping() or not sessions.ping():
raise unavailable("Зависимость недоступна")
return {"status": "ok"}
@router.post("/api/v1/users", status_code=201)
def create_user(
request: Request,
body: CreateUserBody,
_: None = Depends(require_json_content_type),
):
db, _sessions = _state(request)
_require_accepting(db)
return UserService(db).create(body.model_dump())
@router.post("/api/v1/auth/sessions", status_code=201)
def create_session(
request: Request,
authorization: Optional[str] = Header(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
return AuthService(db, sessions).create_session(authorization)
@router.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(
request: Request,
authorization: Optional[str] = Header(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
_actor, token = require_actor(db, sessions, authorization)
AuthService(db, sessions).logout(token)
return Response(status_code=204)
@router.get("/api/v1/users/me")
def current_user(
request: Request,
authorization: Optional[str] = Header(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
return actor.to_dict()
@router.post("/api/v1/chats", status_code=201)
def create_chat(
request: Request,
body: CreateChatBody,
authorization: Optional[str] = Header(default=None),
_: None = Depends(require_json_content_type),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
return ChatService(db).create(actor, body.model_dump())
@router.get("/api/v1/chats")
def list_chats(
request: Request,
authorization: Optional[str] = Header(default=None),
limit: Optional[str] = Query(default=None),
cursor: Optional[str] = Query(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
return ChatService(db).list_for_user(actor, limit, cursor)
@router.get("/api/v1/chats/{chat_id}")
def get_chat(
chat_id: str,
request: Request,
authorization: Optional[str] = Header(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
return ChatService(db).get_for_member(actor, chat_id).to_dict()
@router.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(
chat_id: str,
request: Request,
body: CreateMessageBody,
authorization: Optional[str] = Header(default=None),
_: None = Depends(require_json_content_type),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
chats = ChatService(db)
chat = chats.get_for_member(actor, chat_id)
result = MessageService(db).create(actor, chat, body.model_dump())
logger.info(
"message created chat_id=%s sender_id=%s message_id=%s",
chat.id,
actor.id,
result["id"],
)
return result
@router.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: str,
request: Request,
authorization: Optional[str] = Header(default=None),
limit: Optional[str] = Query(default=None),
cursor: Optional[str] = Query(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
chat = ChatService(db).get_for_member(actor, chat_id)
return MessageService(db).list_for_chat(chat, limit, cursor)