341 lines
12 KiB
Python
341 lines
12 KiB
Python
"""
|
|
管理员后台路由
|
|
"""
|
|
from fastapi import APIRouter, Depends, HTTPException, Query
|
|
from sqlalchemy.orm import Session
|
|
from typing import List, Optional
|
|
from ..core.database import get_db
|
|
from ..models.streamer import StreamerProfile
|
|
from ..schemas.user import UserResponse, UserUpdate, UserBalanceAdjust, UserBatchAction
|
|
from ..schemas.streamer import StreamerProfileResponse, StreamerProfileUpdate, StreamerStatistics
|
|
from ..schemas.system import SystemConfigResponse, SystemConfigCreate, SystemConfigUpdate, SystemConfigBatchUpdate
|
|
from ..schemas.announcement import AnnouncementResponse, AnnouncementCreate, AnnouncementUpdate
|
|
from ..services.user_service import UserService
|
|
from ..services.streamer_service import StreamerService
|
|
from ..services.system_service import SystemService
|
|
from ..services.announcement_service import AnnouncementService
|
|
from ..utils.deps import get_current_admin
|
|
router = APIRouter(prefix="/api/admin", tags=["admin"])
|
|
|
|
|
|
# ==================== 用户管理 ====================
|
|
|
|
@router.get("/users", response_model=List[UserResponse])
|
|
def get_users(
|
|
page: int = Query(1, ge=1),
|
|
size: int = Query(20, ge=1, le=100),
|
|
search: Optional[str] = Query(None, description="搜索关键词"),
|
|
role: Optional[str] = Query(None, description="角色筛选"),
|
|
status: Optional[str] = Query(None, description="状态筛选"),
|
|
sort: str = Query("created_at", description="排序字段"),
|
|
order: str = Query("desc", description="排序方向"),
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""获取用户列表（管理员）"""
|
|
skip = (page - 1) * size
|
|
return UserService.get_user_list(db, skip, size, search, role, status, sort, order)
|
|
|
|
|
|
@router.get("/users/{user_id}", response_model=UserResponse)
|
|
def get_user_detail(
|
|
user_id: int,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""获取用户详情"""
|
|
user = UserService.get_user_by_id(db, user_id)
|
|
if not user:
|
|
raise HTTPException(status_code=404, detail="用户不存在")
|
|
return user
|
|
|
|
|
|
@router.put("/users/{user_id}", response_model=UserResponse)
|
|
def update_user(
|
|
user_id: int,
|
|
user_data: UserUpdate,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""更新用户信息"""
|
|
user = UserService.get_user_by_id(db, user_id)
|
|
if not user:
|
|
raise HTTPException(status_code=404, detail="用户不存在")
|
|
|
|
return UserService.update_user(db, user, user_data)
|
|
|
|
|
|
@router.post("/users/{user_id}/adjust-balance")
|
|
def adjust_user_balance(
|
|
user_id: int,
|
|
adjust_data: UserBalanceAdjust,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""调整用户余额"""
|
|
user = UserService.get_user_by_id(db, user_id)
|
|
if not user:
|
|
raise HTTPException(status_code=404, detail="用户不存在")
|
|
|
|
try:
|
|
UserService.adjust_balance_with_version(db, user, adjust_data.amount, adjust_data.description, current_admin)
|
|
return {"message": "余额调整成功", "new_balance": user.balance}
|
|
except ValueError as e:
|
|
raise HTTPException(status_code=400, detail=str(e))
|
|
|
|
|
|
@router.put("/users/{user_id}/set-role")
|
|
def set_user_role(
|
|
user_id: int,
|
|
role_data: dict,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""设置用户身份"""
|
|
user = UserService.get_user_by_id(db, user_id)
|
|
if not user:
|
|
raise HTTPException(status_code=404, detail="用户不存在")
|
|
|
|
# 检查请求数据
|
|
new_role = role_data.get("role")
|
|
if not new_role:
|
|
raise HTTPException(status_code=400, detail="缺少角色参数")
|
|
|
|
# 验证角色值是否有效
|
|
valid_roles = ["USER", "STREAMER", "ADMIN"]
|
|
if new_role not in valid_roles:
|
|
raise HTTPException(status_code=400, detail=f"无效的角色值，有效值为: {', '.join(valid_roles)}")
|
|
|
|
# 如果设置为主播角色，检查是否已有主播配置
|
|
if new_role == "STREAMER":
|
|
existing_streamer = db.query(StreamerProfile).filter(StreamerProfile.user_id == user_id).first()
|
|
if not existing_streamer:
|
|
# 自动创建默认的主播配置
|
|
default_streamer = StreamerProfile(
|
|
user_id=user_id,
|
|
display_name=user.username,
|
|
commission_rate=5.00,
|
|
max_active_chests=10
|
|
)
|
|
db.add(default_streamer)
|
|
|
|
# 更新用户角色
|
|
user.role = new_role
|
|
db.commit()
|
|
db.refresh(user)
|
|
|
|
return {"message": "用户身份设置成功", "user": user}
|
|
|
|
|
|
@router.post("/users/batch-action")
|
|
def batch_action_users(
|
|
batch_data: UserBatchAction,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""批量操作用户"""
|
|
try:
|
|
affected_count = UserService.batch_action_users(db, batch_data.user_ids, batch_data.action, batch_data.reason)
|
|
return {"message": f"成功操作 {affected_count} 个用户", "affected_count": affected_count}
|
|
except ValueError as e:
|
|
raise HTTPException(status_code=400, detail=str(e))
|
|
|
|
|
|
@router.get("/users/{user_id}/transactions", response_model=List[dict])
|
|
def get_user_transactions(
|
|
user_id: int,
|
|
page: int = Query(1, ge=1),
|
|
size: int = Query(20, ge=1, le=100),
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""获取用户交易流水"""
|
|
user = UserService.get_user_by_id(db, user_id)
|
|
if not user:
|
|
raise HTTPException(status_code=404, detail="用户不存在")
|
|
|
|
skip = (page - 1) * size
|
|
return UserService.get_user_transactions_paginated(db, user_id, skip, size)
|
|
|
|
|
|
# ==================== 主播管理 ====================
|
|
|
|
@router.get("/streamers", response_model=List[StreamerProfileResponse])
|
|
def get_streamers(
|
|
page: int = Query(1, ge=1),
|
|
size: int = Query(20, ge=1, le=100),
|
|
status: Optional[str] = Query(None, description="状态筛选"),
|
|
sort: str = Query("created_at", description="排序字段"),
|
|
order: str = Query("desc", description="排序方向"),
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""获取主播列表"""
|
|
skip = (page - 1) * size
|
|
return StreamerService.get_streamer_list(db, skip, size, status, sort, order)
|
|
|
|
|
|
@router.get("/streamers/{streamer_id}", response_model=StreamerProfileResponse)
|
|
def get_streamer_detail(
|
|
streamer_id: int,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""获取主播详情"""
|
|
streamer = StreamerService.get_streamer_profile(db, streamer_id)
|
|
if not streamer:
|
|
raise HTTPException(status_code=404, detail="主播不存在")
|
|
return streamer
|
|
|
|
|
|
@router.put("/streamers/{streamer_id}", response_model=StreamerProfileResponse)
|
|
def update_streamer(
|
|
streamer_id: int,
|
|
streamer_data: StreamerProfileUpdate,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""更新主播配置"""
|
|
streamer = StreamerService.get_streamer_profile(db, streamer_id)
|
|
if not streamer:
|
|
raise HTTPException(status_code=404, detail="主播不存在")
|
|
|
|
return StreamerService.update_streamer_profile(db, streamer, streamer_data)
|
|
|
|
|
|
@router.get("/streamers/{streamer_id}/stats", response_model=StreamerStatistics)
|
|
def get_streamer_statistics(
|
|
streamer_id: int,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""获取主播统计"""
|
|
return StreamerService.get_streamer_statistics(db, streamer_id)
|
|
|
|
|
|
@router.get("/streamers/{streamer_id}/chests")
|
|
def get_streamer_chests(
|
|
streamer_id: int,
|
|
page: int = Query(1, ge=1),
|
|
size: int = Query(20, ge=1, le=100),
|
|
status: Optional[str] = Query(None, description="状态筛选"),
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""获取主播宝箱列表"""
|
|
skip = (page - 1) * size
|
|
return StreamerService.get_streamer_chests(db, streamer_id, skip, size, status)
|
|
|
|
|
|
# ==================== 系统设置 ====================
|
|
|
|
@router.get("/system/configs", response_model=List[SystemConfigResponse])
|
|
def get_system_configs(
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""获取所有系统配置"""
|
|
return SystemService.get_all_configs(db)
|
|
|
|
|
|
@router.post("/system/configs", response_model=SystemConfigResponse)
|
|
def create_system_config(
|
|
config_data: SystemConfigCreate,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""创建系统配置"""
|
|
return SystemService.create_config(db, config_data)
|
|
|
|
|
|
@router.put("/system/configs/{config_key}", response_model=SystemConfigResponse)
|
|
def update_system_config(
|
|
config_key: str,
|
|
config_data: SystemConfigUpdate,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""更新系统配置"""
|
|
config = SystemService.get_config(db, config_key)
|
|
if not config:
|
|
raise HTTPException(status_code=404, detail="配置不存在")
|
|
|
|
return SystemService.update_config(db, config_key, config_data)
|
|
|
|
|
|
@router.delete("/system/configs/{config_key}")
|
|
def delete_system_config(
|
|
config_key: str,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""删除系统配置"""
|
|
success = SystemService.delete_config(db, config_key)
|
|
if not success:
|
|
raise HTTPException(status_code=404, detail="配置不存在")
|
|
return {"message": "配置删除成功"}
|
|
|
|
|
|
@router.put("/system/configs/batch")
|
|
def batch_update_configs(
|
|
batch_data: SystemConfigBatchUpdate,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""批量更新配置"""
|
|
updated_count = SystemService.batch_update_configs(db, batch_data.configs)
|
|
return {"message": f"成功更新 {updated_count} 项配置", "updated_count": updated_count}
|
|
|
|
|
|
# ==================== 公告管理 ====================
|
|
|
|
@router.get("/announcements", response_model=List[AnnouncementResponse])
|
|
def get_announcements(
|
|
page: int = Query(1, ge=1),
|
|
size: int = Query(20, ge=1, le=100),
|
|
include_expired: bool = Query(False, description="包含过期公告"),
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""获取公告列表"""
|
|
skip = (page - 1) * size
|
|
return AnnouncementService.get_announcements(db, skip, size, include_expired)
|
|
|
|
|
|
@router.post("/announcements", response_model=AnnouncementResponse)
|
|
def create_announcement(
|
|
announcement_data: AnnouncementCreate,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""创建公告"""
|
|
return AnnouncementService.create_announcement(db, announcement_data)
|
|
|
|
|
|
@router.put("/announcements/{announcement_id}", response_model=AnnouncementResponse)
|
|
def update_announcement(
|
|
announcement_id: int,
|
|
announcement_data: AnnouncementUpdate,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""更新公告"""
|
|
announcement = AnnouncementService.get_announcement(db, announcement_id)
|
|
if not announcement:
|
|
raise HTTPException(status_code=404, detail="公告不存在")
|
|
|
|
return AnnouncementService.update_announcement(db, announcement, announcement_data)
|
|
|
|
|
|
@router.delete("/announcements/{announcement_id}")
|
|
def delete_announcement(
|
|
announcement_id: int,
|
|
db: Session = Depends(get_db),
|
|
current_admin: UserService = Depends(get_current_admin)
|
|
):
|
|
"""删除公告"""
|
|
success = AnnouncementService.delete_announcement(db, announcement_id)
|
|
if not success:
|
|
raise HTTPException(status_code=404, detail="公告不存在")
|
|
return {"message": "公告删除成功"}
|