404 lines
10 KiB
Go

package domain
import (
"sort"
"strings"
)
func IsScanSourceNode(node WorkflowNode) bool {
label := strings.TrimSpace(node.Data.Label)
return node.ID == "scan-source" || label == "BOS 增量扫描"
}
func FindScanSourceNode(nodes []WorkflowNode) *WorkflowNode {
for index := range nodes {
if IsScanSourceNode(nodes[index]) {
return &nodes[index]
}
}
return nil
}
func GetNodeByID(nodes []WorkflowNode, nodeID string) *WorkflowNode {
for index := range nodes {
if nodes[index].ID == nodeID {
return &nodes[index]
}
}
return nil
}
func GetIncomingEdges(edges []WorkflowEdge, nodeID string) []WorkflowEdge {
items := make([]WorkflowEdge, 0)
for _, edge := range edges {
if edge.Target == nodeID {
items = append(items, edge)
}
}
return items
}
func GetOutgoingEdges(edges []WorkflowEdge, nodeID string) []WorkflowEdge {
items := make([]WorkflowEdge, 0)
for _, edge := range edges {
if edge.Source == nodeID {
items = append(items, edge)
}
}
return items
}
func GetStartNodeIDs(nodes []WorkflowNode, edges []WorkflowEdge) []string {
items := make([]string, 0)
for _, node := range nodes {
hasIncoming := false
for _, edge := range edges {
if edge.Target == node.ID {
hasIncoming = true
break
}
}
if !hasIncoming {
items = append(items, node.ID)
}
}
return items
}
type InputPortConflict struct {
TargetNodeID string `json:"targetNodeId"`
TargetNodeLabel string `json:"targetNodeLabel,omitempty"`
TargetHandle string `json:"targetHandle,omitempty"`
TargetPortName string `json:"targetPortName,omitempty"`
EdgeIDs []string `json:"edgeIds"`
}
type WorkflowGraphIssueCode string
const (
WorkflowGraphIssueDisconnected WorkflowGraphIssueCode = "workflow_graph_disconnected"
WorkflowGraphIssueIsolatedNode WorkflowGraphIssueCode = "workflow_graph_isolated_node"
WorkflowGraphIssueCycle WorkflowGraphIssueCode = "workflow_graph_cycle"
)
type WorkflowGraphIssue struct {
Code WorkflowGraphIssueCode `json:"code"`
NodeIDs []string `json:"nodeIds,omitempty"`
Component []string `json:"component,omitempty"`
Message string `json:"message"`
}
func normalizeWorkflowHandle(value string) string {
return strings.TrimSpace(value)
}
func findInputPortName(node *WorkflowNode, handle string) string {
if node == nil {
if handle == "" {
return "默认输入"
}
return handle
}
normalizedHandle := normalizeWorkflowHandle(handle)
if normalizedHandle == "" {
return "默认输入"
}
for _, port := range node.Data.Inputs {
if normalizeWorkflowHandle(port.ID) == normalizedHandle {
if name := strings.TrimSpace(port.Name); name != "" {
return name
}
break
}
}
return normalizedHandle
}
func FindInputPortConflicts(nodes []WorkflowNode, edges []WorkflowEdge) []InputPortConflict {
type key struct {
target string
handle string
}
nodeByID := make(map[string]*WorkflowNode, len(nodes))
for index := range nodes {
nodeByID[nodes[index].ID] = &nodes[index]
}
grouped := make(map[key]*InputPortConflict)
for _, edge := range edges {
if strings.TrimSpace(edge.Target) == "" {
continue
}
conflictKey := key{
target: strings.TrimSpace(edge.Target),
handle: normalizeWorkflowHandle(edge.TargetHandle),
}
conflict := grouped[conflictKey]
if conflict == nil {
targetNode := nodeByID[conflictKey.target]
conflict = &InputPortConflict{
TargetNodeID: conflictKey.target,
TargetHandle: conflictKey.handle,
TargetPortName: findInputPortName(targetNode, conflictKey.handle),
}
if targetNode != nil {
conflict.TargetNodeLabel = strings.TrimSpace(targetNode.Data.Label)
}
grouped[conflictKey] = conflict
}
edgeID := strings.TrimSpace(edge.ID)
if edgeID == "" {
edgeID = edge.Source + "->" + edge.Target
}
conflict.EdgeIDs = append(conflict.EdgeIDs, edgeID)
}
conflicts := make([]InputPortConflict, 0)
for _, conflict := range grouped {
if len(conflict.EdgeIDs) <= 1 {
continue
}
sort.Strings(conflict.EdgeIDs)
conflicts = append(conflicts, *conflict)
}
sort.Slice(conflicts, func(i, j int) bool {
if conflicts[i].TargetNodeID != conflicts[j].TargetNodeID {
return conflicts[i].TargetNodeID < conflicts[j].TargetNodeID
}
return conflicts[i].TargetHandle < conflicts[j].TargetHandle
})
return conflicts
}
func ValidateSingleConnectedWorkflowGraph(nodes []WorkflowNode, edges []WorkflowEdge) []WorkflowGraphIssue {
if len(nodes) <= 1 {
return nil
}
nodeByID := make(map[string]WorkflowNode, len(nodes))
for _, node := range nodes {
trimmedID := strings.TrimSpace(node.ID)
if trimmedID == "" {
continue
}
nodeByID[trimmedID] = node
}
if len(nodeByID) <= 1 {
return nil
}
adjacent := make(map[string]map[string]struct{}, len(nodeByID))
degree := make(map[string]int, len(nodeByID))
for nodeID := range nodeByID {
adjacent[nodeID] = map[string]struct{}{}
}
for _, edge := range edges {
source := strings.TrimSpace(edge.Source)
target := strings.TrimSpace(edge.Target)
if source == "" || target == "" {
continue
}
if _, ok := nodeByID[source]; !ok {
continue
}
if _, ok := nodeByID[target]; !ok {
continue
}
if _, ok := adjacent[source][target]; !ok {
adjacent[source][target] = struct{}{}
adjacent[target][source] = struct{}{}
degree[source]++
degree[target]++
}
}
issues := make([]WorkflowGraphIssue, 0)
isolated := make([]string, 0)
for nodeID := range nodeByID {
if degree[nodeID] == 0 {
isolated = append(isolated, nodeID)
}
}
if len(isolated) > 0 {
sort.Strings(isolated)
issues = append(issues, WorkflowGraphIssue{
Code: WorkflowGraphIssueIsolatedNode,
NodeIDs: isolated,
Message: "workflow contains isolated nodes",
})
}
visited := make(map[string]struct{}, len(nodeByID))
components := make([][]string, 0)
for nodeID := range nodeByID {
if _, ok := visited[nodeID]; ok {
continue
}
queue := []string{nodeID}
visited[nodeID] = struct{}{}
component := make([]string, 0)
for len(queue) > 0 {
current := queue[0]
queue = queue[1:]
component = append(component, current)
for next := range adjacent[current] {
if _, ok := visited[next]; ok {
continue
}
visited[next] = struct{}{}
queue = append(queue, next)
}
}
sort.Strings(component)
components = append(components, component)
}
if len(components) > 1 {
sort.Slice(components, func(i, j int) bool {
if len(components[i]) != len(components[j]) {
return len(components[i]) > len(components[j])
}
return strings.Join(components[i], "\x00") < strings.Join(components[j], "\x00")
})
for _, component := range components[1:] {
issues = append(issues, WorkflowGraphIssue{
Code: WorkflowGraphIssueDisconnected,
Component: component,
Message: "workflow contains multiple disconnected chains",
})
}
}
indegree := make(map[string]int, len(nodeByID))
directed := make(map[string][]string, len(nodeByID))
for nodeID := range nodeByID {
indegree[nodeID] = 0
}
for _, edge := range edges {
source := strings.TrimSpace(edge.Source)
target := strings.TrimSpace(edge.Target)
if _, ok := nodeByID[source]; !ok {
continue
}
if _, ok := nodeByID[target]; !ok {
continue
}
directed[source] = append(directed[source], target)
indegree[target]++
}
queue := make([]string, 0, len(nodeByID))
for nodeID, degree := range indegree {
if degree == 0 {
queue = append(queue, nodeID)
}
}
processed := 0
for len(queue) > 0 {
current := queue[0]
queue = queue[1:]
processed++
for _, target := range directed[current] {
indegree[target]--
if indegree[target] == 0 {
queue = append(queue, target)
}
}
}
if processed != len(nodeByID) {
cycleNodes := directedCycleNodes(nodeByID, directed)
sort.Strings(cycleNodes)
issues = append(issues, WorkflowGraphIssue{
Code: WorkflowGraphIssueCycle,
NodeIDs: cycleNodes,
Message: "workflow contains a directed cycle",
})
}
return issues
}
func directedCycleNodes(nodeByID map[string]WorkflowNode, directed map[string][]string) []string {
color := make(map[string]uint8, len(nodeByID))
stack := make([]string, 0, len(nodeByID))
stackIndex := make(map[string]int, len(nodeByID))
cycleSet := make(map[string]struct{})
var visit func(string)
visit = func(nodeID string) {
color[nodeID] = 1
stackIndex[nodeID] = len(stack)
stack = append(stack, nodeID)
for _, target := range directed[nodeID] {
switch color[target] {
case 0:
visit(target)
case 1:
start := stackIndex[target]
for _, cycleNode := range stack[start:] {
cycleSet[cycleNode] = struct{}{}
}
}
}
stack = stack[:len(stack)-1]
delete(stackIndex, nodeID)
color[nodeID] = 2
}
for nodeID := range nodeByID {
if color[nodeID] == 0 {
visit(nodeID)
}
}
items := make([]string, 0, len(cycleSet))
for nodeID := range cycleSet {
items = append(items, nodeID)
}
return items
}
func auditDecisionMatchesHandle(handle string, decision AuditStatus) bool {
if handle == "" {
return decision == AuditStatusApproved
}
normalized := strings.ToLower(handle)
switch decision {
case AuditStatusApproved:
return strings.Contains(normalized, "approved") || strings.Contains(normalized, "通过")
case AuditStatusRejected:
return strings.Contains(normalized, "rejected") || strings.Contains(normalized, "拒绝")
default:
return false
}
}
func GetDecisionOutgoingEdges(edges []WorkflowEdge, nodeID string, decision AuditStatus) []WorkflowEdge {
outgoing := GetOutgoingEdges(edges, nodeID)
filtered := make([]WorkflowEdge, 0)
for _, edge := range outgoing {
if auditDecisionMatchesHandle(edge.SourceHandle, decision) {
filtered = append(filtered, edge)
}
}
if len(filtered) > 0 {
return filtered
}
return outgoing
}
func NodeRequiresAnnotation(node WorkflowNode) bool {
if strings.EqualFold(strings.TrimSpace(node.Data.OperatorID), "operator-builtin-annotation-gate") {
return true
}
for _, item := range node.Data.Hyperparams {
if strings.EqualFold(strings.TrimSpace(item.Key), "REVIEW_MODE") && strings.EqualFold(strings.TrimSpace(item.Value), "annotation") {
return true
}
}
return false
}
func NodeRequiresAudit(node WorkflowNode) bool {
if NodeRequiresAnnotation(node) {
return false
}
label := strings.ToLower(node.Data.Label)
return node.Data.Category == "HUMAN" || strings.Contains(label, "human review") || strings.Contains(node.Data.Label, "人工审核")
}