sparrow/pkg/ruleEngine/nodes/dingtalk_robot_node.go

package nodes

import (
	"encoding/json"
	"fmt"
	"github.com/gogf/gf/encoding/gjson"
	"github.com/gogf/gf/os/grpool"
	"net/http"
	"sparrow/pkg/protocol"
	"sparrow/pkg/ruleEngine"
	"sparrow/pkg/server"
	"sparrow/pkg/utils"
	"sync"
)

type DingTalkRobotNode struct {
	pool    *grpool.Pool
	config  *DingTalkRobotNodeConfig
	client  *utils.HttpClient
	bufPool sync.Pool
}

type DingTalkRobotNodeConfig struct {
	WebHook string `json:"webhook"` // webhook
}

func (d *DingTalkRobotNode) Init(ctx ruleEngine.Context, config string) error {
	d.pool = grpool.New(10)
	if config == "" {
		d.config = &DingTalkRobotNodeConfig{
			WebHook: "http://localhost:8899/test",
		}
	} else {
		c := new(DingTalkRobotNodeConfig)
		err := json.Unmarshal([]byte(config), c)
		if err != nil {
			return err
		}
		d.config = c
	}
	client := utils.NewHttpClient()
	client.SetLogger(server.Log)
	d.client = client
	return nil
}

func (d *DingTalkRobotNode) OnMessage(ctx ruleEngine.Context, message *protocol.Message) error {
	body, err := d.newBody(message)
	if body == nil {
		return nil
	} else if err != nil {
		return err
	}
	fmt.Printf("webhook:-----------%s\n", d.config.WebHook)
	req, err := utils.NewRequest("POST", d.config.WebHook, gjson.New(body))
	if err != nil {
		server.Log.Error(err)
		return err
	}
	req.Header.Add("Content-Type", "application/json")
	return d.pool.Add(func() {
		res, err := d.client.Do(req)
		if err != nil {
			server.Log.Errorf("请求出错%s", err.Error())
			return
		}
		if res != nil && res.Response() != nil {
			defer res.Close()
			if res.Response().StatusCode == http.StatusOK {
				ctx.TellSuccess(message)
			}
		}
	})
}

func (d *DingTalkRobotNode) newBody(message *protocol.Message) (body map[string]interface{}, err error) {
	msg := map[string]interface{}{
		"content": message.AlarmMessage,
	}
	body = map[string]interface{}{
		"msgtype": "text",
		"text":    msg,
	}
	fmt.Printf("message222222:-----------%s\n", body)
	return body, nil
}