fix

zhangqian

2024-05-06 8e274b4390a220f91196dc3e33ce98b4333f5e08

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package dingtalkrobot
 
import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "time"
    "wms/pkg/logx"
)
 
type robot struct {
    Key string
    Url string
}
 
var Robot *robot
 
func Init(key, url string) {
    Robot = &robot{Key: key, Url: url}
}
 
type response struct {
    ErrMsg  string `json:"errmsg"`
    ErrCode int    `json:"errcode"`
}
 
func (r *robot) Alarm(title, content string) {
    nanoTimestamp := time.Now().UnixNano()
    ts := nanoTimestamp / int64(time.Millisecond)
    sign, err := r.sign(ts)
    if err != nil {
        logx.Errorf("send alarm message sign failed, err: %v", err)
        return
    }
 
    fullUrl := fmt.Sprintf("%s&timestamp=%v&sign=%s", r.Url, ts, sign)
    msg := NewMarkdownMessage(title, content)
 
    err = r.send(fullUrl, msg)
    if err != nil {
        logx.Errorf("send alarm message failed, err: %v, message: %s", err, msg)
        return
    }
 
    logx.Infof("send alarm message ok, message: %s", msg)
}
 
func (r *robot) sign(ts int64) (string, error) {
    text := fmt.Sprintf("%v\n%v", ts, r.Key)
    h := hmac.New(sha256.New, []byte(r.Key))
    _, err := h.Write([]byte(text))
    if err != nil {
        return "", err
    }
 
    value := h.Sum(nil)
    sign := base64.StdEncoding.EncodeToString(value)
    return url.QueryEscape(sign), nil
}
 
func (r *robot) send(url string, message interface{}) error {
    msgBytes, _ := json.Marshal(message)
    body := bytes.NewBuffer(msgBytes)
 
    resp, err := http.Post(url, "application/json", body)
    if err != nil {
        return fmt.Errorf("error making POST request: %v", err)
    }
    defer resp.Body.Close()
 
    var result response
    bts, err := io.ReadAll(resp.Body)
    if err != nil {
        return fmt.Errorf("error reading response body: %v", err)
    }
 
    err = json.Unmarshal(bts, &result)
    if err != nil {
        return fmt.Errorf("error decoding JSON: %v", err)
    }
 
    if result.ErrCode != 0 {
        return fmt.Errorf("error returned: ErrCode=%d, ErrMsg=%s", result.ErrCode, result.ErrMsg)
    }
    return nil
}