Files
SakuraHub/sakura_cloud/api/v1/endpoints/auth.py
T
2026-11-16 20:45:22 +08:00

121 lines
4.9 KiB
Python

from __future__ import annotations
from time import monotonic
from fastapi import APIRouter, HTTPException, Request, status
from sqlalchemy import func, or_, select
from sqlalchemy.exc import IntegrityError, SQLAlchemyError
from sakura_cloud.api.deps import CurrentUser, DbSession
from sakura_cloud.core.security import (
create_access_token,
create_refresh_token,
decode_token,
hash_password,
verify_password,
)
from sakura_cloud.models.user import User
from sakura_cloud.schemas.auth import LoginRequest, RefreshRequest, RegisterRequest, TokenPair
from sakura_cloud.schemas.common import ApiResponse
from sakura_cloud.schemas.user import UserOut
router = APIRouter()
_rate_buckets: dict[str, list[float]] = {}
def _rate_limit(request: Request, scope: str, *, limit: int = 5, window_seconds: int = 60) -> None:
client_ip = request.client.host if request.client else "unknown"
key = f"{scope}:{client_ip}"
now = monotonic()
bucket = [item for item in _rate_buckets.get(key, []) if now - item < window_seconds]
if len(bucket) >= limit:
_rate_buckets[key] = bucket
raise HTTPException(status_code=status.HTTP_429_TOO_MANY_REQUESTS, detail="Too many requests")
bucket.append(now)
_rate_buckets[key] = bucket
@router.post("/register", response_model=ApiResponse[UserOut], status_code=status.HTTP_201_CREATED)
def register(payload: RegisterRequest, request: Request, db: DbSession) -> ApiResponse[UserOut]:
_rate_limit(request, "register")
username = payload.username.strip()
email = str(payload.email).strip().lower()
exists = db.scalar(
select(User).where(
or_(
func.lower(User.username) == username.lower(),
func.lower(User.email) == email,
)
)
)
if exists is not None:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="注册失败,请检查输入")
user = User(
username=username,
email=email,
password_hash=hash_password(payload.password),
)
try:
db.add(user)
db.commit()
db.refresh(user)
except IntegrityError as exc:
db.rollback()
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="注册失败,请检查输入") from exc
except SQLAlchemyError as exc:
db.rollback()
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="注册失败,请稍后重试") from exc
return ApiResponse(code=201, message="created", data=UserOut.model_validate(user))
@router.post("/login", response_model=ApiResponse[TokenPair])
def login(payload: LoginRequest, request: Request, db: DbSession) -> ApiResponse[TokenPair]:
_rate_limit(request, "login")
login_id = payload.username_or_email.strip()
user = db.scalar(
select(User).where(
or_(
func.lower(User.username) == login_id.lower(),
func.lower(User.email) == login_id.lower(),
)
)
)
if user is None or not verify_password(payload.password, user.password_hash):
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
tokens = TokenPair(
access_token=create_access_token(user.id, user.token_version),
refresh_token=create_refresh_token(user.id, user.token_version),
)
return ApiResponse(data=tokens)
@router.post("/logout", response_model=ApiResponse[dict[str, bool]])
def logout(current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, bool]]:
# 临时方案:只让客户端清本地 token,不在服务端吊销所有端
return ApiResponse(data={"ok": True})
@router.post("/refresh", response_model=ApiResponse[TokenPair])
def refresh(payload: RefreshRequest, request: Request, db: DbSession) -> ApiResponse[TokenPair]:
_rate_limit(request, "refresh")
try:
token_payload = decode_token(payload.refresh_token)
except ValueError as exc:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid refresh token") from exc
if token_payload.get("type") != "refresh":
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token type")
user_id = token_payload.get("sub")
user = db.get(User, str(user_id)) if user_id else None
if user is None:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found")
if not user.is_active:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User is disabled")
if int(token_payload.get("tv") or 0) != int(user.token_version or 0):
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Token has been revoked")
tokens = TokenPair(
access_token=create_access_token(user.id, user.token_version),
refresh_token=create_refresh_token(user.id, user.token_version),
)
return ApiResponse(data=tokens)