feat: 迁移预警规则管理和历史分类查询

internal/data/business/alert_rule.go

@@ -0,0 +1,97 @@
+package business
+
+import (
+	"context"
+	"errors"
+	"gorm.io/gorm"
+	"kra/internal/biz/business"
+	"time"
+)
+
+type alertRuleRepo struct{ data Provider }
+
+func NewAlertRuleRepo(data Provider) business.AlertRuleRepo { return &alertRuleRepo{data: data} }
+func toBizAlertRule(po alertRulePO) *business.AlertRule {
+	return &business.AlertRule{ID: po.ID, Name: po.RuleName, Type: po.RuleType, Metric: po.MonitorMetric, StatPeriodDays: po.StatPeriodDays, MomDirection: po.MomDirection, MomThreshold: po.MomThreshold, UnloginDays: po.UnloginDays, MonitorScope: po.MonitorScope, WarningColor: po.WarningColor, CreatorID: po.CreatorID, Enabled: po.Enabled, IsDeleted: po.IsDeleted, CreatedAt: po.CreatedAt, UpdatedAt: po.UpdatedAt}
+}
+func newAlertRule(r *business.AlertRule) alertRulePO {
+	return alertRulePO{ID: r.ID, RuleName: r.Name, RuleType: r.Type, MonitorMetric: r.Metric, StatPeriodDays: r.StatPeriodDays, MomDirection: r.MomDirection, MomThreshold: r.MomThreshold, UnloginDays: r.UnloginDays, MonitorScope: r.MonitorScope, WarningColor: r.WarningColor, CreatorID: r.CreatorID, Enabled: r.Enabled, IsDeleted: r.IsDeleted}
+}
+func applyOwnerScope(db *gorm.DB, scope business.LevelOneScope, column string) *gorm.DB {
+	if scope.All {
+		return db
+	}
+	if scope.Empty {
+		return db.Where("1=0")
+	}
+	return db.Where(column+" = ?", scope.UserID)
+}
+func (r *alertRuleRepo) List(ctx context.Context, scope business.LevelOneScope, filter business.AlertRuleFilter, options ...business.ListOption) ([]*business.AlertRule, int64, error) {
+	db := applyOwnerScope(r.data.DB().WithContext(ctx).Table("sys_alert_rule r").Where("r.is_deleted = ?", 0), scope, "r.creator_id")
+	if filter.Type != "" {
+		db = db.Where("r.rule_type = ?", filter.Type)
+	}
+	if filter.Name != "" {
+		db = db.Where("r.rule_name LIKE ?", "%"+filter.Name+"%")
+	}
+	if filter.Metric != nil {
+		db = db.Where("r.monitor_metric = ?", *filter.Metric)
+	}
+	var total int64
+	if err := db.Count(&total).Error; err != nil {
+		return nil, 0, business.ErrStorage
+	}
+	var pos []struct {
+		Rule        alertRulePO `gorm:"embedded"`
+		CreatorName string
+	}
+	o := business.NewListOptions(options...)
+	if err := db.Select("r.*,u.username AS creator_name").Joins("LEFT JOIN sys_users u ON u.id=r.creator_id AND u.deleted_at IS NULL").Order("r.created_at DESC,r.id DESC").Offset(o.Offset).Limit(o.Limit).Scan(&pos).Error; err != nil {
+		return nil, 0, business.ErrStorage
+	}
+	rows := make([]*business.AlertRule, 0, len(pos))
+	for _, po := range pos {
+		rule := toBizAlertRule(po.Rule)
+		rule.CreatorName = po.CreatorName
+		rows = append(rows, rule)
+	}
+	return rows, total, nil
+}
+func (r *alertRuleRepo) Find(ctx context.Context, id uint64) (*business.AlertRule, error) {
+	var po alertRulePO
+	err := r.data.DB().WithContext(ctx).First(&po, "id = ?", id).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, business.ErrAlertRuleNotFound
+	}
+	if err != nil {
+		return nil, business.ErrStorage
+	}
+	rule := toBizAlertRule(po)
+	if err := r.data.DB().WithContext(ctx).Table("sys_users").Where("id = ? AND deleted_at IS NULL", rule.CreatorID).Select("username").Scan(&rule.CreatorName).Error; err != nil {
+		return nil, business.ErrStorage
+	}
+	return rule, nil
+}
+func (r *alertRuleRepo) Create(ctx context.Context, rule *business.AlertRule) error {
+	po := newAlertRule(rule)
+	if err := r.data.DB().WithContext(ctx).Create(&po).Error; err != nil {
+		return storageError(err)
+	}
+	rule.ID, rule.CreatedAt, rule.UpdatedAt = po.ID, po.CreatedAt, po.UpdatedAt
+	return nil
+}
+func (r *alertRuleRepo) Update(ctx context.Context, rule *business.AlertRule) error {
+	// 编辑不覆盖启停、删除和创建人字段，避免并发启停被旧配置覆盖。
+	return storageError(r.data.DB().WithContext(ctx).Model(&alertRulePO{}).Where("id = ?", rule.ID).Updates(map[string]any{"rule_name": rule.Name, "rule_type": rule.Type, "monitor_metric": rule.Metric, "stat_period_days": rule.StatPeriodDays, "mom_direction": rule.MomDirection, "mom_threshold": rule.MomThreshold, "unlogin_days": rule.UnloginDays, "monitor_scope": 1, "warning_color": rule.WarningColor, "updated_at": time.Now()}).Error)
+}
+func (r *alertRuleRepo) SetDeleted(ctx context.Context, id uint64) error {
+	return storageError(r.data.DB().WithContext(ctx).Model(&alertRulePO{}).Where("id = ?", id).Updates(map[string]any{"is_deleted": 1, "updated_at": time.Now()}).Error)
+}
+func (r *alertRuleRepo) SetEnabled(ctx context.Context, id uint64, enabled int) error {
+	return storageError(r.data.DB().WithContext(ctx).Model(&alertRulePO{}).Where("id = ?", id).Updates(map[string]any{"enabled": enabled, "updated_at": time.Now()}).Error)
+}
+func (r *alertRuleRepo) TypesFromRecords(ctx context.Context, scope business.LevelOneScope) ([]string, error) {
+	rows := []string{}
+	err := applyOwnerScope(r.data.DB().WithContext(ctx).Table("sys_alert_record").Where("rule_type IS NOT NULL AND TRIM(rule_type) <> ''"), scope, "business_id").Distinct("rule_type").Order("rule_type").Pluck("rule_type", &rows).Error
+	return rows, storageError(err)
+}