321 lines
13 KiB
Go
321 lines
13 KiB
Go
package main
|
||
|
||
import (
|
||
"crypto/sha256"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"fmt"
|
||
"os"
|
||
"sort"
|
||
"strings"
|
||
|
||
"git.iwork-ai.com/xdc/iqudo-top1/internal/model"
|
||
"github.com/xuri/excelize/v2"
|
||
"gorm.io/datatypes"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
const petKnowledgeSource = "症状-疾病-方案.xlsx"
|
||
const petScriptSource = "症状-疾病-话术.json"
|
||
|
||
func resetPetKnowledge(tx *gorm.DB, tenantID, scenarioID uint64) error {
|
||
var ids []uint64
|
||
if err := tx.Model(&model.KnowledgeItem{}).Where("tenant_id = ? AND scenario_id = ?", tenantID, scenarioID).Pluck("id", &ids).Error; err != nil {
|
||
return fmt.Errorf("list old pet knowledge: %w", err)
|
||
}
|
||
if len(ids) > 0 {
|
||
if err := tx.Where("tenant_id = ? AND scenario_id = ? AND (from_knowledge_id IN ? OR to_knowledge_id IN ?)", tenantID, scenarioID, ids, ids).Delete(&model.KnowledgeRelation{}).Error; err != nil {
|
||
return fmt.Errorf("delete old pet knowledge relations: %w", err)
|
||
}
|
||
if err := tx.Where("tenant_id = ? AND scenario_id = ? AND id IN ?", tenantID, scenarioID, ids).Delete(&model.KnowledgeItem{}).Error; err != nil {
|
||
return fmt.Errorf("delete old pet knowledge items: %w", err)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type petScriptDisease struct {
|
||
Plans []struct {
|
||
Plan string `json:"plan"`
|
||
Products []struct {
|
||
SKUCode string `json:"sku_code"`
|
||
ProductName string `json:"product_name"`
|
||
} `json:"products"`
|
||
} `json:"plans"`
|
||
Combinations []struct {
|
||
Name string `json:"name"`
|
||
Weight int `json:"weight"`
|
||
Products []struct {
|
||
SKUCode string `json:"sku_code"`
|
||
ProductName string `json:"product_name"`
|
||
} `json:"products"`
|
||
Script string `json:"script"`
|
||
} `json:"combinations"`
|
||
}
|
||
|
||
func importPetScripts(tx *gorm.DB, tenantID, scenarioID uint64, filename string) error {
|
||
raw, err := os.ReadFile(filename)
|
||
if err != nil {
|
||
return fmt.Errorf("read pet scripts %s: %w", filename, err)
|
||
}
|
||
var source map[string]map[string]petScriptDisease
|
||
if err := json.Unmarshal(raw, &source); err != nil {
|
||
return fmt.Errorf("parse pet scripts %s: %w", filename, err)
|
||
}
|
||
for symptom, diseases := range source {
|
||
for disease, definition := range diseases {
|
||
diseaseKey := petKnowledgeKey("disease", disease)
|
||
if err := upsertPetScriptItems(tx, tenantID, scenarioID, symptom, disease, diseaseKey, definition); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func upsertPetScriptItems(tx *gorm.DB, tenantID, scenarioID uint64, symptom, disease, diseaseKey string, definition petScriptDisease) error {
|
||
symptomKey := petKnowledgeKey("symptom", symptom)
|
||
if err := upsertPetKnowledgeItem(tx, tenantID, scenarioID, symptomKey, symptom, "symptom", []byte(`{"source":"`+petScriptSource+`"}`)); err != nil {
|
||
return err
|
||
}
|
||
if err := upsertPetKnowledgeItem(tx, tenantID, scenarioID, diseaseKey, disease, "disease", []byte(`{"source":"`+petScriptSource+`"}`)); err != nil {
|
||
return err
|
||
}
|
||
if err := upsertPetRelation(tx, scenarioID, symptomKey, "possible_disease", diseaseKey, 3000); err != nil {
|
||
return err
|
||
}
|
||
for index, combination := range definition.Combinations {
|
||
copyName := fmt.Sprintf("%s-%s话术", disease, combination.Name)
|
||
copyKey := petKnowledgeKey("copy", "json_"+symptom+"_"+disease+"_"+combination.Name)
|
||
content, _ := json.Marshal(map[string]interface{}{"source": petScriptSource, "template": strings.ReplaceAll(combination.Script, "{{purchased_products}}", "{{input.product_names}}"), "combination": combination.Name, "weight": combination.Weight})
|
||
if err := upsertPetKnowledgeItem(tx, tenantID, scenarioID, copyKey, copyName, "copy", content); err != nil {
|
||
return err
|
||
}
|
||
if err := upsertPetRelation(tx, scenarioID, diseaseKey, "recommended_copy", copyKey, 3000+index); err != nil {
|
||
return err
|
||
}
|
||
for productIndex, product := range combination.Products {
|
||
if strings.TrimSpace(product.SKUCode) == "" {
|
||
continue
|
||
}
|
||
productKey := petKnowledgeKey("product", product.SKUCode)
|
||
content, _ := json.Marshal(map[string]interface{}{"source": petScriptSource, "sku_code": product.SKUCode, "product_name": product.ProductName})
|
||
if err := upsertPetKnowledgeItem(tx, tenantID, scenarioID, productKey, product.ProductName, "product", content); err != nil {
|
||
return err
|
||
}
|
||
if err := upsertPetRelation(tx, scenarioID, diseaseKey, "recommended_product", productKey, 3400+index*100+productIndex); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
for index, plan := range definition.Plans {
|
||
if strings.TrimSpace(plan.Plan) == "" {
|
||
continue
|
||
}
|
||
planKey := petKnowledgeKey("plan", plan.Plan)
|
||
if err := upsertPetKnowledgeItem(tx, tenantID, scenarioID, planKey, plan.Plan, "plan", []byte(`{"source":"`+petScriptSource+`"}`)); err != nil {
|
||
return err
|
||
}
|
||
if err := upsertPetRelation(tx, scenarioID, diseaseKey, "recommended_plan", planKey, 3200+index); err != nil {
|
||
return err
|
||
}
|
||
for productIndex, product := range plan.Products {
|
||
if strings.TrimSpace(product.SKUCode) == "" {
|
||
continue
|
||
}
|
||
productKey := petKnowledgeKey("product", product.SKUCode)
|
||
content, _ := json.Marshal(map[string]interface{}{"source": petScriptSource, "sku_code": product.SKUCode, "product_name": product.ProductName})
|
||
if err := upsertPetKnowledgeItem(tx, tenantID, scenarioID, productKey, product.ProductName, "product", content); err != nil {
|
||
return err
|
||
}
|
||
if err := upsertPetRelation(tx, scenarioID, diseaseKey, "recommended_product", productKey, 3600+index*100+productIndex); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func upsertPetKnowledgeItem(tx *gorm.DB, tenantID, scenarioID uint64, key, name, typeName string, content []byte) error {
|
||
row := model.KnowledgeItem{TenantID: tenantID, ScenarioID: scenarioID, ItemKey: key, Name: name, Type: typeName, Content: datatypes.JSON(content), Status: "active", SortOrder: 3000}
|
||
return tx.Where("tenant_id = ? AND scenario_id = ? AND item_key = ?", tenantID, scenarioID, key).Assign(row).FirstOrCreate(&row).Error
|
||
}
|
||
|
||
func upsertPetRelation(tx *gorm.DB, scenarioID uint64, fromKey, relation, toKey string, order int) error {
|
||
var from, to model.KnowledgeItem
|
||
if err := tx.Where("scenario_id = ? AND item_key = ?", scenarioID, fromKey).First(&from).Error; err != nil {
|
||
return fmt.Errorf("find script relation source %s: %w", fromKey, err)
|
||
}
|
||
if err := tx.Where("scenario_id = ? AND item_key = ?", scenarioID, toKey).First(&to).Error; err != nil {
|
||
return fmt.Errorf("find script relation target %s: %w", toKey, err)
|
||
}
|
||
row := model.KnowledgeRelation{TenantID: from.TenantID, ScenarioID: scenarioID, FromKnowledgeID: from.ID, RelationType: relation, ToKnowledgeID: to.ID, Condition: datatypes.JSON([]byte(`{}`)), SortOrder: order}
|
||
return tx.Where("scenario_id = ? AND from_knowledge_id = ? AND relation_type = ? AND to_knowledge_id = ?", scenarioID, from.ID, relation, to.ID).Assign(row).FirstOrCreate(&row).Error
|
||
}
|
||
|
||
type petKnowledgeRow struct {
|
||
Symptom string
|
||
Disease string
|
||
Plan string
|
||
SKUCode string
|
||
ProductName string
|
||
}
|
||
|
||
func importPetKnowledge(tx *gorm.DB, tenantID, scenarioID uint64, filename string) error {
|
||
rows, err := readPetKnowledge(filename)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return upsertPetKnowledge(tx, tenantID, scenarioID, rows)
|
||
}
|
||
|
||
func readPetKnowledge(filename string) ([]petKnowledgeRow, error) {
|
||
book, err := excelize.OpenFile(filename)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("open pet knowledge %s: %w", filename, err)
|
||
}
|
||
defer book.Close()
|
||
sheets := book.GetSheetList()
|
||
if len(sheets) == 0 {
|
||
return nil, fmt.Errorf("pet knowledge %s has no worksheet", filename)
|
||
}
|
||
iterator, err := book.Rows(sheets[0])
|
||
if err != nil {
|
||
return nil, fmt.Errorf("read pet knowledge worksheet: %w", err)
|
||
}
|
||
defer iterator.Close()
|
||
|
||
columns := map[string]int{}
|
||
result := make([]petKnowledgeRow, 0)
|
||
rowNumber := 0
|
||
for iterator.Next() {
|
||
rowNumber++
|
||
values, err := iterator.Columns()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("read pet knowledge row %d: %w", rowNumber, err)
|
||
}
|
||
if rowNumber == 1 {
|
||
for index, value := range values {
|
||
columns[strings.TrimSpace(value)] = index
|
||
}
|
||
for _, required := range []string{"症状", "疾病", "方案", "SKU_CODE", "商品标题"} {
|
||
if _, ok := columns[required]; !ok {
|
||
return nil, fmt.Errorf("pet knowledge is missing column %q", required)
|
||
}
|
||
}
|
||
continue
|
||
}
|
||
row := petKnowledgeRow{
|
||
Symptom: excelValue(values, columns["症状"]),
|
||
Disease: excelValue(values, columns["疾病"]),
|
||
Plan: excelValue(values, columns["方案"]),
|
||
SKUCode: excelValue(values, columns["SKU_CODE"]),
|
||
ProductName: excelValue(values, columns["商品标题"]),
|
||
}
|
||
if row.Symptom == "" && row.Disease == "" && row.Plan == "" {
|
||
continue
|
||
}
|
||
if row.Symptom == "" || row.Disease == "" {
|
||
return nil, fmt.Errorf("pet knowledge row %d must contain 场景 and 分型", rowNumber)
|
||
}
|
||
result = append(result, row)
|
||
}
|
||
if err := iterator.Error(); err != nil {
|
||
return nil, fmt.Errorf("iterate pet knowledge: %w", err)
|
||
}
|
||
if len(result) == 0 {
|
||
return nil, fmt.Errorf("pet knowledge contains no data")
|
||
}
|
||
return result, nil
|
||
}
|
||
|
||
func excelValue(values []string, index int) string {
|
||
if index >= len(values) {
|
||
return ""
|
||
}
|
||
return strings.TrimSpace(values[index])
|
||
}
|
||
|
||
func upsertPetKnowledge(tx *gorm.DB, tenantID, scenarioID uint64, rows []petKnowledgeRow) error {
|
||
type itemDefinition struct {
|
||
name, typeName string
|
||
content map[string]interface{}
|
||
}
|
||
items := map[string]itemDefinition{}
|
||
type relationDefinition struct{ from, relation, to string }
|
||
relations := map[relationDefinition]bool{}
|
||
for _, row := range rows {
|
||
symptomKey := petKnowledgeKey("symptom", row.Symptom)
|
||
diseaseKey := petKnowledgeKey("disease", row.Disease)
|
||
items[symptomKey] = itemDefinition{name: row.Symptom, typeName: "symptom"}
|
||
items[diseaseKey] = itemDefinition{name: row.Disease, typeName: "disease"}
|
||
relations[relationDefinition{symptomKey, "possible_disease", diseaseKey}] = true
|
||
for index, template := range []string{
|
||
"结合客户描述，目前更符合“%s”这一分型。建议先向客户说明判断依据，再介绍对应方案。",
|
||
"针对“%s”，这边建议按下面的方案进行护理和商品搭配；如症状持续或加重，应及时就医。",
|
||
} {
|
||
copyName := fmt.Sprintf("%s推荐话术%d", row.Disease, index+1)
|
||
copyKey := petKnowledgeKey("copy", copyName)
|
||
items[copyKey] = itemDefinition{name: copyName, typeName: "copy", content: map[string]interface{}{"template": fmt.Sprintf(template, row.Disease)}}
|
||
relations[relationDefinition{diseaseKey, "recommended_copy", copyKey}] = true
|
||
}
|
||
if row.Plan != "" {
|
||
planKey := petKnowledgeKey("plan", row.Plan)
|
||
items[planKey] = itemDefinition{name: row.Plan, typeName: "plan"}
|
||
relations[relationDefinition{diseaseKey, "recommended_plan", planKey}] = true
|
||
// The current SOP view expands one relation level from a symptom.
|
||
relations[relationDefinition{symptomKey, "recommended_plan", planKey}] = true
|
||
}
|
||
if row.SKUCode != "" {
|
||
productName := row.ProductName
|
||
if productName == "" {
|
||
productName = row.SKUCode
|
||
}
|
||
productKey := petKnowledgeKey("product", row.SKUCode)
|
||
items[productKey] = itemDefinition{name: productName, typeName: "product", content: map[string]interface{}{"sku_code": row.SKUCode, "product_name": productName}}
|
||
relations[relationDefinition{diseaseKey, "recommended_product", productKey}] = true
|
||
}
|
||
}
|
||
|
||
keys := make([]string, 0, len(items))
|
||
for key := range items {
|
||
keys = append(keys, key)
|
||
}
|
||
sort.Strings(keys)
|
||
ids := make(map[string]uint64, len(keys))
|
||
for order, key := range keys {
|
||
definition := items[key]
|
||
payload := map[string]interface{}{"source": petKnowledgeSource}
|
||
for name, value := range definition.content {
|
||
payload[name] = value
|
||
}
|
||
content, _ := json.Marshal(payload)
|
||
row := model.KnowledgeItem{TenantID: tenantID, ScenarioID: scenarioID, ItemKey: key, Name: definition.name, Type: definition.typeName, Content: datatypes.JSON(content), Status: "active", SortOrder: 1000 + order}
|
||
if err := tx.Where("tenant_id = ? AND scenario_id = ? AND item_key = ?", tenantID, scenarioID, key).Assign(row).FirstOrCreate(&row).Error; err != nil {
|
||
return fmt.Errorf("upsert imported knowledge item %s: %w", key, err)
|
||
}
|
||
ids[key] = row.ID
|
||
}
|
||
|
||
relationList := make([]relationDefinition, 0, len(relations))
|
||
for relation := range relations {
|
||
relationList = append(relationList, relation)
|
||
}
|
||
sort.Slice(relationList, func(i, j int) bool {
|
||
left, right := relationList[i], relationList[j]
|
||
return left.from+left.relation+left.to < right.from+right.relation+right.to
|
||
})
|
||
for order, definition := range relationList {
|
||
row := model.KnowledgeRelation{TenantID: tenantID, ScenarioID: scenarioID, FromKnowledgeID: ids[definition.from], RelationType: definition.relation, ToKnowledgeID: ids[definition.to], Condition: datatypes.JSON([]byte(`{}`)), SortOrder: 1000 + order}
|
||
if err := tx.Where("scenario_id = ? AND from_knowledge_id = ? AND relation_type = ? AND to_knowledge_id = ?", scenarioID, row.FromKnowledgeID, row.RelationType, row.ToKnowledgeID).Assign(row).FirstOrCreate(&row).Error; err != nil {
|
||
return fmt.Errorf("upsert imported knowledge relation: %w", err)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func petKnowledgeKey(typeName, name string) string {
|
||
digest := sha256.Sum256([]byte(typeName + "\x00" + strings.TrimSpace(name)))
|
||
return "xlsx_" + typeName + "_" + hex.EncodeToString(digest[:6])
|
||
}
|