mirror of
https://github.com/Awuqing/BackupX.git
synced 2026-08-28 19:47:27 +08:00
Awuqing
c06bbec383
Remove obsolete implementations, centralize background task ownership and terminal-state recovery, consolidate frontend routing and log streaming, and enforce project-wide verification in CI.
237 lines
8.4 KiB
Go
237 lines
8.4 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"strings"
|
|
|
|
"backupx/server/internal/apperror"
|
|
"backupx/server/internal/model"
|
|
"backupx/server/internal/repository"
|
|
)
|
|
|
|
// TaskTemplateService 管理任务模板 + 一键批量创建任务。
|
|
type TaskTemplateService struct {
|
|
templates repository.TaskTemplateRepository
|
|
tasks *BackupTaskService
|
|
}
|
|
|
|
func NewTaskTemplateService(templates repository.TaskTemplateRepository, tasks *BackupTaskService) *TaskTemplateService {
|
|
return &TaskTemplateService{templates: templates, tasks: tasks}
|
|
}
|
|
|
|
type TaskTemplateSummary struct {
|
|
ID uint `json:"id"`
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
TaskType string `json:"taskType"`
|
|
CreatedBy string `json:"createdBy"`
|
|
CreatedAt string `json:"createdAt"`
|
|
UpdatedAt string `json:"updatedAt"`
|
|
}
|
|
|
|
type TaskTemplateDetail struct {
|
|
TaskTemplateSummary
|
|
Payload BackupTaskUpsertInput `json:"payload"`
|
|
}
|
|
|
|
// TaskTemplateUpsertInput 创建/更新模板时的输入。
|
|
// Payload 字段与 BackupTaskUpsertInput 复用同一结构。
|
|
type TaskTemplateUpsertInput struct {
|
|
Name string `json:"name" binding:"required,min=1,max=128"`
|
|
Description string `json:"description" binding:"max=500"`
|
|
Payload BackupTaskUpsertInput `json:"payload" binding:"required"`
|
|
}
|
|
|
|
// TaskTemplateApplyInput 应用模板批量创建任务。
|
|
// 每个 Variables 条目会用 Variables 中的字段覆盖模板 Payload 生成一个新任务：
|
|
// - name 必填（覆盖模板 Name，任务命名）
|
|
// - sourcePath / sourcePaths / dbHost / dbName 若提供则覆盖
|
|
type TaskTemplateApplyInput struct {
|
|
Variables []TaskTemplateVariables `json:"variables" binding:"required,min=1,max=100"`
|
|
}
|
|
|
|
type TaskTemplateVariables struct {
|
|
Name string `json:"name" binding:"required,min=1,max=100"`
|
|
SourcePath string `json:"sourcePath"`
|
|
SourcePaths []string `json:"sourcePaths"`
|
|
DBHost string `json:"dbHost"`
|
|
DBName string `json:"dbName"`
|
|
Tags string `json:"tags"`
|
|
NodeID *uint `json:"nodeId"`
|
|
}
|
|
|
|
// TaskTemplateApplyResult 单个任务的创建结果。
|
|
type TaskTemplateApplyResult struct {
|
|
Name string `json:"name"`
|
|
TaskID uint `json:"taskId,omitempty"`
|
|
Success bool `json:"success"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
func (s *TaskTemplateService) List(ctx context.Context) ([]TaskTemplateSummary, error) {
|
|
items, err := s.templates.List(ctx)
|
|
if err != nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_LIST_FAILED", "无法获取任务模板列表", err)
|
|
}
|
|
result := make([]TaskTemplateSummary, 0, len(items))
|
|
for i := range items {
|
|
result = append(result, toTemplateSummary(&items[i]))
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (s *TaskTemplateService) Get(ctx context.Context, id uint) (*TaskTemplateDetail, error) {
|
|
item, err := s.templates.FindByID(ctx, id)
|
|
if err != nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_GET_FAILED", "无法获取任务模板", err)
|
|
}
|
|
if item == nil {
|
|
return nil, apperror.New(404, "TASK_TEMPLATE_NOT_FOUND", "任务模板不存在", nil)
|
|
}
|
|
var payload BackupTaskUpsertInput
|
|
if err := json.Unmarshal([]byte(item.Payload), &payload); err != nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_DECODE_FAILED", "无法解析模板内容", err)
|
|
}
|
|
detail := &TaskTemplateDetail{TaskTemplateSummary: toTemplateSummary(item), Payload: payload}
|
|
return detail, nil
|
|
}
|
|
|
|
func (s *TaskTemplateService) Create(ctx context.Context, createdBy string, input TaskTemplateUpsertInput) (*TaskTemplateDetail, error) {
|
|
if strings.TrimSpace(input.Name) == "" {
|
|
return nil, apperror.BadRequest("TASK_TEMPLATE_INVALID", "名称不能为空", nil)
|
|
}
|
|
existing, err := s.templates.FindByName(ctx, strings.TrimSpace(input.Name))
|
|
if err != nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_LOOKUP_FAILED", "无法校验模板名", err)
|
|
}
|
|
if existing != nil {
|
|
return nil, apperror.Conflict("TASK_TEMPLATE_NAME_EXISTS", "模板名称已存在", nil)
|
|
}
|
|
payloadJSON, err := json.Marshal(input.Payload)
|
|
if err != nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_ENCODE_FAILED", "无法序列化模板参数", err)
|
|
}
|
|
item := &model.TaskTemplate{
|
|
Name: strings.TrimSpace(input.Name),
|
|
Description: strings.TrimSpace(input.Description),
|
|
TaskType: strings.TrimSpace(input.Payload.Type),
|
|
Payload: string(payloadJSON),
|
|
CreatedBy: strings.TrimSpace(createdBy),
|
|
}
|
|
if err := s.templates.Create(ctx, item); err != nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_CREATE_FAILED", "无法创建任务模板", err)
|
|
}
|
|
return s.Get(ctx, item.ID)
|
|
}
|
|
|
|
func (s *TaskTemplateService) Update(ctx context.Context, id uint, input TaskTemplateUpsertInput) (*TaskTemplateDetail, error) {
|
|
item, err := s.templates.FindByID(ctx, id)
|
|
if err != nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_GET_FAILED", "无法获取任务模板", err)
|
|
}
|
|
if item == nil {
|
|
return nil, apperror.New(404, "TASK_TEMPLATE_NOT_FOUND", "任务模板不存在", nil)
|
|
}
|
|
payloadJSON, err := json.Marshal(input.Payload)
|
|
if err != nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_ENCODE_FAILED", "无法序列化模板参数", err)
|
|
}
|
|
if strings.TrimSpace(input.Name) != item.Name {
|
|
dup, err := s.templates.FindByName(ctx, strings.TrimSpace(input.Name))
|
|
if err != nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_LOOKUP_FAILED", "无法校验模板名", err)
|
|
}
|
|
if dup != nil && dup.ID != id {
|
|
return nil, apperror.Conflict("TASK_TEMPLATE_NAME_EXISTS", "模板名称已存在", nil)
|
|
}
|
|
}
|
|
item.Name = strings.TrimSpace(input.Name)
|
|
item.Description = strings.TrimSpace(input.Description)
|
|
item.TaskType = strings.TrimSpace(input.Payload.Type)
|
|
item.Payload = string(payloadJSON)
|
|
if err := s.templates.Update(ctx, item); err != nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_UPDATE_FAILED", "无法更新任务模板", err)
|
|
}
|
|
return s.Get(ctx, item.ID)
|
|
}
|
|
|
|
func (s *TaskTemplateService) Delete(ctx context.Context, id uint) error {
|
|
item, err := s.templates.FindByID(ctx, id)
|
|
if err != nil {
|
|
return apperror.Internal("TASK_TEMPLATE_GET_FAILED", "无法获取任务模板", err)
|
|
}
|
|
if item == nil {
|
|
return apperror.New(404, "TASK_TEMPLATE_NOT_FOUND", "任务模板不存在", nil)
|
|
}
|
|
return s.templates.Delete(ctx, id)
|
|
}
|
|
|
|
// Apply 从模板批量创建任务。best-effort：单个失败不影响其他。
|
|
// 每个 Variables 条目按 name 覆盖任务名；其他字段（sourcePath/dbHost/dbName/tags/nodeId）非空则覆盖模板对应字段。
|
|
func (s *TaskTemplateService) Apply(ctx context.Context, id uint, input TaskTemplateApplyInput) ([]TaskTemplateApplyResult, error) {
|
|
template, err := s.Get(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if s.tasks == nil {
|
|
return nil, apperror.Internal("TASK_TEMPLATE_APPLY_UNAVAILABLE", "任务创建服务未注入", nil)
|
|
}
|
|
results := make([]TaskTemplateApplyResult, 0, len(input.Variables))
|
|
for _, v := range input.Variables {
|
|
payload := mergeVariables(template.Payload, v)
|
|
detail, createErr := s.tasks.Create(ctx, payload)
|
|
result := TaskTemplateApplyResult{Name: v.Name}
|
|
if createErr != nil {
|
|
result.Success = false
|
|
if appErr, ok := createErr.(*apperror.AppError); ok {
|
|
result.Error = appErr.Message
|
|
} else {
|
|
result.Error = createErr.Error()
|
|
}
|
|
} else {
|
|
result.Success = true
|
|
result.TaskID = detail.ID
|
|
}
|
|
results = append(results, result)
|
|
}
|
|
return results, nil
|
|
}
|
|
|
|
// mergeVariables 把 Variables 覆盖到模板 Payload 上。返回一个新的 Input（不污染模板）。
|
|
func mergeVariables(base BackupTaskUpsertInput, v TaskTemplateVariables) BackupTaskUpsertInput {
|
|
out := base
|
|
out.Name = strings.TrimSpace(v.Name)
|
|
if strings.TrimSpace(v.SourcePath) != "" {
|
|
out.SourcePath = strings.TrimSpace(v.SourcePath)
|
|
}
|
|
if len(v.SourcePaths) > 0 {
|
|
out.SourcePaths = v.SourcePaths
|
|
}
|
|
if strings.TrimSpace(v.DBHost) != "" {
|
|
out.DBHost = strings.TrimSpace(v.DBHost)
|
|
}
|
|
if strings.TrimSpace(v.DBName) != "" {
|
|
out.DBName = strings.TrimSpace(v.DBName)
|
|
}
|
|
if strings.TrimSpace(v.Tags) != "" {
|
|
out.Tags = strings.TrimSpace(v.Tags)
|
|
}
|
|
if v.NodeID != nil {
|
|
out.NodeID = *v.NodeID
|
|
}
|
|
return out
|
|
}
|
|
|
|
func toTemplateSummary(item *model.TaskTemplate) TaskTemplateSummary {
|
|
return TaskTemplateSummary{
|
|
ID: item.ID,
|
|
Name: item.Name,
|
|
Description: item.Description,
|
|
TaskType: item.TaskType,
|
|
CreatedBy: item.CreatedBy,
|
|
CreatedAt: item.CreatedAt.Format("2006-01-02T15:04:05Z07:00"),
|
|
UpdatedAt: item.UpdatedAt.Format("2006-01-02T15:04:05Z07:00"),
|
|
}
|
|
}
|