liulei/baseapi
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of e.coding.net:rosydev/baseapi

Browse Source
This commit is contained in:
邹宗楠
2023-06-28 09:45:13 +08:00
parent c13ba506a0 14fdcb1e1b
commit ce2042dd6f
159 changed files with 7356 additions and 468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
platformapi/mtwmapi/callback.go
View File

@@ -1,6 +1,7 @@
package mtwmapi
import (
"encoding/json"
"net/http"
"net/url"
"strings"
@@ -148,3 +149,42 @@ func (a *API) GetRefundSkuDetailFromMsg(msg *CallbackMsg) (refundSkuDetail []*Re
utils.UnmarshalUseNumber([]byte(msg.FormData.Get("food")), &refundSkuDetail)
return refundSkuDetail
}
//GetIMCallbackMsg 单独处理im回调
func (a *API) GetIMCallbackMsg(request *http.Request) (msg *ImCallbackMsg, callbackResponse *CallbackResponse) {
var (
err = request.ParseForm()
pushContent PushContentReq
tData string
)
msg = &ImCallbackMsg{}
msg.FormData = make(url.Values)
if err == nil {
data := utils.URLValues2Map(request.Form)
if dataSign, ok := data[signKey]; ok {
for k, v := range data {
if k == "push_content" {
//tData, _ = json.Marshal(v)
tData = v.(string)
continue
}
msg.FormData.Set(k, v.(string))
}
msg.Timestamp = utils.Str2Int(msg.FormData.Get("timestamp"))
msg.Sig = dataSign.(string)
msg.AppID = msg.FormData.Get("app_id")
if err = json.Unmarshal([]byte(tData), &pushContent); err == nil {
msg.PushContent = pushContent
}
//if err = utils.Map2StructByJson(tData, &pushContent, true); err == nil {
// msg.PushContent = pushContent
//}
} else {
callbackResponse = SuccessResponse
}
} else {
baseapi.SugarLogger.Warnf("mtwm GetCallbackMsg ParseForm failed with error:%v", err)
callbackResponse = Err2CallbackResponse(err, "")
}
return msg, callbackResponse
}

57
platformapi/mtwmapi/im.go
View File

@@ -1,5 +1,7 @@
package mtwmapi
import "net/url"
const (
MsgSourceStore = 1 //商家
MsgSourceUser = 2 //用户
@@ -10,7 +12,7 @@ const (
MsgTypeOrderCard = 5 //订单卡片
)
//单聊信息体
// SingleChat 单聊信息体
type SingleChat struct {
AppID int `json:"app_id"` //应用标识
AppPoiCode string `json:"app_poi_code"` //门店标识
@@ -24,22 +26,65 @@ type SingleChat struct {
AppSpuCodes string `json:"app_spu_codes"` //开放平台侧商品标识（无须加密）
}
//获取长链接token返回参数
// GetConnTokenResp 获取长链接token返回参数
type GetConnTokenResp struct {
ConnectionToken string `json:"connectionToken"` //建立长连接的token
UserCount int `json:"userCount"` //30分钟内，消息发送失败的用户数
AppKey string `json:"appKey"` //建立长连接的appkey
}
//获取长连接的token
//https://developer.waimai.meituan.com/home/docDetail/461
// ImCallbackMsg im消息回调参数
type ImCallbackMsg struct {
Timestamp int `json:"timestamp"` //调用接口时的时间戳，即当前时间戳（当前距离Epoch（1970年1月1日) 以秒计算的时间，即unix - timestamp），注意传输时间戳与当前北京时间前后相差不能超过10分钟
AppID string `json:"app_id"`
Sig string `json:"sig"`
FormData url.Values
BizType int `json:"biz_type"` //业务类型字段：1：单聊，2：群聊
PushContent interface{} `json:"push_content"` //消息体详细内容
}
// PushContentReq msgSend商家发送IM消息
type PushContentReq struct {
AppID int `json:"app_id"` //美团分配给APP方的id
AppPoiCode string `json:"app_poi_code"` //APP方门店id，最长不超过128个字符
MsgID int `json:"msg_id"` //消息id，确保消息唯一性，发送消息时，为三方的消息id，接收消息时，为美团的消息id
MsgContent string `json:"msg_content"` //消息内容，需要进行加密。加密方式：使用AES加密算法，加密解密的秘钥取自开放平台APP的secret的前16位，请自行截取。 加密工具：http://tool.chacuo.net/cryptaes
MsgSource int `json:"msg_source"` //消息发送方，1：商家，2：用户
MsgType int `json:"msg_type"` //消息类型，1：文字，2：图片，3：语音，注意b2c不支持语音，4：商品卡片，发送商品卡片类型则不关注msg_content，5：订单卡片类型商家只能接收消息，不支持给用户发送消息，只支持单聊 11：群文字，12：群图片，13：群语音，注意b2c不支持语音，14：群商品卡片 其中商品卡片单次最多传7个商品
Cts int `json:"cts"` //消息发送时间,10位时间戳
//非必填
OpenUserID int `json:"open_user_id"` //用户id，单聊时必传
OrderID int `json:"order_id"` //订单id
GroupID int `json:"group_id"` //群聊id，发送群聊消息时必传
AppSpuCodes string `json:"app_spu_codes"` //开放平台侧商品标识（无须加密）
}
type PushContentResp struct {
ResultCode int `json:"result_code"` //1-全部操作成功，查询到的数据在data字段中；2-部分成功，成功的数据存储在data字段中，失败的数据存在error_list字段中；3-全部操作失败，失败的数据存在error_list字段中；4-请求失败，一般为签名或限流问题，关注error字段中的具体描述即可
ErrorList []ErrorList `json:"error_list"` //返回失败原因，根据失败原因判断是否重发消息
}
type ErrorList struct {
Code int `json:"code"` //错误码
Msg string `json:"msg"` //错误描述
}
// MsgSend 商家发送IM消息 https://open-shangou.meituan.com/home/docDetail/10087
func (a *API) MsgSend(pushContent string) (interface{}, error) {
retVal, err := a.AccessAPI("ecommerce/IM/msgSend", false, map[string]interface{}{
"push_content": pushContent,
})
//fmt.Println(retVal)
return retVal, err
}
// GetConnectionToken 获取长连接的token https://developer.waimai.meituan.com/home/docDetail/461
func (a *API) GetConnectionToken() (retVal interface{}, err error) {
retVal, err = a.AccessAPI("wm/IM/getConnectionToken", false, nil)
return retVal, err
}
//设置消息已读
//https://open-shangou.meituan.com/home/docDetail/465
// MsgRead 设置消息已读 https://open-shangou.meituan.com/home/docDetail/465
func (a *API) MsgRead(appPoiCode string, msgID, openUserID int) error {
_, err := a.AccessAPI("/wm/IM/msgRead", false, map[string]interface{}{
"app_poi_code": appPoiCode,

171
platformapi/mtwmapi/im_server.go
View File

@@ -1,171 +0,0 @@
package mtwmapi
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/base64"
"errors"
"io"
"log"
"sync"
)
//ip配置信息
type global struct {
LocalHost string //本机内网IP
RemoteHost string //远程端IP
RemotePort string //远程端口
ServerList map[string]string
ServerListLock sync.RWMutex
}
type commonConf struct {
HttpPort string
RPCPort string
Cluster bool
CryptoKey string
}
var (
GlobalSetting = &global{}
CommonSetting = &commonConf{
HttpPort: "6000",
RPCPort: "7000",
Cluster: false,
CryptoKey: "Adba723b7fe06819",
}
)
/*
以下为clientID相关逻辑
*/
//对称加密IP和端口，当做clientId
func GenClientId() string {
raw := []byte(GlobalSetting.LocalHost + ":" + CommonSetting.RPCPort)
//raw := []byte(hostStr)
str, err := Encrypt(raw, []byte(CommonSetting.CryptoKey))
if err != nil {
log.Fatal(err)
}
return str
}
func Encrypt(rawData, key []byte) (string, error) {
data, err := aesCBCEncrypt(rawData, key)
if err != nil {
return "", err
}
return base64.StdEncoding.EncodeToString(data), nil
}
//AES加密
func aesCBCEncrypt(rawData, key []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return []byte{}, err
}
//填充原文
blockSize := block.BlockSize()
rawData = pKCS7Padding(rawData, blockSize)
//初始向量IV必须是唯一，但不需要保密
cipherText := make([]byte, blockSize+len(rawData))
//block大小 16
iv := cipherText[:blockSize]
if _, err := io.ReadFull(rand.Reader, iv); err != nil {
return []byte{}, err
}
//block大小和初始向量大小一定要一致
mode := cipher.NewCBCEncrypter(block, iv)
mode.CryptBlocks(cipherText[blockSize:], rawData)
return cipherText, nil
}
func DecryptDESECB(d, key []byte) string {
data, err := base64.StdEncoding.DecodeString(string(d))
if err != nil {
return ""
}
block, err := aes.NewCipher(key)
if err != nil {
return ""
}
bs := block.BlockSize()
if len(data)%bs != 0 {
return ""
}
out := make([]byte, len(data))
dst := out
for len(data) > 0 {
block.Decrypt(dst, data[:bs])
data = data[bs:]
dst = dst[bs:]
}
out = PKCS5UnPadding(out)
return string(out)
}
func PKCS5UnPadding(origData []byte) []byte {
length := len(origData)
unpadding := int(origData[length-1])
return origData[:(length - unpadding)]
}
func Decrypt(rawData string, key []byte) (string, error) {
data, err := base64.StdEncoding.DecodeString(rawData)
if err != nil {
return "", err
}
dnData, err := aesCBCDncrypt(data, key)
if err != nil {
return "", err
}
return string(dnData), nil
}
//AES解密
func aesCBCDncrypt(encryptData, key []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return []byte{}, err
}
blockSize := block.BlockSize()
if len(encryptData) < blockSize {
return []byte{}, errors.New("ciphertext too short")
}
iv := encryptData[:blockSize]
encryptData = encryptData[blockSize:]
if len(encryptData)%blockSize != 0 {
return []byte{}, errors.New("ciphertext is not a multiple of the block size")
}
mode := cipher.NewCBCDecrypter(block, iv)
mode.CryptBlocks(encryptData, encryptData)
//解填充
encryptData, err = pKCS7UnPadding(encryptData)
return encryptData, err
}
func pKCS7Padding(ciphertext []byte, blockSize int) []byte {
padding := blockSize - len(ciphertext)%blockSize
padText := bytes.Repeat([]byte{byte(padding)}, padding)
return append(ciphertext, padText...)
}
func pKCS7UnPadding(origData []byte) ([]byte, error) {
length := len(origData)
unPadding := int(origData[length-1])
if length-unPadding < 0 || length-unPadding > len(origData) {
return nil, errors.New("unPadding error")
}
return origData[:(length - unPadding)], nil
}

308
platformapi/mtwmapi/im_test.go
View File

@@ -3,13 +3,7 @@ package mtwmapi
import (
"encoding/json"
"fmt"
"git.rosy.net.cn/baseapi/utils"
"github.com/gazeboxu/mapstructure"
"github.com/go-redis/redis"
"github.com/gorilla/websocket"
"io"
"net/http/httptest"
"sync"
"testing"
"time"
)
@@ -25,46 +19,6 @@ const (
TestWssUrl1 = "wss://www-jxgy.jxc4.com:443/v2/im/StartWebSocket"
)
type ClientManager struct {
ClientIdMap map[string]*Client // 全部的连接
ClientIdMapLock sync.RWMutex // 读写锁
Connect chan *Client // 连接处理
DisConnect chan *Client // 断开连接处理
GroupLock sync.RWMutex
Groups map[string][]string
//SystemClientsLock sync.RWMutex
//SystemClients map[string][]string
Clients map[string]*Client // 保存连接
Accounts map[string][]string // 账号和连接关系,map的key是账号id即：AccountId，这里主要考虑到一个账号多个连接
mu *sync.Mutex
}
var Manager = NewClientManager()
func NewClientManager() (clientManager *ClientManager) {
clientManager = &ClientManager{
Accounts: make(map[string][]string),
ClientIdMap: make(map[string]*Client, 100),
Connect: make(chan *Client, 10000),
DisConnect: make(chan *Client, 10000),
mu: new(sync.Mutex),
}
return
}
var RegisterChan = make(chan *Client, 100)
type Client struct {
ID string // 连接ID
AccountId string // 账号id, 一个账号可能有多个连接
Socket *websocket.Conn // 连接
HeartbeatTime int64 // 前一次心跳时间
}
var rdb = redis.NewClient(&redis.Options{
//Addr: "www.jxc4.com:6379",
//Password: "",
@@ -73,249 +27,27 @@ var rdb = redis.NewClient(&redis.Options{
DB: 0,
})
type TestStr struct {
VendorID int `json:"vendorID"` //平台品牌 10-美团 11-饿了么
UserID int `json:"userID"` //用户ID
NewMessageNum int `json:"NewMessageNum"` //新消息数量
LatestMsg string `json:"latestMsg"` //最新一条消息
LatestTime int `json:"latestTime"` //最新一条消息发送时间
func TestSendMsg(t *testing.T) {
data := PushContentReq{
AppID: 589,
AppPoiCode: "8694203",
MsgID: 20230615,
MsgContent: "QYEyt4edHFiW0Fg0iKqeSKZ+Dab9zKJWSLwQuE38J+XL/1BUIwkqy3sf3E9lOK77",
MsgSource: 1,
MsgType: 1,
Cts: int(time.Now().Unix()),
OpenUserID: 12248014636,
}
dataMar, err := json.Marshal(data)
fmt.Println(string(dataMar))
ret, err := api.MsgSend(string(dataMar))
fmt.Println(ret, err)
}
func TestCacher_RPush(t *testing.T) {
//ans := TestStr{
// VendorID: 22,
// UserID: 2222222222,
// NewMessageNum: 222,
// LatestMsg: "22222222222",
// LatestTime: 22222222222,
//}
//str, _ := json.Marshal(ans)
//err := rdb.RPush("test", string(str))
keys := []string{"589:7954977:10", "test"}
retVal := make(map[string][]interface{}, 0)
for _, key := range keys {
temp := rdb.LRange(key, 0, -1).Val()
for _, v := range temp {
retVal[key] = append(retVal[key], v)
}
}
fmt.Printf("%s", utils.Format4Output(retVal, false))
//if err != nil {
// fmt.Print(err)
//}
}
//测试心跳
func TestHeartCheck(t *testing.T) {
var clientID = make(map[string]*websocket.Conn)
//conn, resp, err := websocket.DefaultDialer.Dial(TestMTIMPushUrl, nil)
//str := "~#HHhehHBBB#~"
//data := []byte(str)
conn1, resp1, err1 := websocket.DefaultDialer.Dial(TestMTIM4123, nil)
fmt.Println(conn1, resp1, err1)
clientID["1"] = conn1
conn, resp, err := websocket.DefaultDialer.Dial(TestMTIM589, nil)
clientID["2"] = conn
fmt.Println(conn, resp, err)
if err != nil || resp.StatusCode != 101 {
fmt.Printf("连接失败：%v http响应不成功", err)
}
//关闭
defer func(conn *websocket.Conn) {
err := conn.Close()
if err != nil {
return
}
}(conn)
if err := conn.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(time.Second)); err != nil {
fmt.Println(err)
}
//err = conn.WriteMessage(websocket.TextMessage, data)
//if err != nil {
// fmt.Println(err)
//}
for {
_, msg, err := conn.ReadMessage()
temp := string(msg)
if err != nil || temp != "HB" {
break
}
fmt.Printf("%s receive: %s\n", conn.RemoteAddr(), string(msg))
func TestMashal(t *testing.T) {
var pushContent = PushContentReq{}
str := "{\"app_id\":589,\"app_poi_code\":\"8694203\",\"msg_id\":20230615,\"msg_content\":\"3/ SR3dQEf/G7nBfw1K3UN6UaYlCFaxKmbS76MPuJ9w=\",\"msg_source\":1,\"msg_type\":1,\"cts\":1686902500,\"open_user_id\":12248014636,\"order_id\":0,\"group_id\":0,\"app_spu_codes\":\"\"}"
if err := json.Unmarshal([]byte(str), &pushContent); err == nil {
fmt.Println(pushContent)
}
}
func TestGetConnectionToken(t *testing.T) {
resp, err := api.GetConnectionToken()
if err != nil {
t.Fatal(err)
}
retVal := GetConnTokenResp{}
err = mapstructure.Decode(resp, &retVal)
fmt.Println(err)
fmt.Println(utils.Format4Output(retVal, false))
}
//解密测试
func TestAesCBCDecrypt(t *testing.T) {
secret := "a81eb3df418d83d6a1a4b7c572156d2f"
key := secret[:16]
str := "qodhoVd4IGtgPKrvYwq6QrzBecJZkeSUPYR88iGRUsCRFmCFxDHpUhqsbBztNXQx"
//str := "Vv+Y/K8vfS42W+P7xq26aIb6uoaG/nL0ZoMMXpitc5QQ3XJm3Roh10NuSoojYrG/3JZwbzgtYA+kBvodoY2eJV00f9MBY+kLkxToP+aSofsYva9tHbipvjVtexebc+eP7aQMtzbwU4BNNnuRG6e7TkXP+BLdtiGsyvHolGfky+p2fZgWes9R6JIxkuRCXW/yBhUo8F+wWCZ2YQl/szp5lHJ3cmneD6cwem36E0FBcvxZNB9an4pRkBrqi1p43V8QBLO719oXkQ+dqTqJMi1/xDSBrCDYN8QORnARP8+j1oDuqE34Kklcse4WL9rwTJ2sOmOu/O2h6Gx3ZaFaMaWRXBDYv8JpzTZjCbRrLSENlEHTof29BmvXTJ0QZ7qi6iAD"
data, err := Decrypt(str, []byte(key))
//data, err := DecryptAES(key, str)
fmt.Println(data)
fmt.Println(err)
}
var wsList []*websocket.Conn
type RetData struct {
Code int `json:"code"` //响应code
Msg string `json:"msg"` //响应msg success/fail
Data interface{} `json:"data"` //信息
}
func TestWebSocketClient(t *testing.T) {
var retData RetData
retData.Code = 0
retData.Msg = "success"
retData.Data = "发送信息成功"
retJson, _ := json.Marshal(retData)
str := string(retJson)
w := httptest.NewRecorder()
w.Header().Set("Content-Type", "application/json; charset=utf-8")
_, _ = io.WriteString(w, str)
return
}
func TestPUSH(t *testing.T) {
key := "589:7954977:10"
rdb.RPush(key, "1111111111")
//rdb.RPush(key, "{\"vendorID\":10,\"userID\":11158569333,\"NewMessageNum\":3,\"latestMsg\":\"hhhhhhhhhhh\",\"latestTime\":1681983980}")
rdb.RPush(key, "{\"vendorID\":10,\"userID\":11158569333,\"NewMessageNum\":3,\"latestMsg\":\"oooooooooo\",\"latestTime\":1681983980}")
rdb.RPush(key, "2222222222222")
rdb.RPush(key, "{\"vendorID\":10,\"userID\":11158569333,\"NewMessageNum\":4,\"latestMsg\":\"成功插入新数据，看下cnt\",\"latestTime\":1681983980}")
rdb.RPush(key, "{\"vendorID\":10,\"userID\":11158569333,\"NewMessageNum\":5,\"latestMsg\":\"成功插入新数据，看下cnt\",\"latestTime\":1681983980}")
}
//用户消息列表
type UserMessageList struct {
VendorID int `json:"vendorID"` //平台品牌 10-美团 11-饿了么
UserID int `json:"userID"` //用户ID
NewMessageNum int `json:"NewMessageNum"` //新消息数量
LatestMsg string `json:"latestMsg"` //最新一条消息
LatestTime int `json:"latestTime"` //最新一条消息发送时间
}
func TestNewRedis(t *testing.T) {
var (
err error
flag = 11158569333
key = "589:7954977:10"
temp = UserMessageList{}
)
if n := rdb.Exists(key).Val(); n > 0 {
s2 := rdb.LRange(key, 0, -1).Val()
for i := 0; i < len(s2); i++ {
v := UserMessageList{}
_ = json.Unmarshal([]byte(s2[i]), &v)
if v.UserID == flag {
//删除此条数据
err = rdb.LSet(key, int64(i), "del").Err()
err = rdb.LRem(key, 0, "del").Err()
s2 = append(s2[:i], s2[i+1:]...)
i--
//cnt=0 重新赋值
temp = UserMessageList{
VendorID: v.VendorID,
UserID: v.UserID,
NewMessageNum: 0,
LatestMsg: v.LatestMsg,
LatestTime: v.LatestTime,
}
}
}
str, _ := json.Marshal(temp)
err = rdb.RPush(key, str).Err()
}
fmt.Print(err)
//s2 := rdb.LRange(key, 0, -1).Val()
//fmt.Printf("before len %d\n", len(s2))
//fmt.Printf("before ans %s\n", s2)
//cnt := 0
//n := rdb.Exists(key).Val()
//if n > 0 {
// for i := 0; i < len(s2); i++ {
// v := UserMessageList{}
// _ = json.Unmarshal([]byte(s2[i]), &v)
// if v.UserID == flag {
// rdb.LSet(key, int64(i), "del")
// rdb.LRem(key, 0, "del")
// s2 = append(s2[:i], s2[i+1:]...)
// i--
// if v.NewMessageNum == 0 { //目前为首条
// cnt++ //赋值1
// } else {
// cnt = v.NewMessageNum
// }
// }
// }
//}
//fmt.Printf("after cnt %d\n", cnt)
//fmt.Printf("after len %d\n", len(s2))
//fmt.Printf("after ans %s\n", s2)
////存入flag数据
//ans := UserMessageList{
// VendorID: 10,
// UserID: 11158569333,
// NewMessageNum: cnt,
// LatestMsg: "成功插入新数据，看下cnt",
// LatestTime: 1681983980,
//}
//param, _ := json.Marshal(ans)
//rdb.RPush(key, param)
}
// 根据账号获取连接
func TestGetClient(t *testing.T) {
accountId := "QW+r2FtsRKGGLJnlgyDNlChzcKcSZ8Kfgh0qw//ONuQCDKzky4x+nlbnx3k1JX13"
clients := make([]*Client, 0)
Manager.mu.Lock()
defer Manager.mu.Unlock()
if len(Manager.Accounts[accountId]) > 0 {
for _, clientId := range Manager.Accounts[accountId] {
if c, ok := Manager.Clients[clientId]; ok {
clients = append(clients, c)
}
}
}
fmt.Printf(utils.Format4Output(clients, false))
}
func TestMal(t *testing.T) {
}
func TestGetWayBillFee(t *testing.T) {
//order, _ := api.OrderGetOrderDetail(1100486451772280163, false)
//globals.SugarLogger.Debugf("order:==%s", utils.Format4Output(order, false)) 2002
api.GetWayBillFee("1100486451772280163", 2)
api.GetWayBillFee("1100486451772280163", 1)
}
// 商家没有接入众包配送,无法进行众包配送相关操作
func TestGetShippingFeeList(t *testing.T) {
api.GetShippingFeeList("1300486314174032613,1100487300210228389", 1)
api.GetShippingFeeList("1300486314174032613,1100487300210228389", 2)
}

4
platformapi/mtwmapi/mtwmapi_test.go
View File

@@ -20,14 +20,14 @@ func init() {
baseapi.Init(sugarLogger)
// 菜市
// api = New("589", "a81eb3df418d83d6a1a4b7c572156d2f", "", "")
api = New("589", "a81eb3df418d83d6a1a4b7c572156d2f", "", "")
// 果园
// api = New("4123", "df2c88338b85f830cebce2a9eab56628", "", "")
//api = New("4123", "df2c88338b85f830cebce2a9eab56628", "", "")
//商超
api = New("5873", "41c479790a76f86326f89e8048964739", "", "token_ovSLnyKTsMNx0RxMzJ1C7w") //token_n4TwqCntWWuvQwAawzxC0w
// api = New("5873", "41c479790a76f86326f89e8048964739", "", "token_ovSLnyKTsMNx0RxMzJ1C7w") //token_n4TwqCntWWuvQwAawzxC0w
cookieStr := `
acctId=57396785; token=0bWbK5VbK50E2BmIhIH2zHB-am_y7mB37yXHm6RLZWx4*; wmPoiId=-1;
`