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(tracker): share single TAPD record fetch and kind upsert dispatch (#423)

fx-kurumi27c36482c579
diff --git a/internal/tracker/service.go b/internal/tracker/service.go
index 89a4eaf2..1e0a7e21 100644
--- a/internal/tracker/service.go
+++ b/internal/tracker/service.go
@@ -969,37 +969,16 @@ func (s *Service) ImportTAPDStory(store IssueStoreAdapter, projectID, rawURL str
s.addLog(domain.SyncLog{ID: fmt.Sprintf("sync-%d", started.UnixNano()), Direction: "pull", Source: "tapd", Action: "import_story", Status: "failed", Message: actionableAuthError("TAPD", err), ProjectID: projectID, StartedAt: started, FinishedAt: time.Now().UTC()})
return domain.Issue{}, err
}
- toolName, fields := tapdReadTool(ref.Kind)
- raw, err := client.CallTool("proxy_execute_tool", map[string]any{
- "tool_name": toolName,
- "tool_args": map[string]any{
- "workspace_id": ref.WorkspaceID,
- "id": ref.StoryID,
- "limit": 1,
- "page": 1,
- "fields": fields,
- },
- })
+ raw, err := callTAPDRecordGet(client, ref.Kind, ref.WorkspaceID, ref.StoryID)
if err != nil {
s.addLog(domain.SyncLog{ID: fmt.Sprintf("sync-%d", started.UnixNano()), Direction: "pull", Source: "tapd", Action: "import_story", Status: "failed", Message: actionableAuthError("TAPD", err), ProjectID: projectID, StartedAt: started, FinishedAt: time.Now().UTC()})
return domain.Issue{}, err
}
- records, err := parseTAPDRecords(raw, ref.Kind+"s")
+ st, err := pickTAPDRecord(raw, ref.Kind, ref.StoryID)
if err != nil {
return domain.Issue{}, err
}
- st, ok := pickTAPDStory(records, ref.StoryID)
- if !ok {
- return domain.Issue{}, fmt.Errorf("未找到 TAPD %s %s", tapdRecordLabel(ref.Kind), ref.StoryID)
- }
- var issue domain.Issue
- if ref.Kind == "task" {
- issue, err = s.upsertTAPDTask(store, projectID, ref.WorkspaceID, st, fallbackUserID, true)
- } else if ref.Kind == "bug" {
- issue, err = s.upsertTAPDBug(store, projectID, ref.WorkspaceID, st, fallbackUserID, true)
- } else {
- issue, err = s.upsertTAPDStory(store, projectID, ref.WorkspaceID, st, fallbackUserID, true)
- }
+ issue, err := s.upsertTAPDByKind(store, ref.Kind, projectID, ref.WorkspaceID, st, fallbackUserID, true)
if err != nil {
return domain.Issue{}, err
}
@@ -1037,43 +1016,64 @@ func (s *Service) ResyncTAPDIssue(store IssueStoreAdapter, issue domain.Issue) (
s.addLog(domain.SyncLog{ID: fmt.Sprintf("sync-%d", started.UnixNano()), Direction: "pull", Source: "tapd", Action: "resync", Status: "failed", Message: actionableAuthError("TAPD", err), ProjectID: issue.ProjectID, StartedAt: started, FinishedAt: time.Now().UTC()})
return domain.Issue{}, err
}
+ raw, err := callTAPDRecordGet(client, kind, workspaceID, ref.ExternalID)
+ if err != nil {
+ s.addLog(domain.SyncLog{ID: fmt.Sprintf("sync-%d", started.UnixNano()), Direction: "pull", Source: "tapd", Action: "resync", Status: "failed", Message: actionableAuthError("TAPD", err), ProjectID: issue.ProjectID, StartedAt: started, FinishedAt: time.Now().UTC()})
+ return domain.Issue{}, err
+ }
+ st, err := pickTAPDRecord(raw, kind, ref.ExternalID)
+ if err != nil {
+ return domain.Issue{}, err
+ }
+ updated, err := s.upsertTAPDByKind(store, kind, issue.ProjectID, workspaceID, st, 0, false)
+ if err != nil {
+ return domain.Issue{}, err
+ }
+ recordLabel := tapdRecordLabel(kind)
+ s.addLog(domain.SyncLog{ID: fmt.Sprintf("sync-%d", started.UnixNano()), Direction: "pull", Source: "tapd", Action: "resync", Status: "success", Count: 1, Message: fmt.Sprintf("重新同步 TAPD %s %s: %s", recordLabel, st.ID, st.Name), ProjectID: issue.ProjectID, StartedAt: started, FinishedAt: time.Now().UTC()})
+ return updated, nil
+}
+
+// callTAPDRecordGet fetches the single TAPD story/bug/task id through the
+// kind-specific *_get tool and returns the raw tool result.
+func callTAPDRecordGet(client *MCPClient, kind, workspaceID, id string) (string, error) {
toolName, fields := tapdReadTool(kind)
- raw, err := client.CallTool("proxy_execute_tool", map[string]any{
+ return client.CallTool("proxy_execute_tool", map[string]any{
"tool_name": toolName,
"tool_args": map[string]any{
"workspace_id": workspaceID,
- "id": ref.ExternalID,
+ "id": id,
"limit": 1,
"page": 1,
"fields": fields,
},
})
- if err != nil {
- s.addLog(domain.SyncLog{ID: fmt.Sprintf("sync-%d", started.UnixNano()), Direction: "pull", Source: "tapd", Action: "resync", Status: "failed", Message: actionableAuthError("TAPD", err), ProjectID: issue.ProjectID, StartedAt: started, FinishedAt: time.Now().UTC()})
- return domain.Issue{}, err
- }
+}
+
+// pickTAPDRecord decodes a callTAPDRecordGet result and returns the record id.
+func pickTAPDRecord(raw, kind, id string) (tapdStory, error) {
records, err := parseTAPDRecords(raw, kind+"s")
if err != nil {
- return domain.Issue{}, err
+ return tapdStory{}, err
}
- st, ok := pickTAPDStory(records, ref.ExternalID)
+ st, ok := pickTAPDStory(records, id)
if !ok {
- return domain.Issue{}, fmt.Errorf("未找到 TAPD %s %s", tapdRecordLabel(kind), ref.ExternalID)
- }
- var updated domain.Issue
- if kind == "task" {
- updated, err = s.upsertTAPDTask(store, issue.ProjectID, workspaceID, st, 0, false)
- } else if kind == "bug" {
- updated, err = s.upsertTAPDBug(store, issue.ProjectID, workspaceID, st, 0, false)
- } else {
- updated, err = s.upsertTAPDStory(store, issue.ProjectID, workspaceID, st, 0, false)
+ return tapdStory{}, fmt.Errorf("未找到 TAPD %s %s", tapdRecordLabel(kind), id)
}
- if err != nil {
- return domain.Issue{}, err
+ return st, nil
+}
+
+// upsertTAPDByKind stores st with the upsert matching its TAPD record kind;
+// anything other than task or bug is treated as a story.
+func (s *Service) upsertTAPDByKind(store IssueStoreAdapter, kind, projectID, workspaceID string, st tapdStory, fallbackUserID int64, gateClarification bool) (domain.Issue, error) {
+ switch kind {
+ case "task":
+ return s.upsertTAPDTask(store, projectID, workspaceID, st, fallbackUserID, gateClarification)
+ case "bug":
+ return s.upsertTAPDBug(store, projectID, workspaceID, st, fallbackUserID, gateClarification)
+ default:
+ return s.upsertTAPDStory(store, projectID, workspaceID, st, fallbackUserID, gateClarification)
}
- recordLabel := tapdRecordLabel(kind)
- s.addLog(domain.SyncLog{ID: fmt.Sprintf("sync-%d", started.UnixNano()), Direction: "pull", Source: "tapd", Action: "resync", Status: "success", Count: 1, Message: fmt.Sprintf("重新同步 TAPD %s %s: %s", recordLabel, st.ID, st.Name), ProjectID: issue.ProjectID, StartedAt: started, FinishedAt: time.Now().UTC()})
- return updated, nil
}
func tapdReadTool(kind string) (string, string) {
diff --git a/internal/tracker/tapd_record_fetch_test.go b/internal/tracker/tapd_record_fetch_test.go
new file mode 100644
index 00000000..6f03bf0c
--- /dev/null
+++ b/internal/tracker/tapd_record_fetch_test.go
@@ -0,0 +1,51 @@
+package tracker
+
+import (
+ "testing"
+
+ "agentflow/internal/domain"
+)
+
+func TestPickTAPDRecord(t *testing.T) {
+ raw := `{"count":2,"data":[{"id":"1001","name":"需求A"},{"id":"1002","name":"需求B"}]}`
+ st, err := pickTAPDRecord(raw, "story", " 1002 ")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if st.ID != "1002" || st.Name != "需求B" {
+ t.Fatalf("picked %+v, want 1002/需求B", st)
+ }
+
+ for _, tc := range []struct{ kind, want string }{
+ {"story", "未找到 TAPD 需求 9999"},
+ {"bug", "未找到 TAPD 缺陷 9999"},
+ {"task", "未找到 TAPD 任务 9999"},
+ } {
+ if _, err := pickTAPDRecord(raw, tc.kind, "9999"); err == nil || err.Error() != tc.want {
+ t.Fatalf("kind=%s err=%v, want %q", tc.kind, err, tc.want)
+ }
+ }
+
+ if _, err := pickTAPDRecord("not json", "story", "1001"); err == nil {
+ t.Fatal("want parse error for non-JSON result")
+ }
+}
+
+func TestUpsertTAPDByKindDispatchesByRecordKind(t *testing.T) {
+ svc := NewService()
+ store := &memIssueStore{projects: map[string]domain.Project{"dp": {ID: "dp", Name: "DemoDNS", TAPDWorkspaceID: "10000000"}}}
+ for _, tc := range []struct{ kind, id, wantType string }{
+ {"story", "3001", "story"},
+ {"bug", "3002", "bug"},
+ {"task", "3003", "task"},
+ {"", "3004", "story"},
+ } {
+ issue, err := svc.upsertTAPDByKind(store, tc.kind, "dp", "10000000", tapdStory{ID: tc.id, Name: "记录" + tc.id}, 0, false)
+ if err != nil {
+ t.Fatalf("kind=%q: %v", tc.kind, err)
+ }
+ if got := tapdExternalType(issue); got != tc.wantType {
+ t.Fatalf("kind=%q external type=%q, want %q", tc.kind, got, tc.wantType)
+ }
+ }
+}