update

2026-09-13 20:08:13 +08:00
parent 7cc06976ab
commit da3f16e6db
65 changed files with 3855 additions and 2153 deletions
--- a/internal/sop/handler.go
+++ b/internal/sop/handler.go
@@ -11,6 +11,7 @@ import (
 	"git.iwork-ai.com/xdc/iqudo-top1/internal/auth"
 	"git.iwork-ai.com/xdc/iqudo-top1/internal/model"
 	"git.iwork-ai.com/xdc/iqudo-top1/internal/response"
+	"git.iwork-ai.com/xdc/iqudo-top1/internal/scriptkit"
 	"github.com/gin-gonic/gin"
 	"gorm.io/datatypes"
 	"gorm.io/gorm"
@@ -259,15 +260,13 @@ func (h *Handler) validateForPublish(item model.SOP, startNodeKey string, nodes
 	if err := h.db.Where("scenario_id = ? AND tenant_id = ?", item.ScenarioID, tenantID).Find(&fields).Error; err != nil {
 		return nil, err
 	}
-	var knowledgeItems []model.KnowledgeItem
-	if err := h.db.Where("scenario_id = ? AND tenant_id = ?", item.ScenarioID, tenantID).Find(&knowledgeItems).Error; err != nil {
-		return nil, err
+	stageKeys := make([]string, 0)
+	if pkg, err := scriptkit.LoadPackageByScenario(h.db, tenantID, item.ScenarioID); err == nil {
+		for _, stage := range pkg.Stages {
+			stageKeys = append(stageKeys, stage.StageKey)
+		}
 	}
-	var knowledgeRelations []model.KnowledgeRelation
-	if err := h.db.Where("scenario_id = ? AND tenant_id = ?", item.ScenarioID, tenantID).Find(&knowledgeRelations).Error; err != nil {
-		return nil, err
-	}
-	return ValidateForPublish(startNodeKey, nodes, edges, ValidationContext{Fields: fields, KnowledgeItems: knowledgeItems, KnowledgeRelations: knowledgeRelations}), nil
+	return ValidateForPublish(startNodeKey, nodes, edges, ValidationContext{Fields: fields, StageKeys: stageKeys}), nil
 }

 func toModels(tenantID, sopID uint64, input graphInput) ([]model.SOPNode, []model.SOPEdge) {
--- a/internal/sop/validator.go
+++ b/internal/sop/validator.go
@@ -8,13 +8,12 @@ import (
 	"git.iwork-ai.com/xdc/iqudo-top1/internal/model"
 )

-var allowedNodeTypes = map[string]bool{"start": true, "message": true, "question": true, "form": true, "choice": true, "condition": true, "knowledge": true, "escalate": true, "finish": true}
+var allowedNodeTypes = map[string]bool{"start": true, "message": true, "question": true, "form": true, "choice": true, "condition": true, "stage": true, "escalate": true, "finish": true}
 var allowedConditionOperators = map[string]bool{"equals": true, "not_equals": true, "contains": true, "greater_than": true, "less_than": true, "exists": true, "not_exists": true, "in": true}

 type ValidationContext struct {
-	Fields             []model.ScenarioField
-	KnowledgeItems     []model.KnowledgeItem
-	KnowledgeRelations []model.KnowledgeRelation
+	Fields    []model.ScenarioField
+	StageKeys []string
 }

 func ValidateGraph(startNodeKey string, nodes []model.SOPNode, edges []model.SOPEdge) []string {
@@ -135,22 +134,9 @@ func ValidateForPublish(startNodeKey string, nodes []model.SOPNode, edges []mode
 	for _, field := range context.Fields {
 		fieldMap[field.FieldKey] = field
 	}
-	knowledgeByKey := make(map[string]model.KnowledgeItem, len(context.KnowledgeItems))
-	knowledgeTypes := make(map[string]bool)
-	knowledgeIDs := make(map[uint64]bool, len(context.KnowledgeItems))
-	for _, item := range context.KnowledgeItems {
-		if item.Status != "active" {
-			continue
-		}
-		knowledgeByKey[item.ItemKey] = item
-		knowledgeTypes[item.Type] = true
-		knowledgeIDs[item.ID] = true
-	}
-	relationTypes := make(map[string]bool)
-	for _, relation := range context.KnowledgeRelations {
-		if knowledgeIDs[relation.FromKnowledgeID] && knowledgeIDs[relation.ToKnowledgeID] {
-			relationTypes[relation.RelationType] = true
-		}
+	stageKeys := make(map[string]bool, len(context.StageKeys))
+	for _, key := range context.StageKeys {
+		stageKeys[key] = true
 	}
 	collected := map[string]bool{}
 	nodeMap := make(map[string]model.SOPNode, len(nodes))
@@ -191,33 +177,25 @@ func ValidateForPublish(startNodeKey string, nodes []model.SOPNode, edges []mode
 				}
 				collected[fieldKey] = true
 			}
-		case "knowledge":
-			selector, ok := config["knowledge_selector"].(map[string]interface{})
-			if !ok {
-				problems = append(problems, fmt.Sprintf("节点“%s”没有配置知识选择器", node.Title))
-				break
+		case "stage":
+			stageKey, _ := config["stage_key"].(string)
+			if stageKey == "" {
+				problems = append(problems, fmt.Sprintf("节点“%s”没有绑定话术包阶段", node.Title))
+			} else if len(stageKeys) > 0 && !stageKeys[stageKey] {
+				problems = append(problems, fmt.Sprintf("节点“%s”绑定的话术包阶段 %s 不存在", node.Title, stageKey))
 			}
-			validateKnowledgeSelector(node, selector, knowledgeByKey, knowledgeTypes, relationTypes, &problems)
-			if collection, ok := config["knowledge_collection"].(map[string]interface{}); ok {
-				if keys, ok := collection["context_field_keys"].([]interface{}); ok {
-					for _, value := range keys {
-						if key, ok := value.(string); ok {
-							if _, exists := fieldMap[key]; !exists {
-								problems = append(problems, fmt.Sprintf("节点“%s”引用的采集字段 %s 不存在", node.Title, key))
-							} else {
-								collected[key] = true
-							}
-						}
+			if keys, ok := config["field_keys"].([]interface{}); ok {
+				for _, value := range keys {
+					fieldKey, keyOK := value.(string)
+					if !keyOK || fieldKey == "" {
+						problems = append(problems, fmt.Sprintf("节点“%s”包含无效的表单字段", node.Title))
+						continue
 					}
-				}
-				if steps, ok := collection["steps"].([]interface{}); ok {
-					for _, raw := range steps {
-						if step, ok := raw.(map[string]interface{}); ok {
-							if key, ok := step["field_key"].(string); ok && key != "" {
-								collected[key] = true
-							}
-						}
+					if _, exists := fieldMap[fieldKey]; !exists {
+						problems = append(problems, fmt.Sprintf("节点“%s”引用的字段 %s 不存在", node.Title, fieldKey))
+						continue
 					}
+					collected[fieldKey] = true
 				}
 			}
 		}
@@ -354,63 +332,6 @@ func isDefaultCondition(value []byte) bool {
 	return ok && len(object) == 0
 }

-func validateKnowledgeSelector(node model.SOPNode, selector map[string]interface{}, items map[string]model.KnowledgeItem, availableTypes, availableRelations map[string]bool, problems *[]string) {
-	derivedField, _ := selector["derived_field"].(string)
-	answerField, _ := selector["answer_field"].(string)
-	keys, keysValid := selectorStrings(selector, "knowledge_keys")
-	types, typesValid := selectorStrings(selector, "knowledge_types")
-	relations, relationsValid := selectorStrings(selector, "relation_types")
-	if !keysValid || !typesValid || !relationsValid {
-		*problems = append(*problems, fmt.Sprintf("节点“%s”的知识选择器必须使用字符串数组", node.Title))
-		return
-	}
-	if derivedField == "" && answerField == "" && len(keys) == 0 {
-		*problems = append(*problems, fmt.Sprintf("节点“%s”没有配置派生知识字段或固定知识 key", node.Title))
-	}
-	allowedTypes := make(map[string]bool, len(types))
-	for _, itemType := range types {
-		allowedTypes[itemType] = true
-		if !availableTypes[itemType] {
-			*problems = append(*problems, fmt.Sprintf("节点“%s”引用的知识类型 %s 不存在", node.Title, itemType))
-		}
-	}
-	for _, key := range keys {
-		item, exists := items[key]
-		if !exists {
-			*problems = append(*problems, fmt.Sprintf("节点“%s”引用的知识 key %s 不存在或未启用", node.Title, key))
-			continue
-		}
-		if len(allowedTypes) > 0 && !allowedTypes[item.Type] {
-			*problems = append(*problems, fmt.Sprintf("节点“%s”的知识 key %s 不属于允许的根类型", node.Title, key))
-		}
-	}
-	for _, relationType := range relations {
-		if !availableRelations[relationType] {
-			*problems = append(*problems, fmt.Sprintf("节点“%s”引用的知识关系类型 %s 不存在", node.Title, relationType))
-		}
-	}
-}
-
-func selectorStrings(selector map[string]interface{}, key string) ([]string, bool) {
-	raw, exists := selector[key]
-	if !exists || raw == nil {
-		return nil, true
-	}
-	values, ok := raw.([]interface{})
-	if !ok {
-		return nil, false
-	}
-	result := make([]string, 0, len(values))
-	for _, value := range values {
-		text, ok := value.(string)
-		if !ok || text == "" {
-			return nil, false
-		}
-		result = append(result, text)
-	}
-	return result, true
-}
-
 func canReachType(start, nodeType string, nodes map[string]model.SOPNode, adjacency map[string][]string) bool {
 	visited := map[string]bool{}
 	var walk func(string) bool
--- a/internal/sop/validator_test.go
+++ b/internal/sop/validator_test.go
@@ -38,15 +38,13 @@ func TestValidateForPublishBusinessRules(t *testing.T) {
 		{name: "invalid operator", mutate: func(_ *[]model.SOPNode, edges *[]model.SOPEdge, _ *ValidationContext) {
 			(*edges)[2].Condition = jsonData(`{"field":"emergency","operator":"matches","value":true}`)
 		}, want: "不支持的运算符 matches"},
-		{name: "missing knowledge key", mutate: func(_ *[]model.SOPNode, _ *[]model.SOPEdge, context *ValidationContext) {
-			context.KnowledgeItems = nil
-		}, want: "知识 key safety 不存在或未启用"},
-		{name: "missing knowledge type", mutate: func(nodes *[]model.SOPNode, _ *[]model.SOPEdge, _ *ValidationContext) {
-			(*nodes)[2].Config = jsonData(`{"knowledge_selector":{"knowledge_keys":["safety"],"knowledge_types":["missing"],"relation_types":["related_copy"]}}`)
-		}, want: "知识类型 missing 不存在"},
-		{name: "missing relation type", mutate: func(nodes *[]model.SOPNode, _ *[]model.SOPEdge, _ *ValidationContext) {
-			(*nodes)[2].Config = jsonData(`{"knowledge_selector":{"knowledge_keys":["safety"],"knowledge_types":["guidance"],"relation_types":["missing"]}}`)
-		}, want: "知识关系类型 missing 不存在"},
+		{name: "missing stage key", mutate: func(nodes *[]model.SOPNode, _ *[]model.SOPEdge, _ *ValidationContext) {
+			(*nodes)[2].Config = jsonData(`{"stage_key":""}`)
+		}, want: "没有绑定话术包阶段"},
+		{name: "unknown stage key", mutate: func(nodes *[]model.SOPNode, _ *[]model.SOPEdge, context *ValidationContext) {
+			(*nodes)[2].Config = jsonData(`{"stage_key":"missing"}`)
+			context.StageKeys = []string{"safety"}
+		}, want: "话术包阶段 missing 不存在"},
 		{name: "duplicate default path", mutate: func(_ *[]model.SOPNode, edges *[]model.SOPEdge, _ *ValidationContext) {
 			(*edges)[1].Condition = jsonData(`{}`)
 		}, want: "配置了多条默认路径"},
@@ -123,23 +121,19 @@ func validPublishGraph() ([]model.SOPNode, []model.SOPEdge, ValidationContext) {
 	nodes := []model.SOPNode{
 		{NodeKey: "start", Type: "start", Title: "开始", Config: jsonData(`{}`)},
 		{NodeKey: "screen", Type: "form", Title: "急症筛查", Config: jsonData(`{"field_keys":["emergency"],"risk_level":"high"}`)},
-		{NodeKey: "knowledge", Type: "knowledge", Title: "用药原则", Config: jsonData(`{"knowledge_selector":{"knowledge_keys":["safety"],"knowledge_types":["guidance"],"relation_types":["related_copy"]}}`)},
+		{NodeKey: "safety_stage", Type: "stage", Title: "用药原则", Config: jsonData(`{"stage_key":"safety"}`)},
 		{NodeKey: "escalate", Type: "escalate", Title: "转诊", Config: jsonData(`{}`)},
 		{NodeKey: "finish", Type: "finish", Title: "结束", Config: jsonData(`{}`)},
 	}
 	edges := []model.SOPEdge{
 		{SourceNodeKey: "start", TargetNodeKey: "screen", Condition: jsonData(`{}`)},
 		{SourceNodeKey: "screen", TargetNodeKey: "escalate", Condition: jsonData(`{"field":"emergency","operator":"equals","value":true}`)},
-		{SourceNodeKey: "screen", TargetNodeKey: "knowledge", Condition: jsonData(`{}`)},
-		{SourceNodeKey: "knowledge", TargetNodeKey: "finish", Condition: jsonData(`{}`)},
+		{SourceNodeKey: "screen", TargetNodeKey: "safety_stage", Condition: jsonData(`{}`)},
+		{SourceNodeKey: "safety_stage", TargetNodeKey: "finish", Condition: jsonData(`{}`)},
 	}
 	context := ValidationContext{
-		Fields: []model.ScenarioField{{FieldKey: "emergency", FieldName: "是否急症", Required: true}},
-		KnowledgeItems: []model.KnowledgeItem{
-			{Base: model.Base{ID: 1}, ItemKey: "safety", Type: "guidance", Status: "active"},
-			{Base: model.Base{ID: 2}, ItemKey: "safety_copy", Type: "copy", Status: "active"},
-		},
-		KnowledgeRelations: []model.KnowledgeRelation{{FromKnowledgeID: 1, ToKnowledgeID: 2, RelationType: "related_copy"}},
+		Fields:    []model.ScenarioField{{FieldKey: "emergency", FieldName: "是否急症", Required: true}},
+		StageKeys: []string{"safety"},
 	}
 	return nodes, edges, context
 }