Kamixitong/api_test_app_mysql.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
FastAPI接口测试应用 (MySQL版本)
提供所有管理功能的API接口测试页面，直接使用MySQL数据库
"""

import os
import sys
import pymysql
from datetime import datetime, timedelta
from typing import List, Optional
from pydantic import BaseModel

from fastapi import FastAPI, HTTPException, Depends, status
from fastapi.middleware.cors import CORSMiddleware

# 添加项目根目录到Python路径
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

# 导入配置
from config import Config

# 解析数据库URL
def parse_database_url(url):
    """解析数据库URL"""
    # 格式: mysql+pymysql://user:password@host:port/database
    try:
        # 移除mysql+pymysql://前缀
        url = url.replace('mysql+pymysql://', '')
        
        # 找到@符号前的用户名密码
        at_index = url.index('@')
        user_pass = url[:at_index]
        url = url[at_index + 1:]
        
        # 分割用户名和密码
        user, password = user_pass.split(':', 1)
        
        # 找到数据库名
        if '/' in url:
            host_port, database = url.split('/', 1)
            # 提取端口
            if ':' in host_port:
                host, port = host_port.split(':', 1)
            else:
                host = host_port
                port = '3306'
        else:
            raise ValueError("URL格式不正确")
        
        return {
            'user': user,
            'password': password,
            'host': host,
            'port': port,
            'database': database
        }
    except Exception as e:
        print(f"无法解析数据库URL: {e}")
        return None

# 获取数据库连接
def get_db_connection():
    """获取MySQL数据库连接"""
    db_config = parse_database_url(Config.SQLALCHEMY_DATABASE_URI)
    if not db_config:
        raise Exception("无法解析数据库配置")
    
    connection = pymysql.connect(
        host=db_config['host'],
        port=int(db_config['port']),
        user=db_config['user'],
        password=db_config['password'],
        database=db_config['database'],
        charset='utf8mb4',
        cursorclass=pymysql.cursors.DictCursor
    )
    return connection

# 创建FastAPI应用
app = FastAPI(
    title="KaMiXiTong API测试平台 (MySQL版)",
    description="软件授权管理系统的完整API接口测试平台，使用MySQL数据库",
    version="1.0.0",
    docs_url="/docs",
    redoc_url="/redoc"
)

# 添加CORS中间件
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# ==================== 用户管理模型 ====================
class AdminBase(BaseModel):
    username: str
    email: Optional[str] = None
    role: Optional[int] = 0  # 0=普通管理员, 1=超级管理员
    status: Optional[int] = 1  # 0=禁用, 1=正常

    class Config:
        from_attributes = True

class AdminCreate(AdminBase):
    password: str

class AdminUpdate(AdminBase):
    password: Optional[str] = None

class AdminInDB(AdminBase):
    admin_id: int
    create_time: datetime
    update_time: datetime

# ==================== 工单管理模型 ====================
class TicketBase(BaseModel):
    title: str
    product_id: str
    description: str
    priority: Optional[int] = 1  # 1=低, 2=中, 3=高
    status: Optional[int] = 0    # 0=待处理, 1=处理中, 2=已解决, 3=已关闭

    class Config:
        from_attributes = True

class TicketCreate(TicketBase):
    software_version: Optional[str] = None
    machine_code: Optional[str] = None
    license_key: Optional[str] = None

class TicketUpdate(TicketBase):
    pass

class TicketInDB(TicketBase):
    ticket_id: int
    create_time: datetime
    update_time: datetime

# ==================== 卡密管理模型 ====================
class LicenseBase(BaseModel):
    product_id: str
    type: int = 1  # 0=试用, 1=正式
    status: Optional[int] = 0  # 0=未使用, 1=已使用, 2=已过期, 3=已禁用
    valid_days: Optional[int] = 365

    class Config:
        from_attributes = True

class LicenseCreate(LicenseBase):
    count: int = 1
    prefix: Optional[str] = ""
    length: Optional[int] = 32

class LicenseUpdate(LicenseBase):
    pass

class LicenseInDB(LicenseBase):
    license_id: int
    license_key: str
    create_time: datetime
    update_time: datetime
    expire_time: Optional[datetime] = None

# ==================== 版本管理模型 ====================
class VersionBase(BaseModel):
    product_id: str
    version_num: str
    platform: Optional[str] = ""
    description: Optional[str] = ""
    update_log: Optional[str] = ""
    download_url: Optional[str] = ""
    file_hash: Optional[str] = ""
    force_update: Optional[int] = 0
    download_status: Optional[int] = 1  # 0=下架, 1=上架
    min_license_version: Optional[str] = ""
    publish_status: Optional[int] = 0   # 0=未发布, 1=已发布

    class Config:
        from_attributes = True

class VersionCreate(VersionBase):
    publish_now: Optional[bool] = False

class VersionUpdate(VersionBase):
    pass

class VersionInDB(VersionBase):
    version_id: int
    create_time: datetime
    update_time: datetime

# ==================== 设备管理模型 ====================
class DeviceBase(BaseModel):
    product_id: str
    machine_code: str
    software_version: Optional[str] = ""
    status: Optional[int] = 1  # 0=禁用, 1=正常, 2=黑名单

    class Config:
        from_attributes = True

class DeviceCreate(DeviceBase):
    license_key: Optional[str] = None

class DeviceUpdate(DeviceBase):
    pass

class DeviceInDB(DeviceBase):
    device_id: int
    create_time: datetime
    last_verify_time: Optional[datetime] = None

# ==================== 产品管理模型 ====================
class ProductBase(BaseModel):
    product_name: str
    description: Optional[str] = ""
    status: Optional[int] = 1  # 0=禁用, 1=正常

    class Config:
        from_attributes = True

class ProductCreate(ProductBase):
    product_id: Optional[str] = None

class ProductUpdate(ProductBase):
    pass

class ProductInDB(ProductBase):
    product_id: str
    create_time: datetime
    update_time: datetime

# ==================== 用户管理接口 ====================
@app.get("/")
async def root():
    return {"message": "欢迎使用KaMiXiTong API测试平台 (MySQL版)", "version": "1.0.0"}

@app.get("/admins", response_model=List[AdminInDB])
async def get_admins(
    skip: int = 0, 
    limit: int = 100, 
    keyword: Optional[str] = None,
    role: Optional[int] = None,
    status: Optional[int] = None
):
    """获取管理员列表"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 构建查询
            sql = "SELECT * FROM admin WHERE is_deleted = 0"
            params = []
            
            if keyword:
                sql += " AND username LIKE %s"
                params.append(f"%{keyword}%")
            
            if role is not None:
                sql += " AND role = %s"
                params.append(role)
                
            if status is not None:
                sql += " AND status = %s"
                params.append(status)
            
            sql += " ORDER BY create_time DESC LIMIT %s OFFSET %s"
            params.extend([limit, skip])
            
            cursor.execute(sql, params)
            admins = cursor.fetchall()
            
        connection.close()
        return admins
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"数据库查询失败: {str(e)}")

@app.post("/admins", response_model=AdminInDB)
async def create_admin(admin: AdminCreate):
    """创建管理员"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查用户名是否已存在
            cursor.execute(
                "SELECT admin_id FROM admin WHERE username = %s AND is_deleted = 0",
                (admin.username,)
            )
            existing = cursor.fetchone()
            
            if existing:
                raise HTTPException(status_code=400, detail="用户名已存在")
            
            # 创建管理员（简化密码处理）
            sql = """
                INSERT INTO admin (username, email, password_hash, role, status, create_time, update_time)
                VALUES (%s, %s, %s, %s, %s, %s, %s)
            """
            params = (
                admin.username,
                admin.email,
                f"hashed_{admin.password}",  # 简化处理
                admin.role,
                admin.status,
                datetime.utcnow(),
                datetime.utcnow()
            )
            
            cursor.execute(sql, params)
            admin_id = cursor.lastrowid
            
            connection.commit()
            
            # 查询创建的管理员
            cursor.execute("SELECT * FROM admin WHERE admin_id = %s", (admin_id,))
            created_admin = cursor.fetchone()
            
        connection.close()
        return created_admin
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"创建管理员失败: {str(e)}")

@app.get("/admins/{admin_id}", response_model=AdminInDB)
async def get_admin(admin_id: int):
    """获取管理员详情"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            cursor.execute(
                "SELECT * FROM admin WHERE admin_id = %s AND is_deleted = 0",
                (admin_id,)
            )
            admin = cursor.fetchone()
            
        connection.close()
        
        if not admin:
            raise HTTPException(status_code=404, detail="管理员不存在")
        return admin
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"查询管理员失败: {str(e)}")

@app.put("/admins/{admin_id}", response_model=AdminInDB)
async def update_admin(admin_id: int, admin: AdminUpdate):
    """更新管理员"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查管理员是否存在
            cursor.execute(
                "SELECT * FROM admin WHERE admin_id = %s AND is_deleted = 0",
                (admin_id,)
            )
            existing_admin = cursor.fetchone()
            
            if not existing_admin:
                raise HTTPException(status_code=404, detail="管理员不存在")
            
            # 检查新用户名是否已存在
            if admin.username and admin.username != existing_admin['username']:
                cursor.execute(
                    "SELECT admin_id FROM admin WHERE username = %s AND admin_id != %s AND is_deleted = 0",
                    (admin.username, admin_id)
                )
                duplicate = cursor.fetchone()
                
                if duplicate:
                    raise HTTPException(status_code=400, detail="用户名已存在")
            
            # 更新字段
            updates = []
            params = []
            
            if admin.username is not None:
                updates.append("username = %s")
                params.append(admin.username)
            if admin.email is not None:
                updates.append("email = %s")
                params.append(admin.email)
            if admin.role is not None:
                updates.append("role = %s")
                params.append(admin.role)
            if admin.status is not None:
                updates.append("status = %s")
                params.append(admin.status)
            if admin.password:
                updates.append("password_hash = %s")
                params.append(f"hashed_{admin.password}")  # 简化处理
            if updates:
                updates.append("update_time = %s")
                params.append(datetime.utcnow())
                params.append(admin_id)
                
                sql = f"UPDATE admin SET {', '.join(updates)} WHERE admin_id = %s"
                cursor.execute(sql, params)
                connection.commit()
            
            # 查询更新后的管理员
            cursor.execute("SELECT * FROM admin WHERE admin_id = %s", (admin_id,))
            updated_admin = cursor.fetchone()
            
        connection.close()
        return updated_admin
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"更新管理员失败: {str(e)}")

@app.delete("/admins/{admin_id}")
async def delete_admin(admin_id: int):
    """删除管理员（软删除）"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查管理员是否存在
            cursor.execute(
                "SELECT admin_id FROM admin WHERE admin_id = %s AND is_deleted = 0",
                (admin_id,)
            )
            admin = cursor.fetchone()
            
            if not admin:
                raise HTTPException(status_code=404, detail="管理员不存在")
            
            # 软删除
            cursor.execute(
                "UPDATE admin SET is_deleted = 1, delete_time = %s WHERE admin_id = %s",
                (datetime.utcnow(), admin_id)
            )
            connection.commit()
            
        connection.close()
        return {"message": "管理员删除成功"}
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"删除管理员失败: {str(e)}")

@app.post("/admins/{admin_id}/toggle-status")
async def toggle_admin_status(admin_id: int):
    """切换管理员状态"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查管理员是否存在
            cursor.execute(
                "SELECT * FROM admin WHERE admin_id = %s AND is_deleted = 0",
                (admin_id,)
            )
            admin = cursor.fetchone()
            
            if not admin:
                raise HTTPException(status_code=404, detail="管理员不存在")
            
            # 切换状态
            new_status = 0 if admin['status'] == 1 else 1
            cursor.execute(
                "UPDATE admin SET status = %s, update_time = %s WHERE admin_id = %s",
                (new_status, datetime.utcnow(), admin_id)
            )
            connection.commit()
            
            # 查询更新后的管理员
            cursor.execute("SELECT * FROM admin WHERE admin_id = %s", (admin_id,))
            updated_admin = cursor.fetchone()
            
        connection.close()
        
        status_name = "正常" if updated_admin['status'] == 1 else "禁用"
        action = "启用" if updated_admin['status'] == 1 else "禁用"
        return {"message": f"管理员已{action}", "status": updated_admin['status'], "status_name": status_name}
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"切换管理员状态失败: {str(e)}")

# ==================== 工单管理接口 ====================
@app.get("/tickets", response_model=List[TicketInDB])
async def get_tickets(
    skip: int = 0, 
    limit: int = 100, 
    status: Optional[int] = None,
    priority: Optional[int] = None,
    product_id: Optional[str] = None
):
    """获取工单列表"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 构建查询
            sql = "SELECT * FROM ticket"
            params = []
            conditions = []
            
            if status is not None:
                conditions.append("status = %s")
                params.append(status)
            if priority is not None:
                conditions.append("priority = %s")
                params.append(priority)
            if product_id:
                conditions.append("product_id = %s")
                params.append(product_id)
            
            if conditions:
                sql += " WHERE " + " AND ".join(conditions)
            
            sql += " ORDER BY create_time DESC LIMIT %s OFFSET %s"
            params.extend([limit, skip])
            
            cursor.execute(sql, params)
            tickets = cursor.fetchall()
            
        connection.close()
        return tickets
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"查询工单失败: {str(e)}")

@app.post("/tickets", response_model=TicketInDB)
async def create_ticket(ticket: TicketCreate):
    """创建工单"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 创建工单
            sql = """
                INSERT INTO ticket (title, product_id, software_version, machine_code, 
                                  license_key, description, priority, status, create_time, update_time)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
            """
            params = (
                ticket.title,
                ticket.product_id,
                ticket.software_version,
                ticket.machine_code,
                ticket.license_key,
                ticket.description,
                ticket.priority,
                ticket.status,
                datetime.utcnow(),
                datetime.utcnow()
            )
            
            cursor.execute(sql, params)
            ticket_id = cursor.lastrowid
            
            connection.commit()
            
            # 查询创建的工单
            cursor.execute("SELECT * FROM ticket WHERE ticket_id = %s", (ticket_id,))
            created_ticket = cursor.fetchone()
            
        connection.close()
        return created_ticket
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"创建工单失败: {str(e)}")

# ==================== 卡密管理接口 ====================
@app.get("/licenses", response_model=List[LicenseInDB])
async def get_licenses(
    skip: int = 0, 
    limit: int = 100, 
    product_id: Optional[str] = None,
    status: Optional[int] = None,
    license_type: Optional[int] = None,
    keyword: Optional[str] = None
):
    """获取卡密列表"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 构建查询
            sql = "SELECT * FROM license"
            params = []
            conditions = []
            
            if product_id:
                conditions.append("product_id = %s")
                params.append(product_id)
            if status is not None:
                conditions.append("status = %s")
                params.append(status)
            if license_type is not None:
                conditions.append("type = %s")
                params.append(license_type)
            if keyword:
                conditions.append("license_key LIKE %s")
                params.append(f"%{keyword}%")
            
            if conditions:
                sql += " WHERE " + " AND ".join(conditions)
            
            sql += " ORDER BY create_time DESC LIMIT %s OFFSET %s"
            params.extend([limit, skip])
            
            cursor.execute(sql, params)
            licenses = cursor.fetchall()
            
        connection.close()
        return licenses
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"查询卡密失败: {str(e)}")

@app.post("/licenses", response_model=dict)
async def generate_licenses(license: LicenseCreate):
    """批量生成卡密"""
    try:
        # 验证参数
        if license.count < 1 or license.count > 10000:
            raise HTTPException(status_code=400, detail="生成数量必须在1-10000之间")
        
        if license.length < 16 or license.length > 35:
            raise HTTPException(status_code=400, detail="卡密长度必须在16-35之间")
        
        # 试用卡密最大有效期限制
        if license.type == 0 and license.valid_days and license.valid_days > 90:
            raise HTTPException(status_code=400, detail="试用卡密有效期不能超过90天")
        
        # 生成卡密
        import secrets
        import string
        
        connection = get_db_connection()
        with connection.cursor() as cursor:
            licenses = []
            characters = string.ascii_uppercase + string.digits
            
            for i in range(license.count):
                # 生成卡密
                key = license.prefix + ''.join(secrets.choice(characters) for _ in range(license.length - len(license.prefix)))
                
                # 确保卡密唯一
                max_attempts = 10
                for attempt in range(max_attempts):
                    cursor.execute("SELECT license_id FROM license WHERE license_key = %s", (key,))
                    existing = cursor.fetchone()
                    if not existing:
                        break
                    key = license.prefix + ''.join(secrets.choice(characters) for _ in range(license.length - len(license.prefix)))
                else:
                    raise HTTPException(status_code=500, detail="无法生成唯一的卡密，请稍后重试")
                
                # 计算过期时间
                expire_time = None
                if license.valid_days:
                    expire_time = datetime.utcnow() + timedelta(days=license.valid_days)
                
                # 创建卡密
                sql = """
                    INSERT INTO license (product_id, license_key, type, status, create_time, update_time, expire_time)
                    VALUES (%s, %s, %s, %s, %s, %s, %s)
                """
                params = (
                    license.product_id,
                    key,
                    license.type,
                    0,  # 未使用
                    datetime.utcnow(),
                    datetime.utcnow(),
                    expire_time
                )
                
                cursor.execute(sql, params)
                license_id = cursor.lastrowid
                
                # 查询创建的卡密
                cursor.execute("SELECT * FROM license WHERE license_id = %s", (license_id,))
                created_license = cursor.fetchone()
                licenses.append(created_license)
            
            connection.commit()
            
        connection.close()
        
        return {
            "message": f"成功生成 {license.count} 个卡密",
            "licenses": licenses,
            "count": len(licenses)
        }
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"生成卡密失败: {str(e)}")

# ==================== 版本管理接口 ====================
@app.get("/versions", response_model=List[VersionInDB])
async def get_versions(
    skip: int = 0, 
    limit: int = 100, 
    product_id: Optional[str] = None,
    publish_status: Optional[int] = None
):
    """获取版本列表"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 构建查询
            sql = "SELECT * FROM version"
            params = []
            conditions = []
            
            if product_id:
                conditions.append("product_id = %s")
                params.append(product_id)
            if publish_status is not None:
                conditions.append("publish_status = %s")
                params.append(publish_status)
            
            if conditions:
                sql += " WHERE " + " AND ".join(conditions)
            
            sql += " ORDER BY create_time DESC LIMIT %s OFFSET %s"
            params.extend([limit, skip])
            
            cursor.execute(sql, params)
            versions = cursor.fetchall()
            
        connection.close()
        return versions
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"查询版本失败: {str(e)}")

@app.post("/versions", response_model=VersionInDB)
async def create_version(version: VersionCreate):
    """创建版本"""
    try:
        # 验证参数
        if not version.product_id or not version.version_num:
            raise HTTPException(status_code=400, detail="缺少必要参数")
        
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查版本号是否重复
            cursor.execute(
                "SELECT version_id FROM version WHERE product_id = %s AND version_num = %s",
                (version.product_id, version.version_num)
            )
            existing = cursor.fetchone()
            
            if existing:
                raise HTTPException(status_code=400, detail="版本号已存在")
            
            # 创建版本
            sql = """
                INSERT INTO version (product_id, version_num, platform, description, update_log,
                                   download_url, file_hash, force_update, download_status,
                                   min_license_version, publish_status, create_time, update_time)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
            """
            params = (
                version.product_id,
                version.version_num,
                version.platform,
                version.description,
                version.update_log,
                version.download_url,
                version.file_hash,
                version.force_update,
                version.download_status,
                version.min_license_version,
                version.publish_status,
                datetime.utcnow(),
                datetime.utcnow()
            )
            
            cursor.execute(sql, params)
            version_id = cursor.lastrowid
            
            connection.commit()
            
            # 如果选择了立即发布，则发布版本
            if version.publish_now:
                cursor.execute(
                    "UPDATE version SET publish_status = 1, update_time = %s WHERE version_id = %s",
                    (datetime.utcnow(), version_id)
                )
                connection.commit()
            
            # 查询创建的版本
            cursor.execute("SELECT * FROM version WHERE version_id = %s", (version_id,))
            created_version = cursor.fetchone()
            
        connection.close()
        return created_version
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"创建版本失败: {str(e)}")

@app.post("/versions/{version_id}/publish")
async def publish_version(version_id: int):
    """发布版本"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查版本是否存在
            cursor.execute("SELECT * FROM version WHERE version_id = %s", (version_id,))
            version = cursor.fetchone()
            
            if not version:
                raise HTTPException(status_code=404, detail="版本不存在")
            
            # 发布版本
            cursor.execute(
                "UPDATE version SET publish_status = 1, update_time = %s WHERE version_id = %s",
                (datetime.utcnow(), version_id)
            )
            connection.commit()
            
            # 查询更新后的版本
            cursor.execute("SELECT * FROM version WHERE version_id = %s", (version_id,))
            updated_version = cursor.fetchone()
            
        connection.close()
        return {"message": "版本发布成功", "version": updated_version}
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"发布版本失败: {str(e)}")

# ==================== 设备管理接口 ====================
@app.get("/devices", response_model=List[DeviceInDB])
async def get_devices(
    skip: int = 0, 
    limit: int = 100, 
    product_id: Optional[str] = None,
    software_version: Optional[str] = None,
    status: Optional[int] = None,
    keyword: Optional[str] = None
):
    """获取设备列表"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 构建查询
            sql = "SELECT * FROM device"
            params = []
            conditions = []
            
            if product_id:
                conditions.append("product_id = %s")
                params.append(product_id)
            if software_version:
                conditions.append("software_version = %s")
                params.append(software_version)
            if status is not None:
                conditions.append("status = %s")
                params.append(status)
            if keyword:
                conditions.append("machine_code LIKE %s")
                params.append(f"%{keyword}%")
            
            if conditions:
                sql += " WHERE " + " AND ".join(conditions)
            
            sql += " ORDER BY last_verify_time DESC LIMIT %s OFFSET %s"
            params.extend([limit, skip])
            
            cursor.execute(sql, params)
            devices = cursor.fetchall()
            
        connection.close()
        return devices
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"查询设备失败: {str(e)}")

@app.put("/devices/{device_id}/status")
async def update_device_status(device_id: int, status: int):
    """更新设备状态"""
    if status not in [0, 1, 2]:
        raise HTTPException(status_code=400, detail="无效的状态值")
    
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查设备是否存在
            cursor.execute("SELECT * FROM device WHERE device_id = %s", (device_id,))
            device = cursor.fetchone()
            
            if not device:
                raise HTTPException(status_code=404, detail="设备不存在")
            
            # 更新设备状态
            cursor.execute(
                "UPDATE device SET status = %s, last_verify_time = %s WHERE device_id = %s",
                (status, datetime.utcnow(), device_id)
            )
            connection.commit()
            
            # 查询更新后的设备
            cursor.execute("SELECT * FROM device WHERE device_id = %s", (device_id,))
            updated_device = cursor.fetchone()
            
        connection.close()
        return {"message": "设备状态更新成功", "device": updated_device}
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"更新设备状态失败: {str(e)}")

@app.delete("/devices/{device_id}")
async def delete_device(device_id: int):
    """删除设备"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查设备是否存在
            cursor.execute("SELECT device_id FROM device WHERE device_id = %s", (device_id,))
            device = cursor.fetchone()
            
            if not device:
                raise HTTPException(status_code=404, detail="设备不存在")
            
            # 删除设备
            cursor.execute("DELETE FROM device WHERE device_id = %s", (device_id,))
            connection.commit()
            
        connection.close()
        return {"message": "设备删除成功"}
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"删除设备失败: {str(e)}")

# ==================== 产品管理接口 ====================
@app.get("/products", response_model=List[ProductInDB])
async def get_products(
    skip: int = 0, 
    limit: int = 100, 
    keyword: Optional[str] = None
):
    """获取产品列表"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 构建查询
            sql = "SELECT * FROM product"
            params = []
            conditions = []
            
            if keyword:
                conditions.append("(product_name LIKE %s OR description LIKE %s)")
                params.extend([f"%{keyword}%", f"%{keyword}%"])
            
            if conditions:
                sql += " WHERE " + " AND ".join(conditions)
            
            sql += " ORDER BY create_time DESC LIMIT %s OFFSET %s"
            params.extend([limit, skip])
            
            cursor.execute(sql, params)
            products = cursor.fetchall()
            
        connection.close()
        return products
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"查询产品失败: {str(e)}")

@app.post("/products", response_model=ProductInDB)
async def create_product(product: ProductCreate):
    """创建产品"""
    if not product.product_name.strip():
        raise HTTPException(status_code=400, detail="产品名称不能为空")
    
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查自定义ID是否重复
            if product.product_id:
                cursor.execute(
                    "SELECT product_id FROM product WHERE product_id = %s",
                    (product.product_id,)
                )
                existing = cursor.fetchone()
                if existing:
                    raise HTTPException(status_code=400, detail="产品ID已存在")
            
            # 创建产品
            import uuid
            product_id = product.product_id if product.product_id else f"PROD_{uuid.uuid4().hex[:8]}".upper()
            
            sql = """
                INSERT INTO product (product_id, product_name, description, status, create_time, update_time)
                VALUES (%s, %s, %s, %s, %s, %s)
            """
            params = (
                product_id,
                product.product_name,
                product.description,
                product.status,
                datetime.utcnow(),
                datetime.utcnow()
            )
            
            cursor.execute(sql, params)
            connection.commit()
            
            # 查询创建的产品
            cursor.execute("SELECT * FROM product WHERE product_id = %s", (product_id,))
            created_product = cursor.fetchone()
            
        connection.close()
        return created_product
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"创建产品失败: {str(e)}")

@app.get("/products/{product_id}", response_model=ProductInDB)
async def get_product(product_id: str):
    """获取产品详情"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            cursor.execute("SELECT * FROM product WHERE product_id = %s", (product_id,))
            product = cursor.fetchone()
            
        connection.close()
        
        if not product:
            raise HTTPException(status_code=404, detail="产品不存在")
        return product
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"查询产品失败: {str(e)}")

@app.put("/products/{product_id}", response_model=ProductInDB)
async def update_product(product_id: str, product: ProductUpdate):
    """更新产品"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查产品是否存在
            cursor.execute("SELECT * FROM product WHERE product_id = %s", (product_id,))
            existing_product = cursor.fetchone()
            
            if not existing_product:
                raise HTTPException(status_code=404, detail="产品不存在")
            
            # 更新字段
            updates = []
            params = []
            
            if product.product_name is not None:
                updates.append("product_name = %s")
                params.append(product.product_name)
            if product.description is not None:
                updates.append("description = %s")
                params.append(product.description)
            if product.status is not None:
                updates.append("status = %s")
                params.append(product.status)
            
            if updates:
                updates.append("update_time = %s")
                params.append(datetime.utcnow())
                params.append(product_id)
                
                sql = f"UPDATE product SET {', '.join(updates)} WHERE product_id = %s"
                cursor.execute(sql, params)
                connection.commit()
            
            # 查询更新后的产品
            cursor.execute("SELECT * FROM product WHERE product_id = %s", (product_id,))
            updated_product = cursor.fetchone()
            
        connection.close()
        return updated_product
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"更新产品失败: {str(e)}")

@app.delete("/products/{product_id}")
async def delete_product(product_id: str):
    """删除产品"""
    try:
        connection = get_db_connection()
        with connection.cursor() as cursor:
            # 检查产品是否存在
            cursor.execute("SELECT product_id FROM product WHERE product_id = %s", (product_id,))
            product = cursor.fetchone()
            
            if not product:
                raise HTTPException(status_code=404, detail="产品不存在")
            
            # 删除产品
            cursor.execute("DELETE FROM product WHERE product_id = %s", (product_id,))
            connection.commit()
            
        connection.close()
        return {"message": "产品删除成功"}
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"删除产品失败: {str(e)}")

if __name__ == "__main__":
    import uvicorn
    # 使用127.0.0.1而不是0.0.0.0来避免权限问题
    uvicorn.run(app, host="127.0.0.1", port=9004, log_level="info")