Files
mtusi2026lab5/app/endpoints/dependencies.py
T
2026-11-07 16:10:32 +03:00

113 lines
3.7 KiB
Python

import base64
import binascii
from collections.abc import AsyncIterator
from typing import Annotated
from fastapi import Depends, Request, Security
from fastapi.openapi.models import HTTPBase, HTTPBearer
from fastapi.security.base import SecurityBase
from redis.asyncio import Redis
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.config import Settings
from app.core.request_capacity import RequestCapacity
from app.domain.auth import authenticate_token
from app.errors.exceptions import unauthorized_basic, unauthorized_bearer
from app.schemas.user import User
from app.storage.s3 import MinioStorage
async def get_settings(request: Request) -> Settings:
settings: Settings = request.app.state.settings
return settings
async def get_db(request: Request) -> AsyncIterator[AsyncSession]:
"""Одна AsyncSession на HTTP-запрос; незакоммиченная транзакция откатывается."""
session_factory = request.app.state.session_factory
async with session_factory() as session:
yield session
async def get_redis(request: Request) -> Redis:
redis: Redis = request.app.state.redis
return redis
def get_s3(request: Request) -> MinioStorage | None:
return request.app.state.s3
def get_upload_capacity(request: Request) -> RequestCapacity:
return request.app.state.upload_capacity
class AuthorizationHeader(SecurityBase):
"""Отдаёт сырой заголовок Authorization и описывает схему для OpenAPI."""
def __init__(self, model: HTTPBase, scheme_name: str) -> None:
self.model = model
self.scheme_name = scheme_name
async def __call__(self, request: Request) -> str | None:
return request.headers.get("Authorization")
basic_auth = AuthorizationHeader(HTTPBase(scheme="basic"), "BasicAuth")
bearer_auth = AuthorizationHeader(HTTPBearer(), "BearerAuth")
def _split_authorization(authorization: str | None) -> tuple[str, str] | None:
if authorization is None:
return None
scheme, _, value = authorization.partition(" ")
if not value.strip():
return None
return scheme.lower(), value.strip()
async def get_bearer_token(
authorization: Annotated[str | None, Security(bearer_auth)],
) -> str:
parts = _split_authorization(authorization)
if parts is None or parts[0] != "bearer":
raise unauthorized_bearer()
return parts[1]
async def get_basic_credentials(
authorization: Annotated[str | None, Security(basic_auth)],
) -> tuple[str, str]:
"""(username, password) из `Authorization: Basic`; пароль может содержать ':'."""
parts = _split_authorization(authorization)
if parts is None or parts[0] != "basic":
raise unauthorized_basic()
try:
decoded = base64.b64decode(parts[1], validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError, ValueError):
raise unauthorized_basic() from None
username, separator, password = decoded.partition(":")
if not separator or not username:
raise unauthorized_basic()
return username, password
DbSession = Annotated[AsyncSession, Depends(get_db)]
RedisClient = Annotated[Redis, Depends(get_redis)]
AppSettings = Annotated[Settings, Depends(get_settings)]
S3Storage = Annotated[MinioStorage | None, Depends(get_s3)]
UploadCapacity = Annotated[RequestCapacity, Depends(get_upload_capacity)]
BearerToken = Annotated[str, Depends(get_bearer_token)]
BasicCredentials = Annotated[tuple[str, str], Depends(get_basic_credentials)]
async def get_current_user(
token: BearerToken, session: DbSession, redis: RedisClient
) -> User:
return await authenticate_token(session, redis, token)
CurrentUser = Annotated[User, Depends(get_current_user)]