droboticflow/internal/api/review_decision.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
}