droboticflow/internal/api/acceptance_rework_baseline.go

286 lines
10 KiB
Go

package api
import (
"context"
"crypto/sha256"
"droboticflow/internal/domain"
"droboticflow/internal/store"
"encoding/json"
"fmt"
"sort"
"strings"
)
// The return marker survives claiming. Legacy source events used the client's
// operation token, so prefer the durable server operation identity.
func (s *server) acceptanceReturnOperation(ctx context.Context, item domain.HumanItemRecord) (*domain.ReviewOperation, error) {
valid := func(op *domain.ReviewOperation) bool {
if op == nil || op.OrganizationID != item.OrganizationID || op.ProjectID != item.ProjectID || op.Status != "completed" || op.Decision != "rejected" || op.StageID != "prepackage_acceptance" {
return false
}
for _, id := range op.SourceItemIDs {
if id == item.ID {
return true
}
}
return false
}
if item.ReviewOperationID != "" {
op, err := s.store.GetReviewOperation(ctx, item.ReviewOperationID)
if err != nil {
return nil, err
}
if valid(op) {
for _, effect := range op.Effects {
if effect.Item != nil && effect.Item.ID == item.ID && effect.Item.ReviewRound == item.ReviewRound {
return op, nil
}
}
}
}
events, err := s.store.ListHumanEvents(ctx, item.OrganizationID, item.ID)
if err != nil {
return nil, err
}
sort.Slice(events, func(i, j int) bool { return events[i].CreatedAt > events[j].CreatedAt })
for _, event := range events {
if event.EventType != "aggregate_acceptance_rejected" || event.Round != item.ReviewRound {
continue
}
for _, field := range []string{"reviewOperationId", "operationId"} {
id, _ := event.Payload[field].(string)
if id == "" {
continue
}
op, err := s.store.GetReviewOperation(ctx, id)
if err != nil {
return nil, err
}
if valid(op) {
return op, nil
}
}
break
}
return nil, nil
}
func acceptanceSourceBaseline(op *domain.ReviewOperation, source domain.HumanItemRecord, aggregate domain.HumanItemRecord, round int) *domain.ReworkBaselineRecord {
var entries []struct {
SourceItemID string `json:"sourceHumanItemId"`
Slices []domain.SliceSegment `json:"finalSlices"`
Actions []domain.AnnotationSegment `json:"annotation"`
}
encoded, _ := json.Marshal(aggregate.Subject.Payload["items"])
if json.Unmarshal(encoded, &entries) != nil {
return nil
}
for _, entry := range entries {
if entry.SourceItemID != source.ID {
continue
}
baseline := &domain.ReworkBaselineRecord{ID: store.ReworkBaselineID(source.ID, round), OrganizationID: source.OrganizationID, ProjectID: source.ProjectID, ItemID: source.ID, BatchID: source.BatchID, Round: round, StageID: domain.FanyuV58StageQualityReview, ReviewOperationID: op.ID, RejectID: op.ID + ":reject", ReviewedRevision: source.CurrentRevision, ResultVersion: op.ResultVersion, CreatedAt: op.CreatedAt, Slices: entry.Slices, Actions: entry.Actions, Problems: []domain.ReviewProblem{}}
for _, original := range op.Draft.Problems {
if original.SourceItemID != source.ID || original.Scope == "task" {
continue
}
p := original
identity := sha256.Sum256([]byte(op.ID + "\x00" + original.ID))
p.ID = fmt.Sprintf("acceptance-%x", identity[:16])
p.SourceItemID = ""
if p.ViewAnchor != nil {
anchor := *p.ViewAnchor
anchor.SourceItemID = ""
p.ViewAnchor = &anchor
}
if p.Scope != "timestamp" && p.TimeBasis == "slice-seconds" {
for _, slice := range entry.Slices {
if slice.ID == p.SliceID {
p.AtSeconds += slice.Start
break
}
}
}
origin := &domain.ReviewProblemOrigin{OperationID: op.ID, ItemID: op.ItemID, ProblemID: original.ID, UserID: op.UserID, StageID: op.StageID, Round: op.ReviewRound, ResultVersion: op.ResultVersion}
canonical, err := canonicalReviewProblems([]domain.ReviewProblem{p}, []reviewTargetEvidence{{slices: entry.Slices, actions: entry.Actions}})
if err != nil {
p.Origin = origin
baseline.UnlocatedProblems = append(baseline.UnlocatedProblems, p)
continue
}
p = canonical[0]
p.Origin = origin
baseline.Problems = append(baseline.Problems, p)
}
if len(op.Draft.Problems) == 0 {
var input struct {
Comment string `json:"comment"`
}
if json.Unmarshal(op.Input, &input) == nil && strings.TrimSpace(input.Comment) != "" {
baseline.Comment = input.Comment
baseline.UnlocatedProblems = append(baseline.UnlocatedProblems, domain.ReviewProblem{ID: op.ID + ":legacy", Scope: "task", Text: input.Comment, Origin: &domain.ReviewProblemOrigin{OperationID: op.ID, ItemID: op.ItemID, UserID: op.UserID, StageID: op.StageID, Round: op.ReviewRound, ResultVersion: op.ResultVersion}})
}
}
return baseline
}
return nil
}
func (s *server) reworkBaselineForRound(ctx context.Context, item domain.HumanItemRecord, round int) (*domain.ReworkBaselineRecord, error) {
baseline, err := s.store.GetReworkBaseline(ctx, store.ReworkBaselineID(item.ID, round))
if err != nil || baseline != nil || round != item.ReviewRound || item.CurrentStageID != domain.FanyuV58StageQualityReview {
return baseline, err
}
op, err := s.acceptanceReturnOperation(ctx, item)
if err != nil {
return nil, err
}
if op == nil {
events, e := s.store.ListHumanEvents(ctx, item.OrganizationID, item.ID)
if e != nil {
return nil, e
}
sort.Slice(events, func(i, j int) bool { return events[i].CreatedAt > events[j].CreatedAt })
for _, event := range events {
if event.EventType != "aggregate_acceptance_rejected" || event.Round != round {
continue
}
comment, _ := event.Payload["comment"].(string)
if strings.TrimSpace(comment) == "" {
return nil, nil
}
return &domain.ReworkBaselineRecord{ID: store.ReworkBaselineID(item.ID, round), OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, ItemID: item.ID, Round: round, StageID: domain.FanyuV58StageQualityReview, CreatedAt: event.CreatedAt, Comment: comment, Problems: []domain.ReviewProblem{}, UnlocatedProblems: []domain.ReviewProblem{{ID: event.ID + ":legacy", Scope: "task", Text: comment, Origin: &domain.ReviewProblemOrigin{UserID: event.ActorUserID, StageID: "prepackage_acceptance"}}}}, nil
}
return nil, nil
}
// Compact operations retain the frozen result in the next Item; BeforeItem
// may contain only a version fence. Never read today's aggregate payload.
for _, effect := range op.Effects {
for _, frozen := range []*domain.HumanItemRecord{effect.Item, effect.BeforeItem} {
if frozen != nil && frozen.ID == op.ItemID {
if baseline := acceptanceSourceBaseline(op, item, *frozen, round); baseline != nil {
return baseline, nil
}
}
}
}
unlocated := domain.HumanItemRecord{}
unlocated.Subject.Payload = map[string]any{"items": []map[string]any{{"sourceHumanItemId": item.ID}}}
return acceptanceSourceBaseline(op, item, unlocated, round), nil
}
// Handling filters a copy; frozen baselines remain available for audit and CAS.
func (s *server) effectiveAcceptanceBaseline(ctx context.Context, item domain.HumanItemRecord, baseline *domain.ReworkBaselineRecord) (*domain.ReworkBaselineRecord, error) {
if baseline == nil {
return nil, nil
}
states := map[string]map[string]bool{}
filter := func(problems []domain.ReviewProblem) ([]domain.ReviewProblem, error) {
out := make([]domain.ReviewProblem, 0, len(problems))
for _, p := range problems {
if p.Origin != nil && p.Origin.StageID == "prepackage_acceptance" {
key := item.ID + ":acceptance-handling:" + p.Origin.OperationID
skipped, loaded := states[key]
if !loaded {
h, err := s.store.GetReworkHandling(ctx, key)
if err != nil {
return nil, err
}
skipped = map[string]bool{}
if h != nil {
for _, id := range h.SkippedOpinionIDs {
skipped[id] = true
}
}
states[key] = skipped
}
if skipped[p.Origin.ProblemID] {
continue
}
}
out = append(out, p)
}
return out, nil
}
visible := *baseline
var err error
visible.Problems, err = filter(baseline.Problems)
if err != nil {
return nil, err
}
visible.UnlocatedProblems, err = filter(baseline.UnlocatedProblems)
return &visible, err
}
// The formal operation owns this CAS fence until it settles. A failed preflight
// can be replaced; an applying decision keeps its exact misreport selection.
func (s *server) freezeAcceptanceHandling(ctx context.Context, item domain.HumanItemRecord, op *domain.ReviewOperation) error {
if item.ReviewRound == 0 {
return nil
}
baseline, err := s.reworkBaselineForRound(ctx, item, item.ReviewRound)
if err != nil || baseline == nil {
return err
}
origins := map[string]bool{}
for _, group := range [][]domain.ReviewProblem{baseline.Problems, baseline.UnlocatedProblems} {
for _, p := range group {
if p.Origin != nil && p.Origin.StageID == "prepackage_acceptance" && p.Origin.OperationID != "" {
origins[p.Origin.OperationID] = true
}
}
}
for origin := range origins {
for attempt := 0; attempt < 8; attempt++ {
id := item.ID + ":acceptance-handling:" + origin
h, e := s.store.GetReworkHandling(ctx, id)
if e != nil {
return e
}
if h == nil {
h = &domain.ReworkHandlingRecord{ID: id, OrganizationID: item.OrganizationID, ItemID: item.ID, Round: item.ReviewRound, OperationID: origin, SkippedOpinionIDs: []string{}}
}
if h.DecisionOperationID == op.ID {
break
}
if h.DecisionOperationID != "" {
previous, e := s.store.GetReviewOperation(ctx, h.DecisionOperationID)
if e != nil {
return e
}
if previous == nil || (previous.Status != "failed_before_effects" && previous.Status != "completed") {
return fmt.Errorf("验收意见仍有提交结果待核对")
}
}
h.DecisionOperationID = op.ID
saved, e := s.store.CompareAndSwapReworkHandling(ctx, *h, h.Version)
if e != nil {
return e
}
if saved {
break
}
if attempt == 7 {
return fmt.Errorf("验收意见状态已变化,请核对后重试")
}
}
}
problems, unlocated, err := s.qualityRejectionOpinions(ctx, item, op.Draft)
if err != nil {
return err
}
visible := len(unlocated) > 0
for _, p := range problems {
if p.Scope != "task" {
visible = true
}
}
if op.Decision == "approved" && visible {
return fmt.Errorf("仍有原退回意见未确认解决,请核对后再通过审核")
}
if op.Decision == "rejected" && op.Draft.ModelVersion == 2 && !visible {
return fmt.Errorf("退回意见已变化,请核对后重新提交")
}
return nil
}