Merge branch 'v2' of http://192.168.0.224:3000/yongxu/sparrow into v2

pkg/models/relation.go

@@ -6,6 +6,7 @@ import "github.com/jinzhu/gorm"
 type Relation struct {
 	gorm.Model
 	RecordId          string `gorm:"column:record_id;size:32;index"`
+	RuleChainId       string `gorm:"column:rule_chain_id;size:32;index;"`
 	FromID            string `gorm:"column:from_id;size:32;index"`         // 起始节点ID
 	FromType          string `gorm:"column:from_type;size:200;"`           // 起始节点类型
 	ToID              string `gorm:"column:to_id;size:32;index"`           // 目标节点Id

pkg/models/rulechain.go

@@ -1,6 +1,7 @@
 package models
 
 import (
+	"errors"
 	"github.com/jinzhu/gorm"
 )
 
@@ -17,3 +18,46 @@ type RuleChain struct {
 	Intro           string `gorm:"column:intro"`              //描述
 	VendorID        string `gorm:"column:vendor_id"`          //厂商ID
 }
+
+type Cells []*Cell
+
+type Cell struct {
+	Id   string   `json:"id"`   // id
+	Data CellData `json:"data"` // 数据
+}
+
+type CellData struct {
+	Name     string     `json:"name"`      // 名称
+	Id       string     `json:"id"`        // id
+	Type     string     `json:"type"`      // 节点类型
+	Desc     string     `json:"desc"`      // 备注
+	ZIndex   string     `json:"ZIndex"`    // 序号
+	Shape    string     `json:"shape"`     // 类型
+	FuncBody string     `json:"func_body"` // 代码
+	Labels   []string   `json:"labels"`
+	Source   string     `json:"source"` // 源节点id
+	Target   string     `json:"target"` // 目标节点id
+	Headers  []*Headers `json:"headers"`
+}
+
+type NodeConfiguration struct {
+	Url       string            `json:"url"`
+	Method    string            `json:"method"`
+	Headers   map[string]string `json:"headers"`
+	Retry     int               `json:"retry"`
+	TimeOut   int               `json:"time_out"`
+	RetryWait int               `json:"retry_wait"`
+}
+
+type Headers struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
+
+// Validate ``
+func (a *RuleChain) Validate() error {
+	if a.Name == "" {
+		return errors.New("规则链名称为空")
+	}
+	return nil
+}

services/knowoapi/controllers/rule_chain.go

@@ -0,0 +1,86 @@
+package controllers
+
+import (
+	"github.com/kataras/iris"
+	"sparrow/pkg/models"
+	"sparrow/services/knowoapi/services"
+)
+
+// RuleChainController ruleChain
+type RuleChainController struct {
+	Ctx     iris.Context
+	Service services.RuleChainService
+	Token   Token
+}
+
+// Post ``
+// POST /rule_chain
+func (a *RuleChainController) Post() {
+	ptl := new(models.RuleChain)
+	if err := parseBody(a.Ctx, ptl); err != nil {
+		badRequest(a.Ctx, err)
+		return
+	}
+	err := a.Service.Create(ptl)
+	if err != nil {
+		responseError(a.Ctx, ErrDatabase, err.Error())
+		return
+	}
+	done(a.Ctx, ptl)
+}
+
+// Delete delete
+// DELETE /rule_chain
+func (a *RuleChainController) Delete() {
+	RuleChain := new(models.RuleChain)
+	if err := parseBody(a.Ctx, RuleChain); err != nil {
+		badRequest(a.Ctx, err)
+		return
+	}
+	if err := a.Service.Delete(RuleChain); err != nil {
+		responseError(a.Ctx, ErrDatabase, err.Error())
+		return
+	}
+	done(a.Ctx, RuleChain)
+}
+
+// Put delPutete
+// Put /rule_chain
+func (a *RuleChainController) Put() {
+	RuleChain := new(models.RuleChain)
+	if err := parseBody(a.Ctx, RuleChain); err != nil {
+		badRequest(a.Ctx, err)
+		return
+	}
+	if err := a.Service.Update(RuleChain); err != nil {
+		responseError(a.Ctx, ErrDatabase, err.Error())
+		return
+	}
+	done(a.Ctx, RuleChain)
+}
+
+// Get get RuleChains
+// GET /rule_chain?pi=&ps=&name
+func (a *RuleChainController) Get() {
+	pi, err := a.Ctx.URLParamInt("pi")
+	if err != nil {
+		badRequest(a.Ctx, err)
+		return
+	}
+	ps, err := a.Ctx.URLParamInt("ps")
+	if err != nil {
+		badRequest(a.Ctx, err)
+		return
+	}
+	name := a.Ctx.URLParam("name")
+	datas, total, err := a.Service.Query(pi, ps, name)
+	if err != nil {
+		responseError(a.Ctx, ErrDatabase, err.Error())
+		return
+	}
+
+	done(a.Ctx, map[string]interface{}{
+		"list":  datas,
+		"total": total,
+	})
+}

services/knowoapi/model/all.go

@@ -13,6 +13,9 @@ type All struct {
 	Alert       *Alert
 	Device      *Device
 	Role        *Role
+	Relation    *Relation
+	RuleChain   *RuleChain
+	RuleNode    *RuleNode
 }
 
 // Init 初始化所有model
@@ -26,5 +29,8 @@ func (a *All) Init(db *gorm.DB) *All {
 	a.Alert = new(Alert).Init(db)
 	a.Device = new(Device).Init(db)
 	a.Role = new(Role).Init(db)
+	a.Relation = new(Relation).Init(db)
+	a.RuleChain = new(RuleChain).Init(db)
+	a.RuleNode = new(RuleNode).Init(db)
 	return a
 }

services/knowoapi/model/relation.go

@@ -0,0 +1,67 @@
+package model
+
+import (
+	"fmt"
+	"sparrow/pkg/models"
+
+	"github.com/jinzhu/gorm"
+)
+
+// Relation model
+type Relation struct {
+	db *gorm.DB
+}
+
+// Init init Relation
+func (a *Relation) Init(db *gorm.DB) *Relation {
+	a.db = db
+	return a
+}
+
+// Query query all roles
+func (a *Relation) Query(pi, ps int, chanId string) (datas []models.Relation, total int, err error) {
+	tx := a.db.Where("1=1")
+	if chanId != "" {
+		tx = tx.Where("rule_chan_id = ?", chanId)
+	}
+	err = tx.Limit(ps).Offset((pi - 1) * ps).Find(&datas).Error
+	err = tx.Model(&models.Relation{}).Count(&total).Error
+	return
+}
+
+// Get get
+func (a *Relation) Get(pi, ps int, chanId string) (datas []models.Relation, total int, err error) {
+	tx := a.db.Where("1=1")
+	if chanId != "" {
+		tx = tx.Where("chan_id = ?", chanId)
+	}
+	err = tx.Limit(ps).Offset((pi - 1) * ps).Find(&datas).Error
+	err = tx.Model(&models.Relation{}).Count(&total).Error
+	return
+}
+
+// Create  create
+func (a *Relation) Create(relation *models.Relation) error {
+	return a.db.Save(relation).Error
+
+}
+
+// Delete delete
+func (a *Relation) Delete(relation *models.Relation) error {
+	cache := getCache()
+	key := fmt.Sprintf("Relation:%d", relation.ID)
+	if _, ok := cache.Get(key); ok {
+		cache.Delete(key)
+	}
+	return a.db.Delete(relation).Error
+}
+
+func (a *Relation) DeleteByChainId(relation *models.Relation) error {
+	a.db.Model(&models.Relation{}).Where("rule_chan_id = ?", relation.RuleChainId)
+	return a.db.Delete(relation).Error
+}
+
+// Update update
+func (a *Relation) Update(relation *models.Relation) error {
+	return a.db.Save(relation).Error
+}

services/knowoapi/model/rule_chain.go

@@ -0,0 +1,67 @@
+package model
+
+import (
+	"fmt"
+	"sparrow/pkg/models"
+
+	"github.com/jinzhu/gorm"
+)
+
+// RuleChain model
+type RuleChain struct {
+	db *gorm.DB
+}
+
+// Init init RuleChain
+func (a *RuleChain) Init(db *gorm.DB) *RuleChain {
+	a.db = db
+	return a
+}
+
+// Query query all roles
+func (a *RuleChain) Query(pi, ps int, name string) (datas []models.RuleChain, total int, err error) {
+	tx := a.db.Where("1=1")
+	if name != "" {
+		tx = tx.Where("chan_id like ?", "%"+name+"%")
+	}
+	err = tx.Limit(ps).Offset((pi - 1) * ps).Find(&datas).Error
+	err = tx.Model(&models.RuleChain{}).Count(&total).Error
+	return
+}
+
+// Get 获取数据内容
+func (a *RuleChain) Get(vendorId string, recordId string) (data models.RuleChain, err error) {
+	cache := getCache()
+	key := fmt.Sprintf("ChanId:%s", recordId)
+	if v, ok := cache.Get(key); ok {
+		_d := v.(*models.RuleChain)
+		data = *_d
+	} else {
+		err = a.db.Where("vendor_id = ? and record_id = ?", vendorId, recordId).First(&data).Error
+		if err == nil {
+			cache.Set(key, &data)
+		}
+	}
+	return
+}
+
+// Create 创建
+func (a *RuleChain) Create(ruleChain *models.RuleChain) error {
+	return a.db.Save(ruleChain).Error
+
+}
+
+// Delete delete
+func (a *RuleChain) Delete(ruleChain *models.RuleChain) error {
+	cache := getCache()
+	key := fmt.Sprintf("RuleChain:%d", ruleChain.ID)
+	if _, ok := cache.Get(key); ok {
+		cache.Delete(key)
+	}
+	return a.db.Delete(ruleChain).Error
+}
+
+// Update update
+func (a *RuleChain) Update(ruleChain *models.RuleChain) error {
+	return a.db.Save(ruleChain).Error
+}

services/knowoapi/model/rule_node.go

@@ -0,0 +1,56 @@
+package model
+
+import (
+	"fmt"
+	"sparrow/pkg/models"
+
+	"github.com/jinzhu/gorm"
+)
+
+// RuleNode model
+type RuleNode struct {
+	db *gorm.DB
+}
+
+// Init init RuleNode
+func (a *RuleNode) Init(db *gorm.DB) *RuleNode {
+	a.db = db
+	return a
+}
+
+// Query query all roles
+func (a *RuleNode) Query(pi, ps int, chanId string) (datas []models.RuleNode, total int, err error) {
+	tx := a.db.Where("1=1")
+	if chanId != "" {
+		tx = tx.Where("rule_chan_id = ?", chanId)
+	}
+	err = tx.Limit(ps).Offset((pi - 1) * ps).Find(&datas).Error
+	err = tx.Model(&models.RuleNode{}).Count(&total).Error
+	return
+}
+
+// Create  创建
+func (a *RuleNode) Create(ruleNode *models.RuleNode) error {
+	return a.db.Save(ruleNode).Error
+
+}
+
+// Delete delete
+func (a *RuleNode) Delete(ruleNode *models.RuleNode) error {
+	cache := getCache()
+	key := fmt.Sprintf("RuleNode:%d", ruleNode.ID)
+	if _, ok := cache.Get(key); ok {
+		cache.Delete(key)
+	}
+	return a.db.Delete(ruleNode).Error
+}
+
+func (a *RuleNode) DeleteByChainId(ruleNode *models.RuleNode) error {
+	a.db.Model(&models.RuleNode{}).Where("rule_chan_id = ?", ruleNode.RuleChainID)
+	return a.db.Delete(ruleNode).Error
+}
+
+// Update update
+func (a *RuleNode) Update(ruleNode *models.RuleNode) error {
+	return a.db.Save(ruleNode).Error
+}

services/knowoapi/router.go

@@ -52,6 +52,7 @@ func registerRouters(srv *iris.Application, models *model.All, gen *generator.Ke
 	alertService := services.NewAlertService(models)
 	deviceService := services.NewDeviceService(models)
 	roleService := services.NewRoleService(models)
+	ruleChainService := services.NewRuleChainService(models)
 	v1router := srv.Party("/api/v1", func(ctx iris.Context) {
 		span := opentracing.StartSpan(ctx.Path())
 		defer span.Finish()
@@ -95,5 +96,7 @@ func registerRouters(srv *iris.Application, models *model.All, gen *generator.Ke
 	adminRouter := v1router.Party("/admin", newJWThandle())
 	RoleAPI := mvc.New(adminRouter.Party("/role"))
 	RoleAPI.Register(roleService).Handle(new(controllers.RoleController))
-
+	// ruleChain api
+	RuleChainAPI := mvc.New(adminRouter.Party("/rule_chain"))
+	RuleChainAPI.Register(ruleChainService).Handle(new(controllers.RuleChainController))
 }

services/knowoapi/services/rule_chain.go

@@ -0,0 +1,152 @@
+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  create a alert back a  AlertService interface
+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 {
+	if ruleChain.Configuration != "" {
+		var cells models.Cells
+		err := json.Unmarshal([]byte(ruleChain.Configuration), &cells)
+		if err != nil {
+			return err
+		}
+		nodeMap := make(map[string]models.RuleNode)
+		for _, v := range cells {
+			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 cells {
+			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)
+}