115 lines
5.3 KiB
Python
115 lines
5.3 KiB
Python
import secrets
|
|
import logging
|
|
import bcrypt
|
|
import asyncpg
|
|
from datetime import datetime, timezone, timedelta
|
|
from fastapi import APIRouter, Depends, HTTPException, status, Response
|
|
from fastapi.security import HTTPBearer
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy.exc import SQLAlchemyError
|
|
from app.database import get_db
|
|
from app.models import User as UserModel, UserSession
|
|
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
|
|
|
|
logger = logging.getLogger(__name__)
|
|
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:
|
|
return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).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)):
|
|
new_user = UserModel(
|
|
username=user_in.username,
|
|
display_name=user_in.display_name,
|
|
password_hash=get_password_hash(user_in.password)
|
|
)
|
|
db.add(new_user)
|
|
try:
|
|
await db.commit()
|
|
await db.refresh(new_user)
|
|
return User(
|
|
id=str(new_user.id),
|
|
username=new_user.username,
|
|
display_name=new_user.display_name,
|
|
created_at=new_user.created_at.isoformat().replace('+00:00', 'Z')
|
|
)
|
|
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=409, detail={"code": "conflict", "message": "Username already exists"})
|
|
logger.error(f"Database error during registration: {e}")
|
|
raise HTTPException(status_code=500, 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=401, 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=3600)
|
|
|
|
try:
|
|
await redis_client.setex(f"session:{token}", 3600, str(user.id))
|
|
except Exception as e:
|
|
logger.warning(f"Redis unavailable during session creation: {e}")
|
|
|
|
try:
|
|
db.add(UserSession(token=token, user_id=user.id, expires_at=expires_at))
|
|
await db.commit()
|
|
except SQLAlchemyError as e:
|
|
await db.rollback()
|
|
logger.error(f"Failed to save session to PostgreSQL: {e}")
|
|
raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Failed to create session"})
|
|
|
|
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()), db: AsyncSession = Depends(get_db), redis_client = Depends(get_redis)):
|
|
token = credentials.credentials
|
|
try:
|
|
await redis_client.delete(f"session:{token}")
|
|
except Exception as e:
|
|
logger.warning(f"Redis unavailable during session revocation: {e}")
|
|
|
|
try:
|
|
result = await db.execute(select(UserSession).where(UserSession.token == token))
|
|
session = result.scalar_one_or_none()
|
|
if session:
|
|
await db.delete(session)
|
|
await db.commit()
|
|
else:
|
|
raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Invalid or expired session"}, headers={"WWW-Authenticate": "Bearer realm=\"messenger\""})
|
|
except HTTPException:
|
|
raise
|
|
except SQLAlchemyError as e:
|
|
await db.rollback()
|
|
raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Failed to revoke session"})
|
|
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 User(
|
|
id=str(current_user.id),
|
|
username=current_user.username,
|
|
display_name=current_user.display_name,
|
|
created_at=current_user.created_at.isoformat().replace('+00:00', 'Z')
|
|
) |