ZaneYork
/
wecomchan
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add: Go版新增图片类型的推送消息

This commit is contained in:
fcbhank 2021-08-17 01:55:55 +08:00
parent 6747568425
commit cce2cd3d9b
4 changed files with 296 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -1,3 +1,6 @@
demo.php demo.php
show.php show.php
.DS_Store .DS_Store
.idea
go-wecomchan/wecomchan
go-wecomchan/wecomchan.exe

3
go-wecomchan/Dockerfile
View File

@ -1,5 +1,8 @@
FROM golang:1.16.5-alpine3.13 as gobuilder FROM golang:1.16.5-alpine3.13 as gobuilder
# 替换为国内源
RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.ustc.edu.cn/g' /etc/apk/repositories
ENV GO111MODULE="on" ENV GO111MODULE="on"
ENV GOPROXY="https://goproxy.cn,direct" ENV GOPROXY="https://goproxy.cn,direct"
ENV CGO_ENABLED=0 ENV CGO_ENABLED=0

46
go-wecomchan/README.md
View File

@ -18,15 +18,14 @@ docker构建镜像使用，需要安装docker，不依赖golang以及网络。
修改的sendkey，企业微信公司ID 等默认值为你的企业中的相关信息，如不设置运行时和打包后都可通过环境变量传入。 修改的sendkey，企业微信公司ID 等默认值为你的企业中的相关信息，如不设置运行时和打包后都可通过环境变量传入。
```golang ```golang
var SENDKEY string = GetEnvDefault("SENDKEY", "set_a_sendkey") var Sendkey = GetEnvDefault("SENDKEY", "set_a_sendkey")
var WECOM_CID string = GetEnvDefault("WECOM_CID", "企业微信公司ID") var WecomCid = GetEnvDefault("WECOM_CID", "企业微信公司ID")
var WECOM_SECRET string = GetEnvDefault("WECOM_SECRET", "企业微信应用Secret") var WecomSecret = GetEnvDefault("WECOM_SECRET", "企业微信应用Secret")
var WECOM_AID string = GetEnvDefault("WECOM_AID", "企业微信应用ID") var WecomAid = GetEnvDefault("WECOM_AID", "企业微信应用ID")
var WECOM_TOUID string = GetEnvDefault("WECOM_TOUID", "@all") var WecomToUid = GetEnvDefault("WECOM_TOUID", "@all")
var REDIS_ADDR string = GetEnvDefault("REDIS_ADDR", "localhost:6379") var RedisStat = GetEnvDefault("REDIS_STAT", "OFF")
var REDIS_STAT string = GetEnvDefault("REDIS_STAT", "OFF") var RedisAddr = GetEnvDefault("REDIS_ADDR", "localhost:6379")
var REDIS_PASSWORD string = GetEnvDefault("REDIS_PASSWORD", "") var RedisPassword = GetEnvDefault("REDIS_PASSWORD", "")
``` ```
## 直接使用 ## 直接使用
@ -49,10 +48,12 @@ var REDIS_PASSWORD string = GetEnvDefault("REDIS_PASSWORD", "")
新增打包好的镜像可以直接使用 新增打包好的镜像可以直接使用
`docker pull aozakiaoko/go-wecomchan` - v1_推送文本:`docker pull aozakiaoko/go-wecomchan`
Docker Hub 地址为:[https://hub.docker.com/r/aozakiaoko/go-wecomchan](https://hub.docker.com/r/aozakiaoko/go-wecomchan) Docker Hub 地址为:[https://hub.docker.com/r/aozakiaoko/go-wecomchan](https://hub.docker.com/r/aozakiaoko/go-wecomchan)
- v2_推送文本or图片:`docker pull fcbhank/go-wecomchan`
Docker Hub 地址为:[https://hub.docker.com/r/fcbhank/go-wecomchan](https://hub.docker.com/r/fcbhank/go-wecomchan)
1. 构建镜像 1. 构建镜像
`docker build -t go-wecomchan .` `docker build -t go-wecomchan .`
@ -70,10 +71,12 @@ docker run -dit -e SENDKEY=set_a_sendkey \
-e REDIS_STAT=ON \ -e REDIS_STAT=ON \
-e REDIS_ADDR="localhost:6379" \ -e REDIS_ADDR="localhost:6379" \
-e REDIS_PASSWORD="" \ -e REDIS_PASSWORD="" \
-p 8080:8080 aozakiaoko/go-wecomchan # v1 aozakiaoko/go-wecomchan
# v2 fcbhank/go-wecomchan
-p 8080:8080 go-wecomchan
``` ```
如不使用redis不要传入最后三个关于redis的环境变量 如不使用redis不要传入最后三个关于redis的环境变量(REDIS_STAT|REDIS_ADDR|REDIS_PASSWORD)
4. 环境变量说明 4. 环境变量说明
@ -84,9 +87,9 @@ docker run -dit -e SENDKEY=set_a_sendkey \
|WECOM_SECRET|企业微信应用Secret| |WECOM_SECRET|企业微信应用Secret|
|WECOM_AID|企业微信应用ID| |WECOM_AID|企业微信应用ID|
|WECOM_TOUID|需要发送给的人，详见[企业微信官方文档](https://work.weixin.qq.com/api/doc/90000/90135/90236#%E6%96%87%E6%9C%AC%E6%B6%88%E6%81%AF)| |WECOM_TOUID|需要发送给的人，详见[企业微信官方文档](https://work.weixin.qq.com/api/doc/90000/90135/90236#%E6%96%87%E6%9C%AC%E6%B6%88%E6%81%AF)|
|REDIS_STAT|是否启用redis换缓存token,ON-启用 OFF或空-不启用|
|REDIS_ADDR|redis服务器地址，如不启用redis缓存可不设置| |REDIS_ADDR|redis服务器地址，如不启用redis缓存可不设置|
|REDIS_STAT|是否启用redis换缓存token| |REDIS_PASSWORD|redis的连接密码，如不启用redis缓存可不设置|
|REDIS_PASSWORD|redis的连接密码|
## 使用docker-compose 部署 ## 使用docker-compose 部署
@ -95,9 +98,20 @@ docker run -dit -e SENDKEY=set_a_sendkey \
`docker-compose up -d` `docker-compose up -d`
## 调用方式 ## 调用方式
- v1_推送文本
访问 `http://localhost:8080/wecomchan?sendkey=你配置的sendkey&&msg=需要发送的消息&&msg_type=text` 访问 `http://localhost:8080/wecomchan?sendkey=你配置的sendkey&&msg=需要发送的消息&&msg_type=text`
- v2_推送文本or图片
```bash
# 推送文本消息
curl --location --request GET 'http://localhost:8080/wecomchan?sendkey={你的sendkey}&msg={你的文本消息}&msg_type=text'
# 推送图片消息
curl --location --request POST 'http://localhost:8080/wecomchan?sendkey={你的sendkey}&msg_type=image' \
--form 'media=@"test.jpg"'
```
## 后续预计添加 ## 后续预计添加
* [x] Dockerfile 打包镜像(不依赖网络环境) * [x] Dockerfile 打包镜像(不依赖网络环境)

266
go-wecomchan/wecomchan.go
View File

@ -7,6 +7,7 @@ import (
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"log" "log"
"mime/multipart"
"net/http" "net/http"
"os" "os"
"reflect" "reflect"
@ -15,16 +16,44 @@ import (
"github.com/go-redis/redis/v8" "github.com/go-redis/redis/v8"
) )
var SENDKEY string = GetEnvDefault("SENDKEY", "set_a_sendkey") /*------------------------------- 环境变量配置 begin -------------------------------*/
var WECOM_CID string = GetEnvDefault("WECOM_CID", "企业微信公司ID")
var WECOM_SECRET string = GetEnvDefault("WECOM_SECRET", "企业微信应用Secret") var Sendkey = GetEnvDefault("SENDKEY", "set_a_sendkey")
var WECOM_AID string = GetEnvDefault("WECOM_AID", "企业微信应用ID") var WecomCid = GetEnvDefault("WECOM_CID", "企业微信公司ID")
var WECOM_TOUID string = GetEnvDefault("WECOM_TOUID", "@all") var WecomSecret = GetEnvDefault("WECOM_SECRET", "企业微信应用Secret")
var REDIS_ADDR string = GetEnvDefault("REDIS_ADDR", "localhost:6379") var WecomAid = GetEnvDefault("WECOM_AID", "企业微信应用ID")
var REDIS_STAT string = GetEnvDefault("REDIS_STAT", "OFF") var WecomToUid = GetEnvDefault("WECOM_TOUID", "@all")
var REDIS_PASSWORD string = GetEnvDefault("REDIS_PASSWORD", "") var RedisStat = GetEnvDefault("REDIS_STAT", "OFF")
var RedisAddr = GetEnvDefault("REDIS_ADDR", "localhost:6379")
var RedisPassword = GetEnvDefault("REDIS_PASSWORD", "")
var ctx = context.Background() var ctx = context.Background()
/*------------------------------- 环境变量配置 end -------------------------------*/
/*------------------------------- 企业微信服务端API begin -------------------------------*/
var GetTokenApi = "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=%s&corpsecret=%s"
var SendMessageApi = "https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=%s"
var UploadMediaApi = "https://qyapi.weixin.qq.com/cgi-bin/media/upload?access_token=%s&type=%s"
/*------------------------------- 企业微信服务端API end -------------------------------*/
type Msg struct {
Content string `json:"content"`
}
type Pic struct {
MediaId string `json:"media_id"`
}
type JsonData struct {
ToUser string `json:"touser"`
AgentId string `json:"agentid"`
MsgType string `json:"msgtype"`
DuplicateCheckInterval int `json:"duplicate_check_interval"`
Text Msg `json:"text"`
Image Pic `json:"image"`
}
// GetEnvDefault 获取配置信息，未获取到则取默认值
func GetEnvDefault(key, defVal string) string { func GetEnvDefault(key, defVal string) string {
val, ex := os.LookupEnv(key) val, ex := os.LookupEnv(key)
if !ex { if !ex {
@ -33,76 +62,122 @@ func GetEnvDefault(key, defVal string) string {
return val return val
} }
func praser_json(json_str string) map[string]interface{} { // ParseJson 将json字符串解析为map
var wecom_response map[string]interface{} func ParseJson(jsonStr string) map[string]interface{} {
if string(json_str) != "" { var wecomResponse map[string]interface{}
err := json.Unmarshal([]byte(string(json_str)), &wecom_response) if string(jsonStr) != "" {
err := json.Unmarshal([]byte(string(jsonStr)), &wecomResponse)
if err != nil { if err != nil {
log.Println("生成json字符串错误") log.Println("生成json字符串错误")
} }
} }
return wecom_response return wecomResponse
} }
func get_token(corpid, app_secret string) string { // GetRemoteToken 从企业微信服务端API获取access_token，存在redis服务则缓存
resp, err := http.Get("https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=" + corpid + "&corpsecret=" + app_secret) func GetRemoteToken(corpId, appSecret string) string {
getTokenUrl := fmt.Sprintf(GetTokenApi, corpId, appSecret)
log.Println("getTokenUrl==>", getTokenUrl)
resp, err := http.Get(getTokenUrl)
if err != nil { if err != nil {
log.Println(err) log.Println(err)
} }
defer resp.Body.Close() defer resp.Body.Close()
resp_data, err := ioutil.ReadAll(resp.Body) respData, err := ioutil.ReadAll(resp.Body)
if err != nil { if err != nil {
log.Println(err) log.Println(err)
} }
token_response := praser_json(string(resp_data)) tokenResponse := ParseJson(string(respData))
return token_response["access_token"].(string) log.Println("企业微信获取access_token接口返回==>", tokenResponse)
accessToken := tokenResponse["access_token"].(string)
if RedisStat == "ON" {
log.Println("prepare to set redis key")
rdb := RedisClient()
// access_token有效时间为7200秒(2小时)
set, err := rdb.SetNX(ctx, "access_token", accessToken, 7000*time.Second).Result()
log.Println(set)
if err != nil {
log.Println(err)
}
}
return accessToken
} }
func redis_client() *redis.Client { // RedisClient redis客户端
func RedisClient() *redis.Client {
rdb := redis.NewClient(&redis.Options{ rdb := redis.NewClient(&redis.Options{
Addr: REDIS_ADDR, Addr: RedisAddr,
Password: REDIS_PASSWORD, // no password set Password: RedisPassword, // no password set
DB: 0, // use default DB DB: 0, // use default DB
}) })
return rdb return rdb
} }
func post_msg(text_msg, msg_type, post_url string) string { // PostMsg 推送消息
type msg struct { func PostMsg(postData JsonData, postUrl string) string {
Content string `json:"content"` postJson, _ := json.Marshal(postData)
} log.Println("postJson ", string(postJson))
type JsonData struct { log.Println("postUrl ", postUrl)
Touser string `json:"touser"` msgReq, err := http.NewRequest("POST", postUrl, bytes.NewBuffer(postJson))
Agentid string `json:"agentid"`
Msgtype string `json:"msgtype"`
Text msg `json:"text"`
Duplicate_check_interval int `json:"duplicate_check_interval"`
}
post_data := JsonData{
Touser: WECOM_TOUID,
Agentid: WECOM_AID,
Msgtype: msg_type,
Duplicate_check_interval: 600,
Text: msg{Content: text_msg},
}
post_json, _ := json.Marshal(post_data)
log.Println(string(post_json))
msg_req, err := http.NewRequest("POST", post_url, bytes.NewBuffer(post_json))
if err != nil { if err != nil {
log.Println(err) log.Println(err)
} }
msg_req.Header.Set("Content-Type", "application/json") msgReq.Header.Set("Content-Type", "application/json")
client := &http.Client{} client := &http.Client{}
resp, err := client.Do(msg_req) resp, err := client.Do(msgReq)
if err != nil { if err != nil {
panic(err) log.Fatalln("企业微信发送应用消息接口报错==>", err)
} }
defer msg_req.Body.Close() defer msgReq.Body.Close()
body, _ := ioutil.ReadAll(resp.Body) body, _ := ioutil.ReadAll(resp.Body)
mediaResp := ParseJson(string(body))
log.Println("企业微信发送应用消息接口返回==>", mediaResp)
return string(body) return string(body)
} }
// CheckOrUploadMedia 核对消息类型，如果为图片则上传临时素材并返回mediaId
func CheckOrUploadMedia(msgType string, req *http.Request, accessToken string) string {
if msgType != "image" {
log.Println("消息类型不是图片")
return ""
}
// 企业微信图片上传不能大于2M
_ = req.ParseMultipartForm(2 << 20)
imgFile, imgHeader, err := req.FormFile("media")
log.Printf("文件大小==>%d字节", imgHeader.Size)
if err != nil {
log.Fatalln("图片文件出错==>", err)
return ""
}
buf := new(bytes.Buffer)
writer := multipart.NewWriter(buf)
if createFormFile, err := writer.CreateFormFile("media", imgHeader.Filename); err == nil {
readAll, _ := ioutil.ReadAll(imgFile)
createFormFile.Write(readAll)
}
writer.Close()
uploadMediaUrl := fmt.Sprintf(UploadMediaApi, accessToken, msgType)
log.Println("uploadMediaUrl==>", uploadMediaUrl)
newRequest, _ := http.NewRequest("POST", uploadMediaUrl, buf)
newRequest.Header.Set("Content-Type", writer.FormDataContentType())
log.Println("Content-Type ", writer.FormDataContentType())
client := &http.Client{}
resp, err := client.Do(newRequest)
respData, _ := ioutil.ReadAll(resp.Body)
mediaResp := ParseJson(string(respData))
log.Println("企业微信上传临时素材接口返回==>", mediaResp)
if err != nil {
log.Fatalln("上传临时素材出错==>", err)
return ""
} else {
return mediaResp["media_id"].(string)
}
}
// IsZero 判断企业微信服务端是否正常响应
func IsZero(v interface{}) (bool, error) { func IsZero(v interface{}) (bool, error) {
t := reflect.TypeOf(v) t := reflect.TypeOf(v)
if !t.Comparable() { if !t.Comparable() {
@ -111,49 +186,74 @@ func IsZero(v interface{}) (bool, error) {
return v == reflect.Zero(t).Interface(), nil return v == reflect.Zero(t).Interface(), nil
} }
func main() { // 获取企业微信的access_token
var access_token string func getAccessToken() string {
if REDIS_STAT == "ON" { accessToken := ""
log.Println("从redis获取token") if RedisStat == "ON" {
rdb := redis_client() log.Println("尝试从redis获取token")
vals, err := rdb.Get(ctx, "access_token").Result() rdb := RedisClient()
value, err := rdb.Get(ctx, "access_token").Result()
if err == redis.Nil { if err == redis.Nil {
log.Println("access_token does not exist") log.Println("access_token does not exist, need get it from remote API")
} }
access_token = string(vals) accessToken = value
} }
if access_token == "" { if accessToken == "" {
access_token = get_token(WECOM_CID, WECOM_SECRET) log.Println("get access_token from remote API")
accessToken = GetRemoteToken(WecomCid, WecomSecret)
} else {
log.Println("get access_token from redis")
} }
wecom_chan := func(res http.ResponseWriter, req *http.Request) { return accessToken
post_url := "https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=" + access_token }
req.ParseForm()
// InitJsonData 初始化Json公共部分数据
func InitJsonData(msgType string) JsonData {
return JsonData{
ToUser: WecomToUid,
AgentId: WecomAid,
MsgType: msgType,
DuplicateCheckInterval: 600,
}
}
// 主函数入口
func main() {
// 设置日志内容显示文件名和行号
log.SetFlags(log.LstdFlags | log.Lshortfile)
accessToken := getAccessToken()
wecomChan := func(res http.ResponseWriter, req *http.Request) {
_ = req.ParseForm()
sendkey := req.FormValue("sendkey") sendkey := req.FormValue("sendkey")
if sendkey != SENDKEY { if sendkey != Sendkey {
log.Panicln("sendkey 错误，请检查") log.Panicln("sendkey 错误，请检查")
} }
msg := req.FormValue("msg") msgContent := req.FormValue("msg")
msg_type := req.FormValue("msg_type") msgType := req.FormValue("msg_type")
post_status := post_msg(msg, msg_type, post_url) log.Println("mes_type=", msgType)
log.Println(post_status) mediaId := CheckOrUploadMedia(msgType, req, accessToken)
post_response := praser_json(string(post_status)) log.Println("企业微信上传临时素材接口返回的media_id==>", mediaId)
log.Println(post_response)
errcode := post_response["errcode"] // 准备发送应用消息所需参数
ok, err := IsZero(errcode) postData := InitJsonData(msgType)
if err != nil { postData.Text = Msg{
fmt.Printf("%v", err) Content: msgContent,
} else {
if ok && REDIS_STAT == "ON" {
log.Println("pre to set redis key")
rdb := redis_client()
set, err := rdb.SetNX(ctx, "access_token", access_token, 7000*time.Second).Result()
log.Println(set)
if err != nil {
log.Println(err)
}
}
} }
postData.Image = Pic{
MediaId: mediaId,
}
sendMessageUrl := fmt.Sprintf(SendMessageApi, accessToken)
postStatus := PostMsg(postData, sendMessageUrl)
postResponse := ParseJson(postStatus)
errcode := postResponse["errcode"]
_, err := IsZero(errcode)
if err != nil {
log.Printf("%v", err)
}
res.Header().Set("Content-type", "application/json")
_, _ = res.Write([]byte(postStatus))
} }
http.HandleFunc("/wecomchan", wecom_chan) http.HandleFunc("/wecomchan", wecomChan)
log.Fatal(http.ListenAndServe(":8080", nil)) log.Fatal(http.ListenAndServe(":8080", nil))
} }