Files
2025-11-02 15:40:51 +00:00

309 lines
8.2 KiB
Python

"""Authentication API Endpoints
Handles user registration, login, token refresh, and password reset.
"""
from fastapi import APIRouter, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordRequestForm
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from datetime import timedelta
from db.session import get_db
from models.user import User, UserRole
from schemas.auth import (
UserRegister,
UserResponse,
Token,
TokenRefresh,
PasswordResetRequest,
PasswordReset
)
from core.security import (
get_password_hash,
verify_password,
create_access_token,
create_refresh_token,
verify_token
)
from app.config import settings
from api.dependencies import get_current_user
router = APIRouter()
@router.post(
"/register",
response_model=UserResponse,
status_code=status.HTTP_201_CREATED,
summary="Register new user",
description="Create a new user account"
)
async def register(
user_data: UserRegister,
db: AsyncSession = Depends(get_db)
):
"""
Register a new user.
- **email**: Valid email address
- **username**: Unique username
- **password**: Strong password (min 8 chars, uppercase, lowercase, number, special char)
- **full_name**: User's full name (optional)
"""
# Check if email already exists
result = await db.execute(
select(User).where(User.email == user_data.email)
)
if result.scalar_one_or_none():
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Email already registered"
)
# Check if username already exists
result = await db.execute(
select(User).where(User.username == user_data.username)
)
if result.scalar_one_or_none():
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Username already taken"
)
# Create new user
user = User(
email=user_data.email,
username=user_data.username,
full_name=user_data.full_name,
password_hash=get_password_hash(user_data.password),
role=UserRole.USER,
is_active=True
)
db.add(user)
await db.commit()
await db.refresh(user)
return user
@router.post(
"/login",
response_model=Token,
summary="Login",
description="Authenticate user and return access token"
)
async def login(
form_data: OAuth2PasswordRequestForm = Depends(),
db: AsyncSession = Depends(get_db)
):
"""
Login with username/email and password.
Returns access token and refresh token.
"""
# Find user by username or email
result = await db.execute(
select(User).where(
(User.username == form_data.username) |
(User.email == form_data.username)
)
)
user = result.scalar_one_or_none()
# Verify user exists and password is correct
if not user or not verify_password(form_data.password, user.password_hash):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Incorrect username or password",
headers={"WWW-Authenticate": "Bearer"},
)
# Check if user is active
if not user.is_active:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="User account is disabled"
)
# Create tokens
access_token = create_access_token({"sub": str(user.id)})
refresh_token = create_refresh_token({"sub": str(user.id)})
return {
"access_token": access_token,
"refresh_token": refresh_token,
"token_type": "bearer"
}
@router.post(
"/refresh",
response_model=Token,
summary="Refresh token",
description="Get new access token using refresh token"
)
async def refresh_token(
token_data: TokenRefresh,
db: AsyncSession = Depends(get_db)
):
"""
Refresh access token using refresh token.
"""
# Verify refresh token
payload = verify_token(token_data.refresh_token)
if not payload:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid refresh token"
)
user_id = payload.get("sub")
if not user_id:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid token payload"
)
# Verify user still exists and is active
result = await db.execute(
select(User).where(User.id == user_id)
)
user = result.scalar_one_or_none()
if not user or not user.is_active:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="User not found or inactive"
)
# Create new tokens
access_token = create_access_token({"sub": str(user.id)})
new_refresh_token = create_refresh_token({"sub": str(user.id)})
return {
"access_token": access_token,
"refresh_token": new_refresh_token,
"token_type": "bearer"
}
@router.post(
"/logout",
status_code=status.HTTP_204_NO_CONTENT,
summary="Logout",
description="Logout user (client should discard tokens)"
)
async def logout():
"""
Logout user.
Note: Since we're using stateless JWT tokens, the client
should simply discard the tokens. For enhanced security,
implement token blacklisting with Redis.
"""
# TODO: Implement token blacklisting with Redis
# For now, client-side token removal is sufficient
return None
@router.post(
"/password-reset/request",
status_code=status.HTTP_200_OK,
summary="Request password reset",
description="Send password reset email"
)
async def request_password_reset(
request_data: PasswordResetRequest,
db: AsyncSession = Depends(get_db)
):
"""
Request password reset email.
Always returns success to prevent email enumeration.
"""
# Find user by email
result = await db.execute(
select(User).where(User.email == request_data.email)
)
user = result.scalar_one_or_none()
if user and user.is_active:
# Generate reset token
reset_token = create_access_token(
{"sub": str(user.id), "type": "password_reset"},
expires_delta=timedelta(hours=1)
)
# TODO: Send email with reset link
# For now, just log it (in production, use email service)
from loguru import logger
logger.info(f"Password reset token for {user.email}: {reset_token}")
# In production, send email:
# await send_password_reset_email(user.email, reset_token)
# Always return success to prevent email enumeration
return {
"message": "If the email exists, a password reset link has been sent"
}
@router.post(
"/password-reset/confirm",
status_code=status.HTTP_200_OK,
summary="Reset password",
description="Reset password with token"
)
async def reset_password(
reset_data: PasswordReset,
db: AsyncSession = Depends(get_db)
):
"""
Reset password using reset token.
"""
# Verify reset token
payload = verify_token(reset_data.token)
if not payload or payload.get("type") != "password_reset":
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Invalid or expired reset token"
)
user_id = payload.get("sub")
# Get user
result = await db.execute(
select(User).where(User.id == user_id)
)
user = result.scalar_one_or_none()
if not user:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="User not found"
)
# Update password
user.password_hash = get_password_hash(reset_data.new_password)
await db.commit()
return {"message": "Password reset successful"}
@router.get(
"/me",
response_model=UserResponse,
summary="Get current user",
description="Get current authenticated user information"
)
async def get_current_user_info(
current_user: User = Depends(get_current_user)
):
"""
Get current user information.
Requires authentication via Bearer token.
Returns the authenticated user's profile information.
"""
return current_user