Files
mtusi2026lab2/app/routers/auth.py
T
2026-10-09 15:02:48 +03:00

79 lines
4.0 KiB
Python

from fastapi import APIRouter, Depends, HTTPException, status, Response
from fastapi.security import HTTPBearer
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
import asyncpg
import secrets
import bcrypt
from datetime import datetime, timezone, timedelta
from app.database import get_db, settings
from app.models import User as UserModel
from app.schemas import CreateUser, User, Session, ErrorResponse
from app.dependencies import get_basic_auth, get_current_user
from app.redis_client import get_redis
router = APIRouter()
def verify_password(plain_password: str, hashed_password: str) -> bool:
return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))
def get_password_hash(password: str) -> str:
salt = bcrypt.gensalt()
hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
return hashed.decode('utf-8')
@router.post("/api/v1/users", response_model=User, status_code=status.HTTP_201_CREATED, responses={409: {"model": ErrorResponse}})
async def register_user(user_in: CreateUser, db: AsyncSession = Depends(get_db)):
hashed_password = get_password_hash(user_in.password)
new_user = UserModel(username=user_in.username, display_name=user_in.display_name, password_hash=hashed_password)
db.add(new_user)
try:
await db.commit()
await db.refresh(new_user)
return new_user
except Exception as e:
await db.rollback()
if isinstance(e.__cause__, asyncpg.exceptions.UniqueViolationError) or "unique constraint" in str(e).lower():
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail={"code": "conflict", "message": "Username already exists"})
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail={"code": "internal_error", "message": "Database error"})
@router.post("/api/v1/auth/sessions", response_model=Session, status_code=status.HTTP_201_CREATED, responses={401: {"model": ErrorResponse}})
async def create_session(credentials = Depends(get_basic_auth), db: AsyncSession = Depends(get_db), redis_client = Depends(get_redis)):
result = await db.execute(select(UserModel).where(UserModel.username == credentials.username))
user = result.scalar_one_or_none()
if not user or not verify_password(credentials.password, user.password_hash):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={"code": "unauthorized", "message": "Invalid username or password"},
headers={"WWW-Authenticate": "Basic realm=\"messenger\", charset=\"UTF-8\""}
)
token = secrets.token_urlsafe(32)
expires_at = datetime.now(timezone.utc) + timedelta(seconds=settings.SESSION_TTL_SECONDS)
await redis_client.setex(f"session:{token}", settings.SESSION_TTL_SECONDS, str(user.id))
return Session(
token=token, token_type="Bearer", expires_at=expires_at,
user=User(id=str(user.id), username=user.username, display_name=user.display_name, created_at=user.created_at.isoformat().replace('+00:00', 'Z'))
)
@router.delete("/api/v1/auth/sessions/current", status_code=status.HTTP_204_NO_CONTENT, responses={401: {"model": ErrorResponse}})
async def revoke_session(credentials = Depends(HTTPBearer()), redis_client = Depends(get_redis)):
token = credentials.credentials
# Проверяем, существует ли сессия в Redis
exists = await redis_client.exists(f"session:{token}")
if not exists:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={"code": "unauthorized", "message": "Invalid or expired session"},
headers={"WWW-Authenticate": "Bearer realm=\"messenger\""}
)
await redis_client.delete(f"session:{token}")
return Response(status_code=status.HTTP_204_NO_CONTENT)
@router.get("/api/v1/users/me", response_model=User, responses={401: {"model": ErrorResponse}})
async def current_user(current_user: UserModel = Depends(get_current_user)):
return current_user