fix: insert default time

internal/services/env_service.go

@@ -16,12 +16,14 @@ func NewEnvService() *EnvService {
 
 func (es *EnvService) CreateEnvVar(name, value, remark string, hidden bool, userID string) *models.EnvironmentVariable {
 	env := &models.EnvironmentVariable{
-		ID:     utils.GenerateID(),
+		ID:        utils.GenerateID(),
-		Name:   name,
+		Name:      name,
-		Value:  value,
+		Value:     value,
-		Remark: remark,
+		Remark:    remark,
-		Hidden: hidden,
+		Hidden:    hidden,
-		UserID: userID,
+		UserID:    userID,
+		CreatedAt: models.Now(),
+		UpdatedAt: models.Now(),
 	}
 	database.DB.Create(env)
 	return env
@@ -60,11 +62,13 @@ func (es *EnvService) UpdateEnvVar(id string, name, value, remark string, hidden
 	if err := database.DB.Where("id = ?", id).First(&env).Error; err != nil {
 		return nil
 	}
-	env.Name = name
+	updates := map[string]interface{}{
-	env.Value = value
+		"name":   name,
-	env.Remark = remark
+		"value":  value,
-	env.Hidden = hidden
+		"remark": remark,
-	database.DB.Save(&env)
+		"hidden": hidden,
+	}
+	database.DB.Model(&env).Updates(updates)
 	return &env
 }
 

internal/services/tasks/task_log_service.go

@@ -43,6 +43,7 @@ func (s *TaskLogService) CreateEmptyLog(taskID string, command string) (*models.
 		Command:   command,
 		Status:    "running",
 		StartTime: &startTime,
+		CreatedAt: models.Now(),
 	}
 	if err := database.DB.Create(taskLog).Error; err != nil {
 		return nil, err
@@ -57,6 +58,9 @@ func (s *TaskLogService) SaveTaskLog(taskLog *models.TaskLog) error {
 		err = database.DB.Model(taskLog).Where("id = ?", taskLog.ID).Updates(taskLog).Error
 	} else {
 		taskLog.ID = utils.GenerateID()
+		if taskLog.CreatedAt.Time().IsZero() {
+			taskLog.CreatedAt = models.Now()
+		}
 		err = database.DB.Create(taskLog).Error
 	}
 
@@ -155,15 +159,16 @@ func (s *TaskLogService) CreateTaskLogFromAgentResult(result *models.AgentTaskRe
 	}
 
 	taskLog := &models.TaskLog{
-		ID:       utils.GenerateID(),
+		ID:        utils.GenerateID(),
-		TaskID:   result.TaskID,
+		TaskID:    result.TaskID,
-		AgentID:  &result.AgentID,
+		AgentID:   &result.AgentID,
-		Command:  result.Command,
+		Command:   result.Command,
-		Output:   compressed,
+		Output:    compressed,
-		Error:    result.Error,
+		Error:     result.Error,
-		Status:   result.Status,
+		Status:    result.Status,
-		Duration: result.Duration,
+		Duration:  result.Duration,
-		ExitCode: result.ExitCode,
+		ExitCode:  result.ExitCode,
+		CreatedAt: models.Now(),
 	}
 
 	// 处理开始和结束时间
@@ -209,6 +214,7 @@ func (s *TaskLogService) CreateTaskLogFromLocalExecution(taskID string, command,
 		ExitCode:  exitCode,
 		StartTime: &startTime,
 		EndTime:   &endTime,
+		CreatedAt: models.Now(),
 	}
 
 	return taskLog, nil

internal/services/tasks/task_service.go

@@ -21,24 +21,26 @@ func (ts *TaskService) CreateTask(name, command, schedule string, timeout int, w
 		triggerType = constant.TriggerTypeCron
 	}
 	task := &models.Task{
-		ID:          utils.GenerateID(),
+		ID:            utils.GenerateID(),
-		Name:        name,
+		Name:          name,
-		Command:     command,
+		Command:       command,
-		Tags:        tags,
+		Tags:          tags,
-		Type:        taskType,
+		Type:          taskType,
-		TriggerType: triggerType,
+		TriggerType:   triggerType,
-		Config:      config,
+		Config:        config,
-		Schedule:    schedule,
+		Schedule:      schedule,
-		Timeout:     timeout,
+		Timeout:       timeout,
-		WorkDir:     workDir,
+		WorkDir:       workDir,
-		CleanConfig: cleanConfig,
+		CleanConfig:   cleanConfig,
-		Envs:        envs,
+		Envs:          envs,
 		Languages:     languages,
 		AgentID:       agentID,
 		Enabled:       true,
 		RetryCount:    retryCount,
 		RetryInterval: retryInterval,
 		RandomRange:   randomRange,
+		CreatedAt:     models.Now(),
+		UpdatedAt:     models.Now(),
 	}
 	if triggerType != constant.TriggerTypeCron {
 		task.NextRun = nil
@@ -111,11 +113,27 @@ func (ts *TaskService) UpdateTask(id string, name, command, schedule string, tim
 	if triggerType != "" {
 		task.TriggerType = triggerType
 	}
-	if task.TriggerType != constant.TriggerTypeCron {
+	updates := map[string]interface{}{
-		task.NextRun = nil
+		"name":           name,
+		"command":        command,
+		"tags":           tags,
+		"schedule":       schedule,
+		"timeout":        timeout,
+		"work_dir":       workDir,
+		"clean_config":   cleanConfig,
+		"envs":           envs,
+		"enabled":        enabled,
+		"agent_id":       agentID,
+		"languages":      languages,
+		"retry_count":    retryCount,
+		"retry_interval": retryInterval,
+		"random_range":   randomRange,
+		"type":           task.Type,
+		"trigger_type":   task.TriggerType,
+		"next_run":       task.NextRun,
+		"config":         config,
 	}
-	task.Config = config
+	database.DB.Model(&task).Updates(updates)
-	database.DB.Save(&task)
 	return &task
 }