LokiStack/backend/controllers/ai.go

package controllers

import (
	"fmt"
	"strconv"
	"time"

	"lokistack/models"
	"lokistack/services"
	"lokistack/utils"

	"github.com/gin-gonic/gin"
)

// AIController AIOps：模型配置 + 日志分析 + 审计历史
type AIController struct{}

func NewAIController() *AIController { return &AIController{} }

// GetConfig 返回模型配置（APIKey 掩码）+ 今日已用 token。
func (ctrl *AIController) GetConfig(c *gin.Context) {
	userID := c.GetUint("userId")
	cfg := services.MaskedAIConfig()
	utils.Success(c, gin.H{
		"config":         cfg,
		"tokenUsedToday": services.AITokenUsedToday(userID),
	})
}

// SaveConfig 保存模型配置。apiKey 传空或掩码 = 沿用旧值。
func (ctrl *AIController) SaveConfig(c *gin.Context) {
	var req struct {
		models.AIConfig
		APIKey string `json:"apiKey"`
	}
	if !utils.BindAndValidate(c, &req) {
		return
	}
	if err := services.SaveAIConfig(req.AIConfig, req.APIKey); err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, gin.H{"config": services.MaskedAIConfig()})
}

// TestConfig 连通性测试：用已保存（或本次提交）的配置发一句最小请求。
func (ctrl *AIController) TestConfig(c *gin.Context) {
	var req struct {
		APIKey  string `json:"apiKey"`
		BaseURL string `json:"baseUrl"`
		Model   string `json:"model"`
	}
	_ = c.ShouldBindJSON(&req)

	cfg := services.GetAIConfig()
	if req.BaseURL != "" {
		cfg.BaseURL = req.BaseURL
	}
	if req.Model != "" {
		cfg.Model = req.Model
	}
	// 传了新的 key 就用新的（掩码/空则沿用已保存的）
	if req.APIKey != "" && !containsMask(req.APIKey) {
		cfg.APIKey = req.APIKey
	}

	reply, err := services.TestAIConnection(cfg)
	if err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, gin.H{"reply": reply, "model": cfg.Model})
}

func containsMask(s string) bool {
	for i := 0; i+2 < len(s); i++ {
		if s[i] == '*' && s[i+1] == '*' && s[i+2] == '*' {
			return true
		}
	}
	return false
}

// Analyze 执行一次日志分析。
//
// 时间范围在服务端收敛：最大 24 小时。理由不是性能（P0 全走索引，很快），
// 而是"范围越大，信号越笼统，结论越没用"，且 token 会线性增长。
func (ctrl *AIController) Analyze(c *gin.Context) {
	var req struct {
		SourceID uint   `json:"sourceId" binding:"required"`
		Start    int64  `json:"start" binding:"required"`
		End      int64  `json:"end" binding:"required"`
		Question string `json:"question"`
		App      string `json:"app"`
	}
	if !utils.BindAndValidate(c, &req) {
		return
	}
	src := services.GetLogSource(req.SourceID)
	if src == nil {
		utils.BadRequest(c, "数据源不存在")
		return
	}
	from := time.Unix(0, req.Start)
	to := time.Unix(0, req.End)
	if !to.After(from) {
		utils.BadRequest(c, "时间范围无效：结束时间必须晚于开始时间")
		return
	}
	if to.Sub(from) > 24*time.Hour {
		utils.BadRequest(c, fmt.Sprintf("时间范围过大（%d 分钟）：AI 分析最多支持 24 小时，建议用 15~60 分钟", int(to.Sub(from).Minutes())))
		return
	}
	// 长窗口必须指定应用:全命名空间聚合在 6h/24h 下数据量过大,查询会拖垮 Loki
	if to.Sub(from) > time.Hour && req.App == "" {
		utils.BadRequest(c, "超过 1 小时的分析必须指定应用(app):全命名空间长窗口聚合过慢,请先在应用排行里选一个 app 缩小范围")
		return
	}

	userID := c.GetUint("userId")
	username := c.GetString("username")
	admin := c.GetString("role") == "admin"

	cfg := services.GetAIConfig()
	outcome, err := services.RunAIAnalysis(c.Request.Context(), cfg, src, userID, username, admin, from, to, req.Question, req.App)
	if err != nil {
		// 未配置模型 / 配额用尽 / 上游报错：都给出具体原因，不包装成 500
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, outcome)
}

// ListRuns 审计历史（分页）。
func (ctrl *AIController) ListRuns(c *gin.Context) {
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "20"))
	runs, total := services.ListAIRuns(page, pageSize)
	utils.Success(c, gin.H{"list": runs, "total": total, "page": page, "pageSize": pageSize})
}

// GetRun 单条审计详情（含脱敏后的完整 payload）。
func (ctrl *AIController) GetRun(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	run := services.GetAIRun(uint(id))
	if run == nil {
		utils.Error(c, 404, "记录不存在")
		return
	}
	utils.Success(c, run)
}