5148 lines
170 KiB
Go
5148 lines
170 KiB
Go
package clientsdk
|
||
|
||
import (
|
||
"bytes"
|
||
"compress/zlib"
|
||
"crypto/md5"
|
||
"crypto/rand"
|
||
"encoding/base64"
|
||
"encoding/hex"
|
||
"encoding/xml"
|
||
"errors"
|
||
"fmt"
|
||
"html/template"
|
||
"io"
|
||
"io/ioutil"
|
||
"net/http"
|
||
"net/url"
|
||
"regexp"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"xiawan/wx/api/req"
|
||
"xiawan/wx/api/utils"
|
||
"xiawan/wx/api/vo"
|
||
"xiawan/wx/lib"
|
||
|
||
"github.com/gogo/protobuf/proto"
|
||
"github.com/google/uuid"
|
||
"github.com/lunny/log"
|
||
|
||
"xiawan/wx/clientsdk/android"
|
||
"xiawan/wx/clientsdk/baseinfo"
|
||
"xiawan/wx/clientsdk/baseutils"
|
||
"xiawan/wx/clientsdk/cecdh"
|
||
"xiawan/wx/clientsdk/extinfo"
|
||
clientsdk "xiawan/wx/clientsdk/hybrid"
|
||
"xiawan/wx/clientsdk/mmtls"
|
||
"xiawan/wx/protobuf/wechat"
|
||
)
|
||
|
||
// 获取登录二维码 直登
|
||
func SendLoginQRCodeRequestDirect(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
// 重新生成AesKey
|
||
userInfo.SessionKey = baseutils.RandomBytes(16)
|
||
|
||
var request wechat.LoginQRCodeRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// AESKey
|
||
var aesKey wechat.AESKey
|
||
var tmpAesKeyLen = uint32(16)
|
||
aesKey.Len = &tmpAesKeyLen
|
||
aesKey.Key = []byte(userInfo.SessionKey)
|
||
request.Aes = &aesKey
|
||
|
||
// OpCode
|
||
var tmpOpcode = uint32(0)
|
||
request.Opcode = &tmpOpcode
|
||
// 发送请求
|
||
src, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, src, baseinfo.MMRequestTypeGetLoginQRCode, 7)
|
||
// 初始化代理信息
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getloginqrcode", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
userInfo.ClientVersion = baseinfo.ClientVersion
|
||
userInfo.DeviceInfo.DeviceName = baseinfo.IPadDeviceName
|
||
userInfo.DeviceInfo.OsType = baseinfo.DeviceTypeIos
|
||
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendLoginQRCodeRequest 获取登陆二维码 正常
|
||
func SendLoginQRCodeRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
// 重新生成AesKey
|
||
userInfo.SessionKey = baseutils.RandomBytes(16)
|
||
|
||
var request wechat.LoginQRCodeRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// AESKey
|
||
var aesKey wechat.AESKey
|
||
var tmpAesKeyLen = uint32(16)
|
||
aesKey.Len = &tmpAesKeyLen
|
||
aesKey.Key = []byte(userInfo.SessionKey)
|
||
request.Aes = &aesKey
|
||
|
||
// OpCode
|
||
var tmpOpcode = uint32(0)
|
||
request.Opcode = &tmpOpcode
|
||
// 发送请求
|
||
src, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, src, baseinfo.MMRequestTypeGetLoginQRCode, 7)
|
||
// 初始化代理信息
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getloginqrcode", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendLoginQRCodeRequest 获取登陆二维码(绕过验证码)
|
||
func SendLoginQRCodeRequestX(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
// 重新生成AesKey
|
||
userInfo.SessionKey = baseutils.RandomBytes(16)
|
||
|
||
// 构造请求
|
||
var request wechat.LoginQRCodeRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// AESKey
|
||
var aesKey wechat.AESKey
|
||
var tmpAesKeyLen = uint32(16)
|
||
aesKey.Len = &tmpAesKeyLen
|
||
aesKey.Key = []byte(userInfo.SessionKey)
|
||
request.Aes = &aesKey
|
||
|
||
// OpCode
|
||
var tmpOpcode = uint32(0)
|
||
request.Opcode = &tmpOpcode
|
||
// 发送请求
|
||
src, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, src, baseinfo.MMRequestTypeGetLoginQRCode, 7)
|
||
// 初始化代理信息
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getloginqrcode", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendManualAuth 发送ManualAuth请求
|
||
func sendManualAuthByAccountData(userInfo *baseinfo.UserInfo, accountData []byte) (*baseinfo.PackHeader, error) {
|
||
// 打包加密数据
|
||
subHeader := make([]byte, 0)
|
||
tmpBytes := baseutils.Int32ToBytes(uint32(len(accountData)))
|
||
subHeader = append(subHeader, tmpBytes[0:]...)
|
||
|
||
// 获取 deviceDataRequest
|
||
deviceData := GetManualAuthAesReqDataMarshal(userInfo)
|
||
tmpBytes = baseutils.Int32ToBytes(uint32(len(deviceData)))
|
||
subHeader = append(subHeader, tmpBytes[0:]...)
|
||
|
||
// 加密压缩 accountData
|
||
newAccountData := baseutils.CompressAndRsaByVer(accountData, userInfo.GetLoginRsaVer())
|
||
tmpBytes = baseutils.Int32ToBytes(uint32(len(newAccountData)))
|
||
subHeader = append(subHeader, tmpBytes[0:]...)
|
||
subHeader = append(subHeader, newAccountData[0:]...)
|
||
|
||
// 压缩加密 deviceData
|
||
newDeviceData := baseutils.CompressAes(userInfo.SessionKey, deviceData)
|
||
subHeader = append(subHeader, newDeviceData[0:]...)
|
||
|
||
// 发送登陆请求
|
||
sendData := Pack(userInfo, subHeader, baseinfo.MMRequestTypeManualAuth, 17)
|
||
// 初始化代理信息
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/manualauth", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendManualAuthA16发送A16登录请求
|
||
func SendManualAuthA16(userInfo *baseinfo.UserInfo, accountData []byte) (*baseinfo.PackHeader, error) {
|
||
/*req := &wechat.ManualAuthRequest{
|
||
RsaReqData: GetManualAuthRsaReqDataProtobuf(userInfo,userInfo.LoginDataInfo.UserName,userInfo.LoginDataInfo.PassWord),
|
||
AesReqData: GetManualAuthAesReqDataA16Protobuf(userInfo),
|
||
}*/
|
||
// 发送请求
|
||
// 打包加密数据
|
||
subHeader := make([]byte, 0)
|
||
tmpBytes := baseutils.Int32ToBytes(uint32(len(accountData)))
|
||
subHeader = append(subHeader, tmpBytes[0:]...)
|
||
|
||
// 获取 deviceDataRequest
|
||
deviceData := GetManualAuthAesReqDataA16Protobuf(userInfo)
|
||
tmpBytes = baseutils.Int32ToBytes(uint32(len(deviceData)))
|
||
subHeader = append(subHeader, tmpBytes[0:]...)
|
||
|
||
// 加密压缩 accountData
|
||
newAccountData := baseutils.CompressAndRsaByVer(accountData, userInfo.GetLoginRsaVer())
|
||
tmpBytes = baseutils.Int32ToBytes(uint32(len(newAccountData)))
|
||
subHeader = append(subHeader, tmpBytes[0:]...)
|
||
subHeader = append(subHeader, newAccountData[0:]...)
|
||
|
||
// 压缩加密 deviceData
|
||
newDeviceData := baseutils.CompressAes(userInfo.SessionKey, deviceData)
|
||
subHeader = append(subHeader, newDeviceData[0:]...)
|
||
|
||
// 发送登陆请求
|
||
sendData := Pack(userInfo, subHeader, baseinfo.MMRequestTypeManualAuth, 17)
|
||
// 初始化代理信息
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/manualauth", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendManualAuth 发送登陆请求
|
||
func SendManualAuth(userInfo *baseinfo.UserInfo, newpass string, wxid string) (*baseinfo.PackHeader, error) {
|
||
var tmpNid uint32 = 713
|
||
userInfo.EcPublicKey, userInfo.EcPrivateKey = cecdh.GenerateEccKey()
|
||
authRequest := &wechat.ManualAuthAccountRequest{}
|
||
// aes_key
|
||
var aesKey wechat.AESKey
|
||
var tmpAesKeyLen uint32 = 16
|
||
aesKey.Len = &tmpAesKeyLen
|
||
aesKey.Key = []byte(userInfo.SessionKey)
|
||
authRequest.Aes = &aesKey
|
||
|
||
// 其它参数
|
||
var ecdhKey wechat.ECDHKey
|
||
var key wechat.SKBuiltinString_
|
||
key.Buffer = userInfo.EcPublicKey
|
||
var tmpLen = (uint32)(len(userInfo.EcPublicKey))
|
||
key.Len = &tmpLen
|
||
ecdhKey.Nid = &tmpNid
|
||
ecdhKey.Key = &key
|
||
authRequest.EcdhKey = &ecdhKey
|
||
authRequest.UserName = &wxid
|
||
userInfo.WxId = wxid
|
||
//判断是否为iPad登录的伪密码
|
||
if !strings.HasPrefix(newpass, "extdevnewpwd_") {
|
||
newpass = baseutils.Md5Value(newpass)
|
||
}
|
||
authRequest.Password_1 = &newpass
|
||
|
||
// 序列化
|
||
accountData, err := proto.Marshal(authRequest)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if !strings.HasPrefix(userInfo.LoginDataInfo.LoginData, "A") && userInfo.DeviceInfo != nil {
|
||
return sendManualAuthByAccountData(userInfo, accountData)
|
||
}
|
||
return SendManualAuthA16(userInfo, accountData)
|
||
}
|
||
|
||
// 获取DeviceToken IOS
|
||
func SendIosDeviceTokenRequest(userInfo *baseinfo.UserInfo) (*wechat.TrustResp, error) {
|
||
deviceIos := userInfo.DeviceInfo
|
||
fmt.Println("iphonever", deviceIos.IphoneVer, "osType", deviceIos.OsType, "deviceName", deviceIos.DeviceName, userInfo.ClientVersion, baseinfo.ClientVersion, 11111)
|
||
deviceId := Get62Key(userInfo.LoginDataInfo.LoginData)
|
||
if deviceId[:2] != "49" {
|
||
deviceId = "49" + deviceId[2:]
|
||
}
|
||
clientVersion := userInfo.ClientVersion
|
||
if !(int(clientVersion) > 0) {
|
||
clientVersion = baseinfo.ClientVersion
|
||
}
|
||
installTime := strconv.FormatInt(time.Now().Add(-2592234*time.Second).Unix(), 10) // 一个月前(偏移234秒)秒级时间戳
|
||
kernBootTime := strconv.FormatInt(time.Now().Add(-2592230*time.Second).Unix()*1000, 10) // 一个月前(偏移230秒)毫秒秒级时间戳
|
||
uuid1, uuid2 := baseinfo.IOSUuid(deviceId)
|
||
td := &wechat.TrustReq{
|
||
Td: &wechat.TrustData{
|
||
Tdi: []*wechat.TrustDeviceInfo{
|
||
{Key: proto.String("deviceid"), Val: proto.String(deviceId)},
|
||
{Key: proto.String("sdi"), Val: proto.String(extinfo.GetCidMd5(deviceId, extinfo.GetCid(0x0262626262626)))},
|
||
{Key: proto.String("idfv"), Val: proto.String(uuid1)},
|
||
{Key: proto.String("idfa"), Val: proto.String(uuid2)},
|
||
{Key: proto.String("device_model"), Val: proto.String(deviceIos.IphoneVer)},
|
||
{Key: proto.String("os_version"), Val: proto.String(deviceIos.OsType)},
|
||
{Key: proto.String("core_count"), Val: proto.String("6")},
|
||
{Key: proto.String("carrier_name"), Val: proto.String("")},
|
||
{Key: proto.String("is_jailbreak"), Val: proto.String("0")},
|
||
{Key: proto.String("device_name"), Val: proto.String(deviceIos.DeviceName)},
|
||
{Key: proto.String("client_version"), Val: proto.String(fmt.Sprintf("%v", clientVersion))},
|
||
{Key: proto.String("plist_version"), Val: proto.String(fmt.Sprintf("%v", clientVersion))},
|
||
{Key: proto.String("language"), Val: proto.String("zh")},
|
||
{Key: proto.String("locale_country"), Val: proto.String("CN")},
|
||
{Key: proto.String("screen_width"), Val: proto.String("834")},
|
||
{Key: proto.String("screen_height"), Val: proto.String("1112")},
|
||
{Key: proto.String("install_time"), Val: proto.String(installTime)},
|
||
{Key: proto.String("kern_boottime"), Val: proto.String(kernBootTime)},
|
||
},
|
||
},
|
||
}
|
||
pb, _ := proto.Marshal(td)
|
||
var b bytes.Buffer
|
||
w := zlib.NewWriter(&b)
|
||
w.Write(pb)
|
||
w.Close()
|
||
|
||
zt := new(ZT)
|
||
zt.Init()
|
||
// encData := zt.Encrypt(b.Bytes())
|
||
encData := android.SaeEncrypt07(b.Bytes())
|
||
randKey := make([]byte, 16)
|
||
_, _ = io.ReadFull(rand.Reader, randKey)
|
||
fp := &wechat.FPFresh{
|
||
BaseRequest: &wechat.BaseRequest{
|
||
SessionKey: []byte{},
|
||
Uin: proto.Uint32(0),
|
||
DeviceId: append([]byte(deviceId), 0),
|
||
ClientVersion: proto.Uint32(clientVersion),
|
||
OsType: &userInfo.DeviceInfo.OsType,
|
||
Scene: proto.Uint32(0),
|
||
},
|
||
SessKey: randKey,
|
||
Ztdata: &wechat.ZTData{
|
||
Version: []byte("00000007"),
|
||
Encrypted: proto.Uint64(1),
|
||
Data: encData,
|
||
TimeStamp: proto.Int64(int64(time.Now().Unix())),
|
||
OpType: proto.Uint64(5),
|
||
Uin: proto.Uint64(0),
|
||
},
|
||
}
|
||
reqData, _ := proto.Marshal(fp)
|
||
|
||
hec := &android.Client{}
|
||
|
||
DeviceTypeIos := deviceIos.OsType
|
||
if DeviceTypeIos == "" {
|
||
DeviceTypeIos = baseinfo.DeviceTypeIos
|
||
}
|
||
|
||
hec.Init("IOS", int(clientVersion), DeviceTypeIos)
|
||
hecData := hec.HybridEcdhPackIosEn(3789, 0, nil, reqData)
|
||
// 初始化代理信息
|
||
MMInfo := userInfo.GetMMInfo()
|
||
MMInfo.Dialer = userInfo.GetDialer()
|
||
recvData, err := mmtls.MMHTTPPostData(MMInfo, "/cgi-bin/micromsg-bin/fpinitnl", hecData)
|
||
if err != nil {
|
||
return &wechat.TrustResp{}, err
|
||
}
|
||
if len(recvData) <= 31 {
|
||
return &wechat.TrustResp{}, errors.New(hex.EncodeToString(recvData))
|
||
}
|
||
ph := hec.HybridEcdhPackIosUn(recvData)
|
||
DTResp := &wechat.TrustResp{}
|
||
_ = proto.Unmarshal(ph.Data, DTResp)
|
||
return DTResp, nil
|
||
}
|
||
|
||
// 获取DeviceToken
|
||
func SendAndroIdDeviceTokenRequest(userInfo *baseinfo.UserInfo) (*wechat.TrustResp, error) {
|
||
Android16 := userInfo.DeviceInfoA16
|
||
td := &wechat.TrustReq{
|
||
Td: &wechat.TrustData{
|
||
Tdi: []*wechat.TrustDeviceInfo{
|
||
{Key: proto.String("IMEI"), Val: proto.String(Android16.AndriodImei(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("AndroidID"), Val: proto.String(Android16.AndriodID(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("PhoneSerial"), Val: proto.String(Android16.AndriodPhoneSerial(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("cid"), Val: proto.String("")},
|
||
{Key: proto.String("WidevineDeviceID"), Val: proto.String(Android16.AndriodWidevineDeviceID(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("WidevineProvisionID"), Val: proto.String(Android16.AndriodWidevineProvisionID(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("GSFID"), Val: proto.String("")},
|
||
{Key: proto.String("SoterID"), Val: proto.String("")},
|
||
{Key: proto.String("SoterUid"), Val: proto.String("")},
|
||
{Key: proto.String("FSID"), Val: proto.String(Android16.AndriodFSID(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("BootID"), Val: proto.String("")},
|
||
{Key: proto.String("IMSI"), Val: proto.String("")},
|
||
{Key: proto.String("PhoneNum"), Val: proto.String("")},
|
||
{Key: proto.String("WeChatInstallTime"), Val: proto.String("1556077144")},
|
||
{Key: proto.String("PhoneModel"), Val: proto.String(Android16.AndroidPhoneModel(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("BuildBoard"), Val: proto.String("bullhead")},
|
||
{Key: proto.String("BuildBootloader"), Val: proto.String(Android16.AndroidBuildBoard(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("SystemBuildDate"), Val: proto.String("Fri Sep 28 23:37:27 UTC 2019")},
|
||
{Key: proto.String("SystemBuildDateUTC"), Val: proto.String("1538177847")},
|
||
{Key: proto.String("BuildFP"), Val: proto.String(Android16.AndroidBuildFP(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("BuildID"), Val: proto.String(Android16.AndroidBuildID(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("BuildBrand"), Val: proto.String("google")},
|
||
{Key: proto.String("BuildDevice"), Val: proto.String("bullhead")},
|
||
{Key: proto.String("BuildProduct"), Val: proto.String("bullhead")},
|
||
{Key: proto.String("Manufacturer"), Val: proto.String(Android16.AndroidManufacturer(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("RadioVersion"), Val: proto.String(Android16.AndroidRadioVersion(Android16.DeviceIdStr[:15]))},
|
||
{Key: proto.String("AndroidVersion"), Val: proto.String(Android16.AndroidVersion())},
|
||
{Key: proto.String("SdkIntVersion"), Val: proto.String("27")},
|
||
{Key: proto.String("ScreenWidth"), Val: proto.String("1080")},
|
||
{Key: proto.String("ScreenHeight"), Val: proto.String("1794")},
|
||
{Key: proto.String("SensorList"), Val: proto.String("BMI160 accelerometer#Bosch#0.004788#1,BMI160 gyroscope#Bosch#0.000533#1,BMM150 magnetometer#Bosch#0.000000#1,BMP280 pressure#Bosch#0.005000#1,BMP280 temperature#Bosch#0.010000#1,RPR0521 Proximity Sensor#Rohm#1.000000#1,RPR0521 Light Sensor#Rohm#10.000000#1,Orientation#Google#1.000000#1,BMI160 Step detector#Bosch#1.000000#1,Significant motion#Google#1.000000#1,Gravity#Google#1.000000#1,Linear Acceleration#Google#1.000000#1,Rotation Vector#Google#1.000000#1,Geomagnetic Rotation Vector#Google#1.000000#1,Game Rotation Vector#Google#1.000000#1,Pickup Gesture#Google#1.000000#1,Tilt Detector#Google#1.000000#1,BMI160 Step counter#Bosch#1.000000#1,BMM150 magnetometer (uncalibrated)#Bosch#0.000000#1,BMI160 gyroscope (uncalibrated)#Bosch#0.000533#1,Sensors Sync#Google#1.000000#1,Double Twist#Google#1.000000#1,Double Tap#Google#1.000000#1,Device Orientation#Google#1.000000#1,BMI160 accelerometer (uncalibrated)#Bosch#0.004788#1")},
|
||
{Key: proto.String("DefaultInputMethod"), Val: proto.String("com.google.android.inputmethod.latin")},
|
||
{Key: proto.String("InputMethodList"), Val: proto.String("Google \345\215\260\345\272\246\350\257\255\351\224\256\347\233\230#com.google.android.apps.inputmethod.hindi,Google \350\257\255\351\237\263\350\276\223\345\205\245#com.google.android.googlequicksearchbox,Google \346\227\245\350\257\255\350\276\223\345\205\245\346\263\225#com.google.android.inputmethod.japanese,Google \351\237\251\350\257\255\350\276\223\345\205\245\346\263\225#com.google.android.inputmethod.korean,Gboard#com.google.android.inputmethod.latin,\350\260\267\346\255\214\346\213\274\351\237\263\350\276\223\345\205\245\346\263\225#com.google.android.inputmethod.pinyin")},
|
||
{Key: proto.String("DeviceID"), Val: proto.String(Android16.DeviceIdStr[:15])},
|
||
{Key: proto.String("OAID"), Val: proto.String("")},
|
||
},
|
||
},
|
||
}
|
||
pb, _ := proto.Marshal(td)
|
||
var b bytes.Buffer
|
||
w := zlib.NewWriter(&b)
|
||
w.Write(pb)
|
||
w.Close()
|
||
zt := new(android.ZT)
|
||
zt.Init()
|
||
encData := zt.Encrypt(b.Bytes())
|
||
randKey := make([]byte, 16)
|
||
io.ReadFull(rand.Reader, randKey)
|
||
fp := &wechat.FPFresh{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
SessKey: randKey,
|
||
Ztdata: &wechat.ZTData{
|
||
Version: []byte("00000003"), // apad 此处为 "00000003\x00"
|
||
Encrypted: proto.Uint64(1),
|
||
Data: encData,
|
||
TimeStamp: proto.Int64(int64(time.Now().Unix())),
|
||
OpType: proto.Uint64(5),
|
||
Uin: proto.Uint64(0),
|
||
},
|
||
}
|
||
reqData, _ := proto.Marshal(fp)
|
||
hec := &android.Client{}
|
||
hec.Init("Android", int(baseinfo.AndroidClientVersion), baseinfo.AndroidDeviceType)
|
||
sendData := hec.HybridEcdhPackAndroidEn(3789, 10002, 0, nil, reqData)
|
||
MMInfo := userInfo.GetMMInfo()
|
||
MMInfo.Dialer = userInfo.GetDialer()
|
||
recvData, err := mmtls.MMHTTPPostData(MMInfo, "/cgi-bin/micromsg-bin/fpinitnl", sendData)
|
||
if err != nil {
|
||
return &wechat.TrustResp{}, err
|
||
}
|
||
if len(recvData) <= 31 {
|
||
return &wechat.TrustResp{}, errors.New(hex.EncodeToString(recvData))
|
||
}
|
||
ph := hec.HybridEcdhPackAndroidUn(recvData)
|
||
DTResp := &wechat.TrustResp{}
|
||
_ = proto.Unmarshal(ph.Data, DTResp)
|
||
return DTResp, nil
|
||
}
|
||
|
||
// 获取DeviceToken
|
||
func SendDeviceTokenRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
deviceInfo := userInfo.DeviceInfo
|
||
deviceId := hex.EncodeToString(deviceInfo.DeviceID)
|
||
ServerVersion := userInfo.ClientVersion
|
||
if !(int(ServerVersion) > 0) {
|
||
ServerVersion = baseinfo.ServerVersion
|
||
}
|
||
data, err := extinfo.GetZTData(deviceId, deviceInfo.OsType, deviceInfo.OsTypeNumber, deviceInfo.DeviceName, uint64(ServerVersion))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
request := wechat.TrustRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
RandomKey: userInfo.SessionKey,
|
||
SpamBuff: data,
|
||
}
|
||
// 发送请求
|
||
src, _ := proto.Marshal(&request)
|
||
//sendData := Pack(userInfo, src, 3789, 12)
|
||
|
||
secKeyMgr := NewSecLoginKeyMgrByVer(146)
|
||
|
||
reqData := src
|
||
//加密
|
||
encrypt, epKey, token, ecdhpairkey, err := clientsdk.HybridEncrypt(reqData, secKeyMgr.WeChatPubKey)
|
||
if err != nil {
|
||
log.Error("加密 error", err.Error())
|
||
}
|
||
ecdhPacket := &wechat.EcdhPacket{
|
||
Type: proto.Uint32(1),
|
||
Key: &wechat.BufferT{
|
||
ILen: proto.Uint32(415),
|
||
Buffer: ecdhpairkey.PubKey,
|
||
},
|
||
Token: token,
|
||
Url: proto.String(""),
|
||
ProtobufData: encrypt,
|
||
}
|
||
secKeyMgr.PubKey = ecdhpairkey.PubKey
|
||
secKeyMgr.PriKey = ecdhpairkey.PriKey
|
||
secKeyMgr.SourceData = reqData
|
||
secKeyMgr.FinalSha256 = append(secKeyMgr.FinalSha256, epKey[24:]...)
|
||
secKeyMgr.FinalSha256 = append(secKeyMgr.FinalSha256, reqData...)
|
||
ecdhDataPacket, err := proto.Marshal(ecdhPacket)
|
||
if err != nil {
|
||
log.Error("ecdhDataPacket error", err.Error())
|
||
}
|
||
packHeader := CreatePackHead(userInfo, baseinfo.MMPackDataTypeUnCompressed, 3789, ecdhDataPacket, ecdhDataPacket, uint32(len(ecdhDataPacket)), 12, uint32(0x4e))
|
||
//设置Hybrid 加密密钥版本
|
||
packHeader.HybridKeyVer = secKeyMgr.WeChatPubKeyVersion
|
||
//开始组头
|
||
//packHeader.ReqData= PackHeaderSerialize(packHeader, false)
|
||
|
||
sendData := PackHeaderSerialize(packHeader, true)
|
||
MMInfo := userInfo.GetMMInfo()
|
||
MMInfo.Dialer = userInfo.GetDialer()
|
||
resp, err := mmtls.MMHTTPPostData(MMInfo, "/cgi-bin/micromsg-bin/fpinitnl", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
packHeader, err = DecodePackHeader(resp, nil)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
packHeader.Data, err = clientsdk.HybridEcdhDecrypt(packHeader.Data, secKeyMgr.PriKey, secKeyMgr.PubKey, secKeyMgr.FinalSha256)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return packHeader, err
|
||
}
|
||
|
||
// 二次登录-new
|
||
func SendSecautouthRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
userInfo.EcPublicKey, userInfo.EcPrivateKey = cecdh.GenerateEccKey()
|
||
autoAuthKey := &wechat.AutoAuthKey{}
|
||
err := proto.Unmarshal(userInfo.AutoAuthKey, autoAuthKey)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
userInfo.SessionKey = autoAuthKey.EncryptKey.Buffer
|
||
var tmpNid uint32 = 713
|
||
var key wechat.SKBuiltinString_
|
||
key.Buffer = userInfo.EcPublicKey
|
||
var tmpLen = (uint32)(len(userInfo.EcPublicKey))
|
||
key.Len = &tmpLen
|
||
// ClientSeqId
|
||
tmpTime := int(time.Now().UnixNano() / 1000000000)
|
||
tmpTimeStr := strconv.Itoa(tmpTime)
|
||
var strClientSeqID = string(userInfo.DeviceInfo.Imei + "-" + tmpTimeStr)
|
||
// extSpamInfo
|
||
var extSpamInfo wechat.SKBuiltinString_
|
||
extSpamInfo.Buffer = GetExtPBSpamInfoDataLogin(userInfo)
|
||
extSpamInfoLen := uint32(len(extSpamInfo.Buffer))
|
||
extSpamInfo.Len = &extSpamInfoLen
|
||
req := &wechat.AutoAuthRequest{
|
||
RsaReqData: &wechat.AutoAuthRsaReqData{
|
||
AesEncryptKey: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(autoAuthKey.EncryptKey.Buffer))),
|
||
Buffer: autoAuthKey.EncryptKey.Buffer,
|
||
},
|
||
PubEcdhKey: &wechat.ECDHKey{
|
||
Nid: proto.Uint32(tmpNid),
|
||
Key: &key,
|
||
},
|
||
},
|
||
AesReqData: &wechat.AutoAuthAesReqData{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
BaseReqInfo: &wechat.BaseAuthReqInfo{},
|
||
AutoAuthKey: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(userInfo.AutoAuthKey))),
|
||
Buffer: userInfo.AutoAuthKey,
|
||
},
|
||
Imei: &userInfo.DeviceInfo.Imei,
|
||
SoftType: &userInfo.DeviceInfo.SoftTypeXML,
|
||
BuiltinIpSeq: proto.Uint32(0),
|
||
ClientSeqId: &strClientSeqID,
|
||
DeviceName: proto.String(userInfo.DeviceInfo.DeviceName),
|
||
SoftInfoXml: proto.String("iPad Mini 4"),
|
||
Language: proto.String("zh_CN"),
|
||
TimeZone: proto.String("8.00"),
|
||
ExtSpamInfo: &extSpamInfo,
|
||
},
|
||
}
|
||
reqData, err := proto.Marshal(req)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
secKeyMgr := NewSecLoginKeyMgrByVer(146)
|
||
//加密
|
||
encrypt, epKey, token, ecdhpairkey, err := clientsdk.HybridEncrypt(reqData, secKeyMgr.WeChatPubKey)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
/*ecdhPacket := &wechat.EcdhPacket{
|
||
Type: proto.Uint32(1),
|
||
Key: &wechat.BufferT{
|
||
ILen: proto.Uint32(415),
|
||
Buffer: ecdhpairkey.PubKey,
|
||
},
|
||
Token: token,
|
||
Url: proto.String(""),
|
||
ProtobufData: encrypt,
|
||
}*/
|
||
ecdhPacket := &wechat.HybridEcdhRequest{
|
||
Type: proto.Int32(1),
|
||
SecECDHKey: &wechat.BufferT{
|
||
ILen: proto.Uint32(415),
|
||
Buffer: ecdhpairkey.PubKey,
|
||
},
|
||
Randomkeydata: token,
|
||
Randomkeyextenddata: epKey,
|
||
Encyptdata: encrypt,
|
||
}
|
||
secKeyMgr.PubKey = ecdhpairkey.PubKey
|
||
secKeyMgr.PriKey = ecdhpairkey.PriKey
|
||
secKeyMgr.SourceData = reqData
|
||
secKeyMgr.FinalSha256 = append(secKeyMgr.FinalSha256, epKey[24:]...)
|
||
secKeyMgr.FinalSha256 = append(secKeyMgr.FinalSha256, reqData...)
|
||
ecdhDataPacket, err := proto.Marshal(ecdhPacket)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
packHeader := CreatePackHead(userInfo, baseinfo.MMPackDataTypeUnCompressed, 763, ecdhDataPacket, ecdhDataPacket, uint32(len(ecdhDataPacket)), 12, uint32(0x4e))
|
||
//设置Hybrid 加密密钥版本
|
||
packHeader.HybridKeyVer = secKeyMgr.WeChatPubKeyVersion
|
||
//开始组头
|
||
retData := PackHeaderSerialize(packHeader, false)
|
||
//fmt.Println(hex.EncodeToString(retData))
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/secautoauth", retData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
packHeader, err = DecodePackHeader(resp, nil)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
packHeader.Data, err = clientsdk.HybridEcdhDecrypt(packHeader.Data, secKeyMgr.PriKey, secKeyMgr.PubKey, secKeyMgr.FinalSha256)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return packHeader, err
|
||
|
||
/*hec :=&Client{}
|
||
hec.Init("IOS")
|
||
hecData := hec.HybridEcdhPackIosEn(763,userInfo.Uin,userInfo.Session,reqData)
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/secautoauth", hecData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
packHeader := hec.HybridEcdhPackIosUn(resp)
|
||
packHeader, err = DecodePackHeader(resp, nil)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
packHeader.Data, err = clientsdk.HybridEcdhDecrypt(packHeader.Data, secKeyMgr.PriKey, secKeyMgr.PubKey, secKeyMgr.FinalSha256)
|
||
if err != nil {
|
||
return nil, err
|
||
}*/
|
||
// return packHeader, err
|
||
}
|
||
|
||
// SendAutoAuthRequest 发送token登陆请求
|
||
func SendAutoAuthRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
userInfo.EcPublicKey, userInfo.EcPrivateKey = cecdh.GenerateEccKey()
|
||
autoAuthKey := &wechat.AutoAuthKey{}
|
||
err := proto.Unmarshal(userInfo.AutoAuthKey, autoAuthKey)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
userInfo.SessionKey = autoAuthKey.EncryptKey.Buffer
|
||
// 获取AutoAuthRsaReqData
|
||
rsaReqData := GetAutoAuthRsaReqDataMarshal(userInfo)
|
||
aesReqData := GetAutoAuthAesReqDataMarshal(userInfo)
|
||
|
||
// 开始打包数据
|
||
// 加密压缩 rsaReqData
|
||
rsaEncodeData := baseutils.CompressAndRsaByVer(rsaReqData, userInfo.GetLoginRsaVer())
|
||
rsaAesEncodeData := baseutils.CompressAes(userInfo.SessionKey, rsaReqData)
|
||
|
||
// 加密压缩 aesReqData
|
||
aesEncodeData := baseutils.CompressAes(userInfo.SessionKey, aesReqData)
|
||
|
||
body := make([]byte, 0)
|
||
// rsaReqBuflen
|
||
tmpBuf := baseutils.Int32ToBytes(uint32(len(rsaReqData)))
|
||
body = append(body, tmpBuf[0:]...)
|
||
|
||
// aesReqBuf len
|
||
tmpBuf = baseutils.Int32ToBytes(uint32(len(aesReqData)))
|
||
body = append(body, tmpBuf[0:]...)
|
||
|
||
// rsaEncodeData len
|
||
tmpBuf = baseutils.Int32ToBytes(uint32(len(rsaEncodeData)))
|
||
body = append(body, tmpBuf[0:]...)
|
||
|
||
// rsaAesEncodeData len
|
||
tmpBuf = baseutils.Int32ToBytes(uint32(len(rsaAesEncodeData)))
|
||
body = append(body, tmpBuf[0:]...)
|
||
|
||
// rsaEncodeData
|
||
body = append(body, rsaEncodeData[0:]...)
|
||
body = append(body, rsaAesEncodeData[0:]...)
|
||
body = append(body, aesEncodeData[0:]...)
|
||
|
||
/*sendData,secKeyMgr:= Pack12(userInfo, body, baseinfo.MMRequestTypeAutoAuth, 12)
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/autoauth",sendData)
|
||
if err != nil {
|
||
log.Error("mmtls error", err.Error())
|
||
}
|
||
packHeader, err:= DecodePackHeader(resp, nil)
|
||
if err != nil {
|
||
log.Error("ecdhDataPacket error", err.Error())
|
||
}
|
||
packHeader.Data, err = clientsdk.HybridEcdhDecrypt(packHeader.Data, secKeyMgr.PriKey, secKeyMgr.PubKey, secKeyMgr.FinalSha256)
|
||
if err != nil {
|
||
log.Error("HybridEcdhDecrypt error", err.Error())
|
||
}
|
||
return packHeader,nil*/
|
||
// 发送请求
|
||
sendData := Pack(userInfo, body, baseinfo.MMRequestTypeAutoAuth, 9)
|
||
MMInfo := userInfo.GetMMInfo()
|
||
MMInfo.Dialer = userInfo.GetDialer()
|
||
resp, err := mmtls.MMHTTPPostData(MMInfo, "/cgi-bin/micromsg-bin/autoauth", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetCheckLoginQRCodeRequest 长链接：获取检测二维码状态-请求数据包
|
||
func GetCheckLoginQRCodeRequest(userInfo *baseinfo.UserInfo, qrcodeUUID string, qrcodeKey []byte) ([]byte, error) {
|
||
var request wechat.CheckLoginQRCodeRequest
|
||
// 重新生成AesKey
|
||
//userInfo.SessionKey = baseutils.RandomBytes(16)
|
||
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// AESKey
|
||
var aesKey wechat.AESKey
|
||
var tmpAesKeyLen = uint32(16)
|
||
aesKey.Len = &tmpAesKeyLen
|
||
aesKey.Key = []byte(userInfo.SessionKey)
|
||
request.Aes = &aesKey
|
||
|
||
// uuid
|
||
request.Uuid = &qrcodeUUID
|
||
|
||
// timeStamp 当前系统时间
|
||
timeStamp := (uint32)(time.Now().Unix())
|
||
request.TimeStamp = &timeStamp
|
||
|
||
// OpCode
|
||
var tmpOpcode = uint32(0)
|
||
request.Opcode = &tmpOpcode
|
||
|
||
// 发送请求
|
||
src, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, src, baseinfo.MMRequestTypeCheckLoginQRCode, 7)
|
||
return sendData, nil
|
||
}
|
||
|
||
// SendPushQrLoginNotice 二维码二次登录
|
||
func SendPushQrLoginNotice(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
var request wechat.PushLoginURLRequest
|
||
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
|
||
request = wechat.PushLoginURLRequest{
|
||
BaseRequest: baseReq,
|
||
UserName: proto.String(userInfo.GetUserName()),
|
||
AutoAuthTicket: proto.String(""),
|
||
ClientID: proto.String(fmt.Sprintf("iPad-Push-%s.110141", userInfo.DeviceInfo.DeviceID)),
|
||
RandomEnCryptKey: &wechat.BufferT{
|
||
ILen: proto.Uint32(uint32(len(userInfo.SessionKey))),
|
||
Buffer: userInfo.SessionKey,
|
||
},
|
||
OPCode: proto.Uint32(3),
|
||
DeviceName: proto.String(userInfo.DeviceInfo.DeviceName),
|
||
AutoAuthKey: &wechat.BufferT{
|
||
ILen: proto.Uint32(uint32(len(userInfo.AutoAuthKey))),
|
||
Buffer: userInfo.AutoAuthKey,
|
||
},
|
||
}
|
||
// 发送请求
|
||
src, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, src, baseinfo.MMRequestTypePushQrLogin, 1)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/pushloginurl", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetHeartBeatShortRequest 短链接心跳
|
||
func GetHeartBeatShortRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
sendData, err := GetHeartBeatRequest(userInfo)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
MMInfo := userInfo.GetMMInfo()
|
||
MMInfo.Dialer = userInfo.GetDialer()
|
||
resp, err := mmtls.MMHTTPPostData(MMInfo, "/cgi-bin/micromsg-bin/heartbeat", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetHeartBeatRequest 长链接：获取心跳包-请求数据包
|
||
func GetHeartBeatRequest(userInfo *baseinfo.UserInfo) ([]byte, error) {
|
||
var request wechat.HeartBeatRequest
|
||
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// timeStamp 当前系统时间
|
||
timeStamp := (uint32)(time.Now().UnixNano() / 1000000000)
|
||
request.TimeStamp = &timeStamp
|
||
|
||
// Scene
|
||
request.Scene = &tmpScene
|
||
|
||
// KeyBuf
|
||
request.KeyBuf = &wechat.SKBuiltinString_{}
|
||
request.KeyBuf.Buffer = userInfo.SessionKey
|
||
request.KeyBuf.Len = proto.Uint32(uint32(len(userInfo.SessionKey)))
|
||
|
||
// 打包数据
|
||
src, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, src, baseinfo.MMRequestTypeHeartBeat, 5)
|
||
return sendData, nil
|
||
}
|
||
|
||
// SendNewSyncRequest 发送同步信息请求
|
||
func SendNewSyncRequest(userInfo *baseinfo.UserInfo, scene uint32) (*baseinfo.PackHeader, error) {
|
||
var request wechat.NewSyncRequest
|
||
zeroValue32 := uint32(0)
|
||
|
||
// Oplog
|
||
var opLog wechat.CmdList
|
||
opLog.Count = &zeroValue32
|
||
opLog.ItemList = make([]*wechat.CmdItem, 0)
|
||
request.Oplog = &opLog
|
||
|
||
// Selector
|
||
tmpSelector := uint32(262151)
|
||
request.Selector = &tmpSelector
|
||
|
||
// keyBuf
|
||
var keyBuf wechat.SKBuiltinString_
|
||
keyBuf.Buffer = userInfo.SyncKey
|
||
tmpLen := uint32(len(keyBuf.Buffer))
|
||
keyBuf.Len = &tmpLen
|
||
request.KeyBuf = &keyBuf
|
||
|
||
// Scene
|
||
request.Scene = &scene
|
||
// DeviceType
|
||
if userInfo.DeviceInfoA16 != nil {
|
||
request.DeviceType = &baseinfo.AndroidDeviceType
|
||
} else {
|
||
request.DeviceType = &userInfo.DeviceInfo.OsType
|
||
}
|
||
// syncMsgDigest : 短链接同步
|
||
syncMsgDigest := baseinfo.MMSyncMsgDigestTypeShortLink
|
||
request.SyncMsgDigest = &syncMsgDigest
|
||
|
||
// 发送请求
|
||
src, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, src, baseinfo.MMRequestTypeNewSync, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/newsync", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 同步消息
|
||
func SendWxSyncMsg(userInfo *baseinfo.UserInfo, key string) (*baseinfo.PackHeader, error) {
|
||
zeroValue32 := uint32(0)
|
||
// Oplog
|
||
var opLog wechat.CmdList
|
||
opLog.Count = &zeroValue32
|
||
opLog.ItemList = make([]*wechat.CmdItem, 0)
|
||
//
|
||
var keyBuf wechat.SKBuiltinString_
|
||
keyBuf.Buffer = userInfo.SyncKey
|
||
if key != "" {
|
||
keyBuf.Buffer = []byte(key)
|
||
}
|
||
tmpLen := uint32(len(keyBuf.Buffer))
|
||
keyBuf.Len = &tmpLen
|
||
request := wechat.NewSyncRequest{
|
||
Oplog: &opLog,
|
||
Selector: proto.Uint32(262151),
|
||
Scene: proto.Uint32(4),
|
||
DeviceType: proto.String(userInfo.DeviceInfo.OsType),
|
||
SyncMsgDigest: proto.Uint32(baseinfo.MMSyncMsgDigestTypeShortLink),
|
||
KeyBuf: &keyBuf,
|
||
}
|
||
// 发送请求
|
||
src, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, src, baseinfo.MMRequestTypeNewSync, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/newsync", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendGetProfileRequest 发送获取帐号所有信息请求
|
||
func SendGetProfileRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
var request wechat.GetProfileRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpZero = uint32(0)
|
||
baseReq.Scene = &tmpZero
|
||
request.BaseRequest = baseReq
|
||
|
||
// 发送请求
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetProfile, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getprofile", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 获取设备
|
||
func SendGetSafetyInfoRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
baseRequest := GetBaseRequest(userInfo)
|
||
//baseRequest.Scene = proto.Uint32(1)
|
||
var req = wechat.GetSafetyInfoRequest{
|
||
BaseRequest: baseRequest,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 850, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getsafetyinfo", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 删除设备
|
||
func SendDelSafeDeviceRequest(userInfo *baseinfo.UserInfo, uuid string) (*baseinfo.PackHeader, error) {
|
||
baseRequest := GetBaseRequest(userInfo)
|
||
//baseRequest.Scene = proto.Uint32(1)
|
||
var req = wechat.DelSafeDeviceRequest{
|
||
BaseRequest: baseRequest,
|
||
Uuid: proto.String(uuid),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 362, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/delsafedevice", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 检测微信登录环境
|
||
func SendCheckCanSetAliasRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
baseRequest := GetBaseRequest(userInfo)
|
||
var req = wechat.CheckCanSetAliasReq{
|
||
BaseRequest: baseRequest,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 926, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/checkcansetalias", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendInitContactReq 初始化联系人列表
|
||
func SendInitContactReq(userInfo *baseinfo.UserInfo, contactSeq uint32) (*baseinfo.PackHeader, error) {
|
||
var request wechat.InitContactReq
|
||
|
||
// Username
|
||
request.Username = &userInfo.WxId
|
||
// CurrentWxcontactSeq
|
||
request.CurrentWxcontactSeq = &contactSeq
|
||
// CurrentChatRoomContactSeq
|
||
roomContactSeq := uint32(0)
|
||
request.CurrentChatRoomContactSeq = &roomContactSeq
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeInitContact, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/initcontact", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
func GetContactListPageReq(userInfo *baseinfo.UserInfo, CurrentWxcontactSeq uint32, CurrentChatRoomContactSeq uint32) (*baseinfo.PackHeader, error) {
|
||
var request wechat.InitContactReq
|
||
|
||
// Username
|
||
request.Username = &userInfo.WxId
|
||
// CurrentWxcontactSeq
|
||
request.CurrentWxcontactSeq = &CurrentWxcontactSeq
|
||
request.CurrentChatRoomContactSeq = &CurrentChatRoomContactSeq
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeInitContact, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/initcontact", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendBatchGetContactBriefInfoReq 批量获取联系人信息
|
||
func SendBatchGetContactBriefInfoReq(userInfo *baseinfo.UserInfo, userNameList []string) (*baseinfo.PackHeader, error) {
|
||
var request wechat.BatchGetContactBriefInfoReq
|
||
request.ContactUsernameList = userNameList
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeBatchGetContactBriefInfo, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/batchgetcontactbriefinfo", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
func SendGetFriendRelationReq(userInfo *baseinfo.UserInfo, userName string) (*baseinfo.PackHeader, error) {
|
||
var request wechat.MMBizJsApiGetUserOpenIdRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(1)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
request.AppId = proto.String("wx7c8d593b2c3a7703")
|
||
request.UserName = proto.String(userName)
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
//获取好友关系状态
|
||
sendEncodeData := Pack(userInfo, srcData, 1177, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmbiz-bin/usrmsg/mmbizjsapi_getuseropenid", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendGetContactRequest 获取指定微信号信息请求, userWxID:联系人ID roomWxID：群ID
|
||
func SendGetContactRequest(userInfo *baseinfo.UserInfo, userWxIDList []string, antisPanTicketList []string, roomWxIDList []string) (*baseinfo.PackHeader, error) {
|
||
var request wechat.GetContactRequest
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// userCount
|
||
var userCount = uint32(len(userWxIDList))
|
||
request.UserCount = &userCount
|
||
// UserNameList
|
||
userNameList := make([]*wechat.SKBuiltinString, userCount)
|
||
// 遍历
|
||
for index := uint32(0); index < userCount; index++ {
|
||
userNameItem := new(wechat.SKBuiltinString)
|
||
userNameItem.Str = &userWxIDList[index]
|
||
userNameList[index] = userNameItem
|
||
}
|
||
request.UserNameList = userNameList
|
||
|
||
// AntispamTicketCount
|
||
antispamTicketCount := uint32(len(antisPanTicketList))
|
||
request.AntispamTicketCount = &antispamTicketCount
|
||
// AntispamTicket
|
||
tmpAntispamTicketList := make([]*wechat.SKBuiltinString, antispamTicketCount)
|
||
for index := uint32(0); index < antispamTicketCount; index++ {
|
||
antispamTicket := new(wechat.SKBuiltinString)
|
||
antispamTicket.Str = &antisPanTicketList[index]
|
||
tmpAntispamTicketList[index] = antispamTicket
|
||
}
|
||
request.AntispamTicket = tmpAntispamTicketList
|
||
|
||
// FromChatRoomCount
|
||
fromChatRoomCount := uint32(len(roomWxIDList))
|
||
request.FromChatRoomCount = &fromChatRoomCount
|
||
// FromChatRoom
|
||
fromChatRoomList := make([]*wechat.SKBuiltinString, fromChatRoomCount)
|
||
for index := uint32(0); index < fromChatRoomCount; index++ {
|
||
fromChatRoom := new(wechat.SKBuiltinString)
|
||
fromChatRoom.Str = &roomWxIDList[index]
|
||
fromChatRoomList[index] = fromChatRoom
|
||
}
|
||
request.FromChatRoom = fromChatRoomList
|
||
|
||
// GetContactScene
|
||
var getContactScene = uint32(0)
|
||
request.GetContactScene = &getContactScene
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetContact, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getcontact", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 创建红包
|
||
func SendWXCreateRedPacket(userInfo *baseinfo.UserInfo, hbItem *baseinfo.RedPacket) (*baseinfo.PackHeader, error) {
|
||
var request wechat.HongBaoReq
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
// CgiCmd
|
||
request.CgiCmd = proto.Uint32(0)
|
||
// OutPutType
|
||
request.OutPutType = proto.Uint32(0)
|
||
// ReqText
|
||
strReqText := string("")
|
||
strReqText = strReqText + "city=Guangzhou&"
|
||
strReqText = strReqText + "hbType=" + strconv.Itoa(int(hbItem.RedType)) + "&"
|
||
strReqText = strReqText + "headImg=" + "&"
|
||
strReqText = strReqText + "inWay=" + strconv.Itoa(int(hbItem.From)) + "&"
|
||
strReqText = strReqText + "needSendToMySelf=0" + "&"
|
||
strReqText = strReqText + "nickName=" + url.QueryEscape(userInfo.NickName) + "&"
|
||
strReqText = strReqText + "perValue=" + strconv.Itoa(int(hbItem.Amount)) + "&"
|
||
strReqText = strReqText + "province=Guangdong" + "&"
|
||
strReqText = strReqText + "sendUserName=" + userInfo.WxId + "&"
|
||
strReqText = strReqText + "totalAmount=" + strconv.Itoa(int(hbItem.Amount*hbItem.Count)) + "&"
|
||
strReqText = strReqText + "totalNum=" + strconv.Itoa(int(hbItem.Count)) + "&"
|
||
strReqText = strReqText + "username=" + hbItem.Username + "&"
|
||
strReqText = strReqText + "wishing=" + url.QueryEscape(hbItem.Content)
|
||
var reqText wechat.SKBuiltinString_
|
||
reqText.Buffer = []byte(strReqText)
|
||
tmpLen := uint32(len(reqText.Buffer))
|
||
reqText.Len = &tmpLen
|
||
request.ReqText = &reqText
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, 1575, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmpay-bin/requestwxhb", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendReceiveWxHB 发送接收红包请求
|
||
func SendReceiveWxHB(userInfo *baseinfo.UserInfo, hongBaoReceiverItem *baseinfo.HongBaoReceiverItem) (*baseinfo.PackHeader, error) {
|
||
var request wechat.HongBaoReq
|
||
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// CgiCmd
|
||
request.CgiCmd = &hongBaoReceiverItem.CgiCmd
|
||
|
||
// OutPutType
|
||
outputType := baseinfo.MMTenPayReqOutputTypeJSON
|
||
request.OutPutType = &outputType
|
||
/**agreeDuty=0
|
||
&channelId=1
|
||
&encrypt_key=T1LVNmOtXtStQDQwgZP81guupLsaO6meiWltwBFoSNL+WSIFmhqa1msSZ1J0HsRjE0V0u0k2qp2Yrqihjr8WXyV/okS+/4mJEl6whzupyQKYil69t/2kZ87agWyblo0A2SiozLrZSvs2HjFy9SH3IgXVECDSGKWVXcwJ3QqBmvY=&
|
||
encrypt_userinfo=RU3cO5jg3eSTw+Kiwh14q3GhRM3Vk6ZNA5FD4BwmUxo+Bkr/JMItKC10pnNKUgsPfIpZ1/G1tk2MBtCwtQwo8A==&group_name=48593899189@chatroom
|
||
&inWay=0
|
||
&msgType=1&
|
||
nativeUrl=wxpay://c2cbizmessagehandler/hongbao/receivehongbao?msgtype=1&channelid=1&sendid=1800008896202411036324429265017&ver=2&sign=AARxHbYBAAABAAAAAAC07b6S00apLZ%2F7lz0nZyAAAAD5K3H1P3TTsgLxNwDzPyfEp2uvjYg0WGAGRbvB%2BrLW1PF0gCgzTvftYOhOXdBog8moWaYrvz7UoWuTijySa63rd0mAoTd3caJvpcvBzjUQcHvGUsYShwUN28KEUV6S6MOdl8QhdoPeRYZXwZC8kGaJCoLJ5t8zfDGgmdotHQ%3D%3D&
|
||
sendId=1800008896202411036324429265017&union_source=0
|
||
*/
|
||
// ReqText
|
||
strReqText := string("")
|
||
strReqText = strReqText + "agreeDuty=0&"
|
||
strReqText = strReqText + "channelId=" + hongBaoReceiverItem.HongBaoURLItem.ChannelID + "&"
|
||
// strReqText = strReqText + "city=" + hongBaoReceiverItem.City + "&"
|
||
strReqText = strReqText + "encrypt_key=" + baseutils.EscapeURL(userInfo.HBAesKeyEncrypted) + "&"
|
||
strReqText = strReqText + "encrypt_userinfo=" + baseutils.EscapeURL(GetEncryptUserInfo(userInfo)) + "&"
|
||
strReqText = strReqText + "inWay=" + strconv.Itoa(int(hongBaoReceiverItem.InWay)) + "&"
|
||
strReqText = strReqText + "msgType=" + hongBaoReceiverItem.HongBaoURLItem.MsgType + "&"
|
||
strReqText = strReqText + "nativeUrl=" + baseutils.EscapeURL(hongBaoReceiverItem.NativeURL) + "&"
|
||
// strReqText = strReqText + "province=" + hongBaoReceiverItem.Province + "&"
|
||
strReqText = strReqText + "sendId=" + hongBaoReceiverItem.HongBaoURLItem.SendID
|
||
// strReqText = strReqText + "union_source=0"
|
||
var reqText wechat.SKBuiltinString_
|
||
reqText.Buffer = []byte(strReqText)
|
||
tmpLen := uint32(len(reqText.Buffer))
|
||
reqText.Len = &tmpLen
|
||
request.ReqText = &reqText
|
||
// 打包发送数据
|
||
RequestType := baseinfo.MMRequestTypeReceiveWxHB
|
||
urlPath := "/cgi-bin/mmpay-bin/receivewxhb"
|
||
if hongBaoReceiverItem.SceneID == uint32(1005) {
|
||
// 企业外部群红包 timingIdentifier
|
||
//RequestType = uint32(4536)
|
||
strReqText = strReqText + "&union_source=0"
|
||
strReqText = strReqText + "&group_name=" + baseutils.EscapeURL(hongBaoReceiverItem.HongBaoURLItem.SendUserName)
|
||
|
||
//"encrypt_key"
|
||
//"group_name"
|
||
urlPath = "/cgi-bin/mmpay-bin/unionhb/receiveunionhb"
|
||
CgiCmd := uint32(4536)
|
||
request.CgiCmd = &CgiCmd
|
||
|
||
reqText.Buffer = []byte(strReqText)
|
||
tmpLen := uint32(len(reqText.Buffer))
|
||
reqText.Len = &tmpLen
|
||
request.ReqText = &reqText
|
||
// fmt.Print("企业外部群红包 timingIdentifier")
|
||
}
|
||
srcData, _ := proto.Marshal(&request)
|
||
// userInfo.ClientVersion = ClientVersion
|
||
// fmt.Print("\nRequestType:", RequestType)
|
||
// fmt.Print("\nurlPath:", urlPath)
|
||
// fmt.Print("\n")
|
||
sendEncodeData := Pack(userInfo, srcData, RequestType, 5)
|
||
// byte[] 转 string
|
||
// sendEncodeDataStr := string(srcData)
|
||
// fmt.Println("srcData: ", sendEncodeDataStr)
|
||
///cgi-bin/mmpay-bin/unionhb 企业群红包
|
||
/// 打开红包
|
||
// 长链接发送
|
||
// fmt.Print("\n发送长连接接收红包请求\n")
|
||
// err := mmtls.MMTCPSendReq(userInfo.MMInfo, mmtls.MMLongOperationRequest, sendEncodeData)
|
||
// if err != nil {
|
||
// return nil, err
|
||
// }
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, urlPath, sendEncodeData)
|
||
if err != nil {
|
||
fmt.Println("err:", err)
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendOpenWxHB 发送领取红包请求
|
||
func SendOpenWxHB(userInfo *baseinfo.UserInfo, hongBaoOpenItem *baseinfo.HongBaoOpenItem) (*baseinfo.PackHeader, error) {
|
||
var request wechat.HongBaoReq
|
||
|
||
// "channelId": "1",
|
||
// "encrypt_key": "T1LVNmOtXtStQDQwgZP81guupLsaO6meiWltwBFoSNL+WSIFmhqa1msSZ1J0HsRjE0V0u0k2qp2Yrqihjr8WXyV/okS+/4mJEl6whzupyQKYil69t/2kZ87agWyblo0A2SiozLrZSvs2HjFy9SH3IgXVECDSGKWVXcwJ3QqBmvY=",
|
||
// "encrypt_userinfo": "RU3cO5jg3eSTw+Kiwh14q3GhRM3Vk6ZNA5FD4BwmUxo+Bkr/JMItKC10pnNKUgsPfIpZ1/G1tk2MBtCwtQwo8A==",
|
||
// "headImg": "https://wx.qlogo.cn/mmhead/ver_1/iaGwFC19C856VC76SkWmjlib40vgX6xtIQkbUM32rF45VDstSpH6KOdGoKaFCceXT04ia3NayIYspXPTpKcuw33UDcwasgaVkVgLttHCIUnMI0GjV8qd5es6lSUeWZwZry2/132",
|
||
// "msgType": "1",
|
||
// "nativeUrl": "wxpay://c2cbizmessagehandler/hongbao/receivehongbao?msgtype=1&channelid=1&sendid=1800008896202411036324429265017&ver=2&sign=AARxHbYBAAABAAAAAAC07b6S00apLZ%2F7lz0nZyAAAAD5K3H1P3TTsgLxNwDzPyfEp2uvjYg0WGAGRbvB%2BrLW1PF0gCgzTvftYOhOXdBog8moWaYrvz7UoWuTijySa63rd0mAoTd3caJvpcvBzjUQcHvGUsYShwUN28KEUV6S6MOdl8QhdoPeRYZXwZC8kGaJCoLJ5t8zfDGgmdotHQ%3D%3D",
|
||
// "nickName": "琳琳",
|
||
// "sendId": "1800008896202411036324429265017",
|
||
// "sessionUserName": "48593899189@chatroom",
|
||
// "timingIdentifier": "87a72ff1f1700e4dc289b712ff9bdfae",
|
||
// "union_source": "0"
|
||
///402665260
|
||
// baserequest402665506
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// CgiCmd
|
||
request.CgiCmd = &hongBaoOpenItem.CgiCmd
|
||
//
|
||
|
||
// OutPutType
|
||
outputType := baseinfo.MMTenPayReqOutputTypeJSON
|
||
request.OutPutType = &outputType
|
||
|
||
// ReqText
|
||
strReqText := string("")
|
||
strReqText = strReqText + "channelId=" + hongBaoOpenItem.HongBaoURLItem.ChannelID + "&"
|
||
strReqText = strReqText + "city=" + hongBaoOpenItem.City + "&"
|
||
strReqText = strReqText + "encrypt_key=" + baseutils.EscapeURL(userInfo.HBAesKeyEncrypted) + "&"
|
||
strReqText = strReqText + "encrypt_userinfo=" + baseutils.EscapeURL(GetEncryptUserInfo(userInfo)) + "&"
|
||
strReqText = strReqText + "headImg=" + baseutils.EscapeURL(hongBaoOpenItem.HeadImg) + "&"
|
||
strReqText = strReqText + "msgType=" + hongBaoOpenItem.HongBaoURLItem.MsgType + "&"
|
||
strReqText = strReqText + "nativeUrl=" + baseutils.EscapeURL(hongBaoOpenItem.NativeURL) + "&"
|
||
strReqText = strReqText + "nickName=" + baseutils.HongBaoStringToBytes(hongBaoOpenItem.NickName) + "&"
|
||
strReqText = strReqText + "province=" + hongBaoOpenItem.Province + "&"
|
||
strReqText = strReqText + "sendId=" + hongBaoOpenItem.HongBaoURLItem.SendID + "&"
|
||
strReqText = strReqText + "sessionUserName=" + hongBaoOpenItem.HongBaoURLItem.SendUserName + "&"
|
||
strReqText = strReqText + "timingIdentifier=" + hongBaoOpenItem.TimingIdentifier
|
||
// strReqText = strReqText + "&union_source=0"
|
||
// fmt.Println("strReqText: ")
|
||
// fmt.Println(strReqText)
|
||
var reqText wechat.SKBuiltinString_
|
||
reqText.Buffer = []byte(strReqText)
|
||
tmpLen := uint32(len(reqText.Buffer))
|
||
reqText.Len = &tmpLen
|
||
request.ReqText = &reqText
|
||
|
||
urlPath := "/cgi-bin/mmpay-bin/openwxhb"
|
||
RequestType := baseinfo.MMRequestTypeReceiveWxHB
|
||
// if hongBaoOpenItem.SceneID == uint32(1005) {
|
||
// // 企业外部群红包
|
||
// RequestType = uint32(5148)
|
||
// CgiCmd := uint32(0x141c)
|
||
// request.CgiCmd = &CgiCmd
|
||
// urlPath = "/cgi-bin/mmpay-bin/unionhb"
|
||
// //打开 "4536",
|
||
// //拆开 "5148",
|
||
//
|
||
// }
|
||
// fmt.Println("\nurlPath: ")
|
||
// fmt.Println(urlPath)
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, RequestType, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, urlPath, sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
func SendOpenUninoHB(userInfo *baseinfo.UserInfo, hongBaoOpenItem *baseinfo.HongBaoOpenItem) (*baseinfo.PackHeader, error) {
|
||
var request wechat.HongBaoReq
|
||
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// CgiCmd
|
||
request.CgiCmd = &hongBaoOpenItem.CgiCmd
|
||
//
|
||
|
||
// OutPutType
|
||
outputType := baseinfo.MMTenPayReqOutputTypeJSON
|
||
request.OutPutType = &outputType
|
||
|
||
// ReqText
|
||
strReqText := string("")
|
||
strReqText = strReqText + "channelId=" + hongBaoOpenItem.HongBaoURLItem.ChannelID + "&"
|
||
//strReqText = strReqText + "city=" + hongBaoOpenItem.City + "&"
|
||
strReqText = strReqText + "encrypt_key=" + baseutils.EscapeURL(userInfo.HBAesKeyEncrypted) + "&"
|
||
strReqText = strReqText + "encrypt_userinfo=" + baseutils.EscapeURL(GetEncryptUserInfo(userInfo)) + "&"
|
||
strReqText = strReqText + "headImg=" + baseutils.EscapeURL(hongBaoOpenItem.HeadImg) + "&"
|
||
strReqText = strReqText + "msgType=" + hongBaoOpenItem.HongBaoURLItem.MsgType + "&"
|
||
strReqText = strReqText + "nativeUrl=" + baseutils.EscapeURL(hongBaoOpenItem.NativeURL) + "&"
|
||
strReqText = strReqText + "nickName=" + baseutils.HongBaoStringToBytes(hongBaoOpenItem.NickName) + "&"
|
||
//strReqText = strReqText + "province=" + hongBaoOpenItem.Province + "&"
|
||
strReqText = strReqText + "sendId=" + hongBaoOpenItem.HongBaoURLItem.SendID + "&"
|
||
strReqText = strReqText + "sessionUserName=" + hongBaoOpenItem.HongBaoURLItem.SendUserName + "&"
|
||
strReqText = strReqText + "timingIdentifier=" + hongBaoOpenItem.TimingIdentifier + "&"
|
||
strReqText = strReqText + "union_source=0"
|
||
// fmt.Println("strReqText: ")
|
||
// fmt.Println(strReqText)
|
||
var reqText wechat.SKBuiltinString_
|
||
reqText.Buffer = []byte(strReqText)
|
||
tmpLen := uint32(len(reqText.Buffer))
|
||
reqText.Len = &tmpLen
|
||
request.ReqText = &reqText
|
||
|
||
urlPath := "/cgi-bin/mmpay-bin/unionhb/openunionhb"
|
||
RequestType := baseinfo.MMRequestTypeReceiveWxHB
|
||
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, RequestType, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, urlPath, sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendRedEnvelopeWxHB 发送查看红包详情请求
|
||
func SendRedEnvelopeWxHB(userInfo *baseinfo.UserInfo, hongBaoOpenItem *baseinfo.HongBaoOpenItem) (*baseinfo.PackHeader, error) {
|
||
var request wechat.HongBaoReq
|
||
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// CgiCmd
|
||
request.CgiCmd = &hongBaoOpenItem.CgiCmd
|
||
|
||
// OutPutType
|
||
outputType := baseinfo.MMTenPayReqOutputTypeJSON
|
||
request.OutPutType = &outputType
|
||
|
||
// ReqText
|
||
strReqText := string("")
|
||
strReqText = strReqText + "agreeDuty=1" + "&"
|
||
strReqText = strReqText + "inWay=1" + "&"
|
||
strReqText = strReqText + "channelId=" + hongBaoOpenItem.HongBaoURLItem.ChannelID + "&"
|
||
strReqText = strReqText + "msgType=" + hongBaoOpenItem.HongBaoURLItem.MsgType + "&"
|
||
strReqText = strReqText + "nativeUrl=" + baseutils.EscapeURL(hongBaoOpenItem.NativeURL) + "&"
|
||
strReqText = strReqText + "sendId=" + hongBaoOpenItem.HongBaoURLItem.SendID + "&"
|
||
strReqText = strReqText + "sessionUserName=" + hongBaoOpenItem.HongBaoURLItem.SendUserName + "&"
|
||
var reqText wechat.SKBuiltinString_
|
||
reqText.Buffer = []byte(strReqText)
|
||
tmpLen := uint32(len(reqText.Buffer))
|
||
reqText.Len = &tmpLen
|
||
request.ReqText = &reqText
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeQryDetailWxHB, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmpay-bin/qrydetailwxhb", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 查看红包领取列表
|
||
func SendGetRedPacketListRequest(userInfo *baseinfo.UserInfo, hongBaoOpenItem *baseinfo.GetRedPacketList) (*baseinfo.PackHeader, error) {
|
||
var request wechat.HongBaoReq
|
||
if hongBaoOpenItem.Limit == 0 {
|
||
hongBaoOpenItem.Limit = 11
|
||
}
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
// CgiCmd
|
||
request.CgiCmd = proto.Uint32(5)
|
||
// OutPutType
|
||
outputType := baseinfo.MMTenPayReqOutputTypeJSON
|
||
request.OutPutType = &outputType
|
||
// ReqText
|
||
strReqText := string("")
|
||
strReqText = strReqText + "channelId=" + hongBaoOpenItem.HongBaoItem.ChannelID + "&"
|
||
strReqText = strReqText + "msgType=" + hongBaoOpenItem.HongBaoItem.MsgType + "&"
|
||
strReqText = strReqText + "nativeUrl=" + baseutils.EscapeURL(hongBaoOpenItem.NativeURL) + "&province=&"
|
||
strReqText = strReqText + "sendId=" + hongBaoOpenItem.HongBaoItem.SendID + "&"
|
||
strReqText = strReqText + "limit=" + strconv.FormatInt(hongBaoOpenItem.Limit, 10) + "&"
|
||
strReqText = strReqText + "offset=" + strconv.FormatInt(hongBaoOpenItem.Offset, 10)
|
||
var reqText wechat.SKBuiltinString_
|
||
reqText.Buffer = []byte(strReqText)
|
||
tmpLen := uint32(len(reqText.Buffer))
|
||
reqText.Len = &tmpLen
|
||
request.ReqText = &reqText
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeQryDetailWxHB, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmpay-bin/qrydetailwxhb", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendCreatePreTransferRequest 创建转账
|
||
func SendCreatePreTransferRequest(userInfo *baseinfo.UserInfo, transferItem *req.CreatePreTransfer) (*baseinfo.PackHeader, error) {
|
||
description, fee, toUserName := transferItem.Description, transferItem.Fee, transferItem.ToUserName
|
||
var req_text = "delay_confirm_flag=0&desc=" + description + "&fee=" + strconv.Itoa(int(fee)) + "&fee_type=CNY&pay_scene=31&receiver_name=" + toUserName + "&scene=31&transfer_scene=2"
|
||
wcPaySign, err := TenPaySignDes3(req_text, "%^&*Tenpay!@#$")
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
req_text += "&WCPaySign=" + wcPaySign
|
||
tmpReqItem := &baseinfo.TenPayReqItem{}
|
||
tmpReqItem.CgiCMD = 0x53
|
||
tmpReqItem.ReqText = req_text
|
||
return SendWxPayTransferReq(userInfo, tmpReqItem)
|
||
}
|
||
|
||
// SendConfirmPreTransferRequest 确认转账
|
||
func SendConfirmPreTransferRequest(userInfo *baseinfo.UserInfo, transferItem *req.ConfirmPreTransfer) (*baseinfo.PackHeader, error) {
|
||
bankType, bankSerial := transferItem.BankType, transferItem.BankSerial
|
||
payPassword, reqKey := transferItem.PayPassword, transferItem.ReqKey
|
||
var req_text = "auto_deduct_flag=0&bank_type=" + bankType + "&bind_serial=" + bankSerial + "&busi_sms_flag=0&flag=3&passwd=" + payPassword + "&pay_scene=37&req_key=" + reqKey + "&use_touch=0"
|
||
wcPaySign, err := TenPaySignDes3(req_text, "%^&*Tenpay!@#$")
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
req_text += "&WCPaySign=" + wcPaySign
|
||
tmpReqItem := &baseinfo.TenPayReqItem{}
|
||
tmpReqItem.CgiCMD = 0
|
||
tmpReqItem.ReqText = req_text
|
||
return SendWxPayTransferReq(userInfo, tmpReqItem)
|
||
}
|
||
|
||
// SendWxPayTransferReq 发送微信支付之转账请求
|
||
func SendWxPayTransferReq(userInfo *baseinfo.UserInfo, reqItem *baseinfo.TenPayReqItem) (*baseinfo.PackHeader, error) {
|
||
var request wechat.TenPayRequest
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// CgiCmd
|
||
request.CgiCmd = &reqItem.CgiCMD
|
||
|
||
// OutPutType
|
||
outputType := baseinfo.MMTenPayReqOutputTypeJSON
|
||
request.OutPutType = &outputType
|
||
|
||
// ReqText
|
||
var reqTextSKBuf wechat.SKBuiltinString_
|
||
tmpLen := uint32(len(reqItem.ReqText))
|
||
reqTextSKBuf.Len = &tmpLen
|
||
reqTextSKBuf.Buffer = []byte(reqItem.ReqText)
|
||
request.ReqText = &reqTextSKBuf
|
||
|
||
// ReqTextWx
|
||
var wxReqTextSKBuf wechat.SKBuiltinString_
|
||
wxReqTextSKBuf.Buffer = []byte(reqItem.ReqText)
|
||
wxReqTextSKBuf.Len = &tmpLen
|
||
|
||
request.ReqTextWx = &wxReqTextSKBuf
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, 385, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/tenpay", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendTextMsg 发送文本消息请求 toWxid：接受人微信id，content：消息内容，atWxIDList：@用户微信id列表（toWxid只能是群的wxid，content应为：@用户昵称 @用户昵称 消息内容）
|
||
func SendTextMsg(userInfo *baseinfo.UserInfo, toWxid string, content string, atWxIDList []string, ContentType int) (*baseinfo.PackHeader, error) {
|
||
// 构造请求
|
||
var request wechat.NewSendMsgRequest
|
||
var count uint32 = 1
|
||
request.MsgCount = &count
|
||
var msgRequestNewList []*wechat.MicroMsgRequestNew = make([]*wechat.MicroMsgRequestNew, count)
|
||
var msgRequestNew wechat.MicroMsgRequestNew
|
||
var recvierString wechat.SKBuiltinString
|
||
recvierString.Str = &toWxid
|
||
msgRequestNew.ToUserName = &recvierString // 设置接收人wxid
|
||
msgRequestNew.Content = &content // 设置发送内容
|
||
if ContentType == 0 {
|
||
ContentType = 1
|
||
}
|
||
var tmpType uint32 = uint32(ContentType)
|
||
msgRequestNew.Type = &tmpType // 发送的类型
|
||
currentTime := time.Now()
|
||
misSecond := currentTime.UnixNano() / 1000000
|
||
var seconds = uint32(misSecond / 1000)
|
||
msgRequestNew.CreateTime = &seconds // 设置时间 秒为单位
|
||
seqID := time.Now().UnixNano() / int64(time.Millisecond)
|
||
var tmpCheckCode = WithSeqidCalcCheckCode(toWxid, seqID)
|
||
msgRequestNew.ClientMsgId = &tmpCheckCode // 设置校验码
|
||
|
||
// atUserList
|
||
var atUserStr = string("")
|
||
size := len(atWxIDList)
|
||
if size > 0 {
|
||
atUserStr = atUserStr + "<msgsource><atuserlist>"
|
||
for index := 0; index < size; index++ {
|
||
atUserStr = atUserStr + atWxIDList[index]
|
||
if index < size-1 {
|
||
atUserStr = atUserStr + ","
|
||
}
|
||
}
|
||
atUserStr = atUserStr + "</atuserlist></msgsource>"
|
||
msgRequestNew.MsgSource = &atUserStr
|
||
}
|
||
msgRequestNewList[0] = &msgRequestNew
|
||
request.ChatSendList = msgRequestNewList
|
||
|
||
// 发送请求
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, srcData, baseinfo.MMRequestTypeNewSendMsg, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/newsendmsg", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 发送图片v1.1
|
||
func SendUploadImageNewRequest(userInfo *baseinfo.UserInfo, imgData []byte, toUserName string) (*baseinfo.PackHeader, error) {
|
||
// 构造请求
|
||
var protobufdata []byte
|
||
imgStream := bytes.NewBuffer(imgData)
|
||
Startpos := 0
|
||
datalen := 50000
|
||
datatotalength := imgStream.Len()
|
||
ClientImgId := fmt.Sprintf("%v_%v", userInfo.WxId, time.Now().Unix())
|
||
I := 0
|
||
for {
|
||
Startpos = I * datalen
|
||
count := 0
|
||
if datatotalength-Startpos > datalen {
|
||
count = datalen
|
||
} else {
|
||
count = datatotalength - Startpos
|
||
}
|
||
if count < 0 {
|
||
break
|
||
}
|
||
Databuff := make([]byte, count)
|
||
_, _ = imgStream.Read(Databuff)
|
||
request := &wechat.UploadMsgImgRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
ClientImgId: &wechat.SKBuiltinString{
|
||
Str: proto.String(ClientImgId),
|
||
},
|
||
SenderWxid: &wechat.SKBuiltinString{
|
||
Str: proto.String(userInfo.WxId),
|
||
},
|
||
RecvWxid: &wechat.SKBuiltinString{
|
||
Str: proto.String(toUserName),
|
||
},
|
||
TotalLen: proto.Uint32(uint32(datatotalength)),
|
||
StartPos: proto.Uint32(uint32(Startpos)),
|
||
DataLen: proto.Uint32(uint32(len(Databuff))),
|
||
Data: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(Databuff))),
|
||
Buffer: Databuff,
|
||
},
|
||
MsgType: proto.Uint32(3),
|
||
EncryVer: proto.Uint32(0),
|
||
ReqTime: proto.Uint32(uint32(time.Now().Unix())),
|
||
MessageExt: proto.String("png"),
|
||
}
|
||
//序列化
|
||
srcData, _ := proto.Marshal(request)
|
||
sendData := Pack(userInfo, srcData, baseinfo.MMRequestTypeForwardCdnImage, 5)
|
||
// 发送请求
|
||
|
||
rsp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/uploadmsgimg", sendData)
|
||
if err != nil {
|
||
break
|
||
}
|
||
protobufdata = rsp
|
||
I++
|
||
}
|
||
return DecodePackHeader(protobufdata, nil)
|
||
}
|
||
|
||
// 发送企业oplog
|
||
func SendQWOpLogRequest(userInfo *baseinfo.UserInfo, cmdId int64, value []byte) (*baseinfo.PackHeader, error) {
|
||
var request wechat.QYOpLogRequest
|
||
request.Type = proto.Int64(cmdId)
|
||
request.V = value
|
||
// 发送请求
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, srcData, 806, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/openimoplog", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendOplogRequest 发送修改帐号信息请求
|
||
func SendOplogRequest(userInfo *baseinfo.UserInfo, modifyItems []*baseinfo.ModifyItem) (*baseinfo.PackHeader, error) {
|
||
var request wechat.OplogRequest
|
||
// CmdList
|
||
var oplog wechat.CmdList
|
||
count := uint32(len(modifyItems))
|
||
oplog.Count = &count
|
||
|
||
// ItemList
|
||
cmdItemList := make([]*wechat.CmdItem, count)
|
||
var index = uint32(0)
|
||
for ; index < count; index++ {
|
||
//Item
|
||
cmdItem := &wechat.CmdItem{}
|
||
cmdItem.CmdId = &modifyItems[index].CmdID
|
||
|
||
cmdBuf := &wechat.DATA{}
|
||
cmdBuf.Len = &modifyItems[index].Len
|
||
cmdBuf.Data = modifyItems[index].Data
|
||
cmdItem.CmdBuf = cmdBuf
|
||
cmdItemList[index] = cmdItem
|
||
}
|
||
oplog.ItemList = cmdItemList
|
||
request.Oplog = &oplog
|
||
|
||
// 发送请求
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, srcData, baseinfo.MMRequestTypeOplog, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/oplog", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendGetQRCodeRequest 获取二维码
|
||
func SendGetQRCodeRequest(userInfo *baseinfo.UserInfo, userName string) (*baseinfo.PackHeader, error) {
|
||
var request wechat.GetQRCodeRequest
|
||
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// opCode
|
||
opcode := uint32(0)
|
||
request.Opcode = &opcode
|
||
|
||
// style
|
||
style := uint32(0)
|
||
request.Style = &style
|
||
|
||
// UserName
|
||
var userNameSKBuffer wechat.SKBuiltinString
|
||
userNameSKBuffer.Str = &userName
|
||
request.UserName = &userNameSKBuffer
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetQrCode, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getqrcode", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, []byte(userName))
|
||
}
|
||
|
||
// SendLogOutRequest 发送登出请求
|
||
func SendLogOutRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
var request wechat.LogOutRequest
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
// 打包数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, srcData, 282, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/logout", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendSnsPostRequest 发送朋友圈
|
||
func SendSnsPostRequest(userInfo *baseinfo.UserInfo, postItem *baseinfo.SnsPostItem) (*baseinfo.PackHeader, error) {
|
||
var request wechat.SnsPostRequest
|
||
zeroValue32 := uint32(0)
|
||
zeroValue64 := uint64(0)
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// ObjectDesc
|
||
objectDescData := CreateSnsPostItemXML(userInfo.WxId, postItem)
|
||
if postItem.Xml {
|
||
objectDescData = []byte(postItem.Content)
|
||
}
|
||
|
||
length := uint32(len(objectDescData))
|
||
var objectDesc wechat.SKBuiltinString_
|
||
objectDesc.Len = &length
|
||
objectDesc.Buffer = objectDescData
|
||
request.ObjectDesc = &objectDesc
|
||
|
||
// WithUserListCount
|
||
withUserListCount := uint32(len(postItem.WithUserList))
|
||
request.WithUserListCount = &withUserListCount
|
||
// WithUserList
|
||
request.WithUserList = make([]*wechat.SKBuiltinString, withUserListCount)
|
||
index := uint32(0)
|
||
for ; index < withUserListCount; index++ {
|
||
withUser := &wechat.SKBuiltinString{}
|
||
withUser.Str = &postItem.WithUserList[index]
|
||
request.WithUserList[index] = withUser
|
||
}
|
||
|
||
// BlackListCount
|
||
blackListCount := uint32(len(postItem.BlackList))
|
||
request.BlackListCount = &blackListCount
|
||
// BlackList
|
||
request.BlackList = make([]*wechat.SKBuiltinString, blackListCount)
|
||
index = uint32(0)
|
||
for ; index < blackListCount; index++ {
|
||
blackUser := &wechat.SKBuiltinString{}
|
||
blackUser.Str = &postItem.BlackList[index]
|
||
request.BlackList[index] = blackUser
|
||
}
|
||
|
||
// GroupUserCount
|
||
groupUserCount := uint32(len(postItem.GroupUserList))
|
||
request.GroupUserCount = &groupUserCount
|
||
// GroupUser
|
||
request.GroupUser = make([]*wechat.SKBuiltinString, groupUserCount)
|
||
index = uint32(0)
|
||
for ; index < groupUserCount; index++ {
|
||
groupUser := &wechat.SKBuiltinString{}
|
||
groupUser.Str = &postItem.GroupUserList[index]
|
||
request.GroupUser[index] = groupUser
|
||
}
|
||
|
||
// otherFields
|
||
bgImageType := uint32(1)
|
||
request.PostBgimgType = &bgImageType
|
||
request.ObjectSource = &zeroValue32
|
||
request.ReferId = &zeroValue64
|
||
request.Privacy = &postItem.Privacy
|
||
request.SyncFlag = &zeroValue32
|
||
|
||
// ClientId
|
||
tmpTime := int(time.Now().UnixNano() / 1000000000)
|
||
tmpTimeStr := strconv.Itoa(tmpTime)
|
||
clientID := string("sns_post_")
|
||
clientID = clientID + userInfo.WxId + "_" + tmpTimeStr + "_0"
|
||
request.ClientId = &clientID
|
||
|
||
// groupCount
|
||
request.GroupCount = &zeroValue32
|
||
request.GroupIds = make([]*wechat.SnsGroup, zeroValue32)
|
||
|
||
// mediaInfoCount MediaInfo
|
||
mediaInfoCount := uint32(len(postItem.MediaList))
|
||
request.MediaInfoCount = &mediaInfoCount
|
||
request.MediaInfo = make([]*wechat.MediaInfo, mediaInfoCount)
|
||
for index := uint32(0); index < mediaInfoCount; index++ {
|
||
mediaInfo := &wechat.MediaInfo{}
|
||
source := uint32(2)
|
||
mediaInfo.Source = &source
|
||
|
||
// MediaType
|
||
mediaType := uint32(1)
|
||
if postItem.MediaList[index].Type == baseinfo.MMSNSMediaTypeImage {
|
||
mediaType = 1
|
||
}
|
||
mediaInfo.MediaType = &mediaType
|
||
|
||
// VideoPlayLength
|
||
mediaInfo.VideoPlayLength = &zeroValue32
|
||
|
||
// SessionId
|
||
currentTime := int(time.Now().UnixNano() / 1000000)
|
||
sessionID := "memonts-" + strconv.Itoa(currentTime)
|
||
mediaInfo.SessionId = &sessionID
|
||
|
||
// startTime
|
||
startTime := uint32(time.Now().UnixNano() / 1000000000)
|
||
mediaInfo.StartTime = &startTime
|
||
|
||
request.MediaInfo[index] = mediaInfo
|
||
}
|
||
|
||
// SnsPostOperationFields
|
||
var postOperationFields wechat.SnsPostOperationFields
|
||
postOperationFields.ContactTagCount = &zeroValue32
|
||
postOperationFields.TempUserCount = &zeroValue32
|
||
request.SnsPostOperationFields = &postOperationFields
|
||
|
||
// clientcheckdata
|
||
var extSpamInfo wechat.SKBuiltinString_
|
||
if userInfo.DeviceInfo != nil {
|
||
extSpamInfo.Buffer = GetExtPBSpamInfoDataIpad(userInfo)
|
||
} else {
|
||
extSpamInfo.Buffer = GetExtPBSpamInfoDataA16(userInfo)
|
||
}
|
||
extSpamInfoLen := uint32(len(extSpamInfo.Buffer))
|
||
extSpamInfo.Len = &extSpamInfoLen
|
||
request.ExtSpamInfo = &extSpamInfo
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeMMSnsPost, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/mmsnspost", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendSnsPostRequestByXML 通过XML的信息来发送朋友圈
|
||
func SendSnsPostRequestByXML(userInfo *baseinfo.UserInfo, timeLineObj *baseinfo.TimelineObject, blackList []string) (*baseinfo.PackHeader, error) {
|
||
if timeLineObj.ContentObjectVideo != nil {
|
||
return SendSnsPostRequestByXMLVideoNum(userInfo, timeLineObj, blackList)
|
||
}
|
||
var request wechat.SnsPostRequest
|
||
zeroValue32 := uint32(0)
|
||
zeroValue64 := uint64(0)
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// WithUserListCount
|
||
withUserListCount := uint32(0)
|
||
request.WithUserListCount = &withUserListCount
|
||
// WithUserList
|
||
request.WithUserList = make([]*wechat.SKBuiltinString, withUserListCount)
|
||
|
||
// BlackListCount
|
||
tmpCount := uint32(len(blackList))
|
||
request.BlackListCount = &tmpCount
|
||
request.BlackList = make([]*wechat.SKBuiltinString, tmpCount)
|
||
// BlackList
|
||
for index := uint32(0); index < tmpCount; index++ {
|
||
tmpSKBuiltinString := &wechat.SKBuiltinString{}
|
||
tmpSKBuiltinString.Str = &blackList[index]
|
||
request.BlackList[index] = tmpSKBuiltinString
|
||
}
|
||
|
||
// GroupUserCount
|
||
groupUserCount := uint32(0)
|
||
request.GroupUserCount = &groupUserCount
|
||
// GroupUser
|
||
request.GroupUser = make([]*wechat.SKBuiltinString, groupUserCount)
|
||
|
||
// otherFields
|
||
bgImageType := uint32(1)
|
||
request.PostBgimgType = &bgImageType
|
||
request.ObjectSource = &zeroValue32
|
||
request.ReferId = &zeroValue64
|
||
request.Privacy = &timeLineObj.Private
|
||
request.SyncFlag = &zeroValue32
|
||
|
||
// ClientId
|
||
tmpTime := int(time.Now().UnixNano() / 1000000000)
|
||
tmpTimeStr := strconv.Itoa(tmpTime)
|
||
clientID := string("sns_post_")
|
||
clientID = clientID + userInfo.WxId + "_" + tmpTimeStr + "_0"
|
||
request.ClientId = &clientID
|
||
|
||
// groupCount
|
||
request.GroupCount = &zeroValue32
|
||
request.GroupIds = make([]*wechat.SnsGroup, zeroValue32)
|
||
|
||
// mediaInfoCount MediaInfo
|
||
mediaInfoCount := uint32(len(timeLineObj.ContentObject.MediaList.Media))
|
||
request.MediaInfoCount = &mediaInfoCount
|
||
request.MediaInfo = make([]*wechat.MediaInfo, mediaInfoCount)
|
||
for index := uint32(0); index < mediaInfoCount; index++ {
|
||
tmpMediaItem := timeLineObj.ContentObject.MediaList.Media[index]
|
||
|
||
// 解析Source
|
||
mediaInfo := &wechat.MediaInfo{}
|
||
tmpSource := baseutils.ParseInt(tmpMediaItem.URL.Type)
|
||
mediaInfo.Source = &tmpSource
|
||
// MediaType
|
||
mediaType := tmpMediaItem.Type - 1
|
||
mediaInfo.MediaType = &mediaType
|
||
// VideoPlayLength
|
||
playLength := uint32(tmpMediaItem.VideoDuration)
|
||
mediaInfo.VideoPlayLength = &playLength
|
||
// SessionId
|
||
currentTime := int(time.Now().UnixNano() / 1000000)
|
||
sessionID := "memonts-" + strconv.Itoa(currentTime)
|
||
mediaInfo.SessionId = &sessionID
|
||
|
||
// startTime
|
||
startTime := uint32(time.Now().UnixNano() / 1000000000)
|
||
mediaInfo.StartTime = &startTime
|
||
request.MediaInfo[index] = mediaInfo
|
||
}
|
||
|
||
// ID和UserName置为0
|
||
timeLineObj.UserName = userInfo.WxId
|
||
timeLineObj.CreateTime = uint32(int(time.Now().UnixNano() / 1000000000))
|
||
// ObjectDesc
|
||
objectDescData, err := xml.Marshal(timeLineObj)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
str := string(objectDescData)
|
||
str = strings.ReplaceAll(str, "token=\"\"", "")
|
||
str = strings.ReplaceAll(str, "key=\"\"", "")
|
||
str = strings.ReplaceAll(str, "enc_idx=\"\"", "")
|
||
str = strings.ReplaceAll(str, "md5=\"\"", "")
|
||
str = strings.ReplaceAll(str, "videomd5=\"\"", "")
|
||
str = strings.ReplaceAll(str, "video", "")
|
||
objectDescData = []byte(str)
|
||
length := uint32(len(objectDescData))
|
||
var objectDesc wechat.SKBuiltinString_
|
||
objectDesc.Len = &length
|
||
objectDesc.Buffer = objectDescData
|
||
request.ObjectDesc = &objectDesc
|
||
|
||
// SnsPostOperationFields
|
||
var postOperationFields wechat.SnsPostOperationFields
|
||
postOperationFields.ContactTagCount = &zeroValue32
|
||
postOperationFields.TempUserCount = &zeroValue32
|
||
request.SnsPostOperationFields = &postOperationFields
|
||
|
||
// clientcheckdata
|
||
var extSpamInfo wechat.SKBuiltinString_
|
||
if userInfo.DeviceInfo != nil {
|
||
extSpamInfo.Buffer = GetExtPBSpamInfoDataIpad(userInfo)
|
||
} else {
|
||
extSpamInfo.Buffer = GetExtPBSpamInfoDataA16(userInfo)
|
||
}
|
||
extSpamInfoLen := uint32(len(extSpamInfo.Buffer))
|
||
extSpamInfo.Len = &extSpamInfoLen
|
||
request.ExtSpamInfo = &extSpamInfo
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeMMSnsPost, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/mmsnspost", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendSnsPostRequestByXML 通过XML的信息来发送朋友圈(视频号)
|
||
func SendSnsPostRequestByXMLVideoNum(userInfo *baseinfo.UserInfo, timeLineObj *baseinfo.TimelineObject, blackList []string) (*baseinfo.PackHeader, error) {
|
||
var request wechat.SnsPostRequest
|
||
zeroValue32 := uint32(0)
|
||
zeroValue64 := uint64(0)
|
||
fmt.Println("发布 视频号视频")
|
||
newTimeLineObj := &baseinfo.TimelineObjectVideo{
|
||
ID: timeLineObj.ID,
|
||
UserName: timeLineObj.UserName,
|
||
CreateTime: timeLineObj.CreateTime,
|
||
ContentDesc: timeLineObj.ContentDesc,
|
||
ContentDescShowType: timeLineObj.ContentDescShowType,
|
||
ContentDescScene: timeLineObj.ContentDescScene,
|
||
Private: timeLineObj.Private,
|
||
SightFolded: timeLineObj.SightFolded,
|
||
ShowFlag: timeLineObj.ShowFlag,
|
||
AppInfo: timeLineObj.AppInfo,
|
||
SourceUserName: timeLineObj.SourceUserName,
|
||
SourceNickName: timeLineObj.SourceNickName,
|
||
StatisticsData: timeLineObj.StatisticsData,
|
||
StatExtStr: timeLineObj.StatExtStr,
|
||
ContentObject: *timeLineObj.ContentObjectVideo,
|
||
ActionInfo: timeLineObj.ActionInfo,
|
||
Location: timeLineObj.Location,
|
||
PublicUserName: timeLineObj.PublicUserName,
|
||
StreamVideo: timeLineObj.StreamVideo,
|
||
}
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// WithUserListCount
|
||
withUserListCount := uint32(0)
|
||
request.WithUserListCount = &withUserListCount
|
||
// WithUserList
|
||
request.WithUserList = make([]*wechat.SKBuiltinString, withUserListCount)
|
||
|
||
// BlackListCount
|
||
tmpCount := uint32(len(blackList))
|
||
request.BlackListCount = &tmpCount
|
||
request.BlackList = make([]*wechat.SKBuiltinString, tmpCount)
|
||
// BlackList
|
||
for index := uint32(0); index < tmpCount; index++ {
|
||
tmpSKBuiltinString := &wechat.SKBuiltinString{}
|
||
tmpSKBuiltinString.Str = &blackList[index]
|
||
request.BlackList[index] = tmpSKBuiltinString
|
||
}
|
||
|
||
// GroupUserCount
|
||
groupUserCount := uint32(0)
|
||
request.GroupUserCount = &groupUserCount
|
||
// GroupUser
|
||
request.GroupUser = make([]*wechat.SKBuiltinString, groupUserCount)
|
||
|
||
// otherFields
|
||
bgImageType := uint32(1)
|
||
request.PostBgimgType = &bgImageType
|
||
request.ObjectSource = &zeroValue32
|
||
request.ReferId = &zeroValue64
|
||
request.Privacy = &newTimeLineObj.Private
|
||
request.SyncFlag = &zeroValue32
|
||
|
||
// ClientId
|
||
tmpTime := int(time.Now().UnixNano() / 1000000000)
|
||
tmpTimeStr := strconv.Itoa(tmpTime)
|
||
clientID := string("sns_post_")
|
||
clientID = clientID + userInfo.WxId + "_" + tmpTimeStr + "_0"
|
||
request.ClientId = &clientID
|
||
|
||
// groupCount
|
||
request.GroupCount = &zeroValue32
|
||
request.GroupIds = make([]*wechat.SnsGroup, zeroValue32)
|
||
|
||
// mediaInfoCount MediaInfo
|
||
mediaInfoCount := uint32(0)
|
||
request.MediaInfoCount = &mediaInfoCount
|
||
request.MediaInfo = make([]*wechat.MediaInfo, mediaInfoCount)
|
||
|
||
// ID和UserName置为0
|
||
newTimeLineObj.UserName = userInfo.WxId
|
||
newTimeLineObj.CreateTime = uint32(int(time.Now().UnixNano() / 1000000000))
|
||
// ObjectDesc
|
||
// 定义 XML 模板
|
||
const xmlTemplate = `<TimelineObject>
|
||
<id>{{.ID}}</id>
|
||
<username>{{.UserName}}</username>
|
||
<createTime>{{.CreateTime}}</createTime>
|
||
<contentDesc>{{.ContentDesc}}</contentDesc>
|
||
<contentDescShowType>{{.ContentDescShowType}}</contentDescShowType>
|
||
<contentDescScene>{{.ContentDescScene}}</contentDescScene>
|
||
<private>{{.Private}}</private>
|
||
<sightFolded>{{.SightFolded}}</sightFolded>
|
||
<showFlag>{{.ShowFlag}}</showFlag>
|
||
<appInfo>
|
||
<id>{{.AppInfo.ID}}</id>
|
||
<version>{{.AppInfo.Version}}</version>
|
||
<appName>{{.AppInfo.AppName}}</appName>
|
||
<installUrl>{{.AppInfo.InstallURL}}</installUrl>
|
||
<fromUrl>{{.AppInfo.FromURL}}</fromUrl>
|
||
<isForceUpdate>{{.AppInfo.IsForceUpdate}}</isForceUpdate>
|
||
</appInfo>
|
||
<sourceUserName>{{.SourceUserName}}</sourceUserName>
|
||
<sourceNickName>{{.SourceNickName}}</sourceNickName>
|
||
<statisticsData>{{.StatisticsData}}</statisticsData>
|
||
<statExtStr>{{.StatExtStr}}</statExtStr>
|
||
<ContentObject>
|
||
<finderFeed>
|
||
<objectId><![CDATA[{{.ContentObject.FinderFeed.ObjectId}}]]></objectId>
|
||
<nickname><![CDATA[{{.ContentObject.FinderFeed.Nickname}}]]></nickname>
|
||
<avatar><![CDATA[{{.ContentObject.FinderFeed.Avatar}}]]></avatar>
|
||
<mediaList>
|
||
{{range .ContentObject.FinderFeed.MediaList.Media}}
|
||
<media>
|
||
<mediaType>{{.MediaType}}</mediaType>
|
||
<url><![CDATA[{{.Url}}]]></url>
|
||
<thumbUrl><![CDATA[{{.ThumbUrl}}]]></thumbUrl>
|
||
<coverUrl><![CDATA[{{.CoverUrl}}]]></coverUrl>
|
||
<fullCoverUrl><![CDATA[{{.FullCoverUrl}}]]></fullCoverUrl>
|
||
<height>{{.Height}}</height>
|
||
<width>{{.Width}}</width>
|
||
<videoPlayDuration>{{.VideoPlayDuration}}</videoPlayDuration>
|
||
</media>
|
||
{{end}}
|
||
</mediaList>
|
||
</finderFeed>
|
||
</ContentObject>
|
||
<streamvideo>
|
||
<streamvideourl>{{.StreamVideo.StreamVideoURL}}</streamvideourl>
|
||
<streamvideothumburl>{{.StreamVideo.StreamVideoThumbURL}}</streamvideothumburl>
|
||
<streamvideoweburl>{{.StreamVideo.StreamVideoWebURL}}</streamvideoweburl>
|
||
</streamvideo>
|
||
</TimelineObject>`
|
||
|
||
// 创建模板
|
||
tmpl, err := template.New("xmlTemplate").Parse(xmlTemplate)
|
||
if err != nil {
|
||
fmt.Println("SendSnsPostRequestByXMLVideoNum Error parsing template:", err)
|
||
return nil, err
|
||
}
|
||
|
||
// 执行模板并写入到 buffer
|
||
var output bytes.Buffer
|
||
err = tmpl.Execute(&output, newTimeLineObj)
|
||
if err != nil {
|
||
fmt.Println("SendSnsPostRequestByXMLVideoNum Error executing template:", err)
|
||
return nil, err
|
||
}
|
||
|
||
// 正则表达式匹配 '><' 中间可能存在空白字符的情况
|
||
re := regexp.MustCompile(`>\s+<`)
|
||
// 替换为没有空白字符的 '><'
|
||
formattedXML := re.ReplaceAllString(strings.TrimSpace(output.String()), "><")
|
||
fmt.Println("Formatted XML:", formattedXML)
|
||
objectDescData := []byte(formattedXML)
|
||
length := uint32(len(objectDescData))
|
||
var objectDesc wechat.SKBuiltinString_
|
||
objectDesc.Len = &length
|
||
objectDesc.Buffer = objectDescData
|
||
request.ObjectDesc = &objectDesc
|
||
|
||
// SnsPostOperationFields
|
||
var postOperationFields wechat.SnsPostOperationFields
|
||
postOperationFields.ContactTagCount = &zeroValue32
|
||
postOperationFields.TempUserCount = &zeroValue32
|
||
request.SnsPostOperationFields = &postOperationFields
|
||
|
||
// clientcheckdata
|
||
var extSpamInfo wechat.SKBuiltinString_
|
||
if userInfo.DeviceInfo != nil {
|
||
extSpamInfo.Buffer = GetExtPBSpamInfoDataIpad(userInfo)
|
||
} else {
|
||
extSpamInfo.Buffer = GetExtPBSpamInfoDataA16(userInfo)
|
||
}
|
||
extSpamInfoLen := uint32(len(extSpamInfo.Buffer))
|
||
extSpamInfo.Len = &extSpamInfoLen
|
||
request.ExtSpamInfo = &extSpamInfo
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeMMSnsPost, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/mmsnspost", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendSnsObjectOpRequest 发送朋友圈操作
|
||
func SendSnsObjectOpRequest(userInfo *baseinfo.UserInfo, opItems []*baseinfo.SnsObjectOpItem) (*baseinfo.PackHeader, error) {
|
||
var request wechat.SnsObjectOpRequest
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// OpCount
|
||
opCount := uint32(len(opItems))
|
||
request.OpCount = &opCount
|
||
|
||
// OpList
|
||
request.OpList = make([]*wechat.SnsObjectOp, opCount)
|
||
index := uint32(0)
|
||
for ; index < opCount; index++ {
|
||
snsObject := &wechat.SnsObjectOp{}
|
||
id, _ := strconv.ParseUint(opItems[index].SnsObjID, 0, 64)
|
||
snsObject.Id = &id
|
||
snsObject.OpType = &opItems[index].OpType
|
||
if opItems[index].DataLen > 0 {
|
||
skBuffer := &wechat.SKBuiltinString_{}
|
||
skBuffer.Len = &opItems[index].DataLen
|
||
skBuffer.Buffer = opItems[index].Data
|
||
}
|
||
if opItems[index].Ext != 0 {
|
||
extInfo := &wechat.SnsObjectOpExt{
|
||
Id: &opItems[index].Ext,
|
||
}
|
||
CommnetId, _ := proto.Marshal(extInfo)
|
||
snsObject.Ext = &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(CommnetId))),
|
||
Buffer: CommnetId,
|
||
}
|
||
}
|
||
request.OpList[index] = snsObject
|
||
}
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeMMSnsObjectOp, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/mmsnsobjectop", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
func Uint32ToBytes(n uint32) []byte {
|
||
return []byte{
|
||
byte(n),
|
||
byte(n >> 8),
|
||
byte(n >> 16),
|
||
byte(n >> 24),
|
||
}
|
||
}
|
||
|
||
// SendSnsUserPageRequest 发送 获取朋友圈信息 请求
|
||
func SendSnsUserPageRequest(userInfo *baseinfo.UserInfo, userName string, firstPageMd5 string, maxID uint64) (*baseinfo.PackHeader, error) {
|
||
var request wechat.SnsUserPageRequest
|
||
var zeroValue64 = uint64(0)
|
||
var zeroValue32 = uint32(0)
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// 其它参数
|
||
request.Username = &userName
|
||
request.FirstPageMd5 = &firstPageMd5
|
||
request.MaxId = &maxID
|
||
request.MinFilterId = &zeroValue64
|
||
request.LastRequestTime = &zeroValue32
|
||
request.FilterType = &zeroValue32
|
||
|
||
// 打包数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, srcData, baseinfo.MMRequestTypeMMSnsUserPage, 5)
|
||
|
||
// 发送请求
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/mmsnsuserpage", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, srcData)
|
||
}
|
||
|
||
// SendSnsCommentRequest 发送评论/点赞请求
|
||
func SendSnsCommentRequest(userInfo *baseinfo.UserInfo, commentItem *baseinfo.SnsCommentItem) (*baseinfo.PackHeader, error) {
|
||
request := wechat.SnsCommentRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Action: &wechat.SnsActionGroup{
|
||
Id: &commentItem.ItemID,
|
||
ParentId: proto.Uint64(0),
|
||
CurrentAction: &wechat.SnsAction{
|
||
FromUsername: &userInfo.WxId,
|
||
ToUsername: &commentItem.ToUserName,
|
||
Type: &commentItem.OpType,
|
||
Source: proto.Uint32(6),
|
||
ReplyCommentId: &commentItem.ReplyCommentID,
|
||
Content: &commentItem.Content,
|
||
},
|
||
},
|
||
}
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeMMSnsComment, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/mmsnscomment", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 获取收藏lit
|
||
func SendFavSyncListRequest(userInfo *baseinfo.UserInfo, keyBuf string) (*baseinfo.PackHeader, error) {
|
||
var request wechat.FavSyncRequest
|
||
selector := uint32(1)
|
||
request.Selector = &selector
|
||
var skBufferT wechat.SKBuiltinString_
|
||
skBufferT.Len = proto.Uint32(0)
|
||
/*favSyncKeyLen := uint32(len(userInfo.FavSyncKey))
|
||
skBufferT.Len = &favSyncKeyLen
|
||
skBufferT.Buffer = userInfo.FavSyncKey*/
|
||
if keyBuf != "" {
|
||
key, _ := base64.StdEncoding.DecodeString(keyBuf)
|
||
skBufferT.Buffer = key
|
||
skBufferT.Len = proto.Uint32(uint32(len(key)))
|
||
}
|
||
request.KeyBuf = &skBufferT
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeFavSync, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/favsync", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendFavSyncRequest 同步收藏
|
||
func SendFavSyncRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
var request wechat.FavSyncRequest
|
||
|
||
// selector
|
||
selector := uint32(1)
|
||
request.Selector = &selector
|
||
|
||
var skBufferT wechat.SKBuiltinString_
|
||
favSyncKeyLen := uint32(len(userInfo.FavSyncKey))
|
||
skBufferT.Len = &favSyncKeyLen
|
||
skBufferT.Buffer = userInfo.FavSyncKey
|
||
request.KeyBuf = &skBufferT
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeFavSync, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/favsync", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendGetFavInfoRequest 获取 收藏信息
|
||
func SendGetFavInfoRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
var request wechat.GetFavInfoRequest
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetFavInfo, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getfavinfo", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendBatchGetFavItemRequest 获取单条收藏
|
||
func SendBatchGetFavItemRequest(userInfo *baseinfo.UserInfo, favID uint32) (*baseinfo.PackHeader, error) {
|
||
var request wechat.BatchGetFavItemRequest
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// Count
|
||
favIDCount := uint32(1)
|
||
request.Count = &favIDCount
|
||
|
||
// FavIdList
|
||
request.FavIdList = make([]byte, 0)
|
||
tmpBytes := baseutils.EncodeVByte32(favID)
|
||
request.FavIdList = append(request.FavIdList, tmpBytes[0:]...)
|
||
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeBatchGetFavItem, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/batchgetfavitem", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendBatchDelFavItemRequest 删除收藏项
|
||
func SendBatchDelFavItemRequest(userInfo *baseinfo.UserInfo, favID uint32) (*baseinfo.PackHeader, error) {
|
||
var request wechat.BatchDelFavItemRequest
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// Count
|
||
tmpCount := uint32(1)
|
||
request.Count = &tmpCount
|
||
|
||
// FavIdList
|
||
request.FavIdList = make([]byte, 0)
|
||
tmpBytes := baseutils.EncodeVByte32(favID)
|
||
request.FavIdList = append(request.FavIdList, tmpBytes[0:]...)
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeBatchDelFavItem, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/batchdelfavitem", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendGetCDNDnsRequest 获取该帐号的CdnDns信息
|
||
func SendGetCDNDnsRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
var request wechat.GetCDNDnsRequest
|
||
emptyString := string("")
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// ClientIp
|
||
request.ClientIp = &emptyString
|
||
|
||
// Scene
|
||
scene := uint32(1)
|
||
request.Scene = &scene
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetCdnDNS, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getcdndns", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendSnsObjectDetailRequest SendSnsObjectDetailRequest
|
||
func SendSnsObjectDetailRequest(userInfo *baseinfo.UserInfo, snsID uint64) (*baseinfo.PackHeader, error) {
|
||
var request wechat.SnsObjectDetailRequest
|
||
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
request.GroupDetail = proto.Uint32(0)
|
||
// ID
|
||
request.Id = &snsID
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeMMSnsObjectDetail, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/mmsnsobjectdetail", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendSnsSyncRequest 同步朋友圈
|
||
func SendSnsSyncRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
var request wechat.SnsSyncRequest
|
||
// baseRequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// Selector
|
||
tmpSelector := uint32(509)
|
||
request.Selector = &tmpSelector
|
||
|
||
// KeyBuf 第一次使用同步消息Key
|
||
tmpKeyBuffer := userInfo.SnsSyncKey
|
||
if len(tmpKeyBuffer) <= 0 {
|
||
tmpKeyBuffer = userInfo.SyncKey
|
||
}
|
||
tmpLen := uint32(len(tmpKeyBuffer))
|
||
var tmpKeyBuf wechat.SKBuiltinString_
|
||
tmpKeyBuf.Buffer = tmpKeyBuffer
|
||
tmpKeyBuf.Len = &tmpLen
|
||
request.KeyBuf = &tmpKeyBuf
|
||
|
||
// 打包数据 发送
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeMMSnsSync, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/mmsnssync", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendGetContactLabelListRequest 获取设置好的联系人标签列表
|
||
func SendGetContactLabelListRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
var request wechat.GetContactLabelListRequest
|
||
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetContactLabelList, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getcontactlabellist", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendAddContactLabelRequest 发送添加标签请求
|
||
func SendAddContactLabelRequest(userInfo *baseinfo.UserInfo, newLabelList []string) (*baseinfo.PackHeader, error) {
|
||
var request wechat.AddContactLabelRequest
|
||
labelID := uint32(0)
|
||
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// LabelCount
|
||
labelCount := uint32(len(newLabelList))
|
||
request.LabelCount = &labelCount
|
||
|
||
// LabelPairList
|
||
request.LabelPairList = make([]*wechat.LabelPair, labelCount)
|
||
for index := uint32(0); index < labelCount; index++ {
|
||
labelPair := &wechat.LabelPair{}
|
||
labelPair.LabelName = &newLabelList[index]
|
||
labelPair.LabelId = &labelID
|
||
request.LabelPairList[index] = labelPair
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeAddContactLabel, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/addcontactlabel", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendDelContactLabelRequest 删除标签
|
||
func SendDelContactLabelRequest(userInfo *baseinfo.UserInfo, labelId string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.DelContactLabelRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
LabelIdlist: proto.String(labelId),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeDelContactLabel, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/delcontactlabel", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendModifyLabelRequest 修改标签请求
|
||
func SendModifyLabelRequest(userInfo *baseinfo.UserInfo, userLabelList []baseinfo.UserLabelInfoItem) (*baseinfo.PackHeader, error) {
|
||
_userLabelList := make([]*wechat.UserLabelInfo, 0)
|
||
for _, item := range userLabelList {
|
||
_userLabelList = append(_userLabelList, &wechat.UserLabelInfo{
|
||
UserName: proto.String(item.UserName),
|
||
LabelIdlist: proto.String(item.LabelIDList),
|
||
})
|
||
}
|
||
req := wechat.ModifyContactLabelListRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
UserCount: proto.Uint32(uint32(len(_userLabelList))),
|
||
UserLabelInfoList: _userLabelList,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeModifyContactLabelList, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/modifycontactlabellist", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendBindQueryNewRequest SendBindQueryNewRequest
|
||
func SendBindQueryNewRequest(userInfo *baseinfo.UserInfo, reqItem *baseinfo.TenPayReqItem) (*baseinfo.PackHeader, error) {
|
||
var request wechat.TenPayRequest
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// CgiCmd
|
||
request.CgiCmd = &reqItem.CgiCMD
|
||
|
||
// OutPutType
|
||
outputType := baseinfo.MMTenPayReqOutputTypeJSON
|
||
request.OutPutType = &outputType
|
||
|
||
// ReqText
|
||
var reqTextSKBuf wechat.SKBuiltinString_
|
||
tmpLen := uint32(len(reqItem.ReqText))
|
||
reqTextSKBuf.Len = &tmpLen
|
||
reqTextSKBuf.Buffer = []byte(reqItem.ReqText)
|
||
request.ReqText = &reqTextSKBuf
|
||
|
||
// ReqTextWx
|
||
var wxReqTextSKBuf wechat.SKBuiltinString_
|
||
tmpText := "encrypt_key=" + userInfo.HBAesKeyEncrypted
|
||
tmpText = tmpText + "&encrypt_userinfo=" + GetEncryptUserInfo(userInfo)
|
||
tmpWXLen := uint32(len(tmpText))
|
||
wxReqTextSKBuf.Len = &tmpWXLen
|
||
wxReqTextSKBuf.Buffer = []byte(tmpText)
|
||
request.ReqTextWx = &wxReqTextSKBuf
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeBindQueryNew, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmpay-bin/tenpay/bindquerynew", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 确定收款
|
||
func SendTenPayRequest(userInfo *baseinfo.UserInfo, reqItem *baseinfo.TenPayReqItem) (*baseinfo.PackHeader, error) {
|
||
var request wechat.TenPayRequest
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// CgiCmd
|
||
request.CgiCmd = &reqItem.CgiCMD
|
||
|
||
// OutPutType
|
||
outputType := baseinfo.MMTenPayReqOutputTypeJSON
|
||
request.OutPutType = &outputType
|
||
|
||
// ReqText
|
||
var reqTextSKBuf wechat.SKBuiltinString_
|
||
tmpLen := uint32(len(reqItem.ReqText))
|
||
reqTextSKBuf.Len = &tmpLen
|
||
reqTextSKBuf.Buffer = []byte(reqItem.ReqText)
|
||
request.ReqText = &reqTextSKBuf
|
||
|
||
// ReqTextWx
|
||
var wxReqTextSKBuf wechat.SKBuiltinString_
|
||
wxReqTextSKBuf.Buffer = []byte(reqItem.ReqText)
|
||
wxReqTextSKBuf.Len = &tmpLen
|
||
|
||
request.ReqTextWx = &wxReqTextSKBuf
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendEncodeData := Pack(userInfo, srcData, 385, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/tenpay", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendSnsTimeLineRequest 发送获取朋友圈请求
|
||
func SendSnsTimeLineRequest(userInfo *baseinfo.UserInfo, firstPageMD5 string, maxID uint64) (*baseinfo.PackHeader, error) {
|
||
/*var request wechat.SnsTimeLineRequest
|
||
// baserequest
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
request.BaseRequest = baseReq
|
||
|
||
// ClientLatestId
|
||
tmpLatestID := uint64(0)
|
||
request.ClientLatestId = &tmpLatestID
|
||
// FirstPageMd5
|
||
request.FirstPageMd5 = &firstPageMD5
|
||
// LastRequestTime
|
||
lastRequestTime := uint32(0)
|
||
request.LastRequestTime = &lastRequestTime
|
||
// MAXID
|
||
request.MaxId = &maxID
|
||
// MinFilterId
|
||
minFilterID := uint64(0)
|
||
request.MinFilterId = &minFilterID
|
||
// NetworkType
|
||
netWorkType := uint32(1)
|
||
request.NetworkType = &netWorkType*/
|
||
|
||
req := &wechat.SnsTimeLineRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
ClientLatestId: proto.Uint64(0),
|
||
FirstPageMd5: proto.String(firstPageMD5),
|
||
LastRequestTime: proto.Uint32(0),
|
||
MaxId: proto.Uint64(maxID),
|
||
MinFilterId: proto.Uint64(0),
|
||
NetworkType: proto.Uint32(1),
|
||
}
|
||
baseReq := GetBaseRequest(userInfo)
|
||
var tmpScene = uint32(0)
|
||
baseReq.Scene = &tmpScene
|
||
req.BaseRequest = baseReq
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeMMSnsTimeLine, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/mmsnstimeline", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// StatusNotify 发送状态通知
|
||
func StatusNotify(userInfo *baseinfo.UserInfo, toWxid string) (*baseinfo.PackHeader, error) {
|
||
// 构造请求
|
||
request := wechat.StatusNotifyRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Code: proto.Uint32(2),
|
||
FromUserName: proto.String(userInfo.GetUserName()),
|
||
ToUserName: proto.String(toWxid),
|
||
ClientMsgId: proto.String(fmt.Sprintf("%v_%v", toWxid, time.Now().Unix())),
|
||
}
|
||
|
||
// 发送请求
|
||
srcData, _ := proto.Marshal(&request)
|
||
sendData := Pack(userInfo, srcData, baseinfo.MMRequestTypeStatusNotify, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/statusnotify", sendData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendAppMsgRequest 发送App消息
|
||
func SendAppMsgRequest(userInfo *baseinfo.UserInfo, contentType uint32, toUserName, xml string) (*baseinfo.PackHeader, error) {
|
||
curTime := time.Now().Unix()
|
||
req := wechat.SendAppMsgRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Msg: &wechat.AppMsg{
|
||
FromUserName: proto.String(userInfo.GetUserName()),
|
||
AppId: proto.String(""),
|
||
SdkVersion: proto.Uint32(0),
|
||
ToUserName: proto.String(toUserName),
|
||
Type: proto.Uint32(contentType),
|
||
Content: proto.String(xml),
|
||
CreateTime: proto.Uint32(uint32(curTime)),
|
||
ClientMsgId: proto.String(fmt.Sprintf("%s_%v", toUserName, curTime)),
|
||
Source: proto.Int32(0),
|
||
RemindId: proto.Int32(0),
|
||
MsgSource: proto.String(""),
|
||
Thumb: &wechat.BufferT{
|
||
ILen: proto.Uint32(0),
|
||
Buffer: []byte{},
|
||
},
|
||
},
|
||
FromSence: proto.String(""),
|
||
DirectShare: proto.Int32(0),
|
||
SendMsgTicket: proto.String(""),
|
||
}
|
||
|
||
// 打包发送数据
|
||
src, _ := proto.Marshal(&req)
|
||
|
||
sendEncodeData := Pack(userInfo, src, baseinfo.MMRequestTypeSendAppMsg, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/sendappmsg", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendEmojiRequest 发生表情
|
||
func SendEmojiRequest(userInfo *baseinfo.UserInfo, toUserName, Md5 string, length int32) (*baseinfo.PackHeader, error) {
|
||
baseRequest := GetBaseRequest(userInfo)
|
||
//baseRequest.Scene = proto.Uint32(0)
|
||
req := wechat.UploadEmojiRequest{
|
||
BaseRequest: baseRequest,
|
||
EmojiItemCount: proto.Int32(1),
|
||
EmojiItem: []*wechat.EmojiUploadInfoReq{
|
||
{
|
||
MD5: proto.String(Md5),
|
||
StartPos: proto.Int32(length),
|
||
TotalLen: proto.Int32(length),
|
||
EmojiBuffer: &wechat.BufferT{
|
||
ILen: proto.Uint32(0),
|
||
Buffer: []byte{},
|
||
},
|
||
Type: proto.Int32(2),
|
||
ToUserName: proto.String(toUserName),
|
||
ClientMsgID: proto.String(fmt.Sprintf("%d", time.Now().UnixNano()/1000/1000)),
|
||
},
|
||
},
|
||
}
|
||
|
||
// 打包发送数据
|
||
src, _ := proto.Marshal(&req)
|
||
|
||
sendEncodeData := Pack(userInfo, src, baseinfo.MMRequestTypeSendEmoji, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/sendemoji", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 发送表情 new 包含动图
|
||
func ForwardEmojiRequest(userInfo *baseinfo.UserInfo, toUserName, Md5 string, length int32) (*baseinfo.PackHeader, error) {
|
||
baseRequest := GetBaseRequest(userInfo)
|
||
//baseRequest.Scene = proto.Uint32(0)
|
||
req := wechat.UploadEmojiRequest{
|
||
BaseRequest: baseRequest,
|
||
EmojiItemCount: proto.Int32(1),
|
||
EmojiItem: []*wechat.EmojiUploadInfoReq{
|
||
{
|
||
MD5: proto.String(Md5),
|
||
StartPos: proto.Int32(0),
|
||
TotalLen: proto.Int32(length),
|
||
EmojiBuffer: &wechat.BufferT{
|
||
ILen: proto.Uint32(0),
|
||
Buffer: []byte{},
|
||
},
|
||
Type: proto.Int32(1),
|
||
ToUserName: proto.String(toUserName),
|
||
ClientMsgID: proto.String(strconv.FormatInt(time.Now().Unix(), 10)),
|
||
},
|
||
},
|
||
}
|
||
|
||
// 打包发送数据
|
||
src, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, src, baseinfo.MMRequestTypeSendEmoji, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/sendemoji", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 下载语音
|
||
func SendGetMsgVoiceRequest(userInfo *baseinfo.UserInfo, toUserName, NewMsgIds, Bufid string, Length int) (*vo.DownloadVoiceData, error) {
|
||
I := 0
|
||
Startpos := 0
|
||
datalen := 50000
|
||
Databuff := make([]byte, Length+1000)
|
||
var VoiceLength uint32
|
||
totalBytesDownloaded := 0
|
||
maxIterations := (Length + datalen - 1) / datalen
|
||
NewMsgId, _ := strconv.ParseUint(NewMsgIds, 10, 64)
|
||
MasterBufId, _ := strconv.ParseUint(Bufid, 10, 64)
|
||
resp := new(wechat.DownloadVoiceResponse)
|
||
for {
|
||
if I >= maxIterations {
|
||
return nil, fmt.Errorf("超过最大可下载tier(%d)", maxIterations)
|
||
}
|
||
Startpos = I * datalen
|
||
count := 0
|
||
remainingBytes := Length - Startpos
|
||
if remainingBytes <= 0 {
|
||
break
|
||
}
|
||
if remainingBytes > datalen {
|
||
count = datalen
|
||
} else {
|
||
count = remainingBytes
|
||
}
|
||
req := wechat.DownloadVoiceRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
MsgId: proto.Uint32(0),
|
||
Offset: proto.Uint32(uint32(Startpos)),
|
||
Length: proto.Uint32(uint32(count)),
|
||
NewMsgId: proto.Uint64(NewMsgId),
|
||
ChatRoomName: proto.String(toUserName),
|
||
MasterBufId: proto.Uint64(MasterBufId),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeDownloadVoice, 5)
|
||
|
||
res, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/downloadvoice", sendEncodeData)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("network error downloading voice chunk %d at offset %d: %w", I+1, Startpos, err)
|
||
}
|
||
header, err := DecodePackHeader(res, nil)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("failed to decode response header for chunk %d at offset %d: %w", I+1, Startpos, err)
|
||
}
|
||
err = ParseResponseData(userInfo, header, resp)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("failed to parse response data for chunk %d at offset %d: %w", I+1, Startpos, err)
|
||
}
|
||
if resp.GetBaseResponse().GetRet() != 0 {
|
||
return nil, fmt.Errorf("server returned error %d for chunk %d at offset %d", resp.GetBaseResponse().GetRet(), I+1, Startpos)
|
||
}
|
||
// Fix: Write chunk data to correct buffer position instead of overwriting
|
||
// Validate chunk response before processing
|
||
if resp.GetData() == nil {
|
||
return nil, fmt.Errorf("chunk %d at offset %d: response data is nil", I+1, Startpos)
|
||
}
|
||
|
||
chunkData := resp.GetData().GetBuffer()
|
||
chunkSize := len(chunkData)
|
||
|
||
// Validate that chunk data length matches expected size
|
||
expectedChunkSize := count
|
||
if chunkSize != expectedChunkSize {
|
||
return nil, fmt.Errorf("chunk %d at offset %d: expected %d bytes, got %d bytes", I+1, Startpos, expectedChunkSize, chunkSize)
|
||
}
|
||
|
||
// Ensure proper handling of the last chunk which may be smaller
|
||
if I > 0 && chunkSize > datalen {
|
||
return nil, fmt.Errorf("chunk %d at offset %d: chunk size %d exceeds maximum chunk size %d", I+1, Startpos, chunkSize, datalen)
|
||
}
|
||
|
||
// Calculate the correct offset for this chunk
|
||
bufferOffset := Startpos
|
||
|
||
// Buffer bounds checking - prevent buffer overflow
|
||
if bufferOffset+chunkSize > len(Databuff) {
|
||
return nil, fmt.Errorf("buffer overflow: chunk at offset %d with size %d exceeds buffer capacity %d",
|
||
bufferOffset, chunkSize, len(Databuff))
|
||
}
|
||
|
||
// Validate that chunk data fits within allocated buffer space
|
||
if bufferOffset < 0 || bufferOffset >= len(Databuff) {
|
||
return nil, fmt.Errorf("invalid buffer offset: %d, buffer size: %d", bufferOffset, len(Databuff))
|
||
}
|
||
|
||
// Copy chunk data to the correct position in the buffer
|
||
copy(Databuff[bufferOffset:bufferOffset+chunkSize], chunkData)
|
||
|
||
// Track bytes downloaded in this chunk
|
||
totalBytesDownloaded += chunkSize
|
||
|
||
// Progress tracking for validation and debugging
|
||
progressPercent := float64(totalBytesDownloaded) / float64(Length) * 100
|
||
_ = progressPercent // Available for debugging if needed
|
||
|
||
VoiceLength = resp.GetVoiceLength()
|
||
I++
|
||
|
||
// Ensure loop exits when all expected data is downloaded
|
||
if totalBytesDownloaded >= Length {
|
||
break
|
||
}
|
||
}
|
||
|
||
// Validate that downloaded length matches expected Length parameter
|
||
if totalBytesDownloaded != Length {
|
||
return nil, fmt.Errorf("download incomplete: expected %d bytes, but downloaded %d bytes", Length, totalBytesDownloaded)
|
||
}
|
||
|
||
return &vo.DownloadVoiceData{
|
||
Base64: Databuff,
|
||
VoiceLength: VoiceLength,
|
||
}, nil
|
||
}
|
||
|
||
// 群发图片
|
||
func SendGroupMassMsgImage(userInfo *baseinfo.UserInfo, toUSerName []string, ImageBase64 []byte) (*baseinfo.PackHeader, error) {
|
||
baseRequest := GetBaseRequest(userInfo)
|
||
baseRequest.Scene = proto.Uint32(0)
|
||
toList := strings.Join(toUSerName, ";")
|
||
tolistmd5 := baseutils.MD5ToLower(toList)
|
||
ClientImgId := fmt.Sprintf("%v_%v", time.Now().Unix(), tolistmd5)
|
||
var protobufdata []byte
|
||
imgStream := bytes.NewBuffer(ImageBase64)
|
||
Startpos := 0
|
||
datalen := 50000
|
||
datatotalength := imgStream.Len()
|
||
I := 0
|
||
for {
|
||
Startpos = I * datalen
|
||
count := 0
|
||
if datatotalength-Startpos > datalen {
|
||
count = datalen
|
||
} else {
|
||
count = datatotalength - Startpos
|
||
}
|
||
if count < 0 {
|
||
break
|
||
}
|
||
Databuff := make([]byte, count)
|
||
_, _ = imgStream.Read(Databuff)
|
||
req := wechat.MassSendRequest{
|
||
BaseRequest: baseRequest,
|
||
ToList: proto.String(toList),
|
||
ToListMd5: proto.String(tolistmd5),
|
||
ClientId: proto.String(ClientImgId),
|
||
MsgType: proto.Uint64(3),
|
||
MediaTime: proto.Uint64(0),
|
||
DataBuffer: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(Databuff))),
|
||
Buffer: Databuff,
|
||
},
|
||
DataStartPos: proto.Uint64(uint64(Startpos)),
|
||
DataTotalLen: proto.Uint64(uint64(len(Databuff))),
|
||
ThumbTotalLen: proto.Uint64(0),
|
||
ThumbStartPos: proto.Uint64(0),
|
||
ThumbData: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(0),
|
||
Buffer: []byte{},
|
||
},
|
||
CameraType: proto.Uint64(2),
|
||
VideoSource: proto.Uint64(0),
|
||
ToListCount: proto.Uint64(uint64(len(toUSerName))),
|
||
IsSendAgain: proto.Uint64(0),
|
||
CompressType: proto.Uint64(1),
|
||
VoiceFormat: proto.Uint64(0),
|
||
}
|
||
// 打包发送数据
|
||
src, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, src, 193, 5)
|
||
|
||
rsp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/masssend", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
protobufdata = rsp
|
||
I++
|
||
}
|
||
return DecodePackHeader(protobufdata, nil)
|
||
}
|
||
|
||
func SendGroupMassMsgText(userInfo *baseinfo.UserInfo, toUSerName []string, content string) (*baseinfo.PackHeader, error) {
|
||
baseRequest := GetBaseRequest(userInfo)
|
||
// baseRequest.Scene = proto.Uint32(0)
|
||
toList := strings.Join(toUSerName, ";")
|
||
tolistmd5 := baseutils.MD5ToLower(toList)
|
||
Databuff := []byte(content)
|
||
ClientImgId := fmt.Sprintf("%v_%v", time.Now().Unix(), tolistmd5)
|
||
fmt.Println("toList:", toList, "tolistmd5:", tolistmd5)
|
||
req := wechat.MassSendRequest{
|
||
BaseRequest: baseRequest,
|
||
ToList: proto.String(toList),
|
||
ToListMd5: proto.String(tolistmd5),
|
||
ClientId: proto.String(ClientImgId),
|
||
MsgType: proto.Uint64(1),
|
||
MediaTime: proto.Uint64(0),
|
||
DataBuffer: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(Databuff))),
|
||
Buffer: Databuff,
|
||
},
|
||
DataStartPos: proto.Uint64(0),
|
||
DataTotalLen: proto.Uint64(uint64(len(Databuff))),
|
||
ThumbTotalLen: proto.Uint64(0),
|
||
ThumbStartPos: proto.Uint64(0),
|
||
ThumbData: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(0),
|
||
Buffer: []byte{},
|
||
},
|
||
CameraType: proto.Uint64(2),
|
||
VideoSource: proto.Uint64(0),
|
||
ToListCount: proto.Uint64(uint64(len(toUSerName))),
|
||
IsSendAgain: proto.Uint64(1),
|
||
CompressType: proto.Uint64(0),
|
||
VoiceFormat: proto.Uint64(0),
|
||
}
|
||
// 打包发送数据
|
||
src, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, src, 193, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/masssend", sendEncodeData)
|
||
fmt.Println("resp:", string(resp))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetChatroomMemberDetailRequest 获取群成员详细
|
||
func GetChatroomMemberDetailRequest(userInfo *baseinfo.UserInfo, roomId string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.GetChatroomMemberDetailRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
ChatroomWxid: proto.String(roomId),
|
||
ClientVersion: proto.Uint32(0),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetChatRoomMemberDetail, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getchatroommemberdetail", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 群拍一拍
|
||
func SendSendPatRequest(userInfo *baseinfo.UserInfo, chatRoomName string, toUserName string, scene int64) (*baseinfo.PackHeader, error) {
|
||
ClientImgId := fmt.Sprintf("%v_%v_%v", userInfo.WxId, toUserName, time.Now().Unix())
|
||
req := wechat.SendPatRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
FromUsername: proto.String(userInfo.WxId),
|
||
ChatUsername: proto.String(chatRoomName),
|
||
PattedUsername: proto.String(toUserName),
|
||
ClientMsgId: proto.String(ClientImgId),
|
||
Scene: proto.Int64(scene),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 849, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/sendpat", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SetChatRoomAnnouncementRequest 设置群公告
|
||
func SetChatRoomAnnouncementRequest(userInfo *baseinfo.UserInfo, roomId, content string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.SetChatRoomAnnouncementRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
ChatRoomName: proto.String(roomId),
|
||
Announcement: proto.String(content),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeSetChatRoomAnnouncement, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/setchatroomannouncement", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 同意入群
|
||
func JoinGroupRequest(fullUrl string) (*wechat.JoinChatRoomResponse, error) {
|
||
client := &http.Client{
|
||
CheckRedirect: func(req *http.Request, via []*http.Request) error {
|
||
return http.ErrUseLastResponse
|
||
},
|
||
}
|
||
|
||
req, err := http.NewRequest("POST", fullUrl, strings.NewReader("s=1"))
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("异常：%v", err.Error()))
|
||
}
|
||
|
||
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
||
resp, err := client.Do(req)
|
||
if err != nil {
|
||
return nil, errors.New(fmt.Sprintf("异常：%v", err.Error()))
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
if resp.StatusCode == 302 {
|
||
QID := strings.Replace(resp.Header.Get("Location"), "weixin://jump/mainframe/", "", -1)
|
||
response := wechat.JoinChatRoomResponse{}
|
||
response.QID = QID
|
||
response.Msg = "入群成功"
|
||
return &response, nil
|
||
}
|
||
|
||
str, _ := ioutil.ReadAll(resp.Body)
|
||
return nil, errors.New(fmt.Sprintf("异常：%v", string(str)))
|
||
}
|
||
|
||
// 获取群详细
|
||
func SetGetChatRoomInfoDetailRequest(userInfo *baseinfo.UserInfo, roomId string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.GetChatRoomInfoDetailRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
ChatRoomName: proto.String(roomId),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetChatRoomInfoDetail, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getchatroominfodetail", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
//保存群聊操作
|
||
/*func SetMoveToContractRequest(userInfo *baseinfo.UserInfo, ChatRoomName string, Val uint32) (*baseinfo.PackHeader, error) {
|
||
UserNameListSplit := strings.Split(ChatRoomName, ",")
|
||
|
||
|
||
req := wechat.GetChatRoomInfoDetailRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
ChatRoomName: proto.String(roomId),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetChatRoomInfoDetail, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getchatroominfodetail", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}*/
|
||
|
||
// GetCreateChatRoomEntity 创建群
|
||
func GetCreateChatRoomEntity(userInfo *baseinfo.UserInfo, topIc string, userList []string) (*baseinfo.PackHeader, error) {
|
||
userList = append([]string{userInfo.GetUserName()}, userList...)
|
||
memberList := make([]*wechat.MemberReq, 0)
|
||
for _, user := range userList {
|
||
memberList = append(memberList, &wechat.MemberReq{
|
||
MemberName: &wechat.SKBuiltinString{
|
||
Str: proto.String(user),
|
||
},
|
||
})
|
||
}
|
||
req := wechat.CreateChatRoomRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Topic: &wechat.SKBuiltinString{
|
||
Str: proto.String(topIc),
|
||
},
|
||
MemberCount: proto.Uint32(uint32(len(memberList))),
|
||
MemberList: memberList,
|
||
Scene: proto.Uint32(0),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeCreateChatRoom, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/createchatroom", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 添加群管理
|
||
func SendAddChatroomAdmin(userInfo *baseinfo.UserInfo, chatRoomName string, userList []string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.AddChatRoomAdminRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
ChatRoomName: proto.String(chatRoomName),
|
||
UserNameList: userList,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 889, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/addchatroomadmin", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetQrCodeRequest 获取(群聊/个人)二维码
|
||
func GetQrCodeRequest(userInfo *baseinfo.UserInfo, id string, style uint32) (*baseinfo.PackHeader, error) {
|
||
req := wechat.GetQRCodeRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
UserName: &wechat.SKBuiltinString{
|
||
Str: proto.String(id),
|
||
},
|
||
Style: proto.Uint32(style),
|
||
Opcode: proto.Uint32(1), // 安卓 0(群二维码) 1(个人二维码)
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetQrCode, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getqrcode", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 删除群管理
|
||
func SendDelChatroomAdminRequest(userInfo *baseinfo.UserInfo, chatRoomName string, userList []string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.DelChatRoomAdminRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
ChatRoomName: proto.String(chatRoomName),
|
||
UserNameList: userList,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 259, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/delchatroomadmin", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 获取群列表
|
||
func SendWXSyncContactRequest(userInfo *baseinfo.UserInfo, key []byte) (*baseinfo.PackHeader, error) {
|
||
keyBuf := userInfo.SyncKey
|
||
if key != nil {
|
||
keyBuf = key
|
||
}
|
||
osType := ""
|
||
if userInfo.DeviceInfoA16 != nil {
|
||
osType = baseinfo.AndroidDeviceType
|
||
} else {
|
||
osType = userInfo.DeviceInfo.OsType
|
||
}
|
||
req := wechat.NewSyncRequest{
|
||
Oplog: &wechat.CmdList{
|
||
Count: proto.Uint32(0),
|
||
},
|
||
DeviceType: proto.String(osType),
|
||
Scene: proto.Uint32(3), //有时候03，有时候01
|
||
Selector: proto.Uint32(7), // 7
|
||
SyncMsgDigest: proto.Uint32(baseinfo.MMSyncMsgDigestTypeShortLink),
|
||
KeyBuf: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(keyBuf))),
|
||
Buffer: keyBuf,
|
||
},
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 138, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/newsync", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 搜手机或企业对外名片链接提取验证
|
||
func SendQWSearchContactRequest(userInfo *baseinfo.UserInfo, tg string, fromScene uint64, userName string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.SearchQYContactRequest{}
|
||
if utils.IsMobile(tg) {
|
||
req.Tg = proto.String(tg)
|
||
req.FromScene = proto.Uint64(1)
|
||
} else {
|
||
req.UserName = proto.String(tg)
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 372, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/searchopenimcontact", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetAddChatRoomMemberRequest 拉人
|
||
func GetAddChatRoomMemberRequest(userInfo *baseinfo.UserInfo, chatRoomName string, userList []string) (*baseinfo.PackHeader, error) {
|
||
memberList := make([]*wechat.MemberReq, 0)
|
||
for _, user := range userList {
|
||
memberList = append(memberList, &wechat.MemberReq{
|
||
MemberName: &wechat.SKBuiltinString{
|
||
Str: proto.String(user),
|
||
},
|
||
})
|
||
}
|
||
|
||
req := wechat.AddChatRoomMemberRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
MemberCount: proto.Uint32(uint32(len(memberList))),
|
||
MemberList: memberList,
|
||
ChatRoomName: &wechat.SKBuiltinString{
|
||
Str: proto.String(chatRoomName),
|
||
},
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeAddChatRoomMember, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/addchatroommember", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// DelDelChatRoomMember 删除群成员
|
||
func DelDelChatRoomMemberRequest(userInfo *baseinfo.UserInfo, chatRoomName string, delUserList []string) (*baseinfo.PackHeader, error) {
|
||
memberList := make([]*wechat.DelMemberReq, 0)
|
||
for _, user := range delUserList {
|
||
memberList = append(memberList, &wechat.DelMemberReq{
|
||
MemberName: &wechat.SKBuiltinString{
|
||
Str: proto.String(user),
|
||
},
|
||
})
|
||
}
|
||
|
||
req := wechat.DelChatRoomMemberRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
MemberCount: proto.Uint32(uint32(len(memberList))),
|
||
MemberList: memberList,
|
||
ChatRoomName: proto.String(chatRoomName),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeDelChatRoomMember, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/delchatroommember", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetTransferGroupOwnerRequest 转让群
|
||
func GetTransferGroupOwnerRequest(userInfo *baseinfo.UserInfo, chatRoomName, newOwnerUserName string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.TransferChatRoomOwnerRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
ChatRoomName: proto.String(chatRoomName),
|
||
NewOwnerUserName: proto.String(newOwnerUserName),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeTransferChatRoomOwnerRequest, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/transferchatroomowner", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetInviteChatroomMembersEntity 邀请群成员
|
||
func GetInviteChatroomMembersRequest(userInfo *baseinfo.UserInfo, chatRoomName string, userList []string) (*baseinfo.PackHeader, error) {
|
||
memberList := make([]*wechat.MemberReq, 0)
|
||
for _, user := range userList {
|
||
memberList = append(memberList, &wechat.MemberReq{
|
||
MemberName: &wechat.SKBuiltinString{
|
||
Str: proto.String(user),
|
||
},
|
||
})
|
||
}
|
||
req := wechat.InviteChatRoomMemberRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
MemberCount: proto.Uint32(uint32(len(memberList))),
|
||
MemberList: memberList,
|
||
ChatRoomName: &wechat.SKBuiltinString{
|
||
Str: proto.String(chatRoomName),
|
||
},
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeInviteChatRoomMember, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/invitechatroommember", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 查看附近的人
|
||
func SendGetPeopleNearbyResultRequest(userInfo *baseinfo.UserInfo, longitude float32, latitude float32) (*baseinfo.PackHeader, error) {
|
||
req := &wechat.LbsRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
GPSSource: proto.Int64(0),
|
||
Latitude: proto.Float32(latitude),
|
||
Longitude: proto.Float32(longitude),
|
||
OpCode: proto.Uint64(1),
|
||
Precision: proto.Int64(65),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(req)
|
||
sendEncodeData := Pack(userInfo, srcData, 148, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/lbsfind", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetA8KeyRequest 授权链接
|
||
// @opCode ：
|
||
//
|
||
// enum GetA8KeyOpCode
|
||
// {
|
||
// MMGETA8KEY_OPENAPI = 1,
|
||
// MMGETA8KEY_QZONE = 3,
|
||
// MMGETA8KEY_REDIRECT = 2
|
||
// }
|
||
//
|
||
// @scene ：
|
||
//
|
||
// enum GetA8KeyScene
|
||
// {
|
||
// MMGETA8KEY_SCENE_UNKNOW,
|
||
// MMGETA8KEY_SCENE_MSG,
|
||
// MMGETA8KEY_SCENE_TIMELINE,
|
||
// MMGETA8KEY_SCENE_PROFILE,
|
||
// MMGETA8KEY_SCENE_QRCODE,
|
||
// MMGETA8KEY_SCENE_QZONE,
|
||
// MMGETA8KEY_SCENE_OAUTH,
|
||
// MMGETA8KEY_SCENE_OPEN,
|
||
// MMGETA8KEY_SCENE_PLUGIN,
|
||
// MMGETA8KEY_SCENE_JUMPURL,
|
||
// MMGETA8KEY_SCENE_SHAKETV,
|
||
// MMGETA8KEY_SCENE_SCANBARCODE,
|
||
// MMGETA8KEY_SCENE_SCANIMAGE,
|
||
// MMGETA8KEY_SCENE_SCANSTREETVIEW,
|
||
// MMGETA8KEY_SCENE_FAV,
|
||
// MMGETA8KEY_SCENE_MMBIZ,
|
||
// MMGETA8KEY_SCENE_QQMAIL,
|
||
// MMGETA8KEY_SCENE_LINKEDIN,
|
||
// MMGETA8KEY_SCENE_SHAKETV_DETAIL,
|
||
// MMGETA8KEY_SCENE_BIZHOMEPAGE,
|
||
// MMGETA8KEY_SCENE_USBCONNECT,
|
||
// MMGETA8KEY_SCENE_SHORT_URL,
|
||
// MMGETA8KEY_SCENE_WIFI,
|
||
// MMGETA8KEY_SCENE_OUTSIDE_DEEPLINK,
|
||
// MMGETA8KEY_SCENE_PUSH_LOGIN_URL
|
||
// }
|
||
func GetA8KeyRequest(userInfo *baseinfo.UserInfo, opCode, scene uint32, reqUrl string, getType baseinfo.GetA8KeyType) (*baseinfo.PackHeader, error) {
|
||
req := wechat.GetA8KeyRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
OpCode: proto.Uint32(opCode), //2
|
||
ReqUrl: &wechat.SKBuiltinString{
|
||
Str: proto.String(reqUrl),
|
||
},
|
||
Scene: proto.Uint32(scene), //4
|
||
UserName: proto.String(userInfo.GetUserName()),
|
||
BundleID: proto.String(""),
|
||
NetType: proto.String("WiFi"),
|
||
FontScale: proto.Uint32(100),
|
||
RequestId: proto.Uint64(uint64(time.Now().Unix())),
|
||
CodeType: proto.Uint32(19),
|
||
//CodeType: proto.Uint32(15),
|
||
//CodeVersion: proto.Uint32(5),
|
||
OuterUrl: proto.String(""),
|
||
SubScene: proto.Uint32(1),
|
||
}
|
||
|
||
cgi := uint32(0)
|
||
cgiUrl := ""
|
||
|
||
switch getType {
|
||
case baseinfo.ThrIdGetA8Key:
|
||
cgi = baseinfo.MMRequestTypeThrIdGetA8Key
|
||
cgiUrl = "/cgi-bin/micromsg-bin/3rd-geta8key"
|
||
default:
|
||
cgi = baseinfo.MMRequestTypeGetA8Key
|
||
cgiUrl = "/cgi-bin/micromsg-bin/geta8key"
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, uint32(cgi), 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, cgiUrl, sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// JSLoginRequest 授权小程序 返回Code
|
||
// @appId :要授权wxappid
|
||
func JSLoginRequest(userInfo *baseinfo.UserInfo, appId string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.JSLoginRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
AppId: proto.String(appId),
|
||
LoginType: proto.Int32(1),
|
||
VersionType: proto.Int32(0),
|
||
WxaExternalInfo: &wechat.WxaExternalInfo{
|
||
Scene: proto.Int32(1001),
|
||
SourceEnv: proto.Int32(1),
|
||
},
|
||
}
|
||
|
||
/*req := wechat.JSLoginRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
AppId: proto.String(appId),
|
||
Scope: proto.String("snsapi_login"),
|
||
LoginType: proto.Int32(4),
|
||
Url: proto.String("https://open.weixin.qq.com/connect/confirm?uuid=021extwqXdPRRlbJ"),
|
||
VersionType: proto.Int32(0),
|
||
WxaExternalInfo: &wechat.WxaExternalInfo{
|
||
Scene: proto.Int32(1001),
|
||
SourceEnv: proto.Int32(1),
|
||
},
|
||
}*/
|
||
|
||
/*req := wechat.JSLoginRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
AppId: proto.String(appId),
|
||
LoginType: proto.Int32(1),
|
||
VersionType: proto.Int32(0),
|
||
WxaExternalInfo: &wechat.WxaExternalInfo{
|
||
Scene: proto.Int32(1066),
|
||
SourceEnv: proto.Int32(1),
|
||
},
|
||
}*/
|
||
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeJSLogin, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmbiz-bin/js-login", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// JSOperateWxDataRequest 小程序云函数操作; 授权小程序后返回 encryptedData,iv等信息
|
||
func JSOperateWxDataRequest(userInfo *baseinfo.UserInfo, appId string, opt int32, data string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.JSOperateWxDataRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
AppId: proto.String(appId),
|
||
Data: []byte(data),
|
||
GrantScope: proto.String("scope.userInfo"),
|
||
Opt: proto.Int32(opt), // 默认为 1
|
||
VersionType: proto.Int32(0),
|
||
WxaExternalInfo: &wechat.WxaExternalInfo{
|
||
Scene: proto.Int32(1001),
|
||
SourceEnv: proto.Int32(2),
|
||
},
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeJSOperateWxData, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmbiz-bin/js-operatewxdata", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SdkOauthAuthorizeRequest 授权app应用
|
||
func SdkOauthAuthorizeRequest(userInfo *baseinfo.UserInfo, appId string, sdkName string, packageName string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.SdkOauthAuthorizeReq{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
AppId: proto.String(appId),
|
||
Tag3: proto.String("snsapi_userinfo"),
|
||
Tag4: proto.String(sdkName), //wechat_sdk_demo_test
|
||
Tag5: proto.String(packageName), //"com.yimu.renwuxiongObject"
|
||
Tag8: proto.String(""),
|
||
Tag9: proto.String(""),
|
||
Tag10: proto.String(""),
|
||
Tag11: proto.String(""),
|
||
Tag12: proto.Uint32(0),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeSdkOauthAuthorize, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmbiz-bin/sdk_oauth_authorize", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendSearchContactRequest 搜索联系人
|
||
func SendSearchContactRequest(userInfo *baseinfo.UserInfo, opCode, fromScene, searchScene uint32, userName string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.SearchContactRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
UserName: &wechat.SKBuiltinString{
|
||
Str: proto.String(userName),
|
||
},
|
||
OpCode: proto.Uint32(opCode),
|
||
FromScene: proto.Uint32(fromScene),
|
||
SearchScene: proto.Uint32(searchScene),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeSearchContact, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/searchcontact", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// VerifyUserRequest 好友验证
|
||
func VerifyUserRequest(userInfo *baseinfo.UserInfo, opCode uint32, verifyContent string, scene int, V3, V4, ChatRoomUserName string) (*baseinfo.PackHeader, error) {
|
||
// clientcheckdata
|
||
var extSpamInfo wechat.SKBuiltinString_
|
||
if userInfo.DeviceInfo != nil {
|
||
extSpamInfo.Buffer = GetExtPBSpamInfoDataIPhone(userInfo)
|
||
} else {
|
||
extSpamInfo.Buffer = GetExtPBSpamInfoDataA16(userInfo)
|
||
}
|
||
|
||
extSpamInfoLen := uint32(len(extSpamInfo.Buffer))
|
||
extSpamInfo.Len = &extSpamInfoLen
|
||
|
||
userTicket := V4
|
||
if ChatRoomUserName != "" {
|
||
userTicket = ""
|
||
}
|
||
|
||
req := wechat.VerifyUserRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
OpCode: proto.Uint32(opCode),
|
||
VerifyUserListSize: proto.Uint32(1),
|
||
VerifyUserList: []*wechat.VerifyUser{{
|
||
Value: proto.String(V3),
|
||
VerifyUserTicket: proto.String(userTicket),
|
||
AntispamTicket: proto.String(V4),
|
||
FriendFlag: proto.Uint32(0),
|
||
ChatRoomUserName: proto.String(ChatRoomUserName),
|
||
SourceUserName: proto.String(""),
|
||
SourceNickName: proto.String(""),
|
||
ScanQrcodeFromScene: proto.Uint32(0),
|
||
ReportInfo: proto.String(""),
|
||
OuterUrl: proto.String(""),
|
||
SubScene: proto.Uint32(0),
|
||
}},
|
||
VerifyContent: proto.String(verifyContent),
|
||
SceneListCount: proto.Uint32(1),
|
||
SceneList: []byte{byte(scene)},
|
||
ExtSpamInfo: &extSpamInfo,
|
||
//NeedConfirm: proto.Uint32(1),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeVerifyUser, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/verifyuser", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// UploadMContact 上传通讯录
|
||
func UploadMContactRequest(userInfo *baseinfo.UserInfo, mobile string, mobiles []string, opcdoe int32) (*baseinfo.PackHeader, error) {
|
||
mobileList := make([]*wechat.Mobile, 0)
|
||
for _, mobile := range mobiles {
|
||
mobileList = append(mobileList, &wechat.Mobile{
|
||
V: proto.String(mobile),
|
||
})
|
||
}
|
||
req := wechat.UploadMContactRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
UserName: proto.String(userInfo.WxId),
|
||
Opcode: &opcdoe,
|
||
Mobile: proto.String(mobile),
|
||
MobileListSize: proto.Int32(int32(len(mobileList))),
|
||
MobileList: mobileList,
|
||
EmailListSize: proto.Int32(0),
|
||
EmailList: []*wechat.MEmail{},
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeUploadMContact, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/uploadmcontact", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetMFriendRequest 获取通讯录
|
||
func GetMFriendRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
req := wechat.GetMFriendRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
OpType: proto.Uint32(0),
|
||
MD5: proto.String(uuid.New().String()),
|
||
Scene: proto.Uint32(0),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetMFriend, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getmfriend", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetCertRequest 获取证书
|
||
func GetCertRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
//userInfo.SessionKey = baseutils.RandomBytes(16)
|
||
req := wechat.GetCertRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
AesEncryptKey: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(16),
|
||
Buffer: userInfo.SessionKey[:16],
|
||
},
|
||
Version: proto.Uint32(135),
|
||
}
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 381, 7)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getcert", sendEncodeData)
|
||
// fmt.Println(hex.EncodeToString(resp))
|
||
// fmt.Println(hex.EncodeToString(userInfo.SessionKey))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetSdkOauthAuthorizeConfirmRequest
|
||
func GetSdkOauthAuthorizeConfirmRequest(userInfo *baseinfo.UserInfo, AppId, appName, appNamePack string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.SdkOauthAuthorizeConfirmNewReq{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Opt: proto.Uint32(1),
|
||
Scope: []string{"snsapi_userinfo"},
|
||
AppId: proto.String(AppId),
|
||
State: proto.String(appName),
|
||
BundleId: proto.String(appNamePack),
|
||
AvatarId: proto.Uint32(0),
|
||
UniversalLink: proto.String(""),
|
||
OpenSdkVersion: proto.String(""),
|
||
SdkToken: proto.String(""),
|
||
OpenSdkBundleId: proto.String(""),
|
||
SdkTokenChk: proto.Uint32(0),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 1346, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmbiz-bin/sdk_oauth_authorize_confirm", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetQRConnectAuthorizeRequest 获取授权二维码链接组包
|
||
func GetQRConnectAuthorizeRequest(userInfo *baseinfo.UserInfo, url string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.QRConnectAuthorizeReq{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
OAuthUrl: proto.String(url),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 2543, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmbiz-bin/qrconnect_authorize", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetQRConnectAuthorizeConfirmRequest 授权二维码链接确认组包
|
||
func GetQRConnectAuthorizeConfirmRequest(userInfo *baseinfo.UserInfo, url string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.QRConnectAuthorizeConfirmReq{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
OAuthUrl: proto.String(url),
|
||
Opt: proto.Uint32(1),
|
||
Scope: []string{"snsapi_login"},
|
||
AvatarId: proto.Uint32(0),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 1137, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmbiz-bin/qrconnect_authorize_confirm", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 授权链接
|
||
func SendGetMpA8Request(userInfo *baseinfo.UserInfo, url string, opcode uint32) (*baseinfo.PackHeader, error) {
|
||
req := wechat.GetA8KeyRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
CodeType: proto.Uint32(19),
|
||
CodeVersion: proto.Uint32(10),
|
||
Flag: proto.Uint32(0),
|
||
FontScale: proto.Uint32(118),
|
||
NetType: proto.String("WIFI"),
|
||
OpCode: proto.Uint32(opcode),
|
||
UserName: proto.String(userInfo.WxId),
|
||
ReqUrl: &wechat.SKBuiltinString{
|
||
Str: proto.String(url),
|
||
},
|
||
FriendQq: proto.Uint32(0),
|
||
Scene: proto.Uint32(4),
|
||
SubScene: proto.Uint32(1),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 233, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/mp-geta8key", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetOnlineInfoRequest 获取登录信息组包
|
||
func GetOnlineInfoRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
req := wechat.GetOnlineInfoRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeGetOnlineInfo, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getonlineinfo", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// GetRevokeMsgRequest 撤销消息
|
||
func GetRevokeMsgRequest(userInfo *baseinfo.UserInfo, newMsgId string, clientMsgId uint64, toUserName string) (*baseinfo.PackHeader, error) {
|
||
msgId, _ := strconv.ParseUint(newMsgId, 10, 64)
|
||
reqData := wechat.RevokeMsgRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
ClientMsgId: proto.String(fmt.Sprintf("%v_%v", time.Now().Unix(), newMsgId)),
|
||
NewClientMsgId: proto.Uint32(uint32(time.Now().Unix())),
|
||
CreateTime: proto.Uint32(uint32(time.Now().Unix())),
|
||
SvrMsgId: proto.Uint64(clientMsgId),
|
||
FromUserName: proto.String(userInfo.GetUserName()),
|
||
ToUserName: proto.String(toUserName),
|
||
IndexOfRequest: proto.Uint32(26),
|
||
SvrNewMsgId: proto.Uint64(msgId),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&reqData)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeRevokeMsg, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/revokemsg", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// RevokeMsgRequestNew 撤回消息New
|
||
func RevokeMsgRequestNew(userInfo *baseinfo.UserInfo, m req.RevokeMsgModel) (*baseinfo.PackHeader, error) {
|
||
newMsgId, _ := strconv.ParseUint(m.NewMsgId, 10, 64)
|
||
|
||
reqData := wechat.RevokeMsgRequestNew{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
FromUserName: proto.String(userInfo.GetUserName()),
|
||
ToUserName: proto.String(m.ToUserName),
|
||
CreateTime: proto.Uint64(m.CreateTime),
|
||
IndexOfRequest: proto.Uint64(0),
|
||
NewMsgId: proto.Uint64(newMsgId),
|
||
}
|
||
|
||
if m.IsImage {
|
||
// 图片消息撤回
|
||
if m.ClientImgIdStr != "" {
|
||
reqData.ClientMsgId = proto.String(m.ClientImgIdStr) // 使用原始clientImgId字符串
|
||
} else {
|
||
// 如果未提供，尝试构造一个
|
||
reqData.ClientMsgId = proto.String(fmt.Sprintf("%s_%d", userInfo.GetUserName(), m.CreateTime))
|
||
}
|
||
reqData.MsgId = proto.Uint64(m.ClientMsgId) // 对图片消息，使用msgId值
|
||
reqData.NewClientMsgId = proto.Uint64(m.CreateTime) // 尝试使用createTime
|
||
} else {
|
||
// 文本消息撤回，保持原来的逻辑
|
||
reqData.ClientMsgId = proto.String("")
|
||
reqData.MsgId = proto.Uint64(0)
|
||
reqData.NewClientMsgId = proto.Uint64(m.ClientMsgId)
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&reqData)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeRevokeMsg, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/revokemsg", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// UploadHeadImage 修改头像
|
||
func UploadHeadImage(userInfo *baseinfo.UserInfo, base64Image string) (*baseinfo.PackHeader, error) {
|
||
|
||
ImgData := strings.Split(base64Image, ",")
|
||
var ImgBase64 []byte
|
||
if len(ImgData) > 1 {
|
||
ImgBase64, _ = base64.StdEncoding.DecodeString(ImgData[1])
|
||
} else {
|
||
ImgBase64, _ = base64.StdEncoding.DecodeString(base64Image)
|
||
}
|
||
ImgStream := bytes.NewBuffer(ImgBase64)
|
||
Startpos := 0
|
||
datalen := 30000
|
||
datatotalength := ImgStream.Len()
|
||
ImgHash := GetFileMD5Hash(ImgBase64)
|
||
I := 0
|
||
resps := make([]byte, 0)
|
||
for {
|
||
Startpos = I * datalen
|
||
count := 0
|
||
if datatotalength-Startpos > datalen {
|
||
count = datalen
|
||
} else {
|
||
count = datatotalength - Startpos
|
||
}
|
||
if count < 0 {
|
||
break
|
||
}
|
||
Databuff := make([]byte, count)
|
||
_, _ = ImgStream.Read(Databuff)
|
||
req := wechat.UploadHDHeadImgRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
TotalLen: proto.Uint32(uint32(datatotalength)),
|
||
StartPos: proto.Uint32(uint32(Startpos)),
|
||
HeadImgType: proto.Uint32(1),
|
||
Data: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(Databuff))),
|
||
Buffer: Databuff,
|
||
},
|
||
ImgHash: proto.String(ImgHash),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeUploadHDHeadImg, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/uploadhdheadimg", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
resps = resp
|
||
I++
|
||
}
|
||
// 打包发送数据
|
||
return DecodePackHeader(resps, nil)
|
||
}
|
||
|
||
func GetFileMD5Hash(Data []byte) string {
|
||
hash := md5.New()
|
||
hash.Write(Data)
|
||
retVal := hash.Sum(nil)
|
||
return hex.EncodeToString(retVal)
|
||
}
|
||
|
||
// GetVerifyPwdRequest 验证密码
|
||
func GetVerifyPwdRequest(userInfo *baseinfo.UserInfo, pwd string) (*baseinfo.PackHeader, error) {
|
||
|
||
req := wechat.VerifyPwdRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
OpCode: proto.Uint32(1),
|
||
Pwd1: proto.String(baseutils.Md5Value(pwd)),
|
||
Pwd2: proto.String(baseutils.Md5Value(pwd)),
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeVerifyPassword, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/newverifypasswd", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// 转 字符串
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendSetPwdRequest 修改密码
|
||
func SendSetPwdRequest(userInfo *baseinfo.UserInfo, ticket, newPwd string, OpCode uint32) (*baseinfo.PackHeader, error) {
|
||
log.Println("SendSetPwdRequest:", newPwd)
|
||
log.Println("SendSetPwdRequest:", ticket)
|
||
req := &wechat.SetPwdRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Password: proto.String(baseutils.Md5Value(newPwd)),
|
||
Ticket: proto.String(ticket),
|
||
AutoAuthKey: &wechat.BufferT{
|
||
ILen: proto.Uint32(uint32(len(userInfo.AutoAuthKey))),
|
||
Buffer: userInfo.AutoAuthKey,
|
||
},
|
||
}
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(req)
|
||
|
||
S2801, _ := hex.DecodeString("2801")
|
||
|
||
reqdataA := new(bytes.Buffer)
|
||
reqdataA.Write(srcData)
|
||
|
||
if len(userInfo.DeviceInfo.DeviceID) <= 16 {
|
||
reqdataA.Write(S2801)
|
||
}
|
||
|
||
sendEncodeData := Pack(userInfo, reqdataA.Bytes(), baseinfo.MMRequestTypeSetPassword, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/newsetpasswd", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendUploadVoiceRequest 发送语音
|
||
func SendUploadVoiceNewRequest(userInfo *baseinfo.UserInfo, ToWxId string, Startpos int, Databuff []byte, ClientImgId string, VoiceTime int32, Type int32, endFlag int) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.UploadVoiceRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
FromUserName: proto.String(userInfo.WxId),
|
||
ToUserName: proto.String(ToWxId),
|
||
Offset: proto.Uint32(uint32(Startpos)),
|
||
Length: proto.Uint32(uint32(len(Databuff))),
|
||
ClientMsgId: proto.String(ClientImgId),
|
||
MsgId: proto.Uint32(0),
|
||
VoiceLength: proto.Int32(VoiceTime * 1000),
|
||
VoiceFormat: proto.Int32(Type),
|
||
Data: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(Databuff))),
|
||
Buffer: Databuff,
|
||
},
|
||
EndFlag: proto.Uint32(uint32(endFlag)),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeUploadVoiceNew, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/uploadvoice", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendUploadVoiceRequest 发送语音
|
||
/*func SendUploadVoiceRequest(userInfo *baseinfo.UserInfo, toUserName string, data []byte, totalLen, startPos uint32, clientImgId string, voiceLen uint32, voiceFormat uint32) (*baseinfo.PackHeader, error) {
|
||
endFlag := uint32(0)
|
||
if startPos+uint32(len(data)) >= totalLen {
|
||
endFlag = 1
|
||
}
|
||
|
||
var req = wechat.UploadVoiceRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
FromUserName: proto.String(userInfo.GetUserName()),
|
||
ToUserName: proto.String(toUserName),
|
||
ClientMsgId: proto.String(clientImgId),
|
||
VoiceFormat: proto.Uint32(voiceFormat),
|
||
VoiceLength: proto.Uint32(voiceLen),
|
||
Length: proto.Uint32(uint32(len(data))),
|
||
Data: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(data))),
|
||
Buffer: data,
|
||
},
|
||
Offset: proto.Uint32(startPos),
|
||
EndFlag: proto.Uint32(endFlag),
|
||
MsgId: proto.Uint32(0),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeUploadVoice, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/uploadvoice", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}*/
|
||
|
||
// SendNewInitSyncRequest 首次登录初始化
|
||
func SendNewInitSyncRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
mgr := userInfo.SyncKeyMgr()
|
||
if mgr.CurKey() == nil {
|
||
mgr.SetCurKey(&wechat.BufferT{
|
||
ILen: proto.Uint32(0),
|
||
Buffer: make([]byte, 0),
|
||
})
|
||
}
|
||
if mgr.MaxKey() == nil {
|
||
mgr.SetMaxKey(&wechat.BufferT{
|
||
ILen: proto.Uint32(0),
|
||
Buffer: make([]byte, 0),
|
||
})
|
||
}
|
||
req := &wechat.NewInitRequest{}
|
||
req.BaseRequest = GetBaseRequest(userInfo)
|
||
//req.BaseRequest.Scene = proto.Uint32(0)
|
||
req.UserName = proto.String(userInfo.GetUserName())
|
||
req.CurrentSynckey = mgr.CurKey()
|
||
req.MaxSynckey = mgr.MaxKey()
|
||
req.Language = proto.String("zh_CN")
|
||
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(req)
|
||
sendEncodeData := Pack(userInfo, srcData, baseinfo.MMRequestTypeNewInit, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/newinit", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 设置微信号
|
||
func SetWechatRequest(userInfo *baseinfo.UserInfo, alisa string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.GeneralSetRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
SetType: proto.Int32(1),
|
||
SetValue: proto.String(alisa),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 177, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/generalset", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 获取设备
|
||
func GetBoundHardDeviceRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.GetBoundHardDevicesRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Version: proto.Uint32(0),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 539, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getboundharddevices", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 获取步数列表
|
||
func SendGetUserRankLikeCountRequest(userInfo *baseinfo.UserInfo, rankId string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.GetUserRankLikeCountRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Username: proto.String(userInfo.WxId),
|
||
LatestRank: proto.Bool(true),
|
||
RankId: proto.String(rankId),
|
||
AppUsername: proto.String("wx7fa037cc7dfabad5"),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 1042, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmbiz-bin/rank/getuserranklike", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 上传步数
|
||
func UploadStepSetRequestRequest(userInfo *baseinfo.UserInfo, deviceID string, deviceType string, number uint64) (*baseinfo.PackHeader, error) {
|
||
currentTime := time.Now()
|
||
startTime := time.Date(currentTime.Year(), currentTime.Month(), currentTime.Day(), 0, 0, 0, 0, currentTime.Location()).Unix()
|
||
endTime := time.Date(currentTime.Year(), currentTime.Month(), currentTime.Day(), 23, 59, 59, 0, currentTime.Location()).Unix()
|
||
var req = wechat.UploadDeviceStepRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
DeviceID: proto.String(deviceID),
|
||
DeviceType: proto.String(deviceType),
|
||
FromTime: proto.Uint32(uint32(startTime)),
|
||
ToTime: proto.Uint32(uint32(endTime)),
|
||
StepCount: proto.Uint32(uint32(number)),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 1261, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/mmoc-bin/hardware/uploaddevicestep", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 提取企业 wx 详情
|
||
func SendQWContactRequest(userInfo *baseinfo.UserInfo, openIm, chatRoom, t string) (*baseinfo.PackHeader, error) {
|
||
req := wechat.GetQYContactRequest{}
|
||
req.Wxid = proto.String(openIm)
|
||
if chatRoom != "" {
|
||
req.Room = proto.String(chatRoom)
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 881, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getopenimcontact", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 提取全部的企业通寻录
|
||
func SendQWSyncContactRequest(userInfo *baseinfo.UserInfo) (*baseinfo.PackHeader, error) {
|
||
ck := make([]*wechat.SyncKey_, 0)
|
||
ck = append(ck, &wechat.SyncKey_{
|
||
SyncKey: proto.Int64(0),
|
||
Type: proto.Uint32(400),
|
||
})
|
||
key := wechat.SyncMsgKey{
|
||
Len: proto.Uint32(1),
|
||
MsgKey: &wechat.SyncKey{
|
||
Size: proto.Uint32(1),
|
||
Type: ck,
|
||
},
|
||
}
|
||
keyMar, _ := proto.Marshal(&key)
|
||
var req = wechat.QYSyncRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Selector: proto.Int64(0x200000),
|
||
Key: keyMar,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 810, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/openimsync", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 创建企业群
|
||
func SendQWCreateChatRoomRequest(userInfo *baseinfo.UserInfo, userList []string) (*baseinfo.PackHeader, error) {
|
||
memberlist := make([]*wechat.Openimcontact, 0)
|
||
for _, val := range userList {
|
||
memberlist = append(memberlist, &wechat.Openimcontact{
|
||
UserName: proto.String(val),
|
||
})
|
||
}
|
||
var req = wechat.CreateQYChatRoomRequest{
|
||
MemberList: memberlist,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 371, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/createopenimchatroom", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 向企业微信打招呼
|
||
func SendQWApplyAddContactRequest(userInfo *baseinfo.UserInfo, toUserName, v1, Content string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.QYVerifyUserRequest{
|
||
Wxid: proto.String(toUserName),
|
||
V1: proto.String(v1),
|
||
Content: proto.String(Content),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 0xF3, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/sendopenimverifyrequest", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 单向加企业微信
|
||
func SendQWAddContactRequest(userInfo *baseinfo.UserInfo, toUserName, v1, Content string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.QYVAddUserRequest{
|
||
Wxid: proto.String(toUserName),
|
||
V1: proto.String(v1),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 667, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/addopenimcontact", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 提取所有企业群
|
||
func SendQWSyncChatRoomRequest(userInfo *baseinfo.UserInfo, key string) (*baseinfo.PackHeader, error) {
|
||
ck := make([]*wechat.SyncKey_, 0)
|
||
ck = append(ck, &wechat.SyncKey_{
|
||
SyncKey: proto.Int64(0),
|
||
Type: proto.Uint32(0),
|
||
})
|
||
keys := wechat.SyncMsgKey{
|
||
Len: proto.Uint32(1),
|
||
MsgKey: &wechat.SyncKey{
|
||
Size: proto.Uint32(1),
|
||
Type: ck,
|
||
},
|
||
}
|
||
keyMar, _ := proto.Marshal(&keys)
|
||
var req = wechat.QYSyncRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Selector: proto.Int64(2097152), //0x200000 2097152
|
||
Key: keyMar,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 810, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/openimsync", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 转让企业微信群
|
||
func SendQWChatRoomTransferOwnerRequest(userInfo *baseinfo.UserInfo, chatRoomName string, toUserName string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.QWTransferChatRoomOwnerRequest{
|
||
Username: proto.String(chatRoomName),
|
||
Owner: &wechat.Openimcontact{
|
||
UserName: proto.String(toUserName),
|
||
},
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 811, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/modopenimchatroomowner", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 直接拉好友进群
|
||
func SendQWAddChatRoomMemberRequest(userInfo *baseinfo.UserInfo, chatRoomName string, toUserName []string) (*baseinfo.PackHeader, error) {
|
||
list := make([]*wechat.Openimcontact, 0)
|
||
for _, val := range toUserName {
|
||
list = append(list, &wechat.Openimcontact{
|
||
UserName: proto.String(val),
|
||
})
|
||
}
|
||
var req = wechat.QYAddChatRoomRequest{
|
||
ChatRoomName: proto.String(chatRoomName),
|
||
MemberList: list,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 0x32E, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/addopenimchatroommember", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 发送群邀请链接
|
||
func SendQWInviteChatRoomMemberRequest(userInfo *baseinfo.UserInfo, chatRoomName string, toUserName []string) (*baseinfo.PackHeader, error) {
|
||
list := make([]*wechat.Openimcontact, 0)
|
||
for _, val := range toUserName {
|
||
list = append(list, &wechat.Openimcontact{
|
||
UserName: proto.String(val),
|
||
})
|
||
}
|
||
var req = wechat.InviteQYChatRoomRequest{
|
||
ChatRoomName: proto.String(chatRoomName),
|
||
MemberList: list,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 887, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/inviteopenimchatroommember", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 删除企业群群成员
|
||
func SendQWDelChatRoomMemberRequest(userInfo *baseinfo.UserInfo, chatRoomName string, toUserName []string) (*baseinfo.PackHeader, error) {
|
||
list := make([]*wechat.Openimcontact, 0)
|
||
for _, val := range toUserName {
|
||
list = append(list, &wechat.Openimcontact{
|
||
UserName: proto.String(val),
|
||
})
|
||
}
|
||
var req = wechat.QYDelChatRoomMemberRequest{
|
||
Username: proto.String(chatRoomName),
|
||
MemberList: list,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 0x3AF, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/delopenimchatroommember", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 提取企业群全部成员
|
||
func SendQWGetChatRoomMemberRequest(userInfo *baseinfo.UserInfo, chatRoomName string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.GetQYChatroomMemberDetailRequest{
|
||
ChatroomUserName: proto.String(chatRoomName),
|
||
ClientVersion: proto.Uint64(0),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 942, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getopenimchatroommemberdetail", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 提取企业群名称公告设定等信息
|
||
func SendQWGetChatroomInfoRequest(userInfo *baseinfo.UserInfo, chatRoomName string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.Openimcontact{
|
||
UserName: proto.String(chatRoomName),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 407, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getopenimchatroomcontact", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 提取企业群二维码
|
||
func SendQWGetChatRoomQRRequest(userInfo *baseinfo.UserInfo, chatRoomName string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.Openimcontact{
|
||
UserName: proto.String(chatRoomName),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 890, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/getopenimchatroomqrcode", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 增加企业管理员
|
||
func SendQWAppointChatRoomAdminRequest(userInfo *baseinfo.UserInfo, chatRoomName string, toUserName []string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.QYChatRoomAdminRequest{
|
||
ChatRoomName: proto.String(chatRoomName),
|
||
MemberList: toUserName,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 776, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/addopenimchatroomadmin", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 移除企业群管理员
|
||
func SendQWDelChatRoomAdminRequest(userInfo *baseinfo.UserInfo, chatRoomName string, toUserName []string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.QYChatRoomAdminRequest{
|
||
ChatRoomName: proto.String(chatRoomName),
|
||
MemberList: toUserName,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 3677, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/delopenimchatroomadmin", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 同意进企业群
|
||
func SendQWAcceptChatRoomRequest(userInfo *baseinfo.UserInfo, link string, opcode uint32) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.GetA8KeyRequest{}
|
||
req.BaseRequest = GetBaseRequest(userInfo)
|
||
req.CodeType = proto.Uint32(0)
|
||
req.CodeVersion = proto.Uint32(8)
|
||
req.Flag = proto.Uint32(0)
|
||
req.FontScale = proto.Uint32(100)
|
||
req.NetType = proto.String("WIFI")
|
||
req.OpCode = proto.Uint32(opcode)
|
||
req.UserName = proto.String(userInfo.WxId)
|
||
req.ReqUrl = &wechat.SKBuiltinString{
|
||
Str: proto.String(link),
|
||
}
|
||
req.FriendQq = proto.Uint32(0)
|
||
req.Scene = proto.Uint32(37)
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 233, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/geta8key", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 设定企业群管理审核进群
|
||
func SendQWAdminAcceptJoinChatRoomSetRequest(userInfo *baseinfo.UserInfo, link string, url string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.QYChatRoomAdminRequest{}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 3677, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/delopenimchatroomadmin", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 群管理批准进企业群
|
||
func SendQWAdminAcceptJoinChatRoomRequest(userInfo *baseinfo.UserInfo, chatRoomName, key, toUserName string, toUserNames []string) (*baseinfo.PackHeader, error) {
|
||
list := make([]*wechat.Openimcontact, 0)
|
||
for _, val := range toUserNames {
|
||
list = append(list, &wechat.Openimcontact{
|
||
UserName: proto.String(val),
|
||
})
|
||
}
|
||
var req = wechat.QYAdminAddRequest{
|
||
Room: proto.String(chatRoomName),
|
||
Key: proto.String(key),
|
||
Username: &wechat.Openimcontact{
|
||
UserName: proto.String(toUserName),
|
||
},
|
||
Usernamelist: list,
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 0x3AD, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/approveaddopenimchatroommember", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 视频号搜索
|
||
func SendGetFinderSearchRequest(userInfo *baseinfo.UserInfo, Index uint32, Userver int32, UserKey string, Uuid string) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.FinderSearchRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
UserKey: proto.String(UserKey),
|
||
Offset: proto.Uint32(Index),
|
||
Scene: proto.Uint32(0),
|
||
Uuid: proto.String(Uuid),
|
||
FinderTxRequest: &wechat.FinderTxRequest{
|
||
Userver: proto.Int32(Userver),
|
||
},
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 3820, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/findersearch", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 视频号个人中心
|
||
func SendFinderUserPrepareRequest(userInfo *baseinfo.UserInfo, Userver int32) (*baseinfo.PackHeader, error) {
|
||
var req = wechat.FinderUserPrepareRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Scene: proto.Int32(0),
|
||
FinderTxRequest: &wechat.FinderTxRequest{
|
||
Userver: proto.Int32(Userver),
|
||
},
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 3761, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/finderuserprepare", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 视频号关注or取消关注
|
||
func SendFinderFollowRequest(userInfo *baseinfo.UserInfo, FinderUserName string, OpType int32, RefObjectId string, Cook string, Userver int32, PosterUsername string) (*baseinfo.PackHeader, error) {
|
||
//refId, err := strconv.ParseUint(RefObjectId, 10, 64)
|
||
T := time.Now().Unix()
|
||
var req = wechat.FinderFollowRequest{
|
||
FinderUsername: proto.String(FinderUserName),
|
||
OpType: proto.Int32(OpType),
|
||
RefObjectId: proto.Uint64(0),
|
||
PosterUsername: proto.String(""),
|
||
FinderReq: &wechat.FinderTxRequest{
|
||
Userver: proto.Int32(Userver),
|
||
Scene: proto.Int32(6),
|
||
T: proto.Int32(1),
|
||
G: &wechat.FinderZd{
|
||
G1: proto.String(fmt.Sprintf("Finder_Enter%v", T)),
|
||
G2: proto.String(fmt.Sprintf("4-%v", T)),
|
||
G3: proto.String(fmt.Sprintf(`{"sessionId":"109_%v#$0_%v#"}`, T, T)),
|
||
},
|
||
Tg: proto.Int64(time.Now().Unix()),
|
||
},
|
||
Cook: proto.String(Cook),
|
||
EnterType: proto.Int32(7),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 3867, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/finderfollow", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// 获取验证码
|
||
func SendWxBindOpMobileForRegRequest(userInfo *baseinfo.UserInfo, opcode int64, mobile, verifycode string) (*baseinfo.PackHeader, error) {
|
||
tmpTime := int(time.Now().UnixNano() / 1000000000)
|
||
tmpTimeStr := strconv.Itoa(tmpTime)
|
||
var strClientSeqID = string(userInfo.DeviceInfo.Imei + "-" + tmpTimeStr)
|
||
var req = wechat.BindOpMobileForRegRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
Mobile: proto.String(mobile),
|
||
Opcode: proto.Int64(opcode),
|
||
Verifycode: proto.String(verifycode),
|
||
SafeDeviceName: proto.String("iPad"),
|
||
SafeDeviceType: proto.String("iPad"),
|
||
RandomEncryKey: &wechat.SKBuiltinString_{
|
||
Len: proto.Uint32(uint32(len(userInfo.SessionKey))),
|
||
Buffer: userInfo.SessionKey,
|
||
},
|
||
Language: proto.String("zh_CN"),
|
||
InputMobileReTrYs: proto.Uint32(0),
|
||
AdjustRet: proto.Uint32(0),
|
||
ClientSeqID: proto.String(strClientSeqID),
|
||
DialLang: proto.String(""),
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 145, 7)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/bindopmobileforreg", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendUploadAppAttach 上传文件
|
||
func SendUploadAppAttach(userInfo *baseinfo.UserInfo, fileData []byte) (*baseinfo.PackHeader, error) {
|
||
Stream := bytes.NewBuffer(fileData)
|
||
|
||
datalen := 50000
|
||
datatotalength := Stream.Len()
|
||
FileMD5 := lib.GetFileMD5Hash(fileData)
|
||
|
||
ClientAppDataId := fmt.Sprintf("%v_%v_UploadFile", userInfo.WxId, time.Now().Unix())
|
||
|
||
Startpos := 0
|
||
I := 0
|
||
var protobufdata []byte
|
||
|
||
for {
|
||
Startpos = I * datalen
|
||
count := 0
|
||
if datatotalength-Startpos > datalen {
|
||
count = datalen
|
||
} else {
|
||
count = datatotalength - Startpos
|
||
}
|
||
if count <= 0 {
|
||
break
|
||
}
|
||
|
||
Databuff := make([]byte, count)
|
||
_, _ = Stream.Read(Databuff)
|
||
|
||
req := &wechat.UploadAppAttachRequest{
|
||
BaseRequest: GetBaseRequest(userInfo),
|
||
AppId: proto.String(""),
|
||
SdkVersion: proto.Uint32(0),
|
||
ClientAppDataId: proto.String(ClientAppDataId),
|
||
UserName: proto.String(userInfo.WxId),
|
||
TotalLen: proto.Uint32(uint32(datatotalength)),
|
||
StartPos: proto.Uint32(uint32(Startpos)),
|
||
DataLen: proto.Uint32(uint32(len(Databuff))),
|
||
Data: &wechat.SKBuiltinBufferT{
|
||
ILen: proto.Uint32(uint32(len(Databuff))),
|
||
Buffer: Databuff,
|
||
},
|
||
Type: proto.Uint32(6),
|
||
Md5: proto.String(FileMD5),
|
||
}
|
||
|
||
// 序列化请求数据
|
||
reqdata, err := proto.Marshal(req)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 发送请求
|
||
sendEncodeData := Pack(userInfo, reqdata, 220, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/uploadappattach", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
protobufdata = resp
|
||
I++
|
||
}
|
||
|
||
return DecodePackHeader(protobufdata, nil)
|
||
}
|
||
|
||
// SendScanQrcodeEventReportRequest 扫码事件上报 (CGI ID: 8887)
|
||
// 模拟用户扫码行为
|
||
func SendScanQrcodeEventReportRequest(userInfo *baseinfo.UserInfo, loginUrl string) (*baseinfo.PackHeader, error) {
|
||
baseReq := GetBaseRequest(userInfo)
|
||
|
||
var req = wechat.ScanQrcodeEventReportRequest{
|
||
A: &wechat.ScanQrcodeBaseInfo{
|
||
A1: proto.String(""),
|
||
A2: proto.Int32(int32(*baseReq.Uin)),
|
||
A3: proto.String(string(baseReq.DeviceId)),
|
||
A4: proto.Int32(int32(*baseReq.ClientVersion)),
|
||
A5: proto.String(*baseReq.OsType),
|
||
A6: proto.Int32(0),
|
||
},
|
||
D: proto.Int32(19), // 事件类型 (字段2)
|
||
E: proto.Int32(4), // Scene (字段3)
|
||
F: proto.Int32(102462105), // 时间戳 (字段4)
|
||
// 字段5不存在，跳过
|
||
H: proto.String(strings.Trim(strings.TrimSpace(loginUrl), " `\"'")), // 登录URL (字段6)
|
||
I: proto.String(""), // 空字符串 (字段7)
|
||
M: proto.Int32(0), // 标志 (字段8)
|
||
N: []byte("0.964844"), // 版本号二进制 (字段9)
|
||
O: proto.Int32(1), // 标志 (字段10)
|
||
P: []byte("0.992188"), // 版本号二进制 (字段11)
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 8887, 5)
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/scan_qrcode_event_report_cgi", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
// SendExtDeviceLoginConfirmGetRequest 微信小店获取确认信息 (CGI ID: 971)
|
||
func SendExtDeviceLoginConfirmGetRequest(userInfo *baseinfo.UserInfo, loginUrl string) (*baseinfo.PackHeader, error) {
|
||
if userInfo == nil || len(userInfo.SessionKey) == 0 {
|
||
return nil, fmt.Errorf("session 未初始化")
|
||
}
|
||
extra := load971Extra()
|
||
// 替换时间戳为当前时间
|
||
extra = replaceTimestampIn971Extra(extra)
|
||
srcData := build971Raw(loginUrl, extra)
|
||
sendEncodeData := Pack(userInfo, srcData, 971, 5)
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/extdeviceloginconfirmget", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return DecodePackHeader(resp, nil)
|
||
}
|
||
|
||
func encodeVarint(n int) []byte {
|
||
b := make([]byte, 0, 10)
|
||
u := uint64(n)
|
||
for u >= 0x80 {
|
||
b = append(b, byte(u)|0x80)
|
||
u >>= 7
|
||
}
|
||
b = append(b, byte(u))
|
||
return b
|
||
}
|
||
|
||
func build971Raw(url string, extra []byte) []byte {
|
||
b := make([]byte, 0, len(url)+len(extra)+16)
|
||
// Field 1: URL (string)
|
||
b = append(b, 0x0a) // field 1, wire type 2 (length-delimited)
|
||
b = append(b, encodeVarint(len(url))...)
|
||
b = append(b, []byte(url)...)
|
||
|
||
// Field 3: Extra data (nested message)
|
||
if len(extra) > 0 {
|
||
b = append(b, 0x1a) // field 3, wire type 2 (length-delimited)
|
||
b = append(b, encodeVarint(len(extra))...)
|
||
b = append(b, extra...)
|
||
}
|
||
return b
|
||
}
|
||
|
||
// load971Extra 从扫码.txt文件中提取field 3的嵌套消息数据
|
||
// 文件结构: field1(url) + field3(nested message)
|
||
// 我们需要提取field3中的嵌套消息内容
|
||
func load971Extra() []byte {
|
||
p := "protobuf/扫码.txt"
|
||
d, err := ioutil.ReadFile(p)
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
s := strings.TrimSpace(string(d))
|
||
s = strings.TrimPrefix(s, "0x")
|
||
s = strings.ReplaceAll(s, " ", "")
|
||
s = strings.ReplaceAll(s, "\n", "")
|
||
raw, err := hex.DecodeString(s)
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
|
||
// 解析protobuf结构
|
||
// 跳过field 1 (URL)
|
||
if len(raw) < 3 || raw[0] != 0x0a {
|
||
return nil
|
||
}
|
||
i := 1
|
||
// 读取URL长度
|
||
urlLen := 0
|
||
shift := 0
|
||
for {
|
||
if i >= len(raw) {
|
||
return nil
|
||
}
|
||
b := raw[i]
|
||
i++
|
||
urlLen |= int(b&0x7f) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
shift += 7
|
||
}
|
||
// 跳过URL内容
|
||
i += urlLen
|
||
|
||
// 现在应该在field 3的位置
|
||
if i >= len(raw) || raw[i] != 0x1a {
|
||
return nil
|
||
}
|
||
i++ // 跳过field tag
|
||
|
||
// 读取field 3的长度
|
||
field3Len := 0
|
||
shift = 0
|
||
for {
|
||
if i >= len(raw) {
|
||
return nil
|
||
}
|
||
b := raw[i]
|
||
i++
|
||
field3Len |= int(b&0x7f) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
shift += 7
|
||
}
|
||
|
||
// 提取field 3的内容
|
||
if i+field3Len > len(raw) {
|
||
return nil
|
||
}
|
||
return raw[i : i+field3Len]
|
||
}
|
||
|
||
// replaceTimestampIn971Extra 替换 field 3 中的时间戳为当前时间
|
||
// 已知时间戳: 1765334020 (2025-12-10 10:33:40)，以 varint 编码存储
|
||
func replaceTimestampIn971Extra(data []byte) []byte {
|
||
if data == nil || len(data) < 100 {
|
||
return data
|
||
}
|
||
|
||
// 旧时间戳: 1765334020 -> varint: 84b8e3c906 (5字节)
|
||
oldTimestamp := int64(1765334020)
|
||
oldVarint := encodeVarint64(oldTimestamp)
|
||
|
||
// 新时间戳: 当前时间
|
||
newTimestamp := time.Now().Unix()
|
||
newVarint := encodeVarint64(newTimestamp)
|
||
|
||
// 在 data 中搜索并替换旧时间戳
|
||
result := make([]byte, len(data))
|
||
copy(result, data)
|
||
|
||
// 搜索旧时间戳的位置
|
||
for i := 0; i <= len(result)-len(oldVarint); i++ {
|
||
match := true
|
||
for j := 0; j < len(oldVarint); j++ {
|
||
if result[i+j] != oldVarint[j] {
|
||
match = false
|
||
break
|
||
}
|
||
}
|
||
if match {
|
||
// 找到了，替换
|
||
if len(newVarint) == len(oldVarint) {
|
||
// 长度相同，直接替换
|
||
copy(result[i:], newVarint)
|
||
} else {
|
||
// 长度不同，需要重新构建整个数组
|
||
newResult := make([]byte, 0, len(data)-len(oldVarint)+len(newVarint))
|
||
newResult = append(newResult, result[:i]...)
|
||
newResult = append(newResult, newVarint...)
|
||
newResult = append(newResult, result[i+len(oldVarint):]...)
|
||
return newResult
|
||
}
|
||
break
|
||
}
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
func encodeVarint64(n int64) []byte {
|
||
b := make([]byte, 0, 10)
|
||
u := uint64(n)
|
||
for u >= 0x80 {
|
||
b = append(b, byte(u)|0x80)
|
||
u >>= 7
|
||
}
|
||
b = append(b, byte(u))
|
||
return b
|
||
}
|
||
|
||
// SendExtDeviceLoginConfirmOkRequest 微信小店确认登录 (CGI ID: 972)
|
||
func SendExtDeviceLoginConfirmOkRequest(userInfo *baseinfo.UserInfo, loginUrl string) (*baseinfo.PackHeader, error) {
|
||
// 自动拼接deviceId: wxid,newsapp,wxid,weixin
|
||
wxid := userInfo.GetUserName()
|
||
deviceId := fmt.Sprintf("%s,newsapp,%s,weixin", wxid, wxid)
|
||
fmt.Println(deviceId)
|
||
var req = wechat.ExtDeviceLoginConfirmOkRequest{
|
||
D: proto.String(strings.Trim(strings.TrimSpace(strings.Replace(loginUrl, "https", "http", -1)), " `\"'")),
|
||
E: proto.String(deviceId), // 字段2: 设备ID
|
||
H: proto.Int32(0), // 字段4
|
||
J: proto.Int32(0), // 字段5
|
||
M: proto.Int32(0), // 字段7
|
||
}
|
||
// 打包发送数据
|
||
srcData, _ := proto.Marshal(&req)
|
||
sendEncodeData := Pack(userInfo, srcData, 972, 5)
|
||
|
||
resp, err := mmtls.MMHTTPPostData(userInfo.MMInfo, "/cgi-bin/micromsg-bin/extdeviceloginconfirmok", sendEncodeData)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if len(resp) <= 32 {
|
||
return nil, fmt.Errorf("请求被拒绝: %d", len(resp))
|
||
}
|
||
|
||
return DecodePackHeader(resp, nil)
|
||
}
|