forked from longtao.wu/droboticflow
84 lines
2.8 KiB
Go
84 lines
2.8 KiB
Go
package api
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"sort"
|
|
"strings"
|
|
|
|
"droboticflow/internal/domain"
|
|
)
|
|
|
|
// Consolidation is an explicit submission choice, never a migration or a
|
|
// cancel-cut. Action records are not passed by pointer or rewritten here.
|
|
func consolidateInvalidActionSlices(input []domain.SliceSegment, actions []domain.AnnotationSegment, selected []string) ([]domain.SliceSegment, []domain.SliceOperation, error) {
|
|
if len(selected) == 0 {
|
|
return input, nil, nil
|
|
}
|
|
ordered := append([]domain.SliceSegment(nil), input...)
|
|
sort.Slice(ordered, func(i, j int) bool { return ordered[i].Start < ordered[j].Start })
|
|
eligible := map[string]int{}
|
|
for i := 1; i < len(ordered)-1; i++ {
|
|
l, c, r := ordered[i-1], ordered[i], ordered[i+1]
|
|
if l.IsDiscarded() || c.IsDiscarded() || r.IsDiscarded() || strings.TrimSpace(c.Name) == "" || l.Name != c.Name || r.Name != c.Name || !reflect.DeepEqual(l.Dictionary, c.Dictionary) || !reflect.DeepEqual(r.Dictionary, c.Dictionary) || l.End != c.Start || c.End != r.Start {
|
|
continue
|
|
}
|
|
cursor, has, valid := c.Start, false, true
|
|
inner := append([]domain.AnnotationSegment(nil), actions...)
|
|
sort.Slice(inner, func(i, j int) bool { return inner[i].Start < inner[j].Start })
|
|
for _, a := range inner {
|
|
if a.End <= c.Start || a.Start >= c.End {
|
|
continue
|
|
}
|
|
if a.Start != cursor || a.End > c.End || a.End <= a.Start || !a.IsInvalid {
|
|
valid = false
|
|
break
|
|
}
|
|
cursor, has = a.End, true
|
|
}
|
|
if valid && has && cursor == c.End {
|
|
eligible[c.ID] = i
|
|
}
|
|
}
|
|
edges := make([]bool, len(ordered))
|
|
seen := map[string]bool{}
|
|
for _, id := range selected {
|
|
i, ok := eligible[id]
|
|
if !ok || seen[id] {
|
|
return nil, nil, fmt.Errorf("所选无效区间的相邻切片已变化,请重新核对后提交")
|
|
}
|
|
seen[id] = true
|
|
edges[i-1], edges[i] = true, true
|
|
}
|
|
var result []domain.SliceSegment
|
|
var operations []domain.SliceOperation
|
|
for i := 0; i < len(ordered); {
|
|
j := i
|
|
for j < len(ordered)-1 && edges[j] {
|
|
j++
|
|
}
|
|
merged := ordered[i]
|
|
if j > i {
|
|
// Keep original IDs in audit provenance; reuse the leftmost stable ID.
|
|
merged.SourceIDs = nil
|
|
provenance := map[string]bool{}
|
|
ids := []string{}
|
|
for k := i; k <= j; k++ {
|
|
ids = append(ids, ordered[k].ID)
|
|
for _, id := range append([]string{ordered[k].ID}, ordered[k].SourceIDs...) {
|
|
if !provenance[id] {
|
|
merged.SourceIDs = append(merged.SourceIDs, id)
|
|
provenance[id] = true
|
|
}
|
|
}
|
|
}
|
|
merged.End = ordered[j].End
|
|
merged.EndTimestampUS = ordered[j].EndTimestampUS
|
|
operations = append(operations, domain.SliceOperation{Type: "consolidate_invalid_actions", SegmentIDs: ids, Before: append([]domain.SliceSegment(nil), ordered[i:j+1]...), After: []domain.SliceSegment{merged}})
|
|
}
|
|
result = append(result, merged)
|
|
i = j + 1
|
|
}
|
|
return result, operations, nil
|
|
}
|