mirror of
https://github.com/EZ-Api/ez-api.git
synced 2026-01-13 17:47:51 +00:00
5349c9c833
Add admin endpoints to list and revoke child keys under a master. Standardize OpenAPI responses to use ResponseEnvelope with MapData for error payloads, and regenerate swagger specs accordingly.
557 lines
18 KiB
Go
557 lines
18 KiB
Go
package api
|
|
|
|
import (
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/ez-api/ez-api/internal/model"
|
|
"github.com/gin-gonic/gin"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// AlertHandler handles alert-related API endpoints
|
|
type AlertHandler struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
// NewAlertHandler creates a new AlertHandler
|
|
func NewAlertHandler(db *gorm.DB) *AlertHandler {
|
|
return &AlertHandler{db: db}
|
|
}
|
|
|
|
// AlertView represents an alert in API responses
|
|
type AlertView struct {
|
|
ID uint `json:"id"`
|
|
Type string `json:"type"`
|
|
Severity string `json:"severity"`
|
|
Status string `json:"status"`
|
|
Title string `json:"title"`
|
|
Message string `json:"message"`
|
|
RelatedID uint `json:"related_id,omitempty"`
|
|
RelatedType string `json:"related_type,omitempty"`
|
|
RelatedName string `json:"related_name,omitempty"`
|
|
Metadata string `json:"metadata,omitempty"`
|
|
AckedAt *int64 `json:"acked_at,omitempty"`
|
|
AckedBy string `json:"acked_by,omitempty"`
|
|
ResolvedAt *int64 `json:"resolved_at,omitempty"`
|
|
ExpiresAt *int64 `json:"expires_at,omitempty"`
|
|
CreatedAt int64 `json:"created_at"`
|
|
UpdatedAt int64 `json:"updated_at"`
|
|
}
|
|
|
|
func toAlertView(a model.Alert) AlertView {
|
|
view := AlertView{
|
|
ID: a.ID,
|
|
Type: string(a.Type),
|
|
Severity: string(a.Severity),
|
|
Status: string(a.Status),
|
|
Title: a.Title,
|
|
Message: a.Message,
|
|
RelatedID: a.RelatedID,
|
|
RelatedType: a.RelatedType,
|
|
RelatedName: a.RelatedName,
|
|
Metadata: a.Metadata,
|
|
AckedBy: a.AckedBy,
|
|
CreatedAt: a.CreatedAt.UTC().Unix(),
|
|
UpdatedAt: a.UpdatedAt.UTC().Unix(),
|
|
}
|
|
if a.AckedAt != nil {
|
|
ts := a.AckedAt.UTC().Unix()
|
|
view.AckedAt = &ts
|
|
}
|
|
if a.ResolvedAt != nil {
|
|
ts := a.ResolvedAt.UTC().Unix()
|
|
view.ResolvedAt = &ts
|
|
}
|
|
if a.ExpiresAt != nil {
|
|
ts := a.ExpiresAt.UTC().Unix()
|
|
view.ExpiresAt = &ts
|
|
}
|
|
return view
|
|
}
|
|
|
|
// ListAlertsResponse is the response for listing alerts
|
|
type ListAlertsResponse struct {
|
|
Total int64 `json:"total"`
|
|
Limit int `json:"limit"`
|
|
Offset int `json:"offset"`
|
|
Items []AlertView `json:"items"`
|
|
}
|
|
|
|
// ListAlerts godoc
|
|
// @Summary List alerts
|
|
// @Description List system alerts with optional filters
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Param limit query int false "limit (default 50, max 200)"
|
|
// @Param offset query int false "offset"
|
|
// @Param status query string false "filter by status (active, acknowledged, resolved, dismissed)"
|
|
// @Param severity query string false "filter by severity (info, warning, critical)"
|
|
// @Param type query string false "filter by type (rate_limit, error_spike, quota_exceeded, key_disabled, key_expired, provider_down, traffic_spike)"
|
|
// @Success 200 {object} ResponseEnvelope{data=ListAlertsResponse}
|
|
// @Failure 500 {object} ResponseEnvelope{data=MapData}
|
|
// @Router /admin/alerts [get]
|
|
func (h *AlertHandler) ListAlerts(c *gin.Context) {
|
|
limit, offset := parseLimitOffset(c)
|
|
|
|
q := h.db.Model(&model.Alert{}).Order("id desc")
|
|
|
|
if status := strings.TrimSpace(c.Query("status")); status != "" {
|
|
q = q.Where("status = ?", status)
|
|
}
|
|
if severity := strings.TrimSpace(c.Query("severity")); severity != "" {
|
|
q = q.Where("severity = ?", severity)
|
|
}
|
|
if alertType := strings.TrimSpace(c.Query("type")); alertType != "" {
|
|
q = q.Where("type = ?", alertType)
|
|
}
|
|
|
|
var total int64
|
|
if err := q.Count(&total).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to count alerts", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
var alerts []model.Alert
|
|
if err := q.Limit(limit).Offset(offset).Find(&alerts).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list alerts", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
items := make([]AlertView, 0, len(alerts))
|
|
for _, a := range alerts {
|
|
items = append(items, toAlertView(a))
|
|
}
|
|
|
|
c.JSON(http.StatusOK, ListAlertsResponse{
|
|
Total: total,
|
|
Limit: limit,
|
|
Offset: offset,
|
|
Items: items,
|
|
})
|
|
}
|
|
|
|
// GetAlert godoc
|
|
// @Summary Get alert
|
|
// @Description Get a single alert by ID
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Param id path int true "Alert ID"
|
|
// @Success 200 {object} ResponseEnvelope{data=AlertView}
|
|
// @Failure 400 {object} ResponseEnvelope{data=MapData}
|
|
// @Failure 404 {object} ResponseEnvelope{data=MapData}
|
|
// @Router /admin/alerts/{id} [get]
|
|
func (h *AlertHandler) GetAlert(c *gin.Context) {
|
|
id, ok := parseUintParam(c, "id")
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var alert model.Alert
|
|
if err := h.db.First(&alert, id).Error; err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "alert not found"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, toAlertView(alert))
|
|
}
|
|
|
|
// CreateAlertRequest is the request body for creating an alert
|
|
type CreateAlertRequest struct {
|
|
Type string `json:"type" binding:"required"`
|
|
Severity string `json:"severity" binding:"required"`
|
|
Title string `json:"title" binding:"required"`
|
|
Message string `json:"message"`
|
|
RelatedID uint `json:"related_id"`
|
|
RelatedType string `json:"related_type"`
|
|
RelatedName string `json:"related_name"`
|
|
Metadata string `json:"metadata"`
|
|
ExpiresAt *int64 `json:"expires_at"`
|
|
}
|
|
|
|
// CreateAlert godoc
|
|
// @Summary Create alert
|
|
// @Description Create a new system alert
|
|
// @Tags admin
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Param request body CreateAlertRequest true "Alert data"
|
|
// @Success 201 {object} ResponseEnvelope{data=AlertView}
|
|
// @Failure 400 {object} ResponseEnvelope{data=MapData}
|
|
// @Failure 500 {object} ResponseEnvelope{data=MapData}
|
|
// @Router /admin/alerts [post]
|
|
func (h *AlertHandler) CreateAlert(c *gin.Context) {
|
|
var req CreateAlertRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
// Validate type
|
|
validTypes := map[string]bool{
|
|
"rate_limit": true, "error_spike": true, "quota_exceeded": true,
|
|
"key_disabled": true, "key_expired": true, "provider_down": true, "traffic_spike": true,
|
|
}
|
|
if !validTypes[req.Type] {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid alert type"})
|
|
return
|
|
}
|
|
|
|
// Validate severity
|
|
validSeverities := map[string]bool{"info": true, "warning": true, "critical": true}
|
|
if !validSeverities[req.Severity] {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid severity"})
|
|
return
|
|
}
|
|
|
|
alert := model.Alert{
|
|
Type: model.AlertType(req.Type),
|
|
Severity: model.AlertSeverity(req.Severity),
|
|
Status: model.AlertStatusActive,
|
|
Title: strings.TrimSpace(req.Title),
|
|
Message: strings.TrimSpace(req.Message),
|
|
RelatedID: req.RelatedID,
|
|
RelatedType: strings.TrimSpace(req.RelatedType),
|
|
RelatedName: strings.TrimSpace(req.RelatedName),
|
|
Metadata: req.Metadata,
|
|
}
|
|
|
|
if req.ExpiresAt != nil && *req.ExpiresAt > 0 {
|
|
t := time.Unix(*req.ExpiresAt, 0).UTC()
|
|
alert.ExpiresAt = &t
|
|
}
|
|
|
|
if err := h.db.Create(&alert).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create alert", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusCreated, toAlertView(alert))
|
|
}
|
|
|
|
// AckAlertRequest is the request body for acknowledging an alert
|
|
type AckAlertRequest struct {
|
|
AckedBy string `json:"acked_by"`
|
|
}
|
|
|
|
// AcknowledgeAlert godoc
|
|
// @Summary Acknowledge alert
|
|
// @Description Mark an alert as acknowledged
|
|
// @Tags admin
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Param id path int true "Alert ID"
|
|
// @Param request body AckAlertRequest false "Ack data"
|
|
// @Success 200 {object} ResponseEnvelope{data=AlertView}
|
|
// @Failure 400 {object} ResponseEnvelope{data=MapData}
|
|
// @Failure 404 {object} ResponseEnvelope{data=MapData}
|
|
// @Failure 500 {object} ResponseEnvelope{data=MapData}
|
|
// @Router /admin/alerts/{id}/ack [post]
|
|
func (h *AlertHandler) AcknowledgeAlert(c *gin.Context) {
|
|
id, ok := parseUintParam(c, "id")
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var alert model.Alert
|
|
if err := h.db.First(&alert, id).Error; err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "alert not found"})
|
|
return
|
|
}
|
|
|
|
var req AckAlertRequest
|
|
_ = c.ShouldBindJSON(&req)
|
|
|
|
now := time.Now().UTC()
|
|
update := map[string]any{
|
|
"status": model.AlertStatusAcknowledged,
|
|
"acked_at": now,
|
|
"acked_by": strings.TrimSpace(req.AckedBy),
|
|
}
|
|
|
|
if err := h.db.Model(&alert).Updates(update).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to acknowledge alert", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
if err := h.db.First(&alert, id).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to reload alert", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, toAlertView(alert))
|
|
}
|
|
|
|
// ResolveAlert godoc
|
|
// @Summary Resolve alert
|
|
// @Description Mark an alert as resolved
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Param id path int true "Alert ID"
|
|
// @Success 200 {object} ResponseEnvelope{data=AlertView}
|
|
// @Failure 400 {object} ResponseEnvelope{data=MapData}
|
|
// @Failure 404 {object} ResponseEnvelope{data=MapData}
|
|
// @Failure 500 {object} ResponseEnvelope{data=MapData}
|
|
// @Router /admin/alerts/{id}/resolve [post]
|
|
func (h *AlertHandler) ResolveAlert(c *gin.Context) {
|
|
id, ok := parseUintParam(c, "id")
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var alert model.Alert
|
|
if err := h.db.First(&alert, id).Error; err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "alert not found"})
|
|
return
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
update := map[string]any{
|
|
"status": model.AlertStatusResolved,
|
|
"resolved_at": now,
|
|
}
|
|
|
|
if err := h.db.Model(&alert).Updates(update).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to resolve alert", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
if err := h.db.First(&alert, id).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to reload alert", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, toAlertView(alert))
|
|
}
|
|
|
|
// DismissAlert godoc
|
|
// @Summary Dismiss alert
|
|
// @Description Dismiss an alert (soft delete)
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Param id path int true "Alert ID"
|
|
// @Success 200 {object} ResponseEnvelope{data=MapData}
|
|
// @Failure 400 {object} ResponseEnvelope{data=MapData}
|
|
// @Failure 404 {object} ResponseEnvelope{data=MapData}
|
|
// @Failure 500 {object} ResponseEnvelope{data=MapData}
|
|
// @Router /admin/alerts/{id} [delete]
|
|
func (h *AlertHandler) DismissAlert(c *gin.Context) {
|
|
id, ok := parseUintParam(c, "id")
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var alert model.Alert
|
|
if err := h.db.First(&alert, id).Error; err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "alert not found"})
|
|
return
|
|
}
|
|
|
|
if err := h.db.Model(&alert).Update("status", model.AlertStatusDismissed).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to dismiss alert", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"status": "dismissed"})
|
|
}
|
|
|
|
// AlertStats represents alert statistics
|
|
type AlertStats struct {
|
|
Total int64 `json:"total"`
|
|
Active int64 `json:"active"`
|
|
Acknowledged int64 `json:"acknowledged"`
|
|
Resolved int64 `json:"resolved"`
|
|
Critical int64 `json:"critical"`
|
|
Warning int64 `json:"warning"`
|
|
Info int64 `json:"info"`
|
|
}
|
|
|
|
// GetAlertStats godoc
|
|
// @Summary Alert statistics
|
|
// @Description Get alert count statistics by status and severity
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Success 200 {object} ResponseEnvelope{data=AlertStats}
|
|
// @Failure 500 {object} ResponseEnvelope{data=MapData}
|
|
// @Router /admin/alerts/stats [get]
|
|
func (h *AlertHandler) GetAlertStats(c *gin.Context) {
|
|
var total, active, acknowledged, resolved, critical, warning, info int64
|
|
|
|
h.db.Model(&model.Alert{}).Count(&total)
|
|
h.db.Model(&model.Alert{}).Where("status = ?", "active").Count(&active)
|
|
h.db.Model(&model.Alert{}).Where("status = ?", "acknowledged").Count(&acknowledged)
|
|
h.db.Model(&model.Alert{}).Where("status = ?", "resolved").Count(&resolved)
|
|
h.db.Model(&model.Alert{}).Where("severity = ? AND status = ?", "critical", "active").Count(&critical)
|
|
h.db.Model(&model.Alert{}).Where("severity = ? AND status = ?", "warning", "active").Count(&warning)
|
|
h.db.Model(&model.Alert{}).Where("severity = ? AND status = ?", "info", "active").Count(&info)
|
|
|
|
c.JSON(http.StatusOK, AlertStats{
|
|
Total: total,
|
|
Active: active,
|
|
Acknowledged: acknowledged,
|
|
Resolved: resolved,
|
|
Critical: critical,
|
|
Warning: warning,
|
|
Info: info,
|
|
})
|
|
}
|
|
|
|
// AlertThresholdView represents threshold configuration in API responses
|
|
type AlertThresholdView struct {
|
|
GlobalQPS int64 `json:"global_qps"`
|
|
MasterRPM int64 `json:"master_rpm"`
|
|
MasterRPD int64 `json:"master_rpd"`
|
|
MasterTPM int64 `json:"master_tpm"`
|
|
MasterTPD int64 `json:"master_tpd"`
|
|
MinRPMRequests1m int64 `json:"min_rpm_requests_1m"`
|
|
MinTPMTokens1m int64 `json:"min_tpm_tokens_1m"`
|
|
UpdatedAt int64 `json:"updated_at"`
|
|
}
|
|
|
|
func toAlertThresholdView(cfg model.AlertThresholdConfig) AlertThresholdView {
|
|
return AlertThresholdView{
|
|
GlobalQPS: cfg.GlobalQPS,
|
|
MasterRPM: cfg.MasterRPM,
|
|
MasterRPD: cfg.MasterRPD,
|
|
MasterTPM: cfg.MasterTPM,
|
|
MasterTPD: cfg.MasterTPD,
|
|
MinRPMRequests1m: cfg.MinRPMRequests1m,
|
|
MinTPMTokens1m: cfg.MinTPMTokens1m,
|
|
UpdatedAt: cfg.UpdatedAt.UTC().Unix(),
|
|
}
|
|
}
|
|
|
|
// GetAlertThresholds godoc
|
|
// @Summary Get alert thresholds
|
|
// @Description Get current alert threshold configuration for traffic spike detection
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Success 200 {object} ResponseEnvelope{data=AlertThresholdView}
|
|
// @Failure 500 {object} ResponseEnvelope{data=MapData}
|
|
// @Router /admin/alerts/thresholds [get]
|
|
func (h *AlertHandler) GetAlertThresholds(c *gin.Context) {
|
|
cfg, err := h.loadThresholdConfig()
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to load thresholds", "details": err.Error()})
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, toAlertThresholdView(cfg))
|
|
}
|
|
|
|
// UpdateAlertThresholdsRequest is the request body for updating thresholds
|
|
type UpdateAlertThresholdsRequest struct {
|
|
GlobalQPS *int64 `json:"global_qps"`
|
|
MasterRPM *int64 `json:"master_rpm"`
|
|
MasterRPD *int64 `json:"master_rpd"`
|
|
MasterTPM *int64 `json:"master_tpm"`
|
|
MasterTPD *int64 `json:"master_tpd"`
|
|
MinRPMRequests1m *int64 `json:"min_rpm_requests_1m"`
|
|
MinTPMTokens1m *int64 `json:"min_tpm_tokens_1m"`
|
|
}
|
|
|
|
// UpdateAlertThresholds godoc
|
|
// @Summary Update alert thresholds
|
|
// @Description Update alert threshold configuration for traffic spike detection
|
|
// @Tags admin
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Param request body UpdateAlertThresholdsRequest true "Threshold configuration"
|
|
// @Success 200 {object} ResponseEnvelope{data=AlertThresholdView}
|
|
// @Failure 400 {object} ResponseEnvelope{data=MapData}
|
|
// @Failure 500 {object} ResponseEnvelope{data=MapData}
|
|
// @Router /admin/alerts/thresholds [put]
|
|
func (h *AlertHandler) UpdateAlertThresholds(c *gin.Context) {
|
|
var req UpdateAlertThresholdsRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
// Validate positive values
|
|
if req.GlobalQPS != nil && *req.GlobalQPS <= 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "global_qps must be positive"})
|
|
return
|
|
}
|
|
if req.MasterRPM != nil && *req.MasterRPM <= 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "master_rpm must be positive"})
|
|
return
|
|
}
|
|
if req.MasterRPD != nil && *req.MasterRPD <= 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "master_rpd must be positive"})
|
|
return
|
|
}
|
|
if req.MasterTPM != nil && *req.MasterTPM <= 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "master_tpm must be positive"})
|
|
return
|
|
}
|
|
if req.MasterTPD != nil && *req.MasterTPD <= 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "master_tpd must be positive"})
|
|
return
|
|
}
|
|
if req.MinRPMRequests1m != nil && *req.MinRPMRequests1m < 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "min_rpm_requests_1m must be non-negative"})
|
|
return
|
|
}
|
|
if req.MinTPMTokens1m != nil && *req.MinTPMTokens1m < 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "min_tpm_tokens_1m must be non-negative"})
|
|
return
|
|
}
|
|
|
|
cfg, err := h.loadThresholdConfig()
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to load thresholds", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
// Apply updates
|
|
if req.GlobalQPS != nil {
|
|
cfg.GlobalQPS = *req.GlobalQPS
|
|
}
|
|
if req.MasterRPM != nil {
|
|
cfg.MasterRPM = *req.MasterRPM
|
|
}
|
|
if req.MasterRPD != nil {
|
|
cfg.MasterRPD = *req.MasterRPD
|
|
}
|
|
if req.MasterTPM != nil {
|
|
cfg.MasterTPM = *req.MasterTPM
|
|
}
|
|
if req.MasterTPD != nil {
|
|
cfg.MasterTPD = *req.MasterTPD
|
|
}
|
|
if req.MinRPMRequests1m != nil {
|
|
cfg.MinRPMRequests1m = *req.MinRPMRequests1m
|
|
}
|
|
if req.MinTPMTokens1m != nil {
|
|
cfg.MinTPMTokens1m = *req.MinTPMTokens1m
|
|
}
|
|
|
|
if err := h.db.Save(&cfg).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to save thresholds", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, toAlertThresholdView(cfg))
|
|
}
|
|
|
|
// loadThresholdConfig loads the threshold config from DB or creates default with fixed ID=1
|
|
func (h *AlertHandler) loadThresholdConfig() (model.AlertThresholdConfig, error) {
|
|
cfg := model.DefaultAlertThresholdConfig()
|
|
cfg.ID = 1 // Fixed ID to ensure single config row
|
|
err := h.db.Where("id = ?", 1).FirstOrCreate(&cfg).Error
|
|
if err != nil {
|
|
return cfg, err
|
|
}
|
|
return cfg, nil
|
|
}
|