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.

refactor(repo): extract issue deletion task/run accumulation into addTask/addRun (#578)

fx-kurumi9aeef81873fe
diff --git a/internal/repo/issues_delete.go b/internal/repo/issues_delete.go
index 15a15d0e..4099058c 100644
--- a/internal/repo/issues_delete.go
+++ b/internal/repo/issues_delete.go
@@ -142,16 +142,7 @@ func (r *IssuesRepo) issueDeletionStates(db *gorm.DB, issues []domain.Issue) (ma
if state == nil {
return nil, fmt.Errorf("执行任务 %s 的需求编号与记录不一致", task.ID)
}
- state.hasHistory = true
- switch task.Status {
- case "completed", "succeeded":
- state.successful = true
- case "failed", "cancelled":
- default:
- if state.Block == nil {
- state.Block = &IssueDeletionBlock{Code: "active", Reason: "仍有未结束的任务,请先处理或停止后再删除", TaskID: task.ID}
- }
- }
+ state.addTask(task.ID, task.Status)
if task.RunID != "" {
if runIssues[task.RunID] == nil {
runIssues[task.RunID] = map[string]bool{}
@@ -165,44 +156,64 @@ func (r *IssuesRepo) issueDeletionStates(db *gorm.DB, issues []domain.Issue) (ma
if r.isMySQL() {
expr = "JSON_UNQUOTE(JSON_EXTRACT(execution_context, '$.issueId'))"
}
- type linkedRun struct {
- ID, Status, IssueID string
- ActiveNodes bool
- }
q := db.Table("runs").Select("id, status, "+expr+" AS issue_id, "+
"EXISTS (SELECT 1 FROM run_nodes WHERE run_id = runs.id AND status IN ('running', 'pending_input')) AS active_nodes").
Where(expr+" IN ?", ids)
if len(runIDs) > 0 {
q = q.Or("id IN ?", runIDs)
}
- var runs []linkedRun
+ var runs []issueDeletionRun
if err := q.Find(&runs).Error; err != nil {
return nil, err
}
- addRun := func(state *IssueDeletionState, run linkedRun) {
- state.hasHistory = true
- state.successful = state.successful || run.Status == "succeeded"
- state.runIDs = append(state.runIDs, run.ID)
- if domain.TerminalRunStatus(run.Status) && !run.ActiveNodes {
- return
- }
- // Prefer linking to the active run when the earlier reason was a task.
- if state.Block == nil || (state.Block.Code == "active" && state.Block.RunID == "") {
- state.Block = &IssueDeletionBlock{Code: "active", Reason: "仍有未结束的运行,请先处理或停止后再删除", RunID: run.ID}
- }
- }
for _, run := range runs {
linked := runIssues[run.ID]
for id := range linked {
- addRun(states[id], run)
+ states[id].addRun(run)
}
if state := states[run.IssueID]; state != nil && !linked[run.IssueID] {
- addRun(state, run)
+ state.addRun(run)
}
}
return states, nil
}
+// issueDeletionRun is a run linked to an issue, either through its execution
+// context or through a legacy task RunID.
+type issueDeletionRun struct {
+ ID, Status, IssueID string
+ ActiveNodes bool
+}
+
+// addTask records one linked task: any task is history, a completed task
+// counts as success, and an unfinished task blocks deletion.
+func (s *IssueDeletionState) addTask(taskID, status string) {
+ s.hasHistory = true
+ switch status {
+ case "completed", "succeeded":
+ s.successful = true
+ case "failed", "cancelled":
+ default:
+ if s.Block == nil {
+ s.Block = &IssueDeletionBlock{Code: "active", Reason: "仍有未结束的任务,请先处理或停止后再删除", TaskID: taskID}
+ }
+ }
+}
+
+// addRun records one linked run and blocks deletion while it is still active.
+func (s *IssueDeletionState) addRun(run issueDeletionRun) {
+ s.hasHistory = true
+ s.successful = s.successful || run.Status == "succeeded"
+ s.runIDs = append(s.runIDs, run.ID)
+ if domain.TerminalRunStatus(run.Status) && !run.ActiveNodes {
+ return
+ }
+ // Prefer linking to the active run when the earlier reason was a task.
+ if s.Block == nil || (s.Block.Code == "active" && s.Block.RunID == "") {
+ s.Block = &IssueDeletionBlock{Code: "active", Reason: "仍有未结束的运行,请先处理或停止后再删除", RunID: run.ID}
+ }
+}
+
// IssueClosureAllowed permits settled execution history, but no active work.
func (r *IssuesRepo) IssueClosureAllowed(issues []domain.Issue) (map[string]bool, error) {
states, err := r.IssueDeletionStates(issues)
diff --git a/internal/repo/issues_delete_state_test.go b/internal/repo/issues_delete_state_test.go
new file mode 100644
index 00000000..0234ccad
--- /dev/null
+++ b/internal/repo/issues_delete_state_test.go
@@ -0,0 +1,96 @@
+package repo
+
+import "testing"
+
+func TestIssueDeletionStateAddTask(t *testing.T) {
+ for _, tc := range []struct {
+ status string
+ successful bool
+ blocked bool
+ }{
+ {"completed", true, false},
+ {"succeeded", true, false},
+ {"failed", false, false},
+ {"cancelled", false, false},
+ {"running", false, true},
+ {"queued", false, true},
+ } {
+ t.Run(tc.status, func(t *testing.T) {
+ var s IssueDeletionState
+ s.addTask("task-1", tc.status)
+ if !s.hasHistory || s.successful != tc.successful || (s.Block != nil) != tc.blocked {
+ t.Fatalf("state = %+v, want successful=%v blocked=%v", s, tc.successful, tc.blocked)
+ }
+ if tc.blocked && (s.Block.Code != "active" || s.Block.TaskID != "task-1" || s.Block.RunID != "") {
+ t.Fatalf("block = %+v", s.Block)
+ }
+ if len(s.runIDs) != 0 {
+ t.Fatalf("addTask must not record run ids: %v", s.runIDs)
+ }
+ })
+ }
+}
+
+func TestIssueDeletionStateAddTaskKeepsFirstBlock(t *testing.T) {
+ s := IssueDeletionState{Block: &IssueDeletionBlock{Code: "clarifying"}}
+ s.addTask("task-1", "running")
+ if s.Block.Code != "clarifying" {
+ t.Fatalf("block overwritten: %+v", s.Block)
+ }
+}
+
+func TestIssueDeletionStateAddRun(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ run issueDeletionRun
+ successful bool
+ blocked bool
+ }{
+ {"succeeded", issueDeletionRun{ID: "r", Status: "succeeded"}, true, false},
+ {"failed", issueDeletionRun{ID: "r", Status: "failed"}, false, false},
+ {"running", issueDeletionRun{ID: "r", Status: "running"}, false, true},
+ {"terminal with active nodes", issueDeletionRun{ID: "r", Status: "failed", ActiveNodes: true}, false, true},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ var s IssueDeletionState
+ s.addRun(tc.run)
+ if !s.hasHistory || s.successful != tc.successful || (s.Block != nil) != tc.blocked {
+ t.Fatalf("state = %+v, want successful=%v blocked=%v", s, tc.successful, tc.blocked)
+ }
+ if len(s.runIDs) != 1 || s.runIDs[0] != "r" {
+ t.Fatalf("runIDs = %v", s.runIDs)
+ }
+ if tc.blocked && (s.Block.Code != "active" || s.Block.RunID != "r") {
+ t.Fatalf("block = %+v", s.Block)
+ }
+ })
+ }
+}
+
+func TestIssueDeletionStateAddRunBlockPriority(t *testing.T) {
+ var s IssueDeletionState
+ s.addTask("task-1", "running")
+ s.addRun(issueDeletionRun{ID: "run-1", Status: "running"})
+ if s.Block.RunID != "run-1" || s.Block.TaskID != "" {
+ t.Fatalf("task block should upgrade to run block: %+v", s.Block)
+ }
+ s.addRun(issueDeletionRun{ID: "run-2", Status: "running"})
+ if s.Block.RunID != "run-1" {
+ t.Fatalf("existing run block overwritten: %+v", s.Block)
+ }
+ if len(s.runIDs) != 2 {
+ t.Fatalf("runIDs = %v", s.runIDs)
+ }
+
+ clarifying := IssueDeletionState{Block: &IssueDeletionBlock{Code: "clarifying"}}
+ clarifying.addRun(issueDeletionRun{ID: "run-1", Status: "running"})
+ if clarifying.Block.Code != "clarifying" {
+ t.Fatalf("clarifying block overwritten: %+v", clarifying.Block)
+ }
+
+ succeeded := IssueDeletionState{successful: true}
+ succeeded.addRun(issueDeletionRun{ID: "run-1", Status: "failed"})
+ if !succeeded.successful {
+ t.Fatal("earlier success must be kept")
+ }
+}