Files
mtusi2026lab3/app/handlers.py
T
2026-11-06 13:32:02 +03:00

243 lines
8.7 KiB
Python

"""HTTP-обработчики FastAPI для lab2: Basic/Bearer, PostgreSQL, Redis-кэш сессий."""
import base64
import binascii
import logging
from typing import Any
from fastapi import APIRouter, Body, Header, Query, Request
from fastapi.responses import JSONResponse, Response
from .errors import ApiError
from .security import hash_password, verify_password
from .sessions import SessionStore
from .store import Store
from .validation import (
encode_cursor,
parse_cursor,
parse_limit,
validate_chat_id,
validate_create_chat,
validate_create_message,
validate_create_user,
)
router = APIRouter()
logger = logging.getLogger("messenger.handlers")
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
def get_store(request: Request) -> Store:
return request.app.state.store
def get_sessions(request: Request) -> SessionStore:
return request.app.state.sessions
def _unauthorized(message: str, challenge: str) -> ApiError:
err = ApiError(401, "unauthorized", message)
err.challenge = challenge # type: ignore[attr-defined]
return err
def current_user_id(request: Request, authorization: str | None) -> str:
"""lab2: только Bearer. X-User-Id игнорируется."""
if not authorization or not authorization.lower().startswith("bearer "):
raise _unauthorized("Требуется Bearer-токен", BEARER_CHALLENGE)
token = authorization[7:].strip()
if not token:
raise _unauthorized("Пустой Bearer-токен", BEARER_CHALLENGE)
user_id = get_sessions(request).resolve(token)
if user_id is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
return user_id
def _parse_basic(authorization: str | None) -> tuple[str, str]:
if not authorization or not authorization.lower().startswith("basic "):
raise _unauthorized("Требуется Basic-аутентификация", BASIC_CHALLENGE)
try:
decoded = base64.b64decode(authorization[6:].strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
raise _unauthorized("Некорректный Basic", BASIC_CHALLENGE)
if ":" not in decoded:
raise _unauthorized("Некорректный Basic", BASIC_CHALLENGE)
username, password = decoded.split(":", 1)
return username, password
@router.get("/health/live")
def health_live() -> dict[str, str]:
return {"status": "ok"}
@router.get("/health/ready")
def health_ready(request: Request) -> JSONResponse:
"""Ready, если доступна БД (обязательный синхронный путь). Redis — кэш."""
try:
with get_store(request).pool.connection() as conn:
with conn.cursor() as cur:
cur.execute("SELECT 1")
cur.fetchone()
except Exception as exc: # noqa: BLE001
logger.warning("readiness failed: %s", type(exc).__name__)
raise ApiError(503, "unavailable", "Зависимость недоступна")
return JSONResponse({"status": "ok"})
@router.post("/api/v1/users", status_code=201)
def register_user(request: Request, body: Any = Body(...)) -> JSONResponse:
username, display_name, password = validate_create_user(body)
store = get_store(request)
user = store.create_user(username, display_name, hash_password(password))
if user is None:
raise ApiError(409, "conflict", "username уже занят")
return JSONResponse(user, status_code=201)
@router.post("/api/v1/auth/sessions", status_code=201)
def create_session(
request: Request,
authorization: str | None = Header(default=None),
) -> JSONResponse:
username, password = _parse_basic(authorization)
store = get_store(request)
found = store.get_user_by_username(username)
if found is None:
# Одинаковый 401 для неверного username и пароля.
raise _unauthorized("Неверные учётные данные", BASIC_CHALLENGE)
user, password_hash = found
if not verify_password(password_hash, password):
raise _unauthorized("Неверные учётные данные", BASIC_CHALLENGE)
session = get_sessions(request).create(user["id"])
return JSONResponse(
{
"token": session["token"],
"token_type": "Bearer",
"expires_at": session["expires_at"],
"user": user,
},
status_code=201,
)
@router.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(
request: Request,
authorization: str | None = Header(default=None),
) -> JSONResponse:
if not authorization or not authorization.lower().startswith("bearer "):
raise _unauthorized("Требуется Bearer-токен", BEARER_CHALLENGE)
token = authorization[7:].strip()
if not token or get_sessions(request).resolve(token) is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
get_sessions(request).revoke(token)
return Response(status_code=204)
@router.get("/api/v1/users/me")
def current_user(
request: Request, authorization: str | None = Header(default=None)
) -> dict[str, Any]:
user_id = current_user_id(request, authorization)
user = get_store(request).get_user(user_id)
if user is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
return user
@router.post("/api/v1/chats", status_code=201)
def create_chat(
request: Request,
body: Any = Body(...),
authorization: str | None = Header(default=None),
) -> JSONResponse:
caller = current_user_id(request, authorization)
title, member_ids = validate_create_chat(body, caller)
store = get_store(request)
for mid in member_ids:
if store.get_user(mid) is None:
raise ApiError(400, "invalid_request", "Неизвестный участник чата")
chat = store.create_chat(title, member_ids)
return JSONResponse(chat, status_code=201)
@router.get("/api/v1/chats")
def list_chats(
request: Request,
limit: str | None = Query(default=None),
cursor: str | None = Query(default=None),
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, authorization)
page_size = parse_limit(limit)
scope = f"chats:{caller}"
after = parse_cursor(cursor, scope)
items, has_more = get_store(request).list_chats_for(caller, page_size, after)
next_cursor = None
if has_more and items:
last = items[-1]
next_cursor = encode_cursor(last["created_at"], last["id"], scope)
return {"items": items, "next_cursor": next_cursor}
@router.get("/api/v1/chats/{chat_id}")
def get_chat(
chat_id: str,
request: Request,
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
chat = store.get_chat(chat_id)
if chat is None:
raise ApiError(404, "not_found", "Чат не найден")
return chat
@router.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(
chat_id: str,
request: Request,
body: Any = Body(...),
authorization: str | None = Header(default=None),
) -> JSONResponse:
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
text = validate_create_message(body)
message = store.add_message(chat_id, caller, text)
return JSONResponse(message, status_code=201)
@router.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: str,
request: Request,
limit: str | None = Query(default=None),
cursor: str | None = Query(default=None),
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
page_size = parse_limit(limit)
scope = f"messages:{chat_id}"
after = parse_cursor(cursor, scope)
items, has_more = store.list_messages(chat_id, page_size, after)
next_cursor = None
if has_more and items:
last = items[-1]
next_cursor = encode_cursor(last["created_at"], last["id"], scope)
return {"items": items, "next_cursor": next_cursor}