import base64 import binascii import uuid from datetime import datetime, timedelta, timezone import redis.asyncio as aioredis from fastapi import APIRouter, Depends, Header, Request from fastapi.responses import JSONResponse from sqlalchemy.ext.asyncio import AsyncSession from src.api.deps import get_current_user from src.core.config import settings from src.core.redis import get_redis from src.core.security import verify_password from src.db.session import get_db from src.models.models import User from src.schemas.schemas import SessionResponse, UserResponse from src.services import sessions as sessions_service from src.services import users as users_service router = APIRouter(prefix="/api/v1/auth/sessions", tags=["auth"]) def _rid(request: Request) -> str: return getattr(request.state, "request_id", None) or str(uuid.uuid4()) def _error( status_code: int, code: str, message: str, request: Request, challenge: str | None = None, ) -> JSONResponse: rid = _rid(request) headers = {"X-Request-Id": rid} if challenge: headers["WWW-Authenticate"] = challenge return JSONResponse( status_code=status_code, content={ "error": { "code": code, "message": message, "request_id": rid, } }, headers=headers, ) def _parse_basic(authorization: str | None) -> tuple[str, str] | None: if not authorization or not authorization.lower().startswith("basic "): return None encoded = authorization.split(" ", 1)[1].strip() try: decoded = base64.b64decode(encoded, validate=True).decode("utf-8") except (binascii.Error, UnicodeDecodeError): return None if ":" not in decoded: return None username, password = decoded.split(":", 1) return username, password @router.post("", status_code=201) async def create_session( request: Request, authorization: str | None = Header(default=None), db: AsyncSession = Depends(get_db), redis: aioredis.Redis = Depends(get_redis), ): credentials = _parse_basic(authorization) if credentials is None: return _error( 401, "unauthorized", "invalid credentials", request, challenge='Basic realm="messenger", charset="UTF-8"', ) username, password = credentials user = await users_service.get_user_by_username(db, username) if user is None or not verify_password(password, user.password_hash): return _error( 401, "unauthorized", "invalid credentials", request, challenge='Basic realm="messenger", charset="UTF-8"', ) try: token = await sessions_service.create_session(redis, user.id) except (aioredis.RedisError, ConnectionError, OSError): return _error( 503, "unavailable", "session store unavailable", request, ) expires_at = datetime.now(timezone.utc) + timedelta( seconds=settings.session_ttl_seconds ) payload = SessionResponse( token=token, token_type="Bearer", expires_at=expires_at, user=UserResponse.model_validate(user), ) return JSONResponse( status_code=201, content=payload.model_dump(mode="json"), headers={"X-Request-Id": _rid(request)}, ) @router.delete("/current", status_code=204) async def revoke_current_session( request: Request, authorization: str | None = Header(default=None), current_user: User = Depends(get_current_user), redis: aioredis.Redis = Depends(get_redis), ): token = authorization.split(" ", 1)[1].strip() try: await sessions_service.revoke_session(redis, token) except (aioredis.RedisError, ConnectionError, OSError): return _error( 503, "unavailable", "session store unavailable", request, ) return JSONResponse( status_code=204, content=None, headers={"X-Request-Id": _rid(request)}, )