xiamuceer
811 lines
26 KiB
Python
811 lines
26 KiB
Python
"""
|
|
设置管理 API
|
|
"""
|
|
from fastapi import APIRouter, HTTPException, Request, Depends
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import select
|
|
from typing import Dict, Any, List, Optional
|
|
from pathlib import Path
|
|
from pydantic import BaseModel
|
|
from datetime import datetime
|
|
import httpx
|
|
import json
|
|
import time
|
|
|
|
from app.database import get_db
|
|
from app.models.settings import Settings
|
|
from app.schemas.settings import (
|
|
SettingsCreate, SettingsUpdate, SettingsResponse,
|
|
APIKeyPreset, APIKeyPresetConfig, PresetCreateRequest,
|
|
PresetUpdateRequest, PresetResponse, PresetListResponse
|
|
)
|
|
from app.user_manager import User
|
|
from app.logger import get_logger
|
|
from app.config import settings as app_settings, PROJECT_ROOT
|
|
from app.services.ai_service import AIService, create_user_ai_service
|
|
|
|
logger = get_logger(__name__)
|
|
|
|
router = APIRouter(prefix="/settings", tags=["设置管理"])
|
|
|
|
|
|
def read_env_defaults() -> Dict[str, Any]:
|
|
"""从.env文件读取默认配置（仅读取，不修改）"""
|
|
return {
|
|
"api_provider": app_settings.default_ai_provider,
|
|
"api_key": app_settings.openai_api_key or app_settings.anthropic_api_key or "",
|
|
"api_base_url": app_settings.openai_base_url or app_settings.anthropic_base_url or "",
|
|
"llm_model": app_settings.default_model,
|
|
"temperature": app_settings.default_temperature,
|
|
"max_tokens": app_settings.default_max_tokens,
|
|
}
|
|
|
|
|
|
def require_login(request: Request):
|
|
"""依赖：要求用户已登录"""
|
|
if not hasattr(request.state, "user") or not request.state.user:
|
|
raise HTTPException(status_code=401, detail="需要登录")
|
|
return request.state.user
|
|
|
|
|
|
async def get_user_ai_service(
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
) -> AIService:
|
|
"""
|
|
依赖：获取当前用户的AI服务实例
|
|
从数据库读取用户设置并创建对应的AI服务
|
|
"""
|
|
result = await db.execute(
|
|
select(Settings).where(Settings.user_id == user.user_id)
|
|
)
|
|
settings = result.scalar_one_or_none()
|
|
|
|
if not settings:
|
|
# 如果用户没有设置，从.env读取并保存
|
|
env_defaults = read_env_defaults()
|
|
settings = Settings(
|
|
user_id=user.user_id,
|
|
**env_defaults
|
|
)
|
|
db.add(settings)
|
|
await db.commit()
|
|
await db.refresh(settings)
|
|
logger.info(f"用户 {user.user_id} 首次使用AI服务，已从.env同步设置到数据库")
|
|
|
|
# 使用用户设置创建AI服务实例（包括系统提示词）
|
|
return create_user_ai_service(
|
|
api_provider=settings.api_provider,
|
|
api_key=settings.api_key,
|
|
api_base_url=settings.api_base_url or "",
|
|
model_name=settings.llm_model,
|
|
temperature=settings.temperature,
|
|
max_tokens=settings.max_tokens,
|
|
system_prompt=settings.system_prompt # 传递系统提示词
|
|
)
|
|
|
|
|
|
@router.get("", response_model=SettingsResponse)
|
|
async def get_settings(
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
获取当前用户的设置
|
|
如果用户没有保存过设置，自动从.env创建并保存到数据库
|
|
"""
|
|
result = await db.execute(
|
|
select(Settings).where(Settings.user_id == user.user_id)
|
|
)
|
|
settings = result.scalar_one_or_none()
|
|
|
|
if not settings:
|
|
# 如果用户没有保存过设置，从.env读取默认配置并保存到数据库
|
|
env_defaults = read_env_defaults()
|
|
logger.info(f"用户 {user.user_id} 首次获取设置，自动从.env同步到数据库")
|
|
|
|
# 创建新设置并保存到数据库
|
|
settings = Settings(
|
|
user_id=user.user_id,
|
|
**env_defaults
|
|
)
|
|
db.add(settings)
|
|
await db.commit()
|
|
await db.refresh(settings)
|
|
logger.info(f"用户 {user.user_id} 的设置已从.env同步到数据库")
|
|
|
|
logger.info(f"用户 {user.user_id} 获取已保存的设置")
|
|
return settings
|
|
|
|
|
|
@router.post("", response_model=SettingsResponse)
|
|
async def save_settings(
|
|
data: SettingsCreate,
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
创建或更新当前用户的设置（Upsert）
|
|
如果设置已存在则更新，否则创建新设置
|
|
仅保存到数据库
|
|
"""
|
|
# 查找现有设置
|
|
result = await db.execute(
|
|
select(Settings).where(Settings.user_id == user.user_id)
|
|
)
|
|
settings = result.scalar_one_or_none()
|
|
|
|
# 准备数据
|
|
settings_dict = data.model_dump(exclude_unset=True)
|
|
|
|
if settings:
|
|
# 更新现有设置
|
|
for key, value in settings_dict.items():
|
|
setattr(settings, key, value)
|
|
|
|
await db.commit()
|
|
await db.refresh(settings)
|
|
logger.info(f"用户 {user.user_id} 更新设置")
|
|
else:
|
|
# 创建新设置
|
|
settings = Settings(
|
|
user_id=user.user_id,
|
|
**settings_dict
|
|
)
|
|
db.add(settings)
|
|
await db.commit()
|
|
await db.refresh(settings)
|
|
logger.info(f"用户 {user.user_id} 创建设置")
|
|
|
|
return settings
|
|
|
|
|
|
@router.put("", response_model=SettingsResponse)
|
|
async def update_settings(
|
|
data: SettingsUpdate,
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
更新当前用户的设置
|
|
仅保存到数据库
|
|
"""
|
|
result = await db.execute(
|
|
select(Settings).where(Settings.user_id == user.user_id)
|
|
)
|
|
settings = result.scalar_one_or_none()
|
|
|
|
if not settings:
|
|
raise HTTPException(status_code=404, detail="设置不存在，请先创建设置")
|
|
|
|
# 更新设置
|
|
update_data = data.model_dump(exclude_unset=True)
|
|
for key, value in update_data.items():
|
|
setattr(settings, key, value)
|
|
|
|
await db.commit()
|
|
await db.refresh(settings)
|
|
logger.info(f"用户 {user.user_id} 更新设置")
|
|
|
|
return settings
|
|
|
|
|
|
@router.delete("")
|
|
async def delete_settings(
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
删除当前用户的设置
|
|
"""
|
|
result = await db.execute(
|
|
select(Settings).where(Settings.user_id == user.user_id)
|
|
)
|
|
settings = result.scalar_one_or_none()
|
|
|
|
if not settings:
|
|
raise HTTPException(status_code=404, detail="设置不存在")
|
|
|
|
await db.delete(settings)
|
|
await db.commit()
|
|
logger.info(f"用户 {user.user_id} 删除设置")
|
|
|
|
return {"message": "设置已删除", "user_id": user.user_id}
|
|
|
|
|
|
@router.get("/models")
|
|
async def get_available_models(
|
|
api_key: str,
|
|
api_base_url: str,
|
|
provider: str = "openai"
|
|
):
|
|
"""
|
|
从配置的 API 获取可用的模型列表
|
|
|
|
Args:
|
|
api_key: API 密钥
|
|
api_base_url: API 基础 URL
|
|
provider: API 提供商 (openai, anthropic, azure, custom)
|
|
|
|
Returns:
|
|
模型列表
|
|
"""
|
|
try:
|
|
async with httpx.AsyncClient(timeout=10.0) as client:
|
|
if provider == "openai" or provider == "azure" or provider == "custom":
|
|
# OpenAI 兼容接口获取模型列表
|
|
url = f"{api_base_url.rstrip('/')}/models"
|
|
headers = {
|
|
"Authorization": f"Bearer {api_key}",
|
|
"Content-Type": "application/json"
|
|
}
|
|
|
|
logger.info(f"正在从 {url} 获取模型列表")
|
|
response = await client.get(url, headers=headers)
|
|
response.raise_for_status()
|
|
|
|
data = response.json()
|
|
models = []
|
|
|
|
if "data" in data and isinstance(data["data"], list):
|
|
for model in data["data"]:
|
|
model_id = model.get("id", "")
|
|
# 返回所有模型，不进行过滤
|
|
if model_id:
|
|
models.append({
|
|
"value": model_id,
|
|
"label": model_id,
|
|
"description": model.get("description", "") or f"Created: {model.get('created', 'N/A')}"
|
|
})
|
|
|
|
if not models:
|
|
raise HTTPException(
|
|
status_code=404,
|
|
detail="未能从 API 获取到可用的模型列表"
|
|
)
|
|
|
|
logger.info(f"成功获取 {len(models)} 个模型")
|
|
return {
|
|
"provider": provider,
|
|
"models": models,
|
|
"count": len(models)
|
|
}
|
|
|
|
elif provider == "anthropic":
|
|
# Anthropic models API
|
|
url = f"{api_base_url.rstrip('/')}/v1/models"
|
|
headers = {"x-api-key": api_key, "anthropic-version": "2023-06-01"}
|
|
response = await client.get(url, headers=headers)
|
|
response.raise_for_status()
|
|
data = response.json()
|
|
models = [{"value": m["id"], "label": m["id"], "description": m.get("display_name", "")} for m in data.get("data", [])]
|
|
return {"provider": provider, "models": models, "count": len(models)}
|
|
|
|
elif provider == "gemini":
|
|
# Gemini models API
|
|
url = f"{api_base_url.rstrip('/')}/models?key={api_key}"
|
|
response = await client.get(url)
|
|
response.raise_for_status()
|
|
data = response.json()
|
|
models = []
|
|
for m in data.get("models", []):
|
|
if "generateContent" in m.get("supportedGenerationMethods", []):
|
|
mid = m.get("name", "").replace("models/", "")
|
|
models.append({"value": mid, "label": m.get("displayName", mid), "description": ""})
|
|
return {"provider": provider, "models": models, "count": len(models)}
|
|
|
|
else:
|
|
raise HTTPException(status_code=400, detail=f"不支持的提供商: {provider}")
|
|
|
|
except httpx.HTTPStatusError as e:
|
|
logger.error(f"获取模型列表失败 (HTTP {e.response.status_code}): {e.response.text}")
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"无法从 API 获取模型列表 (HTTP {e.response.status_code})"
|
|
)
|
|
except httpx.RequestError as e:
|
|
logger.error(f"请求模型列表失败: {str(e)}")
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"无法连接到 API: {str(e)}"
|
|
)
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"获取模型列表时发生错误: {str(e)}")
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"获取模型列表失败: {str(e)}"
|
|
)
|
|
|
|
|
|
class ApiTestRequest(BaseModel):
|
|
"""API 测试请求模型"""
|
|
api_key: str
|
|
api_base_url: str
|
|
provider: str
|
|
llm_model: str
|
|
|
|
|
|
@router.post("/test")
|
|
async def test_api_connection(data: ApiTestRequest):
|
|
"""
|
|
测试 API 连接和配置是否正确
|
|
|
|
Args:
|
|
data: 包含 API 配置的请求数据
|
|
|
|
Returns:
|
|
测试结果包含状态、响应时间和详细信息
|
|
"""
|
|
api_key = data.api_key
|
|
api_base_url = data.api_base_url
|
|
provider = data.provider
|
|
llm_model = data.llm_model
|
|
import time
|
|
|
|
try:
|
|
start_time = time.time()
|
|
|
|
# 创建临时 AI 服务实例
|
|
test_service = AIService(
|
|
api_provider=provider,
|
|
api_key=api_key,
|
|
api_base_url=api_base_url,
|
|
default_model=llm_model,
|
|
default_temperature=0.7,
|
|
default_max_tokens=100
|
|
)
|
|
|
|
# 发送简单的测试请求
|
|
test_prompt = "请用一句话回复：测试成功"
|
|
|
|
logger.info(f"🧪 开始测试 API 连接")
|
|
logger.info(f" - 提供商: {provider}")
|
|
logger.info(f" - 模型: {llm_model}")
|
|
logger.info(f" - Base URL: {api_base_url}")
|
|
|
|
response = await test_service.generate_text(
|
|
prompt=test_prompt,
|
|
provider=provider,
|
|
model=llm_model,
|
|
temperature=0.7,
|
|
max_tokens=8000
|
|
)
|
|
|
|
end_time = time.time()
|
|
response_time = round((end_time - start_time) * 1000, 2) # 转换为毫秒
|
|
|
|
logger.info(f"✅ API 测试成功")
|
|
logger.info(f" - 响应时间: {response_time}ms")
|
|
|
|
# 安全地处理响应内容（确保是字符串）
|
|
response_str = str(response) if response else 'N/A'
|
|
logger.info(f" - 响应内容: {response_str[:100]}")
|
|
|
|
return {
|
|
"success": True,
|
|
"message": "API 连接测试成功",
|
|
"response_time_ms": response_time,
|
|
"provider": provider,
|
|
"model": llm_model,
|
|
"response_preview": response_str[:100] if len(response_str) > 100 else response_str,
|
|
"details": {
|
|
"api_available": True,
|
|
"model_accessible": True,
|
|
"response_valid": bool(response)
|
|
}
|
|
}
|
|
|
|
except ValueError as e:
|
|
# 配置错误
|
|
error_msg = str(e)
|
|
logger.error(f"❌ API 配置错误: {error_msg}")
|
|
return {
|
|
"success": False,
|
|
"message": "API 配置错误",
|
|
"error": error_msg,
|
|
"error_type": "ConfigurationError",
|
|
"suggestions": [
|
|
"请检查 API Key 是否正确",
|
|
"请确认 API Base URL 格式正确",
|
|
"请验证所选提供商是否匹配"
|
|
]
|
|
}
|
|
|
|
except TimeoutError as e:
|
|
# 超时错误
|
|
error_msg = str(e)
|
|
logger.error(f"❌ API 请求超时: {error_msg}")
|
|
return {
|
|
"success": False,
|
|
"message": "API 请求超时",
|
|
"error": error_msg,
|
|
"error_type": "TimeoutError",
|
|
"suggestions": [
|
|
"请检查网络连接",
|
|
"请确认 API Base URL 是否可访问",
|
|
"如果使用代理，请检查代理设置"
|
|
]
|
|
}
|
|
|
|
except Exception as e:
|
|
# 其他错误
|
|
error_msg = str(e)
|
|
error_type = type(e).__name__
|
|
|
|
logger.error(f"❌ API 测试失败: {error_msg}")
|
|
logger.error(f" - 错误类型: {error_type}")
|
|
|
|
# 分析错误原因并提供建议
|
|
suggestions = []
|
|
if "blocked" in error_msg.lower():
|
|
suggestions = [
|
|
"请求被 API 提供商阻止",
|
|
"可能原因：API Key 被限制或地区限制",
|
|
"建议：检查 API Key 状态和账户余额",
|
|
"建议：尝试更换 API Base URL 或使用代理"
|
|
]
|
|
elif "unauthorized" in error_msg.lower() or "401" in error_msg:
|
|
suggestions = [
|
|
"API Key 认证失败",
|
|
"建议：检查 API Key 是否正确",
|
|
"建议：确认 API Key 是否过期"
|
|
]
|
|
elif "not found" in error_msg.lower() or "404" in error_msg:
|
|
suggestions = [
|
|
"API 端点不存在或模型不可用",
|
|
"建议：检查 API Base URL 是否正确",
|
|
"建议：确认模型名称是否正确"
|
|
]
|
|
elif "rate limit" in error_msg.lower() or "429" in error_msg:
|
|
suggestions = [
|
|
"API 请求频率超限",
|
|
"建议：稍后重试",
|
|
"建议：升级 API 套餐"
|
|
]
|
|
elif "insufficient" in error_msg.lower() or "quota" in error_msg.lower():
|
|
suggestions = [
|
|
"API 配额不足",
|
|
"建议：检查账户余额",
|
|
"建议：充值或升级套餐"
|
|
]
|
|
else:
|
|
suggestions = [
|
|
"请检查所有配置参数是否正确",
|
|
"请确认网络连接正常",
|
|
"请查看详细错误信息"
|
|
]
|
|
|
|
return {
|
|
"success": False,
|
|
"message": "API 测试失败",
|
|
"error": error_msg,
|
|
"error_type": error_type,
|
|
"suggestions": suggestions
|
|
}
|
|
|
|
|
|
# ========== API配置预设管理（零数据库改动方案）==========
|
|
|
|
async def get_user_settings(user_id: str, db: AsyncSession) -> Settings:
|
|
"""获取用户settings，如果不存在则创建"""
|
|
result = await db.execute(
|
|
select(Settings).where(Settings.user_id == user_id)
|
|
)
|
|
settings = result.scalar_one_or_none()
|
|
|
|
if not settings:
|
|
# 创建默认设置
|
|
env_defaults = read_env_defaults()
|
|
settings = Settings(
|
|
user_id=user_id,
|
|
**env_defaults,
|
|
preferences='{}' # 初始化为空JSON
|
|
)
|
|
db.add(settings)
|
|
await db.commit()
|
|
await db.refresh(settings)
|
|
logger.info(f"用户 {user_id} 首次访问，已创建默认设置")
|
|
|
|
return settings
|
|
|
|
|
|
@router.get("/presets", response_model=PresetListResponse)
|
|
async def get_presets(
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
获取所有API配置预设
|
|
|
|
从preferences字段读取预设列表
|
|
"""
|
|
settings = await get_user_settings(user.user_id, db)
|
|
|
|
# 解析preferences
|
|
try:
|
|
prefs = json.loads(settings.preferences or '{}')
|
|
except json.JSONDecodeError:
|
|
logger.warning(f"用户 {user.user_id} 的preferences字段JSON格式错误，重置为空")
|
|
prefs = {}
|
|
|
|
api_presets = prefs.get('api_presets', {'presets': [], 'version': '1.0'})
|
|
presets = api_presets.get('presets', [])
|
|
|
|
# 找到激活的预设
|
|
active_preset_id = next(
|
|
(p['id'] for p in presets if p.get('is_active')),
|
|
None
|
|
)
|
|
|
|
logger.info(f"用户 {user.user_id} 获取预设列表，共 {len(presets)} 个")
|
|
|
|
return {
|
|
"presets": presets,
|
|
"total": len(presets),
|
|
"active_preset_id": active_preset_id
|
|
}
|
|
|
|
|
|
@router.post("/presets", response_model=PresetResponse)
|
|
async def create_preset(
|
|
data: PresetCreateRequest,
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
创建新预设
|
|
|
|
将预设添加到preferences字段的JSON中
|
|
"""
|
|
settings = await get_user_settings(user.user_id, db)
|
|
|
|
# 解析preferences
|
|
try:
|
|
prefs = json.loads(settings.preferences or '{}')
|
|
except json.JSONDecodeError:
|
|
prefs = {}
|
|
|
|
api_presets = prefs.get('api_presets', {'presets': [], 'version': '1.0'})
|
|
presets = api_presets.get('presets', [])
|
|
|
|
# 创建新预设
|
|
new_preset = {
|
|
"id": f"preset_{int(datetime.now().timestamp() * 1000)}",
|
|
"name": data.name,
|
|
"description": data.description,
|
|
"is_active": False,
|
|
"created_at": datetime.now().isoformat(),
|
|
"config": data.config.model_dump()
|
|
}
|
|
|
|
presets.append(new_preset)
|
|
|
|
# 保存回preferences
|
|
api_presets['presets'] = presets
|
|
prefs['api_presets'] = api_presets
|
|
settings.preferences = json.dumps(prefs, ensure_ascii=False)
|
|
|
|
await db.commit()
|
|
|
|
logger.info(f"用户 {user.user_id} 创建预设: {data.name}")
|
|
return new_preset
|
|
|
|
|
|
@router.put("/presets/{preset_id}", response_model=PresetResponse)
|
|
async def update_preset(
|
|
preset_id: str,
|
|
data: PresetUpdateRequest,
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
更新预设
|
|
|
|
在preferences字段的JSON中更新指定预设
|
|
"""
|
|
settings = await get_user_settings(user.user_id, db)
|
|
|
|
# 解析preferences
|
|
try:
|
|
prefs = json.loads(settings.preferences or '{}')
|
|
except json.JSONDecodeError:
|
|
raise HTTPException(status_code=500, detail="配置数据格式错误")
|
|
|
|
api_presets = prefs.get('api_presets', {'presets': [], 'version': '1.0'})
|
|
presets = api_presets.get('presets', [])
|
|
|
|
# 找到并更新预设
|
|
target_preset = next((p for p in presets if p['id'] == preset_id), None)
|
|
if not target_preset:
|
|
raise HTTPException(status_code=404, detail="预设不存在")
|
|
|
|
# 更新字段
|
|
if data.name is not None:
|
|
target_preset['name'] = data.name
|
|
if data.description is not None:
|
|
target_preset['description'] = data.description
|
|
if data.config is not None:
|
|
target_preset['config'] = data.config.model_dump()
|
|
|
|
# 保存回preferences
|
|
prefs['api_presets'] = api_presets
|
|
settings.preferences = json.dumps(prefs, ensure_ascii=False)
|
|
|
|
await db.commit()
|
|
|
|
logger.info(f"用户 {user.user_id} 更新预设: {preset_id}")
|
|
return target_preset
|
|
|
|
|
|
@router.delete("/presets/{preset_id}")
|
|
async def delete_preset(
|
|
preset_id: str,
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
删除预设
|
|
|
|
从preferences字段的JSON中删除指定预设
|
|
"""
|
|
settings = await get_user_settings(user.user_id, db)
|
|
|
|
# 解析preferences
|
|
try:
|
|
prefs = json.loads(settings.preferences or '{}')
|
|
except json.JSONDecodeError:
|
|
raise HTTPException(status_code=500, detail="配置数据格式错误")
|
|
|
|
api_presets = prefs.get('api_presets', {'presets': [], 'version': '1.0'})
|
|
presets = api_presets.get('presets', [])
|
|
|
|
# 找到预设
|
|
target_preset = next((p for p in presets if p['id'] == preset_id), None)
|
|
if not target_preset:
|
|
raise HTTPException(status_code=404, detail="预设不存在")
|
|
|
|
# 检查是否是激活的预设
|
|
if target_preset.get('is_active'):
|
|
raise HTTPException(status_code=400, detail="无法删除激活中的预设，请先激活其他预设")
|
|
|
|
# 删除预设
|
|
presets = [p for p in presets if p['id'] != preset_id]
|
|
|
|
# 保存回preferences
|
|
api_presets['presets'] = presets
|
|
prefs['api_presets'] = api_presets
|
|
settings.preferences = json.dumps(prefs, ensure_ascii=False)
|
|
|
|
await db.commit()
|
|
|
|
logger.info(f"用户 {user.user_id} 删除预设: {preset_id}")
|
|
return {"message": "预设已删除", "preset_id": preset_id}
|
|
|
|
|
|
@router.post("/presets/{preset_id}/activate")
|
|
async def activate_preset(
|
|
preset_id: str,
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
激活预设
|
|
|
|
将预设的配置应用到Settings主字段
|
|
"""
|
|
settings = await get_user_settings(user.user_id, db)
|
|
|
|
# 解析preferences
|
|
try:
|
|
prefs = json.loads(settings.preferences or '{}')
|
|
except json.JSONDecodeError:
|
|
raise HTTPException(status_code=500, detail="配置数据格式错误")
|
|
|
|
api_presets = prefs.get('api_presets', {'presets': [], 'version': '1.0'})
|
|
presets = api_presets.get('presets', [])
|
|
|
|
# 找到目标预设
|
|
target_preset = next((p for p in presets if p['id'] == preset_id), None)
|
|
if not target_preset:
|
|
raise HTTPException(status_code=404, detail="预设不存在")
|
|
|
|
# 应用配置到Settings主字段
|
|
config = target_preset['config']
|
|
settings.api_provider = config['api_provider']
|
|
settings.api_key = config['api_key']
|
|
settings.api_base_url = config.get('api_base_url')
|
|
settings.llm_model = config['llm_model']
|
|
settings.temperature = config['temperature']
|
|
settings.max_tokens = config['max_tokens']
|
|
|
|
# 更新所有预设的is_active状态
|
|
for preset in presets:
|
|
preset['is_active'] = (preset['id'] == preset_id)
|
|
|
|
# 保存回preferences
|
|
prefs['api_presets'] = api_presets
|
|
settings.preferences = json.dumps(prefs, ensure_ascii=False)
|
|
|
|
await db.commit()
|
|
|
|
logger.info(f"用户 {user.user_id} 激活预设: {target_preset['name']}")
|
|
return {
|
|
"message": "预设已激活",
|
|
"preset_id": preset_id,
|
|
"preset_name": target_preset['name']
|
|
}
|
|
|
|
|
|
@router.post("/presets/{preset_id}/test")
|
|
async def test_preset(
|
|
preset_id: str,
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
测试预设的API连接
|
|
"""
|
|
settings = await get_user_settings(user.user_id, db)
|
|
|
|
# 解析preferences
|
|
try:
|
|
prefs = json.loads(settings.preferences or '{}')
|
|
except json.JSONDecodeError:
|
|
raise HTTPException(status_code=500, detail="配置数据格式错误")
|
|
|
|
api_presets = prefs.get('api_presets', {'presets': [], 'version': '1.0'})
|
|
presets = api_presets.get('presets', [])
|
|
|
|
# 找到预设
|
|
target_preset = next((p for p in presets if p['id'] == preset_id), None)
|
|
if not target_preset:
|
|
raise HTTPException(status_code=404, detail="预设不存在")
|
|
|
|
# 使用现有的test_api_connection逻辑
|
|
config = target_preset['config']
|
|
test_request = ApiTestRequest(
|
|
api_key=config['api_key'],
|
|
api_base_url=config.get('api_base_url', ''),
|
|
provider=config['api_provider'],
|
|
llm_model=config['llm_model']
|
|
)
|
|
|
|
logger.info(f"用户 {user.user_id} 测试预设: {target_preset['name']}")
|
|
return await test_api_connection(test_request)
|
|
|
|
|
|
@router.post("/presets/from-current", response_model=PresetResponse)
|
|
async def create_preset_from_current(
|
|
name: str,
|
|
description: Optional[str] = None,
|
|
user: User = Depends(require_login),
|
|
db: AsyncSession = Depends(get_db)
|
|
):
|
|
"""
|
|
从当前配置创建新预设
|
|
|
|
快捷方式：将当前激活的配置保存为新预设
|
|
"""
|
|
settings = await get_user_settings(user.user_id, db)
|
|
|
|
# 从当前Settings主字段读取配置
|
|
current_config = APIKeyPresetConfig(
|
|
api_provider=settings.api_provider,
|
|
api_key=settings.api_key,
|
|
api_base_url=settings.api_base_url,
|
|
llm_model=settings.llm_model,
|
|
temperature=settings.temperature,
|
|
max_tokens=settings.max_tokens
|
|
)
|
|
|
|
# 创建预设
|
|
create_request = PresetCreateRequest(
|
|
name=name,
|
|
description=description,
|
|
config=current_config
|
|
)
|
|
|
|
logger.info(f"用户 {user.user_id} 从当前配置创建预设: {name}")
|
|
return await create_preset(create_request, user, db) |