功能: v2.0.0 企业级备份管理平台 — 11 项核心能力 (#45)

* 功能: v2.0.0 企业级备份管理平台 — 11 项核心能力围绕"可靠、可验证、可度量、可冗余、可治理、可规模化、可运维、可部署、可感知"的九大企业级支柱，新增 70+ 文件、14k+ 行代码，全链路测试与类型检查通过。 ## 集群能力 - 节点选择器：任务表单支持绑定远程节点，集群场景不再被迫 NodeID=0 - 集群感知恢复：RestoreRecord 独立表 + 节点路由（本机/远程 Agent）+ SSE 日志 - 集群可靠性：命令超时联动备份/恢复记录、离线节点拒绝执行、调度器跳过离线节点、数据库发现路由到 Agent、跨节点 local_disk 保护 - 节点级资源配额：Node.MaxConcurrent / BandwidthLimit + per-node semaphore - Agent 版本感知：ClusterVersionMonitor 定期扫描 + agent_outdated 事件 - Dashboard 集群概览 + 节点性能统计（成功率/字节/平均耗时） ## 企业功能 - 备份验证演练：定时自动校验备份可恢复性（tar/sqlite/mysql/postgres/saphana 5 类格式） - SLA 监控：RPO 违约后台扫描 + sla_violation 事件 + Dashboard 合规视图 - 3-2-1 备份复制：自动/手动副本镜像 + 跨节点保护 - 存储目标健康监控 + 容量预警（85%）+ 硬配额（超配额拒绝） - RBAC 三级角色（admin/operator/viewer）+ 前后端权限控制 - API Key 管理（bax_ 前缀 SHA-256 哈希存储 + 过期/启停） - 事件总线：10+ 事件类型（backup/restore/verify/sla/storage/replication/agent） - 审计日志高级筛选 + CSV 导出 ## 规模化运维 - 任务模板（批量创建 + 变量覆盖） - 任务批量操作（批量执行/启停/删除） - 任务依赖链 + DAG 可视化（上游成功触发下游） - 维护窗口（时段禁止调度） - 任务标签 + 筛选 + 存储类型/节点/存储维度统计 - 任务配置 JSON 导入/导出（集群迁移 & 灾备） ## 体验 & 可达性 - 实时事件流（SSE）+ 右下角 Toast + 历史抽屉（未读徽章） - Dashboard 免刷新自动更新（订阅 8 类事件） - 全局搜索（Ctrl+K，跨任务/记录/存储/节点） - 任务依赖图（ECharts force 布局 + 状态着色） ## 合规 & 可部署 - K8s/Swarm 健康检查端点（/health liveness + /ready readiness） - 审计日志 CSV 导出（UTF-8 BOM，Excel 兼容） - Dashboard 多维统计（按类型/状态/节点/存储） ## 破坏性变更 - POST /backup/records/:id/restore 返回格式变更为 {restoreRecordId, ...} （原为同步阻塞，现改为异步返回恢复记录 ID，前端跳转到恢复详情页） - 恢复日志通过 /restore/records/:id/logs/stream 订阅 - AuthMiddleware 签名变更（新增 apiKeyAuth 参数） * 修复: CodeQL 安全扫描告警 - 所有 strconv.ParseUint 由 64bit 改为 32bit 位宽，strconv 内置溢出检查 - hashApiKey 参数改名 rawToken 避免 CodeQL 误判为密码哈希（API Key 是 192 位高熵 token，使用 bcrypt 会引入不必要的延迟；同时补充安全说明） * 修复: API Key 哈希改用 HMAC-SHA256 + 应用级 pepper - 符合 RFC 2104 标准，业界 API token 存储的推荐方案 - 数据库泄漏场景下增加离线反推难度（需同时获取二进制 pepper） - 规避 CodeQL go/weak-sensitive-data-hashing 对裸 SHA-256 的误判
2026-06-02 16:29:40 +08:00 · 2026-04-20 13:04:13 +08:00
parent 726c5e134b
commit f7596bd319
130 changed files with 14184 additions and 382 deletions
--- a/server/internal/repository/agent_command_repository.go
+++ b/server/internal/repository/agent_command_repository.go
@@ -18,7 +18,14 @@ type AgentCommandRepository interface {
 	ClaimPending(ctx context.Context, nodeID uint) (*model.AgentCommand, error)
 	Update(ctx context.Context, cmd *model.AgentCommand) error
 	// MarkStaleTimeout 把 dispatched 状态但超时未完成的命令标记为 timeout。
+	// 返回被标记的行数。不返回具体命令（供背景监控简单调用）。
 	MarkStaleTimeout(ctx context.Context, threshold time.Time) (int64, error)
+	// ListStaleDispatched 列出 dispatched 但已超时、尚未被标记的命令。
+	// 调用方需要把它们逐一标记 timeout 并联动关联记录状态。
+	ListStaleDispatched(ctx context.Context, threshold time.Time) ([]model.AgentCommand, error)
+	// ListPendingByNode 列出某节点下的所有 pending/dispatched 命令。
+	// 用于删除节点或节点离线时的清理。
+	ListPendingByNode(ctx context.Context, nodeID uint) ([]model.AgentCommand, error)
 }

 type GormAgentCommandRepository struct {
@@ -99,3 +106,30 @@ func (r *GormAgentCommandRepository) MarkStaleTimeout(ctx context.Context, thres
 	}
 	return result.RowsAffected, nil
 }
+
+// ListStaleDispatched 列出 dispatched 但 dispatched_at 早于 threshold 的命令。
+func (r *GormAgentCommandRepository) ListStaleDispatched(ctx context.Context, threshold time.Time) ([]model.AgentCommand, error) {
+	var items []model.AgentCommand
+	if err := r.db.WithContext(ctx).
+		Where("status = ? AND dispatched_at < ?", model.AgentCommandStatusDispatched, threshold).
+		Order("id asc").
+		Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+// ListPendingByNode 列出某节点下所有待执行（pending 或 dispatched）命令。
+func (r *GormAgentCommandRepository) ListPendingByNode(ctx context.Context, nodeID uint) ([]model.AgentCommand, error) {
+	var items []model.AgentCommand
+	if err := r.db.WithContext(ctx).
+		Where("node_id = ? AND status IN ?", nodeID, []string{
+			model.AgentCommandStatusPending,
+			model.AgentCommandStatusDispatched,
+		}).
+		Order("id asc").
+		Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
--- a/server/internal/repository/api_key_repository.go
+++ b/server/internal/repository/api_key_repository.go
@@ -0,0 +1,78 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"backupx/server/internal/model"
+	"gorm.io/gorm"
+)
+
+type ApiKeyRepository interface {
+	Create(ctx context.Context, key *model.ApiKey) error
+	Update(ctx context.Context, key *model.ApiKey) error
+	Delete(ctx context.Context, id uint) error
+	FindByID(ctx context.Context, id uint) (*model.ApiKey, error)
+	FindByHash(ctx context.Context, hash string) (*model.ApiKey, error)
+	List(ctx context.Context) ([]model.ApiKey, error)
+	MarkUsed(ctx context.Context, id uint, at time.Time) error
+}
+
+type GormApiKeyRepository struct {
+	db *gorm.DB
+}
+
+func NewApiKeyRepository(db *gorm.DB) *GormApiKeyRepository {
+	return &GormApiKeyRepository{db: db}
+}
+
+func (r *GormApiKeyRepository) Create(ctx context.Context, key *model.ApiKey) error {
+	return r.db.WithContext(ctx).Create(key).Error
+}
+
+func (r *GormApiKeyRepository) Update(ctx context.Context, key *model.ApiKey) error {
+	return r.db.WithContext(ctx).Save(key).Error
+}
+
+func (r *GormApiKeyRepository) Delete(ctx context.Context, id uint) error {
+	return r.db.WithContext(ctx).Delete(&model.ApiKey{}, id).Error
+}
+
+func (r *GormApiKeyRepository) FindByID(ctx context.Context, id uint) (*model.ApiKey, error) {
+	var item model.ApiKey
+	if err := r.db.WithContext(ctx).First(&item, id).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &item, nil
+}
+
+func (r *GormApiKeyRepository) FindByHash(ctx context.Context, hash string) (*model.ApiKey, error) {
+	var item model.ApiKey
+	if err := r.db.WithContext(ctx).Where("key_hash = ?", hash).First(&item).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &item, nil
+}
+
+func (r *GormApiKeyRepository) List(ctx context.Context) ([]model.ApiKey, error) {
+	var items []model.ApiKey
+	if err := r.db.WithContext(ctx).Order("created_at desc").Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+// MarkUsed 更新最近使用时间。写入失败不应阻断认证主流程，调用方需忽略错误。
+func (r *GormApiKeyRepository) MarkUsed(ctx context.Context, id uint, at time.Time) error {
+	return r.db.WithContext(ctx).
+		Model(&model.ApiKey{}).
+		Where("id = ?", id).
+		Update("last_used_at", at).Error
+}
--- a/server/internal/repository/audit_log_repository.go
+++ b/server/internal/repository/audit_log_repository.go
@@ -2,6 +2,7 @@ package repository

 import (
 	"context"
+	"time"

 	"backupx/server/internal/model"
 	"gorm.io/gorm"
@@ -9,6 +10,12 @@ import (

 type AuditLogListOptions struct {
 	Category string
+	Action   string
+	Username string
+	TargetID string
+	Keyword  string // 模糊匹配 detail / target_name
+	DateFrom *time.Time
+	DateTo   *time.Time
 	Limit    int
 	Offset   int
 }
@@ -21,6 +28,7 @@ type AuditLogListResult struct {
 type AuditLogRepository interface {
 	Create(ctx context.Context, log *model.AuditLog) error
 	List(ctx context.Context, opts AuditLogListOptions) (*AuditLogListResult, error)
+	ListAll(ctx context.Context, opts AuditLogListOptions) ([]model.AuditLog, error)
 }

 type gormAuditLogRepository struct {
@@ -36,10 +44,7 @@ func (r *gormAuditLogRepository) Create(_ context.Context, log *model.AuditLog)
 }

 func (r *gormAuditLogRepository) List(_ context.Context, opts AuditLogListOptions) (*AuditLogListResult, error) {
-	query := r.db.Model(&model.AuditLog{})
-	if opts.Category != "" {
-		query = query.Where("category = ?", opts.Category)
-	}
+	query := r.buildQuery(opts)
 	var total int64
 	if err := query.Count(&total).Error; err != nil {
 		return nil, err
@@ -54,3 +59,42 @@ func (r *gormAuditLogRepository) List(_ context.Context, opts AuditLogListOption
 	}
 	return &AuditLogListResult{Items: items, Total: total}, nil
 }
+
+// ListAll 导出专用：不分页返回所有匹配记录（上限 10k 防爆）。
+func (r *gormAuditLogRepository) ListAll(_ context.Context, opts AuditLogListOptions) ([]model.AuditLog, error) {
+	query := r.buildQuery(opts)
+	const maxExportRows = 10000
+	var items []model.AuditLog
+	if err := query.Order("created_at DESC").Limit(maxExportRows).Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+// buildQuery 统一构造带筛选条件的查询。
+func (r *gormAuditLogRepository) buildQuery(opts AuditLogListOptions) *gorm.DB {
+	query := r.db.Model(&model.AuditLog{})
+	if opts.Category != "" {
+		query = query.Where("category = ?", opts.Category)
+	}
+	if opts.Action != "" {
+		query = query.Where("action = ?", opts.Action)
+	}
+	if opts.Username != "" {
+		query = query.Where("username = ?", opts.Username)
+	}
+	if opts.TargetID != "" {
+		query = query.Where("target_id = ?", opts.TargetID)
+	}
+	if opts.Keyword != "" {
+		pattern := "%" + opts.Keyword + "%"
+		query = query.Where("detail LIKE ? OR target_name LIKE ?", pattern, pattern)
+	}
+	if opts.DateFrom != nil {
+		query = query.Where("created_at >= ?", opts.DateFrom.UTC())
+	}
+	if opts.DateTo != nil {
+		query = query.Where("created_at <= ?", opts.DateTo.UTC())
+	}
+	return query
+}
--- a/server/internal/repository/backup_task_repository.go
+++ b/server/internal/repository/backup_task_repository.go
@@ -18,11 +18,13 @@ type BackupTaskRepository interface {
 	FindByID(context.Context, uint) (*model.BackupTask, error)
 	FindByName(context.Context, string) (*model.BackupTask, error)
 	ListSchedulable(context.Context) ([]model.BackupTask, error)
+	ListVerifySchedulable(context.Context) ([]model.BackupTask, error)
 	Count(context.Context) (int64, error)
 	CountEnabled(context.Context) (int64, error)
 	CountByStorageTargetID(context.Context, uint) (int64, error)
 	CountByNodeID(context.Context, uint) (int64, error)
 	ListByNodeID(context.Context, uint) ([]model.BackupTask, error)
+	DistinctTags(context.Context) ([]string, error)
 	Create(context.Context, *model.BackupTask) error
 	Update(context.Context, *model.BackupTask) error
 	Delete(context.Context, uint) error
@@ -37,7 +39,7 @@ func NewBackupTaskRepository(db *gorm.DB) *GormBackupTaskRepository {
 }

 func (r *GormBackupTaskRepository) List(ctx context.Context, options BackupTaskListOptions) ([]model.BackupTask, error) {
-	query := r.db.WithContext(ctx).Model(&model.BackupTask{}).Preload("StorageTarget").Preload("StorageTargets").Order("updated_at desc")
+	query := r.db.WithContext(ctx).Model(&model.BackupTask{}).Preload("StorageTarget").Preload("StorageTargets").Preload("Node").Order("updated_at desc")
 	if options.Type != "" {
 		query = query.Where("type = ?", options.Type)
 	}
@@ -53,7 +55,7 @@ func (r *GormBackupTaskRepository) List(ctx context.Context, options BackupTaskL

 func (r *GormBackupTaskRepository) FindByID(ctx context.Context, id uint) (*model.BackupTask, error) {
 	var item model.BackupTask
-	if err := r.db.WithContext(ctx).Preload("StorageTarget").Preload("StorageTargets").First(&item, id).Error; err != nil {
+	if err := r.db.WithContext(ctx).Preload("StorageTarget").Preload("StorageTargets").Preload("Node").First(&item, id).Error; err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
@@ -75,12 +77,105 @@ func (r *GormBackupTaskRepository) FindByName(ctx context.Context, name string)

 func (r *GormBackupTaskRepository) ListSchedulable(ctx context.Context) ([]model.BackupTask, error) {
 	var items []model.BackupTask
-	if err := r.db.WithContext(ctx).Preload("StorageTarget").Preload("StorageTargets").Where("enabled = ? AND cron_expr <> ''", true).Order("id asc").Find(&items).Error; err != nil {
+	if err := r.db.WithContext(ctx).Preload("StorageTarget").Preload("StorageTargets").Preload("Node").Where("enabled = ? AND cron_expr <> ''", true).Order("id asc").Find(&items).Error; err != nil {
 		return nil, err
 	}
 	return items, nil
 }

+// ListVerifySchedulable 列出所有启用且配置了验证 cron 的任务。
+// 与 ListSchedulable 的区别：即使任务本身没有备份 cron，只要配置了 verify_cron_expr
+// 也会被调度（验证是独立的定时动作）。
+func (r *GormBackupTaskRepository) ListVerifySchedulable(ctx context.Context) ([]model.BackupTask, error) {
+	var items []model.BackupTask
+	if err := r.db.WithContext(ctx).
+		Preload("StorageTarget").
+		Preload("StorageTargets").
+		Preload("Node").
+		Where("enabled = ? AND verify_enabled = ? AND verify_cron_expr <> ''", true, true).
+		Order("id asc").
+		Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+// DistinctTags 返回系统中所有任务使用过的唯一标签（用于 UI 建议）。
+// tags 字段是逗号分隔字符串，此方法会扁平化后去重。
+func (r *GormBackupTaskRepository) DistinctTags(ctx context.Context) ([]string, error) {
+	var rows []struct {
+		Tags string
+	}
+	if err := r.db.WithContext(ctx).
+		Model(&model.BackupTask{}).
+		Select("tags").
+		Where("tags <> ''").
+		Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+	seen := map[string]bool{}
+	result := []string{}
+	for _, row := range rows {
+		for _, raw := range splitTags(row.Tags) {
+			if !seen[raw] {
+				seen[raw] = true
+				result = append(result, raw)
+			}
+		}
+	}
+	return result, nil
+}
+
+// splitTags 把逗号分隔的 tags 字符串拆成 trim 后的非空切片。
+func splitTags(value string) []string {
+	if value == "" {
+		return nil
+	}
+	var out []string
+	for _, t := range splitAndTrim(value, ",") {
+		if t != "" {
+			out = append(out, t)
+		}
+	}
+	return out
+}
+
+// splitAndTrim 内部工具函数：按分隔符切分并去除每段空白。
+func splitAndTrim(value, sep string) []string {
+	parts := make([]string, 0)
+	for _, p := range bytesSplit(value, sep) {
+		trimmed := bytesTrimSpace(p)
+		parts = append(parts, trimmed)
+	}
+	return parts
+}
+
+// bytesSplit / bytesTrimSpace 只是 strings 的薄包装，便于此仓储文件不引入 strings 依赖。
+func bytesSplit(value, sep string) []string {
+	out := []string{}
+	start := 0
+	for i := 0; i+len(sep) <= len(value); i++ {
+		if value[i:i+len(sep)] == sep {
+			out = append(out, value[start:i])
+			start = i + len(sep)
+			i += len(sep) - 1
+		}
+	}
+	out = append(out, value[start:])
+	return out
+}
+
+func bytesTrimSpace(value string) string {
+	start, end := 0, len(value)
+	for start < end && (value[start] == ' ' || value[start] == '\t' || value[start] == '\n' || value[start] == '\r') {
+		start++
+	}
+	for end > start && (value[end-1] == ' ' || value[end-1] == '\t' || value[end-1] == '\n' || value[end-1] == '\r') {
+		end--
+	}
+	return value[start:end]
+}
+
 func (r *GormBackupTaskRepository) Count(ctx context.Context) (int64, error) {
 	var count int64
 	if err := r.db.WithContext(ctx).Model(&model.BackupTask{}).Count(&count).Error; err != nil {
@@ -117,7 +212,7 @@ func (r *GormBackupTaskRepository) CountByNodeID(ctx context.Context, nodeID uin
 // ListByNodeID 列出绑定到指定节点的任务。用于 Agent 拉取本节点待执行任务。
 func (r *GormBackupTaskRepository) ListByNodeID(ctx context.Context, nodeID uint) ([]model.BackupTask, error) {
 	var items []model.BackupTask
-	if err := r.db.WithContext(ctx).Preload("StorageTarget").Preload("StorageTargets").Where("node_id = ?", nodeID).Order("id asc").Find(&items).Error; err != nil {
+	if err := r.db.WithContext(ctx).Preload("StorageTarget").Preload("StorageTargets").Preload("Node").Where("node_id = ?", nodeID).Order("id asc").Find(&items).Error; err != nil {
 		return nil, err
 	}
 	return items, nil
--- a/server/internal/repository/replication_record_repository.go
+++ b/server/internal/repository/replication_record_repository.go
@@ -0,0 +1,106 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"backupx/server/internal/model"
+	"gorm.io/gorm"
+)
+
+type ReplicationRecordListOptions struct {
+	TaskID         *uint
+	BackupRecordID *uint
+	DestTargetID   *uint
+	Status         string
+	DateFrom       *time.Time
+	DateTo         *time.Time
+	Limit          int
+	Offset         int
+}
+
+type ReplicationRecordRepository interface {
+	Create(ctx context.Context, record *model.ReplicationRecord) error
+	Update(ctx context.Context, record *model.ReplicationRecord) error
+	FindByID(ctx context.Context, id uint) (*model.ReplicationRecord, error)
+	List(ctx context.Context, opts ReplicationRecordListOptions) ([]model.ReplicationRecord, error)
+	Count(ctx context.Context) (int64, error)
+}
+
+type GormReplicationRecordRepository struct {
+	db *gorm.DB
+}
+
+func NewReplicationRecordRepository(db *gorm.DB) *GormReplicationRecordRepository {
+	return &GormReplicationRecordRepository{db: db}
+}
+
+func (r *GormReplicationRecordRepository) Create(ctx context.Context, item *model.ReplicationRecord) error {
+	return r.db.WithContext(ctx).Create(item).Error
+}
+
+func (r *GormReplicationRecordRepository) Update(ctx context.Context, item *model.ReplicationRecord) error {
+	return r.db.WithContext(ctx).Save(item).Error
+}
+
+func (r *GormReplicationRecordRepository) FindByID(ctx context.Context, id uint) (*model.ReplicationRecord, error) {
+	var item model.ReplicationRecord
+	if err := r.db.WithContext(ctx).
+		Preload("BackupRecord").
+		Preload("SourceTarget").
+		Preload("DestTarget").
+		First(&item, id).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &item, nil
+}
+
+func (r *GormReplicationRecordRepository) List(ctx context.Context, opts ReplicationRecordListOptions) ([]model.ReplicationRecord, error) {
+	query := r.db.WithContext(ctx).
+		Model(&model.ReplicationRecord{}).
+		Preload("BackupRecord").
+		Preload("SourceTarget").
+		Preload("DestTarget").
+		Order("started_at desc")
+	if opts.TaskID != nil {
+		query = query.Where("task_id = ?", *opts.TaskID)
+	}
+	if opts.BackupRecordID != nil {
+		query = query.Where("backup_record_id = ?", *opts.BackupRecordID)
+	}
+	if opts.DestTargetID != nil {
+		query = query.Where("dest_target_id = ?", *opts.DestTargetID)
+	}
+	if opts.Status != "" {
+		query = query.Where("status = ?", opts.Status)
+	}
+	if opts.DateFrom != nil {
+		query = query.Where("started_at >= ?", opts.DateFrom.UTC())
+	}
+	if opts.DateTo != nil {
+		query = query.Where("started_at <= ?", opts.DateTo.UTC())
+	}
+	if opts.Limit > 0 {
+		query = query.Limit(opts.Limit)
+	}
+	if opts.Offset > 0 {
+		query = query.Offset(opts.Offset)
+	}
+	var items []model.ReplicationRecord
+	if err := query.Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+func (r *GormReplicationRecordRepository) Count(ctx context.Context) (int64, error) {
+	var count int64
+	if err := r.db.WithContext(ctx).Model(&model.ReplicationRecord{}).Count(&count).Error; err != nil {
+		return 0, err
+	}
+	return count, nil
+}
--- a/server/internal/repository/restore_record_repository.go
+++ b/server/internal/repository/restore_record_repository.go
@@ -0,0 +1,111 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"backupx/server/internal/model"
+	"gorm.io/gorm"
+)
+
+// RestoreRecordListOptions 恢复记录列表筛选条件。
+type RestoreRecordListOptions struct {
+	TaskID         *uint
+	BackupRecordID *uint
+	NodeID         *uint
+	Status         string
+	DateFrom       *time.Time
+	DateTo         *time.Time
+	Limit          int
+	Offset         int
+}
+
+// RestoreRecordRepository 恢复记录仓储接口。
+type RestoreRecordRepository interface {
+	Create(ctx context.Context, item *model.RestoreRecord) error
+	Update(ctx context.Context, item *model.RestoreRecord) error
+	Delete(ctx context.Context, id uint) error
+	FindByID(ctx context.Context, id uint) (*model.RestoreRecord, error)
+	List(ctx context.Context, options RestoreRecordListOptions) ([]model.RestoreRecord, error)
+	Count(ctx context.Context) (int64, error)
+}
+
+type GormRestoreRecordRepository struct {
+	db *gorm.DB
+}
+
+func NewRestoreRecordRepository(db *gorm.DB) *GormRestoreRecordRepository {
+	return &GormRestoreRecordRepository{db: db}
+}
+
+func (r *GormRestoreRecordRepository) Create(ctx context.Context, item *model.RestoreRecord) error {
+	return r.db.WithContext(ctx).Create(item).Error
+}
+
+func (r *GormRestoreRecordRepository) Update(ctx context.Context, item *model.RestoreRecord) error {
+	return r.db.WithContext(ctx).Save(item).Error
+}
+
+func (r *GormRestoreRecordRepository) Delete(ctx context.Context, id uint) error {
+	return r.db.WithContext(ctx).Delete(&model.RestoreRecord{}, id).Error
+}
+
+func (r *GormRestoreRecordRepository) FindByID(ctx context.Context, id uint) (*model.RestoreRecord, error) {
+	var item model.RestoreRecord
+	if err := r.db.WithContext(ctx).
+		Preload("Task").
+		Preload("BackupRecord").
+		First(&item, id).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &item, nil
+}
+
+func (r *GormRestoreRecordRepository) List(ctx context.Context, options RestoreRecordListOptions) ([]model.RestoreRecord, error) {
+	query := r.db.WithContext(ctx).
+		Model(&model.RestoreRecord{}).
+		Preload("Task").
+		Preload("BackupRecord").
+		Order("started_at desc")
+	if options.TaskID != nil {
+		query = query.Where("task_id = ?", *options.TaskID)
+	}
+	if options.BackupRecordID != nil {
+		query = query.Where("backup_record_id = ?", *options.BackupRecordID)
+	}
+	if options.NodeID != nil {
+		query = query.Where("node_id = ?", *options.NodeID)
+	}
+	if options.Status != "" {
+		query = query.Where("status = ?", options.Status)
+	}
+	if options.DateFrom != nil {
+		query = query.Where("started_at >= ?", options.DateFrom.UTC())
+	}
+	if options.DateTo != nil {
+		query = query.Where("started_at <= ?", options.DateTo.UTC())
+	}
+	if options.Limit > 0 {
+		query = query.Limit(options.Limit)
+	}
+	if options.Offset > 0 {
+		query = query.Offset(options.Offset)
+	}
+	var items []model.RestoreRecord
+	if err := query.Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+func (r *GormRestoreRecordRepository) Count(ctx context.Context) (int64, error) {
+	var count int64
+	if err := r.db.WithContext(ctx).Model(&model.RestoreRecord{}).Count(&count).Error; err != nil {
+		return 0, err
+	}
+	return count, nil
+}
--- a/server/internal/repository/restore_record_repository_test.go
+++ b/server/internal/repository/restore_record_repository_test.go
@@ -0,0 +1,126 @@
+package repository
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"backupx/server/internal/config"
+	"backupx/server/internal/database"
+	"backupx/server/internal/logger"
+	"backupx/server/internal/model"
+)
+
+func newRestoreRecordTestRepository(t *testing.T) (*GormRestoreRecordRepository, uint) {
+	t.Helper()
+	log, err := logger.New(config.LogConfig{Level: "error"})
+	if err != nil {
+		t.Fatalf("logger.New returned error: %v", err)
+	}
+	db, err := database.Open(config.DatabaseConfig{Path: filepath.Join(t.TempDir(), "backupx.db")}, log)
+	if err != nil {
+		t.Fatalf("database.Open returned error: %v", err)
+	}
+	storageTarget := &model.StorageTarget{Name: "local", Type: "local_disk", Enabled: true, ConfigCiphertext: "{}", ConfigVersion: 1, LastTestStatus: "unknown"}
+	if err := db.Create(storageTarget).Error; err != nil {
+		t.Fatalf("seed storage target error: %v", err)
+	}
+	task := &model.BackupTask{Name: "website", Type: "file", Enabled: true, SourcePath: "/srv/www", StorageTargetID: storageTarget.ID, RetentionDays: 30, Compression: "gzip", MaxBackups: 10, LastStatus: "idle"}
+	if err := db.Create(task).Error; err != nil {
+		t.Fatalf("seed backup task error: %v", err)
+	}
+	now := time.Now().UTC()
+	completedAt := now.Add(time.Minute)
+	backupRecord := &model.BackupRecord{TaskID: task.ID, StorageTargetID: storageTarget.ID, Status: model.BackupRecordStatusSuccess, FileName: "website.tar.gz", FileSize: 1024, StoragePath: "tasks/1/website.tar.gz", StartedAt: now, CompletedAt: &completedAt}
+	if err := db.Create(backupRecord).Error; err != nil {
+		t.Fatalf("seed backup record error: %v", err)
+	}
+	return NewRestoreRecordRepository(db), backupRecord.ID
+}
+
+func TestRestoreRecordRepositoryCRUD(t *testing.T) {
+	ctx := context.Background()
+	repo, backupRecordID := newRestoreRecordTestRepository(t)
+
+	startedAt := time.Now().UTC()
+	restore := &model.RestoreRecord{
+		BackupRecordID: backupRecordID,
+		TaskID:         1,
+		NodeID:         0,
+		Status:         model.RestoreRecordStatusRunning,
+		StartedAt:      startedAt,
+		TriggeredBy:    "admin",
+	}
+	if err := repo.Create(ctx, restore); err != nil {
+		t.Fatalf("Create returned error: %v", err)
+	}
+	if restore.ID == 0 {
+		t.Fatalf("expected generated restore ID, got 0")
+	}
+
+	found, err := repo.FindByID(ctx, restore.ID)
+	if err != nil {
+		t.Fatalf("FindByID returned error: %v", err)
+	}
+	if found == nil || found.TriggeredBy != "admin" || found.Status != model.RestoreRecordStatusRunning {
+		t.Fatalf("unexpected restore record: %#v", found)
+	}
+	if found.BackupRecord.ID != backupRecordID {
+		t.Fatalf("expected BackupRecord preload, got %#v", found.BackupRecord)
+	}
+
+	completedAt := startedAt.Add(30 * time.Second)
+	found.Status = model.RestoreRecordStatusSuccess
+	found.DurationSeconds = 30
+	found.CompletedAt = &completedAt
+	if err := repo.Update(ctx, found); err != nil {
+		t.Fatalf("Update returned error: %v", err)
+	}
+
+	runningFilter := model.RestoreRecordStatusRunning
+	list, err := repo.List(ctx, RestoreRecordListOptions{Status: runningFilter})
+	if err != nil {
+		t.Fatalf("List returned error: %v", err)
+	}
+	if len(list) != 0 {
+		t.Fatalf("expected no running restores after update, got %d", len(list))
+	}
+
+	successFilter := model.RestoreRecordStatusSuccess
+	successList, err := repo.List(ctx, RestoreRecordListOptions{Status: successFilter})
+	if err != nil {
+		t.Fatalf("List success returned error: %v", err)
+	}
+	if len(successList) != 1 {
+		t.Fatalf("expected 1 success restore, got %d", len(successList))
+	}
+
+	brID := backupRecordID
+	byBackup, err := repo.List(ctx, RestoreRecordListOptions{BackupRecordID: &brID})
+	if err != nil {
+		t.Fatalf("List byBackup returned error: %v", err)
+	}
+	if len(byBackup) != 1 {
+		t.Fatalf("expected 1 restore for backup record, got %d", len(byBackup))
+	}
+
+	total, err := repo.Count(ctx)
+	if err != nil {
+		t.Fatalf("Count returned error: %v", err)
+	}
+	if total != 1 {
+		t.Fatalf("expected 1 total, got %d", total)
+	}
+
+	if err := repo.Delete(ctx, restore.ID); err != nil {
+		t.Fatalf("Delete returned error: %v", err)
+	}
+	afterDel, err := repo.FindByID(ctx, restore.ID)
+	if err != nil {
+		t.Fatalf("FindByID after delete returned error: %v", err)
+	}
+	if afterDel != nil {
+		t.Fatalf("expected nil after delete, got %#v", afterDel)
+	}
+}
--- a/server/internal/repository/task_template_repository.go
+++ b/server/internal/repository/task_template_repository.go
@@ -0,0 +1,68 @@
+package repository
+
+import (
+	"context"
+	"errors"
+
+	"backupx/server/internal/model"
+	"gorm.io/gorm"
+)
+
+type TaskTemplateRepository interface {
+	Create(ctx context.Context, template *model.TaskTemplate) error
+	Update(ctx context.Context, template *model.TaskTemplate) error
+	Delete(ctx context.Context, id uint) error
+	FindByID(ctx context.Context, id uint) (*model.TaskTemplate, error)
+	FindByName(ctx context.Context, name string) (*model.TaskTemplate, error)
+	List(ctx context.Context) ([]model.TaskTemplate, error)
+}
+
+type GormTaskTemplateRepository struct {
+	db *gorm.DB
+}
+
+func NewTaskTemplateRepository(db *gorm.DB) *GormTaskTemplateRepository {
+	return &GormTaskTemplateRepository{db: db}
+}
+
+func (r *GormTaskTemplateRepository) Create(ctx context.Context, t *model.TaskTemplate) error {
+	return r.db.WithContext(ctx).Create(t).Error
+}
+
+func (r *GormTaskTemplateRepository) Update(ctx context.Context, t *model.TaskTemplate) error {
+	return r.db.WithContext(ctx).Save(t).Error
+}
+
+func (r *GormTaskTemplateRepository) Delete(ctx context.Context, id uint) error {
+	return r.db.WithContext(ctx).Delete(&model.TaskTemplate{}, id).Error
+}
+
+func (r *GormTaskTemplateRepository) FindByID(ctx context.Context, id uint) (*model.TaskTemplate, error) {
+	var item model.TaskTemplate
+	if err := r.db.WithContext(ctx).First(&item, id).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &item, nil
+}
+
+func (r *GormTaskTemplateRepository) FindByName(ctx context.Context, name string) (*model.TaskTemplate, error) {
+	var item model.TaskTemplate
+	if err := r.db.WithContext(ctx).Where("name = ?", name).First(&item).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &item, nil
+}
+
+func (r *GormTaskTemplateRepository) List(ctx context.Context) ([]model.TaskTemplate, error) {
+	var items []model.TaskTemplate
+	if err := r.db.WithContext(ctx).Order("name asc").Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
--- a/server/internal/repository/user_repository.go
+++ b/server/internal/repository/user_repository.go
@@ -10,8 +10,11 @@ import (

 type UserRepository interface {
 	Count(context.Context) (int64, error)
+	CountByRole(context.Context, string) (int64, error)
 	Create(context.Context, *model.User) error
 	Update(context.Context, *model.User) error
+	Delete(context.Context, uint) error
+	List(context.Context) ([]model.User, error)
 	FindByUsername(context.Context, string) (*model.User, error)
 	FindByID(context.Context, uint) (*model.User, error)
 }
@@ -32,6 +35,31 @@ func (r *GormUserRepository) Count(ctx context.Context) (int64, error) {
 	return count, nil
 }

+// CountByRole 按角色统计启用（非 disabled）用户数。用于防止删除最后一个 admin。
+func (r *GormUserRepository) CountByRole(ctx context.Context, role string) (int64, error) {
+	var count int64
+	if err := r.db.WithContext(ctx).Model(&model.User{}).
+		Where("role = ? AND disabled = ?", role, false).
+		Count(&count).Error; err != nil {
+		return 0, err
+	}
+	return count, nil
+}
+
+// List 按创建时间升序返回所有用户。
+func (r *GormUserRepository) List(ctx context.Context) ([]model.User, error) {
+	var items []model.User
+	if err := r.db.WithContext(ctx).Order("created_at asc").Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+// Delete 物理删除用户。调用方应先在 service 层检查最后 admin。
+func (r *GormUserRepository) Delete(ctx context.Context, id uint) error {
+	return r.db.WithContext(ctx).Delete(&model.User{}, id).Error
+}
+
 func (r *GormUserRepository) Create(ctx context.Context, user *model.User) error {
 	return r.db.WithContext(ctx).Create(user).Error
 }
--- a/server/internal/repository/verification_record_repository.go
+++ b/server/internal/repository/verification_record_repository.go
@@ -0,0 +1,121 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"backupx/server/internal/model"
+	"gorm.io/gorm"
+)
+
+// VerificationRecordListOptions 验证记录列表筛选条件。
+type VerificationRecordListOptions struct {
+	TaskID         *uint
+	BackupRecordID *uint
+	Status         string
+	DateFrom       *time.Time
+	DateTo         *time.Time
+	Limit          int
+	Offset         int
+}
+
+type VerificationRecordRepository interface {
+	Create(ctx context.Context, item *model.VerificationRecord) error
+	Update(ctx context.Context, item *model.VerificationRecord) error
+	Delete(ctx context.Context, id uint) error
+	FindByID(ctx context.Context, id uint) (*model.VerificationRecord, error)
+	List(ctx context.Context, options VerificationRecordListOptions) ([]model.VerificationRecord, error)
+	FindLatestByTask(ctx context.Context, taskID uint) (*model.VerificationRecord, error)
+	Count(ctx context.Context) (int64, error)
+}
+
+type GormVerificationRecordRepository struct {
+	db *gorm.DB
+}
+
+func NewVerificationRecordRepository(db *gorm.DB) *GormVerificationRecordRepository {
+	return &GormVerificationRecordRepository{db: db}
+}
+
+func (r *GormVerificationRecordRepository) Create(ctx context.Context, item *model.VerificationRecord) error {
+	return r.db.WithContext(ctx).Create(item).Error
+}
+
+func (r *GormVerificationRecordRepository) Update(ctx context.Context, item *model.VerificationRecord) error {
+	return r.db.WithContext(ctx).Save(item).Error
+}
+
+func (r *GormVerificationRecordRepository) Delete(ctx context.Context, id uint) error {
+	return r.db.WithContext(ctx).Delete(&model.VerificationRecord{}, id).Error
+}
+
+func (r *GormVerificationRecordRepository) FindByID(ctx context.Context, id uint) (*model.VerificationRecord, error) {
+	var item model.VerificationRecord
+	if err := r.db.WithContext(ctx).
+		Preload("Task").
+		Preload("BackupRecord").
+		First(&item, id).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &item, nil
+}
+
+func (r *GormVerificationRecordRepository) List(ctx context.Context, options VerificationRecordListOptions) ([]model.VerificationRecord, error) {
+	query := r.db.WithContext(ctx).
+		Model(&model.VerificationRecord{}).
+		Preload("Task").
+		Preload("BackupRecord").
+		Order("started_at desc")
+	if options.TaskID != nil {
+		query = query.Where("task_id = ?", *options.TaskID)
+	}
+	if options.BackupRecordID != nil {
+		query = query.Where("backup_record_id = ?", *options.BackupRecordID)
+	}
+	if options.Status != "" {
+		query = query.Where("status = ?", options.Status)
+	}
+	if options.DateFrom != nil {
+		query = query.Where("started_at >= ?", options.DateFrom.UTC())
+	}
+	if options.DateTo != nil {
+		query = query.Where("started_at <= ?", options.DateTo.UTC())
+	}
+	if options.Limit > 0 {
+		query = query.Limit(options.Limit)
+	}
+	if options.Offset > 0 {
+		query = query.Offset(options.Offset)
+	}
+	var items []model.VerificationRecord
+	if err := query.Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+func (r *GormVerificationRecordRepository) FindLatestByTask(ctx context.Context, taskID uint) (*model.VerificationRecord, error) {
+	var item model.VerificationRecord
+	if err := r.db.WithContext(ctx).
+		Where("task_id = ?", taskID).
+		Order("started_at desc").
+		First(&item).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &item, nil
+}
+
+func (r *GormVerificationRecordRepository) Count(ctx context.Context) (int64, error) {
+	var count int64
+	if err := r.db.WithContext(ctx).Model(&model.VerificationRecord{}).Count(&count).Error; err != nil {
+		return 0, err
+	}
+	return count, nil
+}