feat: expand vehicle data platform capabilities

2026-07-27 16:46:15 +08:00
parent e3a1f80f86
commit 3c4bece72c
650 changed files with 62155 additions and 2552 deletions
--- a/vehicle-data-platform/apps/api/internal/platform/alert_mock.go
+++ b/vehicle-data-platform/apps/api/internal/platform/alert_mock.go
@@ -3,6 +3,7 @@ package platform
 import (
 	"context"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -11,25 +12,55 @@ func (m *MockStore) seedAlertCenter() {
 	now := time.Now()
 	boolTrue := true
 	m.alertRules = []AlertRule{
-		{ID: "rule-speeding", Name: "持续超速告警", Description: "速度持续高于阈值", Severity: "critical", ValueType: "numeric", Metric: "speed_kmh", Operator: "gt", Threshold: 80, DurationSec: 60, RecoveryOperator: "lte", RecoveryThreshold: 75, RepeatIntervalSec: 600, ScopeProtocols: []string{"JT808", "GB32960"}, ScopeVINs: []string{}, NotificationChannels: []string{"in_app"}, Enabled: true, Version: 2, CreatedBy: "system", UpdatedBy: "platform-admin", CreatedAt: now.AddDate(0, -2, 0).Format(time.RFC3339), UpdatedAt: now.Add(-48 * time.Hour).Format(time.RFC3339)},
-		{ID: "rule-offline", Name: "离线超时", Description: "车辆超过阈值未上报", Severity: "major", ValueType: "numeric", Metric: "freshness_sec", Operator: "gt", Threshold: 3600, DurationSec: 0, RecoveryOperator: "lte", RecoveryThreshold: 300, RepeatIntervalSec: 3600, ScopeProtocols: []string{"JT808", "GB32960", "YUTONG_MQTT"}, ScopeVINs: []string{}, NotificationChannels: []string{"in_app"}, Enabled: true, Version: 1, CreatedBy: "system", UpdatedBy: "system", CreatedAt: now.AddDate(0, -3, 0).Format(time.RFC3339), UpdatedAt: now.AddDate(0, -3, 0).Format(time.RFC3339)},
-		{ID: "rule-alarm", Name: "协议告警位", Description: "原始协议告警位非零", Severity: "major", ValueType: "boolean", Metric: "alarm_active", Operator: "eq", BooleanThreshold: &boolTrue, DurationSec: 0, RecoveryOperator: "eq", RecoveryThreshold: 0, RepeatIntervalSec: 300, ScopeProtocols: []string{"JT808"}, ScopeVINs: []string{}, NotificationChannels: []string{"in_app"}, Enabled: false, Version: 1, CreatedBy: "platform-admin", UpdatedBy: "platform-admin", CreatedAt: now.Add(-72 * time.Hour).Format(time.RFC3339), UpdatedAt: now.Add(-72 * time.Hour).Format(time.RFC3339)},
+		{ID: "rule-geofence", Name: "车辆驶出运营围栏", Description: "车辆从深圳运营区内移动到围栏外", TriggerType: "geofence", FenceName: "深圳运营区", FenceLongitude: 114.057868, FenceLatitude: 22.543099, FenceRadiusM: 5000, Severity: "critical", ValueType: "numeric", Metric: "geofence_distance_m", Operator: "exit", Threshold: 5000, RepeatIntervalSec: 600, ScopeProtocols: []string{"JT808"}, ScopeVINs: []string{}, NotificationChannels: []string{"in_app"}, Enabled: true, Version: 3, CreatedBy: "system", UpdatedBy: "platform-admin", CreatedAt: now.AddDate(0, -2, 0).Format(time.RFC3339), UpdatedAt: now.Add(-2 * time.Hour).Format(time.RFC3339)},
+		{ID: "rule-low-soc", Name: "SOC 低于 20%", Description: "动力电池 SOC 持续低于 20%", TriggerType: "metric", Severity: "major", ValueType: "numeric", Metric: "soc_percent", Operator: "lt", Threshold: 20, DurationSec: 300, RecoveryOperator: "gte", RecoveryThreshold: 25, RepeatIntervalSec: 3600, ScopeProtocols: []string{"GB32960"}, ScopeVINs: []string{}, NotificationChannels: []string{"in_app"}, Enabled: true, Version: 2, CreatedBy: "system", UpdatedBy: "platform-admin", CreatedAt: now.AddDate(0, -1, 0).Format(time.RFC3339), UpdatedAt: now.Add(-24 * time.Hour).Format(time.RFC3339)},
+		{ID: "rule-offline", Name: "车辆在线状态处理", Description: "车辆离线时创建事件，恢复上报后自动完成", TriggerType: "offline", Severity: "major", ValueType: "numeric", Metric: "freshness_sec", Operator: "gt", Threshold: 3600, RecoveryOperator: "lte", RecoveryThreshold: 3600, RepeatIntervalSec: 3600, ScopeProtocols: []string{"JT808", "GB32960", "YUTONG_MQTT"}, ScopeVINs: []string{}, NotificationChannels: []string{"in_app"}, Enabled: true, Version: 1, CreatedBy: "system", UpdatedBy: "system", CreatedAt: now.AddDate(0, -3, 0).Format(time.RFC3339), UpdatedAt: now.AddDate(0, -3, 0).Format(time.RFC3339)},
+		{ID: "rule-speeding", Name: "车辆急加速", Description: "速度变化率超过运营阈值", TriggerType: "metric", Severity: "major", ValueType: "numeric", Metric: "speed_kmh", Operator: "gt", Threshold: 80, DurationSec: 10, RecoveryOperator: "lte", RecoveryThreshold: 75, RepeatIntervalSec: 600, ScopeProtocols: []string{"JT808"}, ScopeVINs: []string{}, NotificationChannels: []string{"in_app"}, Enabled: true, Version: 2, CreatedBy: "system", UpdatedBy: "platform-admin", CreatedAt: now.AddDate(0, -2, 0).Format(time.RFC3339), UpdatedAt: now.Add(-48 * time.Hour).Format(time.RFC3339)},
+		{ID: "rule-mileage", Name: "里程数据完成日结", Description: "记录车辆每日里程结算完成事件", TriggerType: "metric", Severity: "minor", ValueType: "numeric", Metric: "daily_mileage_km", Operator: "gte", Threshold: 0, RepeatIntervalSec: 86400, ScopeProtocols: []string{"GB32960"}, ScopeVINs: []string{}, NotificationChannels: []string{}, Enabled: true, Version: 1, CreatedBy: "system", UpdatedBy: "system", CreatedAt: now.AddDate(0, -1, 0).Format(time.RFC3339), UpdatedAt: now.Add(-12 * time.Hour).Format(time.RFC3339)},
+		{ID: "rule-alarm", Name: "最高氢浓度超限", Description: "燃料电池系统最高氢浓度超过安全阈值", TriggerType: "metric", Severity: "critical", ValueType: "boolean", Metric: "alarm_active", Operator: "eq", BooleanThreshold: &boolTrue, RecoveryOperator: "eq", RecoveryThreshold: 0, RepeatIntervalSec: 300, ScopeProtocols: []string{"GB32960"}, ScopeVINs: []string{}, NotificationChannels: []string{"in_app"}, Enabled: false, Version: 1, CreatedBy: "platform-admin", UpdatedBy: "platform-admin", CreatedAt: now.Add(-72 * time.Hour).Format(time.RFC3339), UpdatedAt: now.Add(-72 * time.Hour).Format(time.RFC3339)},
+	}
+	for i := range m.alertRules {
+		m.alertRules[i].ScopeOEMs = []string{}
+		m.alertRules[i].ScopeModels = []string{}
+		m.alertRules[i].ScopeCompanies = []string{}
+		input := alertRuleInputFromRule(m.alertRules[i])
+		if err := normalizeAlertNotificationTargets(&input); err == nil {
+			m.alertRules[i].NotificationChannels = input.NotificationChannels
+			m.alertRules[i].NotificationTargets = input.NotificationTargets
+		}
+	}
+	m.alertRuleRevisions = map[string][]AlertRuleRevision{}
+	for _, rule := range m.alertRules {
+		m.alertRuleRevisions[rule.ID] = []AlertRuleRevision{{RuleID: rule.ID, Version: rule.Version, Actor: rule.UpdatedBy, Action: "create", CreatedAt: rule.UpdatedAt, Snapshot: rule}}
 	}
 	locations := []string{"广东省深圳市南山区科技南路", "广东省广州市白云区机场高速", "广东省东莞市南城街道", "广东省佛山市顺德区伦教街道", "上海市临港新片区", "四川省成都市高新区"}
 	statuses := []string{"unprocessed", "unprocessed", "processing", "recovered", "closed", "ignored"}
-	severities := []string{"critical", "critical", "major", "major", "minor", "minor"}
+	severities := []string{"critical", "major", "major", "major", "minor", "critical"}
 	plates := []string{"粤AG18312", "粤B7C526", "粤C9D872", "粤E6P987", "豫A88888", "川AHTWO1"}
 	vins := []string{"LB9A32A24R0LS1426", "LFP23A98V2P012345", "LS5A3A5E8N0123456", "LJ12BA3R1N0456789", "LMRKH9AC2R1004087", "LNXNEGRR7SR318212"}
+	eventSpecs := []struct {
+		ruleID, name, triggerType, protocol, metric, operator, unit string
+		value, threshold                                            float64
+		duration                                                    int
+	}{
+		{"rule-geofence", "车辆驶出运营围栏", "geofence", "JT808", "geofence_distance_m", "exit", "m", 5230, 5000, 0},
+		{"rule-low-soc", "SOC 低于 20%", "metric", "GB32960", "soc_percent", "lt", "%", 18, 20, 300},
+		{"rule-speeding", "车辆急加速", "metric", "JT808", "speed_kmh", "gt", "km/h", 92, 80, 10},
+		{"rule-offline", "车辆恢复在线", "offline", "YUTONG_MQTT", "freshness_sec", "gt", "s", 22, 3600, 0},
+		{"rule-mileage", "里程数据完成日结", "metric", "GB32960", "daily_mileage_km", "gte", "km", 186.4, 0, 0},
+		{"rule-alarm", "最高氢浓度超限", "metric", "GB32960", "alarm_active", "eq", "", 1, 1, 0},
+	}
 	for i := range statuses {
 		triggered := now.Add(-time.Duration(8+i*11) * time.Minute)
-		event := AlertEvent{ID: "alert-demo-" + string(rune('1'+i)), RuleID: "rule-speeding", RuleName: "持续超速告警", RuleVersion: 2, Severity: severities[i], Status: statuses[i], VIN: vins[i], Plate: plates[i], Protocol: []string{"JT808", "JT808", "JT808", "GB32960", "YUTONG_MQTT", "GB32960"}[i], Metric: "speed_kmh", Operator: "gt", TriggerValue: 96 - float64(i*3), Threshold: 80, Unit: "km/h", DurationSec: 60, Location: locations[i], SourceEventID: "source-event-00" + string(rune('1'+i)), EventAt: triggered.Add(-time.Second).Format(time.RFC3339), ReceivedAt: triggered.Format(time.RFC3339), TriggeredAt: triggered.Format(time.RFC3339), Version: 1}
+		spec := eventSpecs[i]
+		event := AlertEvent{ID: "alert-demo-" + string(rune('1'+i)), RuleID: spec.ruleID, RuleName: spec.name, RuleVersion: 2, Severity: severities[i], TriggerType: spec.triggerType, Status: statuses[i], VIN: vins[i], Plate: plates[i], Protocol: spec.protocol, Metric: spec.metric, Operator: spec.operator, TriggerValue: spec.value, Threshold: spec.threshold, Unit: spec.unit, DurationSec: spec.duration, Location: locations[i], SourceEventID: "source-event-00" + string(rune('1'+i)), EventAt: triggered.Add(-time.Second).Format(time.RFC3339), ReceivedAt: triggered.Format(time.RFC3339), TriggeredAt: triggered.Format(time.RFC3339), Version: 1}
 		if statuses[i] == "processing" {
 			event.Handler = "张三"
 		}
 		if statuses[i] == "recovered" || statuses[i] == "closed" || statuses[i] == "ignored" {
 			event.RecoveredAt = triggered.Add(5 * time.Minute).Format(time.RFC3339)
 		}
-		event.Actions = []AlertAction{{ID: int64(i + 1), Action: "trigger", ToStatus: "unprocessed", Actor: "alert-evaluator", Note: "规则命中并达到持续时间", CreatedAt: triggered.Format(time.RFC3339)}}
+		event.Actions = []AlertAction{{ID: int64(i + 1), Action: "trigger", ToStatus: "unprocessed", Actor: "event-evaluator", Note: "标准事件已匹配自动化", CreatedAt: triggered.Format(time.RFC3339)}}
 		if statuses[i] != "unprocessed" {
 			event.Actions = append(event.Actions, AlertAction{ID: int64(20 + i), Action: statuses[i], FromStatus: "unprocessed", ToStatus: statuses[i], Actor: firstNonEmpty(event.Handler, "platform-admin"), CreatedAt: triggered.Add(time.Minute).Format(time.RFC3339)})
 		}
@@ -37,9 +68,17 @@ func (m *MockStore) seedAlertCenter() {
 	}
 	m.nextAlertActionID = 100
 	for i := 0; i < 9; i++ {
-		m.alertNotifications = append(m.alertNotifications, AlertNotification{ID: int64(i + 1), EventID: m.alertEvents[i%len(m.alertEvents)].ID, Title: m.alertEvents[i%len(m.alertEvents)].RuleName, Content: plates[i%len(plates)] + " 触发告警，请及时处理", Severity: severities[i%len(severities)], Channel: "in_app", Read: i >= 7, CreatedAt: now.Add(-time.Duration(i+1) * time.Minute).Format(time.RFC3339)})
+		m.alertNotifications = append(m.alertNotifications, AlertNotification{ID: int64(i + 1), EventID: m.alertEvents[i%len(m.alertEvents)].ID, Title: m.alertEvents[i%len(m.alertEvents)].RuleName, Content: plates[i%len(plates)] + " 的车辆事件已执行通知动作", Severity: severities[i%len(severities)], Channel: "in_app", DeliveryStatus: "delivered", AttemptCount: 1, MaxAttempts: alertNotificationMaxAttempts, Read: i >= 7, CreatedAt: now.Add(-time.Duration(i+1) * time.Minute).Format(time.RFC3339)})
 	}
-	m.nextNotificationID = 10
+	m.alertNotifications = append(m.alertNotifications, AlertNotification{
+		ID: 10, EventID: m.alertEvents[1].ID, Title: "SOC 低电量短信通知", Content: "粤B7C526 的 SOC 已低于 20%，短信网关连接超时",
+		Severity: "major", Channel: "sms", Recipient: "夜班负责人", RecipientID: "night-shift", DeliveryStatus: "failed", AttemptCount: 2,
+		VehiclePlate: "粤B7C526", VehicleVIN: m.alertEvents[1].VIN, Protocol: m.alertEvents[1].Protocol,
+		CreatedAt: now.Add(-12 * time.Minute).Format(time.RFC3339), LastAttemptAt: now.Add(-10 * time.Minute).Format(time.RFC3339),
+		LastError: "短信网关连接超时（provider_timeout）", RetryAvailable: true, MaxAttempts: alertNotificationMaxAttempts,
+	})
+	m.nextNotificationID = 11
+	m.nextNotificationRetryAuditID = 0
 }

 func (m *MockStore) AlertSummary(_ context.Context, query AlertQuery) (AlertSummary, error) {
@@ -66,7 +105,7 @@ func (m *MockStore) AlertSummary(_ context.Context, query AlertQuery) (AlertSumm
 		}
 	}
 	for _, item := range m.alertNotifications {
-		if !item.Read {
+		if item.Channel == "in_app" && !item.Read {
 			result.UnreadNotifications++
 		}
 	}
@@ -161,7 +200,99 @@ func (m *MockStore) AlertEvent(_ context.Context, id string) (AlertEvent, error)
 func (m *MockStore) AlertRules(context.Context) ([]AlertRule, error) {
 	m.alertMu.RLock()
 	defer m.alertMu.RUnlock()
-	return append([]AlertRule(nil), m.alertRules...), nil
+	items := make([]AlertRule, 0, len(m.alertRules))
+	for _, rule := range m.alertRules {
+		if rule.ArchivedAt == "" {
+			items = append(items, rule)
+		}
+	}
+	return items, nil
+}
+
+func (m *MockStore) AlertRulePage(_ context.Context, query AlertRuleQuery) (AlertRulePage, error) {
+	m.alertMu.RLock()
+	defer m.alertMu.RUnlock()
+	summary := AlertRuleLibrarySummary{}
+	items := make([]AlertRule, 0, query.Limit)
+	search := strings.ToLower(strings.TrimSpace(query.Keyword))
+	for _, rule := range m.alertRules {
+		archived := rule.ArchivedAt != ""
+		if archived {
+			summary.Archived++
+		} else {
+			summary.Current++
+			if rule.Enabled {
+				summary.Enabled++
+			} else {
+				summary.Disabled++
+			}
+		}
+		if (query.Lifecycle == "archived") != archived {
+			continue
+		}
+		if query.Status == "enabled" && !rule.Enabled || query.Status == "disabled" && rule.Enabled {
+			continue
+		}
+		if query.Protocol != "" && len(rule.ScopeProtocols) > 0 {
+			matched := false
+			for _, protocol := range rule.ScopeProtocols {
+				if protocol == query.Protocol {
+					matched = true
+					break
+				}
+			}
+			if !matched {
+				continue
+			}
+		}
+		if search != "" {
+			haystack := strings.ToLower(strings.Join([]string{
+				rule.Name, rule.Description, rule.Metric, strings.Join(rule.ScopeVINs, " "),
+				strings.Join(rule.ScopeOEMs, " "), strings.Join(rule.ScopeModels, " "),
+				strings.Join(rule.ScopeCompanies, " "), rule.ArchiveReason,
+			}, " "))
+			if !strings.Contains(haystack, search) {
+				continue
+			}
+		}
+		items = append(items, rule)
+	}
+	sort.SliceStable(items, func(i, j int) bool {
+		if query.Lifecycle == "archived" {
+			if items[i].ArchivedAt != items[j].ArchivedAt {
+				return items[i].ArchivedAt > items[j].ArchivedAt
+			}
+		} else if items[i].Enabled != items[j].Enabled {
+			return items[i].Enabled
+		}
+		return items[i].ID < items[j].ID
+	})
+	total := len(items)
+	start := min(query.Offset, total)
+	end := min(start+query.Limit, total)
+	return AlertRulePage{Items: append([]AlertRule(nil), items[start:end]...), Total: total, Limit: query.Limit, Offset: query.Offset, Summary: summary}, nil
+}
+
+func (m *MockStore) AlertRuleRevisions(_ context.Context, id string) ([]AlertRuleRevision, error) {
+	m.alertMu.RLock()
+	defer m.alertMu.RUnlock()
+	items, ok := m.alertRuleRevisions[id]
+	if !ok {
+		return nil, clientError{Code: "ALERT_RULE_NOT_FOUND", Message: "自动化不存在"}
+	}
+	return append([]AlertRuleRevision(nil), items...), nil
+}
+
+func (m *MockStore) recordAlertRuleRevision(rule AlertRule, actor, action string, reasons ...string) {
+	if m.alertRuleRevisions == nil {
+		m.alertRuleRevisions = map[string][]AlertRuleRevision{}
+	}
+	reason := ""
+	if len(reasons) > 0 {
+		reason = reasons[0]
+	}
+	revision := AlertRuleRevision{RuleID: rule.ID, Version: rule.Version, Actor: actor, Action: action, Reason: reason, CreatedAt: rule.UpdatedAt, Snapshot: rule}
+	m.alertRuleRevisions[rule.ID] = append([]AlertRuleRevision{revision}, m.alertRuleRevisions[rule.ID]...)
 }

 func (m *MockStore) SaveAlertRule(_ context.Context, input AlertRuleInput) (AlertRule, error) {
@@ -172,6 +303,9 @@ func (m *MockStore) SaveAlertRule(_ context.Context, input AlertRuleInput) (Aler
 		if current.ID != input.ID {
 			continue
 		}
+		if current.ArchivedAt != "" {
+			return AlertRule{}, clientError{Code: "ALERT_RULE_ARCHIVED_READ_ONLY", Message: "审计归档中的自动化为只读；请先恢复到当前规则"}
+		}
 		if input.Version != current.Version {
 			return AlertRule{}, clientError{Code: "ALERT_RULE_VERSION_CONFLICT", Message: "规则已被其他用户更新，请刷新后重试"}
 		}
@@ -182,6 +316,7 @@ func (m *MockStore) SaveAlertRule(_ context.Context, input AlertRuleInput) (Aler
 		next.UpdatedAt = now
 		next.UpdatedBy = input.Actor
 		m.alertRules[i] = next
+		m.recordAlertRuleRevision(next, input.Actor, firstNonEmpty(input.AuditAction, "update"))
 		return next, nil
 	}
 	if input.Version != 0 {
@@ -194,11 +329,15 @@ func (m *MockStore) SaveAlertRule(_ context.Context, input AlertRuleInput) (Aler
 	next.CreatedBy = input.Actor
 	next.UpdatedBy = input.Actor
 	m.alertRules = append(m.alertRules, next)
+	if m.alertRuleRevisions == nil {
+		m.alertRuleRevisions = map[string][]AlertRuleRevision{}
+	}
+	m.recordAlertRuleRevision(next, input.Actor, "create")
 	return next, nil
 }

 func ruleFromInput(input AlertRuleInput) AlertRule {
-	return AlertRule{ID: input.ID, Name: input.Name, Description: input.Description, Severity: strings.ToLower(input.Severity), ValueType: strings.ToLower(input.ValueType), Metric: input.Metric, Operator: strings.ToLower(input.Operator), Threshold: input.Threshold, ThresholdHigh: input.ThresholdHigh, BooleanThreshold: input.BooleanThreshold, DurationSec: input.DurationSec, RecoveryOperator: strings.ToLower(input.RecoveryOperator), RecoveryThreshold: input.RecoveryThreshold, RepeatIntervalSec: input.RepeatIntervalSec, ScopeProtocols: append([]string(nil), input.ScopeProtocols...), ScopeVINs: append([]string(nil), input.ScopeVINs...), ScopeOEMs: append([]string(nil), input.ScopeOEMs...), ScopeModels: append([]string(nil), input.ScopeModels...), ScopeCompanies: append([]string(nil), input.ScopeCompanies...), NotificationChannels: append([]string(nil), input.NotificationChannels...), Enabled: input.Enabled}
+	return AlertRule{ID: input.ID, Name: input.Name, Description: input.Description, TriggerType: input.TriggerType, FenceName: input.FenceName, FenceLongitude: input.FenceLongitude, FenceLatitude: input.FenceLatitude, FenceRadiusM: input.FenceRadiusM, Severity: strings.ToLower(input.Severity), ValueType: strings.ToLower(input.ValueType), Metric: input.Metric, Operator: strings.ToLower(input.Operator), Threshold: input.Threshold, ThresholdHigh: input.ThresholdHigh, BooleanThreshold: input.BooleanThreshold, DurationSec: input.DurationSec, RecoveryOperator: strings.ToLower(input.RecoveryOperator), RecoveryThreshold: input.RecoveryThreshold, RepeatIntervalSec: input.RepeatIntervalSec, ScopeProtocols: append([]string(nil), input.ScopeProtocols...), ScopeVINs: append([]string(nil), input.ScopeVINs...), ScopeOEMs: append([]string(nil), input.ScopeOEMs...), ScopeModels: append([]string(nil), input.ScopeModels...), ScopeCompanies: append([]string(nil), input.ScopeCompanies...), NotificationChannels: append([]string(nil), input.NotificationChannels...), NotificationTargets: append([]AlertNotificationTarget(nil), input.NotificationTargets...), Enabled: input.Enabled}
 }

 func (m *MockStore) SetAlertRuleEnabled(_ context.Context, id string, update AlertRuleEnabledUpdate) (AlertRule, error) {
@@ -206,6 +345,9 @@ func (m *MockStore) SetAlertRuleEnabled(_ context.Context, id string, update Ale
 	defer m.alertMu.Unlock()
 	for i := range m.alertRules {
 		if m.alertRules[i].ID == id {
+			if m.alertRules[i].ArchivedAt != "" {
+				return AlertRule{}, clientError{Code: "ALERT_RULE_ARCHIVED_READ_ONLY", Message: "审计归档中的自动化为只读；请先恢复到当前规则"}
+			}
 			if m.alertRules[i].Version != update.Version {
 				return AlertRule{}, clientError{Code: "ALERT_RULE_VERSION_CONFLICT", Message: "规则已被其他用户更新，请刷新后重试"}
 			}
@@ -213,12 +355,56 @@ func (m *MockStore) SetAlertRuleEnabled(_ context.Context, id string, update Ale
 			m.alertRules[i].Version++
 			m.alertRules[i].UpdatedBy = update.Actor
 			m.alertRules[i].UpdatedAt = time.Now().Format(time.RFC3339)
+			m.recordAlertRuleRevision(m.alertRules[i], update.Actor, map[bool]string{true: "enable", false: "disable"}[update.Enabled])
 			return m.alertRules[i], nil
 		}
 	}
 	return AlertRule{}, clientError{Code: "ALERT_RULE_NOT_FOUND", Message: "规则不存在"}
 }

+func (m *MockStore) SetAlertRuleArchived(_ context.Context, id string, archived bool, request AlertRuleLifecycleRequest) (AlertRule, error) {
+	m.alertMu.Lock()
+	defer m.alertMu.Unlock()
+	for i := range m.alertRules {
+		rule := &m.alertRules[i]
+		if rule.ID != id {
+			continue
+		}
+		if rule.Version != request.Version {
+			return AlertRule{}, clientError{Code: "ALERT_RULE_VERSION_CONFLICT", Message: "自动化已被其他用户更新，请刷新后重试"}
+		}
+		if archived {
+			if rule.ArchivedAt != "" {
+				return AlertRule{}, clientError{Code: "ALERT_RULE_ALREADY_ARCHIVED", Message: "自动化已经归档"}
+			}
+			if rule.Enabled {
+				return AlertRule{}, clientError{Code: "ALERT_RULE_ARCHIVE_REQUIRES_DISABLED", Message: "请先停用自动化并确认不再产生新事件，再执行归档"}
+			}
+			rule.ArchivedAt = time.Now().Format(time.RFC3339)
+			rule.ArchivedBy = request.Actor
+			rule.ArchiveReason = request.Reason
+		} else {
+			if rule.ArchivedAt == "" {
+				return AlertRule{}, clientError{Code: "ALERT_RULE_NOT_ARCHIVED", Message: "自动化不在审计归档中"}
+			}
+			rule.ArchivedAt = ""
+			rule.ArchivedBy = ""
+			rule.ArchiveReason = ""
+			rule.Enabled = false
+		}
+		rule.Version++
+		rule.UpdatedBy = request.Actor
+		rule.UpdatedAt = time.Now().Format(time.RFC3339)
+		action := "restore"
+		if archived {
+			action = "archive"
+		}
+		m.recordAlertRuleRevision(*rule, request.Actor, action, request.Reason)
+		return *rule, nil
+	}
+	return AlertRule{}, clientError{Code: "ALERT_RULE_NOT_FOUND", Message: "自动化不存在"}
+}
+
 func (m *MockStore) ActOnAlert(_ context.Context, id string, request AlertActionRequest) (AlertEvent, error) {
 	m.alertMu.Lock()
 	defer m.alertMu.Unlock()
@@ -265,10 +451,46 @@ func (m *MockStore) AlertNotifications(_ context.Context, query AlertNotificatio
 	m.alertMu.RLock()
 	defer m.alertMu.RUnlock()
 	items := make([]AlertNotification, 0, len(m.alertNotifications))
+	search := strings.ToLower(query.Search)
 	for _, item := range m.alertNotifications {
-		if !query.UnreadOnly || !item.Read {
-			items = append(items, item)
+		if len(query.AllowedVINs) > 0 {
+			allowed := false
+			for _, vin := range query.AllowedVINs {
+				if strings.EqualFold(strings.TrimSpace(vin), strings.TrimSpace(item.VehicleVIN)) {
+					allowed = true
+					break
+				}
+			}
+			if !allowed {
+				continue
+			}
 		}
+		if query.UnreadOnly && (item.Channel != "in_app" || item.Read) {
+			continue
+		}
+		deliveryStatus := strings.ToLower(strings.TrimSpace(item.DeliveryStatus))
+		if deliveryStatus == "sent" {
+			deliveryStatus = "delivered"
+		}
+		if deliveryStatus == "created" || deliveryStatus == "reserved" {
+			deliveryStatus = "queued"
+		}
+		if deliveryStatus == "" {
+			deliveryStatus = "delivered"
+		}
+		if query.DeliveryStatus != "" && deliveryStatus != query.DeliveryStatus {
+			continue
+		}
+		if search != "" && !strings.Contains(strings.ToLower(strings.Join([]string{item.Title, item.Content, item.EventID, item.VehiclePlate, item.VehicleVIN, item.Recipient, item.Protocol}, "\n")), search) {
+			continue
+		}
+		item.DeliveryStatus = deliveryStatus
+		if item.AttemptCount <= 0 {
+			item.AttemptCount = 1
+		}
+		item.MaxAttempts = alertNotificationMaxAttempts
+		item.RetryAvailable = deliveryStatus == "failed" && item.AttemptCount < alertNotificationMaxAttempts
+		items = append(items, item)
 	}
 	total := len(items)
 	start := query.Offset
@@ -282,6 +504,48 @@ func (m *MockStore) AlertNotifications(_ context.Context, query AlertNotificatio
 	return Page[AlertNotification]{Items: append([]AlertNotification(nil), items[start:end]...), Total: total, Limit: query.Limit, Offset: query.Offset}, nil
 }

+func (m *MockStore) AlertNotificationDeliveryHealth(_ context.Context) (AlertNotificationDeliveryHealth, error) {
+	m.alertMu.RLock()
+	defer m.alertMu.RUnlock()
+	health := AlertNotificationDeliveryHealth{Channels: []AlertNotificationChannelHealth{}, AsOf: time.Now().Format(time.RFC3339)}
+	byChannel := map[string]*AlertNotificationChannelHealth{}
+	for _, notification := range m.alertNotifications {
+		if notification.Channel == "in_app" {
+			continue
+		}
+		channel := byChannel[notification.Channel]
+		if channel == nil {
+			channel = &AlertNotificationChannelHealth{Channel: notification.Channel}
+			byChannel[notification.Channel] = channel
+		}
+		status := strings.ToLower(strings.TrimSpace(notification.DeliveryStatus))
+		if status == "created" || status == "reserved" || status == "queued" {
+			channel.Queued++
+			health.Queued++
+			if channel.OldestQueuedAt == "" || notification.CreatedAt < channel.OldestQueuedAt {
+				channel.OldestQueuedAt = notification.CreatedAt
+			}
+			if health.OldestQueuedAt == "" || notification.CreatedAt < health.OldestQueuedAt {
+				health.OldestQueuedAt = notification.CreatedAt
+			}
+		}
+		if status == "failed" {
+			channel.Failed++
+			health.Failed++
+			if notification.AttemptCount >= alertNotificationMaxAttempts {
+				channel.DeadLetter++
+				health.DeadLetter++
+			}
+		}
+	}
+	for _, key := range []string{"sms", "email", "wecom"} {
+		if channel := byChannel[key]; channel != nil {
+			health.Channels = append(health.Channels, *channel)
+		}
+	}
+	return health, nil
+}
+
 func (m *MockStore) MarkAlertNotificationsRead(_ context.Context, request AlertNotificationReadRequest) (int, error) {
 	m.alertMu.Lock()
 	defer m.alertMu.Unlock()
@@ -292,7 +556,19 @@ func (m *MockStore) MarkAlertNotificationsRead(_ context.Context, request AlertN
 	count := 0
 	now := time.Now().Format(time.RFC3339)
 	for i := range m.alertNotifications {
-		if ids[m.alertNotifications[i].ID] && !m.alertNotifications[i].Read {
+		if ids[m.alertNotifications[i].ID] && m.alertNotifications[i].Channel == "in_app" && !m.alertNotifications[i].Read {
+			if len(request.AllowedVINs) > 0 {
+				allowed := false
+				for _, vin := range request.AllowedVINs {
+					if strings.EqualFold(strings.TrimSpace(vin), strings.TrimSpace(m.alertNotifications[i].VehicleVIN)) {
+						allowed = true
+						break
+					}
+				}
+				if !allowed {
+					continue
+				}
+			}
 			m.alertNotifications[i].Read = true
 			m.alertNotifications[i].ReadAt = now
 			count++
@@ -301,6 +577,85 @@ func (m *MockStore) MarkAlertNotificationsRead(_ context.Context, request AlertN
 	return count, nil
 }

+func (m *MockStore) RetryAlertNotification(_ context.Context, id int64, request AlertNotificationRetryRequest) (AlertNotificationRetryResult, error) {
+	m.alertMu.Lock()
+	defer m.alertMu.Unlock()
+	for _, audit := range m.alertNotificationRetryAudits {
+		if audit.ID == 0 {
+			continue
+		}
+		if audit.IdempotencyKey == request.IdempotencyKey {
+			if audit.NotificationID != id {
+				return AlertNotificationRetryResult{}, clientError{Code: "ALERT_NOTIFICATION_RETRY_KEY_REUSED", Message: "重试请求键已经用于其他通知"}
+			}
+			for _, notification := range m.alertNotifications {
+				if notification.ID == id {
+					return AlertNotificationRetryResult{Notification: notification, Receipt: audit, Idempotent: true}, nil
+				}
+			}
+		}
+	}
+	for index := range m.alertNotifications {
+		notification := &m.alertNotifications[index]
+		if notification.ID != id {
+			continue
+		}
+		attemptCount := notification.AttemptCount
+		if attemptCount <= 0 {
+			attemptCount = 1
+		}
+		if notification.DeliveryStatus != "failed" {
+			return AlertNotificationRetryResult{}, clientError{Code: "ALERT_NOTIFICATION_NOT_RETRYABLE", Message: "通知已经离开发送失败状态，请刷新后复核"}
+		}
+		if attemptCount != request.ExpectedAttemptCount {
+			return AlertNotificationRetryResult{}, clientError{Code: "ALERT_NOTIFICATION_ATTEMPT_CONFLICT", Message: "通知尝试次数已经变化，请刷新后重试"}
+		}
+		if attemptCount >= alertNotificationMaxAttempts {
+			return AlertNotificationRetryResult{}, clientError{Code: "ALERT_NOTIFICATION_RETRY_LIMIT", Message: "通知已经达到 3 次投递上限，请检查渠道配置后人工处置"}
+		}
+		nextStatus := "queued"
+		auditNextStatus := "reserved"
+		now := time.Now().Format(time.RFC3339)
+		if notification.Channel == "in_app" {
+			nextStatus = "delivered"
+			auditNextStatus = "sent"
+			notification.DeliveredAt = now
+			notification.ProviderMessageID = "in_app:" + strconv.FormatInt(notification.ID, 10) + ":retry:" + strconv.Itoa(attemptCount+1)
+		} else {
+			notification.ProviderMessageID = ""
+			notification.DeliveredAt = ""
+		}
+		notification.DeliveryStatus = nextStatus
+		notification.AttemptCount = attemptCount + 1
+		notification.LastAttemptAt = now
+		notification.RetryRequestedBy = request.Actor
+		notification.RetryRequestedAt = now
+		notification.RetryAvailable = false
+		notification.MaxAttempts = alertNotificationMaxAttempts
+		m.nextNotificationRetryAuditID++
+		audit := AlertNotificationRetryAudit{
+			ID: m.nextNotificationRetryAuditID, NotificationID: id, IdempotencyKey: request.IdempotencyKey, Actor: request.Actor,
+			Reason: request.Reason, PreviousStatus: "failed", NextStatus: auditNextStatus,
+			AttemptCount: notification.AttemptCount, RequestedAt: now,
+		}
+		m.alertNotificationRetryAudits = append([]AlertNotificationRetryAudit{audit}, m.alertNotificationRetryAudits...)
+		return AlertNotificationRetryResult{Notification: *notification, Receipt: audit}, nil
+	}
+	return AlertNotificationRetryResult{}, clientError{Code: "ALERT_NOTIFICATION_NOT_FOUND", Message: "通知记录不存在"}
+}
+
+func (m *MockStore) AlertNotificationRetryAudits(_ context.Context, id int64) ([]AlertNotificationRetryAudit, error) {
+	m.alertMu.RLock()
+	defer m.alertMu.RUnlock()
+	items := make([]AlertNotificationRetryAudit, 0)
+	for _, audit := range m.alertNotificationRetryAudits {
+		if audit.NotificationID == id {
+			items = append(items, audit)
+		}
+	}
+	return items, nil
+}
+
 func (m *MockStore) EvaluateAlerts(context.Context) (AlertEvaluationResult, error) {
 	return AlertEvaluationResult{RulesEvaluated: len(m.alertRules), VehiclesScanned: len(m.vehicles), AsOf: time.Now().Format(time.RFC3339)}, nil
 }