forked from longtao.wu/droboticflow
687 lines
24 KiB
Go
687 lines
24 KiB
Go
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"droboticflow/internal/domain"
|
|
"github.com/go-chi/chi/v5"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
)
|
|
|
|
type ReviewDecisionInput struct {
|
|
OperationID string `json:"operationId,omitempty"`
|
|
DraftVersion *int `json:"draftVersion,omitempty"`
|
|
ResultVersion string `json:"resultVersion,omitempty"`
|
|
}
|
|
type reviewOperationContextKey struct{}
|
|
|
|
func operationFromRequest(r *http.Request) *domain.ReviewOperation {
|
|
v, _ := r.Context().Value(reviewOperationContextKey{}).(*domain.ReviewOperation)
|
|
return v
|
|
}
|
|
func reviewDecisionDigest(input any) (json.RawMessage, string) {
|
|
data, _ := json.Marshal(input)
|
|
return data, fmt.Sprintf("%x", sha256.Sum256(data))
|
|
}
|
|
func reviewOperationID(item domain.HumanItemRecord, user, operation string) string {
|
|
data, _ := json.Marshal([]any{item.OrganizationID, item.ID, user, operation})
|
|
return fmt.Sprintf("review-operation-%x", sha256.Sum256(data))
|
|
}
|
|
|
|
func (s *server) reviewOperationAccess(w http.ResponseWriter, r *http.Request, op *domain.ReviewOperation) bool {
|
|
p, _ := currentPrincipal(r)
|
|
item, e := s.store.GetHumanItem(r.Context(), op.ItemID)
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return false
|
|
}
|
|
role := domain.AnnotationRoleQualityReviewer
|
|
if strings.HasPrefix(op.Kind, "acceptance") {
|
|
role = domain.AnnotationRoleAcceptanceReviewer
|
|
}
|
|
allowed := false
|
|
if p != nil && item != nil {
|
|
allowed = s.canAccessHumanItem(r.Context(), r, *item, role)
|
|
// A previously admitted operation remains recoverable after its claim
|
|
// was cleared by the decision or a later round started. This grants
|
|
// access to this immutable receipt only, never to the new task state.
|
|
if !allowed && role == domain.AnnotationRoleAcceptanceReviewer && op.AcceptanceClaim != nil {
|
|
a := s.acceptanceAccessFor(r.Context(), p.User.ID)
|
|
allowed = a.active && a.err == nil && op.AcceptanceClaim.UserID == p.User.ID && op.AcceptanceClaim.SupplierID == a.user.SupplierID && op.AcceptanceClaim.StageID == op.StageID && op.AcceptanceClaim.Round == op.ReviewRound
|
|
}
|
|
}
|
|
if p == nil || p.User.ID != op.UserID || op.OrganizationID != s.requestOrganizationID(r) || item == nil || item.ProjectID != op.ProjectID || !allowed {
|
|
renderJSON(w, 403, map[string]string{"error": "Review operation access denied"})
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Replay is checked before the current claim: a successful decision intentionally
|
|
// moves the task away from its original reviewer.
|
|
func (s *server) replayReviewDecision(w http.ResponseWriter, r *http.Request, resource string, meta ReviewDecisionInput, input any) bool {
|
|
if strings.TrimSpace(meta.OperationID) == "" {
|
|
return false
|
|
}
|
|
p, _ := currentPrincipal(r)
|
|
if p == nil {
|
|
return false
|
|
}
|
|
op, e := s.store.FindReviewOperation(r.Context(), s.requestOrganizationID(r), p.User.ID, resource, meta.OperationID)
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return true
|
|
}
|
|
if op == nil {
|
|
return false
|
|
}
|
|
if !s.reviewOperationAccess(w, r, op) {
|
|
return true
|
|
}
|
|
_, digest := reviewDecisionDigest(input)
|
|
if digest != op.Digest {
|
|
renderJSON(w, 409, map[string]string{"error": "操作标识已用于另一份决定,请核对原结果", "code": "review_operation_conflict"})
|
|
return true
|
|
}
|
|
if op.Status == "prepared" {
|
|
return false
|
|
}
|
|
if op.Status == "failed_before_effects" {
|
|
renderJSON(w, 409, reviewOperationReceipt(op))
|
|
return true
|
|
}
|
|
s.respondReviewOperation(w, r, op, true)
|
|
return true
|
|
}
|
|
func reviewOperationReceipt(op *domain.ReviewOperation) map[string]any {
|
|
return map[string]any{"operationId": op.OperationID, "itemId": op.ItemID, "stageId": op.StageID, "reviewRound": op.ReviewRound, "resultVersion": op.ResultVersion, "draftVersion": op.DraftVersion, "decision": op.Decision, "status": op.Status, "scope": map[string]any{"sourceItemIds": op.SourceItemIDs}, "completedAt": op.CompletedAt, "error": op.Error, "result": op.Response}
|
|
}
|
|
|
|
// Preparation persists the accepted intent before a write fence is taken. If
|
|
// the process stops before planning effects, reconcile replays only this exact
|
|
// request, with the original page generation and validation rules.
|
|
func (s *server) prepareReviewDecision(w http.ResponseWriter, r *http.Request, item domain.HumanItemRecord, kind string, meta ReviewDecisionInput, input any, decision string) (*http.Request, bool) {
|
|
page := r.Header.Get("X-Review-Page")
|
|
session, e := s.store.GetReviewSession(r.Context(), reviewSessionKey(item))
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return r, false
|
|
}
|
|
if meta.OperationID == "" {
|
|
if s.reviewDecisionProtocol(r.Context(), item) == "receipt" && session != nil && session.Enrolled && session.UserID == func() string {
|
|
p, _ := currentPrincipal(r)
|
|
if p == nil {
|
|
return ""
|
|
}
|
|
return p.User.ID
|
|
}() && session.PageID == page {
|
|
renderValidationError(w, validationIssue{Field: "operationId", Message: "正式决定需要操作标识、草稿版本和审查结果版本"})
|
|
return r, false
|
|
}
|
|
if item.CurrentStageID == domain.FanyuV58StageQualityReview && decision == "approved" && item.ReviewRound > 0 {
|
|
principal, _ := currentPrincipal(r)
|
|
if principal == nil {
|
|
renderJSON(w, 401, map[string]string{"error": "请先登录"})
|
|
return r, false
|
|
}
|
|
draft, err := s.loadCurrentReviewDraft(r.Context(), item, principal.User.ID)
|
|
if err != nil {
|
|
renderError(w, 500, err)
|
|
return r, false
|
|
}
|
|
problems, err := s.qualityRejectionProblems(r.Context(), item, *draft)
|
|
if err != nil {
|
|
renderError(w, 500, err)
|
|
return r, false
|
|
}
|
|
for _, problem := range problems {
|
|
if problem.Scope != "task" {
|
|
renderValidationError(w, validationIssue{Field: "decision", Message: "仍有原退回意见未确认解决,请逐条核对后再通过审核"})
|
|
return r, false
|
|
}
|
|
}
|
|
}
|
|
return r, true
|
|
}
|
|
p, _ := currentPrincipal(r)
|
|
generation, _ := strconv.Atoi(r.Header.Get("X-Review-Generation"))
|
|
if p == nil || session == nil || !session.Enrolled || session.UserID != p.User.ID || session.PageID != page || session.Generation != generation || (session.ExpiresAt <= nowISO() && session.WriteID == "") {
|
|
reviewSessionFailure(w, "review_session_lost")
|
|
return r, false
|
|
}
|
|
if len(meta.OperationID) > 160 || strings.TrimSpace(meta.OperationID) != meta.OperationID || meta.DraftVersion == nil || meta.ResultVersion == "" {
|
|
renderValidationError(w, validationIssue{Field: "operationId", Message: "操作标识、草稿版本和结果版本不能为空"})
|
|
return r, false
|
|
}
|
|
batch, e := s.store.GetHumanBatch(r.Context(), item.BatchID)
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return r, false
|
|
}
|
|
if kind == "quality" && (batch == nil || !batch.RequirePrePackageAcceptance || isFanyuV5FourStageBatch(batch) || item.CurrentStageID != domain.FanyuV58StageQualityReview) {
|
|
renderValidationError(w, validationIssue{Field: "operationId", Message: "当前任务不属于连续审查的质检流程"})
|
|
return r, false
|
|
}
|
|
if kind == "acceptance" {
|
|
_, supported, err := v58AggregateSourceBatch(r.Context(), s, batch)
|
|
if err != nil {
|
|
renderError(w, 500, err)
|
|
return r, false
|
|
}
|
|
if !supported {
|
|
renderValidationError(w, validationIssue{Field: "operationId", Message: "请使用当前审核阶段对应的正式提交入口"})
|
|
return r, false
|
|
}
|
|
}
|
|
draft, e := s.loadCurrentReviewDraft(r.Context(), item, p.User.ID)
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return r, false
|
|
}
|
|
if draft.ResultVersion != meta.ResultVersion || draft.Version != *meta.DraftVersion || session.ResultVersion != meta.ResultVersion {
|
|
renderJSON(w, 409, map[string]string{"code": "review_draft_conflict", "error": "审查结果或草稿已变化,请重新核对"})
|
|
return r, false
|
|
}
|
|
if decision == "approved" && len(draft.Problems) > 0 {
|
|
renderValidationError(w, validationIssue{Field: "decision", Message: "存在已保存的问题,请清除后通过,或选择退回"})
|
|
return r, false
|
|
}
|
|
data, digest := reviewDecisionDigest(input)
|
|
// Already accepted legacy intents retain their original recovery contract.
|
|
existing, err := s.store.GetReviewOperation(r.Context(), reviewOperationID(item, p.User.ID, meta.OperationID))
|
|
if err != nil {
|
|
renderError(w, 500, err)
|
|
return r, false
|
|
}
|
|
if existing == nil && kind == "quality" && decision == "approved" {
|
|
problems, legacy, err := s.qualityRejectionOpinions(r.Context(), item, *draft)
|
|
if err != nil {
|
|
renderError(w, 500, err)
|
|
return r, false
|
|
}
|
|
if len(legacy) > 0 {
|
|
renderValidationError(w, validationIssue{Field: "decision", Message: "仍有验收退回意见未确认解决"})
|
|
return r, false
|
|
}
|
|
for _, problem := range problems {
|
|
if problem.Scope != "task" {
|
|
renderValidationError(w, validationIssue{Field: "decision", Message: "仍有原退回意见未确认解决,请逐条核对后再通过审核"})
|
|
return r, false
|
|
}
|
|
}
|
|
}
|
|
if existing == nil && duplicateReviewOpinions(draft.Problems) {
|
|
renderJSON(w, 409, map[string]string{"code": "review_opinion_confirmation_required", "error": "有同一对象的多条旧意见,请先确认最终意见再提交"})
|
|
return r, false
|
|
}
|
|
if existing == nil && draft.ModelVersion == 2 && decision == "rejected" {
|
|
problems := draft.Problems
|
|
var unlocated []domain.ReviewProblem
|
|
if kind == "quality" {
|
|
problems, unlocated, err = s.qualityRejectionOpinions(r.Context(), item, *draft)
|
|
if err != nil {
|
|
renderError(w, 500, err)
|
|
return r, false
|
|
}
|
|
}
|
|
hasVisibleProblem := len(unlocated) > 0
|
|
for _, problem := range problems {
|
|
if problem.Scope != "task" {
|
|
hasVisibleProblem = true
|
|
break
|
|
}
|
|
}
|
|
if !hasVisibleProblem {
|
|
renderValidationError(w, validationIssue{Field: "comment", Message: "请先填写并保存退回意见,或将原退回意见标记为仍有问题"})
|
|
return r, false
|
|
}
|
|
}
|
|
op := &domain.ReviewOperation{ReviewerSupplierID: p.User.SupplierID, AcceptanceClaim: item.AcceptanceClaim, ID: reviewOperationID(item, p.User.ID, meta.OperationID), OperationID: meta.OperationID, OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, UserID: p.User.ID, ItemID: item.ID, TaskID: item.LegacyTaskID, StageID: item.CurrentStageID, ReviewRound: item.ReviewRound, ResultVersion: meta.ResultVersion, DraftVersion: *meta.DraftVersion, Draft: *draft, Kind: kind, Decision: decision, Input: data, Digest: digest, SessionKey: reviewSessionKey(item), PageID: page, Generation: generation, Status: "prepared", CreatedAt: nowISO(), SourceItemIDs: []string{item.ID}}
|
|
if session.WriteID != "" && session.WriteID != op.ID {
|
|
reviewSessionFailure(w, "review_write_in_progress")
|
|
return r, false
|
|
}
|
|
saved, e := s.store.CompareAndSwapReviewOperation(r.Context(), *op, 0)
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return r, false
|
|
}
|
|
if !saved {
|
|
current, e := s.store.GetReviewOperation(r.Context(), op.ID)
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return r, false
|
|
}
|
|
if current == nil || current.UserID != op.UserID || current.OperationID != op.OperationID || current.Digest != digest {
|
|
renderJSON(w, 409, map[string]string{"code": "review_operation_conflict", "error": "本轮审查已有正式操作,请先核对该操作"})
|
|
return r, false
|
|
}
|
|
if current.Status != "prepared" {
|
|
s.respondReviewOperation(w, r, current, true)
|
|
return r, false
|
|
}
|
|
op = current
|
|
} else {
|
|
op.Revision = 1
|
|
}
|
|
return r.WithContext(context.WithValue(r.Context(), reviewOperationContextKey{}, op)), true
|
|
}
|
|
|
|
// Validation failures have no effects. A process crash does not run this defer,
|
|
// leaving the prepared request available to its explicit reconciliation route.
|
|
func (s *server) finishReviewDecisionPreparation(r *http.Request) {
|
|
op := operationFromRequest(r)
|
|
if op == nil {
|
|
return
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
current, e := s.store.GetReviewOperation(ctx, op.ID)
|
|
if e != nil || current == nil || current.Status != "prepared" {
|
|
return
|
|
}
|
|
if strings.HasSuffix(current.Kind, "_draft") {
|
|
s.cancelDraftReviewOperation(ctx, current)
|
|
return
|
|
}
|
|
current.Status = "failed_before_effects"
|
|
current.Error = "提交前校验未通过;草稿已保留,请修正后重新确认"
|
|
_, _ = s.store.CompareAndSwapReviewOperation(ctx, *current, current.Revision)
|
|
s.finishReviewWrite(op.SessionKey, op.ID)
|
|
}
|
|
func compactReviewResponse(response any) any {
|
|
switch value := response.(type) {
|
|
case domain.HumanItemRecord:
|
|
value.Subject = domain.HumanSubjectRef{ItemKey: value.Subject.ItemKey, ArtifactID: value.Subject.ArtifactID, MediaType: value.Subject.MediaType}
|
|
return value
|
|
case map[string]any:
|
|
copy := make(map[string]any, len(value))
|
|
for key, entry := range value {
|
|
copy[key] = compactReviewResponse(entry)
|
|
}
|
|
return copy
|
|
default:
|
|
return response
|
|
}
|
|
}
|
|
|
|
func (s *server) commitReviewPlan(w http.ResponseWriter, r *http.Request, effects []domain.ReviewDecisionEffect, sources []string, httpStatus int, response any) {
|
|
op := operationFromRequest(r)
|
|
if op == nil {
|
|
renderError(w, 500, fmt.Errorf("review operation missing"))
|
|
return
|
|
}
|
|
// BeforeItem is only a concurrency/recovery fence. Keep the full next Item
|
|
// once for compatibility with older in-flight recovery handlers, not three
|
|
// times in before/after/response. Never prune the source task's evidence.
|
|
for i := range effects {
|
|
if before := effects[i].BeforeItem; before != nil {
|
|
effects[i].BeforeItem = &domain.HumanItemRecord{ID: before.ID, Version: before.Version, ReviewOperationID: before.ReviewOperationID}
|
|
}
|
|
}
|
|
op.Effects = effects
|
|
op.SourceItemIDs = sources
|
|
op.HTTPStatus = httpStatus
|
|
op.Response, _ = json.Marshal(compactReviewResponse(response))
|
|
op.Status = "applying"
|
|
encoded, encodeErr := bson.Marshal(op)
|
|
if encodeErr != nil || len(encoded) > 15*1024*1024 {
|
|
s.failReviewPlan(r, op.ID, "审核提交记录过大,尚未产生正式变更;草稿已保留,请联系管理员处理。")
|
|
renderJSON(w, http.StatusUnprocessableEntity, map[string]string{"code": "review_operation_too_large", "error": "审核提交记录过大,草稿已保留,请联系管理员处理。"})
|
|
return
|
|
}
|
|
saved, e := s.store.CompareAndSwapReviewOperation(r.Context(), *op, op.Revision)
|
|
if e != nil {
|
|
s.failReviewPlan(r, op.ID, "审核提交记录保存失败,尚未产生正式变更;草稿已保留,请稍后重试或联系管理员。")
|
|
renderError(w, 500, e)
|
|
return
|
|
}
|
|
if !saved {
|
|
op, e = s.store.GetReviewOperation(r.Context(), op.ID)
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return
|
|
}
|
|
} else {
|
|
op.Revision++
|
|
}
|
|
s.respondReviewOperation(w, r, op, true)
|
|
}
|
|
|
|
func (s *server) failReviewPlan(r *http.Request, id, message string) {
|
|
ctx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), 10*time.Second)
|
|
defer cancel()
|
|
current, err := s.store.GetReviewOperation(ctx, id)
|
|
if err != nil || current == nil || current.Status != "prepared" {
|
|
return
|
|
}
|
|
current.Status, current.Error = "failed_before_effects", message
|
|
_, _ = s.store.CompareAndSwapReviewOperation(ctx, *current, current.Revision)
|
|
}
|
|
func (s *server) respondReviewOperation(w http.ResponseWriter, r *http.Request, op *domain.ReviewOperation, run bool) {
|
|
if run && op.Status == "applying" {
|
|
op = s.runReviewOperation(r.Context(), op)
|
|
}
|
|
if op.Status == "completed" {
|
|
s.finishReviewWrite(op.SessionKey, op.ID)
|
|
w.Header().Set("X-Review-Operation", op.OperationID)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(op.HTTPStatus)
|
|
_, _ = w.Write(append(append([]byte(nil), op.Response...), '\n'))
|
|
return
|
|
}
|
|
if op.Status == "failed_before_effects" {
|
|
renderJSON(w, http.StatusConflict, reviewOperationReceipt(op))
|
|
return
|
|
}
|
|
if strings.HasSuffix(op.Kind, "_draft") {
|
|
renderJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "草稿保存结果正在核对,请重试原保存操作或重新进入审查", "code": "review_draft_reconcile_required", "operationId": op.OperationID})
|
|
return
|
|
}
|
|
renderJSON(w, http.StatusAccepted, reviewOperationReceipt(op))
|
|
}
|
|
func (s *server) runReviewOperation(ctx context.Context, op *domain.ReviewOperation) *domain.ReviewOperation {
|
|
for op.Status == "applying" {
|
|
if op.Step >= len(op.Effects) {
|
|
op.Status = "completed"
|
|
op.CompletedAt = nowISO()
|
|
op.Error = ""
|
|
} else {
|
|
e := s.applyReviewEffect(ctx, op, op.Effects[op.Step])
|
|
if e != nil {
|
|
latest, readErr := s.store.GetReviewOperation(context.WithoutCancel(ctx), op.ID)
|
|
if readErr == nil && latest != nil && (latest.Status == "completed" || latest.Status == "failed_before_effects") {
|
|
return latest
|
|
}
|
|
if errors.Is(e, errDraftIntentStale) {
|
|
op.Status = "failed_before_effects"
|
|
}
|
|
op.Error = e.Error()
|
|
_, _ = s.store.CompareAndSwapReviewOperation(context.WithoutCancel(ctx), *op, op.Revision)
|
|
return op
|
|
}
|
|
op.Step++
|
|
op.Error = ""
|
|
}
|
|
saved, e := s.store.CompareAndSwapReviewOperation(ctx, *op, op.Revision)
|
|
if e != nil {
|
|
op.Status = "applying"
|
|
op.Error = e.Error()
|
|
return op
|
|
}
|
|
if saved {
|
|
op.Revision++
|
|
} else {
|
|
current, e := s.store.GetReviewOperation(ctx, op.ID)
|
|
if e != nil || current == nil {
|
|
op.Status = "applying"
|
|
op.Error = "无法核对正式操作,请稍后重试"
|
|
return op
|
|
}
|
|
op = current
|
|
}
|
|
}
|
|
return op
|
|
}
|
|
func (s *server) applyReviewEffect(ctx context.Context, op *domain.ReviewOperation, e domain.ReviewDecisionEffect) error {
|
|
switch {
|
|
case e.Draft != nil:
|
|
return s.applyDraftReviewOperation(ctx, op, *e.Draft)
|
|
case e.ReworkBaseline != nil:
|
|
existing, err := s.store.GetReworkBaseline(ctx, e.ReworkBaseline.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if existing != nil {
|
|
return nil
|
|
}
|
|
return s.store.UpsertReworkBaseline(ctx, *e.ReworkBaseline)
|
|
case e.Review != nil:
|
|
existing, err := s.store.ListAnnotationReviews(ctx, e.Review.OrganizationID, e.Review.TaskID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, previous := range existing {
|
|
if previous.ID == e.Review.ID {
|
|
return nil
|
|
}
|
|
}
|
|
return s.store.UpsertAnnotationReview(ctx, *e.Review)
|
|
case e.Task != nil:
|
|
current, err := s.store.GetAnnotationTask(ctx, e.Task.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if current != nil {
|
|
applied, err := s.reviewEffectApplied(ctx, current.ReviewOperationID, op.ID, e.Task.ID, true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if applied {
|
|
return nil
|
|
}
|
|
}
|
|
ok, err := s.store.UpdateAnnotationTaskForReview(ctx, *e.BeforeTask, *e.Task)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !ok {
|
|
return fmt.Errorf("审查任务状态已变化,需核对 %s", e.Task.ID)
|
|
}
|
|
return nil
|
|
case e.Item != nil:
|
|
current, err := s.store.GetHumanItem(ctx, e.Item.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if current != nil {
|
|
applied, err := s.reviewEffectApplied(ctx, current.ReviewOperationID, op.ID, e.Item.ID, false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if applied {
|
|
return nil
|
|
}
|
|
}
|
|
ok, err := s.store.UpdateHumanItemForReview(ctx, *e.Item, e.BeforeItem.Version)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !ok {
|
|
return fmt.Errorf("审查对象版本已变化,需核对 %s", e.Item.ID)
|
|
}
|
|
return nil
|
|
case e.Attempt != nil:
|
|
current, err := s.store.GetHumanItem(ctx, e.Attempt.ItemID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if current != nil {
|
|
applied, err := s.reviewEffectApplied(ctx, current.ReviewOperationID, op.ID, current.ID, false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if applied {
|
|
return nil
|
|
}
|
|
}
|
|
attempt := *e.Attempt
|
|
existing, err := s.store.ListHumanStageAttempts(ctx, attempt.OrganizationID, attempt.ItemID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, previous := range existing {
|
|
if previous.StageID == attempt.StageID && previous.Round == attempt.Round {
|
|
attempt.ID = previous.ID
|
|
attempt.CreatedAt = previous.CreatedAt
|
|
attempt.Version = previous.Version
|
|
break
|
|
}
|
|
}
|
|
return s.store.UpsertHumanStageAttempt(ctx, attempt)
|
|
case e.Reject != nil:
|
|
previous, err := s.store.GetHumanReject(ctx, e.Reject.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if previous != nil {
|
|
return nil
|
|
}
|
|
return s.store.UpsertHumanReject(ctx, *e.Reject)
|
|
case e.Event != nil:
|
|
events, err := s.store.ListHumanEvents(ctx, e.Event.OrganizationID, e.Event.ItemID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, v := range events {
|
|
if v.ID == e.Event.ID {
|
|
return nil
|
|
}
|
|
}
|
|
err = s.store.AppendHumanEvent(ctx, *e.Event)
|
|
if mongo.IsDuplicateKeyError(err) {
|
|
return nil
|
|
}
|
|
return err
|
|
case e.Worklog != nil:
|
|
return s.store.UpsertAnnotationWorklogEvent(ctx, *e.Worklog)
|
|
case e.Batch != nil:
|
|
root, err := s.store.GetHumanItem(ctx, op.ItemID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if root != nil {
|
|
applied, err := s.reviewEffectApplied(ctx, root.ReviewOperationID, op.ID, root.ID, false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if applied {
|
|
return nil
|
|
}
|
|
}
|
|
current, err := s.store.GetHumanBatch(ctx, e.Batch.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if current == nil {
|
|
return fmt.Errorf("审查批次不存在")
|
|
}
|
|
current.Status = e.Batch.Status
|
|
current.AcceptedCount = e.Batch.AcceptedCount
|
|
return s.store.UpsertHumanBatch(ctx, *current)
|
|
case e.FlushBatchID != "":
|
|
batch, err := s.store.GetHumanBatch(ctx, e.FlushBatchID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if batch == nil {
|
|
return fmt.Errorf("审查批次不存在")
|
|
}
|
|
return s.flushHumanReleasePartitions(ctx, batch, e.FlushForce)
|
|
}
|
|
return nil
|
|
}
|
|
func (s *server) handleReviewOperation(w http.ResponseWriter, r *http.Request) {
|
|
p, _ := currentPrincipal(r)
|
|
if p == nil {
|
|
renderJSON(w, 401, map[string]string{"error": "Authentication required"})
|
|
return
|
|
}
|
|
op, e := s.store.FindReviewOperation(r.Context(), s.requestOrganizationID(r), p.User.ID, chi.URLParam(r, "id"), chi.URLParam(r, "operationId"))
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return
|
|
}
|
|
if op == nil {
|
|
renderJSON(w, 404, map[string]string{"error": "Review operation not found"})
|
|
return
|
|
}
|
|
if !s.reviewOperationAccess(w, r, op) {
|
|
return
|
|
}
|
|
if r.Method == http.MethodGet {
|
|
renderJSON(w, 200, reviewOperationReceipt(op))
|
|
return
|
|
}
|
|
if strings.HasSuffix(op.Kind, "_draft") {
|
|
item, err := s.store.GetHumanItem(r.Context(), op.ItemID)
|
|
if err != nil {
|
|
renderError(w, 500, err)
|
|
return
|
|
}
|
|
op = s.recoverDraftReviewOperation(r.Context(), op, item)
|
|
s.respondReviewOperation(w, r, op, false)
|
|
return
|
|
}
|
|
if op.Status == "prepared" {
|
|
replay := r.Clone(r.Context())
|
|
replay.Method = http.MethodPost
|
|
replay.Body = io.NopCloser(bytes.NewReader(op.Input))
|
|
replay.Header = r.Header.Clone()
|
|
replay.Header.Set("X-Review-Page", op.PageID)
|
|
replay.Header.Set("X-Review-Generation", strconv.Itoa(op.Generation))
|
|
route := chi.NewRouteContext()
|
|
id := op.ItemID
|
|
if op.Kind == "quality" {
|
|
id = op.TaskID
|
|
}
|
|
route.URLParams.Add("id", id)
|
|
replay = replay.WithContext(context.WithValue(replay.Context(), chi.RouteCtxKey, route))
|
|
if op.Kind == "quality" {
|
|
s.handleAnnotationReviewCreate(w, replay)
|
|
} else {
|
|
s.handleHumanItemDecision(w, replay)
|
|
}
|
|
return
|
|
}
|
|
if op.Status == "failed_before_effects" {
|
|
renderJSON(w, 409, reviewOperationReceipt(op))
|
|
return
|
|
}
|
|
s.respondReviewOperation(w, r, op, true)
|
|
}
|
|
|
|
// A later round can already be under review when reconciliation catches up.
|
|
// Follow immutable before-markers to prove the old effect happened, rather than
|
|
// writing its old target over newer work or permanently treating it as a conflict.
|
|
func (s *server) reviewEffectApplied(ctx context.Context, marker, wanted, resource string, task bool) (bool, error) {
|
|
seen := map[string]bool{}
|
|
for marker != "" && !seen[marker] {
|
|
if marker == wanted {
|
|
return true, nil
|
|
}
|
|
seen[marker] = true
|
|
next, err := s.store.GetReviewOperation(ctx, marker)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if next == nil {
|
|
return false, nil
|
|
}
|
|
previous := ""
|
|
for _, effect := range next.Effects {
|
|
if task && effect.BeforeTask != nil && effect.BeforeTask.ID == resource {
|
|
previous = effect.BeforeTask.ReviewOperationID
|
|
break
|
|
}
|
|
if !task && effect.BeforeItem != nil && effect.BeforeItem.ID == resource {
|
|
previous = effect.BeforeItem.ReviewOperationID
|
|
break
|
|
}
|
|
}
|
|
marker = previous
|
|
}
|
|
return false, nil
|
|
}
|