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.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package repo
import (
"encoding/json"
"fmt"
"sort"
"strings"
"time"
"agentflow/internal/domain"
"gorm.io/gorm"
)
// ---------- MR delivery states ( Gongfeng MCP delivery analytics ) ----------
func (r mrDeliveryStateRow) toDomain() domain.MRDeliveryState {
item := domain.MRDeliveryState{
MRProject: r.MRProject, MRIID: r.MRIID, MRURL: r.MRURL, State: r.State,
TargetBranch: r.TargetBranch, IssueID: r.IssueID,
}
if r.RegisteredBy != nil {
item.RegisteredBy = *r.RegisteredBy
}
if r.MergedAt != nil {
item.MergedAt = r.MergedAt.UTC()
}
if r.CheckedAt != nil {
item.CheckedAt = r.CheckedAt.UTC()
}
if r.Created != nil {
item.CreatedAt = r.Created.UTC()
}
if r.Updated != nil {
item.UpdatedAt = r.Updated.UTC()
}
return item
}
func mrDeliveryRowValues(item domain.MRDeliveryState, now time.Time) map[string]any {
checked := timePtr(item.CheckedAt)
return map[string]any{
"mr_project": item.MRProject, "mr_iid": item.MRIID, "mr_url": item.MRURL,
"state": item.State, "target_branch": domain.NormalizeBranchName(item.TargetBranch),
"issue_id": item.IssueID, "merged_at": timePtr(item.MergedAt), "checked_at": checked,
"created_at": timePtr(item.CreatedAt), "updated_at": timePtr(now),
}
}
func (r *DeliveryRepo) mrDeliveryState(project string, iid int) (domain.MRDeliveryState, bool) {
return mrDeliveryStateDB(r.DB, project, iid)
}
func mrDeliveryStateDB(db *gorm.DB, project string, iid int) (domain.MRDeliveryState, bool) {
var row mrDeliveryStateRow
if err := db.Where("mr_project = ? AND mr_iid = ?", project, iid).Take(&row).Error; err != nil {
return domain.MRDeliveryState{}, false
}
return row.toDomain(), true
}
// EnsureMRDeliveryState registers (or refreshes) the link between an MR and an
// issue. The baseline-promote marker issue is protected from being overwritten
// by regular work items.
func (r *DeliveryRepo) EnsureMRDeliveryState(project string, iid int, url, issueID string) error {
if project == "" || iid <= 0 {
return nil
}
url = strings.TrimSpace(url)
issueID = strings.TrimSpace(issueID)
now := time.Now().UTC()
return r.DB.Transaction(func(tx *gorm.DB) error {
existing, ok := mrDeliveryStateDB(tx, project, iid)
if !ok {
_, err := insertIgnore(tx, "mr_delivery_states", mrDeliveryRowValues(domain.MRDeliveryState{
MRProject: project, MRIID: iid, MRURL: url, State: "unknown", IssueID: issueID,
}, now))
return err
}
originalURL, originalIssueID := existing.MRURL, existing.IssueID
if url != "" {
existing.MRURL = url
}
if existing.IssueID == issueID || issueID == domain.BaselinePromoteIssueID {
// keep
} else if existing.IssueID == domain.BaselinePromoteIssueID {
// never demote the baseline marker
} else if issueID != "" {
existing.IssueID = issueID
}
if existing.MRURL == originalURL && existing.IssueID == originalIssueID {
return nil
}
return upsert(tx, "mr_delivery_states", mrDeliveryRowValues(existing, now))
})
}
// SetMRDeliveryRegisteredBy records who registered an MR the first time; a
// later registration by someone else keeps the original user.
func (r *DeliveryRepo) SetMRDeliveryRegisteredBy(project string, iid int, userID int64) error {
if project == "" || iid <= 0 || userID <= 0 {
return nil
}
return r.DB.Table("mr_delivery_states").
Where("mr_project = ? AND mr_iid = ? AND registered_by IS NULL", project, iid).
Update("registered_by", userID).Error
}
func (r *DeliveryRepo) UpdateMRDeliveryState(project string, iid int, state string, targetBranch string, mergedAt, checkedAt time.Time) error {
if project == "" || iid <= 0 {
return nil
}
state = strings.TrimSpace(state)
if state == "" {
state = "unknown"
}
targetBranch = domain.NormalizeBranchName(targetBranch)
if checkedAt.IsZero() {
checkedAt = time.Now().UTC()
}
if err := r.recordMRState(project, iid, state, targetBranch, mergedAt, checkedAt); err != nil {
return err
}
classified := r.classifyMRDelivery(domain.MRDeliveryState{
MRProject: project,
State: state,
TargetBranch: targetBranch,
})
existing, ok := r.mrDeliveryState(project, iid)
if !ok {
return nil
}
if domain.IsBaselinePromoteIssueID(existing.IssueID) {
if classified == "merged" {
return r.PromoteIntegratedIssuesIfBaselineLanded(project, checkedAt)
}
return nil
}
if existing.IssueID != "" {
if !r.shouldWriteIssueDeliveryFromMR(existing.IssueID, existing.MRURL) {
return nil
}
if classified == "merged" {
return r.MarkIssueDelivered(existing.IssueID, existing.MRURL, checkedAt)
}
return r.syncIssueMRState(existing.IssueID, existing.MRURL, classified)
}
return nil
}
// recordMRState stores a looked-up Gongfeng state without touching issues.
func (r *DeliveryRepo) recordMRState(project string, iid int, state, targetBranch string, mergedAt, checkedAt time.Time) error {
values := map[string]any{"state": state, "target_branch": domain.NormalizeBranchName(targetBranch), "checked_at": checkedAt.UTC(), "updated_at": time.Now().UTC()}
if state != "merged" {
values["merged_at"] = nil
} else if !mergedAt.IsZero() {
// A response without a timestamp must not erase an authoritative time.
values["merged_at"] = mergedAt.UTC()
}
return r.DB.Model(&mrDeliveryStateRow{}).
Where("mr_project = ? AND mr_iid = ?", project, iid).
Updates(values).Error
}
// MarkIssueDelivered locks a work item from MR polling / reconcile. mrURL must
// be one of the item's delivery MRs (or the item has none yet).
func (r *DeliveryRepo) MarkIssueDelivered(issueID, mrURL string, deliveredAt time.Time) error {
return r.markIssueDelivered(issueID, singleDeliveryMR(mrURL), deliveredAt, false)
}
// MarkIssueDeliveredFromSOP locks a work item after a new SOP run succeeds.
// Unlike MarkIssueDelivered, it may lock a human-reopened item again.
func (r *DeliveryRepo) MarkIssueDeliveredFromSOP(issueID, mrURL string, deliveredAt time.Time) error {
return r.MarkIssueDeliveredFromSOPMRs(issueID, singleDeliveryMR(mrURL), deliveredAt)
}
// MarkIssueDeliveredFromSOPMRs is MarkIssueDeliveredFromSOP for a run that
// delivered one MR per repository. The list replaces the item's delivery MRs;
// an empty list keeps MRs from earlier deliveries.
func (r *DeliveryRepo) MarkIssueDeliveredFromSOPMRs(issueID string, mrs []domain.DeliveryMR, deliveredAt time.Time) error {
return r.markIssueDelivered(issueID, mrs, deliveredAt, true)
}
func singleDeliveryMR(mrURL string) []domain.DeliveryMR {
mrURL = strings.TrimSpace(mrURL)
if mrURL == "" {
return nil
}
mr := domain.DeliveryMR{URL: mrURL}
if project, iid, _, ok := domain.ParseDeliveryMRURL(mrURL); ok {
mr.Project, mr.IID = project, iid
}
return []domain.DeliveryMR{mr}
}
// registerDeliveryMR links the MR to the issue for polling and returns its
// classified state. A live Gongfeng lookup result is stored first.
func (r *DeliveryRepo) registerDeliveryMR(issueID string, mr domain.DeliveryMR, at time.Time) string {
project, iid := mr.Project, mr.IID
if project == "" || iid <= 0 {
if p, n, _, ok := domain.ParseDeliveryMRURL(mr.URL); ok {
project, iid = p, n
}
}
if project == "" || iid <= 0 {
return "unknown"
}
_ = r.EnsureMRDeliveryState(project, iid, mr.URL, issueID)
if st := strings.TrimSpace(mr.GongfengState); st != "" {
_ = r.recordMRState(project, iid, st, mr.TargetBranch, time.Time{}, at)
}
return r.lookupMRDeliveryState(mr.URL)
}
func (r *DeliveryRepo) markIssueDelivered(issueID string, mrs []domain.DeliveryMR, deliveredAt time.Time, fromSOP bool) error {
issueID = strings.TrimSpace(issueID)
if issueID == "" {
return nil
}
issue, ok := r.issues.Issue(issueID)
if !ok {
return nil
}
if deliveredAt.IsZero() {
deliveredAt = time.Now().UTC()
}
if issueDeliverySkipped(issue, mrs, deliveredAt, fromSOP) {
return nil
}
issue.DeliveryState = "merged"
if len(mrs) > 0 && (fromSOP || len(issue.DeliveryMRList()) == 0) {
list := make([]domain.DeliveryMR, 0, len(mrs))
for _, mr := range mrs {
mr.State = r.registerDeliveryMR(issue.ID, mr, deliveredAt)
list = append(list, mr)
}
issue.SetDeliveryMRs(list)
} else {
for _, mr := range mrs {
issue.SetDeliveryMRState(mr.URL, r.lookupMRDeliveryState(mr.URL))
}
if fromSOP {
list := issue.DeliveryMRList()
for idx := range list {
list[idx].State = r.lookupMRDeliveryState(list[idx].URL)
}
issue.SetDeliveryMRs(list)
}
}
issue.DeliveryUpdatedAt = deliveredAt.UTC()
if issue.Status != "closed" {
issue.Status = "done"
}
issue.AutomationState = "ignored"
return r.issues.PutIssue(issue)
}
// issueDeliverySkipped reports whether a delivery signal must leave the work
// item untouched. deliveredAt must already be resolved (non-zero).
func issueDeliverySkipped(issue domain.Issue, mrs []domain.DeliveryMR, deliveredAt time.Time, fromSOP bool) bool {
// A manually closed issue is an explicit terminal state. Background MR
// polling and stale SOP callbacks must not change it.
if issue.ManuallyClosed() {
return true
}
// A human reopen must stay open until a new SOP succeeds. MR poll / reconcile
// uses "now" as checkedAt and would otherwise immediately lock the item again.
if strings.EqualFold(issue.DeliveryState, "reopened") && !fromSOP {
return true
}
// Poll / reconcile may see leftover MRs from earlier SOP runs. Those rows
// stay in mr_delivery_states for analytics, but must not replace the
// work item's delivery MRs.
if !fromSOP {
for _, mr := range mrs {
if len(issue.DeliveryMRList()) > 0 && !issue.HasDeliveryMR(mr.URL) {
return true
}
}
}
return issue.DeliveryState == "merged" && !deliveredAt.After(issue.DeliveryUpdatedAt)
}
func (r *DeliveryRepo) ReopenDeliveredIssue(issueID string) (domain.Issue, error) {
issue, ok := r.issues.Issue(strings.TrimSpace(issueID))
if !ok {
return domain.Issue{}, fmt.Errorf("issue not found")
}
if !strings.EqualFold(issue.Status, "closed") && !issue.DeliveryLocked() {
return domain.Issue{}, fmt.Errorf("工作项尚未完成交付,无需重新打开")
}
if issue.TrackerClosed() {
return domain.Issue{}, fmt.Errorf("外部工作项仍处于关闭状态,请先在外部系统重新打开")
}
if issue.DeliveryLocked() {
issue.DeliveryState = "reopened"
}
issue.DeliveryUpdatedAt = time.Now().UTC()
issue.Status = "todo"
issue.CloseSource = ""
issue.AutomationState = "eligible"
if err := r.issues.PutIssue(issue); err != nil {
return domain.Issue{}, err
}
stored, _ := r.issues.Issue(issue.ID)
return stored, nil
}
// ReconcileMergedMRDeliveries applies terminal delivery state for MR rows that
// were already merged before this version was deployed. Human-reopened items
// stay open until a new SOP succeeds.
func (r *DeliveryRepo) ReconcileMergedMRDeliveries() error {
var rows []mrDeliveryStateRow
if err := r.DB.Where("state = 'merged' AND issue_id <> '' AND issue_id <> ?", domain.BaselinePromoteIssueID).Find(&rows).Error; err != nil {
return err
}
type mergedDelivery struct {
issueID, mrURL string
at time.Time
}
items := []mergedDelivery{}
for _, row := range rows {
if r.classifyMRDelivery(row.toDomain()) != "merged" {
continue
}
at := time.Time{}
if row.Updated != nil {
at = *row.Updated
}
if row.CheckedAt != nil {
at = *row.CheckedAt
}
items = append(items, mergedDelivery{issueID: row.IssueID, mrURL: row.MRURL, at: at})
}
for _, item := range items {
if err := r.MarkIssueDelivered(item.issueID, item.mrURL, item.at); err != nil {
return err
}
}
return nil
}
// ReconcileUnlinkedDeliveryMRs attaches MR links that were present in a
// succeeded run but missed at delivery time. It is a one-shot backfill for
// items already locked with an empty link; new runs record the link when they
// finish. Items with nothing to recover stay empty and are not retried here.
func (r *DeliveryRepo) ReconcileUnlinkedDeliveryMRs() error {
now := time.Now().UTC()
for _, issue := range r.issues.Issues() {
if !issue.DeliveryLocked() || len(issue.DeliveryMRList()) > 0 {
continue
}
recovered := r.recoverUnlinkedDeliveryMRs(issue)
if len(recovered) == 0 {
continue
}
for idx := range recovered {
recovered[idx].State = r.registerDeliveryMR(issue.ID, recovered[idx], now)
}
issue.SetDeliveryMRs(recovered)
if err := r.issues.PutIssue(issue); err != nil {
return err
}
}
return nil
}
// ReconcileCompletedDeliveries locks issues whose latest SOP already succeeded
// but were created before delivery locking shipped.
func (r *DeliveryRepo) ReconcileCompletedDeliveries() error {
for _, issue := range r.issues.Issues() {
if issue.DeliveryLocked() || strings.EqualFold(issue.DeliveryState, "reopened") {
continue
}
taskID := strings.TrimSpace(issue.LatestTaskID)
if taskID == "" {
continue
}
task, ok := r.tasks.Task(taskID)
if !ok || task.Status != "completed" || strings.TrimSpace(task.RunID) == "" {
continue
}
run, ok := r.runs.Run(task.RunID)
if !ok || run.Status != "succeeded" {
continue
}
at := run.UpdatedAt
if at.IsZero() {
at = time.Now().UTC()
}
if err := r.markIssueDelivered(issue.ID, domain.ResolveRunDeliveryMRs(run, nil), at, false); err != nil {
return err
}
}
return nil
}
// ReconcileDeliveryMRStates refreshes deliveryMrState labels for locked issues.
func (r *DeliveryRepo) ReconcileDeliveryMRStates() error {
for _, issue := range r.issues.Issues() {
if !issue.DeliveryLocked() {
continue
}
list := issue.DeliveryMRList()
if len(list) == 0 {
if issue.DeliveryMRState != "" {
issue.DeliveryMRState = ""
_ = r.issues.PutIssue(issue)
}
continue
}
for idx := range list {
state := r.lookupMRDeliveryState(list[idx].URL)
// Keep a mainline label after the human-owned baseline → default MR
// landed; the work MR still targets the integrate branch.
if state == "" || domain.KeepMainlineDeliveryLabel(list[idx].State, state) {
continue
}
list[idx].State = state
}
before := issue
issue.SetDeliveryMRs(list)
if deliveryMRFieldsEqual(before, issue) {
continue
}
_ = r.issues.PutIssue(issue)
}
return r.ReconcileBaselinePromoteDeliveries()
}
// PromoteIssueToMainline marks a baseline-integrated issue as on the default
// branch after the human-owned promote MR merged. The work MR URL is kept.
func (r *DeliveryRepo) PromoteIssueToMainline(issueID, mrURL string, at time.Time) error {
issueID = strings.TrimSpace(issueID)
if issueID == "" {
return nil
}
issue, ok := r.issues.Issue(issueID)
if !ok {
return nil
}
if strings.EqualFold(issue.DeliveryState, "reopened") {
return nil
}
if at.IsZero() {
at = time.Now().UTC()
}
changed := false
if issue.DeliveryState != "merged" {
issue.DeliveryState = "merged"
if issue.Status != "closed" {
issue.Status = "done"
}
issue.AutomationState = "ignored"
changed = true
}
before := issue
if trimmed := strings.TrimSpace(mrURL); trimmed != "" {
issue.SetDeliveryMRState(trimmed, "merged")
} else if len(issue.DeliveryMRList()) == 0 {
issue.DeliveryMRState = "merged"
}
if !deliveryMRFieldsEqual(before, issue) {
changed = true
}
if at.After(issue.DeliveryUpdatedAt) {
issue.DeliveryUpdatedAt = at.UTC()
changed = true
}
if !changed {
return nil
}
return r.issues.PutIssue(issue)
}
// PromoteIntegratedIssuesIfBaselineLanded no longer upgrades labels from a
// promote MR's timestamp. Whether baseline work is on the default branch is
// decided by commit containment in the MR sync.
func (r *DeliveryRepo) PromoteIntegratedIssuesIfBaselineLanded(string, time.Time) error {
return nil
}
// ReconcileBaselinePromoteDeliveries used to fan a merged promote MR out by
// timestamp. Commit containment in the MR sync owns that decision now.
func (r *DeliveryRepo) ReconcileBaselinePromoteDeliveries() error {
return nil
}
func (r *DeliveryRepo) promoteIntegratedIssues(project string, promoteAt time.Time) error {
seen := map[string]struct{}{}
var rows []mrDeliveryStateRow
if err := r.DB.Where("mr_project = ? AND issue_id <> '' AND issue_id <> ?", project, domain.BaselinePromoteIssueID).Find(&rows).Error; err != nil {
return err
}
for _, row := range rows {
item := row.toDomain()
if domain.IsBaselinePromoteIssueID(item.IssueID) {
continue
}
at := item.UpdatedAt
if !item.CheckedAt.IsZero() {
at = item.CheckedAt
}
if r.classifyMRDelivery(domain.MRDeliveryState{MRProject: project, State: item.State, TargetBranch: item.TargetBranch}) != "integrated" {
continue
}
if !domain.WorkLandedWithPromote(at.UTC(), promoteAt) {
continue
}
if err := r.PromoteIssueToMainline(item.IssueID, item.MRURL, promoteAt); err != nil {
return err
}
seen[item.IssueID] = struct{}{}
}
for _, issue := range r.issues.Issues() {
if _, ok := seen[issue.ID]; ok {
continue
}
if !domain.WorkLandedWithPromote(issue.DeliveryUpdatedAt, promoteAt) {
continue
}
for _, mr := range issue.DeliveryMRList() {
if !strings.EqualFold(mr.State, "integrated") {
continue
}
proj, _, _, ok := domain.ParseDeliveryMRURL(mr.URL)
if !ok || !strings.EqualFold(strings.TrimSpace(proj), project) {
continue
}
if err := r.PromoteIssueToMainline(issue.ID, mr.URL, promoteAt); err != nil {
return err
}
}
}
return nil
}
// recoverUnlinkedDeliveryMRs reads the issue's latest succeeded SOP. Branch
// lookup already ran at delivery time; this pass only recovers MR URLs quoted
// in artifacts so a missed link can be attached without reopening the item.
func (r *DeliveryRepo) recoverUnlinkedDeliveryMRs(issue domain.Issue) []domain.DeliveryMR {
if r.tasks == nil || r.runs == nil {
return nil
}
taskID := strings.TrimSpace(issue.LatestTaskID)
if taskID == "" {
return nil
}
task, ok := r.tasks.Task(taskID)
if !ok || strings.TrimSpace(task.RunID) == "" {
return nil
}
run, ok := r.runs.Run(task.RunID)
if !ok || run.Status != "succeeded" {
return nil
}
return domain.ResolveRunDeliveryMRs(run, nil)
}
// MergedWorkMRs lists merged work MRs for one Gongfeng project. Baseline
// promote rows are omitted; the caller decides landing from commit refs.
func (r *DeliveryRepo) MergedWorkMRs(project string) ([]domain.MRDeliveryState, error) {
project = strings.TrimSpace(project)
if project == "" {
return nil, nil
}
var rows []mrDeliveryStateRow
if err := r.DB.Where("mr_project = ? AND state = ? AND issue_id <> '' AND issue_id <> ?", project, "merged", domain.BaselinePromoteIssueID).Find(&rows).Error; err != nil {
return nil, err
}
out := make([]domain.MRDeliveryState, 0, len(rows))
for _, row := range rows {
out = append(out, row.toDomain())
}
return out, nil
}
// ApplyDefaultBranchLanding sets the delivery label from whether the work
// commit is contained in the default branch. The work MR URL is kept.
func (r *DeliveryRepo) ApplyDefaultBranchLanding(issueID, mrURL string, onDefault bool) error {
if onDefault {
return r.PromoteIssueToMainline(issueID, mrURL, time.Now().UTC())
}
return r.demoteIssueToBaseline(issueID, mrURL)
}
func (r *DeliveryRepo) demoteIssueToBaseline(issueID, mrURL string) error {
issue, ok := r.issues.Issue(strings.TrimSpace(issueID))
if !ok || strings.EqualFold(issue.DeliveryState, "reopened") {
return nil
}
mrURL = strings.TrimSpace(mrURL)
if mrURL == "" || !strings.EqualFold(issue.DeliveryMRState, "merged") {
return nil
}
before := issue
if !issue.SetDeliveryMRState(mrURL, "integrated") {
return nil
}
if deliveryMRFieldsEqual(before, issue) {
return nil
}
return r.issues.PutIssue(issue)
}
func (r *DeliveryRepo) lookupMRDeliveryState(mrURL string) string {
project, iid, _, ok := domain.ParseDeliveryMRURL(mrURL)
if !ok {
return ""
}
states := r.MRDeliveryStatesMap([]domain.MRDeliveryKey{{Project: project, IID: iid}})
if st, ok := states[domain.MRDeliveryKey{Project: project, IID: iid}]; ok {
if classified := r.classifyMRDelivery(st); classified != "" {
return classified
}
}
return "unknown"
}
func (r *DeliveryRepo) classifyMRDelivery(st domain.MRDeliveryState) string {
def, integ := r.branchContextForMRProject(st.MRProject)
return domain.ClassifyMRDeliveryState(st.State, st.TargetBranch, def, integ)
}
func (r *DeliveryRepo) branchContextForMRProject(project string) (defaultBranch, integrate string) {
integrate = domain.DefaultIntegrateBranch
project = strings.TrimSpace(project)
if project == "" {
return "", integrate
}
for _, repo := range r.catalog.Repositories() {
if strings.EqualFold(strings.TrimSpace(repo.GongfengProjectID), project) {
return strings.TrimSpace(repo.DefaultBranch), strings.TrimSpace(repo.IntegrateBranch)
}
}
return "", integrate
}
func (r *DeliveryRepo) shouldWriteIssueDeliveryFromMR(issueID, mrURL string) bool {
issue, ok := r.issues.Issue(strings.TrimSpace(issueID))
if !ok {
return false
}
if len(issue.DeliveryMRList()) == 0 {
return true
}
return issue.HasDeliveryMR(mrURL)
}
func (r *DeliveryRepo) syncIssueMRState(issueID, mrURL, state string) error {
issue, ok := r.issues.Issue(strings.TrimSpace(issueID))
if !ok {
return nil
}
if !r.shouldWriteIssueDeliveryFromMR(issue.ID, mrURL) {
return nil
}
state = strings.TrimSpace(state)
if strings.TrimSpace(mrURL) == "" || state == "" {
return nil
}
before := issue
issue.SetDeliveryMRState(mrURL, state)
if deliveryMRFieldsEqual(before, issue) {
return nil
}
return r.issues.PutIssue(issue)
}
func deliveryMRFieldsEqual(a, b domain.Issue) bool {
if a.DeliveryMRURL != b.DeliveryMRURL || a.DeliveryMRState != b.DeliveryMRState || len(a.DeliveryMRs) != len(b.DeliveryMRs) {
return false
}
for i := range a.DeliveryMRs {
if a.DeliveryMRs[i] != b.DeliveryMRs[i] {
return false
}
}
return true
}
func (r *DeliveryRepo) MRDeliveryStatesMap(keys []domain.MRDeliveryKey) map[domain.MRDeliveryKey]domain.MRDeliveryState {
out := map[domain.MRDeliveryKey]domain.MRDeliveryState{}
if len(keys) == 0 {
return out
}
conditions := make([]string, 0, len(keys))
args := make([]any, 0, len(keys)*2)
for _, k := range keys {
if k.Project == "" || k.IID <= 0 {
continue
}
conditions = append(conditions, "(mr_project = ? AND mr_iid = ?)")
args = append(args, k.Project, k.IID)
}
if len(conditions) == 0 {
return out
}
var rows []mrDeliveryStateRow
if err := r.DB.Where(strings.Join(conditions, " OR "), args...).Find(&rows).Error; err != nil {
return out
}
for _, row := range rows {
item := row.toDomain()
out[domain.MRDeliveryKey{Project: item.MRProject, IID: item.MRIID}] = item
}
return out
}
func (r *DeliveryRepo) MRDeliveryStatesNeedingRefresh(staleBefore time.Time) ([]domain.MRDeliveryState, error) {
var rows []mrDeliveryStateRow
if err := r.DB.
Where("(state NOT IN ('merged', 'closed') OR (state='merged' AND (target_branch='' OR merged_at IS NULL))) AND (checked_at IS NULL OR checked_at < ?)", staleBefore.UTC()).
Order("checked_at IS NULL DESC, checked_at ASC").
Find(&rows).Error; err != nil {
return nil, err
}
out := []domain.MRDeliveryState{}
for _, row := range rows {
out = append(out, row.toDomain())
}
return out, nil
}
func (r *DeliveryRepo) ListMRDeliveryStates() ([]domain.MRDeliveryState, error) {
var rows []mrDeliveryStateRow
if err := r.DB.Order("updated_at DESC").Find(&rows).Error; err != nil {
return nil, err
}
out := []domain.MRDeliveryState{}
for _, row := range rows {
out = append(out, row.toDomain())
}
return out, nil
}
// DiscoverMRDeliveryStatesFromArtifacts registers MR links found in run artifacts.
func (r *DeliveryRepo) DiscoverMRDeliveryStatesFromArtifacts() error {
var rows []struct {
ExecutionContext string `gorm:"column:execution_context"`
Name string `gorm:"column:name"`
NodeID string `gorm:"column:node_id"`
Content string `gorm:"column:content"`
}
if err := r.DB.Table("run_artifacts").
Joins("JOIN runs r ON r.id = run_artifacts.run_id").
Where("run_artifacts.content LIKE ? AND (run_artifacts.name IN ('mr-body','e2e-report','closeout') OR run_artifacts.node_id='mr' OR run_artifacts.name LIKE '%mr%') AND run_artifacts.name NOT LIKE '%patch%' AND run_artifacts.name NOT LIKE '%diff%'", "%merge_requests/%").
Select("r.execution_context AS execution_context, run_artifacts.name AS name, run_artifacts.node_id AS node_id, run_artifacts.content AS content").
Find(&rows).Error; err != nil {
return err
}
type pending struct {
project string
iid int
url string
issueID string
pri int
}
seen := map[string]pending{}
for _, row := range rows {
pri := domain.MRArtifactPriority(row.Name, "", row.NodeID)
if pri <= 0 {
continue
}
issueID := issueIDFromExecutionContext(row.ExecutionContext)
for _, ref := range domain.ParseGongfengMRs(row.Content) {
key := ref.Project + "#" + fmt.Sprintf("%d", ref.IID)
if cur, exists := seen[key]; exists && (cur.pri > pri || (cur.pri == pri && len(cur.url) >= len(ref.URL))) {
continue
}
seen[key] = pending{project: ref.Project, iid: ref.IID, url: ref.URL, issueID: issueID, pri: pri}
}
}
for _, item := range seen {
if err := r.EnsureMRDeliveryState(item.project, item.iid, item.url, item.issueID); err != nil {
return err
}
}
return nil
}
func issueIDFromExecutionContext(raw string) string {
raw = strings.TrimSpace(raw)
if raw == "" {
return ""
}
var ctx domain.TelemetryContext
if json.Unmarshal([]byte(raw), &ctx) != nil {
return ""
}
return strings.TrimSpace(ctx.IssueID)
}
// ---------- Delivery analytics ----------
type deliveryAcc struct {
item domain.AnalyticsDelivery
latest time.Time
latestRun domain.Run
mrAt time.Time
displayRank int
mrs []mrRef
// 该需求全部关联执行(含失败与返工)的累计节点求和耗时与执行次数。
execDuration int64
runCount int
failedRuns int
reworks int
firstRunAt time.Time
lastRunAt time.Time
// costKnown requires every included attempt to have a recognized cost.
costKnown bool
runs []domain.Run
clarificationDuration int64
developmentDuration int64
testDuration int64
clarificationStart time.Time
clarificationSource string
developmentStart time.Time
developmentSource string
developmentRunID string
phaseSamples domain.AnalyticsPhaseSamples
phaseEvidence []domain.AnalyticsPhaseEvidence
unclassifiedPhaseNodes int
}
func requirementPhaseDurations(run domain.Run, fallback domain.WorkflowDefinition) (clarification, development, test int64) {
measurements := requirementPhaseMeasurements(run, fallback)
return measurements.clarification, measurements.development, measurements.test
}
type phaseMeasurements struct {
clarification int64
development int64
test int64
clarificationStart time.Time
clarificationStartSource string
developmentStart time.Time
developmentStartSource string
samples domain.AnalyticsPhaseSamples
evidence []domain.AnalyticsPhaseEvidence
unclassified int
}
func requirementPhaseMeasurements(run domain.Run, fallback domain.WorkflowDefinition) phaseMeasurements {
var result phaseMeasurements
workflow := run.WorkflowSnapshot
frozenDefinition := workflow.ID != ""
if workflow.ID == "" {
workflow = fallback
}
definitions := make(map[string]domain.WorkflowNode, len(workflow.Nodes))
for _, node := range workflow.Nodes {
definitions[node.ID] = node
}
lane := domain.InferSOPLane(workflow)
for nodeID, nodeRun := range run.Nodes {
if nodeRun == nil || nodeRun.StartedAt.IsZero() {
continue
}
definition := definitions[nodeID]
// A composed SOP node encloses its child Run. Counting both would
// duplicate the same wall-clock time in requirement phase totals.
if definition.Type == "sop" {
continue
}
stage, source := nodeMetricStage(nodeID, definition, lane, frozenDefinition)
if stage == "clarification" && (result.clarificationStart.IsZero() || nodeRun.StartedAt.Before(result.clarificationStart)) {
result.clarificationStart, result.clarificationStartSource = nodeRun.StartedAt, source
}
if stage == "development" && (result.developmentStart.IsZero() || nodeRun.StartedAt.Before(result.developmentStart)) {
result.developmentStart, result.developmentStartSource = nodeRun.StartedAt, source
}
if nodeRun.FinishedAt.IsZero() || nodeRun.FinishedAt.Before(nodeRun.StartedAt) {
continue
}
duration := nodeRun.FinishedAt.Sub(nodeRun.StartedAt).Milliseconds()
switch stage {
case "clarification":
result.clarification += duration
result.samples.Clarification++
case "development":
result.development += duration
result.samples.Development++
case "testing":
result.test += duration
result.samples.Testing++
default:
if stage != "none" {
result.unclassified++
}
continue
}
if source == "inferred" {
result.samples.Inferred++
}
result.evidence = append(result.evidence, domain.AnalyticsPhaseEvidence{
RunID: run.ID, NodeID: nodeID, Stage: stage, Source: source, DurationMs: duration,
})
}
sort.Slice(result.evidence, func(i, j int) bool {
if result.evidence[i].RunID != result.evidence[j].RunID {
return result.evidence[i].RunID < result.evidence[j].RunID
}
return result.evidence[i].NodeID < result.evidence[j].NodeID
})
return result
}
// nodeMetricStage resolves which requirement phase a node counts toward and
// where that answer came from. An explicit MetricStage is "explicit" only when
// it was read from the Run's frozen workflow snapshot; a blank one falls back
// to inferring the stage from the node ID, name and lane.
func nodeMetricStage(nodeID string, definition domain.WorkflowNode, lane string, frozenDefinition bool) (stage, source string) {
if stage = strings.TrimSpace(definition.MetricStage); stage == "" {
return inferLegacyMetricStage(nodeID, definition.Name, lane), "inferred"
}
if !frozenDefinition {
return stage, "inferred"
}
return stage, "explicit"
}
func inferLegacyMetricStage(nodeID, name, lane string) string {
text := strings.ToLower(strings.TrimSpace(nodeID + " " + name))
switch {
case strings.Contains(text, "澄清") || strings.Contains(text, "需求确认") || strings.Contains(text, "clarif") || strings.Contains(text, "requirement-shaping"):
return "clarification"
case strings.Contains(text, "测试") || strings.Contains(text, "验证") || strings.Contains(text, "验收") || strings.Contains(text, "test") || strings.Contains(text, "verify") || strings.Contains(text, " qa"):
return "testing"
case strings.Contains(text, "研发") || strings.Contains(text, "开发") || strings.Contains(text, "前端") || strings.Contains(text, "后端") || strings.Contains(text, "implement") || strings.Contains(text, "coding") || strings.Contains(text, "frontend") || strings.Contains(text, "backend"):
return "development"
case lane == domain.SOPLaneProduct || lane == domain.SOPLaneDesign:
return "clarification"
default:
return ""
}
}
// mrRef 记录一个 issue 关联到的某个 MR。同一需求跑多次、提多个 MR 时会有多条。
type mrRef struct {
project string
iid int
url string
createdAt time.Time
sourceRank int
}
// addMR 按 project+iid 去重登记一个 MR。
func (a *deliveryAcc) addMR(project string, iid int, url string, at time.Time, sourceRank int) {
for i := range a.mrs {
if a.mrs[i].project == project && a.mrs[i].iid == iid {
if url != "" && a.mrs[i].url == "" {
a.mrs[i].url = url
}
if at.After(a.mrs[i].createdAt) {
a.mrs[i].createdAt = at
}
if sourceRank > a.mrs[i].sourceRank {
a.mrs[i].sourceRank = sourceRank
}
return
}
}
a.mrs = append(a.mrs, mrRef{project: project, iid: iid, url: url, createdAt: at, sourceRank: sourceRank})
}
func (a *deliveryAcc) addMRsFromText(text string, at time.Time, sourceRank int) {
for i, ref := range domain.ParseGongfengMRs(text) {
a.addMR(ref.Project, ref.IID, ref.URL, at, sourceRank)
if i > 0 {
continue
}
if a.item.MRURL != "" && sourceRank < a.displayRank {
continue
}
if a.item.MRURL != "" && sourceRank == a.displayRank && !at.After(a.mrAt) {
continue
}
a.displayRank = sourceRank
a.mrAt = at
a.item.MRURL = ref.URL
a.item.MRProject = ref.Project
a.item.MRIID = ref.IID
a.item.MRState = "unknown"
}
}
// deliveryGroupKey keeps TAPD throughput at one row per external requirement,
// even when an import created multiple local Issue records for the same story.
func deliveryGroupKey(issueID string, issue domain.Issue, run domain.Run) string {
if externalID := issue.RequirementTAPDID(); externalID != "" {
projectID := strings.TrimSpace(issue.ProjectID)
if projectID == "" {
projectID = strings.TrimSpace(run.ExecutionContext.ProjectID)
}
return "tapd\x00" + projectID + "\x00" + externalID
}
return "issue\x00" + issueID
}
// deliveryRunIssueID returns the run's requirement ID when the run counts
// toward deliveries under filter; buildDeliveries and countDeliveryGroups
// must share this so the overview badge matches the delivery tab.
func deliveryRunIssueID(filter domain.AnalyticsFilter, run domain.Run, issues map[string]domain.Issue) (string, bool) {
issueID := strings.TrimSpace(run.ExecutionContext.IssueID)
if issueID == "" {
return "", false
}
if filter.WorkflowID != "" && run.WorkflowID != filter.WorkflowID {
return "", false
}
if !analyticsRunInWindow(run, filter) {
return "", false
}
issue := issues[issueID]
if filter.UserID != "" && !analyticsRunMatchesUser(run, filter.UserID, issue) {
return "", false
}
if filter.IssueSource != "" && !analyticsIssueMatchesSource(issue, filter.IssueSource) {
return "", false
}
if filter.RequirementsOnly && !analyticsIsRequirementIssue(issue) {
return "", false
}
return issueID, true
}
// countDeliveryGroups is the overview counterpart of len(buildDeliveries):
// same run filter and grouping, without MR lookups or phase accounting.
func countDeliveryGroups(filter domain.AnalyticsFilter, runs []domain.Run, issues map[string]domain.Issue) int {
groups := map[string]struct{}{}
for _, run := range runs {
issueID, ok := deliveryRunIssueID(filter, run, issues)
if !ok {
continue
}
groups[deliveryGroupKey(issueID, issues[issueID], run)] = struct{}{}
}
return len(groups)
}
// buildDeliveries 按需求聚合全部关联执行。issues 允许传入已加载的需求快照,
// 传 nil 时内部自行加载,避免同一次分析重复查询。
func (r *DeliveryRepo) buildDeliveries(filter domain.AnalyticsFilter, now time.Time, runs []domain.Run, workflowDefs map[string]domain.WorkflowDefinition, issues map[string]domain.Issue) []domain.AnalyticsDelivery {
byIssue := map[string]*deliveryAcc{}
if issues == nil {
issues = map[string]domain.Issue{}
for _, issue := range r.issues.Issues() {
issues[issue.ID] = issue
}
}
clarificationByGroup := map[string]time.Time{}
for issueID, issue := range issues {
started := issue.Clarification.StartedAt
if started.IsZero() {
continue
}
key := deliveryGroupKey(issueID, issue, domain.Run{})
if prior := clarificationByGroup[key]; prior.IsZero() || started.Before(prior) {
clarificationByGroup[key] = started
}
}
mrRuns := make([]domain.Run, 0, len(runs))
for _, run := range runs {
if _, ok := deliveryRunIssueID(filter, run, issues); ok {
mrRuns = append(mrRuns, run)
}
}
mrText := r.mrTextsByRun(mrRuns)
for _, run := range runs {
issueID, ok := deliveryRunIssueID(filter, run, issues)
if !ok {
continue
}
groupKey := deliveryGroupKey(issueID, issues[issueID], run)
acc := byIssue[groupKey]
if acc == nil {
acc = &deliveryAcc{item: domain.AnalyticsDelivery{IssueID: issueID, MRState: "none"}, costKnown: true}
if started := clarificationByGroup[groupKey]; !started.IsZero() {
acc.clarificationStart, acc.clarificationSource = started, "recorded"
}
byIssue[groupKey] = acc
}
// 需求维度的 Token/成本累计其全部关联执行,包含失败与返工。
acc.item.Tokens += run.Usage.TotalTokens
acc.item.CostUSD += run.Usage.CostUSD
acc.costKnown = acc.costKnown && usageCostKnown(run.Usage)
// A child SOP run lies inside its parent's SOP node: its usage, phases
// and reworks count, but not as another run or another stretch of time.
if run.IsWorkspace() {
// A conversation workspace has no SOP graph: only its usage and
// active period count, never as an SOP run or phase sample.
if acc.firstRunAt.IsZero() || run.CreatedAt.Before(acc.firstRunAt) {
acc.firstRunAt = run.CreatedAt
}
if ended := run.UpdatedAt; ended.After(acc.lastRunAt) {
acc.lastRunAt = ended
}
if acc.latestRun.ID == "" || acc.latestRun.IsWorkspace() && run.CreatedAt.After(acc.latest) {
acc.latest = run.CreatedAt
acc.latestRun = run
acc.item.IssueID = issueID
}
continue
}
nested := strings.TrimSpace(run.ExecutionContext.ParentRunID) != ""
if !nested {
acc.execDuration += runExecutionDuration(run)
}
phase := requirementPhaseMeasurements(run, workflowDefs[run.WorkflowID])
acc.developmentDuration += phase.development
acc.testDuration += phase.test
acc.phaseSamples.Development += phase.samples.Development
acc.phaseSamples.Testing += phase.samples.Testing
acc.phaseSamples.Inferred += phase.samples.Inferred
for _, evidence := range phase.evidence {
if evidence.Stage != "clarification" {
acc.phaseEvidence = append(acc.phaseEvidence, evidence)
}
}
if started := phase.clarificationStart; !started.IsZero() && (acc.clarificationStart.IsZero() || started.Before(acc.clarificationStart)) {
acc.clarificationStart, acc.clarificationSource = started, phase.clarificationStartSource
}
if started := phase.developmentStart; !started.IsZero() && (acc.developmentStart.IsZero() || started.Before(acc.developmentStart)) {
acc.developmentStart, acc.developmentSource, acc.developmentRunID = started, phase.developmentStartSource, run.ID
}
acc.unclassifiedPhaseNodes += phase.unclassified
acc.reworks += runReworks(run)
if !nested {
acc.runCount++
if run.Status == "failed" {
acc.failedRuns++
}
}
if acc.firstRunAt.IsZero() || run.CreatedAt.Before(acc.firstRunAt) {
acc.firstRunAt = run.CreatedAt
}
if ended := runEndedAt(run, now); ended.After(acc.lastRunAt) {
acc.lastRunAt = ended
}
latestNested := strings.TrimSpace(acc.latestRun.ExecutionContext.ParentRunID) != ""
newer := acc.latest.IsZero() || run.CreatedAt.After(acc.latest)
if acc.latestRun.ID == "" || acc.latestRun.IsWorkspace() || (!nested && (latestNested || newer)) || (nested && latestNested && newer) {
acc.latest = run.CreatedAt
acc.latestRun = run
acc.item.IssueID = issueID
}
acc.runs = append(acc.runs, run)
text := mrText[run.ID]
if text == "" {
text = runMRText(run)
}
acc.addMRsFromText(text, run.CreatedAt, 40)
}
out := make([]domain.AnalyticsDelivery, 0, len(byIssue))
mrsByIssue := make(map[string][]mrRef, len(byIssue))
projectCache := map[string]domain.Project{}
for _, acc := range byIssue {
issueID := acc.item.IssueID
run := acc.latestRun
acc.item.RunID = run.ID
acc.item.RunStatus = run.Status
acc.item.SOPSucceeded = !run.IsWorkspace() && run.Status == "succeeded"
acc.item.DirectDelivery = run.IsWorkspace()
acc.item.WorkflowID = run.WorkflowID
acc.item.WorkflowName = run.WorkflowSnapshot.Name
if run.IsWorkspace() {
acc.item.WorkflowName = "对话改代码"
}
if acc.item.WorkflowName == "" {
acc.item.WorkflowName = workflowDefs[run.WorkflowID].Name
}
if acc.item.WorkflowName == "" {
acc.item.WorkflowName = run.WorkflowID
}
duration, _ := analyticsRunDuration(run, now)
if run.IsWorkspace() {
duration = 0
}
acc.item.DurationMs = duration
acc.item.RunCount = acc.runCount
acc.item.FailedRuns = acc.failedRuns
acc.item.Reworks = acc.reworks
// 执行耗时为该需求全部执行按 SOP 节点求和的累计值;周期耗时为首次执行开始到最后一次执行结束。
acc.item.ExecutionDurationMs = acc.execDuration
if !acc.clarificationStart.IsZero() && !acc.developmentStart.IsZero() && !acc.developmentStart.Before(acc.clarificationStart) {
acc.clarificationDuration = acc.developmentStart.Sub(acc.clarificationStart).Milliseconds()
acc.phaseSamples.Clarification = 1
acc.item.ClarificationStartedAt = acc.clarificationStart
acc.item.DevelopmentStartedAt = acc.developmentStart
source := "explicit"
if acc.clarificationSource == "inferred" || acc.developmentSource == "inferred" {
source = "inferred"
}
acc.phaseEvidence = append(acc.phaseEvidence, domain.AnalyticsPhaseEvidence{RunID: acc.developmentRunID, NodeID: "clarification-to-development", Stage: "clarification", Source: source, DurationMs: acc.clarificationDuration, StartedAt: acc.clarificationStart, FinishedAt: acc.developmentStart})
}
acc.item.ClarificationDurationMs = acc.clarificationDuration
acc.item.DevelopmentDurationMs = acc.developmentDuration
acc.item.TestDurationMs = acc.testDuration
acc.item.PhaseSamples = acc.phaseSamples
acc.item.PhaseEvidence = acc.phaseEvidence
acc.item.UnclassifiedPhaseNodes = acc.unclassifiedPhaseNodes
acc.item.FirstRunAt = acc.firstRunAt
acc.item.LastRunAt = acc.lastRunAt
if !acc.firstRunAt.IsZero() && acc.lastRunAt.After(acc.firstRunAt) {
acc.item.CycleDurationMs = acc.lastRunAt.Sub(acc.firstRunAt).Milliseconds()
}
acc.item.UserID = analyticsRunUserID(run, issues[issueID])
acc.item.Category = analyticsWorkflowCategory(run.WorkflowSnapshot, workflowDefs[run.WorkflowID])
acc.item.CostKnown = acc.costKnown
var project domain.Project
if issue, ok := issues[issueID]; ok && r.catalog != nil && r.catalog.projects != nil {
cached, seen := projectCache[issue.ProjectID]
if !seen {
cached, _ = r.catalog.projects.Project(issue.ProjectID)
projectCache[issue.ProjectID] = cached
}
project = cached
}
acc.item.Lanes = compactDeliveryLanes(BuildRequirementSnapshot(issues[issueID], project, acc.runs, nil, workflowDefs, now).Lanes)
if issue, ok := issues[issueID]; ok {
acc.item.Title = issue.Title
acc.item.Source = issue.Source
if acc.item.Source == "" {
acc.item.Source = "local"
}
if issue.ExternalRef != nil {
acc.item.ExternalIID = issue.ExternalRef.ExternalIID
acc.item.IssueURL = issue.ExternalRef.ExternalURL
}
acc.item.ExternalID = issue.RequirementTAPDID()
for _, mr := range issue.DeliveryMRList() {
acc.addMRsFromText(mr.URL, issue.DeliveryUpdatedAt, 100)
}
} else {
acc.item.Title = issueID
acc.item.Source = "local"
}
if acc.item.MRURL == "" {
acc.item.MRState = "none"
}
// Include MR links held on the issue even when its Runs have no artifacts.
mrsByIssue[issueID] = acc.mrs
out = append(out, acc.item)
}
sort.Slice(out, func(i, j int) bool {
if out[i].Delivered != out[j].Delivered {
return out[i].Delivered
}
if out[i].SOPSucceeded != out[j].SOPSucceeded {
return out[i].SOPSucceeded
}
return out[i].RunID > out[j].RunID
})
r.applyMRDeliveryStates(out, mrsByIssue, issues)
return out
}
// overlayIssueMRState merges the state the work item itself recorded for
// the MR at url into the looked-up state: an empty/unknown lookup falls back
// to the recorded state, otherwise the recorded state may only upgrade it
// (see domain.EffectiveAnalyticsMRState).
func overlayIssueMRState(state, url string, own []domain.DeliveryMR) string {
for _, mr := range own {
if !domain.SameGongfengMR(mr.URL, url) {
continue
}
if state == "" || state == "unknown" {
if mr.State != "" {
return mr.State
}
return state
}
return domain.EffectiveAnalyticsMRState(state, mr.State)
}
return state
}
func (r *DeliveryRepo) applyMRDeliveryStates(items []domain.AnalyticsDelivery, mrsByIssue map[string][]mrRef, issues map[string]domain.Issue) {
if len(items) == 0 {
return
}
// 收集该批次所有 issue 关联到的全部 MR(不只是展示用的那个),逐一 ensure 并批量查状态。
keySet := make(map[domain.MRDeliveryKey]struct{})
ensured := map[string]struct{}{}
ensure := func(project string, iid int, url, issueID string) {
if project == "" || iid <= 0 {
return
}
ensureKey := fmt.Sprintf("%s\x00%d\x00%s\x00%s", project, iid, url, issueID)
if _, ok := ensured[ensureKey]; !ok {
_ = r.EnsureMRDeliveryState(project, iid, url, issueID)
ensured[ensureKey] = struct{}{}
}
keySet[domain.MRDeliveryKey{Project: project, IID: iid}] = struct{}{}
}
for i := range items {
for _, ref := range mrsByIssue[items[i].IssueID] {
ensure(ref.project, ref.iid, ref.url, items[i].IssueID)
}
// 兜底:展示用的 MR 一般已在 mrs 中,这里再确保一次。
ensure(items[i].MRProject, items[i].MRIID, items[i].MRURL, items[i].IssueID)
}
if len(keySet) == 0 {
for i := range items {
if issue, ok := issues[items[i].IssueID]; ok {
items[i].MRState = domain.EffectiveAnalyticsMRState(items[i].MRState, issue.DeliveryMRState)
}
domain.FinalizeAnalyticsDelivery(&items[i])
}
return
}
keys := make([]domain.MRDeliveryKey, 0, len(keySet))
for k := range keySet {
keys = append(keys, k)
}
states := r.MRDeliveryStatesMap(keys)
repositories := r.catalog.Repositories()
classify := func(st domain.MRDeliveryState) string {
def, integ := "", domain.DefaultIntegrateBranch
for _, repository := range repositories {
if strings.EqualFold(strings.TrimSpace(repository.GongfengProjectID), strings.TrimSpace(st.MRProject)) {
def, integ = strings.TrimSpace(repository.DefaultBranch), strings.TrimSpace(repository.IntegrateBranch)
break
}
}
return domain.ClassifyMRDeliveryState(st.State, st.TargetBranch, def, integ)
}
for i := range items {
// 同一需求可能跑多次、提多个 MR。只有合入仓库默认分支才算「已合入/已交付」。
// 合入集成分支记为 integrated(已合入基线)。多个候选按
// merged > integrated > opened/closed 取最新的一个。
preferProject, preferIID := "", 0
if issue, ok := issues[items[i].IssueID]; ok {
if p, iid, _, ok := domain.ParseDeliveryMRURL(issue.DeliveryMRURL); ok {
preferProject, preferIID = p, iid
}
}
own := issues[items[i].IssueID].DeliveryMRList()
var best *mrRef
bestState := ""
items[i].MRs = nil
seen := map[domain.MRDeliveryKey]bool{}
for j := range mrsByIssue[items[i].IssueID] {
ref := mrsByIssue[items[i].IssueID][j]
if ref.project == "" || ref.iid <= 0 {
continue
}
st, ok := states[domain.MRDeliveryKey{Project: ref.project, IID: ref.iid}]
mr := domain.DeliveryMR{Project: ref.project, IID: ref.iid, URL: ref.url, State: "unknown", TargetBranch: st.TargetBranch}
if ok {
mr.State = classify(st)
}
mr.State = overlayIssueMRState(mr.State, mr.URL, own)
key := domain.MRDeliveryKey{Project: strings.ToLower(ref.project), IID: ref.iid}
if !seen[key] {
items[i].MRs = append(items[i].MRs, mr)
seen[key] = true
}
if !ok {
continue
}
classified := classify(st)
if classified == "" {
continue
}
if best == nil || betterAnalyticsMR(preferProject, preferIID, *best, bestState, ref, classified) {
copied := ref
best = &copied
bestState = classified
}
}
if best != nil && domain.AnalyticsMRRank(bestState) > 0 {
items[i].MRProject = best.project
items[i].MRIID = best.iid
if best.url != "" {
items[i].MRURL = best.url
}
items[i].MRState = bestState
} else if items[i].MRProject != "" && items[i].MRIID > 0 {
if st, ok := states[domain.MRDeliveryKey{Project: items[i].MRProject, IID: items[i].MRIID}]; ok {
// An unclassified (unknown) lookup must not downgrade a label
// already carried by the run or the locked issue.
if classified := classify(st); classified != "" && classified != "unknown" {
items[i].MRState = classified
}
}
}
if issue, ok := issues[items[i].IssueID]; ok {
items[i].MRState = domain.EffectiveAnalyticsMRState(items[i].MRState, issue.DeliveryMRState)
}
domain.FinalizeAnalyticsDelivery(&items[i])
}
}
func betterAnalyticsMR(preferProject string, preferIID int, best mrRef, bestState string, next mrRef, nextState string) bool {
bestRank := domain.AnalyticsMRRank(bestState)
nextRank := domain.AnalyticsMRRank(nextState)
if nextRank != bestRank {
return nextRank > bestRank
}
bestPref := preferIID > 0 && strings.EqualFold(best.project, preferProject) && best.iid == preferIID
nextPref := preferIID > 0 && strings.EqualFold(next.project, preferProject) && next.iid == preferIID
if nextPref != bestPref {
return nextPref
}
if next.sourceRank != best.sourceRank {
return next.sourceRank > best.sourceRank
}
return next.createdAt.After(best.createdAt)
}
func runMRText(run domain.Run) string {
urls := []string{}
for _, mr := range domain.ResolveRunDeliveryMRs(run, nil) {
urls = append(urls, mr.URL)
}
return strings.Join(urls, "\n")
}
func (r *DeliveryRepo) mrTextsByRun(runs []domain.Run) map[string]string {
out := map[string]string{}
if len(runs) == 0 {
return out
}
if len(runs) > 500 {
for start := 0; start < len(runs); start += 500 {
for id, value := range r.mrTextsByRun(runs[start:min(start+500, len(runs))]) {
out[id] = value
}
}
return out
}
ids := make([]string, 0, len(runs))
byID := map[string]domain.Run{}
for _, run := range runs {
ids = append(ids, run.ID)
byID[run.ID] = run
}
var rows []runArtifactRow
if err := r.DB.Where("run_id IN ? AND content LIKE ? AND name NOT LIKE ? AND name NOT LIKE ?", ids, "%merge_requests/%", "%patch%", "%diff%").
Select("run_id", "name", "path", "node_id", "content").Order("created_at, id").Find(&rows).Error; err != nil {
return out
}
for _, row := range rows {
run := byID[row.RunID]
run.Artifacts = append(run.Artifacts, domain.Artifact{Name: row.Name, Path: row.Path, NodeID: row.NodeID, Content: row.Content})
byID[row.RunID] = run
}
for id, run := range byID {
out[id] = runMRText(run)
}
return out
}
func compactDeliveryLanes(lanes []domain.RequirementLane) []domain.RequirementLane {
if len(lanes) == 0 {
return nil
}
out := make([]domain.RequirementLane, len(lanes))
for i, lane := range lanes {
lane.Stages = nil
out[i] = lane
}
return out
}