添加ai支持

This commit is contained in:
2026-06-10 16:04:42 +08:00
parent 51f3f917f9
commit cd03cdc44a
15 changed files with 2159 additions and 3 deletions
+457
View File
@@ -0,0 +1,457 @@
package routers
import (
"errors"
"ops/models"
"sync"
"time"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type TabAIChatSetting struct {
ID uint `gorm:"primaryKey;autoIncrement"`
Enabled bool `gorm:"default:false;index"`
CreatedAt *time.Time `gorm:"type:datetime;autoCreateTime"`
UpdatedAt *time.Time `gorm:"type:datetime;autoUpdateTime"`
}
type TabAIChatOpenAIProfile struct {
ID uint `gorm:"primaryKey;autoIncrement"`
Name string `gorm:"size:100;not null;uniqueIndex"`
Active bool `gorm:"default:false;index"`
ApiKey string `gorm:"type:text"`
BaseUrl string `gorm:"size:500"`
Model string `gorm:"size:200"`
Timeout int `gorm:"default:120"`
MaxTokens int `gorm:"default:4096"`
SystemPrompt string `gorm:"type:text"`
SortOrder int `gorm:"default:0;index"`
CreatedAt *time.Time `gorm:"type:datetime;autoCreateTime"`
UpdatedAt *time.Time `gorm:"type:datetime;autoUpdateTime"`
}
type TabAIChatToolRouter struct {
ID uint `gorm:"primaryKey;autoIncrement"`
Enabled bool `gorm:"default:true"`
OpenAIName string `gorm:"size:100;index"`
Timeout int `gorm:"default:30"`
MaxTokens int `gorm:"default:512"`
CreatedAt *time.Time `gorm:"type:datetime;autoCreateTime"`
UpdatedAt *time.Time `gorm:"type:datetime;autoUpdateTime"`
}
type TabAIChatTool struct {
ID uint `gorm:"primaryKey;autoIncrement"`
Name string `gorm:"size:100;not null;uniqueIndex"`
Enabled bool `gorm:"default:true;index"`
Description string `gorm:"type:text"`
SortOrder int `gorm:"default:0;index"`
CreatedAt *time.Time `gorm:"type:datetime;autoCreateTime"`
UpdatedAt *time.Time `gorm:"type:datetime;autoUpdateTime"`
}
var aiChatConfigMu sync.RWMutex
func ApiAIChatInit() {
err := models.DB.AutoMigrate(
&TabAIChatSetting{},
&TabAIChatOpenAIProfile{},
&TabAIChatToolRouter{},
&TabAIChatTool{},
)
if err != nil {
panic(err)
}
if err := seedAIChatConfigFromYAMLIfEmpty(); err != nil {
panic(err)
}
if err := RefreshAIChatConfigCache(); err != nil {
panic(err)
}
}
func seedAIChatConfigFromYAMLIfEmpty() error {
var settingCount int64
var profileCount int64
models.DB.Model(&TabAIChatSetting{}).Count(&settingCount)
models.DB.Model(&TabAIChatOpenAIProfile{}).Count(&profileCount)
if settingCount > 0 || profileCount > 0 {
return nil
}
cfg := models.ConfigsAIChat
return models.DB.Transaction(func(tx *gorm.DB) error {
if err := tx.Create(&TabAIChatSetting{ID: 1, Enabled: cfg.Enabled}).Error; err != nil {
return err
}
profiles := cfg.OpenAI
if len(profiles) == 0 {
profiles = []models.ConfigsAIChatOpenAI_{{
Name: "default",
Active: true,
BaseUrl: "https://ark.cn-beijing.volces.com/api/v3",
Timeout: 120,
MaxTokens: 4096,
SystemPrompt: "你是一个有帮助的 AI 助手。",
}}
}
for i, profile := range profiles {
if profile.Name == "" {
profile.Name = "default"
}
if profile.Timeout <= 0 {
profile.Timeout = 120
}
if profile.MaxTokens <= 0 {
profile.MaxTokens = 4096
}
if err := tx.Create(&TabAIChatOpenAIProfile{
Name: profile.Name,
Active: profile.Active,
ApiKey: profile.ApiKey,
BaseUrl: profile.BaseUrl,
Model: profile.Model,
Timeout: profile.Timeout,
MaxTokens: profile.MaxTokens,
SystemPrompt: profile.SystemPrompt,
SortOrder: i,
}).Error; err != nil {
return err
}
}
toolRouter := cfg.ToolRouter
if toolRouter.Timeout <= 0 {
toolRouter.Timeout = 30
}
if toolRouter.MaxTokens <= 0 {
toolRouter.MaxTokens = 512
}
if toolRouter.OpenAIName == "" && len(profiles) > 0 {
toolRouter.OpenAIName = profiles[0].Name
}
if err := tx.Create(&TabAIChatToolRouter{
ID: 1,
Enabled: toolRouter.Enabled,
OpenAIName: toolRouter.OpenAIName,
Timeout: toolRouter.Timeout,
MaxTokens: toolRouter.MaxTokens,
}).Error; err != nil {
return err
}
tools := toolRouter.Tools
if len(tools) == 0 {
tools = []models.ConfigsAIChatTool_{{Name: "time", Enabled: true, Description: "提供当前日期、时间和相对日期换算。"}}
}
for i, tool := range tools {
if tool.Name == "" {
continue
}
if err := tx.Create(&TabAIChatTool{
Name: tool.Name,
Enabled: tool.Enabled,
Description: tool.Description,
SortOrder: i,
}).Error; err != nil {
return err
}
}
return nil
})
}
func RefreshAIChatConfigCache() error {
var setting TabAIChatSetting
if err := models.DB.First(&setting, 1).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil
}
return err
}
var profiles []TabAIChatOpenAIProfile
if err := models.DB.Order("sort_order asc, id asc").Find(&profiles).Error; err != nil {
return err
}
var toolRouter TabAIChatToolRouter
if err := models.DB.First(&toolRouter, 1).Error; err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return err
}
var tools []TabAIChatTool
if err := models.DB.Order("sort_order asc, id asc").Find(&tools).Error; err != nil {
return err
}
cfg := models.ConfigsAIChat_{
Enabled: setting.Enabled,
OpenAI: make([]models.ConfigsAIChatOpenAI_, 0, len(profiles)),
ToolRouter: models.ConfigsAIChatToolRouter_{
Enabled: toolRouter.Enabled,
OpenAIName: toolRouter.OpenAIName,
Timeout: defaultInt(toolRouter.Timeout, 30),
MaxTokens: defaultInt(toolRouter.MaxTokens, 512),
Tools: make([]models.ConfigsAIChatTool_, 0, len(tools)),
},
}
for _, profile := range profiles {
cfg.OpenAI = append(cfg.OpenAI, models.ConfigsAIChatOpenAI_{
Name: profile.Name,
Active: profile.Active,
ApiKey: profile.ApiKey,
BaseUrl: profile.BaseUrl,
Model: profile.Model,
Timeout: defaultInt(profile.Timeout, 120),
MaxTokens: defaultInt(profile.MaxTokens, 4096),
SystemPrompt: profile.SystemPrompt,
})
}
for _, tool := range tools {
cfg.ToolRouter.Tools = append(cfg.ToolRouter.Tools, models.ConfigsAIChatTool_{
Name: tool.Name,
Enabled: tool.Enabled,
Description: tool.Description,
})
}
aiChatConfigMu.Lock()
models.ConfigsAIChat = cfg
aiChatConfigMu.Unlock()
return nil
}
func getAIChatConfig() models.ConfigsAIChat_ {
aiChatConfigMu.RLock()
defer aiChatConfigMu.RUnlock()
return models.ConfigsAIChat
}
func defaultInt(value int, fallback int) int {
if value <= 0 {
return fallback
}
return value
}
func handleAIChatAdminGetConfig(ctx *gin.Context) {
if ok, _ := requireSysAdmin(ctx); !ok {
return
}
cfg := getAIChatConfig()
ReturnJson(ctx, "apiOK", gin.H{
"enabled": cfg.Enabled,
"openai": maskAIChatProfiles(cfg.OpenAI),
"toolRouter": gin.H{
"enabled": cfg.ToolRouter.Enabled,
"openaiName": cfg.ToolRouter.OpenAIName,
"timeout": cfg.ToolRouter.Timeout,
"maxTokens": cfg.ToolRouter.MaxTokens,
"tools": maskAIChatTools(cfg.ToolRouter.Tools),
},
})
}
func handleAIChatAdminRefreshCache(ctx *gin.Context) {
if ok, _ := requireSysAdmin(ctx); !ok {
return
}
if err := RefreshAIChatConfigCache(); err != nil {
ReturnJson(ctx, "apiErr", gin.H{"error": err.Error()})
return
}
ReturnJson(ctx, "apiOK", nil)
}
func handleAIChatAdminUpdateConfig(ctx *gin.Context) {
ok, data := requireSysAdmin(ctx)
if !ok {
return
}
if data == nil {
ReturnJson(ctx, "apiErr", nil)
return
}
var req models.ConfigsAIChat_
if err := decodeJSON(data, &req); err != nil {
ReturnJson(ctx, "apiErr", gin.H{"error": err.Error()})
return
}
if len(req.OpenAI) == 0 {
ReturnJson(ctx, "apiErr", gin.H{"error": "openai profiles cannot be empty"})
return
}
if err := saveAIChatConfig(req); err != nil {
ReturnJson(ctx, "apiErr", gin.H{"error": err.Error()})
return
}
if err := RefreshAIChatConfigCache(); err != nil {
ReturnJson(ctx, "apiErr", gin.H{"error": err.Error()})
return
}
ReturnJson(ctx, "apiOK", nil)
}
func saveAIChatConfig(req models.ConfigsAIChat_) error {
return models.DB.Transaction(func(tx *gorm.DB) error {
if err := tx.Save(&TabAIChatSetting{ID: 1, Enabled: req.Enabled}).Error; err != nil {
return err
}
var existingProfiles []TabAIChatOpenAIProfile
if err := tx.Find(&existingProfiles).Error; err != nil {
return err
}
existingByName := make(map[string]TabAIChatOpenAIProfile, len(existingProfiles))
for _, profile := range existingProfiles {
existingByName[profile.Name] = profile
}
incomingNames := make(map[string]bool, len(req.OpenAI))
activeSet := false
for i, profile := range req.OpenAI {
if profile.Name == "" {
continue
}
incomingNames[profile.Name] = true
if profile.Timeout <= 0 {
profile.Timeout = 120
}
if profile.MaxTokens <= 0 {
profile.MaxTokens = 4096
}
if profile.Active {
if activeSet {
profile.Active = false
} else {
activeSet = true
}
}
tab := TabAIChatOpenAIProfile{
Name: profile.Name,
Active: profile.Active,
ApiKey: profile.ApiKey,
BaseUrl: profile.BaseUrl,
Model: profile.Model,
Timeout: profile.Timeout,
MaxTokens: profile.MaxTokens,
SystemPrompt: profile.SystemPrompt,
SortOrder: i,
}
if old, ok := existingByName[profile.Name]; ok {
tab.ID = old.ID
if tab.ApiKey == "" {
tab.ApiKey = old.ApiKey
}
}
if err := tx.Save(&tab).Error; err != nil {
return err
}
}
for _, old := range existingProfiles {
if !incomingNames[old.Name] {
if err := tx.Delete(&old).Error; err != nil {
return err
}
}
}
if !activeSet && len(req.OpenAI) > 0 {
if err := tx.Model(&TabAIChatOpenAIProfile{}).Where("name = ?", req.OpenAI[0].Name).Update("active", true).Error; err != nil {
return err
}
}
toolRouter := req.ToolRouter
if toolRouter.Timeout <= 0 {
toolRouter.Timeout = 30
}
if toolRouter.MaxTokens <= 0 {
toolRouter.MaxTokens = 512
}
if err := tx.Save(&TabAIChatToolRouter{ID: 1, Enabled: toolRouter.Enabled, OpenAIName: toolRouter.OpenAIName, Timeout: toolRouter.Timeout, MaxTokens: toolRouter.MaxTokens}).Error; err != nil {
return err
}
var existingTools []TabAIChatTool
if err := tx.Find(&existingTools).Error; err != nil {
return err
}
existingToolByName := make(map[string]TabAIChatTool, len(existingTools))
for _, tool := range existingTools {
existingToolByName[tool.Name] = tool
}
incomingToolNames := make(map[string]bool, len(toolRouter.Tools))
for i, tool := range toolRouter.Tools {
if tool.Name == "" {
continue
}
incomingToolNames[tool.Name] = true
tab := TabAIChatTool{Name: tool.Name, Enabled: tool.Enabled, Description: tool.Description, SortOrder: i}
if old, ok := existingToolByName[tool.Name]; ok {
tab.ID = old.ID
}
if err := tx.Save(&tab).Error; err != nil {
return err
}
}
for _, old := range existingTools {
if !incomingToolNames[old.Name] {
if err := tx.Delete(&old).Error; err != nil {
return err
}
}
}
return nil
})
}
func maskAIChatProfiles(profiles []models.ConfigsAIChatOpenAI_) []gin.H {
items := make([]gin.H, 0, len(profiles))
for _, profile := range profiles {
items = append(items, gin.H{
"name": profile.Name,
"active": profile.Active,
"apiKeySet": profile.ApiKey != "",
"baseUrl": profile.BaseUrl,
"model": profile.Model,
"timeout": profile.Timeout,
"maxTokens": profile.MaxTokens,
"systemPrompt": profile.SystemPrompt,
})
}
return items
}
func maskAIChatTools(tools []models.ConfigsAIChatTool_) []gin.H {
items := make([]gin.H, 0, len(tools))
for _, tool := range tools {
items = append(items, gin.H{
"name": tool.Name,
"enabled": tool.Enabled,
"description": tool.Description,
})
}
return items
}
func requireSysAdmin(ctx *gin.Context) (bool, map[string]interface{}) {
isAuth, user, data := AuthenticationAuthority(ctx)
if !isAuth {
ReturnJson(ctx, "userCookieError", nil)
return false, nil
}
if !SysAdminCheck(user.ID) {
ReturnJson(ctx, "permission_denied", nil)
return false, nil
}
return true, data
}