github/openwechat
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

更新热登陆存储接口行为 🔨

Browse Source
This commit is contained in:
eatMoreApple 2021-05-11 18:47:37 +08:00
parent 72aaf1bc96
commit 41bf30c8a0
5 changed files with 517 additions and 514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

448
bot.go
View File

@ -1,40 +1,40 @@
package openwechat package openwechat
import ( import (
"context" "context"
"errors" "errors"
"log" "log"
"net/url" "net/url"
) )
type Bot struct { type Bot struct {
ScanCallBack func(body []byte) // 扫码回调,可获取扫码用户的头像 ScanCallBack func(body []byte) // 扫码回调,可获取扫码用户的头像
LoginCallBack func(body []byte) // 登陆回调 LoginCallBack func(body []byte) // 登陆回调
LogoutCallBack func(bot *Bot) // 退出回调 LogoutCallBack func(bot *Bot) // 退出回调
UUIDCallback func(uuid string) // 获取UUID的回调函数 UUIDCallback func(uuid string) // 获取UUID的回调函数
MessageHandler func(msg *Message) // 获取消息成功的handle MessageHandler func(msg *Message) // 获取消息成功的handle
GetMessageErrorHandler func(err error) // 获取消息发生错误的handle GetMessageErrorHandler func(err error) // 获取消息发生错误的handle
isHot bool isHot bool
err error err error
context context.Context context context.Context
cancel context.CancelFunc cancel context.CancelFunc
Caller *Caller Caller *Caller
self *Self self *Self
storage *Storage storage *Storage
hotReloadStorage HotReloadStorage hotReloadStorage HotReloadStorage
} }
// 判断当前用户是否正常在线 // 判断当前用户是否正常在线
func (b *Bot) Alive() bool { func (b *Bot) Alive() bool {
if b.self == nil { if b.self == nil {
return false return false
} }
select { select {
case <-b.context.Done(): case <-b.context.Done():
return false return false
default: default:
return true return true
} }
} }
// 获取当前的用户 // 获取当前的用户
@ -44,10 +44,10 @@ func (b *Bot) Alive() bool {
// } // }
// fmt.Println(self.NickName) // fmt.Println(self.NickName)
func (b *Bot) GetCurrentUser() (*Self, error) { func (b *Bot) GetCurrentUser() (*Self, error) {
if b.self == nil { if b.self == nil {
return nil, errors.New("user not login") return nil, errors.New("user not login")
} }
return b.self, nil return b.self, nil
} }
// 热登录,可实现重复登录, // 热登录,可实现重复登录,
@ -56,270 +56,278 @@ func (b *Bot) GetCurrentUser() (*Self, error) {
// err := bot.HotLogin(storage, true) // err := bot.HotLogin(storage, true)
// fmt.Println(err) // fmt.Println(err)
func (b *Bot) HotLogin(storage HotReloadStorage, retry ...bool) error { func (b *Bot) HotLogin(storage HotReloadStorage, retry ...bool) error {
b.isHot = true b.isHot = true
b.hotReloadStorage = storage b.hotReloadStorage = storage
var err error var err error
// 如果load出错了,就执行正常登陆逻辑 // 如果load出错了,就执行正常登陆逻辑
// 第一次没有数据load都会出错的 // 第一次没有数据load都会出错的
if err = storage.Load(); err != nil { if err = storage.Load(); err != nil {
return b.Login() return b.Login()
} }
if err = b.hotLoginInit(); err != nil { if err = b.hotLoginInit(); err != nil {
return err return err
} }
// 如果webInit出错,则说明可能身份信息已经失效 // 如果webInit出错,则说明可能身份信息已经失效
// 如果retry为True的话,则进行正常登陆 // 如果retry为True的话,则进行正常登陆
if err = b.webInit(); err != nil { if err = b.webInit(); err != nil {
if len(retry) > 0 { if len(retry) > 0 {
if retry[0] { if retry[0] {
return b.Login() return b.Login()
} }
} }
} }
return err return err
} }
// 热登陆初始化 // 热登陆初始化
func (b *Bot) hotLoginInit() error { func (b *Bot) hotLoginInit() error {
cookies := b.hotReloadStorage.GetCookie() item := b.hotReloadStorage.GetHotReloadStorageItem()
for u, ck := range cookies { cookies := item.Cookies
path, err := url.Parse(u) for u, ck := range cookies {
if err != nil { path, err := url.Parse(u)
return err if err != nil {
} return err
b.Caller.Client.Jar.SetCookies(path, ck) }
} b.Caller.Client.Jar.SetCookies(path, ck)
b.storage.LoginInfo = b.hotReloadStorage.GetLoginInfo() }
b.storage.Request = b.hotReloadStorage.GetBaseRequest() b.storage.LoginInfo = item.LoginInfo
return nil b.storage.Request = item.BaseRequest
b.Caller.Client.domain = item.WechatDomain
return nil
} }
// 用户登录 // 用户登录
// 该方法会一直阻塞，直到用户扫码登录，或者二维码过期 // 该方法会一直阻塞，直到用户扫码登录，或者二维码过期
func (b *Bot) Login() error { func (b *Bot) Login() error {
uuid, err := b.Caller.GetLoginUUID() uuid, err := b.Caller.GetLoginUUID()
if err != nil { if err != nil {
return err return err
} }
// 二维码获取回调 // 二维码获取回调
if b.UUIDCallback != nil { if b.UUIDCallback != nil {
b.UUIDCallback(uuid) b.UUIDCallback(uuid)
} }
for { for {
// 长轮询检查是否扫码登录 // 长轮询检查是否扫码登录
resp, err := b.Caller.CheckLogin(uuid) resp, err := b.Caller.CheckLogin(uuid)
if err != nil { if err != nil {
return err return err
} }
switch resp.Code { switch resp.Code {
case statusSuccess: case statusSuccess:
// 判断是否有登录回调，如果有执行它 // 判断是否有登录回调，如果有执行它
if b.LoginCallBack != nil { if b.LoginCallBack != nil {
b.LoginCallBack(resp.Raw) b.LoginCallBack(resp.Raw)
} }
return b.handleLogin(resp.Raw) return b.handleLogin(resp.Raw)
case statusScanned: case statusScanned:
// 执行扫码回调 // 执行扫码回调
if b.ScanCallBack != nil { if b.ScanCallBack != nil {
b.ScanCallBack(resp.Raw) b.ScanCallBack(resp.Raw)
} }
case statusTimeout: case statusTimeout:
return errors.New("login time out") return errors.New("login time out")
case statusWait: case statusWait:
continue continue
} }
} }
} }
// 用户退出 // 用户退出
func (b *Bot) Logout() error { func (b *Bot) Logout() error {
if b.Alive() { if b.Alive() {
if b.LogoutCallBack != nil { if b.LogoutCallBack != nil {
b.LogoutCallBack(b) b.LogoutCallBack(b)
} }
info := b.storage.LoginInfo info := b.storage.LoginInfo
if err := b.Caller.Logout(info); err != nil { if err := b.Caller.Logout(info); err != nil {
return err return err
} }
b.stopAsyncCALL(errors.New("logout")) b.stopAsyncCALL(errors.New("logout"))
return nil return nil
} }
return errors.New("user not login") return errors.New("user not login")
} }
// 登录逻辑 // 登录逻辑
func (b *Bot) handleLogin(data []byte) error { func (b *Bot) handleLogin(data []byte) error {
// 获取登录的一些基本的信息 // 获取登录的一些基本的信息
info, err := b.Caller.GetLoginInfo(data) info, err := b.Caller.GetLoginInfo(data)
if err != nil { if err != nil {
return err return err
} }
// 将LoginInfo存到storage里面 // 将LoginInfo存到storage里面
b.storage.LoginInfo = info b.storage.LoginInfo = info
// 构建BaseRequest // 构建BaseRequest
request := &BaseRequest{ request := &BaseRequest{
Uin: info.WxUin, Uin: info.WxUin,
Sid: info.WxSid, Sid: info.WxSid,
Skey: info.SKey, Skey: info.SKey,
DeviceID: GetRandomDeviceId(), DeviceID: GetRandomDeviceId(),
} }
// 将BaseRequest存到storage里面方便后续调用 // 将BaseRequest存到storage里面方便后续调用
b.storage.Request = request b.storage.Request = request
// 如果是热登陆,则将当前的重要信息写入hotReloadStorage // 如果是热登陆,则将当前的重要信息写入hotReloadStorage
if b.isHot { if b.isHot {
cookies := b.Caller.Client.GetCookieMap() cookies := b.Caller.Client.GetCookieMap()
if err := b.hotReloadStorage.Dump(cookies, request, info); err != nil { item := HotReloadStorageItem{
return err BaseRequest: request,
} Cookies: cookies,
} LoginInfo: info,
WechatDomain: b.Caller.Client.domain,
}
if err := b.hotReloadStorage.Dump(item); err != nil {
return err
}
}
return b.webInit() return b.webInit()
} }
// 根据有效凭证获取和初始化用户信息 // 根据有效凭证获取和初始化用户信息
func (b *Bot) webInit() error { func (b *Bot) webInit() error {
req := b.storage.Request req := b.storage.Request
info := b.storage.LoginInfo info := b.storage.LoginInfo
// 获取初始化的用户信息和一些必要的参数 // 获取初始化的用户信息和一些必要的参数
resp, err := b.Caller.WebInit(req) resp, err := b.Caller.WebInit(req)
if err != nil { if err != nil {
return err return err
} }
// 设置当前的用户 // 设置当前的用户
b.self = &Self{Bot: b, User: &resp.User} b.self = &Self{Bot: b, User: &resp.User}
b.self.Self = b.self b.self.Self = b.self
b.storage.Response = resp b.storage.Response = resp
// 通知手机客户端已经登录 // 通知手机客户端已经登录
if err = b.Caller.WebWxStatusNotify(req, resp, info); err != nil { if err = b.Caller.WebWxStatusNotify(req, resp, info); err != nil {
return err return err
} }
// 开启协程，轮训获取是否有新的消息返回 // 开启协程，轮训获取是否有新的消息返回
go func() { go func() {
if b.GetMessageErrorHandler == nil { if b.GetMessageErrorHandler == nil {
b.GetMessageErrorHandler = b.stopAsyncCALL b.GetMessageErrorHandler = b.stopAsyncCALL
} }
if err := b.asyncCall(); err != nil { if err := b.asyncCall(); err != nil {
b.GetMessageErrorHandler(err) b.GetMessageErrorHandler(err)
} }
}() }()
return nil return nil
} }
// 轮训请求 // 轮训请求
// 根据状态码判断是否有新的请求 // 根据状态码判断是否有新的请求
func (b *Bot) asyncCall() error { func (b *Bot) asyncCall() error {
var ( var (
err error err error
resp *SyncCheckResponse resp *SyncCheckResponse
) )
for b.Alive() { for b.Alive() {
// 长轮训检查是否有消息返回 // 长轮训检查是否有消息返回
resp, err = b.Caller.SyncCheck(b.storage.LoginInfo, b.storage.Response) resp, err = b.Caller.SyncCheck(b.storage.LoginInfo, b.storage.Response)
if err != nil { if err != nil {
return err return err
} }
// 如果不是正常的状态码返回，发生了错误，直接退出 // 如果不是正常的状态码返回，发生了错误，直接退出
if !resp.Success() { if !resp.Success() {
return resp return resp
} }
// 如果Selector不为0，则获取消息 // 如果Selector不为0，则获取消息
if !resp.NorMal() { if !resp.NorMal() {
if err = b.getNewWechatMessage(); err != nil { if err = b.getNewWechatMessage(); err != nil {
return err return err
} }
} }
} }
return err return err
} }
// 当获取消息发生错误时, 默认的错误处理行为 // 当获取消息发生错误时, 默认的错误处理行为
func (b *Bot) stopAsyncCALL(err error) { func (b *Bot) stopAsyncCALL(err error) {
b.cancel() b.cancel()
b.err = err b.err = err
b.self = nil b.self = nil
log.Printf("exit with : %s", err.Error()) log.Printf("exit with : %s", err.Error())
} }
// 获取新的消息 // 获取新的消息
func (b *Bot) getNewWechatMessage() error { func (b *Bot) getNewWechatMessage() error {
resp, err := b.Caller.WebWxSync(b.storage.Request, b.storage.Response, b.storage.LoginInfo) resp, err := b.Caller.WebWxSync(b.storage.Request, b.storage.Response, b.storage.LoginInfo)
if err != nil { if err != nil {
return err return err
} }
// 更新SyncKey并且重新存入storage // 更新SyncKey并且重新存入storage
b.storage.Response.SyncKey = resp.SyncKey b.storage.Response.SyncKey = resp.SyncKey
// 遍历所有的新的消息，依次处理 // 遍历所有的新的消息，依次处理
for _, message := range resp.AddMsgList { for _, message := range resp.AddMsgList {
// 根据不同的消息类型来进行处理，方便后续统一调用 // 根据不同的消息类型来进行处理，方便后续统一调用
message.init(b) message.init(b)
// 调用自定义的处理方法 // 调用自定义的处理方法
if handler := b.MessageHandler; handler != nil { if handler := b.MessageHandler; handler != nil {
handler(message) handler(message)
} }
} }
return nil return nil
} }
// 当消息同步发生了错误或者用户主动在手机上退出，该方法会立即返回，否则会一直阻塞 // 当消息同步发生了错误或者用户主动在手机上退出，该方法会立即返回，否则会一直阻塞
func (b *Bot) Block() error { func (b *Bot) Block() error {
if b.self == nil { if b.self == nil {
return errors.New("`Block` must be called after user login") return errors.New("`Block` must be called after user login")
} }
<-b.context.Done() <-b.context.Done()
return nil return nil
} }
// 获取当前Bot崩溃的原因 // 获取当前Bot崩溃的原因
func (b *Bot) CrashReason() error { func (b *Bot) CrashReason() error {
return b.err return b.err
} }
// setter for Bot.MessageHandler // setter for Bot.MessageHandler
func (b *Bot) MessageOnSuccess(h func(msg *Message)) { func (b *Bot) MessageOnSuccess(h func(msg *Message)) {
b.MessageHandler = h b.MessageHandler = h
} }
// setter for Bot.GetMessageErrorHandler // setter for Bot.GetMessageErrorHandler
func (b *Bot) MessageOnError(h func(err error)) { func (b *Bot) MessageOnError(h func(err error)) {
b.GetMessageErrorHandler = h b.GetMessageErrorHandler = h
} }
// Bot的构造方法，需要自己传入Caller // Bot的构造方法，需要自己传入Caller
func NewBot(caller *Caller) *Bot { func NewBot(caller *Caller) *Bot {
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
return &Bot{Caller: caller, storage: &Storage{}, context: ctx, cancel: cancel} return &Bot{Caller: caller, storage: &Storage{}, context: ctx, cancel: cancel}
} }
// 默认的Bot的构造方法, // 默认的Bot的构造方法,
// mode不传入默认为openwechat.Normal,详情见mode // mode不传入默认为openwechat.Normal,详情见mode
// bot := openwechat.DefaultBot(openwechat.Desktop) // bot := openwechat.DefaultBot(openwechat.Desktop)
func DefaultBot(modes ...mode) *Bot { func DefaultBot(modes ...mode) *Bot {
var m mode var m mode
if len(modes) == 0 { if len(modes) == 0 {
m = Normal m = Normal
} else { } else {
m = modes[0] m = modes[0]
} }
caller := DefaultCaller() caller := DefaultCaller()
caller.Client.mode = m caller.Client.mode = m
return NewBot(caller) return NewBot(caller)
} }
// 通过uuid获取登录二维码的url // 通过uuid获取登录二维码的url
func GetQrcodeUrl(uuid string) string { func GetQrcodeUrl(uuid string) string {
return qrcode + uuid return qrcode + uuid
} }
// 打印登录二维码 // 打印登录二维码
func PrintlnQrcodeUrl(uuid string) { func PrintlnQrcodeUrl(uuid string) {
println("访问下面网址扫描二维码登录") println("访问下面网址扫描二维码登录")
println(GetQrcodeUrl(uuid)) println(GetQrcodeUrl(uuid))
} }

476
caller.go
View File

@ -1,349 +1,351 @@
package openwechat package openwechat
import ( import (
"errors" "errors"
"net/http" "net/http"
"net/url" "net/url"
"os" "os"
) )
// 调用请求和解析请求 // 调用请求和解析请求
// 上层模块可以直接获取封装后的请求结果 // 上层模块可以直接获取封装后的请求结果
type Caller struct { type Caller struct {
Client *Client Client *Client
path *url.URL
} }
// Constructor for Caller // Constructor for Caller
func NewCaller(client *Client) *Caller { func NewCaller(client *Client) *Caller {
return &Caller{Client: client} return &Caller{Client: client}
} }
// Default Constructor for Caller // Default Constructor for Caller
func DefaultCaller() *Caller { func DefaultCaller() *Caller {
return NewCaller(DefaultClient()) return NewCaller(DefaultClient())
} }
// 获取登录的uuid // 获取登录的uuid
func (c *Caller) GetLoginUUID() (string, error) { func (c *Caller) GetLoginUUID() (string, error) {
resp := NewReturnResponse(c.Client.GetLoginUUID()) resp := NewReturnResponse(c.Client.GetLoginUUID())
if resp.Err() != nil { if resp.Err() != nil {
return "", resp.Err() return "", resp.Err()
} }
defer resp.Body.Close() defer resp.Body.Close()
data, err := resp.ReadAll() data, err := resp.ReadAll()
if err != nil { if err != nil {
return "", err return "", err
} }
// 正则匹配uuid字符串 // 正则匹配uuid字符串
results := uuidRegexp.FindSubmatch(data) results := uuidRegexp.FindSubmatch(data)
if len(results) != 2 { if len(results) != 2 {
// 如果没有匹配到,可能微信的接口做了修改，或者当前机器的ip被加入了黑名单 // 如果没有匹配到,可能微信的接口做了修改，或者当前机器的ip被加入了黑名单
return "", errors.New("uuid does not match") return "", errors.New("uuid does not match")
} }
return string(results[1]), nil return string(results[1]), nil
} }
// 检查是否登录成功 // 检查是否登录成功
func (c *Caller) CheckLogin(uuid string) (*CheckLoginResponse, error) { func (c *Caller) CheckLogin(uuid string) (*CheckLoginResponse, error) {
resp := NewReturnResponse(c.Client.CheckLogin(uuid)) resp := NewReturnResponse(c.Client.CheckLogin(uuid))
if resp.Err() != nil { if resp.Err() != nil {
return nil, resp.Err() return nil, resp.Err()
} }
defer resp.Body.Close() defer resp.Body.Close()
data, err := resp.ReadAll() data, err := resp.ReadAll()
if err != nil { if err != nil {
return nil, err return nil, err
} }
// 正则匹配检测的code // 正则匹配检测的code
// 具体code参考global.go // 具体code参考global.go
results := statusCodeRegexp.FindSubmatch(data) results := statusCodeRegexp.FindSubmatch(data)
if len(results) != 2 { if len(results) != 2 {
return nil, errors.New("error status code match") return nil, errors.New("error status code match")
} }
code := string(results[1]) code := string(results[1])
return &CheckLoginResponse{Code: code, Raw: data}, nil return &CheckLoginResponse{Code: code, Raw: data}, nil
} }
// 获取登录信息 // 获取登录信息
func (c *Caller) GetLoginInfo(body []byte) (*LoginInfo, error) { func (c *Caller) GetLoginInfo(body []byte) (*LoginInfo, error) {
// 从响应体里面获取需要跳转的url // 从响应体里面获取需要跳转的url
results := redirectUriRegexp.FindSubmatch(body) results := redirectUriRegexp.FindSubmatch(body)
if len(results) != 2 { if len(results) != 2 {
return nil, errors.New("redirect url does not match") return nil, errors.New("redirect url does not match")
} }
path, err := url.Parse(string(results[1])) path, err := url.Parse(string(results[1]))
if err != nil { if err != nil {
return nil, err return nil, err
} }
host := path.Host
domain, err := getDomainByHost(host) domain, err := getDomainByHost(path.Host)
if err != nil { if err != nil {
return nil, err return nil, err
} }
c.Client.domain = domain c.Client.domain = domain
resp := NewReturnResponse(c.Client.GetLoginInfo(path.String()))
if resp.Err() != nil { resp := NewReturnResponse(c.Client.GetLoginInfo(path.String()))
return nil, resp.Err() if resp.Err() != nil {
} return nil, resp.Err()
defer resp.Body.Close() }
var loginInfo LoginInfo defer resp.Body.Close()
// xml结构体序列化储存 var loginInfo LoginInfo
if err := resp.ScanXML(&loginInfo); err != nil { // xml结构体序列化储存
return nil, err if err := resp.ScanXML(&loginInfo); err != nil {
} return nil, err
if !loginInfo.Ok() { }
return nil, loginInfo if !loginInfo.Ok() {
} return nil, loginInfo
return &loginInfo, nil }
return &loginInfo, nil
} }
// 获取初始化信息 // 获取初始化信息
func (c *Caller) WebInit(request *BaseRequest) (*WebInitResponse, error) { func (c *Caller) WebInit(request *BaseRequest) (*WebInitResponse, error) {
resp := NewReturnResponse(c.Client.WebInit(request)) resp := NewReturnResponse(c.Client.WebInit(request))
if resp.Err() != nil { if resp.Err() != nil {
return nil, resp.Err() return nil, resp.Err()
} }
var webInitResponse WebInitResponse var webInitResponse WebInitResponse
defer resp.Body.Close() defer resp.Body.Close()
if err := resp.ScanJSON(&webInitResponse); err != nil { if err := resp.ScanJSON(&webInitResponse); err != nil {
return nil, err return nil, err
} }
return &webInitResponse, nil return &webInitResponse, nil
} }
// 通知手机已登录 // 通知手机已登录
func (c *Caller) WebWxStatusNotify(request *BaseRequest, response *WebInitResponse, info *LoginInfo) error { func (c *Caller) WebWxStatusNotify(request *BaseRequest, response *WebInitResponse, info *LoginInfo) error {
resp := NewReturnResponse(c.Client.WebWxStatusNotify(request, response, info)) resp := NewReturnResponse(c.Client.WebWxStatusNotify(request, response, info))
if resp.Err() != nil { if resp.Err() != nil {
return resp.Err() return resp.Err()
} }
var item struct{ BaseResponse BaseResponse } var item struct{ BaseResponse BaseResponse }
defer resp.Body.Close() defer resp.Body.Close()
if err := resp.ScanJSON(&item); err != nil { if err := resp.ScanJSON(&item); err != nil {
return err return err
} }
if !item.BaseResponse.Ok() { if !item.BaseResponse.Ok() {
return item.BaseResponse return item.BaseResponse
} }
return nil return nil
} }
// 异步获取是否有新的消息 // 异步获取是否有新的消息
func (c *Caller) SyncCheck(info *LoginInfo, response *WebInitResponse) (*SyncCheckResponse, error) { func (c *Caller) SyncCheck(info *LoginInfo, response *WebInitResponse) (*SyncCheckResponse, error) {
resp := NewReturnResponse(c.Client.SyncCheck(info, response)) resp := NewReturnResponse(c.Client.SyncCheck(info, response))
if resp.Err() != nil { if resp.Err() != nil {
return nil, resp.Err() return nil, resp.Err()
} }
defer resp.Body.Close() defer resp.Body.Close()
data, err := resp.ReadAll() data, err := resp.ReadAll()
if err != nil { if err != nil {
return nil, err return nil, err
} }
results := syncCheckRegexp.FindSubmatch(data) results := syncCheckRegexp.FindSubmatch(data)
if len(results) != 3 { if len(results) != 3 {
return nil, errors.New("parse sync key failed") return nil, errors.New("parse sync key failed")
} }
retCode, selector := string(results[1]), string(results[2]) retCode, selector := string(results[1]), string(results[2])
syncCheckResponse := &SyncCheckResponse{RetCode: retCode, Selector: selector} syncCheckResponse := &SyncCheckResponse{RetCode: retCode, Selector: selector}
return syncCheckResponse, nil return syncCheckResponse, nil
} }
// 获取所有的联系人 // 获取所有的联系人
func (c *Caller) WebWxGetContact(info *LoginInfo) (Members, error) { func (c *Caller) WebWxGetContact(info *LoginInfo) (Members, error) {
resp := NewReturnResponse(c.Client.WebWxGetContact(info)) resp := NewReturnResponse(c.Client.WebWxGetContact(info))
if resp.Err() != nil { if resp.Err() != nil {
return nil, resp.Err() return nil, resp.Err()
} }
defer resp.Body.Close() defer resp.Body.Close()
var item WebWxContactResponse var item WebWxContactResponse
if err := resp.ScanJSON(&item); err != nil { if err := resp.ScanJSON(&item); err != nil {
return nil, err return nil, err
} }
if !item.BaseResponse.Ok() { if !item.BaseResponse.Ok() {
return nil, item.BaseResponse return nil, item.BaseResponse
} }
return item.MemberList, nil return item.MemberList, nil
} }
// 获取联系人的详情 // 获取联系人的详情
// 注: Members参数的长度不要大于50 // 注: Members参数的长度不要大于50
func (c *Caller) WebWxBatchGetContact(members Members, request *BaseRequest) (Members, error) { func (c *Caller) WebWxBatchGetContact(members Members, request *BaseRequest) (Members, error) {
resp := NewReturnResponse(c.Client.WebWxBatchGetContact(members, request)) resp := NewReturnResponse(c.Client.WebWxBatchGetContact(members, request))
if resp.Err() != nil { if resp.Err() != nil {
return nil, resp.Err() return nil, resp.Err()
} }
defer resp.Body.Close() defer resp.Body.Close()
var item WebWxBatchContactResponse var item WebWxBatchContactResponse
if err := resp.ScanJSON(&item); err != nil { if err := resp.ScanJSON(&item); err != nil {
return nil, err return nil, err
} }
if !item.BaseResponse.Ok() { if !item.BaseResponse.Ok() {
return nil, item.BaseResponse return nil, item.BaseResponse
} }
return item.ContactList, nil return item.ContactList, nil
} }
// 获取新的消息接口 // 获取新的消息接口
func (c *Caller) WebWxSync(request *BaseRequest, response *WebInitResponse, info *LoginInfo) (*WebWxSyncResponse, error) { func (c *Caller) WebWxSync(request *BaseRequest, response *WebInitResponse, info *LoginInfo) (*WebWxSyncResponse, error) {
resp := NewReturnResponse(c.Client.WebWxSync(request, response, info)) resp := NewReturnResponse(c.Client.WebWxSync(request, response, info))
if resp.Err() != nil { if resp.Err() != nil {
return nil, resp.Err() return nil, resp.Err()
} }
defer resp.Body.Close() defer resp.Body.Close()
var webWxSyncResponse WebWxSyncResponse var webWxSyncResponse WebWxSyncResponse
if err := resp.ScanJSON(&webWxSyncResponse); err != nil { if err := resp.ScanJSON(&webWxSyncResponse); err != nil {
return nil, err return nil, err
} }
return &webWxSyncResponse, nil return &webWxSyncResponse, nil
} }
// 发送消息接口 // 发送消息接口
func (c *Caller) WebWxSendMsg(msg *SendMessage, info *LoginInfo, request *BaseRequest) (*SentMessage, error) { func (c *Caller) WebWxSendMsg(msg *SendMessage, info *LoginInfo, request *BaseRequest) (*SentMessage, error) {
resp, err := c.Client.WebWxSendMsg(msg, info, request) resp, err := c.Client.WebWxSendMsg(msg, info, request)
return getSuccessSentMessage(msg, resp, err) return getSuccessSentMessage(msg, resp, err)
} }
// 修改用户备注接口 // 修改用户备注接口
func (c *Caller) WebWxOplog(request *BaseRequest, remarkName, toUserName string) error { func (c *Caller) WebWxOplog(request *BaseRequest, remarkName, toUserName string) error {
resp := NewReturnResponse(c.Client.WebWxOplog(request, remarkName, toUserName)) resp := NewReturnResponse(c.Client.WebWxOplog(request, remarkName, toUserName))
return parseBaseResponseError(resp) return parseBaseResponseError(resp)
} }
func (c *Caller) UploadMedia(file *os.File, request *BaseRequest, info *LoginInfo, fromUserName, toUserName string) (*UploadResponse, error) { func (c *Caller) UploadMedia(file *os.File, request *BaseRequest, info *LoginInfo, fromUserName, toUserName string) (*UploadResponse, error) {
// 首先尝试上传图片 // 首先尝试上传图片
resp := NewReturnResponse(c.Client.WebWxUploadMediaByChunk(file, request, info, fromUserName, toUserName)) resp := NewReturnResponse(c.Client.WebWxUploadMediaByChunk(file, request, info, fromUserName, toUserName))
// 无错误上传成功之后获取请求结果，判断结果是否正常 // 无错误上传成功之后获取请求结果，判断结果是否正常
if resp.Err() != nil { if resp.Err() != nil {
return nil, resp.Err() return nil, resp.Err()
} }
defer resp.Body.Close() defer resp.Body.Close()
var item UploadResponse var item UploadResponse
if err := resp.ScanJSON(&item); err != nil { if err := resp.ScanJSON(&item); err != nil {
return &item, err return &item, err
} }
if !item.BaseResponse.Ok() { if !item.BaseResponse.Ok() {
return &item, item.BaseResponse return &item, item.BaseResponse
} }
if len(item.MediaId) == 0 { if len(item.MediaId) == 0 {
return &item, errors.New("upload failed") return &item, errors.New("upload failed")
} }
return &item, nil return &item, nil
} }
// 发送图片消息接口 // 发送图片消息接口
func (c *Caller) WebWxSendImageMsg(file *os.File, request *BaseRequest, info *LoginInfo, fromUserName, toUserName string) (*SentMessage, error) { func (c *Caller) WebWxSendImageMsg(file *os.File, request *BaseRequest, info *LoginInfo, fromUserName, toUserName string) (*SentMessage, error) {
// 首先尝试上传图片 // 首先尝试上传图片
resp, err := c.UploadMedia(file, request, info, fromUserName, toUserName) resp, err := c.UploadMedia(file, request, info, fromUserName, toUserName)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// 构造新的图片类型的信息 // 构造新的图片类型的信息
msg := NewMediaSendMessage(ImageMessage, fromUserName, toUserName, resp.MediaId) msg := NewMediaSendMessage(ImageMessage, fromUserName, toUserName, resp.MediaId)
// 发送图片信息 // 发送图片信息
resp1, err := c.Client.WebWxSendMsgImg(msg, request, info) resp1, err := c.Client.WebWxSendMsgImg(msg, request, info)
return getSuccessSentMessage(msg, resp1, err) return getSuccessSentMessage(msg, resp1, err)
} }
func (c *Caller) WebWxSendFile(file *os.File, req *BaseRequest, info *LoginInfo, fromUserName, toUserName string) (*SentMessage, error) { func (c *Caller) WebWxSendFile(file *os.File, req *BaseRequest, info *LoginInfo, fromUserName, toUserName string) (*SentMessage, error) {
resp, err := c.UploadMedia(file, req, info, fromUserName, toUserName) resp, err := c.UploadMedia(file, req, info, fromUserName, toUserName)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// 构造新的文件类型的信息 // 构造新的文件类型的信息
stat, _ := file.Stat() stat, _ := file.Stat()
appMsg := NewFileAppMessage(stat, resp.MediaId) appMsg := NewFileAppMessage(stat, resp.MediaId)
content, err := appMsg.XmlByte() content, err := appMsg.XmlByte()
if err != nil { if err != nil {
return nil, err return nil, err
} }
msg := NewSendMessage(AppMessage, string(content), fromUserName, toUserName, "") msg := NewSendMessage(AppMessage, string(content), fromUserName, toUserName, "")
return c.WebWxSendAppMsg(msg, req) return c.WebWxSendAppMsg(msg, req)
} }
// 发送媒体消息 // 发送媒体消息
func (c *Caller) WebWxSendAppMsg(msg *SendMessage, req *BaseRequest) (*SentMessage, error) { func (c *Caller) WebWxSendAppMsg(msg *SendMessage, req *BaseRequest) (*SentMessage, error) {
resp, err := c.Client.WebWxSendAppMsg(msg, req) resp, err := c.Client.WebWxSendAppMsg(msg, req)
return getSuccessSentMessage(msg, resp, err) return getSuccessSentMessage(msg, resp, err)
} }
// 用户退出 // 用户退出
func (c *Caller) Logout(info *LoginInfo) error { func (c *Caller) Logout(info *LoginInfo) error {
resp := NewReturnResponse(c.Client.Logout(info)) resp := NewReturnResponse(c.Client.Logout(info))
return parseBaseResponseError(resp) return parseBaseResponseError(resp)
} }
// 拉好友入群 // 拉好友入群
func (c *Caller) AddFriendIntoChatRoom(req *BaseRequest, info *LoginInfo, group *Group, friends ...*Friend) error { func (c *Caller) AddFriendIntoChatRoom(req *BaseRequest, info *LoginInfo, group *Group, friends ...*Friend) error {
if len(friends) == 0 { if len(friends) == 0 {
return errors.New("no friends found") return errors.New("no friends found")
} }
resp := NewReturnResponse(c.Client.AddMemberIntoChatRoom(req, info, group, friends...)) resp := NewReturnResponse(c.Client.AddMemberIntoChatRoom(req, info, group, friends...))
return parseBaseResponseError(resp) return parseBaseResponseError(resp)
} }
// 从群聊中移除用户 // 从群聊中移除用户
func (c *Caller) RemoveFriendFromChatRoom(req *BaseRequest, info *LoginInfo, group *Group, users ...*User) error { func (c *Caller) RemoveFriendFromChatRoom(req *BaseRequest, info *LoginInfo, group *Group, users ...*User) error {
if len(users) == 0 { if len(users) == 0 {
return errors.New("no users found") return errors.New("no users found")
} }
resp := NewReturnResponse(c.Client.RemoveMemberFromChatRoom(req, info, group, users...)) resp := NewReturnResponse(c.Client.RemoveMemberFromChatRoom(req, info, group, users...))
return parseBaseResponseError(resp) return parseBaseResponseError(resp)
} }
// 同意加好友请求 // 同意加好友请求
func (c *Caller) WebWxVerifyUser(storage *Storage, info RecommendInfo, verifyContent string) error { func (c *Caller) WebWxVerifyUser(storage *Storage, info RecommendInfo, verifyContent string) error {
resp := NewReturnResponse(c.Client.WebWxVerifyUser(storage, info, verifyContent)) resp := NewReturnResponse(c.Client.WebWxVerifyUser(storage, info, verifyContent))
return parseBaseResponseError(resp) return parseBaseResponseError(resp)
} }
// 撤回消息操作 // 撤回消息操作
func (c *Caller) WebWxRevokeMsg(msg *SentMessage, request *BaseRequest) error { func (c *Caller) WebWxRevokeMsg(msg *SentMessage, request *BaseRequest) error {
resp := NewReturnResponse(c.Client.WebWxRevokeMsg(msg, request)) resp := NewReturnResponse(c.Client.WebWxRevokeMsg(msg, request))
return parseBaseResponseError(resp) return parseBaseResponseError(resp)
} }
// 处理响应返回的结果是否正常 // 处理响应返回的结果是否正常
func parseBaseResponseError(resp *ReturnResponse) error { func parseBaseResponseError(resp *ReturnResponse) error {
if resp.Err() != nil { if resp.Err() != nil {
return resp.Err() return resp.Err()
} }
defer resp.Body.Close() defer resp.Body.Close()
var item struct{ BaseResponse BaseResponse } var item struct{ BaseResponse BaseResponse }
if err := resp.ScanJSON(&item); err != nil { if err := resp.ScanJSON(&item); err != nil {
return err return err
} }
if !item.BaseResponse.Ok() { if !item.BaseResponse.Ok() {
return item.BaseResponse return item.BaseResponse
} }
return nil return nil
} }
func parseMessageResponseError(resp *ReturnResponse, msg *SentMessage) error { func parseMessageResponseError(resp *ReturnResponse, msg *SentMessage) error {
if resp.Err() != nil { if resp.Err() != nil {
return resp.Err() return resp.Err()
} }
defer resp.Body.Close() defer resp.Body.Close()
var messageResp MessageResponse var messageResp MessageResponse
if err := resp.ScanJSON(&messageResp); err != nil { if err := resp.ScanJSON(&messageResp); err != nil {
return err return err
} }
if !messageResp.BaseResponse.Ok() { if !messageResp.BaseResponse.Ok() {
return messageResp.BaseResponse return messageResp.BaseResponse
} }
// 发送成功之后将msgId赋值给SendMessage // 发送成功之后将msgId赋值给SendMessage
msg.MsgId = messageResp.MsgID msg.MsgId = messageResp.MsgID
return nil return nil
} }
func getSuccessSentMessage(msg *SendMessage, resp *http.Response, err error) (*SentMessage, error) { func getSuccessSentMessage(msg *SendMessage, resp *http.Response, err error) (*SentMessage, error) {
returnResp := NewReturnResponse(resp, err) returnResp := NewReturnResponse(resp, err)
sendSuccessMsg := &SentMessage{SendMessage: msg} sendSuccessMsg := &SentMessage{SendMessage: msg}
err = parseMessageResponseError(returnResp, sendSuccessMsg) err = parseMessageResponseError(returnResp, sendSuccessMsg)
return sendSuccessMsg, err return sendSuccessMsg, err
} }

2
client.go
View File

@ -40,7 +40,7 @@ func (u UserAgentHook) AfterRequest(response *http.Response, err error) {}
type Client struct { type Client struct {
HttpHooks HttpHooks HttpHooks HttpHooks
*http.Client *http.Client
domain *domain domain *WechatDomain
mode mode mode mode
mu sync.Mutex mu sync.Mutex
cookies map[string][]*http.Cookie cookies map[string][]*http.Cookie

99
stroage.go
View File

@ -1,88 +1,81 @@
package openwechat package openwechat
import ( import (
"bytes" "bytes"
"encoding/json" "encoding/json"
"net/http" "net/http"
"os" "os"
) )
// 身份信息, 维持整个登陆的Session会话 // 身份信息, 维持整个登陆的Session会话
type Storage struct { type Storage struct {
LoginInfo *LoginInfo LoginInfo *LoginInfo
Request *BaseRequest Request *BaseRequest
Response *WebInitResponse Response *WebInitResponse
}
type HotReloadStorageItem struct {
Cookies map[string][]*http.Cookie
BaseRequest *BaseRequest
LoginInfo *LoginInfo
WechatDomain *WechatDomain
} }
// 热登陆存储接口 // 热登陆存储接口
type HotReloadStorage interface { type HotReloadStorage interface {
GetCookie() map[string][]*http.Cookie // 获取client.cookie GetHotReloadStorageItem() HotReloadStorageItem // 获取HotReloadStorageItem
GetBaseRequest() *BaseRequest // 获取BaseRequest Dump(item HotReloadStorageItem) error // 实现该方法, 将必要信息进行序列化
GetLoginInfo() *LoginInfo // 获取LoginInfo Load() error // 实现该方法, 将存储媒介的内容反序列化
Dump(cookies map[string][]*http.Cookie, req *BaseRequest, info *LoginInfo) error // 实现该方法, 将必要信息进行序列化
Load() error // 实现该方法, 将存储媒介的内容反序列化
} }
// 实现HotReloadStorage接口 // 实现HotReloadStorage接口
// 默认以json文件的形式存储 // 默认以json文件的形式存储
type JsonFileHotReloadStorage struct { type JsonFileHotReloadStorage struct {
Cookie map[string][]*http.Cookie item HotReloadStorageItem
Req *BaseRequest filename string
Info *LoginInfo
filename string
} }
// 将信息写入json文件 // 将信息写入json文件
func (f *JsonFileHotReloadStorage) Dump(cookies map[string][]*http.Cookie, req *BaseRequest, info *LoginInfo) error { func (f *JsonFileHotReloadStorage) Dump(item HotReloadStorageItem) error {
file, err := os.OpenFile(f.filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, os.ModePerm) file, err := os.OpenFile(f.filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, os.ModePerm)
if err != nil { if err != nil {
return err return err
} }
defer file.Close() defer file.Close()
f.Cookie = cookies f.item = item
f.Req = req
f.Info = info
data, err := json.Marshal(f) data, err := json.Marshal(f.item)
if err != nil { if err != nil {
return err return err
} }
_, err = file.Write(data) _, err = file.Write(data)
return err return err
} }
// 从文件中读取信息 // 从文件中读取信息
func (f *JsonFileHotReloadStorage) Load() error { func (f *JsonFileHotReloadStorage) Load() error {
file, err := os.Open(f.filename) file, err := os.Open(f.filename)
if err != nil { if err != nil {
return err return err
} }
defer file.Close() defer file.Close()
var buffer bytes.Buffer var buffer bytes.Buffer
if _, err := buffer.ReadFrom(file); err != nil { if _, err := buffer.ReadFrom(file); err != nil {
return err return err
} }
err = json.Unmarshal(buffer.Bytes(), f) err = json.Unmarshal(buffer.Bytes(), &f.item)
return err return err
} }
func (f *JsonFileHotReloadStorage) GetCookie() map[string][]*http.Cookie { func (f *JsonFileHotReloadStorage) GetHotReloadStorageItem() HotReloadStorageItem {
return f.Cookie return f.item
}
func (f *JsonFileHotReloadStorage) GetBaseRequest() *BaseRequest {
return f.Req
}
func (f *JsonFileHotReloadStorage) GetLoginInfo() *LoginInfo {
return f.Info
} }
func NewJsonFileHotReloadStorage(filename string) *JsonFileHotReloadStorage { func NewJsonFileHotReloadStorage(filename string) *JsonFileHotReloadStorage {
return &JsonFileHotReloadStorage{filename: filename} return &JsonFileHotReloadStorage{filename: filename}
} }

6
url.go
View File

@ -47,18 +47,18 @@ var domainMap = map[string][]string{
"wechat.com": {"https://wechat.com", "https://file.web.wechat.com", "https://webpush.web.wechat.com"}, "wechat.com": {"https://wechat.com", "https://file.web.wechat.com", "https://webpush.web.wechat.com"},
} }
func getDomainByHost(host string) (*domain, error) { func getDomainByHost(host string) (*WechatDomain, error) {
value, exist := domainMap[host] value, exist := domainMap[host]
if !exist { if !exist {
return nil, errors.New("invalid host") return nil, errors.New("invalid host")
} }
return &domain{ return &WechatDomain{
BaseHost: value[0], BaseHost: value[0],
FileHost: value[1], FileHost: value[1],
SyncHost: value[2], SyncHost: value[2],
}, nil }, nil
} }
type domain struct { type WechatDomain struct {
BaseHost, FileHost, SyncHost string BaseHost, FileHost, SyncHost string
} }