98 lines
5.2 KiB
Go
98 lines
5.2 KiB
Go
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, ConditionMode: po.ConditionMode, AmountDirection: po.AmountDirection, AmountThreshold: po.AmountThreshold, 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, ConditionMode: r.ConditionMode, AmountDirection: r.AmountDirection, AmountThreshold: r.AmountThreshold, 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 = ? AND is_deleted = 0", 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{"condition_mode": rule.ConditionMode, "amount_direction": rule.AmountDirection, "amount_threshold": rule.AmountThreshold, "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)
|
|
}
|