droboticflow/internal/api/review_draft.go

328 lines
10 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"
"fmt"
"math"
"net/http"
"strings"
)
func reviewDraftKey(item domain.HumanItemRecord, userID, resultVersion string) string {
encoded, _ := json.Marshal([]any{item.OrganizationID, item.ProjectID, userID, item.ID, item.CurrentStageID, item.ReviewRound, resultVersion})
return fmt.Sprintf("%x", sha256.Sum256(encoded))
}
// loadCurrentReviewDraft is also the formal-decision seam: draft version is
// independent from both the reviewed result and page-control generations.
func (server *server) loadCurrentReviewDraft(ctx context.Context, item domain.HumanItemRecord, userID string) (*domain.ReviewDraft, error) {
resultVersion, e := server.reviewResultVersion(ctx, item)
if e != nil {
return nil, e
}
key := reviewDraftKey(item, userID, resultVersion)
draft, e := server.store.GetReviewDraft(ctx, key)
if e != nil {
return nil, e
}
if draft == nil {
draft = &domain.ReviewDraft{ID: key, OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, UserID: userID, ItemID: item.ID, StageID: item.CurrentStageID, ReviewRound: item.ReviewRound, ResultVersion: resultVersion, Problems: []domain.ReviewProblem{}}
}
return draft, nil
}
type reviewTargetEvidence struct {
sourceID string
slices []domain.SliceSegment
actions []domain.AnnotationSegment
local bool
}
func (server *server) reviewTargetEvidenceForItem(ctx context.Context, item domain.HumanItemRecord) ([]reviewTargetEvidence, error) {
if item.CurrentStageID == "prepackage_acceptance" {
var entries []struct {
SourceItemID string `json:"sourceHumanItemId"`
Slices []domain.SliceSegment `json:"finalSlices"`
Actions []domain.AnnotationSegment `json:"annotation"`
}
encoded, err := json.Marshal(item.Subject.Payload["items"])
if err != nil {
return nil, err
}
if err := json.Unmarshal(encoded, &entries); err != nil {
return nil, err
}
out := make([]reviewTargetEvidence, 0, len(entries))
for _, entry := range entries {
out = append(out, reviewTargetEvidence{sourceID: entry.SourceItemID, slices: entry.Slices, actions: entry.Actions, local: true})
}
return out, nil
}
if item.LegacyTaskID == "" {
return nil, fmt.Errorf("review evidence unavailable")
}
slices, e := server.store.ListSliceRevisions(ctx, item.OrganizationID, item.LegacyTaskID)
if e != nil {
return nil, e
}
actions, e := server.store.ListAnnotationRevisions(ctx, item.OrganizationID, item.LegacyTaskID)
if e != nil {
return nil, e
}
evidence := reviewTargetEvidence{}
for _, revision := range slices {
if revision.Revision == item.CurrentRevision {
evidence.slices = revision.Segments
}
}
if len(evidence.slices) == 0 && len(slices) > 0 {
evidence.slices = slices[len(slices)-1].Segments
}
for _, revision := range actions {
if revision.Revision == item.CurrentRevision {
evidence.actions = revision.Segments
}
}
return []reviewTargetEvidence{evidence}, nil
}
func canonicalReviewViewAnchor(anchor domain.ReviewViewAnchor, evidence []reviewTargetEvidence) (*domain.ReviewViewAnchor, error) {
anchor.SourceItemID = strings.TrimSpace(anchor.SourceItemID)
anchor.SliceID = strings.TrimSpace(anchor.SliceID)
if anchor.SliceID == "" {
return nil, fmt.Errorf("问题画面锚点须包含切片")
}
if math.IsNaN(anchor.AtSeconds) || math.IsInf(anchor.AtSeconds, 0) {
return nil, fmt.Errorf("问题画面时间不合法")
}
switch anchor.TimeBasis {
case "capture-seconds", "slice-seconds":
default:
return nil, fmt.Errorf("问题画面时间基准须为 capture-seconds 或 slice-seconds")
}
var source *reviewTargetEvidence
for i := range evidence {
if evidence[i].sourceID == anchor.SourceItemID {
if source != nil {
return nil, fmt.Errorf("画面来源身份不唯一")
}
source = &evidence[i]
}
}
if source == nil {
return nil, fmt.Errorf("问题画面来源不属于当前被审结果")
}
var slice *domain.SliceSegment
for i := range source.slices {
if source.slices[i].ID == anchor.SliceID {
if slice != nil {
return nil, fmt.Errorf("画面切片身份不唯一")
}
slice = &source.slices[i]
}
}
if slice == nil {
return nil, fmt.Errorf("问题画面切片不属于当前被审结果")
}
// Canonical basis follows the current evidence, mirroring problem spans:
// quality reviews recall capture seconds, aggregate members recall
// slice-relative seconds. Discarded slices stay valid viewing bookmarks.
at := anchor.AtSeconds
basis := "capture-seconds"
windowStart, windowEnd := slice.Start, slice.End
if source.local {
basis = "slice-seconds"
windowStart, windowEnd = 0, slice.End-slice.Start
if anchor.TimeBasis == "capture-seconds" {
at = anchor.AtSeconds - slice.Start
}
} else if anchor.TimeBasis == "slice-seconds" {
at = anchor.AtSeconds + slice.Start
}
if at < windowStart || at >= windowEnd {
at = windowStart
}
anchor.AtSeconds = at
anchor.TimeBasis = basis
return &anchor, nil
}
func canonicalReviewProblems(problems []domain.ReviewProblem, evidence []reviewTargetEvidence) ([]domain.ReviewProblem, error) {
if len(problems) > 2000 {
return nil, fmt.Errorf("问题记录过多,请分次核对")
}
ids := map[string]bool{}
out := make([]domain.ReviewProblem, 0, len(problems))
for _, p := range problems {
p.Origin = nil // Provenance is assigned only from frozen server records.
p.ID = strings.TrimSpace(p.ID)
p.Text = strings.TrimSpace(p.Text)
if p.ID == "" || len(p.ID) > 200 || ids[p.ID] || p.Text == "" || len([]rune(p.Text)) > 10000 {
return nil, fmt.Errorf("问题身份须唯一,说明须为 1–10000 字")
}
ids[p.ID] = true
if math.IsNaN(p.AtSeconds) || math.IsInf(p.AtSeconds, 0) {
return nil, fmt.Errorf("问题时间不合法")
}
if p.Scope == "task" {
p.SourceItemID = ""
p.SliceID = ""
p.ActionID = ""
p.Start = 0
p.End = 0
p.AtSeconds = 0
p.TimeBasis = "task"
} else {
// 时间点意见依赖调用方声明的输入时间基准;先留存,下方共享分支会改写规范基准。
inputTimeBasis := p.TimeBasis
var source *reviewTargetEvidence
for i := range evidence {
if evidence[i].sourceID == p.SourceItemID {
if source != nil {
return nil, fmt.Errorf("来源身份不唯一")
}
source = &evidence[i]
}
}
if source == nil {
return nil, fmt.Errorf("问题来源不属于当前被审结果")
}
var slice *domain.SliceSegment
for i := range source.slices {
if source.slices[i].ID == p.SliceID {
if slice != nil {
return nil, fmt.Errorf("切片身份不唯一")
}
slice = &source.slices[i]
}
}
if slice == nil {
return nil, fmt.Errorf("问题切片不属于当前被审结果")
}
p.Start = slice.Start
p.End = slice.End
p.TimeBasis = "capture-seconds"
if source.local {
p.Start = 0
p.End = slice.End - slice.Start
p.TimeBasis = "slice-seconds"
}
switch p.Scope {
case "slice":
p.ActionID = ""
case "timestamp":
// D5 时间点意见:身份 = 来源 + 规范帧(不随切片边界漂移)。
// 点没有持续时长(Start=End),不吸附越界点,不落舍弃片段。
p.ActionID = ""
if slice.IsDiscarded() {
return nil, fmt.Errorf("时间点意见不能落在舍弃片段上,请选择保留片段的画面")
}
switch inputTimeBasis {
case "capture-seconds", "slice-seconds":
default:
return nil, fmt.Errorf("时间点意见须声明 capture-seconds 或 slice-seconds 时间基准")
}
at := p.AtSeconds
if source.local {
if inputTimeBasis == "capture-seconds" {
at = p.AtSeconds - slice.Start
}
} else if inputTimeBasis == "slice-seconds" {
at = p.AtSeconds + slice.Start
}
const timestampEpsilon = 0.000001
if at < p.Start-timestampEpsilon || at >= p.End-timestampEpsilon {
return nil, fmt.Errorf("时间点超出所选切片范围,请重新定位后保存")
}
p.AtSeconds = at
p.Start, p.End = at, at
case "action":
if slice.IsDiscarded() {
return nil, fmt.Errorf("舍弃切片请记录切片问题")
}
var action *domain.AnnotationSegment
for i := range source.actions {
a := &source.actions[i]
if a.ID == p.ActionID && a.Start >= slice.Start-0.000001 && a.End <= slice.End+0.000001 {
if action != nil {
return nil, fmt.Errorf("动作身份不唯一")
}
action = a
}
}
if action == nil {
return nil, fmt.Errorf("问题动作不属于所选切片")
}
p.Start = action.Start
p.End = action.End
if source.local {
p.Start -= slice.Start
p.End -= slice.Start
}
default:
return nil, fmt.Errorf("问题范围须为动作、切片或时间点")
}
if p.AtSeconds < p.Start || p.AtSeconds >= p.End {
p.AtSeconds = p.Start
}
}
// The viewing anchor is optional for every scope and independent of the
// problem target; a missing anchor stays missing (no invented frame).
if p.ViewAnchor != nil {
anchor, e := canonicalReviewViewAnchor(*p.ViewAnchor, evidence)
if e != nil {
return nil, e
}
p.ViewAnchor = anchor
}
// Preserve legacy order and canonical evidence here; the write contract
// separately enforces one effective opinion per target.
out = append(out, p)
}
return out, nil
}
func (server *server) handleReviewDraft(w http.ResponseWriter, r *http.Request) {
item, ok := server.loadReviewItemForRequest(w, r)
if !ok {
return
}
principal, _ := currentPrincipal(r)
draft, e := server.loadCurrentReviewDraft(r.Context(), *item, principal.User.ID)
if e != nil {
renderError(w, 500, e)
return
}
if r.Method == http.MethodGet && r.URL.Query().Get("history") == "1" {
history, err := server.store.GetReviewDraftArchive(r.Context(), draft.LegacyBackupID)
if err != nil {
renderError(w, 500, err)
return
}
problems := []domain.ReviewProblem{}
if history != nil {
problems = history.Problems
}
renderJSON(w, 200, map[string]any{"problems": problems})
return
}
if r.Method == http.MethodGet {
renderJSON(w, 200, map[string]any{"draft": draft})
return
}
var input reviewDraftSaveInput
if !decodeJSON(w, r, &input) {
return
}
if input.ResultVersion != draft.ResultVersion {
reviewSessionFailure(w, "review_context_changed")
return
}
if strings.TrimSpace(input.OperationID) == "" || len(input.OperationID) > 200 || input.Version < 0 {
renderValidationError(w, validationIssue{Field: "operationId", Message: "valid operationId and version are required"})
return
}
server.saveRecoverableReviewDraft(w, r, *item, *draft, input)
}