6541 lines
219 KiB
Go
6541 lines
219 KiB
Go
package wxcore
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding/base64"
|
||
"encoding/json"
|
||
"errors"
|
||
"strconv"
|
||
"xiawan/wx/api/req"
|
||
"xiawan/wx/api/vo"
|
||
"xiawan/wx/clientsdk"
|
||
"xiawan/wx/clientsdk/baseinfo"
|
||
"xiawan/wx/clientsdk/mmtls"
|
||
"xiawan/wx/db"
|
||
"xiawan/wx/protobuf/wechat"
|
||
"xiawan/wx/srv/srvconfig"
|
||
"xiawan/wx/srv/wxface"
|
||
|
||
"fmt"
|
||
"math/rand"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/gogo/protobuf/proto"
|
||
"github.com/lunny/log"
|
||
"github.com/techoner/gophp/serialize"
|
||
)
|
||
|
||
// WXReqInvoker 微信请求调用器
|
||
type WXReqInvoker struct {
|
||
wxconn *WXConnect
|
||
}
|
||
|
||
func NewWXReqInvoker(conn wxface.IWXConnect) *WXReqInvoker {
|
||
return &WXReqInvoker{wxconn: conn.(*WXConnect)}
|
||
}
|
||
|
||
// {"fee":10,"fee_type":"1","payer":"085e9858e389aa9cb96dbfab5","receiver":"085e9858ea6d9e4b4adaa23ed","retcode":"0","retmsg":"ok"}
|
||
type ZZPacket struct {
|
||
Fee int `json:"fee,omitempty"`
|
||
Fee_type string `json:"fee_type,omitempty"`
|
||
Payer string `json:"payer,omitempty"`
|
||
Receiver string `json:"receiver,omitempty"`
|
||
Retcode string `json:"retcode,omitempty"`
|
||
Retmsg string `json:"retmsg,omitempty"`
|
||
}
|
||
|
||
type RedPacket struct {
|
||
Retcode int `json:"retcode,omitempty"`
|
||
Retmsg string `json:"retmsg,omitempty"`
|
||
SendId string `json:"sendId,omitempty"`
|
||
Amount int `json:"amount,omitempty"`
|
||
RecNum int `json:"recNum,omitempty"`
|
||
RecAmount int `json:"recAmount,omitempty"`
|
||
TotalNum int `json:"totalNum,omitempty"`
|
||
TotalAmount int `json:"totalAmount,omitempty"`
|
||
HasWriteAnswer int `json:"hasWriteAnswer,omitempty"`
|
||
HbType int `json:"hbType,omitempty"`
|
||
IsSender int `json:"isSender,omitempty"`
|
||
IsContinue int `json:"isContinue,omitempty"`
|
||
ReceiveStatus int `json:"receiveStatus,omitempty"`
|
||
HbStatus int `json:"hbStatus,omitempty"`
|
||
StatusMess string `json:"statusMess,omitempty"`
|
||
Wishing string `json:"wishing,omitempty"`
|
||
ReceiveId string `json:"receiveId,omitempty"`
|
||
HeadTitle string `json:"headTitle,omitempty"`
|
||
CanShare int `json:"canShare,omitempty"`
|
||
OperationHeader []interface{} `json:"operationHeader,omitempty"`
|
||
Record []RecordItem `json:"record,omitempty"`
|
||
Watermark string `json:"watermark,omitempty"`
|
||
JumpChange int `json:"jumpChange,omitempty"`
|
||
ChangeWording string `json:"changeWording,omitempty"`
|
||
SendUserName string `json:"sendUserName,omitempty"`
|
||
RealNameInfo RealNameInfo `json:"real_name_info,omitempty"`
|
||
SessionUserName string `json:"sessionUserName,omitempty"`
|
||
JumpChangeType int `json:"jumpChangeType,omitempty"`
|
||
ChangeIconUrl string `json:"changeIconUrl,omitempty"`
|
||
ShowSourceOpen ShowSourceOpen `json:"showSourceOpen,omitempty"`
|
||
ExpressionMd5 string `json:"expression_md5,omitempty"`
|
||
ExpressionType int `json:"expression_type,omitempty"`
|
||
ShowYearExpression int `json:"showYearExpression,omitempty"`
|
||
ShowOpenNormalExpression int `json:"showOpenNormalExpression,omitempty"`
|
||
EnableAnswerByExpression int `json:"enableAnswerByExpression,omitempty"`
|
||
EnableAnswerBySelfie int `json:"enableAnswerBySelfie,omitempty"`
|
||
EnableSetStatus bool `json:"enable_set_status,omitempty"`
|
||
}
|
||
|
||
type RecordItem struct {
|
||
ReceiveAmount int `json:"receiveAmount,omitempty"`
|
||
ReceiveTime string `json:"receiveTime,omitempty"`
|
||
Answer string `json:"answer,omitempty"`
|
||
ReceiveId string `json:"receiveId,omitempty"`
|
||
State int `json:"state,omitempty"`
|
||
GameTips string `json:"gameTips,omitempty"`
|
||
ReceiveOpenId string `json:"receiveOpenId,omitempty"`
|
||
UserName string `json:"userName,omitempty"`
|
||
}
|
||
|
||
type RealNameInfo struct {
|
||
GuideFlag int `json:"guide_flag,omitempty"`
|
||
GuideWording string `json:"guide_wording,omitempty"`
|
||
LeftButtonWording string `json:"left_button_wording,omitempty"`
|
||
RightButtonWording string `json:"right_button_wording,omitempty"`
|
||
UploadCreditUrl string `json:"upload_credit_url,omitempty"`
|
||
}
|
||
|
||
type ShowSourceOpen struct {
|
||
Source SourceObject `json:"source,omitempty"`
|
||
Operation Operation `json:"operation,omitempty"`
|
||
UprightCornerList []UprightCorner `json:"upright_corner_list,omitempty"`
|
||
}
|
||
|
||
type SourceObject struct {
|
||
CorpName string `json:"corpName,omitempty"`
|
||
SubType int `json:"subType,omitempty"`
|
||
MaterialId string `json:"materialId,omitempty"`
|
||
SourceObject DetailImage `json:"sourceObject,omitempty"`
|
||
CoverStatusFlag int `json:"cover_status_flag,omitempty"`
|
||
}
|
||
|
||
type DetailImage struct {
|
||
DetailImage string `json:"detailImage,omitempty"`
|
||
DetailImageMd5 string `json:"detailImageMd5,omitempty"`
|
||
}
|
||
|
||
type Operation struct {
|
||
Name string `json:"name,omitempty"`
|
||
Type string `json:"type,omitempty"`
|
||
Content string `json:"content,omitempty"`
|
||
Enable int `json:"enable,omitempty"`
|
||
}
|
||
|
||
type UprightCorner struct {
|
||
Wordding string `json:"wording,omitempty"`
|
||
JumpInfo JumpInfo `json:"jump_info,omitempty"`
|
||
}
|
||
|
||
type JumpInfo struct {
|
||
Type int `json:"type,omitempty"`
|
||
Url string `json:"url,omitempty"`
|
||
}
|
||
type Preson struct {
|
||
GroupID string
|
||
GroupName string
|
||
UserId string
|
||
UserName string
|
||
TotalCount int // 累计次数
|
||
TotalAmount int // 累计金额
|
||
}
|
||
|
||
type HistoryFinancial struct {
|
||
TotalAmount int // 历史累计金额
|
||
TotalCount int // 历史累计次数
|
||
}
|
||
|
||
type FinancialStats struct {
|
||
GlobalTotalAmount int // 全局累计金额
|
||
Stats []Preson // 每个群或个人的统计信息
|
||
// 全局累计次数
|
||
GlobalTotalCount int
|
||
// 历史累计次数和金额
|
||
History map[string]HistoryFinancial
|
||
}
|
||
|
||
// 发送短信
|
||
func (wxqi *WXReqInvoker) SendWxBindOpMobileForRequest(OpCode int64, PhoneNumber string, VerifyCode string) (*wechat.BindOpMobileForRegResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendWxBindOpMobileForRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendWxBindOpMobileForRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendWxBindOpMobileForRegRequest(tmpUserInfo, OpCode, PhoneNumber, VerifyCode)
|
||
if err != nil {
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
WXBindOpMobileForReg := &wechat.BindOpMobileForRegResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, WXBindOpMobileForReg)
|
||
if err != nil {
|
||
// 请求出问题了，应该关闭链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
if WXBindOpMobileForReg.BaseResponse.GetRet() == -301 {
|
||
for _, tg := range WXBindOpMobileForReg.GetNewHostList().GetList() {
|
||
fmt.Println(tg.GetOrigin(), tg.GetSubstitute())
|
||
if tg.GetOrigin() == "extshort.weixin.qq.com" {
|
||
/*G.MmtlsHost = tg.GetRedirect()*/
|
||
tmpUserInfo.MMInfo.ShortHost = tg.GetSubstitute()
|
||
}
|
||
//ShortHost
|
||
if tg.GetOrigin() == "long.weixin.qq.com" {
|
||
/*G.Mmtlsip = tg.GetRedirect()*/
|
||
tmpUserInfo.MMInfo.LongHost = tg.GetSubstitute()
|
||
|
||
}
|
||
/*fmt.Println("MmtlsHost", WXBindOpMobileForReg.MmtlsHost)
|
||
fmt.Println("Mmtlsip", G.Mmtlsip)*/
|
||
}
|
||
}
|
||
return WXBindOpMobileForReg, nil
|
||
}
|
||
|
||
// SendGetLoginQrcodeRequest 获取登录二维码 直登
|
||
func (wxqi *WXReqInvoker) SendGetLoginQrcodeRequestDirect() (*wechat.LoginQRCodeResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetLoginQrcodeRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
// 等待 2秒
|
||
time.Sleep(2 * time.Second)
|
||
if !wxqi.wxconn.IsConnected() {
|
||
// 等待 1 秒
|
||
time.Sleep(1 * time.Second)
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetLoginQrcodeRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
}
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendLoginQRCodeRequestDirect(tmpUserInfo)
|
||
if err != nil {
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
|
||
// 获取登录二维码响应
|
||
qrCodeResponse := &wechat.LoginQRCodeResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, qrCodeResponse)
|
||
if err != nil {
|
||
// 请求出问题了，应该关闭链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
return qrCodeResponse, nil
|
||
}
|
||
|
||
// SendGetLoginQrcodeRequest 获取登录二维码
|
||
func (wxqi *WXReqInvoker) SendGetLoginQrcodeRequest() (*wechat.LoginQRCodeResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetLoginQrcodeRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
// 等待 2秒
|
||
time.Sleep(2 * time.Second)
|
||
if !wxqi.wxconn.IsConnected() {
|
||
// 等待 1 秒
|
||
time.Sleep(1 * time.Second)
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetLoginQrcodeRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
}
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendLoginQRCodeRequest(tmpUserInfo)
|
||
if err != nil {
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
|
||
// 获取登录二维码响应
|
||
qrCodeResponse := &wechat.LoginQRCodeResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, qrCodeResponse)
|
||
if err != nil {
|
||
// 请求出问题了，应该关闭链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
return qrCodeResponse, nil
|
||
}
|
||
|
||
// SendGetLoginQrcodeRequest 获取登录二维码(绕过验证码)
|
||
func (wxqi *WXReqInvoker) SendGetLoginQrcodeRequestX() (*wechat.LoginQRCodeResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetLoginQrcodeRequestX error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetLoginQrcodeRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendLoginQRCodeRequestX(tmpUserInfo)
|
||
if err != nil {
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
|
||
// 获取登录二维码响应
|
||
qrCodeResponse := &wechat.LoginQRCodeResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, qrCodeResponse)
|
||
if err != nil {
|
||
// 请求出问题了，应该关闭链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
return qrCodeResponse, nil
|
||
}
|
||
|
||
// SendCheckLoginQrcodeRequest 检测二维码状态
|
||
func (wxqi *WXReqInvoker) SendCheckLoginQrcodeRequest(qrcodeUUID string, qrcodeKey []byte) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCheckLoginQrcodeRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendCheckLoginQrcodeRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 跟新缓存到二维码信息
|
||
wxCache := wxqi.wxconn.GetWXCache()
|
||
tmpQrcodeInfo := wxCache.GetQrcodeInfo()
|
||
tmpQrcodeInfo.QrCodeUUID = qrcodeUUID
|
||
tmpQrcodeInfo.QrCodeKey = qrcodeKey
|
||
wxCache.SetQrcodeInfo(tmpQrcodeInfo)
|
||
|
||
// 获取检测二维码状态请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
reqData, err := clientsdk.GetCheckLoginQRCodeRequest(tmpUserInfo, qrcodeUUID, qrcodeKey)
|
||
if err != nil {
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return err
|
||
}
|
||
|
||
// 发送给长链接请求去处理
|
||
longReq := &WXLongRequest{
|
||
OpCode: mmtls.MMLongOperationCheckQrcode,
|
||
Data: reqData,
|
||
}
|
||
wxqi.wxconn.SendToWXLongReqQueue(longReq)
|
||
return nil
|
||
}
|
||
|
||
// 发送登录请求根据设备Id进行登录
|
||
func (wxqi *WXReqInvoker) SendManualAuthByDeviceIdRequest() error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendManualAuthByDeviceIdRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendManualAuthByDeviceIdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
//检查是否在线会进行一次二次登录如果用户退出或者掉线才能重新登录
|
||
if wxqi.wxconn.CheckOnLineStatus() {
|
||
return errors.New("该链接已绑定微信号！")
|
||
}
|
||
// 根据数据库缓存跟新UserInfo
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
tmpDeviceId := tmpUserInfo.LoginDataInfo.LoginData
|
||
userName := tmpUserInfo.LoginDataInfo.UserName
|
||
password := tmpUserInfo.LoginDataInfo.PassWord
|
||
if strings.HasPrefix(tmpDeviceId, "62") {
|
||
tmpDeviceId, err := clientsdk.Parse62Data(tmpDeviceId)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
tmpUserInfo.DeviceInfo.SetDeviceId(tmpDeviceId)
|
||
} else if !strings.HasPrefix(tmpDeviceId, "49") && len(tmpDeviceId) >= 32 {
|
||
tmpUserInfo.DeviceInfo.SetDeviceId("49" + tmpDeviceId[2:])
|
||
} else if strings.HasPrefix(tmpDeviceId, "49") && len(tmpDeviceId) >= 32 {
|
||
tmpUserInfo.DeviceInfo.SetDeviceId(tmpDeviceId)
|
||
} else if strings.HasPrefix(tmpDeviceId, "A") {
|
||
tmpUserInfo.DeviceInfoA16.DeviceId = []byte(tmpDeviceId[:15])
|
||
tmpUserInfo.DeviceInfoA16.DeviceIdStr = tmpDeviceId
|
||
tmpUserInfo.DeviceInfo = nil
|
||
return dataA16Login(wxqi, tmpUserInfo, password, userName)
|
||
} else {
|
||
//短信登录
|
||
tmpUserInfo.Ticket = tmpUserInfo.LoginDataInfo.Ticket
|
||
return SmsLogin(wxqi, tmpUserInfo, password, userName)
|
||
//return errors.New("SendManualAuthByDeviceIdRequest err: deviceId something the matter")
|
||
}
|
||
// 发送62登录请求
|
||
tmpUserInfo.DeviceInfoA16 = nil
|
||
return data62Login(wxqi, tmpUserInfo, password, userName)
|
||
}
|
||
|
||
// A16登录请求
|
||
func dataA16Login(wxqi *WXReqInvoker, tmpUserInfo *baseinfo.UserInfo, password string, userName string) error {
|
||
//进行登录操作
|
||
packHeader, err := clientsdk.SendHybridManualAutoRequest(tmpUserInfo, password, userName, 146)
|
||
//packHeader, err := clientsdk.SendManualAuth(tmpUserInfo, password, userName)
|
||
if err != nil {
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return err
|
||
}
|
||
//var manualResponse wechat.UnifyAuthResponse
|
||
var manualResponse wechat.ManualAuthResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, &manualResponse)
|
||
if err != nil {
|
||
log.Info("error SendManualAuth", err.Error())
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return err
|
||
}
|
||
retCode := manualResponse.GetBaseResponse().GetRet()
|
||
if retCode == baseinfo.MMErrIdcRedirect {
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
return dealRouter.Handle(wxResp)
|
||
} else if retCode == baseinfo.MMLoginSuccess {
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
} else {
|
||
// 断开链接
|
||
defer wxqi.wxconn.Stop()
|
||
}
|
||
// 发送给微信消息处理器
|
||
return errors.New("login failed：" + manualResponse.GetBaseResponse().GetErrMsg().GetStr())
|
||
}
|
||
|
||
func SmsLogin(wxqi *WXReqInvoker, tmpUserInfo *baseinfo.UserInfo, password string, userName string) error {
|
||
var manualResponse wechat.ManualAuthResponse
|
||
tmpUserInfo.DeviceInfoA16 = nil
|
||
//packHeader, err := clientsdk.SendManualAuth(tmpUserInfo, password, userName)
|
||
packHeader, err := clientsdk.SendHybridManualAutoRequest(tmpUserInfo, password, userName, 146)
|
||
if err != nil {
|
||
// 断开链接
|
||
log.Info("短信登录断开", err.Error())
|
||
wxqi.wxconn.Stop()
|
||
return err
|
||
}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, &manualResponse)
|
||
if err != nil {
|
||
// 断开链接
|
||
log.Info("短信登录断开", err.Error())
|
||
wxqi.wxconn.Stop()
|
||
return err
|
||
}
|
||
retCode := manualResponse.GetBaseResponse().GetRet()
|
||
if retCode == baseinfo.MMErrIdcRedirect {
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
//wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
return dealRouter.Handle(wxResp)
|
||
} else if retCode == baseinfo.MMLoginSuccess {
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
} else {
|
||
// 断开链接
|
||
defer wxqi.wxconn.Stop()
|
||
}
|
||
// 发送给微信消息处理器
|
||
return errors.New("login failed：" + manualResponse.GetBaseResponse().GetErrMsg().GetStr())
|
||
}
|
||
|
||
// 62登录
|
||
func data62Login(wxqi *WXReqInvoker, tmpUserInfo *baseinfo.UserInfo, password string, userName string) error {
|
||
// 发送请求
|
||
var manualResponse wechat.ManualAuthResponse
|
||
if tmpUserInfo.LoginDataInfo.NewType == 1 {
|
||
packHeader, err := clientsdk.SendHybridManualAutoRequest(tmpUserInfo, password, userName, 145)
|
||
if err != nil {
|
||
// 断开链接
|
||
log.Info("62登录断开", err.Error())
|
||
wxqi.wxconn.Stop()
|
||
return err
|
||
}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, &manualResponse)
|
||
if err != nil {
|
||
// 断开链接
|
||
log.Info("62登录断开", err.Error())
|
||
wxqi.wxconn.Stop()
|
||
return err
|
||
}
|
||
retCode := manualResponse.GetBaseResponse().GetRet()
|
||
if retCode == baseinfo.MMErrIdcRedirect {
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
//wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
return dealRouter.Handle(wxResp)
|
||
} else if retCode == baseinfo.MMLoginSuccess {
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
} else {
|
||
// 断开链接
|
||
defer wxqi.wxconn.Stop()
|
||
}
|
||
// 发送给微信消息处理器
|
||
return errors.New("login failed：" + manualResponse.GetBaseResponse().GetErrMsg().GetStr())
|
||
} else {
|
||
//packHeader, err := clientsdk.SendHybridManualAutoRequest(tmpUserInfo, password, userName, 146)
|
||
packHeader, err := clientsdk.SendManualAuth(tmpUserInfo, password, userName)
|
||
//session:=hex.EncodeToString(packHeader.Session)
|
||
//fmt.Println("-->",session)
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, &manualResponse)
|
||
if err != nil {
|
||
// 断开链接
|
||
log.Info("62登录断开", err.Error())
|
||
wxqi.wxconn.Stop()
|
||
return err
|
||
}
|
||
//特殊号，新疆、西藏
|
||
/*if session=="000000000000"{
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
tmpUserInfo.LoginDataInfo.NewType=1
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
return dealRouter.Handle(wxResp)
|
||
}*/
|
||
retCode := manualResponse.GetBaseResponse().GetRet()
|
||
if retCode == baseinfo.MMErrIdcRedirect {
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
//wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
return dealRouter.Handle(wxResp)
|
||
} else if retCode == baseinfo.MMLoginSuccess {
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
} else {
|
||
// 断开链接
|
||
defer wxqi.wxconn.Stop()
|
||
}
|
||
// 发送给微信消息处理器
|
||
return errors.New("login failed：" + manualResponse.GetBaseResponse().GetErrMsg().GetStr())
|
||
}
|
||
//tmpUserInfo.HostUrl = manualResponse.GetDnsInfo().NewHostList.List[1].GetSubstitute()
|
||
}
|
||
|
||
// 获取DeviceToken
|
||
func (wxqi *WXReqInvoker) SendDeviceTokenRequest() (*wechat.TrustResp, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendDeviceTokenRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendDeviceTokenRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 根据数据库缓存跟新UserInfo
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendDeviceTokenRequest(tmpUserInfo)
|
||
if err != nil {
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
trustResp := &wechat.TrustResp{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, trustResp)
|
||
if err != nil {
|
||
// 断开链接
|
||
// 请求出问题了，判断是否掉线，并重连
|
||
// wxqi.wxconn.CheckOnLineStatusLogin()
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
// 发送给微信消息处理器
|
||
fmt.Println(trustResp.BaseResponse.GetErrMsg().GetStr())
|
||
return trustResp, nil
|
||
}
|
||
|
||
// SendManualAuthRequest 发送登陆请求
|
||
func (wxqi *WXReqInvoker) SendManualAuthRequest(newPass string, wxID string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendManualAuthRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendManualAuthRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 根据数据库缓存跟新UserInfo
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
// 发送请求
|
||
send:
|
||
//clientsdk.SendHybridManualAutoRequest(tmpUserInfo,newPass,wxID,0) //
|
||
packHeader, err := clientsdk.SendManualAuth(tmpUserInfo, newPass, wxID)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MM_ERR_CERT_EXPIRED {
|
||
// 切换密钥登录
|
||
tmpUserInfo.SwitchRSACert()
|
||
goto send
|
||
}
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return err
|
||
}
|
||
|
||
// 跟新缓存到二维码信息
|
||
wxCache := wxqi.wxconn.GetWXCache()
|
||
tmpQrcodeInfo := wxCache.GetQrcodeInfo()
|
||
tmpQrcodeInfo.QrCodePassword = newPass
|
||
tmpQrcodeInfo.QrCodeWxId = wxID
|
||
wxCache.SetQrcodeInfo(tmpQrcodeInfo)
|
||
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendHybridManualAutoRequest
|
||
// ver hybrid 密钥版本 145 和146
|
||
func (wxqi *WXReqInvoker) SendHybridManualAutoRequest(newPass string, wxID string, ver byte) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendHybridManualAutoRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendManualAuthRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 根据数据库缓存跟新UserInfo
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
// 发送请求
|
||
packHeader, err := clientsdk.SendHybridManualAutoRequest(tmpUserInfo, newPass, wxID, ver)
|
||
if err != nil {
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return err
|
||
}
|
||
|
||
// 跟新缓存到二维码信息
|
||
wxCache := wxqi.wxconn.GetWXCache()
|
||
tmpQrcodeInfo := wxCache.GetQrcodeInfo()
|
||
tmpQrcodeInfo.QrCodePassword = newPass
|
||
tmpQrcodeInfo.QrCodeWxId = wxID
|
||
wxCache.SetQrcodeInfo(tmpQrcodeInfo)
|
||
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendAutoAuthRequest 发送Token登陆请求
|
||
func (wxqi *WXReqInvoker) SendAutoAuthRequest() error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendAutoAuthRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
// 开始 二次 登录
|
||
fmt.Println(time.Now().Format("2006-01-02 15:04:05"), "开始二次登录", "["+wxqi.wxconn.GetWXAccount().GetUserInfo().GetUserName()+"]", wxqi.wxconn.GetWXAccount().GetUserInfo().UUID)
|
||
// 发送请求
|
||
send:
|
||
packHeader := &baseinfo.PackHeader{}
|
||
var err error = nil
|
||
// 尝试 3 次二次登录
|
||
packHeader, err = clientsdk.SendAutoAuthRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MM_ERR_CERT_EXPIRED {
|
||
tmpUserInfo.SwitchRSACert()
|
||
}
|
||
|
||
// 200 毫秒判断一次 !wxqi.wxconn.IsConnected()， 10 秒后重新二次登录
|
||
count := 5 * 10
|
||
for {
|
||
if count <= 0 {
|
||
break
|
||
}
|
||
count = count - 1
|
||
time.Sleep(200 * time.Millisecond)
|
||
}
|
||
packHeader, err = clientsdk.SendAutoAuthRequest(tmpUserInfo)
|
||
}
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MM_ERR_CERT_EXPIRED {
|
||
tmpUserInfo.SwitchRSACert()
|
||
}
|
||
// 200 毫秒判断一次 !wxqi.wxconn.IsConnected()， 10 秒后重新二次登录
|
||
count := 5 * 10
|
||
for {
|
||
if count <= 0 {
|
||
break
|
||
}
|
||
count = count - 1
|
||
if !wxqi.wxconn.IsConnected() && packHeader != nil && baseinfo.MMErrSessionTimeOut == packHeader.RetCode {
|
||
// 退出
|
||
wxqi.wxconn.Stop()
|
||
return nil
|
||
}
|
||
time.Sleep(200 * time.Millisecond)
|
||
}
|
||
packHeader, err = clientsdk.SendAutoAuthRequest(tmpUserInfo)
|
||
}
|
||
if err != nil {
|
||
// 断开链接
|
||
log.Info("二次登录失败", err.Error())
|
||
if packHeader != nil {
|
||
switch packHeader.RetCode {
|
||
case baseinfo.MMErrSessionTimeOut: // Session 会话过期
|
||
wxqi.wxconn.GetWXAccount().SetLoginState(baseinfo.MMLoginStateNoLogin)
|
||
db.UpdateLoginStatus(wxqi.wxconn.GetWXAccount().GetUserInfo().GetUserName(), int32(wxqi.wxconn.GetWXAccount().GetLoginState()), "二次登录失败需要重新登录")
|
||
wxqi.wxconn.Stop()
|
||
case baseinfo.MMErrDropped: // 账号被强制下线
|
||
wxqi.wxconn.GetWXAccount().SetLoginState(baseinfo.MMLoginStateOffLine)
|
||
db.UpdateLoginStatus(wxqi.wxconn.GetWXAccount().GetUserInfo().GetUserName(), int32(wxqi.wxconn.GetWXAccount().GetLoginState()), "账号被客户强制下线")
|
||
wxqi.wxconn.Stop()
|
||
case baseinfo.MM_ERR_CERT_EXPIRED:
|
||
tmpUserInfo.SwitchRSACert()
|
||
goto send
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
return dealRouter.Handle(wxResp)
|
||
}
|
||
|
||
// SendPushQrLoginNotice 发送二维码二次登录请求
|
||
func (wxqi *WXReqInvoker) SendPushQrLoginNotice() (*wechat.PushLoginURLResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendPushQrLoginNotice error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 重新链接，然后发送二维码二次登陆请求
|
||
wxqi.wxconn.Stop()
|
||
err := wxqi.wxconn.Start()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendPushQrLoginNotice err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendPushQrLoginNotice(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.GetRetCode() == baseinfo.MMRequestRetSessionTimeOut {
|
||
return nil, errors.New("SendPushQrLoginNotice err: packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut ")
|
||
}
|
||
|
||
// 断开链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
|
||
// 获取登录二维码响应
|
||
qrCodeResponse := &wechat.PushLoginURLResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, qrCodeResponse)
|
||
if err != nil {
|
||
// 请求出问题了，应该关闭链接
|
||
wxqi.wxconn.Stop()
|
||
return nil, err
|
||
}
|
||
|
||
//让路由处理时间
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
dealRouter.Handle(wxResp)
|
||
|
||
return qrCodeResponse, nil
|
||
}
|
||
|
||
// SendHeartBeatRequest 发送心跳包
|
||
func (wxqi *WXReqInvoker) SendHeartBeatRequest() error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendHeartBeatRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 如果心跳包已经停止发送
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendHeartBeatRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 获取请求包
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
reqData, err := clientsdk.GetHeartBeatRequest(tmpUserInfo)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
// 发送给长链接请求去处理
|
||
longReq := &WXLongRequest{
|
||
OpCode: mmtls.MMLongOperationHeartBeat,
|
||
Data: reqData,
|
||
}
|
||
wxqi.wxconn.SendToWXLongReqQueue(longReq)
|
||
return nil
|
||
}
|
||
|
||
// GetHeartBeatShortRequest 发送短链接心跳
|
||
func (wxqi *WXReqInvoker) SendHeartBeatShortRequest() (*wechat.HeartBeatResponse, int32, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendHeartBeatShortRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.GetHeartBeatShortRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.CheckSessionOut() {
|
||
return nil, packHeader.RetCode, errors.New("SendHeartBeatShortRequest sessionOut")
|
||
}
|
||
return nil, 0, err
|
||
}
|
||
|
||
hearBeatResp := new(wechat.HeartBeatResponse)
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, hearBeatResp)
|
||
if err != nil {
|
||
return nil, packHeader.RetCode, err
|
||
}
|
||
return hearBeatResp, 0, nil
|
||
}
|
||
|
||
// 获取设备
|
||
func (wxqi *WXReqInvoker) SendGetSafetyInfoRequest() (*wechat.GetSafetyInfoResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetSafetyInfoRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("setPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetSafetyInfoRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.GetSafetyInfoResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 删除设备
|
||
func (wxqi *WXReqInvoker) SendDelSafeDeviceRequest(deviceUUID string) (*wechat.DelSafeDeviceResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendDelSafeDeviceRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("setPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendDelSafeDeviceRequest(tmpUserInfo, deviceUUID)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.DelSafeDeviceResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 获取硬件设备情况
|
||
func (wxqi *WXReqInvoker) SendGetBoundHardDeviceRequest() (*wechat.GetBoundHardDevicesResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetBoundHardDeviceRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("setPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.GetBoundHardDeviceRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.GetBoundHardDevicesResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 检测微信登录环境
|
||
func (wxqi *WXReqInvoker) SendCheckCanSetAliasRequest() (*wechat.CheckCanSetAliasResp, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCheckCanSetAliasRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("setPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendCheckCanSetAliasRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.CheckCanSetAliasResp{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// SendNewSyncRequest 发送同步请求
|
||
func (wxqi *WXReqInvoker) SendNewSyncRequest(scene uint32) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendNewSyncRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 注释掉强制设置初始化完成，避免触发历史消息推送
|
||
// wxqi.wxconn.GetWXCache().SetInitNewSyncFinished(true)
|
||
// wxqi.wxconn.GetWXCache().SetInitContactFinished(true)
|
||
// wxqi.wxconn.GetWXCache().SetInitFavSyncFinished(true)
|
||
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendNewSyncRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendNewSyncRequest(tmpUserInfo, scene)
|
||
if err != nil {
|
||
if packHeader != nil && (packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut || packHeader.RetCode == baseinfo.MMErrSessionTimeOut) {
|
||
// token登陆
|
||
// wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
return dealRouter.Handle(wxResp)
|
||
}
|
||
|
||
// 同步消息
|
||
func (wxqi *WXReqInvoker) SendWxSyncMsg(key string) (*wechat.NewSyncResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendWxSyncMsg error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendWxSyncMsg err: wxconn.IsConnected() == false")
|
||
}
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendWxSyncMsg(tmpUserInfo, key)
|
||
if err != nil {
|
||
if packHeader != nil && (packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut || packHeader.RetCode == baseinfo.MMErrSessionTimeOut) {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.NewSyncResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// SendNewInitSyncRequest 首次登录初始化
|
||
func (wxqi *WXReqInvoker) SendNewInitSyncRequest() error {
|
||
return nil
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendNewInitSyncRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 同步历史消息控制
|
||
if !srvconfig.GlobalSetting.SyncHisyory {
|
||
fmt.Println("不进行初始化同步（跳过历史消息）")
|
||
// 禁用历史消息推送，不设置初始化完成标志
|
||
// wxqi.wxconn.GetWXCache().SetInitNewSyncFinished(true)
|
||
return nil
|
||
}
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendNewInitSyncRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendNewInitSyncRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && (packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut || packHeader.RetCode == baseinfo.MMErrSessionTimeOut) {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
return dealRouter.Handle(wxResp)
|
||
}
|
||
|
||
// SendGetProfileRequest 获取微信账号配置信息
|
||
func (wxqi *WXReqInvoker) SendGetProfileRequest() error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetProfileRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendGetProfileRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetProfileRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendGetProfileRequest 获取微信账号配置信息
|
||
func (wxqi *WXReqInvoker) SendGetProfileNewRequest() (*wechat.GetProfileResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetProfileNewRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetProfileNewRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetProfileRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
response := &wechat.GetProfileResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
return response, err
|
||
}
|
||
|
||
// SendInitContactRequest 发送初始化联系人请求
|
||
func (wxqi *WXReqInvoker) SendInitContactRequest(contactSeq uint32) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendInitContactRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendInitContactRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendInitContactReq(tmpUserInfo, contactSeq)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// 分页获取联系人
|
||
func (wxqi *WXReqInvoker) SendGetContactListPageRequest(CurrentWxcontactSeq uint32, CurrentChatRoomContactSeq uint32) (*wechat.InitContactResp, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetContactListPageRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("CurrentChatRoomContactSeq err: wxconn.IsConnected() == false")
|
||
}
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.GetContactListPageReq(tmpUserInfo, CurrentWxcontactSeq, CurrentChatRoomContactSeq)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.InitContactResp{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
return response, err
|
||
}
|
||
|
||
// SendBatchGetContactBriefInfoReq 批量获取联系人
|
||
func (wxqi *WXReqInvoker) SendBatchGetContactBriefInfoReq(userWxidList []string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendBatchGetContactBriefInfoReq error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendBatchGetContactBriefInfoReq err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendBatchGetContactBriefInfoReq(tmpUserInfo, userWxidList)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendGetContactRequest 获取联系人信息列表
|
||
func (wxqi *WXReqInvoker) SendGetContactRequest(userInfoList []string, antisPanTicketList []string, chatRoomWxidList []string, needResp bool) (*wechat.GetContactResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetContactRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetContactRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetContactRequest(tmpUserInfo, userInfoList, antisPanTicketList, chatRoomWxidList)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
if needResp {
|
||
response := &wechat.GetContactResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
return response, err
|
||
}
|
||
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil, nil
|
||
}
|
||
|
||
// 获取联系人信息，优先缓存获取 isCache 从缓存取 true，获取新的 false
|
||
func (wxqi *WXReqInvoker) SendGetContactRequestForCache(userWxid string, isCache bool) (*wechat.ModContact, *wechat.VerifyUserValidTicket, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetContactRequestForCache error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, nil, errors.New("SendGetContactRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
// 先缓存获取
|
||
if isCache {
|
||
ContactInfo := db.GetContact(userWxid, tmpUserInfo.UUID)
|
||
// ContactInfo := table.ContactList.GetModContacts(userWxid)
|
||
if ContactInfo != nil {
|
||
return ContactInfo, nil, nil
|
||
}
|
||
}
|
||
|
||
// 发送请求
|
||
userInfoList := make([]string, 1)
|
||
userInfoList[0] = userWxid
|
||
packHeader, err := clientsdk.SendGetContactRequest(tmpUserInfo, userInfoList, []string{}, []string{})
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, nil, err
|
||
}
|
||
|
||
// 解析获取联系人响应
|
||
getContactResp := new(wechat.GetContactResponse)
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, getContactResp)
|
||
if err != nil {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
return nil, nil, err
|
||
}
|
||
// 置顶群获取的数据缓存到程序（抢红包统计、转账统计、撤回都用得上）
|
||
contactInfo := getContactResp.GetContactList()[0]
|
||
verifyUser := getContactResp.GetVerifyUserValidTicketList()[0]
|
||
// table.ContactList.SetModContacts(contactInfo)
|
||
go db.SaveOrUpdateContact(contactInfo, tmpUserInfo.UUID)
|
||
return contactInfo, verifyUser, nil
|
||
}
|
||
|
||
// SendGetContactRequestForHB 获取联系人信息列表
|
||
func (wxqi *WXReqInvoker) SendGetContactRequestForHB(userWxid string) (*wechat.GetContactResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetContactRequestForHB error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetContactRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
userInfoList := make([]string, 1)
|
||
userInfoList[0] = userWxid
|
||
packHeader, err := clientsdk.SendGetContactRequest(tmpUserInfo, userInfoList, []string{}, []string{})
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
// 解析获取联系人响应
|
||
getContactResp := new(wechat.GetContactResponse)
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, getContactResp)
|
||
if err != nil {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
return nil, err
|
||
}
|
||
// 置顶群获取的数据缓存到程序（抢红包统计、转账统计、撤回都用得上）
|
||
// 判断不等于 null
|
||
if getContactResp.GetContactList() != nil && len(getContactResp.GetContactList()) > 0 {
|
||
contactInfo := getContactResp.GetContactList()[0]
|
||
go db.SaveOrUpdateContact(contactInfo, tmpUserInfo.UUID)
|
||
}
|
||
// table.ContactList.SetModContacts(userInfo)
|
||
return getContactResp, nil
|
||
}
|
||
|
||
// SendGetContactRequestForList 获取联系人信息列表List
|
||
func (wxqi *WXReqInvoker) SendGetContactRequestForList(userInfoList []string, roomWxIDList []string) (*wechat.GetContactResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetContactRequestForList error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetContactRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetContactRequest(tmpUserInfo, userInfoList, []string{}, roomWxIDList)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
// 解析获取联系人响应
|
||
getContactResp := new(wechat.GetContactResponse)
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, getContactResp)
|
||
if err != nil {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
return nil, err
|
||
}
|
||
return getContactResp, nil
|
||
}
|
||
|
||
// 获取好友关系状态
|
||
func (wxqi *WXReqInvoker) SendGetFriendRelationRequest(userName string) (*wechat.MMBizJsApiGetUserOpenIdResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetFriendRelationRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetFriendRela(ti\n\ttmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()\n\tpackHeader, err := clientsdk.SendGetFrienonReq err: wxconn.IsConnected() == false")
|
||
}
|
||
// 发送请求
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetFriendRelationReq(tmpUserInfo, userName)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
// 解析获取联系人响应
|
||
resp := new(wechat.MMBizJsApiGetUserOpenIdResponse)
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, resp)
|
||
if err != nil {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
return nil, err
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// 创建红包
|
||
func (wxqi *WXReqInvoker) SendWXCreateRedPacketRequest(hbItem *baseinfo.RedPacket) (*wechat.HongBaoRes, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendWXCreateRedPacketRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendReceiveWxHBRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 开始
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendWXCreateRedPacket(wxqi.wxconn.GetWXAccount().GetUserInfo(), hbItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
var hongbaoResp wechat.HongBaoRes
|
||
errs := clientsdk.ParseResponseData(tmpUserInfo, packHeader, &hongbaoResp)
|
||
if errs != nil {
|
||
return nil, errs
|
||
}
|
||
return &hongbaoResp, nil
|
||
}
|
||
|
||
// SendReceiveWxHBRequest 拆红包
|
||
func (wxqi *WXReqInvoker) SendOpenRedEnvelopesRequest(hbItem *baseinfo.HongBaoItem) (*wechat.HongBaoRes, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendOpenRedEnvelopesRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}() // 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendReceiveWxHBRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 开始接收红包
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
currentProfile := wxqi.wxconn.GetWXAccount().GetUserProfile()
|
||
hongBaoReceiverItem := new(baseinfo.HongBaoReceiverItem)
|
||
hongBaoReceiverItem.CgiCmd = baseinfo.MMHongBaoReqCgiCmdReceiveWxhb // 接收红包
|
||
hongBaoReceiverItem.Province = currentProfile.GetUserInfo().GetProvince() // 当前帐号设置的省
|
||
hongBaoReceiverItem.City = currentProfile.GetUserInfo().GetCity() // 当前帐号设置的市
|
||
hongBaoReceiverItem.InWay = baseinfo.MMHongBaoReqInAwayGroup // 群红包
|
||
hongBaoReceiverItem.NativeURL = hbItem.NativeURL // nativeurl
|
||
hongBaoReceiverItem.HongBaoURLItem = hbItem.URLItem
|
||
hongBaoReceiverItem.SceneID = hbItem.SceneID
|
||
// 判断群和私人
|
||
if hbItem.IsGroup != 1 {
|
||
hongBaoReceiverItem.InWay = baseinfo.MMHongBaoReqInAwayPersonal
|
||
}
|
||
// 发送接收红包请求
|
||
recvReqStartMs := time.Now().UnixMilli()
|
||
packHeader, err := clientsdk.SendReceiveWxHB(wxqi.wxconn.GetWXAccount().GetUserInfo(), hongBaoReceiverItem)
|
||
recvReqEndMs := time.Now().UnixMilli()
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
var hongbaoResp wechat.HongBaoRes
|
||
parseRespStartMs := time.Now().UnixMilli()
|
||
errs := clientsdk.ParseResponseData(tmpUserInfo, packHeader, &hongbaoResp)
|
||
parseRespEndMs := time.Now().UnixMilli()
|
||
|
||
if errs != nil {
|
||
return nil, errs
|
||
}
|
||
// 解析
|
||
retHongBaoReceiveResp := &baseinfo.HongBaoReceiverResp{}
|
||
unmarshalRecvStartMs := time.Now().UnixMilli()
|
||
err = json.Unmarshal(hongbaoResp.GetRetText().GetBuffer(), retHongBaoReceiveResp)
|
||
unmarshalRecvEndMs := time.Now().UnixMilli()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// 发送给微信消息处理器 打开红包
|
||
openReqStartMs := time.Now().UnixMilli()
|
||
rsp, er := wxqi.SendOpenWxHBNewRequest(hbItem, retHongBaoReceiveResp.TimingIdentifier)
|
||
openReqEndMs := time.Now().UnixMilli()
|
||
if er != nil {
|
||
return nil, er
|
||
}
|
||
|
||
var data RedPacket
|
||
if rsp != nil {
|
||
_ = json.Unmarshal(rsp.RetText.Buffer, &data)
|
||
}
|
||
nowMs := time.Now().UnixMilli()
|
||
if hbItem != nil && hbItem.RecvAtMs > 0 && data.Retcode == 0 && data.ReceiveStatus == 2 {
|
||
detectToEnqueue := hbItem.EnqueueAtMs - hbItem.RecvAtMs
|
||
enqueueToDequeue := hbItem.DequeueAtMs - hbItem.EnqueueAtMs
|
||
dequeueToRecvStart := recvReqStartMs - hbItem.DequeueAtMs
|
||
recvNet := recvReqEndMs - recvReqStartMs
|
||
parseResp := parseRespEndMs - parseRespStartMs
|
||
unmarshalRecv := unmarshalRecvEndMs - unmarshalRecvStartMs
|
||
openNet := openReqEndMs - openReqStartMs
|
||
openDoneMs := openReqEndMs - hbItem.RecvAtMs
|
||
totalMs := nowMs - hbItem.RecvAtMs
|
||
fmt.Printf("红包耗时 total=%dms open=%dms detect->enqueue=%dms enqueue->dequeue=%dms dequeue->recvStart=%dms recvNet=%dms parse=%dms recvUnmarshal=%dms openNet=%dms sendid=%s isGroup=%d fromUser=%s\n",
|
||
totalMs, openDoneMs, detectToEnqueue, enqueueToDequeue, dequeueToRecvStart, recvNet, parseResp, unmarshalRecv, openNet, data.SendId, hbItem.IsGroup, hbItem.FromUserName)
|
||
}
|
||
|
||
// go func() {
|
||
// wxqi.SendOpenHBMsgToSelf(rsp, hbItem)
|
||
// wxqi.ThanksHB(rsp)
|
||
// }()
|
||
return rsp, nil
|
||
}
|
||
|
||
// ThanksHB 抢红包回复感谢语
|
||
func (wxqi *WXReqInvoker) ThanksHB(HongBaoRes *wechat.HongBaoRes) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("ThanksHB error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
currentTaskMgr := wxqi.wxconn.GetWXTaskMgr()
|
||
taskMgr, _ := currentTaskMgr.(*WXTaskMgr)
|
||
currentGrapHBMgr := taskMgr.GetGrabHBTask()
|
||
if !currentGrapHBMgr.IsAutoReply() {
|
||
return
|
||
}
|
||
autoReplyContent := currentGrapHBMgr.GetAutoReplyContent()
|
||
if autoReplyContent == "" {
|
||
return
|
||
}
|
||
|
||
var data RedPacket
|
||
err := json.Unmarshal(HongBaoRes.RetText.Buffer, &data)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if data.Retcode == 0 && data.ReceiveStatus == 2 {
|
||
groupid := data.SessionUserName
|
||
sendWxid := data.SendUserName
|
||
if sendWxid == wxqi.wxconn.GetWXAccount().GetUserInfo().WxId {
|
||
return
|
||
}
|
||
|
||
type KV struct {
|
||
Msg string
|
||
msgType int
|
||
}
|
||
kvs := []KV{}
|
||
for _, v := range strings.Split(autoReplyContent, ",") {
|
||
// 清理前后空格，判断不能为空
|
||
v = strings.TrimSpace(v)
|
||
if v == "" {
|
||
continue
|
||
}
|
||
kvs = append(kvs, KV{v, 1})
|
||
}
|
||
// 判断 len 为 0 则不发送
|
||
if len(kvs) == 0 {
|
||
return
|
||
}
|
||
|
||
rand.Seed(time.Now().UnixNano())
|
||
randomIndex := rand.Intn(len(kvs))
|
||
randomKV := kvs[randomIndex]
|
||
time.Sleep(9 * time.Second)
|
||
switch randomKV.msgType {
|
||
case 1:
|
||
wxqi.SendTextMsgRequest(groupid, randomKV.Msg, []string{}, 1)
|
||
return
|
||
case 2:
|
||
wxqi.SendEmojiRequest(randomKV.Msg, groupid, 1)
|
||
return
|
||
default:
|
||
return
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
func (wxqi *WXReqInvoker) SendOpenHBMsgToSelf(HongBaoRes *wechat.HongBaoRes, hbItem *baseinfo.HongBaoItem) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendOpenHBMsgToSelf error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
// 判断统计是否开启
|
||
currentTaskMgr := wxqi.wxconn.GetWXTaskMgr()
|
||
taskMgr, _ := currentTaskMgr.(*WXTaskMgr)
|
||
currentGrapHBMgr := taskMgr.GetGrabHBTask()
|
||
if !currentGrapHBMgr.IsHBStat() {
|
||
return
|
||
}
|
||
var data RedPacket
|
||
err := json.Unmarshal(HongBaoRes.RetText.Buffer, &data)
|
||
// buffer 转 字符串
|
||
// hongbaoRespStr := string(HongBaoRes.RetText.Buffer)
|
||
// fmt.Println("SendOpenHBMsgToSelf hongbaoRespStr1: ", hongbaoRespStr)
|
||
// sendWxid 企业红包为空
|
||
if err != nil {
|
||
return
|
||
}
|
||
if data.Retcode == 0 && data.ReceiveStatus == 2 {
|
||
now := time.Now()
|
||
timeStr := now.Format("2006-01-02 15:04:05")
|
||
amount := data.Amount
|
||
totalNum := data.TotalNum
|
||
totalAmount := data.TotalAmount
|
||
sendWxid := data.SendUserName
|
||
if sendWxid == "" {
|
||
sendWxid = hbItem.FromUserName
|
||
}
|
||
groupid := data.SessionUserName
|
||
// 判断是个人还是群
|
||
grouName := ""
|
||
sendUser := ""
|
||
if hbItem.IsGroup == 1 {
|
||
// groupInfo := table.ContactList.GetModContacts(groupid)
|
||
groupInfo := db.GetContact(groupid, tmpUserInfo.UUID)
|
||
if groupInfo == nil {
|
||
result, _ := wxqi.SendGetContactRequest([]string{groupid}, nil, []string{groupid}, true)
|
||
groupInfo = result.GetContactList()[0]
|
||
go db.SaveOrUpdateContact(groupInfo, tmpUserInfo.UUID)
|
||
}
|
||
chatroomMemberList := groupInfo.GetNewChatroomData().GetChatroomMemberList()
|
||
for i := range chatroomMemberList {
|
||
if chatroomMemberList[i].GetUserName() == sendWxid {
|
||
sendUser = chatroomMemberList[i].GetNickName()
|
||
}
|
||
}
|
||
if sendUser == "" {
|
||
// 先从缓存取
|
||
sendUserInfo := db.GetContact(sendWxid, tmpUserInfo.UUID)
|
||
// sendUserInfo := table.ContactList.GetModContacts(sendWxid)
|
||
if sendUserInfo == nil {
|
||
result, _ := wxqi.SendGetContactRequest([]string{sendWxid}, nil, []string{groupid}, true)
|
||
sendUserInfo = result.GetContactList()[0]
|
||
go db.SaveOrUpdateContact(sendUserInfo, tmpUserInfo.UUID)
|
||
}
|
||
// wxqi.wxconn.
|
||
// table.ContactList.SetModContacts(sendUserInfo)
|
||
sendUser = sendUserInfo.NickName.GetStr()
|
||
}
|
||
grouName = groupInfo.NickName.GetStr()
|
||
// table.ContactList.SetModContacts(groupInfo)
|
||
} else {
|
||
// sendUserInfo := table.ContactList.GetModContacts(sendWxid)
|
||
sendUserInfo := db.GetContact(sendWxid, tmpUserInfo.UUID)
|
||
if sendUserInfo == nil {
|
||
result, _ := wxqi.SendGetContactRequest([]string{sendWxid}, nil, []string{}, true)
|
||
sendUserInfo = result.GetContactList()[0]
|
||
go db.SaveOrUpdateContact(sendUserInfo, tmpUserInfo.UUID)
|
||
}
|
||
sendUser = sendUserInfo.NickName.GetStr()
|
||
// table.ContactList.SetModContacts(sendUserInfo)
|
||
}
|
||
financialStats := &FinancialStats{}
|
||
AmountKey := wxqi.wxconn.GetWXAccount().GetUserInfo().WxId + "_Amount_" + strconv.FormatUint(uint64(hbItem.IsGroup), 10)
|
||
error := db.GETObj(AmountKey, financialStats)
|
||
if error != nil {
|
||
}
|
||
cumulativeAmount := financialStats.GlobalTotalAmount + amount
|
||
// 累计金额
|
||
financialStats.GlobalTotalAmount = cumulativeAmount
|
||
// 累计次数
|
||
financialStats.GlobalTotalCount = financialStats.GlobalTotalCount + 1
|
||
// 历史累计 2006-01-02
|
||
dateStr := now.Format("2006-01-02")
|
||
//昨天
|
||
yesterdayStr := now.AddDate(0, 0, -1).Format("2006-01-02")
|
||
//前天
|
||
beforeYesterdayStr := now.AddDate(0, 0, -2).Format("2006-01-02")
|
||
if financialStats.History == nil {
|
||
financialStats.History = make(map[string]HistoryFinancial)
|
||
}
|
||
// 今天
|
||
if _, ok := financialStats.History[dateStr]; !ok {
|
||
financialStats.History[dateStr] = HistoryFinancial{
|
||
0,
|
||
0,
|
||
}
|
||
}
|
||
// 昨天
|
||
if _, ok := financialStats.History[yesterdayStr]; !ok {
|
||
financialStats.History[yesterdayStr] = HistoryFinancial{
|
||
0,
|
||
0,
|
||
}
|
||
}
|
||
// 前天
|
||
if _, ok := financialStats.History[beforeYesterdayStr]; !ok {
|
||
financialStats.History[beforeYesterdayStr] = HistoryFinancial{
|
||
0,
|
||
0,
|
||
}
|
||
}
|
||
financialStats.History[dateStr] = HistoryFinancial{
|
||
TotalAmount: financialStats.History[dateStr].TotalAmount + amount,
|
||
TotalCount: financialStats.History[dateStr].TotalCount + 1,
|
||
}
|
||
// 群累计金额
|
||
var presonCumulativeAmount int
|
||
// 群累计次数
|
||
var presonCumulativeCount int
|
||
|
||
isExistPreson := false
|
||
if hbItem.IsGroup == 1 {
|
||
for i := range financialStats.Stats {
|
||
if (hbItem.IsGroup == 1 && financialStats.Stats[i].GroupID == groupid) || (hbItem.IsGroup == 0 && financialStats.Stats[i].UserId == sendWxid) {
|
||
presonCumulativeAmount = financialStats.Stats[i].TotalAmount + amount
|
||
financialStats.Stats[i].TotalAmount = presonCumulativeAmount
|
||
presonCumulativeCount = financialStats.Stats[i].TotalCount + 1
|
||
financialStats.Stats[i].TotalCount = presonCumulativeCount
|
||
isExistPreson = true
|
||
break
|
||
}
|
||
}
|
||
if !isExistPreson {
|
||
presonCumulativeAmount = amount
|
||
presonCumulativeCount = 1
|
||
financialStats.Stats = append(financialStats.Stats, Preson{
|
||
groupid,
|
||
grouName,
|
||
sendWxid,
|
||
sendUser,
|
||
1,
|
||
amount,
|
||
})
|
||
|
||
}
|
||
}
|
||
|
||
//把金额缓存到redis
|
||
db.SETExpirationObj(AmountKey, financialStats, -1)
|
||
tipText := "【抢到红包啦】\n"
|
||
if hbItem.IsGroup == 1 {
|
||
tipText = tipText + "\t金额: " + fmt.Sprintf("%s元\n", fmt.Sprintf("%.2f", float64(amount)/100))
|
||
tipText = tipText + "\t总金额: " + fmt.Sprintf("%s元\n", fmt.Sprintf("%.2f", float64(totalAmount)/100))
|
||
tipText = tipText + "\t红包总数: " + fmt.Sprintf("%d\n", totalNum)
|
||
tipText = tipText + "\t时间: " + fmt.Sprintf("%s\n", timeStr)
|
||
tipText = tipText + "\t群名: " + fmt.Sprintf("%s\n", grouName)
|
||
tipText = tipText + "\t发送者: " + fmt.Sprintf("%s\n", sendUser)
|
||
tipText = tipText + "~~~~~~~~~~~~~~~~~~~~~\n"
|
||
tipText = tipText + "【群红包收入统计】\n"
|
||
tipText = tipText + "\t今日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[dateStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[dateStr].TotalCount))
|
||
tipText = tipText + "\t昨日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[yesterdayStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[yesterdayStr].TotalCount))
|
||
tipText = tipText + "\t前日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[beforeYesterdayStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[beforeYesterdayStr].TotalCount))
|
||
tipText = tipText + "\t本群累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(presonCumulativeAmount)/100), fmt.Sprintf("%d", financialStats.History[dateStr].TotalCount))
|
||
tipText = tipText + "\t全局累计: " + fmt.Sprintf("%s元 / %s次", fmt.Sprintf("%.2f", float64(cumulativeAmount)/100), fmt.Sprintf("%d", financialStats.GlobalTotalCount))
|
||
} else {
|
||
tipText = tipText + "\t金额: " + fmt.Sprintf("%s元\n", fmt.Sprintf("%.2f", float64(amount)/100))
|
||
tipText = tipText + "\t时间: " + fmt.Sprintf("%s\n", timeStr)
|
||
tipText = tipText + "\t发送者: " + fmt.Sprintf("%s\n", sendUser)
|
||
tipText = tipText + "~~~~~~~~~~~~~~~~~~~~~\n"
|
||
tipText = tipText + "【个人红包收入统计】\n"
|
||
tipText = tipText + "\t今日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[dateStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[dateStr].TotalCount))
|
||
tipText = tipText + "\t昨日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[yesterdayStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[yesterdayStr].TotalCount))
|
||
tipText = tipText + "\t前日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[beforeYesterdayStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[beforeYesterdayStr].TotalCount))
|
||
tipText = tipText + "\t全局累计: " + fmt.Sprintf("%s元 / %s次", fmt.Sprintf("%.2f", float64(cumulativeAmount)/100), fmt.Sprintf("%d", financialStats.GlobalTotalCount))
|
||
}
|
||
_, _ = wxqi.SendTextMsgRequest(wxqi.wxconn.GetWXAccount().GetUserInfo().WxId, tipText, []string{}, 1)
|
||
}
|
||
return
|
||
}
|
||
|
||
// 接收转账
|
||
func (wxqi *WXReqInvoker) SendReceiveZZ(transferItem *baseinfo.TenPayReqItem, wcPayInfo *baseinfo.WCPayInfo2) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendReceiveZZ error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}() // 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendReceiveZZ err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
ZZRes, err := wxqi.SendTenPayRequest(transferItem)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
// buffer 转 字符串
|
||
// hongbaoRespStr := string(ZZRes.RetText.Buffer)
|
||
// fmt.Println("SendOpenHBMsgToSelf hongbaoRespStr1: ", hongbaoRespStr)
|
||
// 转账后统计金额
|
||
wxqi.SendOpenZZMsgToSelf(ZZRes, wcPayInfo)
|
||
// 转账回复感谢语
|
||
wxqi.ThanksZZ(ZZRes, wcPayInfo)
|
||
return nil
|
||
|
||
}
|
||
|
||
// ThanksHB 转账回复感谢语
|
||
func (wxqi *WXReqInvoker) ThanksZZ(ZhuanZhangRes *wechat.TenPayResponse, wcPayInfo *baseinfo.WCPayInfo2) {
|
||
// fmt.Println("ThanksZZ", ZhuanZhangRes, wcPayInfo)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("ThanksZZ error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
currentTaskMgr := wxqi.wxconn.GetWXTaskMgr()
|
||
taskMgr, _ := currentTaskMgr.(*WXTaskMgr)
|
||
currentGrapHBMgr := taskMgr.GetGrabHBTask()
|
||
// fmt.Println("currentGrapHBMgr", currentGrapHBMgr.IsAutoTransferReply())
|
||
if !currentGrapHBMgr.IsAutoTransferReply() {
|
||
return
|
||
}
|
||
autoTransferReplyContent := currentGrapHBMgr.GetAutoTransferReplyContent()
|
||
// fmt.Println("autoTransferReplyContent", autoTransferReplyContent)
|
||
// 清除头尾空格
|
||
autoTransferReplyContent = strings.TrimSpace(autoTransferReplyContent)
|
||
// fmt.Println("autoTransferReplyContent", autoTransferReplyContent)
|
||
if autoTransferReplyContent == "" {
|
||
return
|
||
}
|
||
var data ZZPacket
|
||
err := json.Unmarshal(ZhuanZhangRes.RetText.Buffer, &data)
|
||
// fmt.Println("ZhuanZhangRes.RetText.Buffer", ZhuanZhangRes.RetText.Buffer)
|
||
if err != nil {
|
||
return
|
||
}
|
||
// fmt.Println("data", data)
|
||
if data.Retcode == "0" && data.Retmsg == "ok" {
|
||
// groupid := wcPayInfo.FromGroupId
|
||
sendWxid := wcPayInfo.FromUserName
|
||
// if groupid == "" {
|
||
// groupid = sendWxid
|
||
// }
|
||
if sendWxid == wxqi.wxconn.GetWXAccount().GetUserInfo().WxId {
|
||
return
|
||
}
|
||
fmt.Println("autoTransferReplyContent", autoTransferReplyContent, sendWxid)
|
||
wxqi.SendTextMsgRequest(sendWxid, autoTransferReplyContent, []string{}, 1)
|
||
}
|
||
}
|
||
|
||
func (wxqi *WXReqInvoker) SendOpenZZMsgToSelf(ZhuanZhangRes *wechat.TenPayResponse, wcPayInfo *baseinfo.WCPayInfo2) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendOpenZZMsgToSelf error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
// 判断统计是否开启
|
||
currentTaskMgr := wxqi.wxconn.GetWXTaskMgr()
|
||
taskMgr, _ := currentTaskMgr.(*WXTaskMgr)
|
||
currentGrapHBMgr := taskMgr.GetGrabHBTask()
|
||
fmt.Println("SendOpenZZMsgToSelf")
|
||
if !currentGrapHBMgr.IsTransStat() {
|
||
return
|
||
}
|
||
|
||
var data ZZPacket
|
||
err := json.Unmarshal(ZhuanZhangRes.RetText.Buffer, &data)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if data.Retcode == "0" && data.Retmsg == "ok" {
|
||
now := time.Now()
|
||
timeStr := now.Format("2006-01-02 15:04:05")
|
||
amount := data.Fee
|
||
sendWxid := ""
|
||
if sendWxid == "" {
|
||
sendWxid = wcPayInfo.FromUserName
|
||
}
|
||
groupid := wcPayInfo.FromGroupId
|
||
// 判断是个人还是群
|
||
grouName := ""
|
||
sendUser := ""
|
||
if wcPayInfo.FromGroupId != "" {
|
||
// groupInfo := table.ContactList.GetModContacts(groupid)
|
||
groupInfo := db.GetContact(groupid, tmpUserInfo.UUID)
|
||
if groupInfo == nil {
|
||
result, _ := wxqi.SendGetContactRequest([]string{groupid}, nil, []string{groupid}, true)
|
||
groupInfo = result.GetContactList()[0]
|
||
go db.SaveOrUpdateContact(groupInfo, tmpUserInfo.UUID)
|
||
}
|
||
chatroomMemberList := groupInfo.GetNewChatroomData().GetChatroomMemberList()
|
||
for i := range chatroomMemberList {
|
||
if chatroomMemberList[i].GetUserName() == sendWxid {
|
||
sendUser = chatroomMemberList[i].GetNickName()
|
||
}
|
||
}
|
||
if sendUser == "" {
|
||
// 先从缓存取
|
||
// sendUserInfo := table.ContactList.GetModContacts(sendWxid)
|
||
sendUserInfo := db.GetContact(sendWxid, tmpUserInfo.UUID)
|
||
if sendUserInfo == nil {
|
||
result, _ := wxqi.SendGetContactRequest([]string{sendWxid}, nil, []string{groupid}, true)
|
||
sendUserInfo = result.GetContactList()[0]
|
||
go db.SaveOrUpdateContact(sendUserInfo, tmpUserInfo.UUID)
|
||
|
||
}
|
||
// wxqi.wxconn.
|
||
// table.ContactList.SetModContacts(sendUserInfo)
|
||
sendUser = sendUserInfo.NickName.GetStr()
|
||
}
|
||
grouName = groupInfo.NickName.GetStr()
|
||
// table.ContactList.SetModContacts(groupInfo)
|
||
} else {
|
||
// sendUserInfo := table.ContactList.GetModContacts(sendWxid)
|
||
sendUserInfo := db.GetContact(sendWxid, tmpUserInfo.UUID)
|
||
if sendUserInfo == nil {
|
||
result, _ := wxqi.SendGetContactRequest([]string{sendWxid}, nil, []string{}, true)
|
||
sendUserInfo = result.GetContactList()[0]
|
||
go db.SaveOrUpdateContact(sendUserInfo, tmpUserInfo.UUID)
|
||
}
|
||
sendUser = sendUserInfo.NickName.GetStr()
|
||
// table.ContactList.SetModContacts(sendUserInfo)
|
||
}
|
||
financialStats := &FinancialStats{}
|
||
isGroup := "0"
|
||
if wcPayInfo.FromGroupId != "" {
|
||
isGroup = "1"
|
||
}
|
||
AmountKey := wxqi.wxconn.GetWXAccount().GetUserInfo().WxId + "_ZZ_Amount_" + isGroup
|
||
error := db.GETObj(AmountKey, financialStats)
|
||
if error != nil {
|
||
}
|
||
cumulativeAmount := financialStats.GlobalTotalAmount + amount
|
||
// 累计金额
|
||
financialStats.GlobalTotalAmount = cumulativeAmount
|
||
// 累计次数
|
||
financialStats.GlobalTotalCount = financialStats.GlobalTotalCount + 1
|
||
// 历史累计 2006-01-02
|
||
dateStr := now.Format("2006-01-02")
|
||
//昨天
|
||
yesterdayStr := now.AddDate(0, 0, -1).Format("2006-01-02")
|
||
//前天
|
||
beforeYesterdayStr := now.AddDate(0, 0, -2).Format("2006-01-02")
|
||
if financialStats.History == nil {
|
||
financialStats.History = make(map[string]HistoryFinancial)
|
||
}
|
||
// 今天
|
||
if _, ok := financialStats.History[dateStr]; !ok {
|
||
financialStats.History[dateStr] = HistoryFinancial{
|
||
0,
|
||
0,
|
||
}
|
||
}
|
||
// 昨天
|
||
if _, ok := financialStats.History[yesterdayStr]; !ok {
|
||
financialStats.History[yesterdayStr] = HistoryFinancial{
|
||
0,
|
||
0,
|
||
}
|
||
}
|
||
// 前天
|
||
if _, ok := financialStats.History[beforeYesterdayStr]; !ok {
|
||
financialStats.History[beforeYesterdayStr] = HistoryFinancial{
|
||
0,
|
||
0,
|
||
}
|
||
}
|
||
financialStats.History[dateStr] = HistoryFinancial{
|
||
TotalAmount: financialStats.History[dateStr].TotalAmount + amount,
|
||
TotalCount: financialStats.History[dateStr].TotalCount + 1,
|
||
}
|
||
// 群累计金额
|
||
var presonCumulativeAmount int
|
||
// 群累计次数
|
||
var presonCumulativeCount int
|
||
|
||
isExistPreson := false
|
||
if wcPayInfo.FromGroupId != "" {
|
||
for i := range financialStats.Stats {
|
||
if (wcPayInfo.FromGroupId != "" && financialStats.Stats[i].GroupID == groupid) || (wcPayInfo.FromGroupId == "" && financialStats.Stats[i].UserId == sendWxid) {
|
||
presonCumulativeAmount = financialStats.Stats[i].TotalAmount + amount
|
||
financialStats.Stats[i].TotalAmount = presonCumulativeAmount
|
||
presonCumulativeCount = financialStats.Stats[i].TotalCount + 1
|
||
financialStats.Stats[i].TotalCount = presonCumulativeCount
|
||
isExistPreson = true
|
||
break
|
||
}
|
||
}
|
||
if !isExistPreson {
|
||
presonCumulativeAmount = amount
|
||
presonCumulativeCount = 1
|
||
financialStats.Stats = append(financialStats.Stats, Preson{
|
||
groupid,
|
||
grouName,
|
||
sendWxid,
|
||
sendUser,
|
||
1,
|
||
amount,
|
||
})
|
||
|
||
}
|
||
}
|
||
|
||
//把金额缓存到redis
|
||
db.SETExpirationObj(AmountKey, financialStats, -1)
|
||
tipText := "【收到转账】\n"
|
||
if wcPayInfo.FromGroupId != "" {
|
||
tipText = tipText + "\t金额: " + fmt.Sprintf("%s元\n", fmt.Sprintf("%.2f", float64(amount)/100))
|
||
tipText = tipText + "\t时间: " + fmt.Sprintf("%s\n", timeStr)
|
||
tipText = tipText + "\t群名: " + fmt.Sprintf("%s\n", grouName)
|
||
tipText = tipText + "\t发送者: " + fmt.Sprintf("%s\n", sendUser)
|
||
tipText = tipText + "~~~~~~~~~~~~~~~~~~~~~\n"
|
||
tipText = tipText + "【群转账收入统计】\n"
|
||
tipText = tipText + "\t今日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[dateStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[dateStr].TotalCount))
|
||
tipText = tipText + "\t昨日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[yesterdayStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[yesterdayStr].TotalCount))
|
||
tipText = tipText + "\t前日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[beforeYesterdayStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[beforeYesterdayStr].TotalCount))
|
||
tipText = tipText + "\t本群累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(presonCumulativeAmount)/100), fmt.Sprintf("%d", financialStats.History[dateStr].TotalCount))
|
||
tipText = tipText + "\t全局累计: " + fmt.Sprintf("%s元 / %s次", fmt.Sprintf("%.2f", float64(cumulativeAmount)/100), fmt.Sprintf("%d", financialStats.GlobalTotalCount))
|
||
} else {
|
||
tipText = tipText + "\t金额: " + fmt.Sprintf("%s元\n", fmt.Sprintf("%.2f", float64(amount)/100))
|
||
tipText = tipText + "\t时间: " + fmt.Sprintf("%s\n", timeStr)
|
||
tipText = tipText + "\t发送者: " + fmt.Sprintf("%s\n", sendUser)
|
||
tipText = tipText + "~~~~~~~~~~~~~~~~~~~~~\n"
|
||
tipText = tipText + "【个人转账收入统计】\n"
|
||
tipText = tipText + "\t今日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[dateStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[dateStr].TotalCount))
|
||
tipText = tipText + "\t昨日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[yesterdayStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[yesterdayStr].TotalCount))
|
||
tipText = tipText + "\t前日累计: " + fmt.Sprintf("%s元 / %s次\n", fmt.Sprintf("%.2f", float64(financialStats.History[beforeYesterdayStr].TotalAmount)/100), fmt.Sprintf("%d", financialStats.History[beforeYesterdayStr].TotalCount))
|
||
tipText = tipText + "\t全局累计: " + fmt.Sprintf("%s元 / %s次", fmt.Sprintf("%.2f", float64(cumulativeAmount)/100), fmt.Sprintf("%d", financialStats.GlobalTotalCount))
|
||
}
|
||
_, _ = wxqi.SendTextMsgRequest(wxqi.wxconn.GetWXAccount().GetUserInfo().WxId, tipText, []string{}, 1)
|
||
}
|
||
return
|
||
}
|
||
|
||
// SendOpenWxHBNewRequest 打开红包
|
||
func (wxqi *WXReqInvoker) SendOpenWxHBNewRequest(hbItem *baseinfo.HongBaoItem, timingIdentifier string) (*wechat.HongBaoRes, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendOpenWxHBNewRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendReceiveWxHBRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 构造参数
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
currentProfile := wxqi.wxconn.GetWXAccount().GetUserProfile()
|
||
hongBaoOpenItem := new(baseinfo.HongBaoOpenItem)
|
||
hongBaoOpenItem.CgiCmd = baseinfo.MMHongBaoReqCgiCmdOpenWxhb // 打开红包
|
||
hongBaoOpenItem.Province = currentProfile.GetUserInfo().GetProvince() // 当前帐号设置的省
|
||
hongBaoOpenItem.City = currentProfile.GetUserInfo().GetCity() // 当前帐号设置的市
|
||
hongBaoOpenItem.NativeURL = hbItem.NativeURL // nativeurl
|
||
hongBaoOpenItem.HongBaoURLItem = hbItem.URLItem // 解析URL的各个字段信息
|
||
hongBaoOpenItem.HeadImg = currentProfile.GetUserInfoExt().GetSmallHeadImgUrl() // 当前帐号的小头像URL
|
||
hongBaoOpenItem.TimingIdentifier = timingIdentifier
|
||
hongBaoOpenItem.SceneID = hbItem.SceneID // 红包推送的参数
|
||
hongBaoOpenItem.NickName = currentProfile.GetUserInfo().GetNickName().GetStr() // 当前帐号的昵称
|
||
|
||
var packHeader *baseinfo.PackHeader
|
||
var err error
|
||
openSendStartMs := time.Now().UnixMilli()
|
||
openPath := "openwxhb"
|
||
if hongBaoOpenItem.SceneID == 1005 {
|
||
hongBaoOpenItem.CgiCmd = 5148 // 这里是pb字段的cgicmd 抓包得到
|
||
packHeader, err = clientsdk.SendOpenUninoHB(wxqi.wxconn.GetWXAccount().GetUserInfo(), hongBaoOpenItem)
|
||
openPath = "openunionhb"
|
||
} else {
|
||
packHeader, err = clientsdk.SendOpenWxHB(wxqi.wxconn.GetWXAccount().GetUserInfo(), hongBaoOpenItem)
|
||
}
|
||
openSendEndMs := time.Now().UnixMilli()
|
||
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
//wechat.HongBaoRes{}
|
||
// 解析获取联系人响应
|
||
resp := new(wechat.HongBaoRes)
|
||
openParseStartMs := time.Now().UnixMilli()
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, resp)
|
||
openParseEndMs := time.Now().UnixMilli()
|
||
if err != nil {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
return nil, err
|
||
}
|
||
if hbItem != nil && hbItem.RecvAtMs > 0 {
|
||
fmt.Printf("红包open阶段 send=%dms parse=%dms path=%s cgi=%d scene=%d\n", openSendEndMs-openSendStartMs, openParseEndMs-openParseStartMs, openPath, hongBaoOpenItem.CgiCmd, hongBaoOpenItem.SceneID)
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// SendReceiveWxHBRequest 接收红包
|
||
func (wxqi *WXReqInvoker) SendReceiveWxHBRequest(hbItem *baseinfo.HongBaoItem) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendReceiveWxHBRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendReceiveWxHBRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 开始接收红包
|
||
currentProfile := wxqi.wxconn.GetWXAccount().GetUserProfile()
|
||
hongBaoReceiverItem := new(baseinfo.HongBaoReceiverItem)
|
||
hongBaoReceiverItem.CgiCmd = baseinfo.MMHongBaoReqCgiCmdReceiveWxhb // 接收红包
|
||
hongBaoReceiverItem.Province = currentProfile.GetUserInfo().GetProvince() // 当前帐号设置的省
|
||
hongBaoReceiverItem.City = currentProfile.GetUserInfo().GetCity() // 当前帐号设置的市
|
||
hongBaoReceiverItem.InWay = baseinfo.MMHongBaoReqInAwayGroup // 群红包
|
||
hongBaoReceiverItem.NativeURL = hbItem.NativeURL // nativeurl
|
||
hongBaoReceiverItem.HongBaoURLItem = hbItem.URLItem
|
||
packHeader, err := clientsdk.SendReceiveWxHB(wxqi.wxconn.GetWXAccount().GetUserInfo(), hongBaoReceiverItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
// 发送给微信消息处理器
|
||
return nil
|
||
}
|
||
|
||
// SendOpenWxHBRequest 打开红包
|
||
func (wxqi *WXReqInvoker) SendOpenWxHBRequest(hbItem *baseinfo.HongBaoItem, timingIdentifier string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendOpenWxHBRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendReceiveWxHBRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 构造参数
|
||
currentProfile := wxqi.wxconn.GetWXAccount().GetUserProfile()
|
||
hongBaoOpenItem := new(baseinfo.HongBaoOpenItem)
|
||
hongBaoOpenItem.CgiCmd = baseinfo.MMHongBaoReqCgiCmdOpenWxhb // 打开红包
|
||
hongBaoOpenItem.Province = currentProfile.GetUserInfo().GetProvince() // 当前帐号设置的省
|
||
hongBaoOpenItem.City = currentProfile.GetUserInfo().GetCity() // 当前帐号设置的市
|
||
hongBaoOpenItem.NativeURL = hbItem.NativeURL // nativeurl
|
||
hongBaoOpenItem.HongBaoURLItem = hbItem.URLItem // 解析URL的各个字段信息
|
||
hongBaoOpenItem.HeadImg = currentProfile.GetUserInfoExt().GetSmallHeadImgUrl() // 当前帐号的小头像URL
|
||
hongBaoOpenItem.TimingIdentifier = timingIdentifier // 接收红包返回的
|
||
hongBaoOpenItem.NickName = currentProfile.GetUserInfo().GetNickName().GetStr() // 当前帐号的昵称
|
||
packHeader, err := clientsdk.SendOpenWxHB(wxqi.wxconn.GetWXAccount().GetUserInfo(), hongBaoOpenItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
//wechat.HongBaoRes{}
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendRedEnvelopesDetailRequest 查看红包详情
|
||
func (wxqi *WXReqInvoker) SendRedEnvelopesDetailRequest(hbItem *baseinfo.HongBaoItem) (*wechat.HongBaoRes, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendRedEnvelopesDetailRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendReceiveWxHBRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 构造参数
|
||
currentProfile := wxqi.wxconn.GetWXAccount().GetUserProfile()
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
hongBaoOpenItem := new(baseinfo.HongBaoOpenItem)
|
||
hongBaoOpenItem.CgiCmd = 5181 // 查看红包
|
||
hongBaoOpenItem.Province = currentProfile.GetUserInfo().GetProvince() // 当前帐号设置的省
|
||
hongBaoOpenItem.City = currentProfile.GetUserInfo().GetCity() // 当前帐号设置的市
|
||
hongBaoOpenItem.NativeURL = hbItem.NativeURL // nativeurl
|
||
hongBaoOpenItem.HongBaoURLItem = hbItem.URLItem // 解析URL的各个字段信息
|
||
hongBaoOpenItem.HeadImg = currentProfile.GetUserInfoExt().GetSmallHeadImgUrl() // 当前帐号的小头像URL
|
||
hongBaoOpenItem.NickName = currentProfile.GetUserInfo().GetNickName().GetStr() // 当前帐号的昵称
|
||
packHeader, err := clientsdk.SendRedEnvelopeWxHB(wxqi.wxconn.GetWXAccount().GetUserInfo(), hongBaoOpenItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
resp := new(wechat.HongBaoRes)
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, resp)
|
||
if err != nil {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
return nil, err
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// SendGetRedPacketListRequest 查看红包领取列表
|
||
func (wxqi *WXReqInvoker) SendGetRedPacketListRequest(hbItem *baseinfo.GetRedPacketList) (*wechat.HongBaoRes, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetRedPacketListRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendReceiveWxHBRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetRedPacketListRequest(wxqi.wxconn.GetWXAccount().GetUserInfo(), hbItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
resp := new(wechat.HongBaoRes)
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, resp)
|
||
if err != nil {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
return nil, err
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// SendCreatePreTransferRequest 创建转账
|
||
func (wxqi *WXReqInvoker) SendCreatePreTransferRequest(transferItem *req.CreatePreTransfer) (*baseinfo.PreTransferResp, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCreatePreTransferRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCreatePreTransferRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendCreatePreTransferRequest(wxqi.wxconn.GetWXAccount().GetUserInfo(), transferItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
tenPayResp := new(wechat.TenPayResponse)
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, tenPayResp)
|
||
if err != nil {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
return nil, err
|
||
}
|
||
retResp := &baseinfo.PreTransferResp{}
|
||
retText := tenPayResp.GetRetText().GetBuffer()
|
||
err = json.Unmarshal(retText, retResp)
|
||
return retResp, err
|
||
}
|
||
|
||
// SendConfirmPreTransferRequest 确认转账
|
||
func (wxqi *WXReqInvoker) SendConfirmPreTransferRequest(transferItem *req.ConfirmPreTransfer) (*wechat.TenPayResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendConfirmPreTransferRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendConfirmPreTransferRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendConfirmPreTransferRequest(wxqi.wxconn.GetWXAccount().GetUserInfo(), transferItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
tenPayResp := new(wechat.TenPayResponse)
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, tenPayResp)
|
||
if err != nil {
|
||
// token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
return nil, err
|
||
}
|
||
return tenPayResp, nil
|
||
}
|
||
|
||
// SendTextMsgRequest 发送消息
|
||
func (wxqi *WXReqInvoker) SendTextMsgRequest(toUserName string, content string, atWxIDList []string, ContentType int) (*wechat.NewSendMsgResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendTextMsgRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendReceiveWxHBRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送消息
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendTextMsg(tmpUserInfo, toUserName, content, atWxIDList, ContentType)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.NewSendMsgResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return response, nil
|
||
}
|
||
|
||
// 发送图片
|
||
func (wxqi *WXReqInvoker) SendUploadImageNewRequest(imgData []byte, toUserName string) (*wechat.UploadMsgImgResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendUploadImageNewRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendUploadImageNewRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 发送消息
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendUploadImageNewRequest(tmpUserInfo, imgData, toUserName)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.UploadMsgImgResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// SendTextMsgToFileHelperRequest 发送消息给文件传输助手
|
||
func (wxqi *WXReqInvoker) SendTextMsgToFileHelperRequest(content string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendTextMsgToFileHelperRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
_, error := wxqi.SendTextMsgRequest(baseinfo.FileHelperWXID, content, nil, 1)
|
||
return error
|
||
}
|
||
|
||
// SendCardMsgToFileHelperRequest 发送名片给文件传输助手
|
||
func (wxqi *WXReqInvoker) SendCardMsgToFileHelperRequest(content string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCardMsgToFileHelperRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
_, error := wxqi.SendTextMsgRequest(baseinfo.FileHelperWXID, content, nil, 42)
|
||
return error
|
||
}
|
||
|
||
// SendOplogRequest 发送Oplog请求
|
||
func (wxqi *WXReqInvoker) SendOplogRequest(modifyItems []*baseinfo.ModifyItem) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendOplogRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendOplogRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 发送消息
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendOplogRequest(tmpUserInfo, modifyItems)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// 发送企业oplog
|
||
func (wxqi *WXReqInvoker) SendQWOpLogRequest(cmdId int64, value []byte) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWOpLogRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendQWOpLogRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 发送消息
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWOpLogRequest(tmpUserInfo, cmdId, value)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendGetQRCodeRequest 获取群/个人二维码(封号;限制功能)
|
||
func (wxqi *WXReqInvoker) SendGetQRCodeRequest(userName string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetQRCodeRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendOplogRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送消息
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetQRCodeRequest(tmpUserInfo, userName)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
// 发送给微信消息处理器
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendLogoutRequest 退出登陆
|
||
func (wxqi *WXReqInvoker) SendLogoutRequest() error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendLogoutRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendOplogRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送消息
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendLogOutRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.CheckSessionOut() {
|
||
err = wxqi.SendAutoAuthRequest()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
// 断开链接, 发送token登陆
|
||
return err
|
||
}
|
||
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendFavSyncRequest 同步收藏
|
||
func (wxqi *WXReqInvoker) SendFavSyncRequest() error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendFavSyncRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendOplogRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 同步收藏
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendFavSyncRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
return dealRouter.Handle(wxResp)
|
||
}
|
||
func (wxqi *WXReqInvoker) SendFavSyncRequestResult() (*wechat.FavSyncResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendFavSyncRequestResult error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendOplogRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 同步收藏
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendFavSyncRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
var response wechat.FavSyncResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, wxResp.GetPackHeader(), &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &response, nil
|
||
}
|
||
|
||
// 获取收藏list
|
||
func (wxqi *WXReqInvoker) SendFavSyncListRequestResult(keyBuf string) (*wechat.SyncResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendFavSyncListRequestResult error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendOplogRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
// 同步收藏
|
||
wxqi.SendFavSyncRequest()
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendFavSyncListRequest(tmpUserInfo, keyBuf)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
NewWXResponse(wxqi.wxconn, packHeader)
|
||
var response wechat.FavSyncResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
var List []wechat.AddFavItem
|
||
for _, v := range response.CmdList.ItemList {
|
||
if *v.CmdId == uint32(200) {
|
||
var data wechat.AddFavItem
|
||
_ = proto.Unmarshal(v.CmdBuf.Data, &data)
|
||
List = append(List, data)
|
||
}
|
||
}
|
||
rep := &wechat.SyncResponse{
|
||
Ret: *response.Ret,
|
||
List: List,
|
||
KeyBuf: *response.KeyBuf,
|
||
}
|
||
return rep, nil
|
||
}
|
||
|
||
// SendGetFavInfoRequest 获取收藏信息
|
||
func (wxqi *WXReqInvoker) SendGetFavInfoRequest() error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetFavInfoRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendGetFavInfo err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 同步收藏
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetFavInfoRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
func (wxqi *WXReqInvoker) SendGetFavInfoRequestResult() (*wechat.GetFavInfoResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetFavInfoRequestResult error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetFavInfo err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 同步收藏
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetFavInfoRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
var response wechat.GetFavInfoResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, wxResp.GetPackHeader(), &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// 发送给路由处理
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return &response, nil
|
||
}
|
||
|
||
// SendBatchGetFavItemRequest 获取收藏项详情
|
||
func (wxqi *WXReqInvoker) SendBatchGetFavItemRequest(favID uint32) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendBatchGetFavItemRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendBatchGetFavItemRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 获取单条收藏详情
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendBatchGetFavItemRequest(tmpUserInfo, favID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
func (wxqi *WXReqInvoker) SendBatchGetFavItemRequestResult(favID uint32) (*wechat.BatchGetFavItemResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendBatchGetFavItemRequestResult error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendBatchGetFavItemRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 获取单条收藏详情
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendBatchGetFavItemRequest(tmpUserInfo, favID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
var response wechat.BatchGetFavItemResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, wxResp.GetPackHeader(), &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &response, nil
|
||
}
|
||
|
||
// SendBatchDelFavItemRequest 删除收藏
|
||
func (wxqi *WXReqInvoker) SendBatchDelFavItemRequest(favID uint32) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendBatchDelFavItemRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendBatchDelFavItemRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 删除单条收藏详情
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendBatchDelFavItemRequest(tmpUserInfo, favID)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
func (wxqi *WXReqInvoker) SendBatchDelFavItemRequestResult(favID uint32) (*wechat.BatchDelFavItemResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendBatchDelFavItemRequestResult error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendBatchDelFavItemRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 删除单条收藏详情
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendBatchDelFavItemRequest(tmpUserInfo, favID)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
var response wechat.BatchDelFavItemResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, wxResp.GetPackHeader(), &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &response, nil
|
||
}
|
||
|
||
// SendGetCDNDnsRequest 获取CdnDns信息
|
||
func (wxqi *WXReqInvoker) SendGetCDNDnsRequest() error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetCDNDnsRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendGetCDNDnsRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 获取CdnDns信息
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetCDNDnsRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
dealRouter := wxqi.wxconn.GetWXServer().GetWXMsgHandler().GetRouterByRespID(packHeader.URLID)
|
||
return dealRouter.Handle(wxResp)
|
||
}
|
||
|
||
// 设置朋友圈可见天数
|
||
func (wxqi *WXReqInvoker) SetFriendCircleDays(postItem *req.SetFriendCircleDaysModel) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SetFriendCircleDays error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SetFriendCircleDays err: wxconn.IsConnected() == false")
|
||
}
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SetFriendCircleDaysRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, _ := clientsdk.SendGetProfileRequest(tmpUserInfo)
|
||
userInfo := &wechat.GetProfileResponse{}
|
||
clientsdk.ParseResponseData(tmpUserInfo, packHeader, userInfo)
|
||
userInfo.UserInfoExt.SnsUserInfo.SnsFlagex = proto.Uint32(postItem.Function)
|
||
userInfo.UserInfoExt.SnsUserInfo.SnsPrivacyRecent = proto.Uint32(postItem.Value)
|
||
reqBuf, _ := proto.Marshal(userInfo.UserInfoExt.SnsUserInfo)
|
||
modifyItem := baseinfo.ModifyItem{
|
||
CmdID: 0x33,
|
||
Len: uint32(len(reqBuf)),
|
||
Data: reqBuf,
|
||
}
|
||
return wxqi.SendOplogRequest([]*baseinfo.ModifyItem{&modifyItem})
|
||
}
|
||
|
||
// SendSnsPostRequest 发送朋友圈
|
||
func (wxqi *WXReqInvoker) SendSnsPostRequestNew(postItem *baseinfo.SnsPostItem) (*wechat.SnsPostResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSnsPostRequestNew error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendSnsPostRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送朋友圈
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSnsPostRequest(tmpUserInfo, postItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
/*wxqi.wxconn.SendToWXMsgHandler(wxResp)*/
|
||
var snsPostResp wechat.SnsPostResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, wxResp.GetPackHeader(), &snsPostResp)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &snsPostResp, nil
|
||
}
|
||
|
||
// SendSnsPostRequest 发送朋友圈
|
||
func (wxqi *WXReqInvoker) SendSnsPostRequest(postItem *baseinfo.SnsPostItem) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSnsPostRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendSnsPostRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 发送朋友圈
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSnsPostRequest(tmpUserInfo, postItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendSnsObjectOpRequest 操作朋友圈
|
||
func (wxqi *WXReqInvoker) SendSnsObjectOpRequest(opItems []*baseinfo.SnsObjectOpItem) (*wechat.SnsObjectOpResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSnsObjectOpRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendSnsObjectOpRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 操作朋友圈
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSnsObjectOpRequest(tmpUserInfo, opItems)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.SnsObjectOpResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
return response, err
|
||
}
|
||
|
||
// SendSnsPostRequestByXML 同步转发朋友圈
|
||
func (wxqi *WXReqInvoker) SendSnsPostRequestByXML(timeLineObj *baseinfo.TimelineObject, blackList []string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSnsPostRequestByXML error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendSnsPostRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 转发朋友圈
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSnsPostRequestByXML(tmpUserInfo, timeLineObj, blackList)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendSnsUserPageRequest 获取指定好友朋友圈
|
||
func (wxqi *WXReqInvoker) SendSnsUserPageRequest(userName string, firstPageMd5 string, maxID uint64, needResp bool) (*wechat.SnsUserPageResponseNew, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSnsUserPageRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendSnsUserPageRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 获取指定好友朋友圈
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSnsUserPageRequest(tmpUserInfo, userName, firstPageMd5, maxID)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
err = wxqi.SendAutoAuthRequest()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
packHeader, err = clientsdk.SendSnsUserPageRequest(tmpUserInfo, userName, firstPageMd5, maxID)
|
||
} else {
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
// 是否需要自己解析
|
||
if needResp {
|
||
response := &wechat.SnsUserPageResponseNew{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
return response, err
|
||
}
|
||
// 如果不需要则发给路由去解析
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil, nil
|
||
}
|
||
|
||
// SendSnsObjectDetailRequest 获取指定的朋友圈详情
|
||
func (wxqi *WXReqInvoker) SendSnsObjectDetailRequest(snsID uint64) (*wechat.SnsObject, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSnsObjectDetailRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendSnsObjectDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 获取指定好友朋友圈
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSnsObjectDetailRequest(tmpUserInfo, snsID)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.SnsObjectDetailResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response.GetObject(), nil
|
||
}
|
||
|
||
// SendSnsSyncRequest 同步朋友圈
|
||
func (wxqi *WXReqInvoker) SendSnsSyncRequest(toHandler bool) (*wechat.SnsSyncResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSnsSyncRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendSnsSyncRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 同步朋友圈
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSnsSyncRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
// 解析 同步朋友圈响应包
|
||
snsSyncResp := &wechat.SnsSyncResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, snsSyncResp)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if !toHandler { // 不发送 同步朋友圈 消息到对应的 messageHandler
|
||
return snsSyncResp, nil
|
||
}
|
||
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil, nil
|
||
}
|
||
|
||
// SendSnsTimeLineRequest 获取朋友圈首页
|
||
func (wxqi *WXReqInvoker) SendSnsTimeLineRequest(firstPageMD5 string, maxID uint64) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSnsTimeLineRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendSnsTimeLineRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 取朋友圈首页
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSnsTimeLineRequest(tmpUserInfo, firstPageMD5, maxID)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
func (wxqi *WXReqInvoker) SendSnsTimeLineRequestResult(firstPageMD5 string, maxID uint64) (*wechat.SnsTimeLineResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSnsTimeLineRequestResult error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendSnsTimeLineRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 取朋友圈首页
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSnsTimeLineRequest(tmpUserInfo, firstPageMD5, maxID)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
var response wechat.SnsTimeLineResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, wxResp.GetPackHeader(), &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &response, nil
|
||
}
|
||
|
||
// SendSnsCommentRequest 发送评论/点赞请求
|
||
func (wxqi *WXReqInvoker) SendSnsCommentRequest(commentItem *baseinfo.SnsCommentItem) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSnsCommentRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendSnsCommentRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 点赞/评论
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSnsCommentRequest(tmpUserInfo, commentItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// SendGetContactLabelListRequest 获取联系人标签列表
|
||
func (wxqi *WXReqInvoker) SendGetContactLabelListRequest(needResp bool) (*wechat.GetContactLabelListResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetContactLabelListRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetContactLabelListRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 获取标签列表
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetContactLabelListRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
// 自己解析
|
||
if needResp {
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
var response wechat.GetContactLabelListResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, wxResp.GetPackHeader(), &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &response, nil
|
||
}
|
||
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil, nil
|
||
}
|
||
|
||
// SendAddContactLabelRequest 添加标签
|
||
func (wxqi *WXReqInvoker) SendAddContactLabelRequest(newLabelList []string, needResp bool) (*wechat.AddContactLabelResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendAddContactLabelRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendAddContactLabelRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 添加标签列表
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendAddContactLabelRequest(tmpUserInfo, newLabelList)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
// 自己解析
|
||
if needResp {
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
var response wechat.AddContactLabelResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, wxResp.GetPackHeader(), &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &response, nil
|
||
}
|
||
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil, nil
|
||
}
|
||
|
||
// SendDelContactLabelRequest 删除标签
|
||
func (wxqi *WXReqInvoker) SendDelContactLabelRequest(labelId string) (*wechat.DelContactLabelResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendDelContactLabelRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendAddContactLabelRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 添加标签列表
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendDelContactLabelRequest(tmpUserInfo, labelId)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
var response wechat.DelContactLabelResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, wxResp.GetPackHeader(), &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &response, nil
|
||
|
||
}
|
||
|
||
// SendModifyLabelRequest 修改标签
|
||
func (wxqi *WXReqInvoker) SendModifyLabelRequest(userLabelList []baseinfo.UserLabelInfoItem) (*wechat.ModifyContactLabelListResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendModifyLabelRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendAddContactLabelRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 添加标签列表
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendModifyLabelRequest(tmpUserInfo, userLabelList)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
var response wechat.ModifyContactLabelListResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, wxResp.GetPackHeader(), &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &response, nil
|
||
}
|
||
|
||
// SendBindQueryNewRequest 查询钱包信息
|
||
func (wxqi *WXReqInvoker) SendBindQueryNewRequest(reqItem *baseinfo.TenPayReqItem) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendBindQueryNewRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendBindQueryNewRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
// 添加标签列表
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendBindQueryNewRequest(tmpUserInfo, reqItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
wxResp := NewWXResponse(wxqi.wxconn, packHeader)
|
||
wxqi.wxconn.SendToWXMsgHandler(wxResp)
|
||
return nil
|
||
}
|
||
|
||
// 获取银行卡信息
|
||
func (wxqi *WXReqInvoker) SendBandCardRequest(reqItem *baseinfo.TenPayReqItem) (*wechat.TenPayResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendBandCardRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendBandCardRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendBindQueryNewRequest(tmpUserInfo, reqItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
var response wechat.TenPayResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &response, nil
|
||
}
|
||
|
||
// 支付方法
|
||
func (wxqi *WXReqInvoker) SendTenPayRequest(reqItem *baseinfo.TenPayReqItem) (*wechat.TenPayResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendTenPayRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendTenPayRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendTenPayRequest(tmpUserInfo, reqItem)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
var response wechat.TenPayResponse
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &response, nil
|
||
}
|
||
|
||
// SendCdnDownloadReuqest Cdn下载请求
|
||
func (wxqi *WXReqInvoker) SendCdnDownloadReuqest(downItem *baseinfo.DownMediaItem) (*baseinfo.CdnDownloadResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCdnDownloadReuqest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCdnDownloadReuqest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
return clientsdk.SendCdnDownloadReuqest(tmpUserInfo, downItem)
|
||
}
|
||
|
||
// GetMsgBigImg 获取图片
|
||
func (wxqi *WXReqInvoker) GetMsgBigImg(m req.DownloadParam) (*wechat.GetMsgImgResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("GetMsgBigImg error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetMsgBigImg err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, error := clientsdk.GetMsgBigImg(tmpUserInfo, m)
|
||
if error != nil {
|
||
return nil, error
|
||
}
|
||
var response wechat.GetMsgImgResponse
|
||
err := clientsdk.ParseResponseData(tmpUserInfo, packHeader, &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &response, nil
|
||
}
|
||
|
||
// GetMsgVideo 获取视频数据
|
||
func (wxqi *WXReqInvoker) GetMsgVideo(m req.DownloadParam) (*wechat.DownloadVideoResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("GetMsgVideo error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCdnDownloadReuqest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, error := clientsdk.GetMsgCdnVideo(tmpUserInfo, m)
|
||
if error != nil {
|
||
return nil, error
|
||
}
|
||
var response wechat.DownloadVideoResponse
|
||
err := clientsdk.ParseResponseData(tmpUserInfo, packHeader, &response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &response, nil
|
||
}
|
||
|
||
// SendCdnSnsUploadImageReuqest Cdn上传高清图片
|
||
func (wxqi *WXReqInvoker) SendCdnSnsUploadImageReuqest(imgData []byte) (*baseinfo.CdnSnsImageUploadResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCdnSnsUploadImageReuqest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCdnDownloadReuqest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
if tmpUserInfo.SNSDnsInfo == nil {
|
||
wxqi.SendGetCDNDnsRequest()
|
||
}
|
||
|
||
return clientsdk.SendCdnSnsUploadImageReuqest(tmpUserInfo, imgData)
|
||
}
|
||
|
||
// SendCdnSnsVideoDownloadReuqest 发送CDN朋友圈视频下载请求
|
||
func (wxqi *WXReqInvoker) SendCdnSnsVideoDownloadReuqest(encKey uint64, tmpURL string) ([]byte, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCdnSnsVideoDownloadReuqest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCdnDownloadReuqest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
if tmpUserInfo.SNSDnsInfo == nil {
|
||
wxqi.SendGetCDNDnsRequest()
|
||
}
|
||
|
||
// 发送朋友圈
|
||
return clientsdk.SendCdnSnsVideoDownloadReuqest(tmpUserInfo, encKey, tmpURL)
|
||
}
|
||
|
||
// SendCdnSnsVideoUploadReuqest 发送CDN朋友圈上传视频请求
|
||
func (wxqi *WXReqInvoker) SendCdnSnsVideoUploadReuqest(videoData []byte, thumbData []byte) (*baseinfo.CdnSnsVideoUploadResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCdnSnsVideoUploadReuqest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCdnSnsVideoUploadReuqest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
if tmpUserInfo.DNSInfo == nil {
|
||
_ = wxqi.SendGetCDNDnsRequest()
|
||
}
|
||
return clientsdk.SendCdnSnsVideoUploadReuqest(tmpUserInfo, videoData, thumbData)
|
||
}
|
||
|
||
// SendCdnUploadImageReuqest 发送图片给文件助手
|
||
func (wxqi *WXReqInvoker) SendCdnUploadImageReuqest(imgData []byte, toUserName string) (bool, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCdnUploadImageReuqest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return false, errors.New("SendCdnUploadImageReuqest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
if tmpUserInfo.DNSInfo == nil {
|
||
_ = wxqi.SendGetCDNDnsRequest()
|
||
}
|
||
|
||
_, _, err := clientsdk.SendCdnUploadImageReuqestWithDetails(tmpUserInfo, toUserName, imgData)
|
||
return err == nil, err
|
||
}
|
||
|
||
// 发送图片
|
||
func (wxqi *WXReqInvoker) SendCdnUploadImageRequest(imgData []byte, toUserName string) (bool, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCdnUploadImageRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return false, errors.New("SendCdnUploadImageReuqest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
if tmpUserInfo.DNSInfo == nil {
|
||
_ = wxqi.SendGetCDNDnsRequest()
|
||
}
|
||
|
||
_, _, err := clientsdk.SendCdnUploadImageReuqestWithDetails(tmpUserInfo, toUserName, imgData)
|
||
return err == nil, err
|
||
}
|
||
|
||
func (wxqi *WXReqInvoker) SendCdnUploadVideoRequest(toUserName string, imgData []byte, videoData []byte) (*baseinfo.CdnMsgVideoUploadResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCdnUploadVideoRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCdnUploadVideoRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
if tmpUserInfo.DNSInfo == nil {
|
||
_ = wxqi.SendGetCDNDnsRequest()
|
||
}
|
||
|
||
return clientsdk.SendCdnUploadVideoRequest(tmpUserInfo, toUserName, imgData, videoData)
|
||
}
|
||
|
||
// SendImageToFileHelper 发送图片给文件助手
|
||
func (wxqi *WXReqInvoker) SendImageToFileHelper(imgData []byte) (bool, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendImageToFileHelper error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return false, errors.New("SendImageToFileHelper err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
return wxqi.SendCdnUploadImageReuqest(imgData, baseinfo.FileHelperWXID)
|
||
}
|
||
|
||
// ForwardCdnImageRequest 转发Cdn图片
|
||
func (wxqi *WXReqInvoker) ForwardCdnImageRequest(item baseinfo.ForwardImageItem) (*wechat.UploadMsgImgResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("ForwardCdnImageRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("ForwardCdnImageRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.ForwardCdnImageRequest(tmpUserInfo, item)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.UploadMsgImgResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// ForwardCdnVideoRequest 转发Cdn视频
|
||
func (wxqi *WXReqInvoker) ForwardCdnVideoRequest(item baseinfo.ForwardVideoItem) (*wechat.UploadVideoResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("ForwardCdnVideoRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("ForwardCdnVideoRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.ForwardCdnVideoRequest(tmpUserInfo, item)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.UploadVideoResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendAppMessage 发送app信息
|
||
func (wxqi *WXReqInvoker) SendAppMessage(msgXml, toUSerName string, contentType uint32) (*wechat.SendAppMsgResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendAppMessage error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendEmojiRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
// 提交个状态
|
||
//_, _ = clientsdk.StatusNotify(tmpUserInfo, toUSerName)
|
||
|
||
// 发送app
|
||
packHeader, err := clientsdk.SendAppMsgRequest(tmpUserInfo, contentType, toUSerName, msgXml)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.SendAppMsgResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendEmojiRequest 发送表情
|
||
func (wxqi *WXReqInvoker) SendEmojiRequest(md5 string, toUSerName string, length int32) (*wechat.SendAppMsgResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendEmojiRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 生成xml
|
||
//msgXMl := `<appmsg appid="" sdkver="0"><title></title><des></des><action></action><type>8</type><showtype>0</showtype><soundtype>0</soundtype><mediatagname></mediatagname><messageext></messageext><messageaction></messageaction><content></content><contentattr>0</contentattr><url></url><lowurl></lowurl><dataurl></dataurl><lowdataurl></lowdataurl><songalbumurl></songalbumurl><songlyric></songlyric><appattach><totallen>1060941</totallen><attachid>0:0:ce58baf1002411bdafd299a689cadfe4</attachid><emoticonmd5>ce58baf1002411bdafd299a689cadfe4</emoticonmd5><fileext>pic</fileext><cdnthumbaeskey></cdnthumbaeskey><aeskey></aeskey></appattach><extinfo></extinfo><sourceusername></sourceusername><sourcedisplayname></sourcedisplayname><thumburl></thumburl><md5></md5><statextstr></statextstr><directshare>0</directshare></appmsg><fromusername></fromusername>` //clientsdk.CreateSendEmojiMsgXMl(md5, length)
|
||
msgXMl := clientsdk.CreateSendEmojiMsgXMl(md5, length)
|
||
return wxqi.SendAppMessage(msgXMl, toUSerName, 8)
|
||
}
|
||
|
||
// 发送表情new
|
||
func (wxqi *WXReqInvoker) ForwardEmojiRequest(md5 string, toUSerName string, length int32) (*wechat.UploadEmojiResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("ForwardEmojiRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("ForwardEmojiRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.ForwardEmojiRequest(tmpUserInfo, toUSerName, md5, length)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.UploadEmojiResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 下载语音
|
||
func (wxqi *WXReqInvoker) SendGetMsgVoiceRequest(toUserName, newMsgId, bufid string, length int) (*vo.DownloadVoiceData, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetMsgVoiceRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetMsgVoiceRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
return clientsdk.SendGetMsgVoiceRequest(tmpUserInfo, toUserName, newMsgId, bufid, length)
|
||
}
|
||
|
||
// 群发文字
|
||
func (wxqi *WXReqInvoker) SendGroupMassMsgTextRequest(toUSerName []string, content string) (*wechat.MassSendResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGroupMassMsgTextRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SetChatRoomAnnouncementRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGroupMassMsgText(tmpUserInfo, toUSerName, content)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.MassSendResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 群发图片
|
||
func (wxqi *WXReqInvoker) SendGroupMassMsgImageRequest(toUSerName []string, ImageBase64 []byte) (*wechat.MassSendResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGroupMassMsgImageRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SetChatRoomAnnouncementRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGroupMassMsgImage(tmpUserInfo, toUSerName, ImageBase64)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.MassSendResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 群拍一拍
|
||
func (wxqi *WXReqInvoker) SendSendPatRequest(chatRoomName string, toUserName string, scene int64) (*wechat.SendPatResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSendPatRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendSendPatRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendSendPatRequest(tmpUserInfo, chatRoomName, toUserName, scene)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.SendPatResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// SetChatRoomAnnouncementRequest 设置群公告
|
||
func (wxqi *WXReqInvoker) SetChatRoomAnnouncementRequest(roomId, content string) (*wechat.SetChatRoomAnnouncementResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SetChatRoomAnnouncementRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SetChatRoomAnnouncementRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.SetChatRoomAnnouncementRequest(tmpUserInfo, roomId, content)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.SetChatRoomAnnouncementResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// GetChatroomMemberDetailRequest 获取群成员
|
||
func (wxqi *WXReqInvoker) GetChatroomMemberDetailRequest(roomId string) (*wechat.GetChatroomMemberDetailResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("GetChatroomMemberDetailRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetChatroomMemberDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetChatroomMemberDetailRequest(tmpUserInfo, roomId)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.GetChatroomMemberDetailResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// 获取群详细
|
||
func (wxqi *WXReqInvoker) SetGetChatRoomInfoDetailRequest(roomId string) (*wechat.GetChatRoomInfoDetailRequest, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SetGetChatRoomInfoDetailRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetChatroomMemberDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SetGetChatRoomInfoDetailRequest(tmpUserInfo, roomId)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.GetChatRoomInfoDetailRequest{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// 同意进入群聊
|
||
func (wxqi *WXReqInvoker) ConsentToJoinGroupRequest(url string) (*wechat.JoinChatRoomResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("ConsentToJoinGroupRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("ConsentToJoinGroupRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
opCode := uint32(2)
|
||
scene := uint32(4)
|
||
reqUrl := url
|
||
packHeader, err := clientsdk.GetA8KeyRequest(tmpUserInfo, opCode, scene, reqUrl, baseinfo.GetA8Key)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.GetA8KeyResp{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if response.FullURL == nil {
|
||
return nil, errors.New("GetA8key读取失败")
|
||
}
|
||
FullURL := *response.FullURL
|
||
response1, err := clientsdk.JoinGroupRequest(FullURL)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response1, nil
|
||
}
|
||
|
||
// 添加群管理
|
||
func (wxqi *WXReqInvoker) SendAddChatroomAdminRequest(chatRoomName string, userList []string) (*wechat.AddChatRoomAdminResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendAddChatroomAdminRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetChatroomMemberDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendAddChatroomAdmin(tmpUserInfo, chatRoomName, userList)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.AddChatRoomAdminResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// 删除群管理
|
||
func (wxqi *WXReqInvoker) SendDelChatroomAdminRequest(chatRoomName string, userList []string) (*wechat.DelChatRoomAdminResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendDelChatroomAdminRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendDelChatroomAdminRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.SendDelChatroomAdminRequest(tmpUserInfo, chatRoomName, userList)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.DelChatRoomAdminResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 获取群列表
|
||
func (wxqi *WXReqInvoker) SendWXSyncContactRequest() (*vo.GroupData, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendWXSyncContactRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendWXSyncContactRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
list := make([]wechat.ModContact, 0)
|
||
v := int64(0)
|
||
_ = initGroup(wxqi, tmpUserInfo, []byte(""), &list, v)
|
||
return &vo.GroupData{
|
||
Count: int64(len(list)),
|
||
List: list,
|
||
}, nil
|
||
}
|
||
|
||
func initGroup(wxqi *WXReqInvoker, tmpUserInfo *baseinfo.UserInfo, key []byte, list *[]wechat.ModContact, v int64) error {
|
||
packHeader, err := clientsdk.SendWXSyncContactRequest(tmpUserInfo, key)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
response := &wechat.NewSyncResponse{}
|
||
// 解析token登陆响应 -cmdList.list
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
i := len(*list)
|
||
wxId := tmpUserInfo.WxId
|
||
for _, item := range response.CmdList.ItemList {
|
||
fmt.Println(item.GetCmdId())
|
||
fmt.Println(string(item.GetCmdBuf().GetData()))
|
||
if item.GetCmdId() == baseinfo.CmdIDModContact || item.GetCmdId() == baseinfo.CmdIDAddMsg {
|
||
contact := new(wechat.ModContact)
|
||
err := proto.Unmarshal(item.GetCmdBuf().GetData(), contact)
|
||
if err != nil {
|
||
continue
|
||
}
|
||
// 判断contact是否是群 == 0 不是群
|
||
if contact.GetChatroomVersion() == 0 {
|
||
continue
|
||
}
|
||
//被移除群聊
|
||
if contact.GetChatRoomNotify() == 0 {
|
||
fmt.Println("消息免打扰群, 群wxid = ", contact.GetUserName().GetStr(), " 群昵称：", contact.GetNickName().GetStr())
|
||
} else {
|
||
fmt.Println("微信群, 群wxid = ", contact.GetUserName().GetStr(), " 群昵称：", contact.GetNickName().GetStr())
|
||
}
|
||
userName := contact.GetUserName().GetStr()
|
||
if strings.HasSuffix(userName, "@chatroom") {
|
||
add := false
|
||
if contact.NewChatroomData.GetMemberCount() > 0 {
|
||
for _, v := range contact.NewChatroomData.ChatroomMemberList {
|
||
if wxId == v.GetUserName() {
|
||
add = true
|
||
}
|
||
}
|
||
}
|
||
if add {
|
||
*list = append(*list, *contact)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
v++
|
||
if len(*list) > i || (len(*list) == 0 && v <= 1) {
|
||
key = response.KeyBuf.Buffer
|
||
tmpUserInfo.SyncKey = key
|
||
_ = initGroup(wxqi, tmpUserInfo, key, list, v)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// SendCreateChatRoomRequest 创建群请求
|
||
func (wxqi *WXReqInvoker) SendCreateChatRoomRequest(topIc string, userList []string) (*wechat.CreateChatRoomResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCreateChatRoomRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetChatroomMemberDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetCreateChatRoomEntity(tmpUserInfo, topIc, userList)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.CreateChatRoomResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendDelDelChatRoomMemberRequest 删除群成员
|
||
func (wxqi *WXReqInvoker) SendDelDelChatRoomMemberRequest(chatRoomName string, delUserList []string) (*wechat.DelChatRoomMemberResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendDelDelChatRoomMemberRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetChatroomMemberDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.DelDelChatRoomMemberRequest(tmpUserInfo, chatRoomName, delUserList)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.DelChatRoomMemberResponse{}
|
||
// 解析响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendTransferGroupOwnerRequest 转让群
|
||
func (wxqi *WXReqInvoker) SendTransferGroupOwnerRequest(chatRoomName, newOwnerUserName string) (*wechat.TransferChatRoomOwnerResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendTransferGroupOwnerRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetChatroomMemberDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetTransferGroupOwnerRequest(tmpUserInfo, chatRoomName, newOwnerUserName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.TransferChatRoomOwnerResponse{}
|
||
// 解析响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// GetQuitChatroomRequest 退出群聊请求
|
||
func (wxqi *WXReqInvoker) GetQuitChatroomRequest(chatRoomName string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("GetQuitChatroomRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("GetChatroomMemberDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
qutiChatRoomItem := clientsdk.CreateQutiChatRoomItem(chatRoomName, tmpUserInfo.GetUserName())
|
||
return wxqi.SendOplogRequest([]*baseinfo.ModifyItem{qutiChatRoomItem})
|
||
}
|
||
|
||
// GetInviteChatroomMembersRequest 邀请群成员
|
||
func (wxqi *WXReqInvoker) SendInviteChatroomMembersRequest(chatRoomName string, userList []string) (*wechat.CreateChatRoomResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendInviteChatroomMembersRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetChatroomMemberDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetInviteChatroomMembersRequest(tmpUserInfo, chatRoomName, userList)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.CreateChatRoomResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendAddChatRoomMemberRequest 发送拉人请求
|
||
func (wxqi *WXReqInvoker) SendAddChatRoomMemberRequest(chatRoomName string, userList []string) (*wechat.AddChatRoomMemberResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendAddChatRoomMemberRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetChatroomMemberDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetAddChatRoomMemberRequest(tmpUserInfo, chatRoomName, userList)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.AddChatRoomMemberResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// GetA8KeyRequest 授权链接
|
||
func (wxqi *WXReqInvoker) GetA8KeyRequest(opCode, scene uint32, reqUrl string, getType baseinfo.GetA8KeyType) (*wechat.GetA8KeyResp, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("GetA8KeyRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetA8KeyRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetA8KeyRequest(tmpUserInfo, opCode, scene, reqUrl, getType)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.GetA8KeyResp{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// JSLoginRequest 小程序授权
|
||
func (wxqi *WXReqInvoker) JSLoginRequest(appId string) (*wechat.JSLoginResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("JSLoginRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("JSLoginRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.JSLoginRequest(tmpUserInfo, appId)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.JSLoginResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// JSOperateWxDataRequest 小程序云函数操作
|
||
func (wxqi *WXReqInvoker) JSOperateWxDataRequest(appId string, opt int32, data string) (*wechat.JSOperateWxDataResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("JSOperateWxDataRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("JSOperateWxDataRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.JSOperateWxDataRequest(tmpUserInfo, appId, opt, data)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.JSOperateWxDataResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SdkOauthAuthorizeRequest 授权 App应用
|
||
func (wxqi *WXReqInvoker) SdkOauthAuthorizeRequest(appId string, sdkName string, packageName string) (*wechat.SdkOauthAuthorizeConfirmNewResp, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SdkOauthAuthorizeRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SdkOauthAuthorizeRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetSdkOauthAuthorizeConfirmRequest(tmpUserInfo, appId, sdkName, packageName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.SdkOauthAuthorizeConfirmNewResp{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendSearchContactRequest 搜索联系人
|
||
func (wxqi *WXReqInvoker) SendSearchContactRequest(opCode, fromScene, searchScene uint32, userName string) (*wechat.SearchContactResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendSearchContactRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendSearchContactRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.SendSearchContactRequest(tmpUserInfo, opCode, fromScene, searchScene, userName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.SearchContactResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// VerifyUserRequest 添加好友 关注公众号 同意好友添加
|
||
func (wxqi *WXReqInvoker) VerifyUserRequest(opCode uint32, verifyContent string, scene int, V3, V4, ChatRoomUserName string) (*wechat.VerifyUserResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("VerifyUserRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("VerifyUserRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.VerifyUserRequest(tmpUserInfo, opCode, verifyContent, scene, V3, V4, ChatRoomUserName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.VerifyUserResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// UploadMContact 上传手机通讯录
|
||
func (wxqi *WXReqInvoker) UploadMContact(mobile string, mobileList []string, opcode int32) (*wechat.UploadMContactResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("UploadMContact error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("UploadMContact err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.UploadMContactRequest(tmpUserInfo, mobile, mobileList, opcode)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.UploadMContactResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// GetMFriend 获取手机通讯录好友
|
||
func (wxqi *WXReqInvoker) GetMFriend() (*wechat.GetMFriendResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("GetMFriend error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetMFriend err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetMFriendRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.GetMFriendResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
func (wxqi *WXReqInvoker) SendCertRequest() (*wechat.GetCertResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCertRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCertRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetCertRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.GetCertResponse{}
|
||
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendQRConnectAuthorize 发送二维码授权请求
|
||
func (wxqi *WXReqInvoker) SendQRConnectAuthorize(qrUrl string) (*wechat.QRConnectAuthorizeResp, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQRConnectAuthorize error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQRConnectAuthorize err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetQRConnectAuthorizeRequest(tmpUserInfo, qrUrl)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.QRConnectAuthorizeResp{}
|
||
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendQRConnectAuthorize 发送二维码授权请求确认
|
||
func (wxqi *WXReqInvoker) SendQRConnectAuthorizeConfirm(qrUrl string) (*wechat.SdkOauthAuthorizeConfirmNewResp, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQRConnectAuthorizeConfirm error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQRConnectAuthorizeConfirm err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetQRConnectAuthorizeConfirmRequest(tmpUserInfo, qrUrl)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.SdkOauthAuthorizeConfirmNewResp{}
|
||
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// 授权链接
|
||
func (wxqi *WXReqInvoker) SendGetMpA8Request(url string, opcode uint32) (*wechat.GetA8KeyResp, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetMpA8Request error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetMpA8Request err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetMpA8Request(tmpUserInfo, url, opcode)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.GetA8KeyResp{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// SendOnlineInfoRequest 获取登录设备信息
|
||
func (wxqi *WXReqInvoker) SendOnlineInfo() (*wechat.GetOnlineInfoResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendOnlineInfo error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCertRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetOnlineInfoRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.GetOnlineInfoResponse{}
|
||
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendGetQrCodeRequest 发送获取(群聊/个人)二维码请求
|
||
func (wxqi *WXReqInvoker) SendGetQrCodeRequest(id string, style uint32) (*wechat.GetQRCodeResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetQrCodeRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCertRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.GetQrCodeRequest(tmpUserInfo, id, style)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.GetQRCodeResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendGetPeopleNearbyResult 查看附近的人
|
||
func (wxqi *WXReqInvoker) SendGetPeopleNearbyResultRequest(longitude float32, latitude float32) (*wechat.LbsResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetPeopleNearbyResultRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetPeopleNearbyResult err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetPeopleNearbyResultRequest(tmpUserInfo, longitude, latitude)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.LbsResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// SendRevokeMsgRequest 撤销消息
|
||
func (wxqi *WXReqInvoker) SendRevokeMsgRequest(newMsgId string, clientMsgId uint64, toUserName string) (*wechat.RevokeMsgResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendRevokeMsgRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCertRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetRevokeMsgRequest(tmpUserInfo, newMsgId, clientMsgId, toUserName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.RevokeMsgResponse{}
|
||
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendRevokeMsgRequestNew 撤回消息New
|
||
func (wxqi *WXReqInvoker) SendRevokeMsgRequestNew(m req.RevokeMsgModel) (*wechat.RevokeMsgResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendRevokeMsgRequestNew error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendRevokeMsgRequestNew err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.RevokeMsgRequestNew(tmpUserInfo, m)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.RevokeMsgResponse{}
|
||
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendDelContactRequest 删除好友
|
||
func (wxqi *WXReqInvoker) SendDelContactRequest(userName string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendDelContactRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
resp, err := wxqi.SendGetContactRequest([]string{userName}, []string{}, []string{}, true)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if resp.GetBaseResponse().GetRet() != 0 || len(resp.GetContactList()) <= 0 {
|
||
return errors.New("获取用户详细失败！")
|
||
}
|
||
|
||
modifyItem := clientsdk.CreateDeleteFriendField(resp.GetContactList()[0])
|
||
return wxqi.SendOplogRequest([]*baseinfo.ModifyItem{modifyItem})
|
||
}
|
||
|
||
// SendModifyUserInfoRequest 修改用户资料
|
||
func (wxqi *WXReqInvoker) SendModifyUserInfoRequest(city, country, nickName, province, signature string, sex uint32, initFlag uint32) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendModifyUserInfoRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
modUserInfo := wxqi.wxconn.GetWXAccount().GetUserProfile().GetUserInfo()
|
||
if modUserInfo == nil {
|
||
modUserInfo = &wechat.ModUserInfo{}
|
||
} else {
|
||
initFlag = modUserInfo.GetBitFlag()
|
||
}
|
||
if nickName != "" {
|
||
modUserInfo.NickName = &wechat.SKBuiltinString{
|
||
Str: proto.String(nickName),
|
||
}
|
||
}
|
||
if city != "" {
|
||
modUserInfo.City = proto.String(city)
|
||
}
|
||
if province != "" {
|
||
modUserInfo.Province = proto.String(province)
|
||
}
|
||
if signature != "" {
|
||
modUserInfo.Signature = proto.String(signature)
|
||
}
|
||
modUserInfo.Sex = proto.Uint32(sex)
|
||
modifyItem := clientsdk.CreateModifyUserInfoField(modUserInfo, initFlag, nickName)
|
||
return wxqi.SendOplogRequest([]*baseinfo.ModifyItem{modifyItem})
|
||
}
|
||
|
||
// 修改昵称
|
||
func (wxqi *WXReqInvoker) SendUpdateNickNameRequest(cmd uint32, val string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendUpdateNickNameRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
newData := &wechat.ModInfo{
|
||
Cmd: proto.Uint32(cmd),
|
||
Value: proto.String(val),
|
||
}
|
||
data, marshalErr := proto.Marshal(newData)
|
||
if marshalErr != nil {
|
||
log.Info("proto.Marshal wechat.ModUserInfo failed: ", marshalErr)
|
||
return marshalErr
|
||
}
|
||
return wxqi.SendOplogRequest([]*baseinfo.ModifyItem{{
|
||
CmdID: uint32(64),
|
||
Len: uint32(len(data)),
|
||
Data: data,
|
||
}})
|
||
}
|
||
|
||
// 修改姓名
|
||
func (wxqi *WXReqInvoker) SetNickNameService(cmd uint32, val string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SetNickNameService error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
newData := &wechat.ModInfo{
|
||
Cmd: proto.Uint32(cmd),
|
||
Value: proto.String(val),
|
||
}
|
||
data, marshalErr := proto.Marshal(newData)
|
||
if marshalErr != nil {
|
||
log.Info("proto.Marshal wechat.ModUserInfo failed: ", marshalErr)
|
||
return marshalErr
|
||
}
|
||
return wxqi.SendOplogRequest([]*baseinfo.ModifyItem{{
|
||
CmdID: uint32(64),
|
||
Len: uint32(len(data)),
|
||
Data: data,
|
||
}})
|
||
}
|
||
|
||
// 修改性别
|
||
func (wxqi *WXReqInvoker) SetSexService(val uint32, country string, city string, province string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SetSexService error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
rsp, _ := wxqi.SendGetProfileNewRequest()
|
||
modUserInfo := rsp.UserInfo
|
||
req := wechat.ModUserInfo{
|
||
BitFlag: proto.Uint32(2178),
|
||
Sex: modUserInfo.Sex,
|
||
UserName: &wechat.SKBuiltinString{
|
||
Str: proto.String(modUserInfo.GetUserName().GetStr()),
|
||
},
|
||
NickName: &wechat.SKBuiltinString{
|
||
Str: proto.String(modUserInfo.NickName.GetStr()),
|
||
},
|
||
BindUin: proto.Uint32(modUserInfo.GetBindUin()),
|
||
BindEmail: modUserInfo.BindEmail,
|
||
BindMobile: modUserInfo.BindMobile,
|
||
Status: modUserInfo.Status,
|
||
ImgLen: modUserInfo.ImgLen,
|
||
Province: modUserInfo.Province,
|
||
City: modUserInfo.City,
|
||
Signature: modUserInfo.Signature,
|
||
PluginFlag: modUserInfo.PluginFlag,
|
||
Country: modUserInfo.Country,
|
||
}
|
||
if modUserInfo.GetSex() != val {
|
||
req.Sex = proto.Uint32(val)
|
||
}
|
||
if country != "" || city != "" || province != "" {
|
||
req.Country = proto.String(country)
|
||
req.City = proto.String(city)
|
||
req.Province = proto.String(province)
|
||
}
|
||
data, marshalErr := proto.Marshal(&req)
|
||
if marshalErr != nil {
|
||
log.Info("proto.Marshal wechat.SetSexService failed: ", marshalErr)
|
||
return marshalErr
|
||
}
|
||
return wxqi.SendOplogRequest([]*baseinfo.ModifyItem{{
|
||
CmdID: uint32(1),
|
||
Len: uint32(len(data)),
|
||
Data: data,
|
||
}})
|
||
}
|
||
|
||
// 修改头像
|
||
func (wxqi *WXReqInvoker) UploadHeadImage(base64 string) (*wechat.UploadHDHeadImgResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("UploadHeadImage error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendCertRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.UploadHeadImage(tmpUserInfo, base64)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.UploadHDHeadImgResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 修改加好友需要验证属性
|
||
func (wxqi *WXReqInvoker) UpdateAutopassRequest(SwitchType uint32) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("UpdateAutopassRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("verifyPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
modifyItem := clientsdk.CreateBlackSnsItem(tmpUserInfo.GetUserName(), SwitchType)
|
||
return wxqi.SendOplogRequest([]*baseinfo.ModifyItem{modifyItem})
|
||
}
|
||
|
||
func (wxqi *WXReqInvoker) verifyPwdRequest(oldPwd string) (*wechat.VerifyPwdResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("verifyPwdRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("verifyPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.GetVerifyPwdRequest(tmpUserInfo, oldPwd)
|
||
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.VerifyPwdResponse{}
|
||
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// 转 json 打印 response
|
||
responseJson, _ := json.Marshal(response)
|
||
fmt.Println("verifyPwdRequest response: ", string(responseJson))
|
||
|
||
return response, nil
|
||
}
|
||
|
||
func (wxqi *WXReqInvoker) setPwdRequest(ticket, newPwd string, OpCode uint32) (*wechat.SetPwdResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("setPwdRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("setPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.SendSetPwdRequest(tmpUserInfo, ticket, newPwd, OpCode)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.SetPwdResponse{}
|
||
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// SendChangePwdRequest 更改密码
|
||
func (wxqi *WXReqInvoker) SendChangePwdRequest(oldPwd, NewPwd string, OpCode uint32) (*wechat.BaseResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendChangePwdRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
log.Println("SendChangePwdRequest", oldPwd)
|
||
verifyPwdResp, err := wxqi.verifyPwdRequest(oldPwd)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if verifyPwdResp.GetBaseResponse().GetRet() != 0 {
|
||
return verifyPwdResp.GetBaseResponse(), nil
|
||
}
|
||
log.Info("旧密码校验成功！")
|
||
resp, err := wxqi.setPwdRequest(verifyPwdResp.GetTicket(), NewPwd, OpCode)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return resp.GetBaseResponse(), nil
|
||
}
|
||
|
||
// SendModifyRemarkRequest 修改备注
|
||
func (wxqi *WXReqInvoker) SendModifyRemarkRequest(userName string, remarkName string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendModifyRemarkRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
resp, err := wxqi.SendGetContactRequest([]string{userName}, []string{}, []string{}, true)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if resp.GetBaseResponse().GetRet() != 0 || len(resp.GetContactList()) <= 0 {
|
||
return errors.New("获取用户详细失败！")
|
||
}
|
||
modContact := resp.GetContactList()[0]
|
||
modContact.GetRemark().Str = proto.String(remarkName)
|
||
modifyItem := clientsdk.CreateModifyFriendField(modContact)
|
||
return wxqi.SendOplogRequest([]*baseinfo.ModifyItem{modifyItem})
|
||
}
|
||
|
||
// SendUploadVoiceRequest 发送语音消息
|
||
/*func (wxqi *WXReqInvoker) SendUploadVoiceRequest(toUserName string, voiceData []byte, voiceSecond, voiceFormat uint32) (*wechat.UploadVoiceResponse, error) {
|
||
de defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()fer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("Recovered from panic: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("verifyPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
// 计算语音长度
|
||
if voiceSecond <= 0 {
|
||
voiceSecond = (uint32)(float32(len(voiceData)) / 1.8 / 1024)
|
||
if voiceSecond >= 60 {
|
||
voiceSecond = 59
|
||
}
|
||
}
|
||
var startPos = uint32(0)
|
||
//mmtls结构限制，块长度ushort最大长度65535
|
||
var dataLenth = uint32(65000)
|
||
var totalLen = uint32(len(voiceData))
|
||
var clientMsgId = fmt.Sprintf("%v", time.Now().Unix())
|
||
response := &wechat.UploadVoiceResponse{}
|
||
|
||
for startPos != totalLen {
|
||
count := uint32(0)
|
||
if totalLen-startPos > dataLenth {
|
||
count = dataLenth
|
||
} else {
|
||
count = totalLen - startPos
|
||
}
|
||
updateData := voiceData[startPos : startPos+count]
|
||
packHeader, err := clientsdk.SendUploadVoiceRequest(
|
||
tmpUserInfo, toUserName, updateData, totalLen, startPos, clientMsgId, voiceSecond*1000, voiceFormat)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
startPos += count
|
||
}
|
||
return response, nil
|
||
}*/
|
||
func (wxqi *WXReqInvoker) SendUploadVoiceRequest(toUserName string, voiceData string, voiceSecond, voiceFormat int32) (*wechat.UploadVoiceResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendUploadVoiceRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("verifyPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
VoiceData := strings.Split(voiceData, ",")
|
||
var VoiceBase64 []byte
|
||
if len(VoiceData) > 1 {
|
||
VoiceBase64, _ = base64.StdEncoding.DecodeString(VoiceData[1])
|
||
} else {
|
||
VoiceBase64, _ = base64.StdEncoding.DecodeString(voiceData)
|
||
}
|
||
VoiceStream := bytes.NewBuffer(VoiceBase64)
|
||
Startpos := 0
|
||
datalen := 65000
|
||
datatotalength := VoiceStream.Len()
|
||
ClientImgId := fmt.Sprintf("%s—%v", tmpUserInfo.WxId, time.Now().UnixNano())
|
||
// 计算语音长度
|
||
if voiceSecond <= 0 {
|
||
voiceSecond = (int32)(float32(len(voiceData)) / 1.8 / 1024)
|
||
if voiceSecond >= 60 {
|
||
voiceSecond = 59
|
||
}
|
||
}
|
||
for {
|
||
count := 0
|
||
if datatotalength-Startpos > datalen {
|
||
count = datalen
|
||
} else {
|
||
count = datatotalength - Startpos
|
||
}
|
||
if count < 0 {
|
||
break
|
||
}
|
||
|
||
endFlag := 0
|
||
if Startpos+count >= datatotalength {
|
||
endFlag = 1
|
||
}
|
||
Databuff := make([]byte, count)
|
||
_, _ = VoiceStream.Read(Databuff)
|
||
packHeader, err := clientsdk.SendUploadVoiceNewRequest(
|
||
tmpUserInfo, toUserName, Startpos, Databuff, ClientImgId, voiceSecond, voiceFormat, endFlag)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.UploadVoiceResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if response.GetEndFlag() == 1 {
|
||
return response, nil
|
||
}
|
||
Startpos += count
|
||
}
|
||
return nil, nil
|
||
|
||
/*response := &wechat.UploadVoiceResponse{}
|
||
|
||
for startPos != totalLen {
|
||
count := uint32(0)
|
||
if totalLen-startPos > dataLenth {
|
||
count = dataLenth
|
||
} else {
|
||
count = totalLen - startPos
|
||
}
|
||
updateData := voiceData[startPos : startPos+count]
|
||
packHeader, err := clientsdk.SendUploadVoiceRequest(
|
||
tmpUserInfo, toUserName, updateData, totalLen, startPos, clientMsgId, voiceSecond*1000, voiceFormat)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
startPos += count
|
||
}
|
||
return response, nil*/
|
||
}
|
||
|
||
// 设置微信号
|
||
func (wxqi *WXReqInvoker) SetWechatRequest(alisa string) (*wechat.GeneralSetResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SetWechatRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("setPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SetWechatRequest(tmpUserInfo, alisa)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.GeneralSetResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 设置微信步数
|
||
func (wxqi *WXReqInvoker) UpdateStepNumberRequest(number uint64) (*wechat.UploadDeviceStepResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("UpdateStepNumberRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("setPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.GetBoundHardDeviceRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.GetBoundHardDevicesResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
device := response.GetDeviceList()[0]
|
||
//上传步数
|
||
packHeaderUpd, errUpd := clientsdk.UploadStepSetRequestRequest(tmpUserInfo, device.HardDevice.GetDeviceId(), device.HardDevice.GetDeviceType(), number)
|
||
if errUpd != nil {
|
||
if packHeaderUpd != nil &&
|
||
packHeaderUpd.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, errUpd
|
||
}
|
||
responseUpdate := &wechat.UploadDeviceStepResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeaderUpd, responseUpdate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return responseUpdate, nil
|
||
}
|
||
|
||
// 获取步数列表
|
||
func (wxqi *WXReqInvoker) SendGetUserRankLikeCountRequest(rankId string) (*wechat.GetUserRankLikeCountResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetUserRankLikeCountRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendGetUserRankLikeCountRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetUserRankLikeCountRequest(tmpUserInfo, rankId)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.GetUserRankLikeCountResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 搜手机或企业对外名片链接提取验证
|
||
func (wxqi *WXReqInvoker) SendQWSearchContactRequest(tg string, fromScene uint64, userName string) (*wechat.SearchQYContactResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWSearchContactRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("GetChatroomMemberDetailRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.SendQWSearchContactRequest(tmpUserInfo, tg, fromScene, userName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
response := &wechat.SearchQYContactResponse{}
|
||
// 解析token登陆响应
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 提取企业 wx 详情
|
||
func (wxqi *WXReqInvoker) SendQWContactRequest(openIm, chatRoom, t string) (*wechat.GetQYContactResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWContactRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("setPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWContactRequest(tmpUserInfo, openIm, chatRoom, t)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.GetQYContactResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 提取全部的企业通寻录
|
||
func (wxqi *WXReqInvoker) SendQWSyncContactRequest() (*wechat.GetQYContactResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWSyncContactRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("setPwdRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWSyncContactRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.QYSyncRespone{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
list := make([]*wechat.ContactInfo, 0)
|
||
for _, val := range response.List.List {
|
||
if val.GetCmdid().String() == wechat.SyncCmdID_OpenimContact.String() {
|
||
rps := &wechat.ContactInfo{}
|
||
_ = proto.Unmarshal(val.Cmdg.Data, rps)
|
||
list = append(list, rps)
|
||
}
|
||
}
|
||
rsp := &wechat.GetQYContactResponse{
|
||
Continue: response.Continue,
|
||
ContactList: list,
|
||
}
|
||
|
||
return rsp, nil
|
||
}
|
||
|
||
func (wxqi *WXReqInvoker) SendQWRemarkRequest(toUserName string, name string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWRemarkRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendQWRemarkRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
|
||
packHeader, err := clientsdk.SendQWSyncContactRequest(tmpUserInfo)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
response := &wechat.GetQYContactResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 创建企业群
|
||
func (wxqi *WXReqInvoker) SendQWCreateChatRoomRequest(userList []string) (*wechat.CreateQYChatRoomResponese, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWCreateChatRoomRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWRemarkRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWCreateChatRoomRequest(tmpUserInfo, userList)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.CreateQYChatRoomResponese{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 向企业微信打招呼
|
||
func (wxqi *WXReqInvoker) SendQWApplyAddContactRequest(toUserName, v1, Content string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWApplyAddContactRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendQWApplyAddContactRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWApplyAddContactRequest(tmpUserInfo, toUserName, v1, Content)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 单向加企业微信
|
||
func (wxqi *WXReqInvoker) SendQWAddContactRequest(toUserName, v1, Content string) error {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWAddContactRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return errors.New("SendQWApplyAddContactRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWAddContactRequest(tmpUserInfo, toUserName, v1, Content)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 提取所有微信企业群
|
||
func (wxqi *WXReqInvoker) SendQWSyncChatRoomRequest(key string) (*vo.QYChatroomContactVo, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWSyncChatRoomRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWSyncChatRoomRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWSyncChatRoomRequest(tmpUserInfo, key)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.QYSyncRespone{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
list := make([]*wechat.QYChatroomContactInfo, 0)
|
||
|
||
for _, val := range response.List.List {
|
||
if val.GetCmdid() == 0x193 {
|
||
rps := &wechat.QYChatroomContactInfo{}
|
||
_ = proto.Unmarshal(val.Cmdg.Data, rps)
|
||
list = append(list, rps)
|
||
}
|
||
}
|
||
rsp := &vo.QYChatroomContactVo{
|
||
Key: string(response.Key),
|
||
List: list,
|
||
}
|
||
return rsp, nil
|
||
}
|
||
|
||
// 转让企业微信群
|
||
func (wxqi *WXReqInvoker) SendQWChatRoomTransferOwnerRequest(chatRoomName string, toUserName string) (*wechat.BaseResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWChatRoomTransferOwnerRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWChatRoomTransferOwnerRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWChatRoomTransferOwnerRequest(tmpUserInfo, chatRoomName, toUserName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.BaseResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 直接拉好友进群
|
||
func (wxqi *WXReqInvoker) SendQWAddChatRoomMemberRequest(chatRoomName string, toUserName []string) (*wechat.QYAddChatRoomMemberResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWAddChatRoomMemberRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWAddChatRoomMemberRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWAddChatRoomMemberRequest(tmpUserInfo, chatRoomName, toUserName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.QYAddChatRoomMemberResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
func (wxqi *WXReqInvoker) SendQWInviteChatRoomMemberRequest(chatRoomName string, toUserName []string) (*wechat.BaseResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWInviteChatRoomMemberRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWInviteChatRoomMemberRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWInviteChatRoomMemberRequest(tmpUserInfo, chatRoomName, toUserName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.BaseResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 删除企业群群成员
|
||
func (wxqi *WXReqInvoker) SendQWDelChatRoomMemberRequest(chatRoomName string, toUserName []string) (*wechat.QYDelChatRoomMemberResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWDelChatRoomMemberRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWInviteChatRoomMemberRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWDelChatRoomMemberRequest(tmpUserInfo, chatRoomName, toUserName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.QYDelChatRoomMemberResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 提取企业群全部成员
|
||
func (wxqi *WXReqInvoker) SendQWGetChatRoomMemberRequest(chatRoomName string) (*wechat.GetQYChatroomMemberDetailResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWGetChatRoomMemberRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWGetChatRoomMemberRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWGetChatRoomMemberRequest(tmpUserInfo, chatRoomName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.GetQYChatroomMemberDetailResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 提取企业群名称公告设定等信息
|
||
func (wxqi *WXReqInvoker) SendQWGetChatroomInfoRequest(chatRoomName string) (*wechat.QYChatroomContactResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWGetChatroomInfoRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWGetChatRoomMemberRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWGetChatroomInfoRequest(tmpUserInfo, chatRoomName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.QYChatroomContactResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 提取企业群二维码
|
||
func (wxqi *WXReqInvoker) SendQWGetChatRoomQRRequest(chatRoomName string) (*wechat.QYGetQRCodeResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWGetChatRoomQRRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWGetChatRoomMemberRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWGetChatRoomQRRequest(tmpUserInfo, chatRoomName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.QYGetQRCodeResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 增加企业管理员
|
||
func (wxqi *WXReqInvoker) SendQWAppointChatRoomAdminRequest(chatRoomName string, toUserName []string) (*wechat.TransferChatRoomOwnerResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWAppointChatRoomAdminRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWAppointChatRoomAdminRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWAppointChatRoomAdminRequest(tmpUserInfo, chatRoomName, toUserName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.TransferChatRoomOwnerResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 移除企业群管理员
|
||
func (wxqi *WXReqInvoker) SendQWDelChatRoomAdminRequest(chatRoomName string, toUserName []string) (*wechat.TransferChatRoomOwnerResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWDelChatRoomAdminRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWDelChatRoomAdminRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWDelChatRoomAdminRequest(tmpUserInfo, chatRoomName, toUserName)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.TransferChatRoomOwnerResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 同意进企业群
|
||
func (wxqi *WXReqInvoker) SendQWAcceptChatRoomRequest(link string, opcode uint32) (*wechat.GetA8KeyResp, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWAcceptChatRoomRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWAcceptChatRoomRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWAcceptChatRoomRequest(tmpUserInfo, link, opcode)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.GetA8KeyResp{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 设定企业群管理审核进群
|
||
func (wxqi *WXReqInvoker) SendQWAdminAcceptJoinChatRoomSetRequest(chatRoomName string, p int64) (*wechat.TransferChatRoomOwnerResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWAdminAcceptJoinChatRoomSetRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWAdminAcceptJoinChatRoomSetRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
req := &wechat.QYAdminAcceptJoinChatRoomSet{
|
||
G: proto.String(chatRoomName),
|
||
P: proto.Int64(p),
|
||
}
|
||
buffer, err := proto.Marshal(req)
|
||
packHeader, err := clientsdk.SendQWOpLogRequest(tmpUserInfo, 0x10, buffer)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.TransferChatRoomOwnerResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 群管理批准进企业群
|
||
func (wxqi *WXReqInvoker) SendQWAdminAcceptJoinChatRoomRequest(chatRoomName, key, toUserName string, toUserNames []string) (*wechat.TransferChatRoomOwnerResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWAdminAcceptJoinChatRoomRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWAdminAcceptJoinChatRoomRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendQWAdminAcceptJoinChatRoomRequest(tmpUserInfo, chatRoomName, key, toUserName, toUserNames)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.TransferChatRoomOwnerResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 修改企业群名称
|
||
func (wxqi *WXReqInvoker) SendQWModChatRoomNameRequest(chatRoomName, name string) (*wechat.TransferChatRoomOwnerResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWModChatRoomNameRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWModChatRoomNameRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
req := &wechat.QYModChatRoomTopicRequest{
|
||
G: proto.String(chatRoomName),
|
||
P: proto.String(name),
|
||
}
|
||
buffer, err := proto.Marshal(req)
|
||
packHeader, err := clientsdk.SendQWOpLogRequest(tmpUserInfo, 8, buffer)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.TransferChatRoomOwnerResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 修改成员在群中呢称
|
||
func (wxqi *WXReqInvoker) SendQWModChatRoomMemberNickRequest(chatRoomName, name string) (*wechat.TransferChatRoomOwnerResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWModChatRoomMemberNickRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWModChatRoomNameRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
req := &wechat.QYModChatRoomTopicRequest{
|
||
G: proto.String(chatRoomName),
|
||
P: proto.String(name),
|
||
}
|
||
buffer, err := proto.Marshal(req)
|
||
packHeader, err := clientsdk.SendQWOpLogRequest(tmpUserInfo, 10, buffer)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.TransferChatRoomOwnerResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 发布企业群公告
|
||
func (wxqi *WXReqInvoker) SendQWChatRoomAnnounceRequest(chatRoomName, Announcement string) (*wechat.TransferChatRoomOwnerResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWChatRoomAnnounceRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWModChatRoomNameRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
req := &wechat.QYModChatRoomTopicRequest{
|
||
G: proto.String(chatRoomName),
|
||
P: proto.String(Announcement),
|
||
}
|
||
buffer, err := proto.Marshal(req)
|
||
packHeader, err := clientsdk.SendQWOpLogRequest(tmpUserInfo, 9, buffer)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.TransferChatRoomOwnerResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 删除企业群
|
||
func (wxqi *WXReqInvoker) SendQWDelChatRoomRequest(chatRoomName string) (*wechat.TransferChatRoomOwnerResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendQWDelChatRoomRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWDelChatRoomRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
jsonbyte, _ := serialize.Marshal(chatRoomName)
|
||
packHeader, err := clientsdk.SendQWOpLogRequest(tmpUserInfo, 14, jsonbyte)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.TransferChatRoomOwnerResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 视频号搜索
|
||
func (wxqi *WXReqInvoker) SendGetFinderSearchRequest(Index uint32, Userver int32, UserKey string, Uuid string) (*wechat.FinderSearchResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendGetFinderSearchRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWDelChatRoomRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendGetFinderSearchRequest(tmpUserInfo, Index, Userver, UserKey, Uuid)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.FinderSearchResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 视频号个人中心
|
||
func (wxqi *WXReqInvoker) SendFinderUserPrepareRequest(uServer int32) (*wechat.FinderUserPrepareResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendFinderUserPrepareRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWDelChatRoomRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendFinderUserPrepareRequest(tmpUserInfo, uServer)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.FinderUserPrepareResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// 视频号关注，取消关注
|
||
func (wxqi *WXReqInvoker) SendFinderFollowRequest(FinderUserName string, OpType int32, RefObjectId string, Cook string, Userver int32, PosterUsername string) (*wechat.FinderFollowResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendFinderFollowRequest error: %v\n", r)
|
||
// 这里可以记录日志或者执行其他的恢复操作
|
||
}
|
||
}()
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendQWDelChatRoomRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
/*userInfo := wxqi.wxconn.GetWXAccount().GetUserInfo().DeviceInfo
|
||
userInfo.OsType = "iPhone"
|
||
userInfo.OsTypeNumber = "iPhone iOS12.4.4"
|
||
wxqi.SendAutoAuthRequest()*/
|
||
packHeader, err := clientsdk.SendFinderFollowRequest(tmpUserInfo, FinderUserName, OpType, RefObjectId, Cook, Userver, PosterUsername)
|
||
if err != nil {
|
||
if packHeader != nil &&
|
||
packHeader.CheckSessionOut() {
|
||
// 断开链接, 发送token登陆
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.FinderFollowResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// UploadAppAttach 上传文件
|
||
func (wxqi *WXReqInvoker) UploadAppAttach(fileData []byte) (*wechat.UploadAppAttachResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("UploadAppAttach error: %v\n", r)
|
||
}
|
||
}()
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("UploadAppAttach err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendUploadAppAttach(tmpUserInfo, fileData)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.RetCode == baseinfo.MMRequestRetSessionTimeOut {
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.UploadAppAttachResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// SendScanQrcodeEventReportRequest 扫码事件上报 (CGI 8887)
|
||
func (wxqi *WXReqInvoker) SendScanQrcodeEventReportRequest(loginUrl string) (*wechat.ScanQrcodeEventReportRequest, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendScanQrcodeEventReportRequest error: %v\n", r)
|
||
}
|
||
}()
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendScanQrcodeEventReportRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendScanQrcodeEventReportRequest(tmpUserInfo, loginUrl)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.CheckSessionOut() {
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.ScanQrcodeEventReportRequest{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// SendExtDeviceLoginConfirmGetRequest 微信小店获取确认信息 (CGI 971)
|
||
func (wxqi *WXReqInvoker) SendExtDeviceLoginConfirmGetRequest(loginUrl string) (*wechat.ExtDeviceLoginConfirmGetResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendExtDeviceLoginConfirmGetRequest error: %v\n", r)
|
||
}
|
||
}()
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendExtDeviceLoginConfirmGetRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendExtDeviceLoginConfirmGetRequest(tmpUserInfo, loginUrl)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.CheckSessionOut() {
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.ExtDeviceLoginConfirmGetResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// SendExtDeviceLoginConfirmOkRequest 微信小店确认登录 (CGI 972)
|
||
func (wxqi *WXReqInvoker) SendExtDeviceLoginConfirmOkRequest(loginUrl string) (*wechat.ExtDeviceLoginConfirmOkResponse, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendExtDeviceLoginConfirmOkRequest error: %v\n", r)
|
||
}
|
||
}()
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, errors.New("SendExtDeviceLoginConfirmOkRequest err: wxconn.IsConnected() == false")
|
||
}
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
packHeader, err := clientsdk.SendExtDeviceLoginConfirmOkRequest(tmpUserInfo, loginUrl)
|
||
if err != nil {
|
||
if packHeader != nil && packHeader.CheckSessionOut() {
|
||
wxqi.wxconn.SendAutoAuthWaitingMinutes(4)
|
||
}
|
||
return nil, err
|
||
}
|
||
response := &wechat.ExtDeviceLoginConfirmOkResponse{}
|
||
err = clientsdk.ParseResponseData(tmpUserInfo, packHeader, response)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// SendCdnUploadImageReuqestWithDetails 发送图片到CDN并返回详细信息
|
||
func (wxqi *WXReqInvoker) SendCdnUploadImageReuqestWithDetails(imgData []byte, toUserName string) (*baseinfo.CdnImageUploadResponse, string, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCdnUploadImageReuqestWithDetails error: %v\n", r)
|
||
}
|
||
}()
|
||
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, "", errors.New("SendCdnUploadImageReuqestWithDetails err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
if tmpUserInfo.DNSInfo == nil {
|
||
_ = wxqi.SendGetCDNDnsRequest()
|
||
}
|
||
|
||
return clientsdk.SendCdnUploadImageReuqestWithDetails(tmpUserInfo, toUserName, imgData)
|
||
}
|
||
|
||
// SendCdnUploadImageReuqestWithSource 发送图片到CDN并返回详细信息（支持自定义 source）
|
||
func (wxqi *WXReqInvoker) SendCdnUploadImageReuqestWithSource(imgData []byte, toUserName string, sourceValue uint32) (*baseinfo.CdnImageUploadResponse, string, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
fmt.Printf("SendCdnUploadImageReuqestWithSource error: %v\n", r)
|
||
}
|
||
}()
|
||
|
||
// 判断是否与微信服务器握手成功
|
||
if !wxqi.wxconn.IsConnected() {
|
||
return nil, "", errors.New("SendCdnUploadImageReuqestWithSource err: wxconn.IsConnected() == false")
|
||
}
|
||
|
||
tmpUserInfo := wxqi.wxconn.GetWXAccount().GetUserInfo()
|
||
if tmpUserInfo.DNSInfo == nil {
|
||
_ = wxqi.SendGetCDNDnsRequest()
|
||
}
|
||
|
||
return clientsdk.SendCdnUploadImageReuqestWithSource(tmpUserInfo, toUserName, imgData, sourceValue)
|
||
}
|