MessageCenter/rpc/internal/common/sendWxTmplMsg.go

package common

import (
	"app.yhyue.com/moapp/MessageCenter/entity"
	"app.yhyue.com/moapp/MessageCenter/rpc/internal/config"
	"app.yhyue.com/moapp/MessageCenter/util"
	"app.yhyue.com/moapp/jybase/common"
	dataFormat "app.yhyue.com/moapp/jybase/date"
	m "app.yhyue.com/moapp/jybase/mongodb"
	"app.yhyue.com/moapp/jybase/redis"
	qrpc "app.yhyue.com/moapp/jybase/rpc"
	"encoding/json"
	"fmt"
	"net/url"
	"regexp"
	"strings"
	"time"
)

type WxTmplPush struct {
	MgoId, OpenId, Position string //UserId 用户mgoId, OpenId 微信id, Position 职位id
	Config                  *WxTmplConfig
}

var AllMsgType func() map[string]WxTmplConfig
var allMsgValueKeys = []string{"$class", "$title", "$detail", "$date", "$note"}

type WxTmplConfig struct {
	Name      string //信息名称
	Switch    string //开关
	TmplId    string //微信模版id
	TmplValue string //微信模版
}

const CacheDb = "msgCount"

func MessageType() (func() map[string]WxTmplConfig, []map[string]interface{}) {
	var data []map[string]interface{}
	rData := entity.Mysql.SelectBySql("SELECT * FROM message_column ORDER BY sequence ASC")
	switchName := map[string]WxTmplConfig{}
	if rData != nil && len(*rData) > 0 {
		data = *rData
		for _, mData := range *rData {
			if settingKey, messageName, tmplId, tmplValue := util.ObjToString(mData["switch"]), util.ObjToString(mData["name"]), util.ObjToString(mData["wxtmplId"]), util.ObjToString(mData["wxtmpValue"]); settingKey != "" && messageName != "" && tmplId != "" && tmplValue != "" {
				switchName[settingKey] = WxTmplConfig{
					Name:      messageName,
					Switch:    settingKey,
					TmplId:    tmplId,
					TmplValue: tmplValue,
				}
			}
		}
	}
	return func() map[string]WxTmplConfig {
		return switchName
	}, data
}

var getSendTotalRedisKey = func(uFlag ...string) string {
	if len(uFlag) == 0 { //统计当日信息总发送量
		return fmt.Sprintf("messageCenter_SendWxMsgTotal_%s", time.Now().Format(dataFormat.Date_yyyyMMdd))
	} //统计单用户今日发送量
	return fmt.Sprintf("messageCenter_SendWxMsgTotal_%s_%s", time.Now().Format(dataFormat.Date_yyyyMMdd), uFlag[0])
}

func GetWxTmplConfig(class string) (*WxTmplConfig, error) {
	if val, ok := AllMsgType()[class]; ok {
		return &val, nil
	}
	return nil, fmt.Errorf("未知消息类型")
}

func (stm *WxTmplPush) SendMsg(link, title, detail, date string) error {
	if stm.Config.TmplId == "" || (stm.MgoId != "" && stm.OpenId != "" && stm.Position != "") || link == "" {
		return fmt.Errorf("缺少参数")
	}
	// 校验推送是否开启
	if err := stm.getUserOpenIdAndWxPushState(); err != nil {
		return err
	}
	// 校验发送量及频率
	if err := stm.Check(); err != nil {
		return err
	}
	// 获取消息
	msg, err := stm.getMessage(title, detail, date)
	if err != nil {
		return err
	}
	// 发送信息
	autoLoginHref := fmt.Sprintf("%s/swordfish/SingleLogin?toHref=%s", config.ConfigJson.WxWebdomain, url.QueryEscape(link))
	if _, err := stm.Send(autoLoginHref, msg); err != nil {
		return err
	}
	// 发送数量计数
	stm.IncrCount()
	return nil
}

var (
	regSpecial = regexp.MustCompile(`\\n|\\t|\\'|\\"|\n|\t|\'|\"`)
)

// getMessage 获取消息内容
func (stm *WxTmplPush) getMessage(title, detail, date string) (map[string]*qrpc.TmplItem, error) {
	var formatValue string = stm.Config.TmplValue
	for _, key := range allMsgValueKeys {
		switch key {
		case "$class":
			formatValue = strings.ReplaceAll(formatValue, key, regSpecial.ReplaceAllString(stm.Config.Name, ""))
		case "$title":
			formatValue = strings.ReplaceAll(formatValue, key, regSpecial.ReplaceAllString(title, ""))

		case "$detail":
			formatValue = strings.ReplaceAll(formatValue, key, regSpecial.ReplaceAllString(detail, ""))
			fmt.Println("1", regSpecial.ReplaceAllString(detail, ""))
			fmt.Println("2", regSpecial.ReplaceAllString("这是推送\\n信\\t息的\\n内容", ""))
			fmt.Println("3", detail, "这是推送\\n信\\t息的\\n内容", detail == "这是推送\\n信\\t息的\\n内容")
			fmt.Println(strings.ReplaceAll(formatValue, key, regSpecial.ReplaceAllString(detail, "")))
		case "$date":
			formatValue = strings.ReplaceAll(formatValue, key, regSpecial.ReplaceAllString(date, ""))
		case "$note":
			formatValue = strings.ReplaceAll(formatValue, key, regSpecial.ReplaceAllString(config.ConfigJson.WxTmplConfig.CloseNotice, ""))
		}
	}
	bValue := map[string]*qrpc.TmplItem{}
	fmt.Println("formatValue", formatValue)
	if err := json.Unmarshal([]byte(formatValue), &bValue); err != nil {
		return nil, fmt.Errorf("格式化信息内容异常 %s", err.Error())
	}
	return bValue, nil

}

// Check 校验发送量和频率
func (stm *WxTmplPush) Check() error {
	uCache, allCache := getSendTotalRedisKey(stm.OpenId), getSendTotalRedisKey()
	//校验当日微信模版发送总量
	if total := redis.GetInt(CacheDb, allCache); total > config.ConfigJson.WxTmplConfig.Limit.Total {
		return fmt.Errorf("已达发送总量上限")
	}
	//校验当日单用户发送总量
	if uTotal := redis.GetInt(CacheDb, uCache); uTotal > config.ConfigJson.WxTmplConfig.Limit.OneDayLimit {
		return fmt.Errorf("已达单该用户发送总量上限")
	}
	//校验发送间隔
	if sendWait, _ := redis.Exists(CacheDb, fmt.Sprintf("%s_sendwait", uCache)); sendWait {
		return fmt.Errorf("发送模版消息频繁，稍后重试")
	}
	return nil
}

func (stm *WxTmplPush) IncrCount() {
	uCache, allCache := getSendTotalRedisKey(stm.OpenId), getSendTotalRedisKey() //当日微信模版消息发送总量
	var total int64
	if total = redis.Incr(CacheDb, allCache); total == 1 {
		_ = redis.SetExpire(CacheDb, allCache, 60*60*24)
	}
	if uTotal := redis.Incr(CacheDb, uCache); uTotal == 1 {
		_ = redis.SetExpire(CacheDb, uCache, 60*60*24)
	} //当日用户发送数量
	redis.Put(CacheDb, fmt.Sprintf("%s_sendwait", uCache), 1, config.ConfigJson.WxTmplConfig.Limit.DuringMine*60) //下次发送时间

	for _, num := range config.ConfigJson.WxTmplConfig.Limit.Alert.Nums {
		if total == num {
			util.SendRetryMail(3, strings.Join(config.ConfigJson.WxTmplConfig.Limit.Alert.ToMail, ","), strings.Join(config.ConfigJson.WxTmplConfig.Limit.Alert.ToMail, ","),
				"剑鱼微信模版告警邮件", fmt.Sprintf("今日发送微信模版信息数量已达%d条，总量%d条", total, config.ConfigJson.WxTmplConfig.Limit.Total), entity.GmailAuth)
		}
	}
}

// getUserOpenIdAndWxPushState 查询微信openid微信消息通知状态
// mId mongoUserid、oId 用户openid、pId positionId 用户职位id
func (stm *WxTmplPush) getUserOpenIdAndWxPushState() error {
	uData := func() map[string]interface{} {
		query := map[string]interface{}{}
		if stm.OpenId != "" {
			query["s_m_openid"] = stm.OpenId
		} else if stm.MgoId != "" {
			query["_id"] = m.StringTOBsonId(stm.MgoId)
		} else if stm.Position != "" {
			uInfo := entity.Mysql.SelectBySql("SELECT user_id FROM base_service.base_position WHERE id = ? ", stm.Position)
			if uInfo != nil && len(*uInfo) > 0 {
				if baseUserId := common.Int64All((*uInfo)[0]["user_id"]); baseUserId != 0 {
					query["base_user_id"] = baseUserId
				}
			}
		}
		if len(query) > 0 {
			rData, _ := entity.MQFW.FindOneByField("user", query, fmt.Sprintf(`{"s_m_openid":1,"o_pushset.%s.i_wxpush":1}`, stm.Config.Switch))
			if rData != nil && len(*rData) > 0 {
				return *rData
			}
		}
		return nil
	}()
	if uData == nil {
		return fmt.Errorf("未查询到用户信息")
	}
	stm.OpenId = common.ObjToString(uData["s_m_openid"])
	if stm.OpenId == "" {
		return fmt.Errorf("未查询到用户微信信息")
	}
	if pushSetMap := common.ObjToMap(uData["o_pushset"]); pushSetMap != nil && len(*pushSetMap) > 0 {
		if pushKeyMap := common.ObjToMap((*pushSetMap)[stm.Config.Switch]); pushKeyMap != nil && len(*pushKeyMap) > 0 {
			if common.Int64All((*pushKeyMap)["i_wxpush"]) == 1 {
				return nil
			}
		}
	}
	return fmt.Errorf("未开启推送设置")
}

// Send 发送微信模版消息
func (stm *WxTmplPush) Send(link string, msg map[string]*qrpc.TmplItem) (pushOk bool, err error) {
	return qrpc.WxSendTmplMsg(config.ConfigJson.WxTmplConfig.RpcAddr, &qrpc.WxTmplMsg{
		OpenId:   stm.OpenId,
		TplId:    stm.Config.TmplId,
		TmplData: msg,
		Url:      link,
	})
}