forked from longtao.wu/droboticflow
286 lines
10 KiB
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
|
|
}
|