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/services/knowoapi/model"
)

// 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
	}
	return a.model.RuleChain.Create(ruleChain)
}

func (a ruleChainService) create(ruleChain *models.RuleChain) error {
	fmt.Printf("++++++++++++++++%s+++++++++++++++", ruleChain.Cell)
	if len(ruleChain.Cell) > 0 {
		nodeMap := make(map[string]models.RuleNode)
		for _, v := range ruleChain.Cell {
			if v.Data.Shape != "edge" {
				ruleNode := models.RuleNode{
					Model:       gorm.Model{},
					RecordId:    guid.S(),
					RuleChainID: ruleChain.RecordId,
					Type:        v.Data.Type,
					Name:        v.Data.Name,
					DebugModel:  true,
					Intro:       v.Data.Desc,
				}
				if v.Data.Shape == "input-node" {
					ruleChain.FirstRuleNodeID = ruleNode.RecordId
				}

				var configuration models.NodeConfiguration
				if v.Data.Shape == "action_node" {
					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.Data.Shape == "edge" {
				err := a.model.Relation.Create(&models.Relation{
					RecordId:    guid.S(),
					RuleChainId: ruleChain.RecordId,
					FromID:      nodeMap[v.Data.Source].RecordId,
					FromType:    nodeMap[v.Data.Source].Type,
					ToID:        nodeMap[v.Data.Target].RecordId,
					ToType:      nodeMap[v.Data.Target].Type,
				})
				if err != nil {
					return err
				}
			}
		}
	}
	return nil
}

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

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
	}

	return a.model.RuleChain.Update(ruleChain)
}