710 lines
28 KiB
Go
710 lines
28 KiB
Go
package api
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"math"
|
||
"net/http"
|
||
"reflect"
|
||
stdslices "slices"
|
||
"strings"
|
||
|
||
"droboticflow/internal/domain"
|
||
"github.com/go-chi/chi/v5"
|
||
)
|
||
|
||
func sliceDisposition(s domain.SliceSegment) string {
|
||
if s.DeliveryDisposition == "" {
|
||
return "keep"
|
||
}
|
||
return s.DeliveryDisposition
|
||
}
|
||
|
||
func allSlicesDiscarded(slices []domain.SliceSegment, segments []domain.AnnotationSegment) bool {
|
||
if len(slices) == 0 || len(segments) > 0 {
|
||
return false
|
||
}
|
||
for _, s := range slices {
|
||
if !s.IsDiscarded() {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// Disposition changes require an explicit action or a verified cancel-cut.
|
||
// Ordinary description saves cannot silently drop policy or forge audit identity.
|
||
func (s *server) canonicalSliceDispositions(ctx context.Context, item *domain.HumanItemRecord, slices []domain.SliceSegment, operations ...[]domain.SliceOperation) ([]domain.SliceSegment, []validationIssue) {
|
||
next, issues := s.canonicalSliceDispositionState(ctx, item, slices, operations...)
|
||
if len(issues) == 0 {
|
||
issues = s.validateProjectSliceNames(ctx, item, next, "draft")
|
||
}
|
||
return next, issues
|
||
}
|
||
|
||
func (s *server) canonicalSliceDispositionState(ctx context.Context, item *domain.HumanItemRecord, slices []domain.SliceSegment, operations ...[]domain.SliceOperation) ([]domain.SliceSegment, []validationIssue) {
|
||
previous := decodeMaterializationValue[domain.SliceSegment](annotationWorkspacePayload(item)["sliceSegments"])
|
||
if len(previous) == 0 && item.LegacyTaskID != "" {
|
||
revisions, err := s.store.ListSliceRevisions(ctx, item.OrganizationID, item.LegacyTaskID)
|
||
if err != nil {
|
||
return nil, []validationIssue{annotationReadValidationIssue("sliceSegments", "无法读取已保存的切片用途", err)}
|
||
}
|
||
for _, r := range revisions {
|
||
if r.Revision == item.CurrentRevision || len(previous) == 0 {
|
||
previous = r.Segments
|
||
}
|
||
}
|
||
}
|
||
trustedPrevious := previousForSliceMergeUndo(item, previous, slices)
|
||
var localMerges []sliceMergeEvidence
|
||
phase := stringValue(mapValue(item.Subject.Payload["sliceWorkflow"])["phase"])
|
||
if len(operations) > 0 && (phase == "slice" || phase == "") {
|
||
if replayed, merges := replayLocalSliceMerges(trustedPrevious, slices, operations[0]); replayed != nil {
|
||
trustedPrevious, localMerges = replayed, merges
|
||
}
|
||
}
|
||
next, issues := canonicalDispositions(trustedPrevious, slices)
|
||
applySliceArchiveEdits(next, currentSliceArchiveEdits(item))
|
||
// In-place structure editing is unlocked in every annotate pass (spec
|
||
// §3.4): first-pass and rework share this one path. Boundary moves and
|
||
// merges of discarded evidence stay explicit operations, and the
|
||
// submit-time containment and status-whitelist validations are the
|
||
// bottom line that keeps every action inside exactly one slice.
|
||
if len(issues) == 0 {
|
||
recordSliceMerges(item, trustedPrevious, next, localMerges...)
|
||
}
|
||
return next, issues
|
||
}
|
||
|
||
func canonicalDispositions(previous, slices []domain.SliceSegment) ([]domain.SliceSegment, []validationIssue) {
|
||
old := map[string]domain.SliceSegment{}
|
||
proposed := map[string]domain.SliceSegment{}
|
||
for _, p := range previous {
|
||
if _, duplicate := old[p.ID]; duplicate {
|
||
return nil, []validationIssue{{Field: "sliceSegments", Message: "已保存的切片 ID 重复"}}
|
||
}
|
||
old[p.ID] = p
|
||
}
|
||
for _, candidate := range slices {
|
||
if _, duplicate := proposed[candidate.ID]; duplicate {
|
||
return nil, []validationIssue{{Field: "sliceSegments", Message: "切片 ID 必须唯一"}}
|
||
}
|
||
proposed[candidate.ID] = candidate
|
||
}
|
||
next := append([]domain.SliceSegment(nil), slices...)
|
||
seen := map[string]bool{}
|
||
issues := []validationIssue{}
|
||
mergedSources := map[string]bool{}
|
||
for i, c := range next {
|
||
if sources := explicitSliceMerge(previous, c); len(sources) > 0 {
|
||
next[i] = clearedMergedSlice(c)
|
||
for _, source := range sources {
|
||
mergedSources[source.ID] = true
|
||
}
|
||
seen[c.ID] = true
|
||
continue
|
||
}
|
||
p, exists := old[c.ID]
|
||
inherited := false
|
||
if !exists && c.IsDiscarded() {
|
||
// Source IDs are flattened by repeated local cuts. Resolve only against
|
||
// this task's saved slices; never trust client-supplied audit fields.
|
||
for _, sourceID := range c.SourceIDs {
|
||
if source, ok := old[sourceID]; ok {
|
||
p, exists, inherited = source, true, true
|
||
break
|
||
}
|
||
}
|
||
}
|
||
seen[c.ID] = true
|
||
if sliceDisposition(c) != "keep" && sliceDisposition(c) != "discard" {
|
||
issues = append(issues, validationIssue{Field: fmt.Sprintf("sliceSegments.%d.deliveryDisposition", i), Message: "切片用途必须为 keep 或 discard"})
|
||
continue
|
||
}
|
||
if (!exists && c.IsDiscarded()) || (exists && (sliceDisposition(p) != sliceDisposition(c) || p.DiscardReason != c.DiscardReason)) {
|
||
issues = append(issues, validationIssue{Field: fmt.Sprintf("sliceSegments.%d.deliveryDisposition", i), Code: "explicit_disposition_required", Message: "请通过舍弃/恢复操作保存切片用途"})
|
||
}
|
||
if exists {
|
||
next[i].SourceIDs = append([]string(nil), p.SourceIDs...)
|
||
if inherited {
|
||
next[i].SourceIDs = append([]string{p.ID}, next[i].SourceIDs...)
|
||
// Preserve intermediate parents from several cuts in one unsaved
|
||
// edit, so a later undo can rejoin exactly those siblings.
|
||
for _, sourceID := range c.SourceIDs {
|
||
ancestor, ok := proposed[sourceID]
|
||
if ok && sourceID != c.ID && ancestor.IsDiscarded() && ancestor.DiscardReason == p.DiscardReason &&
|
||
stdslices.Contains(ancestor.SourceIDs, p.ID) && !stdslices.Contains(next[i].SourceIDs, sourceID) {
|
||
next[i].SourceIDs = append(next[i].SourceIDs, sourceID)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
next[i].DiscardReasonLabelID = p.DiscardReasonLabelID
|
||
next[i].DiscardReasonVersion = p.DiscardReasonVersion
|
||
next[i].DiscardReasonName = p.DiscardReasonName
|
||
next[i].DiscardReasonDictionary = p.DiscardReasonDictionary
|
||
next[i].DiscardReasonNote = p.DiscardReasonNote
|
||
next[i].DiscardedByUserID = p.DiscardedByUserID
|
||
next[i].DiscardedAt = p.DiscardedAt
|
||
next[i].DiscardedAnnotations = append([]domain.AnnotationSegment(nil), p.DiscardedAnnotations...)
|
||
if next[i].IsDiscarded() {
|
||
next[i].Name, next[i].TaskLabelID, next[i].TaskLabel = "", "", ""
|
||
}
|
||
}
|
||
for _, p := range previous {
|
||
if p.IsDiscarded() && !seen[p.ID] && !mergedSources[p.ID] {
|
||
// Undoing a split can reunite a child with its original discarded
|
||
// parent, but cannot silently absorb it into a kept/differently judged slice.
|
||
rejoined := false
|
||
for i, candidate := range next {
|
||
if candidate.IsDiscarded() && stdslices.Contains(p.SourceIDs, candidate.ID) &&
|
||
candidate.Start <= p.Start && candidate.End >= p.End &&
|
||
candidate.DiscardReason == p.DiscardReason &&
|
||
candidate.DiscardReasonLabelID == p.DiscardReasonLabelID &&
|
||
candidate.DiscardReasonVersion == p.DiscardReasonVersion {
|
||
// The child may have been restored and edited since the split.
|
||
// Its current archive owns its interval, even when a parent still
|
||
// retains an older, wider original for boundary undo.
|
||
childEvidence := restoredDiscardAnnotations(p)
|
||
parentWindow := candidate
|
||
parentWindow.Start, parentWindow.End = p.Start, p.End
|
||
if !sameArchiveContent(restoredDiscardAnnotations(parentWindow), childEvidence) {
|
||
next[i].DiscardedAnnotations = append(archiveOutsideIntervals(candidate.DiscardedAnnotations, candidate.ID, p), childEvidence...)
|
||
}
|
||
rejoined = true
|
||
break
|
||
}
|
||
}
|
||
if !rejoined {
|
||
issues = append(issues, validationIssue{Field: "sliceSegments", Message: "不能直接删除或合并舍弃片段,请先恢复"})
|
||
}
|
||
}
|
||
}
|
||
return next, issues
|
||
}
|
||
|
||
// Server-owned recovery evidence is separate from the public discard archive:
|
||
// a kept slice has no discarded annotations. Workspace snapshot writes must not
|
||
// replace this payload field with client evidence. One entry per slice bounds
|
||
// storage, and revision/phase checks prevent replay across materialization.
|
||
const sliceRestoreEvidenceKey = "sliceRestoreEvidence"
|
||
|
||
type sliceRestoreEvidence struct {
|
||
Slice domain.SliceSegment `json:"slice"`
|
||
Restored []domain.AnnotationSegment `json:"restored"`
|
||
Revision int `json:"revision"`
|
||
Phase string `json:"phase"`
|
||
}
|
||
|
||
func sameRestoredAnnotations(active, restored []domain.AnnotationSegment) bool {
|
||
remaining := append([]domain.AnnotationSegment(nil), active...)
|
||
unchanged := len(remaining) == len(restored)
|
||
for _, expected := range restored {
|
||
found := -1
|
||
for i, a := range remaining {
|
||
if reflect.DeepEqual(a, expected) {
|
||
found = i
|
||
break
|
||
}
|
||
}
|
||
if found < 0 {
|
||
unchanged = false
|
||
break
|
||
}
|
||
remaining = append(remaining[:found], remaining[found+1:]...)
|
||
}
|
||
return unchanged
|
||
}
|
||
|
||
func discardArchiveAfterRestore(e sliceRestoreEvidence, next domain.SliceSegment, active []domain.AnnotationSegment) []domain.AnnotationSegment {
|
||
if sameRestoredAnnotations(active, e.Restored) {
|
||
return append([]domain.AnnotationSegment(nil), e.Slice.DiscardedAnnotations...)
|
||
}
|
||
// Edits/deletions supersede only the exposed and current intervals.
|
||
return append(append([]domain.AnnotationSegment(nil), active...), archiveOutsideIntervals(e.Slice.DiscardedAnnotations, next.ID, e.Slice, next)...)
|
||
}
|
||
|
||
// Only a changed restore->discard writes ownership. Inherited archive records
|
||
// are not writes. Empty replacement content is an authoritative deletion.
|
||
const sliceArchiveEditsKey = "sliceArchiveEdits"
|
||
|
||
type sliceArchiveEdit struct {
|
||
Owner domain.SliceSegment `json:"owner"`
|
||
Intervals []domain.SliceSegment `json:"intervals"`
|
||
Annotations []domain.AnnotationSegment `json:"annotations"`
|
||
Version int `json:"version"`
|
||
Revision int `json:"revision"`
|
||
Phase string `json:"phase"`
|
||
}
|
||
|
||
func currentSliceArchiveEdits(item *domain.HumanItemRecord) []sliceArchiveEdit {
|
||
var result []sliceArchiveEdit
|
||
phase := stringValue(mapValue(item.Subject.Payload["sliceWorkflow"])["phase"])
|
||
for _, edit := range decodeMaterializationValue[sliceArchiveEdit](item.Subject.Payload[sliceArchiveEditsKey]) {
|
||
if edit.Revision == item.CurrentRevision && edit.Phase == phase {
|
||
result = append(result, edit)
|
||
}
|
||
}
|
||
stdslices.SortStableFunc(result, func(a, b sliceArchiveEdit) int {
|
||
if a.Version < b.Version {
|
||
return -1
|
||
}
|
||
if a.Version > b.Version {
|
||
return 1
|
||
}
|
||
return 0
|
||
})
|
||
return result
|
||
}
|
||
|
||
func applySliceArchiveEdits(slices []domain.SliceSegment, edits []sliceArchiveEdit) {
|
||
for _, edit := range edits {
|
||
for i := range slices {
|
||
target := &slices[i]
|
||
// The owner and its saved ancestors may recover this write. Do not turn
|
||
// a sibling's inherited full archive or client SourceIDs into ownership.
|
||
if !target.IsDiscarded() || (target.ID != edit.Owner.ID && !stdslices.Contains(edit.Owner.SourceIDs, target.ID)) {
|
||
continue
|
||
}
|
||
for _, interval := range edit.Intervals {
|
||
replacement := interval
|
||
replacement.ID = edit.Owner.ID
|
||
replacement.DiscardedAnnotations = edit.Annotations
|
||
content := restoredDiscardAnnotations(replacement)
|
||
window := *target
|
||
window.Start, window.End = interval.Start, interval.End
|
||
if sameArchiveContent(restoredDiscardAnnotations(window), content) {
|
||
continue
|
||
}
|
||
target.DiscardedAnnotations = append(archiveOutsideIntervals(target.DiscardedAnnotations, target.ID, interval), content...)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func sameArchiveContent(a, b []domain.AnnotationSegment) bool {
|
||
if len(a) != len(b) {
|
||
return false
|
||
}
|
||
for i := range a {
|
||
left, right := a[i], b[i]
|
||
left.ID, right.ID = "", ""
|
||
if !reflect.DeepEqual(left, right) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
func archiveOutsideIntervals(originals []domain.AnnotationSegment, sliceID string, intervals ...domain.SliceSegment) []domain.AnnotationSegment {
|
||
var archive []domain.AnnotationSegment
|
||
for _, original := range originals {
|
||
parts := []domain.AnnotationSegment{original}
|
||
for _, interval := range intervals {
|
||
var kept []domain.AnnotationSegment
|
||
for _, a := range parts {
|
||
if a.End <= interval.Start || a.Start >= interval.End {
|
||
kept = append(kept, a)
|
||
continue
|
||
}
|
||
for _, bounds := range [][2]float64{{a.Start, math.Min(a.End, interval.Start)}, {math.Max(a.Start, interval.End), a.End}} {
|
||
if bounds[1] <= bounds[0] {
|
||
continue
|
||
}
|
||
part := a
|
||
part.Start, part.End = bounds[0], bounds[1]
|
||
part.ID = fmt.Sprintf("%s@%s:%g:%g", original.ID, sliceID, part.Start, part.End)
|
||
part.StartTimestampUS, part.EndTimestampUS = 0, 0
|
||
kept = append(kept, part)
|
||
}
|
||
}
|
||
parts = kept
|
||
}
|
||
archive = append(archive, parts...)
|
||
}
|
||
return archive
|
||
}
|
||
|
||
// Keep the original archive intact for boundary undo. Restoring a child only
|
||
// reactivates the part of that evidence inside its current interval.
|
||
func restoredDiscardAnnotations(slice domain.SliceSegment) []domain.AnnotationSegment {
|
||
var result []domain.AnnotationSegment
|
||
for _, annotation := range slice.DiscardedAnnotations {
|
||
start, end := math.Max(annotation.Start, slice.Start), math.Min(annotation.End, slice.End)
|
||
if end <= start {
|
||
continue
|
||
}
|
||
if start != annotation.Start || end != annotation.End {
|
||
annotation.ID += "@" + slice.ID
|
||
annotation.StartTimestampUS, annotation.EndTimestampUS = 0, 0
|
||
}
|
||
annotation.Start, annotation.End = start, end
|
||
result = append(result, annotation)
|
||
}
|
||
return result
|
||
}
|
||
|
||
type sliceDispositionInput struct {
|
||
combinedAnnotationDraftInput
|
||
RestoreClassifications bool `json:"restoreClassifications,omitempty"`
|
||
SliceID string `json:"sliceId"`
|
||
Disposition string `json:"disposition"`
|
||
Reason string `json:"reason"`
|
||
ReasonLabelID string `json:"reasonLabelId"`
|
||
ReasonVersion int `json:"reasonVersion"`
|
||
ReasonNote string `json:"reasonNote"`
|
||
RestorePreviousName bool `json:"restorePreviousName,omitempty"`
|
||
ResetToPending bool `json:"resetToPending,omitempty"`
|
||
RestoreNameFromVersion int `json:"restoreNameFromVersion,omitempty"`
|
||
}
|
||
|
||
func sliceNameBeforeDiscard(item *domain.HumanItemRecord, sliceID string, version int) (string, bool) {
|
||
prior := sliceBeforeDiscard(item, sliceID, version)
|
||
if prior == nil {
|
||
return "", false
|
||
}
|
||
return prior.Name, true
|
||
}
|
||
func sliceBeforeDiscard(item *domain.HumanItemRecord, sliceID string, version int) *domain.SliceSegment {
|
||
history, _ := normalizeStructuredValue(item.Subject.Payload["sliceDispositionHistory"]).([]any)
|
||
resets, _ := normalizeStructuredValue(item.Subject.Payload["sliceResetHistory"]).([]any)
|
||
resetVersion := 0
|
||
if len(resets) > 0 {
|
||
resetVersion = intValue(mapValue(resets[len(resets)-1])["itemVersion"])
|
||
}
|
||
for i := len(history) - 1; i >= 0; i-- {
|
||
entry := mapValue(history[i])
|
||
entryVersion := intValue(entry["itemVersion"])
|
||
if entryVersion <= resetVersion {
|
||
break
|
||
}
|
||
if stringValue(entry["sliceId"]) != sliceID || (version != 0 && entryVersion != version) {
|
||
continue
|
||
}
|
||
before := decodeMaterializationValue[domain.SliceSegment]([]any{entry["before"]})
|
||
after := decodeMaterializationValue[domain.SliceSegment]([]any{entry["after"]})
|
||
if len(before) == 1 && len(after) == 1 && !before[0].IsDiscarded() && after[0].IsDiscarded() {
|
||
copy := before[0]
|
||
return ©
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (s *server) handleSliceDisposition(w http.ResponseWriter, r *http.Request) {
|
||
task, err := s.store.GetAnnotationTask(r.Context(), chi.URLParam(r, "id"))
|
||
if err != nil {
|
||
renderError(w, 500, err)
|
||
return
|
||
}
|
||
if task == nil {
|
||
renderJSON(w, 404, map[string]string{"error": "Annotation task not found"})
|
||
return
|
||
}
|
||
p, _, ok := s.ensureAnnotationTaskAccess(w, r, *task)
|
||
if !ok {
|
||
return
|
||
}
|
||
if p == nil || p.User.Role != domain.UserRoleAnnotator {
|
||
renderJSON(w, 403, map[string]string{"error": "只有标注员可设置舍弃/恢复,审核员请通过审核意见打回"})
|
||
return
|
||
}
|
||
item, ok := s.requireLegacyHumanItemClaim(w, r, *task, domain.FanyuV58StageAnnotationCombined)
|
||
if !ok {
|
||
return
|
||
}
|
||
if rejectPendingCombinedSubmission(w, item) {
|
||
return
|
||
}
|
||
workflow := mapValue(item.Subject.Payload["sliceWorkflow"])
|
||
if stringValue(workflow["status"]) == "processing" {
|
||
renderJSON(w, 409, map[string]string{"error": "切片正在生成,请完成后再设置用途"})
|
||
return
|
||
}
|
||
var body sliceDispositionInput
|
||
if !decodeJSON(w, r, &body) {
|
||
return
|
||
}
|
||
if body.Version != item.Version {
|
||
renderJSON(w, 409, map[string]string{"code": "version_conflict", "error": "任务已变化,请刷新后重试"})
|
||
return
|
||
}
|
||
if rejectInvalidSavedAnnotationWorkspaces(w, item) {
|
||
return
|
||
}
|
||
workspace, next, prepared := s.prepareSliceDisposition(w, r, task, item, p.User.ID, body)
|
||
if !prepared {
|
||
return
|
||
}
|
||
version := item.Version
|
||
item.Version++
|
||
item.UpdatedAt = nowISO()
|
||
won, e := s.store.UpdateHumanItemVersioned(r.Context(), *item, version)
|
||
if e != nil {
|
||
renderError(w, 500, e)
|
||
return
|
||
}
|
||
if !won {
|
||
renderJSON(w, 409, map[string]string{"code": "version_conflict", "error": "任务已变化,请刷新后重试"})
|
||
return
|
||
}
|
||
_ = s.appendHumanEvent(r.Context(), *item, "slice_disposition_changed", p.User.ID, map[string]any{"sliceId": next.ID, "disposition": body.Disposition, "reason": next.DiscardReason, "reasonLabelId": next.DiscardReasonLabelID, "reasonVersion": next.DiscardReasonVersion, "reasonNote": next.DiscardReasonNote, "start": next.Start, "end": next.End})
|
||
renderJSON(w, 200, map[string]any{"item": item, "workspace": workspace})
|
||
}
|
||
|
||
// prepareSliceDisposition updates only this in-memory item. Callers commit one CAS
|
||
// after every command and structure validation succeeds.
|
||
func (s *server) prepareSliceDisposition(w http.ResponseWriter, r *http.Request, task *domain.AnnotationTaskRecord, item *domain.HumanItemRecord, actorID string, body sliceDispositionInput) (map[string]any, domain.SliceSegment, bool) {
|
||
workflow := mapValue(item.Subject.Payload["sliceWorkflow"])
|
||
if body.Disposition != "keep" && body.Disposition != "discard" {
|
||
renderValidationError(w, validationIssue{Field: "disposition", Message: "用途必须为 keep 或 discard"})
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
body.Reason = strings.TrimSpace(body.Reason)
|
||
body.ReasonNote = strings.TrimSpace(body.ReasonNote)
|
||
var reasonLabel *domain.AnnotationLabelRecord
|
||
if body.Disposition == "discard" {
|
||
var issues []validationIssue
|
||
reasonLabel, issues = s.resolveDiscardReason(r.Context(), item, body)
|
||
if len(issues) > 0 {
|
||
renderValidationError(w, issues...)
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
if reasonLabel != nil {
|
||
body.Reason = reasonLabel.Name
|
||
if body.ReasonNote != "" {
|
||
body.Reason += ":" + body.ReasonNote
|
||
}
|
||
} else {
|
||
body.ReasonNote = ""
|
||
}
|
||
}
|
||
|
||
slices, issues := s.canonicalSliceDispositionState(r.Context(), item, body.normalizedSliceSegments(), body.normalizedOperations())
|
||
issues = append(issues, s.validateProjectSliceNames(r.Context(), item, slices, "restore")...)
|
||
if task.SourceIsFullVideo {
|
||
timeline, e := s.annotationFrameTimelineForTask(r.Context(), *task, "left")
|
||
if e != nil {
|
||
renderJSON(w, 422, map[string]string{"error": e.Error()})
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
task.CoverageStartSecond = floatValue(timeline["rangeStartSecond"])
|
||
task.CoverageEndSecond = floatValue(timeline["rangeEndSecond"])
|
||
task.CoverageMode = "full_common_range"
|
||
}
|
||
issues = append(issues, validateSliceSegments(slices, *task)...)
|
||
issues = append(issues, validateCompleteSliceCoverage(slices, *task)...)
|
||
issues = append(issues, s.canonicalActionDictionaries(r.Context(), item, body.Segments, dispositionDictionaryMode(body))...)
|
||
issues = append(issues, validateDraftCombinedAnnotationEvents(body.Segments, *task)...)
|
||
idx := -1
|
||
for i, v := range slices {
|
||
if v.ID == body.SliceID {
|
||
idx = i
|
||
}
|
||
}
|
||
if idx < 0 {
|
||
issues = append(issues, validationIssue{Field: "sliceId", Message: "请选择当前切片"})
|
||
}
|
||
if len(issues) > 0 {
|
||
renderValidationError(w, describeSliceNameIssues(issues, slices)...)
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
before := slices[idx]
|
||
if body.ResetToPending && (body.Disposition != "keep" || !before.IsDiscarded()) {
|
||
renderValidationError(w, validationIssue{Field: "resetToPending", Message: "只能在明确取消舍弃时重置待标注区间"})
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
restoredName := ""
|
||
if body.RestorePreviousName || body.RestoreNameFromVersion != 0 {
|
||
var found bool
|
||
restoredName, found = sliceNameBeforeDiscard(item, before.ID, body.RestoreNameFromVersion)
|
||
if body.RestoreNameFromVersion != 0 && (!found || !before.IsDiscarded() || body.Disposition != "keep") {
|
||
renderValidationError(w, validationIssue{Field: "restoreNameFromVersion", Message: "只能恢复当前切片本轮编辑中已记录的舍弃前名称"})
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
}
|
||
next := before
|
||
evidence := decodeMaterializationValue[sliceRestoreEvidence](item.Subject.Payload[sliceRestoreEvidenceKey])
|
||
phase := stringValue(workflow["phase"])
|
||
archiveEdits := currentSliceArchiveEdits(item)
|
||
var retainedEvidence []sliceRestoreEvidence
|
||
var recovery *sliceRestoreEvidence
|
||
for _, e := range evidence {
|
||
if e.Revision != item.CurrentRevision || e.Phase != phase {
|
||
continue
|
||
}
|
||
if e.Slice.ID == next.ID {
|
||
copy := e
|
||
recovery = ©
|
||
} else {
|
||
for _, candidate := range slices {
|
||
if candidate.ID == e.Slice.ID && !candidate.IsDiscarded() {
|
||
retainedEvidence = append(retainedEvidence, e)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Blank annotations are valid. Keep an allocated empty slice so restore
|
||
// (including restore with no archived descriptions) serializes [] not null.
|
||
segments := append([]domain.AnnotationSegment{}, body.Segments...)
|
||
if body.Disposition == "discard" {
|
||
next.DeliveryDisposition = "discard"
|
||
next.Name, next.TaskLabelID, next.TaskLabel = "", "", ""
|
||
next.Dictionary = nil
|
||
next.DiscardReason = body.Reason
|
||
next.DiscardReasonLabelID = ""
|
||
next.DiscardReasonVersion = 0
|
||
next.DiscardReasonName = ""
|
||
next.DiscardReasonDictionary = nil
|
||
if reasonLabel != nil {
|
||
next.DiscardReasonLabelID = reasonLabel.ID
|
||
next.DiscardReasonVersion = reasonLabel.Version
|
||
next.DiscardReasonName = reasonLabel.Name
|
||
next.DiscardReasonDictionary = reasonLabel.Selection()
|
||
if body.RestoreClassifications {
|
||
next.DiscardReasonDictionary = savedDictionarySelection(item, &domain.DictionarySelection{ID: reasonLabel.ID, Version: reasonLabel.Version}, "discard_reason")
|
||
}
|
||
}
|
||
next.DiscardReasonNote = body.ReasonNote
|
||
next.DiscardedByUserID = actorID
|
||
next.DiscardedAt = nowISO()
|
||
next.AnnotationStatus = domain.SliceAnnotationPending
|
||
kept := []domain.AnnotationSegment{}
|
||
var archived []domain.AnnotationSegment
|
||
for _, a := range segments {
|
||
if a.Start >= next.Start && a.End <= next.End {
|
||
archived = append(archived, a)
|
||
} else if a.Start < next.End && a.End > next.Start {
|
||
renderValidationError(w, validationIssue{Field: "segments", Message: "描述跨越切片边界,请先修正"})
|
||
return nil, domain.SliceSegment{}, false
|
||
} else {
|
||
kept = append(kept, a)
|
||
}
|
||
}
|
||
if !before.IsDiscarded() && recovery != nil {
|
||
next.DiscardedAnnotations = discardArchiveAfterRestore(*recovery, next, archived)
|
||
if !sameRestoredAnnotations(archived, recovery.Restored) {
|
||
intervals := []domain.SliceSegment{{Start: recovery.Slice.Start, End: recovery.Slice.End}, {Start: next.Start, End: next.End}}
|
||
if intervals[0].Start <= intervals[1].End && intervals[1].Start <= intervals[0].End {
|
||
intervals = []domain.SliceSegment{{Start: math.Min(recovery.Slice.Start, next.Start), End: math.Max(recovery.Slice.End, next.End)}}
|
||
}
|
||
archiveEdits = append(archiveEdits, sliceArchiveEdit{Owner: domain.SliceSegment{ID: next.ID, SourceIDs: append([]string(nil), next.SourceIDs...)}, Intervals: intervals, Annotations: append([]domain.AnnotationSegment(nil), archived...), Version: item.Version + 1, Revision: item.CurrentRevision, Phase: phase})
|
||
}
|
||
} else {
|
||
next.DiscardedAnnotations = append(next.DiscardedAnnotations, archived...)
|
||
}
|
||
if archiveIssues := validateDraftCombinedAnnotationEvents(next.DiscardedAnnotations, *task); len(archiveIssues) > 0 {
|
||
renderValidationError(w, archiveIssues...)
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
segments = kept
|
||
} else {
|
||
if before.IsDiscarded() {
|
||
restored := restoredDiscardAnnotations(before)
|
||
if body.ResetToPending || len(restored) == 0 {
|
||
// Explicit restore starts fresh; legacy empty archives still need
|
||
// a real pending partition. Original evidence remains server-owned.
|
||
keptSlice := before
|
||
keptSlice.DeliveryDisposition = "keep"
|
||
restored = fillPendingActionGaps([]domain.SliceSegment{keptSlice}, nil)
|
||
}
|
||
if body.ResetToPending {
|
||
outside := []domain.AnnotationSegment{}
|
||
for _, action := range segments {
|
||
if action.End <= before.Start || action.Start >= before.End {
|
||
outside = append(outside, action)
|
||
} else if action.Start < before.Start || action.End > before.End {
|
||
renderValidationError(w, validationIssue{Field: "segments", Message: "动作跨越切片边界,不能取消舍弃"})
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
}
|
||
segments = outside
|
||
}
|
||
used := map[string]bool{}
|
||
for _, a := range segments {
|
||
used[a.ID] = true
|
||
}
|
||
for i := range restored {
|
||
base := restored[i].ID
|
||
for n := 1; used[restored[i].ID]; n++ {
|
||
restored[i].ID = fmt.Sprintf("%s@%s:%d", base, next.ID, n)
|
||
}
|
||
used[restored[i].ID] = true
|
||
}
|
||
segments = append(segments, restored...)
|
||
retainedEvidence = append(retainedEvidence, sliceRestoreEvidence{Slice: before, Restored: restored, Revision: item.CurrentRevision, Phase: phase})
|
||
} else if recovery != nil {
|
||
retainedEvidence = append(retainedEvidence, *recovery)
|
||
}
|
||
next.DeliveryDisposition = "keep"
|
||
if before.IsDiscarded() {
|
||
next.Name, next.TaskLabelID, next.TaskLabel = "", "", ""
|
||
// Precise undo targets a server-recorded discard, even after later
|
||
// undo/redo writes. Ordinary restore deliberately remains unnamed.
|
||
next.Name = restoredName
|
||
next.Dictionary = nil
|
||
if body.RestorePreviousName || body.RestoreNameFromVersion != 0 {
|
||
if prior := sliceBeforeDiscard(item, before.ID, body.RestoreNameFromVersion); prior != nil {
|
||
next.Dictionary = prior.Dictionary
|
||
}
|
||
}
|
||
}
|
||
next.DiscardReason = ""
|
||
next.DiscardReasonLabelID = ""
|
||
next.DiscardReasonVersion = 0
|
||
next.DiscardReasonName = ""
|
||
next.DiscardReasonDictionary = nil
|
||
next.DiscardReasonNote = ""
|
||
next.DiscardedByUserID = ""
|
||
next.DiscardedAt = ""
|
||
next.DiscardedAnnotations = nil
|
||
next.AnnotationStatus = domain.SliceAnnotationPending
|
||
}
|
||
slices[idx] = next
|
||
applySliceArchiveEdits(slices, archiveEdits)
|
||
next = slices[idx]
|
||
// Disposition is an incremental edit, not confirmation of the whole slicing
|
||
// plan. Other slices may still have draft names; confirmation validates them.
|
||
issues = s.validateProjectSliceNames(r.Context(), item, slices, "restore")
|
||
issues = append(issues, s.canonicalActionDictionaries(r.Context(), item, segments, "restore")...)
|
||
issues = append(issues, validateDraftCombinedAnnotationEvents(segments, *task)...)
|
||
|
||
if len(issues) > 0 {
|
||
renderValidationError(w, describeSliceNameIssues(issues, slices)...)
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
statuses := body.normalizedStatuses()
|
||
statuses[next.ID] = domain.SliceAnnotationPending
|
||
if issues := rememberDictionarySelections(item, sliceDictionarySelections(slices)...); len(issues) > 0 {
|
||
renderValidationError(w, issues...)
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
workspace := map[string]any{"sliceSegments": slices, "segments": segments, "statuses": statuses, "operations": body.normalizedOperations(), "userId": actorID, "savedAt": nowISO()}
|
||
if item.Subject.Payload == nil {
|
||
item.Subject.Payload = map[string]any{}
|
||
}
|
||
history, _ := normalizeStructuredValue(item.Subject.Payload["sliceDispositionHistory"]).([]any)
|
||
history = append(history, map[string]any{"sliceId": next.ID, "before": before, "after": next, "actorUserId": actorID, "at": nowISO(), "itemVersion": item.Version + 1})
|
||
item.Subject.Payload["sliceDispositionHistory"] = history
|
||
item.Subject.Payload[sliceRestoreEvidenceKey] = retainedEvidence
|
||
item.Subject.Payload[sliceArchiveEditsKey] = archiveEdits
|
||
item.Subject.Payload["annotationWorkspace"] = workspace
|
||
delete(item.Subject.Payload, "annotationDraft")
|
||
if body.Disposition == "discard" {
|
||
// Frame validation can be slow; reject a dictionary change made while it ran.
|
||
if _, issues := s.resolveDiscardReason(r.Context(), item, body); len(issues) > 0 {
|
||
renderValidationError(w, issues...)
|
||
return nil, domain.SliceSegment{}, false
|
||
}
|
||
}
|
||
return workspace, next, true
|
||
}
|
||
|
||
func dispositionDictionaryMode(body sliceDispositionInput) string {
|
||
if body.RestoreClassifications {
|
||
return "restore"
|
||
}
|
||
return "draft"
|
||
}
|