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.
356 lines
12 KiB
Go
356 lines
12 KiB
Go
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
|
||
}
|