Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

【架构优化】从 PutAssistantTask 中拆出写入字段推算 stampAssistantTask 与完成通知判定 assistantTaskCompletion (#803)

fx-kurumiccd7499457f0
diff --git a/internal/repo/assistant.go b/internal/repo/assistant.go
index 9d3c59f8..2801564d 100644
--- a/internal/repo/assistant.go
+++ b/internal/repo/assistant.go
@@ -550,20 +550,7 @@ func (r *AssistantRepo) PutAssistantTask(userID int64, v domain.AssistantTask) e
return err
}
}
- now := time.Now().UTC()
- if prior.ID != "" {
- v.CreatedAt = prior.CreatedAt
- } else if v.CreatedAt.IsZero() {
- v.CreatedAt = now
- }
- v.NotificationSnapshot = domain.CloneNotificationBindings(prior.NotificationSnapshot)
- if v.LastStatus == "running" && (prior.LastStatus != "running" || prior.LastRunAt.UnixMilli() != v.LastRunAt.UnixMilli()) {
- v.NotificationSnapshot = domain.CloneNotificationBindings(v.Notifications)
- }
- if v.UpdatedAt.IsZero() {
- v.UpdatedAt = now
- }
- v.UserID = userID
+ v = stampAssistantTask(v, prior, userID, time.Now().UTC())
enabled := 0
if v.Enabled {
enabled = 1
@@ -582,18 +569,48 @@ func (r *AssistantRepo) PutAssistantTask(userID int64, v domain.AssistantTask) e
}); err != nil {
return err
}
- trigger := map[string]string{"ok": "succeeded", "error": "failed"}[v.LastStatus]
- if prior.ID != "" && prior.LastStatus == "running" && trigger != "" && !v.LastRunAt.IsZero() {
- result := v.NotificationResult
- if result == "" {
- result = v.LastMessage
- }
+ if trigger, result, ok := assistantTaskCompletion(prior, v); ok {
return r.notifications.enqueueTaskNotifications(tx, "assistant_task", v.ID, v.ProjectID, v.Name, trigger, v.LastRunAt, prior.NotificationSnapshot, result, v.LastError)
}
return nil
})
}
+// stampAssistantTask fills the server-owned fields of a task about to be
+// written: creation time is inherited from the stored row (or defaulted to
+// now), the notification snapshot is carried over and refreshed whenever a
+// new run starts, the update time defaults to now and the owner is pinned.
+func stampAssistantTask(v, prior domain.AssistantTask, userID int64, now time.Time) domain.AssistantTask {
+ if prior.ID != "" {
+ v.CreatedAt = prior.CreatedAt
+ } else if v.CreatedAt.IsZero() {
+ v.CreatedAt = now
+ }
+ v.NotificationSnapshot = domain.CloneNotificationBindings(prior.NotificationSnapshot)
+ if v.LastStatus == "running" && (prior.LastStatus != "running" || prior.LastRunAt.UnixMilli() != v.LastRunAt.UnixMilli()) {
+ v.NotificationSnapshot = domain.CloneNotificationBindings(v.Notifications)
+ }
+ if v.UpdatedAt.IsZero() {
+ v.UpdatedAt = now
+ }
+ v.UserID = userID
+ return v
+}
+
+// assistantTaskCompletion reports whether writing v over prior finishes a
+// running task, returning the notification trigger and the result text.
+func assistantTaskCompletion(prior, v domain.AssistantTask) (trigger, result string, ok bool) {
+ trigger = map[string]string{"ok": "succeeded", "error": "failed"}[v.LastStatus]
+ if prior.ID == "" || prior.LastStatus != "running" || trigger == "" || v.LastRunAt.IsZero() {
+ return "", "", false
+ }
+ result = v.NotificationResult
+ if result == "" {
+ result = v.LastMessage
+ }
+ return trigger, result, true
+}
+
func (r *AssistantRepo) DeleteAssistantTask(userID int64, id string) error {
id = assistantRecordID(id)
if userID <= 0 || id == "" {
diff --git a/internal/repo/assistant_task_stamp_test.go b/internal/repo/assistant_task_stamp_test.go
new file mode 100644
index 00000000..47225d52
--- /dev/null
+++ b/internal/repo/assistant_task_stamp_test.go
@@ -0,0 +1,114 @@
+package repo
+
+import (
+ "testing"
+ "time"
+
+ "agentflow/internal/domain"
+)
+
+func TestStampAssistantTaskNewTaskDefaults(t *testing.T) {
+ now := time.Date(2026, 11, 14, 12, 0, 0, 0, time.UTC)
+ got := stampAssistantTask(domain.AssistantTask{ID: "t1", UserID: 99}, domain.AssistantTask{}, 7, now)
+ if !got.CreatedAt.Equal(now) || !got.UpdatedAt.Equal(now) {
+ t.Fatalf("times = %v / %v, want %v", got.CreatedAt, got.UpdatedAt, now)
+ }
+ if got.UserID != 7 {
+ t.Fatalf("user = %d, want 7", got.UserID)
+ }
+ if got.NotificationSnapshot != nil {
+ t.Fatalf("snapshot = %#v, want nil", got.NotificationSnapshot)
+ }
+}
+
+func TestStampAssistantTaskKeepsCallerTimesForNewTask(t *testing.T) {
+ now := time.Date(2026, 11, 14, 12, 0, 0, 0, time.UTC)
+ created := now.Add(-time.Hour)
+ updated := now.Add(-time.Minute)
+ got := stampAssistantTask(domain.AssistantTask{ID: "t1", CreatedAt: created, UpdatedAt: updated}, domain.AssistantTask{}, 7, now)
+ if !got.CreatedAt.Equal(created) || !got.UpdatedAt.Equal(updated) {
+ t.Fatalf("times = %v / %v, want %v / %v", got.CreatedAt, got.UpdatedAt, created, updated)
+ }
+}
+
+func TestStampAssistantTaskInheritsPriorCreatedAtAndSnapshot(t *testing.T) {
+ now := time.Date(2026, 11, 14, 12, 0, 0, 0, time.UTC)
+ priorCreated := now.Add(-24 * time.Hour)
+ prior := domain.AssistantTask{
+ ID: "t1",
+ CreatedAt: priorCreated,
+ LastStatus: "ok",
+ NotificationSnapshot: []domain.NotificationBinding{{BotID: "old", Events: []string{"succeeded"}}},
+ }
+ v := domain.AssistantTask{
+ ID: "t1",
+ CreatedAt: now,
+ LastStatus: "ok",
+ Notifications: []domain.NotificationBinding{{BotID: "new"}},
+ }
+ got := stampAssistantTask(v, prior, 7, now)
+ if !got.CreatedAt.Equal(priorCreated) {
+ t.Fatalf("created = %v, want prior %v", got.CreatedAt, priorCreated)
+ }
+ if len(got.NotificationSnapshot) != 1 || got.NotificationSnapshot[0].BotID != "old" {
+ t.Fatalf("snapshot = %#v, want prior snapshot", got.NotificationSnapshot)
+ }
+ got.NotificationSnapshot[0].Events[0] = "mutated"
+ if prior.NotificationSnapshot[0].Events[0] != "succeeded" {
+ t.Fatal("snapshot must be cloned, not shared with prior")
+ }
+}
+
+func TestStampAssistantTaskRefreshesSnapshotWhenRunStarts(t *testing.T) {
+ now := time.Date(2026, 11, 14, 12, 0, 0, 0, time.UTC)
+ runAt := now.Add(-time.Second)
+ bindings := []domain.NotificationBinding{{BotID: "new"}}
+ priorSnapshot := []domain.NotificationBinding{{BotID: "old"}}
+ cases := []struct {
+ name string
+ prior domain.AssistantTask
+ want string
+ }{
+ {"idle to running", domain.AssistantTask{ID: "t1", LastStatus: "ok", NotificationSnapshot: priorSnapshot}, "new"},
+ {"new run while running", domain.AssistantTask{ID: "t1", LastStatus: "running", LastRunAt: runAt.Add(-time.Minute), NotificationSnapshot: priorSnapshot}, "new"},
+ {"same run still running", domain.AssistantTask{ID: "t1", LastStatus: "running", LastRunAt: runAt, NotificationSnapshot: priorSnapshot}, "old"},
+ }
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ v := domain.AssistantTask{ID: "t1", LastStatus: "running", LastRunAt: runAt, Notifications: bindings}
+ got := stampAssistantTask(v, tc.prior, 7, now)
+ if len(got.NotificationSnapshot) != 1 || got.NotificationSnapshot[0].BotID != tc.want {
+ t.Fatalf("snapshot = %#v, want bot %q", got.NotificationSnapshot, tc.want)
+ }
+ })
+ }
+}
+
+func TestAssistantTaskCompletion(t *testing.T) {
+ runAt := time.Date(2026, 11, 14, 12, 0, 0, 0, time.UTC)
+ running := domain.AssistantTask{ID: "t1", LastStatus: "running"}
+ cases := []struct {
+ name string
+ prior domain.AssistantTask
+ v domain.AssistantTask
+ wantOK bool
+ wantTrigger string
+ wantResult string
+ }{
+ {"succeeded uses notification result", running, domain.AssistantTask{LastStatus: "ok", LastRunAt: runAt, NotificationResult: "summary", LastMessage: "msg"}, true, "succeeded", "summary"},
+ {"failed falls back to last message", running, domain.AssistantTask{LastStatus: "error", LastRunAt: runAt, LastMessage: "msg"}, true, "failed", "msg"},
+ {"new task", domain.AssistantTask{}, domain.AssistantTask{LastStatus: "ok", LastRunAt: runAt}, false, "", ""},
+ {"prior not running", domain.AssistantTask{ID: "t1", LastStatus: "ok"}, domain.AssistantTask{LastStatus: "ok", LastRunAt: runAt}, false, "", ""},
+ {"still running", running, domain.AssistantTask{LastStatus: "running", LastRunAt: runAt}, false, "", ""},
+ {"unknown status", running, domain.AssistantTask{LastStatus: "skipped", LastRunAt: runAt}, false, "", ""},
+ {"missing run time", running, domain.AssistantTask{LastStatus: "ok"}, false, "", ""},
+ }
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ trigger, result, ok := assistantTaskCompletion(tc.prior, tc.v)
+ if ok != tc.wantOK || trigger != tc.wantTrigger || result != tc.wantResult {
+ t.Fatalf("got (%q, %q, %v), want (%q, %q, %v)", trigger, result, ok, tc.wantTrigger, tc.wantResult, tc.wantOK)
+ }
+ })
+ }
+}