droboticflow/internal/api/review_draft_operation.go
d-robotics 74ea7f8274 🛡️ 03: deprecate task-scope review comments (ADR 0009)
Server: reject NEW task-scope problems on draft PUT (409
review_task_scope_deprecated, ID-matched against stored entries;
existing entries round-trip unchanged, full-replace semantics kept);
formal-rejection flattening no longer emits 整体任务 lines or
expands ProblemSliceIDs; rework-baseline reads hide task problems
(read-only narrowing); workforce stats stop counting task scope.

Frontend: remove task from composer scope lists and card cycle;
hide stored task opinions in rework banner/soft reminder/rail,
QC panel groups and history, acceptance source projection, stats
panel rows, frozen-comment displays (stripTaskOpinionLines);
submit/approve gates count visible problems only; stats panel
documents the 2026-10-14 scope switch.

Data untouched: no migration, no deletion, audit trail intact.
2026-10-14 19:02:29 +08:00

356 lines
12 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package api
import (
"context"
"crypto/sha256"
"droboticflow/internal/domain"
"encoding/json"
"errors"
"fmt"
"net/http"
"strconv"
"strings"
)
var errDraftIntentStale = errors.New("草稿已有新版本,原保存操作不会覆盖新内容")
type reviewDraftSaveInput struct {
ModelVersion int `json:"modelVersion,omitempty"`
Version int `json:"version"`
ResultVersion string `json:"resultVersion"`
OperationID string `json:"operationId"`
Problems []domain.ReviewProblem `json:"problems"`
Confirmations []domain.ReviewConfirmation `json:"confirmations,omitempty"`
}
func (s *server) reviewDecisionProtocol(ctx context.Context, item domain.HumanItemRecord) string {
batch, err := s.humanBatchForListRead(ctx, item.BatchID)
if err != nil || batch == nil {
return "legacy"
}
if batch.RequirePrePackageAcceptance && !isFanyuV5FourStageBatch(batch) && item.CurrentStageID == domain.FanyuV58StageQualityReview {
return "receipt"
}
_, supported, err := v58AggregateSourceBatch(ctx, s, batch)
if err == nil && supported && item.CurrentStageID == fanyuV5PrePackageAcceptanceStageID {
return "receipt"
}
return "legacy"
}
func (s *server) saveRecoverableReviewDraft(w http.ResponseWriter, r *http.Request, item domain.HumanItemRecord, draft domain.ReviewDraft, input reviewDraftSaveInput) {
principal, _ := currentPrincipal(r)
page := r.Header.Get("X-Review-Page")
generation, _ := strconv.Atoi(r.Header.Get("X-Review-Generation"))
session, err := s.store.GetReviewSession(r.Context(), reviewSessionKey(item))
if err != nil {
renderError(w, 500, err)
return
}
if session == nil || !session.Enrolled || session.UserID != principal.User.ID || session.PageID != page || session.Generation != generation || (session.ExpiresAt <= nowISO() && session.WriteID == "") {
reviewSessionFailure(w, "review_session_lost")
return
}
evidence, err := s.reviewTargetEvidenceForItem(r.Context(), item)
if err != nil {
renderError(w, 500, err)
return
}
problems, err := canonicalReviewProblems(input.Problems, evidence)
if err != nil {
renderValidationError(w, validationIssue{Field: "problems", Message: err.Error()})
return
}
input.Problems = problems
confirmations, err := canonicalReviewConfirmations(r.Context(), s, item, input.Confirmations, problems)
if err != nil {
renderValidationError(w, validationIssue{Field: "confirmations", Message: err.Error()})
return
}
input.Confirmations = confirmations
encoded, _ := json.Marshal(problems)
problemDigest := fmt.Sprintf("%x", sha256.Sum256(encoded))
data, digest := reviewDecisionDigest(input)
id := reviewOperationID(item, principal.User.ID, input.OperationID)
old, err := s.store.GetReviewOperation(r.Context(), id)
if err != nil {
renderError(w, 500, err)
return
}
if old != nil {
if !strings.HasSuffix(old.Kind, "_draft") || old.Digest != digest {
renderJSON(w, 409, map[string]string{"code": "review_draft_operation_conflict", "error": "该保存操作内容已变化,请重新核对"})
return
}
old = s.recoverDraftReviewOperation(r.Context(), old, &item)
s.respondReviewOperation(w, r, old, false)
return
}
if session.WriteID != "" {
reviewSessionFailure(w, "review_write_in_progress")
return
}
if draft.LastOperationID == input.OperationID {
if draft.LastOperationDigest != problemDigest {
renderJSON(w, 409, map[string]string{"code": "review_draft_operation_conflict", "error": "该保存操作内容已变化,请重新核对"})
return
}
renderJSON(w, 200, map[string]any{"draft": draft})
return
}
if draft.Version != input.Version {
renderJSON(w, 409, map[string]string{"code": "review_draft_version_conflict", "error": "已保存草稿已有新版本,请核对后再保存"})
return
}
if input.ModelVersion != 0 && input.ModelVersion != 2 || (input.ModelVersion != 2 && (draft.ModelVersion == 2 || duplicateReviewOpinions(problems))) {
renderJSON(w, 409, map[string]string{"code": "review_client_outdated", "error": "请更新页面后继续,未保存文字请先保留"})
return
}
// ADR 0009:整体作用域停用——新增一律拒绝(存量 ID 原样回传不阻断),
// 先于重复意见校验给出明确的停用错误码。
if err := rejectNewTaskScopeProblems(draft, problems); err != nil {
renderJSON(w, 409, map[string]string{"code": "review_task_scope_deprecated", "error": err.Error()})
return
}
if err := validateReviewOpinionChange(draft, problems, input.ModelVersion); err != nil {
renderJSON(w, 409, map[string]string{"code": "review_opinion_duplicate", "error": err.Error()})
return
}
if input.ModelVersion == 2 {
if draft.ModelVersion < 2 && draft.Version > 0 {
draft.LegacyBackupID = fmt.Sprintf("%s:v%d", draft.ID, draft.Version)
}
draft.ModelVersion = 2
}
draft.Problems = problems
draft.Confirmations = confirmations
draft.LastOperationID = input.OperationID
draft.LastOperationDigest = problemDigest
draft.UpdatedAt = nowISO()
kind := "quality_draft"
if item.CurrentStageID == fanyuV5PrePackageAcceptanceStageID {
kind = "acceptance_draft"
}
response := draft
response.Version++
responseJSON, _ := json.Marshal(map[string]any{"draft": response})
op := &domain.ReviewOperation{AcceptanceClaim: item.AcceptanceClaim, ID: id, OperationID: input.OperationID, OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, UserID: principal.User.ID, ItemID: item.ID, StageID: item.CurrentStageID, ReviewRound: item.ReviewRound, ResultVersion: input.ResultVersion, DraftVersion: input.Version, Draft: draft, Kind: kind, Input: data, Digest: digest, SessionKey: session.ID, PageID: page, Generation: generation, Status: "prepared", CreatedAt: nowISO(), Effects: []domain.ReviewDecisionEffect{{Draft: &draft}}, HTTPStatus: 200, Response: responseJSON}
saved, err := s.store.CompareAndSwapReviewOperation(r.Context(), *op, 0)
if err != nil {
renderError(w, 500, err)
return
}
if !saved {
renderJSON(w, 409, map[string]string{"error": "保存操作正在核对,请重试同一操作", "code": "review_draft_operation_conflict"})
return
}
op.Revision = 1
r = r.WithContext(context.WithValue(r.Context(), reviewOperationContextKey{}, op))
defer s.finishReviewDecisionPreparation(r)
finish, allowed := s.beginReviewWrite(w, r, item)
if !allowed {
return
}
defer finish()
current, err := s.loadCurrentReviewDraft(r.Context(), item, principal.User.ID)
if err != nil {
renderError(w, 500, err)
return
}
if current.Version != input.Version || current.ResultVersion != input.ResultVersion {
renderJSON(w, 409, map[string]string{"code": "review_draft_version_conflict", "error": "已保存草稿已有新版本,请核对后再保存"})
return
}
op.Status = "applying"
saved, err = s.store.CompareAndSwapReviewOperation(r.Context(), *op, op.Revision)
if err != nil {
renderError(w, 500, err)
return
}
if saved {
op.Revision++
} else {
op, err = s.store.GetReviewOperation(r.Context(), op.ID)
if err != nil {
renderError(w, 500, err)
return
}
}
s.respondReviewOperation(w, r, op, true)
}
func (s *server) applyDraftReviewOperation(ctx context.Context, op *domain.ReviewOperation, target domain.ReviewDraft) error {
current, err := s.store.GetReviewDraft(ctx, target.ID)
if err != nil {
return err
}
if current != nil && current.LastOperationID == op.OperationID && current.LastOperationDigest == target.LastOperationDigest {
return nil
}
if current != nil && current.Version != target.Version {
return errDraftIntentStale
}
if current != nil && current.ModelVersion < 2 && target.ModelVersion == 2 && current.Version > 0 {
snapshot := *current
snapshot.ID = target.LegacyBackupID
if err := s.store.ArchiveReviewDraft(ctx, snapshot); err != nil {
return err
}
}
saved, err := s.store.CompareAndSwapReviewDraft(ctx, target, target.Version)
if err != nil {
return err
}
if !saved {
current, err = s.store.GetReviewDraft(ctx, target.ID)
if err != nil {
return err
}
if current != nil && current.LastOperationID == op.OperationID && current.LastOperationDigest == target.LastOperationDigest {
return nil
}
return errDraftIntentStale
}
return nil
}
// Cancellation advances only the old draft's CAS version. An already-running
// original writer can no longer land after takeover and overwrite a newer save.
func (s *server) cancelDraftReviewOperation(ctx context.Context, op *domain.ReviewOperation) *domain.ReviewOperation {
// Cancellation itself must not mutate a draft under another writer's fence.
for attempt := 0; attempt < 8; attempt++ {
session, err := s.store.GetReviewSession(ctx, op.SessionKey)
if err != nil {
op.Error = err.Error()
return op
}
if session == nil || session.WriteID == op.ID {
break
}
if session.WriteID != "" {
op.Error = "另一个审查写入正在处理,原草稿保存等待核对"
return op
}
next := *session
next.WriteID = op.ID
saved, err := s.store.CompareAndSwapReviewSession(ctx, next, session.Revision)
if err != nil {
op.Error = err.Error()
return op
}
if saved {
break
}
if attempt == 7 {
return op
}
}
for attempt := 0; attempt < 8; attempt++ {
current, err := s.store.GetReviewDraft(ctx, op.Draft.ID)
if err != nil {
op.Error = err.Error()
return op
}
if current != nil && current.LastOperationID == op.OperationID && current.LastOperationDigest == op.Draft.LastOperationDigest {
op.Status = "applying"
return s.runReviewOperation(ctx, op)
}
if current == nil {
empty := op.Draft
empty.Problems = []domain.ReviewProblem{}
empty.LastOperationID = ""
empty.LastOperationDigest = ""
current = &empty
}
if current.Version == op.DraftVersion {
saved, err := s.store.CompareAndSwapReviewDraft(ctx, *current, current.Version)
if err != nil {
op.Error = err.Error()
return op
}
if !saved {
continue
}
}
op.Status = "failed_before_effects"
op.Error = "审查上下文已变化,原草稿保存已取消;已有文字保留"
saved, err := s.store.CompareAndSwapReviewOperation(ctx, *op, op.Revision)
if err != nil {
op.Error = err.Error()
return op
}
if !saved {
latest, e := s.store.GetReviewOperation(ctx, op.ID)
if e == nil && latest != nil {
op = latest
}
}
s.finishReviewWrite(op.SessionKey, op.ID)
return op
}
return op
}
func (s *server) recoverDraftReviewOperation(ctx context.Context, op *domain.ReviewOperation, item *domain.HumanItemRecord) *domain.ReviewOperation {
if op.Status == "completed" || op.Status == "failed_before_effects" {
s.finishReviewWrite(op.SessionKey, op.ID)
return op
}
version, err := func() (string, error) {
if item == nil {
return "", nil
}
return s.reviewResultVersion(ctx, *item)
}()
if err != nil {
op.Error = err.Error()
return op
}
if item == nil || item.AssignedUserID != op.UserID || item.CurrentStageID != op.StageID || item.ReviewRound != op.ReviewRound || (item.Status != domain.HumanItemClaimed && item.Status != domain.HumanItemInProgress) || version != op.ResultVersion {
return s.cancelDraftReviewOperation(ctx, op)
}
session, err := s.store.GetReviewSession(ctx, op.SessionKey)
if err != nil {
op.Error = err.Error()
return op
}
if session != nil && session.Enrolled && session.UserID == op.UserID && session.PageID == op.PageID && session.Generation == op.Generation && session.WriteID == "" && session.ExpiresAt > nowISO() {
next := *session
next.WriteID = op.ID
saved, e := s.store.CompareAndSwapReviewSession(ctx, next, session.Revision)
if e != nil {
op.Error = e.Error()
return op
}
if saved {
session = &next
} else {
session, err = s.store.GetReviewSession(ctx, op.SessionKey)
if err != nil {
op.Error = err.Error()
return op
}
}
}
if session == nil || session.UserID != op.UserID || session.PageID != op.PageID || session.Generation != op.Generation || session.WriteID != op.ID {
return s.cancelDraftReviewOperation(ctx, op)
}
if op.Status == "prepared" {
op.Status = "applying"
saved, e := s.store.CompareAndSwapReviewOperation(ctx, *op, op.Revision)
if e != nil {
op.Error = e.Error()
return op
}
if saved {
op.Revision++
} else {
latest, e := s.store.GetReviewOperation(ctx, op.ID)
if e != nil || latest == nil {
return op
}
op = latest
}
}
op = s.runReviewOperation(ctx, op)
s.finishReviewWrite(op.SessionKey, op.ID)
return op
}