128 lines
4.8 KiB
Python
128 lines
4.8 KiB
Python
from fastapi import APIRouter, Depends, Request, Response, status, HTTPException
|
|
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
|
|
from sqlalchemy.orm import Session
|
|
from app.config.database import get_db
|
|
from app.config.settings import settings
|
|
from app.controllers.auth.auth_controller import AuthController
|
|
from app.schemas.auth.auth_schema import (
|
|
UserSignup,
|
|
UserSignin,
|
|
TokenResponse,
|
|
UserResponse,
|
|
UserUpdate,
|
|
ResetPassword,
|
|
RefreshTokenRequest,
|
|
ForgotPasswordRequest,
|
|
VerifyOTPRequest,
|
|
ResetPasswordWithOTP,
|
|
)
|
|
from app.schemas.auth.language_schema import UpdateLanguageRequest
|
|
from app.middleware.auth_middleware import get_current_user, security_scheme
|
|
from app.middleware.tenant_middleware import get_tenant_from_header
|
|
from app.models.auth.user_model import User
|
|
import uuid
|
|
|
|
router = APIRouter()
|
|
|
|
def _cookie_kwargs():
|
|
kwargs = dict(httponly=True, samesite="lax", secure=settings.COOKIE_SECURE, path="/")
|
|
if settings.COOKIE_DOMAIN:
|
|
kwargs["domain"] = settings.COOKIE_DOMAIN
|
|
return kwargs
|
|
|
|
@router.post("/signup", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
|
|
def signup(
|
|
user_data: UserSignup,
|
|
db: Session = Depends(get_db),
|
|
tenant_id: uuid.UUID = Depends(get_tenant_from_header),
|
|
):
|
|
return AuthController.signup(db, user_data, tenant_id)
|
|
|
|
@router.post("/signin", response_model=TokenResponse)
|
|
def signin(signin_data: UserSignin, response: Response, db: Session = Depends(get_db)):
|
|
result = AuthController.signin(db, signin_data)
|
|
cookie_kw = _cookie_kwargs()
|
|
access_max_age = settings.ACCESS_TOKEN_EXPIRES if signin_data.remember_me else None
|
|
refresh_max_age = settings.REFRESH_TOKEN_EXPIRES if signin_data.remember_me else None
|
|
response.set_cookie(key="access_token", value=result["access_token"], max_age=access_max_age, **cookie_kw)
|
|
response.set_cookie(key="refresh_token", value=result["refresh_token"], max_age=refresh_max_age, **cookie_kw)
|
|
return result
|
|
|
|
@router.post("/refresh", response_model=TokenResponse)
|
|
def refresh_token(
|
|
token_data: RefreshTokenRequest,
|
|
request: Request,
|
|
response: Response,
|
|
db: Session = Depends(get_db),
|
|
):
|
|
refresh_tok = token_data.refresh_token or request.cookies.get("refresh_token")
|
|
if not refresh_tok:
|
|
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Missing refresh token")
|
|
result = AuthController.refresh_token_raw(db, refresh_tok)
|
|
cookie_kw = _cookie_kwargs()
|
|
response.set_cookie(key="access_token", value=result["access_token"], **cookie_kw)
|
|
response.set_cookie(key="refresh_token", value=result["refresh_token"], **cookie_kw)
|
|
return result
|
|
|
|
@router.get("/me", response_model=UserResponse)
|
|
def get_me(
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
return AuthController.me(db, current_user)
|
|
|
|
@router.put("/update/{user_id}", response_model=UserResponse)
|
|
def update_user(
|
|
user_id: uuid.UUID,
|
|
user_data: UserUpdate,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
return AuthController.update_user(db, user_id, user_data, current_user)
|
|
|
|
@router.patch("/update/{user_id}/language", response_model=UserResponse)
|
|
def update_language(
|
|
user_id: uuid.UUID,
|
|
language_data: UpdateLanguageRequest,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
user_update = UserUpdate(preferred_language=language_data.preferred_language.value)
|
|
return AuthController.update_user(db, user_id, user_update, current_user)
|
|
|
|
@router.post("/reset-password")
|
|
def reset_password(
|
|
password_data: ResetPassword,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
return AuthController.reset_password(db, current_user, password_data)
|
|
|
|
@router.post("/logout")
|
|
def logout(
|
|
request: Request,
|
|
response: Response,
|
|
credentials: HTTPAuthorizationCredentials = Depends(security_scheme),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
token = credentials.credentials if credentials else request.cookies.get("access_token")
|
|
result = AuthController.logout(current_user, token)
|
|
cookie_kw = _cookie_kwargs()
|
|
response.delete_cookie(key="access_token", **cookie_kw)
|
|
response.delete_cookie(key="refresh_token", **cookie_kw)
|
|
return result
|
|
|
|
@router.post("/forgot-password")
|
|
def forgot_password(request: ForgotPasswordRequest, db: Session = Depends(get_db)):
|
|
return AuthController.forgot_password(db, request)
|
|
|
|
@router.post("/verify-otp")
|
|
def verify_otp(request: VerifyOTPRequest, db: Session = Depends(get_db)):
|
|
return AuthController.verify_otp(db, request)
|
|
|
|
|
|
@router.post("/reset-password-otp")
|
|
def reset_password_with_otp(
|
|
request: ResetPasswordWithOTP, db: Session = Depends(get_db)
|
|
):
|
|
return AuthController.reset_password_with_otp(db, request) |