sparrow/services/knowoapi/services/rule_chain.go

package services

import (
	"encoding/json"
	"fmt"
	"github.com/gogf/gf/util/guid"
	"github.com/jinzhu/gorm"
	"sparrow/pkg/models"
	"sparrow/pkg/rpcs"
	"sparrow/pkg/server"
	"sparrow/services/knowoapi/model"
)

var nodeType = map[string]string{
	"MsgTypeFilter":     "MsgTypeFilterNode",
	"MsgTypeSwitchNode": "MsgTypeSwitchNode",
	"JavascriptFilter":  "FilterJavascriptNode",
	"RestApiAction":     "RestApiRequestNode",
}

// RuleChainService 业务接口
type RuleChainService interface {
	Create(*models.RuleChain) error
	Delete(*models.RuleChain) error
	Update(*models.RuleChain) error
	Query(int, int, string) ([]models.RuleChain, int, error)
	Get(vendorId, recordId string) (models.RuleChain, error)
}
type ruleChainService struct {
	model *model.All
}

// NewRuleChainService  new ruleChain service
func NewRuleChainService(model *model.All) RuleChainService {
	return ruleChainService{
		model: model,
	}
}

func (a ruleChainService) Query(pi, ps int, name string) ([]models.RuleChain, int, error) {
	return a.model.RuleChain.Query(pi, ps, name)
}

func (a ruleChainService) Get(vendorId, recordId string) (models.RuleChain, error) {
	return a.model.RuleChain.Get(vendorId, recordId)
}

func (a ruleChainService) Create(ruleChain *models.RuleChain) error {
	ruleChain.RecordId = guid.S()

	err := a.create(ruleChain)
	if err != nil {
		return err
	}

	err = a.model.RuleChain.Create(ruleChain)
	if err != nil {
		return err
	}
	params := rpcs.ArgsRuleChainAct{
		RuleChainId: ruleChain.RecordId,
		VendorId:    ruleChain.VendorID,
	}
	reply := new(rpcs.ReplyEmptyResult)
	err = server.RPCCallByName(nil, rpcs.ControllerName, "Controller.CreateRuleChain", &params, &reply)
	if err != nil {
		server.Log.Errorf("create ruleChan error : %v", err)
	}
	return nil
}

func (a ruleChainService) create(ruleChain *models.RuleChain) error {
	if len(ruleChain.Cell) == 0 {
		return nil
	}
	marshal, _ := json.Marshal(ruleChain.Cell)
	ruleChain.Configuration = fmt.Sprintf("%s", marshal)

	nodeMap := make(map[string]models.RuleNode)
	var inputNodeId string
	for _, v := range ruleChain.Cell {
		if v.Shape != "edge" {
			if v.Shape == "input-node" {
				inputNodeId = v.Source.Cell
				continue
			}
			ruleNode := models.RuleNode{
				Model:       gorm.Model{},
				RecordId:    guid.S(),
				RuleChainID: ruleChain.RecordId,
				Type:        nodeType[v.Data.Type],
				Name:        v.Data.Name,
				DebugModel:  true,
				Intro:       v.Data.Desc,
			}

			switch ruleNode.Type {
			case "MsgTypeSwitchNode":
				ruleNode.Name = "消息类型路由器"
			case "MsgTypeFilter":
				conMap := map[string]interface{}{
					"msg_type": v.Data.MesType,
				}
				marshal, _ := json.Marshal(conMap)
				ruleNode.Configuration = fmt.Sprintf("%s", marshal)

			case "FilterJavascriptNode":
				conMap := map[string]string{
					"func_body": v.Data.FuncBody,
				}
				marshal, _ := json.Marshal(conMap)
				ruleNode.Configuration = fmt.Sprintf("%s", marshal)
			case "RestApiRequestNode":
				configuration := models.NodeConfiguration{
					Url:       v.Data.Url,
					Method:    v.Data.Method,
					Retry:     v.Data.Retry,
					TimeOut:   v.Data.TimeOut,
					RetryWait: v.Data.RetryWait,
					Headers:   make(map[string]interface{}),
				}
				if len(v.Data.Headers) > 0 {
					for _, header := range v.Data.Headers {
						configuration.Headers[header.Key] = header.Value
					}
				}
				marshal, _ := json.Marshal(configuration)
				ruleNode.Configuration = fmt.Sprintf("%s", marshal)
			}

			nodeMap[v.Id] = ruleNode

			err := a.model.RuleNode.Create(&ruleNode)
			if err != nil {
				return err
			}
		}
	}

	for _, v := range ruleChain.Cell {
		if v.Shape == "edge" && v.Source.Cell != inputNodeId {
			err := a.model.Relation.Create(&models.Relation{
				RecordId:    guid.S(),
				RuleChainId: ruleChain.RecordId,
				FromID:      nodeMap[v.Source.Cell].RecordId,
				//FromType:     nodeMap[v.Source.Cell].Type,
				ToID:         nodeMap[v.Target.Cell].RecordId,
				ToType:       nodeMap[v.Target.Cell].Type,
				RelationType: v.Data.Label,
			})
			if err != nil {
				return err
			}
		}
	}

	return nil
}

func (a ruleChainService) Delete(ruleChain *models.RuleChain) error {
	err := a.delete(ruleChain)
	if err != nil {
		return err
	}
	err = a.model.RuleChain.Delete(ruleChain)
	if err != nil {
		return err
	}
	params := rpcs.ArgsRuleChainAct{
		RuleChainId: ruleChain.RecordId,
		VendorId:    ruleChain.VendorID,
	}
	reply := new(rpcs.ReplyEmptyResult)
	err = server.RPCCallByName(nil, rpcs.ControllerName, "Controller.DeleteRuleChain", &params, &reply)
	if err != nil {
		server.Log.Errorf("delete ruleChan error : %v", err)
	}
	return nil
}

func (a ruleChainService) delete(ruleChain *models.RuleChain) error {
	node, _, err := a.model.RuleNode.Query(1, 100, ruleChain.RecordId)
	if err != nil {
		return err
	}
	if len(node) > 0 {
		for _, v := range node {
			_ = a.model.RuleNode.Delete(&v)
		}
	}

	relation, _, err := a.model.Relation.Query(1, 100, ruleChain.RecordId)
	if err != nil {
		return err
	}
	if len(relation) > 0 {
		for _, v := range relation {
			_ = a.model.Relation.DeleteByChainId(&v)
		}
	}
	return nil
}

func (a ruleChainService) Update(ruleChain *models.RuleChain) error {
	err := a.delete(ruleChain)
	if err != nil {
		return err
	}
	err = a.create(ruleChain)
	if err != nil {
		return err
	}

	err = a.model.RuleChain.Update(ruleChain)
	if err != nil {
		return err
	}
	params := rpcs.ArgsRuleChainAct{
		RuleChainId: ruleChain.RecordId,
		VendorId:    ruleChain.VendorID,
	}
	reply := new(rpcs.ReplyEmptyResult)
	err = server.RPCCallByName(nil, rpcs.ControllerName, "Controller.UpdateRuleChain", &params, &reply)
	if err != nil {
		server.Log.Errorf("update ruleChan error : %v", err)
	}
	return nil
}