Fix Services & Update the middleware && others

internal/service/log_service.go

@@ -1,78 +1,152 @@
-// Filename: internal/service/log_service.go
 package service
 
 import (
+	"context"
+	"fmt"
 	"gemini-balancer/internal/models"
 	"strconv"
 
-	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
 	"gorm.io/gorm"
 )
 
 type LogService struct {
-	db *gorm.DB
+	db     *gorm.DB
+	logger *logrus.Entry
 }
 
-func NewLogService(db *gorm.DB) *LogService {
-	return &LogService{db: db}
+func NewLogService(db *gorm.DB, logger *logrus.Logger) *LogService {
+	return &LogService{
+		db:     db,
+		logger: logger.WithField("component", "LogService"),
+	}
 }
 
-func (s *LogService) Record(log *models.RequestLog) error {
-	return s.db.Create(log).Error
+func (s *LogService) Record(ctx context.Context, log *models.RequestLog) error {
+	return s.db.WithContext(ctx).Create(log).Error
 }
 
-func (s *LogService) GetLogs(c *gin.Context) ([]models.RequestLog, int64, error) {
+// LogQueryParams 解耦 Gin，使用结构体传参
+type LogQueryParams struct {
+	Page       int
+	PageSize   int
+	ModelName  string
+	IsSuccess  *bool // 使用指针区分"未设置"和"false"
+	StatusCode *int
+	KeyID      *uint64
+	GroupID    *uint64
+}
+
+func (s *LogService) GetLogs(ctx context.Context, params LogQueryParams) ([]models.RequestLog, int64, error) {
+	// 参数校验
+	if params.Page < 1 {
+		params.Page = 1
+	}
+	if params.PageSize < 1 || params.PageSize > 100 {
+		params.PageSize = 20
+	}
+
 	var logs []models.RequestLog
 	var total int64
 
-	query := s.db.Model(&models.RequestLog{}).Scopes(s.filtersScope(c))
+	// 构建基础查询
+	query := s.db.WithContext(ctx).Model(&models.RequestLog{})
+	query = s.applyFilters(query, params)
 
-	// 先计算总数
+	// 计算总数
 	if err := query.Count(&total).Error; err != nil {
-		return nil, 0, err
+		return nil, 0, fmt.Errorf("failed to count logs: %w", err)
 	}
+
 	if total == 0 {
 		return []models.RequestLog{}, 0, nil
 	}
 
-	// 再执行分页查询
-	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
-	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
-	offset := (page - 1) * pageSize
-
-	err := query.Order("request_time desc").Limit(pageSize).Offset(offset).Find(&logs).Error
-	if err != nil {
-		return nil, 0, err
+	// 分页查询
+	offset := (params.Page - 1) * params.PageSize
+	if err := query.Order("request_time DESC").
+		Limit(params.PageSize).
+		Offset(offset).
+		Find(&logs).Error; err != nil {
+		return nil, 0, fmt.Errorf("failed to query logs: %w", err)
 	}
 
 	return logs, total, nil
 }
 
-func (s *LogService) filtersScope(c *gin.Context) func(db *gorm.DB) *gorm.DB {
-	return func(db *gorm.DB) *gorm.DB {
-		if modelName := c.Query("model_name"); modelName != "" {
-			db = db.Where("model_name = ?", modelName)
-		}
-		if isSuccessStr := c.Query("is_success"); isSuccessStr != "" {
-			if isSuccess, err := strconv.ParseBool(isSuccessStr); err == nil {
-				db = db.Where("is_success = ?", isSuccess)
-			}
-		}
-		if statusCodeStr := c.Query("status_code"); statusCodeStr != "" {
-			if statusCode, err := strconv.Atoi(statusCodeStr); err == nil {
-				db = db.Where("status_code = ?", statusCode)
-			}
-		}
-		if keyIDStr := c.Query("key_id"); keyIDStr != "" {
-			if keyID, err := strconv.ParseUint(keyIDStr, 10, 64); err == nil {
-				db = db.Where("key_id = ?", keyID)
-			}
-		}
-		if groupIDStr := c.Query("group_id"); groupIDStr != "" {
-			if groupID, err := strconv.ParseUint(groupIDStr, 10, 64); err == nil {
-				db = db.Where("group_id = ?", groupID)
-			}
-		}
-		return db
+func (s *LogService) applyFilters(query *gorm.DB, params LogQueryParams) *gorm.DB {
+	if params.ModelName != "" {
+		query = query.Where("model_name = ?", params.ModelName)
 	}
+	if params.IsSuccess != nil {
+		query = query.Where("is_success = ?", *params.IsSuccess)
+	}
+	if params.StatusCode != nil {
+		query = query.Where("status_code = ?", *params.StatusCode)
+	}
+	if params.KeyID != nil {
+		query = query.Where("key_id = ?", *params.KeyID)
+	}
+	if params.GroupID != nil {
+		query = query.Where("group_id = ?", *params.GroupID)
+	}
+	return query
+}
+
+// ParseLogQueryParams 在 Handler 层调用，解析 Gin 参数
+func ParseLogQueryParams(queryParams map[string]string) (LogQueryParams, error) {
+	params := LogQueryParams{
+		Page:     1,
+		PageSize: 20,
+	}
+
+	if pageStr, ok := queryParams["page"]; ok {
+		if page, err := strconv.Atoi(pageStr); err == nil && page > 0 {
+			params.Page = page
+		}
+	}
+
+	if pageSizeStr, ok := queryParams["page_size"]; ok {
+		if pageSize, err := strconv.Atoi(pageSizeStr); err == nil && pageSize > 0 {
+			params.PageSize = pageSize
+		}
+	}
+
+	if modelName, ok := queryParams["model_name"]; ok {
+		params.ModelName = modelName
+	}
+
+	if isSuccessStr, ok := queryParams["is_success"]; ok {
+		if isSuccess, err := strconv.ParseBool(isSuccessStr); err == nil {
+			params.IsSuccess = &isSuccess
+		} else {
+			return params, fmt.Errorf("invalid is_success parameter: %s", isSuccessStr)
+		}
+	}
+
+	if statusCodeStr, ok := queryParams["status_code"]; ok {
+		if statusCode, err := strconv.Atoi(statusCodeStr); err == nil {
+			params.StatusCode = &statusCode
+		} else {
+			return params, fmt.Errorf("invalid status_code parameter: %s", statusCodeStr)
+		}
+	}
+
+	if keyIDStr, ok := queryParams["key_id"]; ok {
+		if keyID, err := strconv.ParseUint(keyIDStr, 10, 64); err == nil {
+			params.KeyID = &keyID
+		} else {
+			return params, fmt.Errorf("invalid key_id parameter: %s", keyIDStr)
+		}
+	}
+
+	if groupIDStr, ok := queryParams["group_id"]; ok {
+		if groupID, err := strconv.ParseUint(groupIDStr, 10, 64); err == nil {
+			params.GroupID = &groupID
+		} else {
+			return params, fmt.Errorf("invalid group_id parameter: %s", groupIDStr)
+		}
+	}
+
+	return params, nil
 }