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.

【架构优化】从 BusinessDomainReport 中拆出业务域分组构造 newBusinessDomainGroups 与项目用量累加 addBusinessDomainProjectUsage (#738)

fx-kurumi88d181982cdd
diff --git a/internal/repo/analytics_business_domains.go b/internal/repo/analytics_business_domains.go
index 61cc8f70..00174236 100644
--- a/internal/repo/analytics_business_domains.go
+++ b/internal/repo/analytics_business_domains.go
@@ -25,14 +25,7 @@ func (r *AnalyticsRepo) BusinessDomainReport(filter domain.AnalyticsFilter, proj
return domain.BusinessDomainReport{}, errors.New(snap.DataErrors[0])
}
out := domain.BusinessDomainReport{Attribution: "current", GeneratedAt: snap.Summary.GeneratedAt, From: filter.From, To: filter.To, Summary: snap.Summary, Delivery: snap.Delivery, Trend: snap.Trend, Projects: []domain.BusinessDomainProjectUsage{}, BusinessDomains: []domain.BusinessDomainUsage{}}
- groups := map[string]*domain.BusinessDomainUsage{}
- order := []string{}
- for _, d := range domains {
- groups[d.ID] = &domain.BusinessDomainUsage{ID: d.ID, Name: d.Name, Active: d.Active, CostKnown: true}
- order = append(order, d.ID)
- }
- groups[""] = &domain.BusinessDomainUsage{ID: "", Name: "未分类", Active: true, CostKnown: true}
- order = append(order, "")
+ groups, order := newBusinessDomainGroups(domains)
usage := map[string]domain.AnalyticsProjectUsage{}
for _, u := range snap.ProjectUsage {
usage[u.ProjectID] = u
@@ -52,15 +45,7 @@ func (r *AnalyticsRepo) BusinessDomainReport(filter domain.AnalyticsFilter, proj
if g == nil {
continue
}
- g.ProjectCount++
- g.Runs += u.Runs
- g.Success += u.Success
- g.Failed += u.Failed
- g.Tokens += u.Tokens
- g.CostUSD += u.CostUSD
- g.CostCNY += u.CostCNY
- g.UniqueIssues += u.UniqueIssues
- g.CostKnown = g.CostKnown && u.CostKnown
+ addBusinessDomainProjectUsage(g, u)
}
if err := r.addBusinessDeliveryCounts(snap.Deliveries, projectDomains, groups); err != nil {
return domain.BusinessDomainReport{}, err
@@ -77,6 +62,34 @@ func (r *AnalyticsRepo) BusinessDomainReport(filter domain.AnalyticsFilter, proj
return out, nil
}
+// newBusinessDomainGroups builds one usage group per business domain in the
+// given order, followed by the "未分类" group (empty ID) for projects without a
+// domain. The returned order is the output order of the report.
+func newBusinessDomainGroups(domains []domain.BusinessDomain) (map[string]*domain.BusinessDomainUsage, []string) {
+ groups := map[string]*domain.BusinessDomainUsage{}
+ order := []string{}
+ for _, d := range domains {
+ groups[d.ID] = &domain.BusinessDomainUsage{ID: d.ID, Name: d.Name, Active: d.Active, CostKnown: true}
+ order = append(order, d.ID)
+ }
+ groups[""] = &domain.BusinessDomainUsage{ID: "", Name: "未分类", Active: true, CostKnown: true}
+ order = append(order, "")
+ return groups, order
+}
+
+// addBusinessDomainProjectUsage adds one project's usage to its business domain group.
+func addBusinessDomainProjectUsage(g *domain.BusinessDomainUsage, u domain.AnalyticsProjectUsage) {
+ g.ProjectCount++
+ g.Runs += u.Runs
+ g.Success += u.Success
+ g.Failed += u.Failed
+ g.Tokens += u.Tokens
+ g.CostUSD += u.CostUSD
+ g.CostCNY += u.CostCNY
+ g.UniqueIssues += u.UniqueIssues
+ g.CostKnown = g.CostKnown && u.CostKnown
+}
+
// Resolve only delivered issues, then attribute each delivery once across all query batches.
func (r *AnalyticsRepo) addBusinessDeliveryCounts(deliveries []domain.AnalyticsDelivery, projectDomains map[string]string, groups map[string]*domain.BusinessDomainUsage) error {
ids := make([]string, 0, len(deliveries))
diff --git a/internal/repo/analytics_business_domains_groups_test.go b/internal/repo/analytics_business_domains_groups_test.go
new file mode 100644
index 00000000..cd23a697
--- /dev/null
+++ b/internal/repo/analytics_business_domains_groups_test.go
@@ -0,0 +1,49 @@
+package repo
+
+import (
+ "agentflow/internal/domain"
+ "reflect"
+ "testing"
+)
+
+func TestNewBusinessDomainGroupsKeepsOrderAndAppendsUnclassified(t *testing.T) {
+ groups, order := newBusinessDomainGroups([]domain.BusinessDomain{
+ {ID: "bd-b", Name: "支付", Active: true},
+ {ID: "bd-a", Name: "广告", Active: false},
+ })
+ if want := []string{"bd-b", "bd-a", ""}; !reflect.DeepEqual(order, want) {
+ t.Fatalf("order = %v, want %v", order, want)
+ }
+ if len(groups) != 3 {
+ t.Fatalf("groups = %d, want 3", len(groups))
+ }
+ want := map[string]domain.BusinessDomainUsage{
+ "bd-b": {ID: "bd-b", Name: "支付", Active: true, CostKnown: true},
+ "bd-a": {ID: "bd-a", Name: "广告", Active: false, CostKnown: true},
+ "": {ID: "", Name: "未分类", Active: true, CostKnown: true},
+ }
+ for id, w := range want {
+ g := groups[id]
+ if g == nil || !reflect.DeepEqual(*g, w) {
+ t.Fatalf("group %q = %+v, want %+v", id, g, w)
+ }
+ }
+}
+
+func TestNewBusinessDomainGroupsWithoutDomains(t *testing.T) {
+ groups, order := newBusinessDomainGroups(nil)
+ if !reflect.DeepEqual(order, []string{""}) || len(groups) != 1 || groups[""].Name != "未分类" {
+ t.Fatalf("groups = %+v, order = %v", groups, order)
+ }
+}
+
+func TestAddBusinessDomainProjectUsageSumsAndAndsCostKnown(t *testing.T) {
+ g := &domain.BusinessDomainUsage{ID: "bd", CostKnown: true}
+ addBusinessDomainProjectUsage(g, domain.AnalyticsProjectUsage{ProjectID: "p1", Runs: 3, Success: 2, Failed: 1, Tokens: 100, CostUSD: 1.5, CostCNY: 10, UniqueIssues: 2, CostKnown: true})
+ addBusinessDomainProjectUsage(g, domain.AnalyticsProjectUsage{ProjectID: "p2", Runs: 1, Success: 1, Tokens: 50, CostUSD: 0.5, CostCNY: 4, UniqueIssues: 1, CostKnown: false})
+ addBusinessDomainProjectUsage(g, domain.AnalyticsProjectUsage{ProjectID: "p3", CostKnown: true})
+ want := domain.BusinessDomainUsage{ID: "bd", ProjectCount: 3, Runs: 4, Success: 3, Failed: 1, Tokens: 150, CostUSD: 2, CostCNY: 14, UniqueIssues: 3, CostKnown: false}
+ if !reflect.DeepEqual(*g, want) {
+ t.Fatalf("usage = %+v, want %+v", *g, want)
+ }
+}
diff --git a/internal/repo/analytics_business_domains_report_test.go b/internal/repo/analytics_business_domains_report_test.go
new file mode 100644
index 00000000..c1045835
--- /dev/null
+++ b/internal/repo/analytics_business_domains_report_test.go
@@ -0,0 +1,100 @@
+package repo
+
+import (
+ "fmt"
+ "testing"
+ "time"
+
+ "agentflow/internal/domain"
+)
+
+// BusinessDomainReport must group project usage by the domains it is given,
+// in their order, append the "未分类" group last, drop groups without projects
+// and leave projects whose domain is unknown out of every group.
+func TestBusinessDomainReportGroupsProjectUsageByDomain(t *testing.T) {
+ s, err := OpenTest()
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(s.Close)
+ prefix := fmt.Sprintf("bd-report-%d", time.Now().UnixNano())
+ id := func(name string) string { return prefix + "-" + name }
+ at := time.Date(2026, 9, 1, 8, 0, 0, 0, time.UTC)
+ runs := []struct {
+ project, status string
+ tokens int64
+ }{
+ {"p1", "succeeded", 10},
+ {"p1", "succeeded", 20},
+ {"p2", "failed", 40},
+ {"p3", "succeeded", 80},
+ {"p4", "succeeded", 160},
+ }
+ for i, r := range runs {
+ runAt := at.Add(time.Duration(i) * time.Hour)
+ issueID := id(fmt.Sprintf("issue-%d", i))
+ run := domain.Run{ID: id(fmt.Sprintf("run-%d", i)), WorkflowID: id("wf"), Status: r.status, CreatedAt: runAt, UpdatedAt: runAt,
+ ExecutionContext: domain.TelemetryContext{ProjectID: id(r.project), IssueID: issueID}, Usage: domain.TokenUsage{TotalTokens: r.tokens}}
+ if err := s.PutRun(run); err != nil {
+ t.Fatal(err)
+ }
+ }
+ projects := []domain.Project{
+ {ID: id("p1"), Name: "一号", BusinessDomainID: id("dom-a")},
+ {ID: id("p2"), Name: "二号", BusinessDomainID: id("dom-a")},
+ {ID: id("p3"), Name: "未归属"},
+ {ID: id("p4"), Name: "已删业务域", BusinessDomainID: id("dom-gone")},
+ {ID: id("p5"), Name: "无运行", BusinessDomainID: id("dom-z")},
+ }
+ domains := []domain.BusinessDomain{
+ {ID: id("dom-z"), Name: "Z 业务", Active: false},
+ {ID: id("dom-empty"), Name: "空业务", Active: true},
+ {ID: id("dom-a"), Name: "A 业务", Active: true},
+ }
+ ids := make([]string, 0, len(projects))
+ for _, p := range projects {
+ ids = append(ids, p.ID)
+ }
+ filter := domain.AnalyticsFilter{ProjectIDs: ids, From: at.Add(-time.Hour), To: at.Add(24 * time.Hour)}
+ report, err := s.BusinessDomainReport(filter, projects, domains)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(report.Projects) != len(projects) {
+ t.Fatalf("every matching project must be listed, got %+v", report.Projects)
+ }
+ gotOrder := []string{}
+ byID := map[string]domain.BusinessDomainUsage{}
+ for _, g := range report.BusinessDomains {
+ gotOrder = append(gotOrder, g.ID)
+ byID[g.ID] = g
+ }
+ if want := []string{id("dom-z"), id("dom-a"), ""}; fmt.Sprint(gotOrder) != fmt.Sprint(want) {
+ t.Fatalf("group order = %v, want %v (input order, empty groups dropped, 未分类 last)", gotOrder, want)
+ }
+ a := byID[id("dom-a")]
+ if a.Name != "A 业务" || !a.Active || a.ProjectCount != 2 || a.Runs != 3 || a.Success != 2 || a.Failed != 1 || a.Tokens != 70 || a.UniqueIssues != 3 {
+ t.Fatalf("dom-a must sum p1 and p2: %+v", a)
+ }
+ z := byID[id("dom-z")]
+ if z.Name != "Z 业务" || z.Active || z.ProjectCount != 1 || z.Runs != 0 || z.Tokens != 0 || !z.CostKnown {
+ t.Fatalf("a project without runs still counts towards its domain: %+v", z)
+ }
+ u := byID[""]
+ if u.Name != "未分类" || !u.Active || u.ProjectCount != 1 || u.Runs != 1 || u.Tokens != 80 {
+ t.Fatalf("project without a domain belongs to 未分类 only: %+v", u)
+ }
+ for _, g := range report.BusinessDomains {
+ if g.Tokens >= 160 {
+ t.Fatalf("project with an unknown domain must not be attributed to any group: %+v", g)
+ }
+ }
+
+ only, err := s.BusinessDomainReport(domain.AnalyticsFilter{ProjectIDs: []string{id("p1")}, From: filter.From, To: filter.To}, projects, domains)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(only.Projects) != 1 || len(only.BusinessDomains) != 1 || only.BusinessDomains[0].ID != id("dom-a") || only.BusinessDomains[0].ProjectCount != 1 || only.BusinessDomains[0].Tokens != 30 {
+ t.Fatalf("filtered projects must not be counted: projects=%+v groups=%+v", only.Projects, only.BusinessDomains)
+ }
+}