buff/backend/app/api/client/steam.py

"""
Steam账号管理接口
"""
from fastapi import APIRouter, Depends, HTTPException, Request
from sqlalchemy.orm import Session
from pydantic import BaseModel
from typing import Optional, List
from app.database import get_db
from app.models.steam_account import SteamAccount
from app.models.user import User
from app.core.encrypt import encryptor
from app.core.logger import logger
from app.config import settings
from datetime import datetime

router = APIRouter()

class SteamAccountRequest(BaseModel):
    """Steam账号请求"""
    user_id: int
    steam_username: str
    steam_id: Optional[str] = None
    shared_secret: str
    identity_secret: str

class SteamAccountUpdateRequest(BaseModel):
    """Steam账号更新请求"""
    user_id: int
    steam_username: Optional[str] = None
    steam_id: Optional[str] = None
    shared_secret: Optional[str] = None
    identity_secret: Optional[str] = None
    is_active: Optional[int] = None

@router.get("/steam-accounts")
async def get_steam_accounts(
    request: Request,
    db: Session = Depends(get_db)
):
    """获取Steam账号列表"""
    try:
        # 获取请求参数
        params = dict(request.query_params)
        
        # 解密请求数据（如果有）
        user_id = None
        if settings.ENCRYPT_ENABLED:
            encrypted_data = params.get("encrypted", "")
            if encrypted_data:
                decrypted = encryptor.decrypt(encrypted_data)
                user_id = decrypted.get("user_id")
        else:
            user_id = params.get("user_id")
            if user_id:
                user_id = int(user_id)
        
        if not user_id:
            return {"code": 400, "msg": "缺少用户ID"}
        
        # 验证用户是否存在
        user = db.query(User).filter(User.id == user_id).first()
        if not user:
            return {"code": 404, "msg": "用户不存在"}
        
        # 查询Steam账号列表
        accounts = db.query(SteamAccount).filter(
            SteamAccount.user_id == user_id
        ).order_by(SteamAccount.created_at.desc()).all()
        
        # 格式化返回数据
        accounts_data = []
        for account in accounts:
            # 解密共享密钥和身份密钥
            shared_secret = ""
            identity_secret = ""
            try:
                if account.shared_secret:
                    shared_secret = encryptor.decrypt(account.shared_secret)
                if account.identity_secret:
                    identity_secret = encryptor.decrypt(account.identity_secret)
            except Exception as e:
                logger.error(f"解密Steam账号密钥失败: {e}")
            
            accounts_data.append({
                "id": account.id,
                "steam_username": account.steam_username,
                "steam_id": account.steam_id,
                "shared_secret": shared_secret,
                "identity_secret": identity_secret,
                "is_active": account.is_active,
                "last_used_time": account.last_used_time.isoformat() if account.last_used_time else None,
                "created_at": account.created_at.isoformat() if account.created_at else None,
                "updated_at": account.updated_at.isoformat() if account.updated_at else None
            })
        
        return {
            "code": 200,
            "msg": "成功",
            "data": accounts_data
        }
        
    except Exception as e:
        logger.error(f"获取Steam账号列表失败: {e}")
        return {"code": 500, "msg": "获取Steam账号列表失败"}

@router.post("/steam-accounts")
async def create_steam_account(
    request: Request,
    db: Session = Depends(get_db)
):
    """添加Steam账号"""
    try:
        # 获取请求数据
        data = await request.json()
        
        # 解密请求数据
        if settings.ENCRYPT_ENABLED:
            encrypted_data = data.get("encrypted", "")
            if not encrypted_data:
                return {"code": 400, "msg": "缺少加密数据"}
            decrypted = encryptor.decrypt(encrypted_data)
        else:
            decrypted = data
        
        req = SteamAccountRequest(**decrypted)
        
        # 验证用户是否存在
        user = db.query(User).filter(User.id == req.user_id).first()
        if not user:
            return {"code": 404, "msg": "用户不存在"}
        
        # 检查Steam用户名是否已存在
        existing = db.query(SteamAccount).filter(
            SteamAccount.user_id == req.user_id,
            SteamAccount.steam_username == req.steam_username
        ).first()
        if existing:
            return {"code": 400, "msg": "该Steam账号已存在"}
        
        # 加密存储共享密钥和身份密钥
        encrypted_shared_secret = encryptor.encrypt(req.shared_secret)
        encrypted_identity_secret = encryptor.encrypt(req.identity_secret)
        
        # 创建Steam账号
        steam_account = SteamAccount(
            user_id=req.user_id,
            steam_username=req.steam_username,
            steam_id=req.steam_id,
            shared_secret=encrypted_shared_secret,
            identity_secret=encrypted_identity_secret,
            is_active=1,
            created_at=datetime.now(),
            updated_at=datetime.now()
        )
        db.add(steam_account)
        db.commit()
        db.refresh(steam_account)
        
        logger.info(f"用户 {req.user_id} 添加Steam账号成功: {req.steam_username}")
        return {
            "code": 200,
            "msg": "添加成功",
            "data": {
                "id": steam_account.id,
                "steam_username": steam_account.steam_username
            }
        }
        
    except Exception as e:
        db.rollback()
        logger.error(f"添加Steam账号失败: {e}")
        return {"code": 500, "msg": "添加失败"}

@router.put("/steam-accounts/{account_id}")
async def update_steam_account(
    account_id: int,
    request: Request,
    db: Session = Depends(get_db)
):
    """更新Steam账号"""
    try:
        # 获取请求数据
        data = await request.json()
        
        # 解密请求数据
        if settings.ENCRYPT_ENABLED:
            encrypted_data = data.get("encrypted", "")
            if not encrypted_data:
                return {"code": 400, "msg": "缺少加密数据"}
            decrypted = encryptor.decrypt(encrypted_data)
        else:
            decrypted = data
        
        req = SteamAccountUpdateRequest(**decrypted)
        
        # 查找Steam账号
        account = db.query(SteamAccount).filter(SteamAccount.id == account_id).first()
        if not account:
            return {"code": 404, "msg": "Steam账号不存在"}
        
        # 验证用户ID是否匹配
        if account.user_id != req.user_id:
            return {"code": 403, "msg": "无权访问该账号"}
        
        # 更新字段
        if req.steam_username is not None:
            # 检查新用户名是否与其他账号冲突
            existing = db.query(SteamAccount).filter(
                SteamAccount.user_id == req.user_id,
                SteamAccount.steam_username == req.steam_username,
                SteamAccount.id != account_id
            ).first()
            if existing:
                return {"code": 400, "msg": "该Steam账号已存在"}
            account.steam_username = req.steam_username
        
        if req.steam_id is not None:
            account.steam_id = req.steam_id
        
        if req.shared_secret is not None:
            account.shared_secret = encryptor.encrypt(req.shared_secret)
        
        if req.identity_secret is not None:
            account.identity_secret = encryptor.encrypt(req.identity_secret)
        
        if req.is_active is not None:
            account.is_active = req.is_active
        
        account.updated_at = datetime.now()
        db.commit()
        
        logger.info(f"用户 {req.user_id} 更新Steam账号成功: {account_id}")
        return {
            "code": 200,
            "msg": "更新成功",
            "data": {
                "id": account.id,
                "steam_username": account.steam_username
            }
        }
        
    except Exception as e:
        db.rollback()
        logger.error(f"更新Steam账号失败: {e}")
        return {"code": 500, "msg": "更新失败"}

@router.delete("/steam-accounts/{account_id}")
async def delete_steam_account(
    account_id: int,
    request: Request,
    db: Session = Depends(get_db)
):
    """删除Steam账号"""
    try:
        # 获取请求数据（从body或query参数）
        data = {}
        try:
            # 尝试从body获取
            body = await request.body()
            if body:
                import json
                data = json.loads(body)
        except:
            pass
        
        # 如果body为空，尝试从query参数获取
        if not data:
            params = dict(request.query_params)
            if settings.ENCRYPT_ENABLED:
                encrypted_data = params.get("encrypted", "")
                if encrypted_data:
                    data = encryptor.decrypt(encrypted_data)
                else:
                    data = params
            else:
                data = params
        
        # 解密请求数据
        user_id = None
        if settings.ENCRYPT_ENABLED and isinstance(data, dict):
            encrypted_data = data.get("encrypted", "")
            if encrypted_data:
                decrypted = encryptor.decrypt(encrypted_data)
                user_id = decrypted.get("user_id")
        elif isinstance(data, dict):
            user_id = data.get("user_id")
            if user_id:
                try:
                    user_id = int(user_id)
                except:
                    pass
        
        if not user_id:
            return {"code": 400, "msg": "缺少用户ID"}
        
        # 查找Steam账号
        account = db.query(SteamAccount).filter(SteamAccount.id == account_id).first()
        if not account:
            return {"code": 404, "msg": "Steam账号不存在"}
        
        # 验证用户ID是否匹配
        if account.user_id != user_id:
            return {"code": 403, "msg": "无权访问该账号"}
        
        # 删除账号
        db.delete(account)
        db.commit()
        
        logger.info(f"用户 {user_id} 删除Steam账号成功: {account_id}")
        return {
            "code": 200,
            "msg": "删除成功"
        }
        
    except Exception as e:
        db.rollback()
        logger.error(f"删除Steam账号失败: {e}")
        return {"code": 500, "msg": "删除失败"}