forked from longtao.wu/droboticflow
328 lines
10 KiB
Go
328 lines
10 KiB
Go
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)
|
||
}
|