Merge remote-tracking branch 'origin/tuoyun' into tuoyun

pull/131/head
Gordon 3 years ago
commit 0ed5f8081a

@ -26,7 +26,7 @@ func main() {
userRouterGroup := r.Group("/user") userRouterGroup := r.Group("/user")
{ {
userRouterGroup.POST("/update_user_info", user.UpdateUserInfo) //1 userRouterGroup.POST("/update_user_info", user.UpdateUserInfo) //1
userRouterGroup.POST("/get_user_info", user.GetUsersInfo) //1 userRouterGroup.POST("/get_users_info", user.GetUsersInfo) //1
userRouterGroup.POST("/get_self_user_info", user.GetSelfUserInfo) //1 userRouterGroup.POST("/get_self_user_info", user.GetSelfUserInfo) //1
} }
//friend routing group //friend routing group
@ -34,17 +34,19 @@ func main() {
{ {
// friendRouterGroup.POST("/get_friends_info", friend.GetFriendsInfo) // friendRouterGroup.POST("/get_friends_info", friend.GetFriendsInfo)
friendRouterGroup.POST("/add_friend", friend.AddFriend) //1 friendRouterGroup.POST("/add_friend", friend.AddFriend) //1
friendRouterGroup.POST("/delete_friend", friend.DeleteFriend) //1
friendRouterGroup.POST("/get_friend_apply_list", friend.GetFriendApplyList) //1 friendRouterGroup.POST("/get_friend_apply_list", friend.GetFriendApplyList) //1
friendRouterGroup.POST("/get_self_apply_list", friend.GetSelfApplyList) //1 friendRouterGroup.POST("/get_self_friend_apply_list", friend.GetSelfFriendApplyList) //1
friendRouterGroup.POST("/get_friend_list", friend.GetFriendList) //1 friendRouterGroup.POST("/get_friend_list", friend.GetFriendList) //1
friendRouterGroup.POST("/add_blacklist", friend.AddBlacklist) //1
friendRouterGroup.POST("/get_blacklist", friend.GetBlacklist) //1
friendRouterGroup.POST("/remove_blacklist", friend.RemoveBlacklist) //1
friendRouterGroup.POST("/delete_friend", friend.DeleteFriend) //1
friendRouterGroup.POST("/add_friend_response", friend.AddFriendResponse) //1 friendRouterGroup.POST("/add_friend_response", friend.AddFriendResponse) //1
friendRouterGroup.POST("/set_friend_remark", friend.SetFriendRemark) //1 friendRouterGroup.POST("/set_friend_remark", friend.SetFriendRemark) //1
friendRouterGroup.POST("/is_friend", friend.IsFriend) //1
friendRouterGroup.POST("/add_black", friend.AddBlack) //1
friendRouterGroup.POST("/get_black_list", friend.GetBlacklist) //1
friendRouterGroup.POST("/remove_black", friend.RemoveBlack) //1
friendRouterGroup.POST("/import_friend", friend.ImportFriend) //1 friendRouterGroup.POST("/import_friend", friend.ImportFriend) //1
friendRouterGroup.POST("/is_friend", friend.IsFriend) //1
} }
//group related routing group //group related routing group
groupRouterGroup := r.Group("/group") groupRouterGroup := r.Group("/group")

@ -85,7 +85,7 @@ credential:
rpcport: rpcport:
openImUserPort: [ 10100 ] openImUserPort: [ 10100 ]
openImFriendPort: [ 10200 ] openImFriendPort: [ 10200 ]
openImOfflineMessagePort: [ 10300] openImOfflineMessagePort: [ 10300 ]
openImOnlineRelayPort: [ 10400 ] openImOnlineRelayPort: [ 10400 ]
openImGroupPort: [ 10500 ] openImGroupPort: [ 10500 ]
openImAuthPort: [ 10600 ] openImAuthPort: [ 10600 ]
@ -144,8 +144,8 @@ push:
pushUrl: "https://api.jpush.cn/v3/push" pushUrl: "https://api.jpush.cn/v3/push"
pushIntent: "intent:#Intent;component=io.openim.app.enterprisechat/io.openim.app.enterprisechat.MainActivity;end" pushIntent: "intent:#Intent;component=io.openim.app.enterprisechat/io.openim.app.enterprisechat.MainActivity;end"
manager: manager:
appManagerUid: ["openIM123456","openIM654321"] appManagerUid: [ "openIM123456","openIM654321" ]
secrets: ["openIM1","openIM2"] secrets: [ "openIM1","openIM2" ]
secret: tuoyun secret: tuoyun
@ -176,30 +176,251 @@ iOSPush:
badgeCount: true badgeCount: true
notification: notification:
groupCreated: groupCreated:
conversation: conversation:
conversationChanged: true reliabilityLevel: 1
unreadCount: true unreadCount: true
offlinePush: offlinePush:
switch: true switch: true
title: "create group title" title: "create group title" # xx create the group
desc: "create group desc" desc: "create group desc"
ext: "create group ext" ext: "create group ext"
defaultTips: defaultTips:
tips: "create the group" # xx create the group tips: "create the group" # xx create the group
groupInfoChanged: groupInfoSet:
conversation: conversation:
conversationChanged: true reliabilityLevel: 1
unreadCount: true unreadCount: false
offlinePush: offlinePush:
switch: true switch: false
title: "group info changed title"
desc: "group info changed desc"
ext: "group info changed ext"
defaultTips:
tips: "group info changed by" # group info changed by xx
joinGroupApplication:
conversation:
reliabilityLevel: 1
unreadCount: false
offlinePush:
switch: false
title: "group info changed title" title: "group info changed title"
desc: "group info changed desc" desc: "group info changed desc"
ext: "group info changed ext" ext: "group info changed ext"
defaultTips: defaultTips:
tips: "group info changed by" # group info changed by xx tips: "group info changed by" # group info changed by xx
conversationChanged: 0
memberQuit:
conversation:
reliabilityLevel: 1
unreadCount: false
offlinePush:
switch: false
title: "group info changed title"
desc: "group info changed desc"
ext: "group info changed ext"
defaultTips:
tips: "group info changed by" # group info changed by xx
groupApplicationAccepted:
conversation:
reliabilityLevel: 1
unreadCount: false
offlinePush:
switch: false
title: "group info changed title"
desc: "group info changed desc"
ext: "group info changed ext"
defaultTips:
tips: "group info changed by" # group info changed by xx
groupApplicationRejected:
conversation:
reliabilityLevel: 1
unreadCount: false
offlinePush:
switch: false
title: "group info changed title"
desc: "group info changed desc"
ext: "group info changed ext"
defaultTips:
tips: "group info changed by" # group info changed by xx
groupOwnerTransferred:
conversation:
reliabilityLevel: 1
unreadCount: false
offlinePush:
switch: false
title: "group info changed title"
desc: "group info changed desc"
ext: "group info changed ext"
defaultTips:
tips: "group info changed by" # group info changed by xx
memberKicked:
conversation:
reliabilityLevel: 1
unreadCount: false
offlinePush:
switch: false
title: "group info changed title"
desc: "group info changed desc"
ext: "group info changed ext"
defaultTips:
tips: "group info changed by" # group info changed by xx
memberInvited:
conversation:
reliabilityLevel: 1
unreadCount: false
offlinePush:
switch: false
title: "group info changed title"
desc: "group info changed desc"
ext: "group info changed ext"
defaultTips:
tips: "group info changed by" # group info changed by xx
memberEnter:
conversation:
reliabilityLevel: 1
unreadCount: false
offlinePush:
switch: false
title: "group info changed title"
desc: "group info changed desc"
ext: "group info changed ext"
defaultTips:
tips: "group info changed by" # group info changed by xx
#############################friend#################################
friendApplicationAdded:
conversation:
reliabilityLevel: 2
unreadCount: false
offlinePush:
switch: true
title: "Somebody applies to add you as a friend"
desc: "Somebody applies to add you as a friend"
ext: "Somebody applies to add you as a friend"
defaultTips:
tips: "I applies to add you as a friend" #
friendApplicationApproved:
conversation:
reliabilityLevel: 2
unreadCount: false
offlinePush:
switch: true
title: "Someone applies to add your friend application"
desc: "Someone applies to add your friend application"
ext: "Someone applies to add your friend application"
defaultTips:
tips: "I applies to add your friend application" #
friendApplicationRejected:
conversation:
reliabilityLevel: 2
unreadCount: false
offlinePush:
switch: true
title: "Someone rejected your friend application"
desc: "Someone rejected your friend application"
ext: "Someone rejected your friend application"
defaultTips:
tips: "I rejected your friend application" #
friendAdded:
conversation:
reliabilityLevel: 3
unreadCount: true
offlinePush:
switch: true
title: "We have become friends"
desc: "We have become friends"
ext: "We have become friends"
defaultTips:
tips: "We have become friends" #
friendDeleted:
conversation:
reliabilityLevel: 2
unreadCount: false
offlinePush:
switch: true
title: "Deleted a friend"
desc: "Deleted a friend"
ext: "Deleted a friend"
defaultTips:
tips: "Deleted a friend" #
friendRemarkSet:
conversation:
reliabilityLevel: 2
unreadCount: false
offlinePush:
switch: true
title: "Your friend's profile has been changed"
desc: "Your friend's profile has been changed"
ext: "Your friend's profile has been changed"
defaultTips:
tips: "Your friend's profile has been changed" #
blackAdded:
conversation:
reliabilityLevel: 2
unreadCount: false
offlinePush:
switch: true
title: "Blocked a user"
desc: "Blocked a user"
ext: "Blocked a user"
defaultTips:
tips: "Blocked a user" #
blackDeleted:
conversation:
reliabilityLevel: 2
unreadCount: false
offlinePush:
switch: true
title: "Remove a blocked user"
desc: "Remove a blocked user"
ext: "Remove a blocked user"
defaultTips:
tips: "Remove a blocked user"
#####################user#########################
userInfoUpdated:
conversation:
reliabilityLevel: 2
unreadCount: false
offlinePush:
switch: true
title: "Remove a blocked user"
desc: "Remove a blocked user"
ext: "Remove a blocked user"
defaultTips:
tips: "Remove a blocked user"
#---------------demo configuration---------------------# #---------------demo configuration---------------------#
@ -215,9 +436,9 @@ demo:
superCode: 666666 superCode: 666666
mail: mail:
title: "openIM" title: "openIM"
senderMail: "1765567899@qq.com" senderMail: "1765567899@qq.com"
senderAuthorizationCode: "1gxyausfoevlzbfag" senderAuthorizationCode: "1gxyausfoevlzbfag"
smtpAddr: "smtp.qq.com" smtpAddr: "smtp.qq.com"
smtpPort: 25 smtpPort: 25

@ -6,7 +6,7 @@ import (
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3" "Open_IM/pkg/grpc-etcdv3/getcdv3"
"Open_IM/pkg/proto/chat" "Open_IM/pkg/proto/chat"
"Open_IM/pkg/proto/sdk_ws" open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"context" "context"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"net/http" "net/http"

@ -4,7 +4,7 @@ import (
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
pbChat "Open_IM/pkg/proto/chat" pbChat "Open_IM/pkg/proto/chat"
"Open_IM/pkg/proto/sdk_ws" open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"context" "context"
"Open_IM/pkg/grpc-etcdv3/getcdv3" "Open_IM/pkg/grpc-etcdv3/getcdv3"

@ -16,7 +16,7 @@ import (
"strings" "strings"
) )
func AddBlacklist(c *gin.Context) { func AddBlack(c *gin.Context) {
params := api.AddBlacklistReq{} params := api.AddBlacklistReq{}
if err := c.BindJSON(&params); err != nil { if err := c.BindJSON(&params); err != nil {
log.NewError("0", "BindJSON failed ", err.Error()) log.NewError("0", "BindJSON failed ", err.Error())
@ -129,7 +129,7 @@ func AddFriendResponse(c *gin.Context) {
req := &rpc.AddFriendResponseReq{CommID: &rpc.CommID{}} req := &rpc.AddFriendResponseReq{CommID: &rpc.CommID{}}
utils.CopyStructFields(req.CommID, &params.ParamsCommFriend) utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
req.HandleMsg = params.HandleMsg req.HandleMsg = params.HandleMsg
req.Flag = params.Flag req.HandleResult = params.Flag
var ok bool var ok bool
ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token")) ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
if !ok { if !ok {
@ -257,7 +257,7 @@ func SetFriendRemark(c *gin.Context) {
c.JSON(http.StatusOK, resp) c.JSON(http.StatusOK, resp)
} }
func RemoveBlacklist(c *gin.Context) { func RemoveBlack(c *gin.Context) {
params := api.RemoveBlackListReq{} params := api.RemoveBlackListReq{}
if err := c.BindJSON(&params); err != nil { if err := c.BindJSON(&params); err != nil {
log.NewError("0", "BindJSON failed ", err.Error()) log.NewError("0", "BindJSON failed ", err.Error())
@ -423,7 +423,7 @@ func GetFriendApplyList(c *gin.Context) {
c.JSON(http.StatusOK, resp) c.JSON(http.StatusOK, resp)
} }
func GetSelfApplyList(c *gin.Context) { func GetSelfFriendApplyList(c *gin.Context) {
params := api.GetSelfApplyListReq{} params := api.GetSelfApplyListReq{}
if err := c.BindJSON(&params); err != nil { if err := c.BindJSON(&params); err != nil {
log.NewError("0", "BindJSON failed ", err.Error()) log.NewError("0", "BindJSON failed ", err.Error())

@ -1,51 +1,37 @@
package apiThird package apiThird
import ( import (
api "Open_IM/pkg/base_info"
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
log2 "Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
sts "github.com/tencentyun/qcloud-cos-sts-sdk/go" sts "github.com/tencentyun/qcloud-cos-sts-sdk/go"
"net/http" "net/http"
"time" "time"
) )
type paramsTencentCloudStorageCredential struct {
Token string `json:"token"`
OperationID string `json:"operationID"`
}
var lastTime int64
var lastRes *sts.CredentialResult
func TencentCloudStorageCredential(c *gin.Context) { func TencentCloudStorageCredential(c *gin.Context) {
params := paramsTencentCloudStorageCredential{} req := api.TencentCloudStorageCredentialReq{}
if err := c.BindJSON(&params); err != nil { if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "Parameter parsing errorplease check the parameters and request service again"}) log.NewError("0", "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
} }
ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
log2.Info(params.Token, params.OperationID, "api TencentUpLoadCredential call start...") if !ok {
log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
if time.Now().Unix()-lastTime < 10 && lastRes != nil { c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
c.JSON(http.StatusOK, gin.H{
"errCode": 0,
"errMsg": "",
"region": config.Config.Credential.Tencent.Region,
"bucket": config.Config.Credential.Tencent.Bucket,
"data": lastRes,
})
return return
} }
log.NewInfo(req.OperationID, "TencentCloudStorageCredential args ", userID)
lastTime = time.Now().Unix()
cli := sts.NewClient( cli := sts.NewClient(
config.Config.Credential.Tencent.SecretID, config.Config.Credential.Tencent.SecretID,
config.Config.Credential.Tencent.SecretKey, config.Config.Credential.Tencent.SecretKey,
nil, nil,
) )
log2.Info(c.Request.Header.Get("token"), c.PostForm("optionID"), "api TencentUpLoadCredential sts.NewClient cli = %v", cli)
opt := &sts.CredentialOptions{ opt := &sts.CredentialOptions{
DurationSeconds: int64(time.Hour.Seconds()), DurationSeconds: int64(time.Hour.Seconds()),
@ -65,29 +51,15 @@ func TencentCloudStorageCredential(c *gin.Context) {
}, },
}, },
} }
log2.Info(c.Request.Header.Get("token"), c.PostForm("optionID"), "api TencentUpLoadCredential sts.CredentialOptions opt = %v", opt)
res, err := cli.GetCredential(opt) res, err := cli.GetCredential(opt)
resp := api.TencentCloudStorageCredentialResp{}
if err != nil { if err != nil {
log2.Error(c.Request.Header.Get("token"), c.PostForm("optionID"), "api TencentUpLoadCredential cli.GetCredential err = %s", err.Error()) resp.ErrCode = constant.ErrTencentCredential.ErrCode
c.JSON(http.StatusOK, gin.H{ resp.ErrMsg = err.Error()
"errCode": constant.ErrTencentCredential.ErrCode, } else {
"errMsg": err.Error(), resp.Data.Bucket = config.Config.Credential.Tencent.Bucket
"bucket": "", resp.Data.Region = config.Config.Credential.Tencent.Region
"region": "", resp.Data.CredentialResult = res
"data": res,
})
return
} }
log2.Info(c.Request.Header.Get("token"), c.PostForm("optionID"), "api TencentUpLoadCredential cli.GetCredential success res = %v, res.Credentials = %v", res, res.Credentials) c.JSON(http.StatusOK, resp)
lastRes = res
c.JSON(http.StatusOK, gin.H{
"errCode": 0,
"errMsg": "",
"region": config.Config.Credential.Tencent.Region,
"bucket": config.Config.Credential.Tencent.Bucket,
"data": res,
})
} }

@ -68,48 +68,6 @@ func (s *friendServer) Run() {
} }
} }
////
//func (s *friendServer) GetFriendsInfo(ctx context.Context, req *pbFriend.GetFriendsInfoReq) (*pbFriend.GetFriendInfoResp, error) {
// return nil, nil
//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo args ", req.String())
//// var (
//// isInBlackList int32
//// // isFriend int32
//// comment string
//// )
////
//// friendShip, err := imdb.FindFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
//// if err != nil {
//// log.NewError(req.CommID.OperationID, "FindFriendRelationshipFromFriend failed ", err.Error())
//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
//// // isFriend = constant.FriendFlag
//// }
//// comment = friendShip.Remark
////
//// friendUserInfo, err := imdb.FindUserByUID(req.CommID.ToUserID)
//// if err != nil {
//// log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error())
//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
//// }
////
//// err = imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
//// if err == nil {
//// isInBlackList = constant.BlackListFlag
//// }
////
//// resp := pbFriend.GetFriendInfoResp{ErrCode: 0, ErrMsg: "",}
////
//// utils.CopyStructFields(resp.FriendInfoList, friendUserInfo)
//// resp.Data.IsBlack = isInBlackList
//// resp.Data.OwnerUserID = req.CommID.FromUserID
//// resp.Data.Remark = comment
//// resp.Data.CreateTime = friendUserInfo.CreateTime
////
//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo ok ", resp)
//// return &resp, nil
////
//}
func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlacklistReq) (*pbFriend.AddBlacklistResp, error) { func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlacklistReq) (*pbFriend.AddBlacklistResp, error) {
log.NewInfo(req.CommID.OperationID, "AddBlacklist args ", req.String()) log.NewInfo(req.CommID.OperationID, "AddBlacklist args ", req.String())
ok := token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) ok := token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID)
@ -153,7 +111,7 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
chat.FriendApplicationAddedNotification(req) chat.FriendApplicationNotification(req)
return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{}}, nil return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{}}, nil
} }
@ -235,7 +193,7 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
log.NewError(req.CommID.OperationID, "GetFriendApplicationByBothUserID failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID) log.NewError(req.CommID.OperationID, "GetFriendApplicationByBothUserID failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID)
return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
friendRequest.HandleResult = req.Flag friendRequest.HandleResult = req.HandleResult
friendRequest.HandleTime = time.Now() friendRequest.HandleTime = time.Now()
//friendRequest.HandleTime.Unix() //friendRequest.HandleTime.Unix()
friendRequest.HandleMsg = req.HandleMsg friendRequest.HandleMsg = req.HandleMsg
@ -247,7 +205,7 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
} }
//Change the status of the friend request form //Change the status of the friend request form
if req.Flag == constant.FriendFlag { if req.HandleResult == constant.FriendFlag {
//Establish friendship after find friend relationship not exists //Establish friendship after find friend relationship not exists
_, err := imdb.GetFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID) _, err := imdb.GetFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
if err == nil { if err == nil {
@ -275,8 +233,13 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
chat.FriendAddedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID) chat.FriendAddedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
} }
} }
if req.HandleResult == constant.FriendResponseAgree {
chat.FriendApplicationProcessedNotification(req) chat.FriendApplicationApprovedNotification(req)
} else if req.HandleResult == constant.FriendResponseRefuse {
chat.FriendApplicationRejectedNotification(req)
} else {
log.Error(req.CommID.OperationID, "HandleResult failed ", req.HandleResult)
}
log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok") log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok")
return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{}}, nil return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{}}, nil
} }
@ -345,7 +308,7 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFri
return &pbFriend.SetFriendRemarkResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbFriend.SetFriendRemarkResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
log.NewInfo(req.CommID.OperationID, "rpc SetFriendComment ok") log.NewInfo(req.CommID.OperationID, "rpc SetFriendComment ok")
chat.FriendInfoChangedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID) chat.FriendRemarkSetNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
return &pbFriend.SetFriendRemarkResp{CommonResp: &pbFriend.CommonResp{}}, nil return &pbFriend.SetFriendRemarkResp{CommonResp: &pbFriend.CommonResp{}}, nil
} }
@ -442,8 +405,26 @@ func (s *friendServer) GetFriendApplyList(ctx context.Context, req *pbFriend.Get
for _, applyUserInfo := range ApplyUsersInfo { for _, applyUserInfo := range ApplyUsersInfo {
var userInfo sdkws.FriendRequest var userInfo sdkws.FriendRequest
utils.CopyStructFields(&userInfo, applyUserInfo) utils.CopyStructFields(&userInfo, applyUserInfo)
u, err := imdb.GetUserByUserID(userInfo.FromUserID)
if err != nil {
log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.FromUserID)
continue
}
userInfo.FromNickname = u.Nickname
userInfo.FromFaceURL = u.FaceURL
userInfo.FromGender = u.Gender
u, err = imdb.GetUserByUserID(userInfo.ToUserID)
if err != nil {
log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.ToUserID)
continue
}
userInfo.ToNickname = u.Nickname
userInfo.ToFaceURL = u.FaceURL
userInfo.ToGender = u.Gender
appleUserList = append(appleUserList, &userInfo) appleUserList = append(appleUserList, &userInfo)
} }
log.NewInfo(req.CommID.OperationID, "rpc GetFriendApplyList ok", pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList}) log.NewInfo(req.CommID.OperationID, "rpc GetFriendApplyList ok", pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList})
return &pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList}, nil return &pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList}, nil
} }
@ -466,8 +447,68 @@ func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetSe
for _, selfApplyOtherUserInfo := range usersInfo { for _, selfApplyOtherUserInfo := range usersInfo {
var userInfo sdkws.FriendRequest // pbFriend.ApplyUserInfo var userInfo sdkws.FriendRequest // pbFriend.ApplyUserInfo
cp.FriendRequestDBCopyOpenIM(&userInfo, &selfApplyOtherUserInfo) cp.FriendRequestDBCopyOpenIM(&userInfo, &selfApplyOtherUserInfo)
u, err := imdb.GetUserByUserID(userInfo.FromUserID)
if err != nil {
log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.FromUserID)
continue
}
userInfo.FromNickname = u.Nickname
userInfo.FromFaceURL = u.FaceURL
userInfo.FromGender = u.Gender
u, err = imdb.GetUserByUserID(userInfo.ToUserID)
if err != nil {
log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.ToUserID)
continue
}
userInfo.ToNickname = u.Nickname
userInfo.ToFaceURL = u.FaceURL
userInfo.ToGender = u.Gender
selfApplyOtherUserList = append(selfApplyOtherUserList, &userInfo) selfApplyOtherUserList = append(selfApplyOtherUserList, &userInfo)
} }
log.NewInfo(req.CommID.OperationID, "rpc GetSelfApplyList ok", pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList}) log.NewInfo(req.CommID.OperationID, "rpc GetSelfApplyList ok", pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList})
return &pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList}, nil return &pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList}, nil
} }
////
//func (s *friendServer) GetFriendsInfo(ctx context.Context, req *pbFriend.GetFriendsInfoReq) (*pbFriend.GetFriendInfoResp, error) {
// return nil, nil
//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo args ", req.String())
//// var (
//// isInBlackList int32
//// // isFriend int32
//// comment string
//// )
////
//// friendShip, err := imdb.FindFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
//// if err != nil {
//// log.NewError(req.CommID.OperationID, "FindFriendRelationshipFromFriend failed ", err.Error())
//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
//// // isFriend = constant.FriendFlag
//// }
//// comment = friendShip.Remark
////
//// friendUserInfo, err := imdb.FindUserByUID(req.CommID.ToUserID)
//// if err != nil {
//// log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error())
//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
//// }
////
//// err = imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
//// if err == nil {
//// isInBlackList = constant.BlackListFlag
//// }
////
//// resp := pbFriend.GetFriendInfoResp{ErrCode: 0, ErrMsg: "",}
////
//// utils.CopyStructFields(resp.FriendInfoList, friendUserInfo)
//// resp.Data.IsBlack = isInBlackList
//// resp.Data.OwnerUserID = req.CommID.FromUserID
//// resp.Data.Remark = comment
//// resp.Data.CreateTime = friendUserInfo.CreateTime
////
//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo ok ", resp)
//// return &resp, nil
////
//}

@ -141,12 +141,18 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
resp.ErrMsg = constant.ErrDB.ErrMsg resp.ErrMsg = constant.ErrDB.ErrMsg
return resp, nil return resp, nil
} }
chat.GroupCreatedNotification(req.OperationID, req.OpUserID, req.OwnerUserID, groupId, okUserIDList)
utils.CopyStructFields(resp.GroupInfo, group) utils.CopyStructFields(resp.GroupInfo, group)
resp.GroupInfo.MemberCount = imdb.GetGroupMemberNumByGroupID(groupId) resp.GroupInfo.MemberCount, err = imdb.GetGroupMemberNumByGroupID(groupId)
if err != nil {
log.NewError(req.OperationID, "GetGroupMemberNumByGroupID failed ", err.Error(), groupId)
resp.ErrCode = constant.ErrDB.ErrCode
resp.ErrMsg = constant.ErrDB.ErrMsg
return resp, nil
}
resp.GroupInfo.OwnerUserID = req.OwnerUserID resp.GroupInfo.OwnerUserID = req.OwnerUserID
log.NewInfo(req.OperationID, "rpc CreateGroup return ", resp.String()) log.NewInfo(req.OperationID, "rpc CreateGroup return ", resp.String())
chat.GroupCreatedNotification(req.OperationID, req.OpUserID, groupId, okUserIDList)
return resp, nil return resp, nil
} }
@ -166,7 +172,7 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
var resp pbGroup.GetJoinedGroupListResp var resp pbGroup.GetJoinedGroupListResp
for _, v := range joinedGroupList { for _, v := range joinedGroupList {
var groupNode open_im_sdk.GroupInfo var groupNode open_im_sdk.GroupInfo
num := imdb.GetGroupMemberNumByGroupID(v) num, err := imdb.GetGroupMemberNumByGroupID(v)
owner, err2 := imdb.GetGroupOwnerInfoByGroupID(v) owner, err2 := imdb.GetGroupOwnerInfoByGroupID(v)
group, err := imdb.GetGroupInfoByGroupID(v) group, err := imdb.GetGroupInfoByGroupID(v)
if num > 0 && owner != nil && err2 == nil && group != nil && err == nil { if num > 0 && owner != nil && err2 == nil && group != nil && err == nil {
@ -228,7 +234,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
toInsertInfo.OperatorUserID = req.OpUserID toInsertInfo.OperatorUserID = req.OpUserID
err = imdb.InsertIntoGroupMember(toInsertInfo) err = imdb.InsertIntoGroupMember(toInsertInfo)
if err != nil { if err != nil {
log.NewError(req.OperationID, "InsertIntoGroupMember failed ", req.GroupID, toUserInfo.UserID, toUserInfo.Nickname, toUserInfo.FaceUrl) log.NewError(req.OperationID, "InsertIntoGroupMember failed ", req.GroupID, toUserInfo.UserID, toUserInfo.Nickname, toUserInfo.FaceURL)
resultNode.Result = -1 resultNode.Result = -1
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue continue
@ -401,8 +407,21 @@ func (s *groupServer) GetGroupApplicationList(_ context.Context, req *pbGroup.Ge
log.NewDebug(req.OperationID, "GetGroupApplicationList reply ", reply) log.NewDebug(req.OperationID, "GetGroupApplicationList reply ", reply)
resp := pbGroup.GetGroupApplicationListResp{} resp := pbGroup.GetGroupApplicationListResp{}
for _, v := range reply { for _, v := range reply {
var node open_im_sdk.GroupRequest node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
group, err := imdb.GetGroupInfoByGroupID(v.GroupID)
if err != nil {
log.Error(req.OperationID, "GetGroupInfoByGroupID failed ", err.Error(), v.GroupID)
continue
}
user, err := imdb.GetUserByUserID(v.UserID)
if err != nil {
log.Error(req.OperationID, "GetUserByUserID failed ", err.Error(), v.UserID)
continue
}
cp.GroupRequestDBCopyOpenIM(&node, &v) cp.GroupRequestDBCopyOpenIM(&node, &v)
cp.UserDBCopyOpenIMPublicUser(node.UserInfo, user)
cp.GroupDBCopyOpenIM(node.GroupInfo, group)
log.NewDebug(req.OperationID, "node ", node, "v ", v) log.NewDebug(req.OperationID, "node ", node, "v ", v)
resp.GroupRequestList = append(resp.GroupRequestList, &node) resp.GroupRequestList = append(resp.GroupRequestList, &node)
} }
@ -447,8 +466,6 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), groupRequest) log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), groupRequest)
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
chat.ApplicationProcessedNotification(req)
if req.HandleResult == constant.GroupResponseAgree {
if req.HandleResult == constant.GroupResponseAgree { if req.HandleResult == constant.GroupResponseAgree {
user, err := imdb.GetUserByUserID(req.FromUserID) user, err := imdb.GetUserByUserID(req.FromUserID)
@ -461,7 +478,7 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
member.UserID = req.FromUserID member.UserID = req.FromUserID
member.RoleLevel = constant.GroupOrdinaryUsers member.RoleLevel = constant.GroupOrdinaryUsers
member.OperatorUserID = req.OpUserID member.OperatorUserID = req.OpUserID
member.FaceUrl = user.FaceUrl member.FaceUrl = user.FaceURL
member.Nickname = user.Nickname member.Nickname = user.Nickname
err = imdb.InsertIntoGroupMember(member) err = imdb.InsertIntoGroupMember(member)
@ -469,8 +486,13 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), member) log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), member)
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
} chat.GroupApplicationAcceptedNotification(req)
chat.MemberEnterNotification(req) chat.MemberEnterNotification(req)
} else if req.HandleResult == constant.GroupResponseRefuse {
chat.GroupApplicationRejectedNotification(req)
} else {
log.Error(req.OperationID, "HandleResult failed ", req.HandleResult)
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}}, nil
} }
log.NewInfo(req.OperationID, "rpc GroupApplicationResponse return ", pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{}}) log.NewInfo(req.OperationID, "rpc GroupApplicationResponse return ", pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{}})
@ -502,7 +524,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
} }
chat.JoinApplicationNotification(req) chat.JoinGroupApplicationNotification(req)
log.NewInfo(req.OperationID, "ReceiveJoinApplicationNotification rpc return ") log.NewInfo(req.OperationID, "ReceiveJoinApplicationNotification rpc return ")
return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
@ -528,7 +550,7 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
// return &pbGroup.CommonResp{ErrorCode: constant.ErrQuitGroup.ErrCode, ErrorMsg: constant.ErrQuitGroup.ErrMsg}, nil // return &pbGroup.CommonResp{ErrorCode: constant.ErrQuitGroup.ErrCode, ErrorMsg: constant.ErrQuitGroup.ErrMsg}, nil
} }
chat.MemberLeaveNotification(req) chat.MemberQuitNotification(req)
log.NewInfo(req.OperationID, "rpc QuitGroup return ", pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}) log.NewInfo(req.OperationID, "rpc QuitGroup return ", pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}})
return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
} }
@ -584,11 +606,10 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
log.NewError(req.OperationID, "SetGroupInfo failed ", err.Error(), groupInfo) log.NewError(req.OperationID, "SetGroupInfo failed ", err.Error(), groupInfo)
return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
log.NewInfo(req.OperationID, "SetGroupInfo rpc return ", pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}})
if changedType != 0 { if changedType != 0 {
chat.GroupInfoChangedNotification(req.OperationID, req.OpUserID, req.GroupInfo.GroupID, changedType) chat.GroupInfoSetNotification(req.OperationID, req.OpUserID, req.GroupInfo.GroupID)
} }
log.NewInfo(req.OperationID, "SetGroupInfo rpc return ", pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}})
return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}}, nil return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}}, nil
} }
@ -611,8 +632,7 @@ func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.Transfe
log.NewError(req.OperationID, "UpdateGroupMemberInfo failed ", groupMemberInfo) log.NewError(req.OperationID, "UpdateGroupMemberInfo failed ", groupMemberInfo)
return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
changedType := int32(1) << 4 chat.GroupOwnerTransferredNotification(req)
chat.GroupInfoChangedNotification(req.OperationID, req.OpUserID, req.GroupID, changedType)
return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil

@ -0,0 +1,154 @@
package msg
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
utils2 "Open_IM/pkg/common/utils"
pbFriend "Open_IM/pkg/proto/friend"
open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"github.com/golang/protobuf/proto"
)
func getFromToUserNickname(fromUserID, toUserID string) (string, string, error) {
from, err := imdb.GetUserByUserID(fromUserID)
if err != nil {
return "", "", utils.Wrap(err, "")
}
to, err := imdb.GetUserByUserID(toUserID)
if err != nil {
return "", "", utils.Wrap(err, "")
}
return from.Nickname, to.Nickname, nil
}
func friendNotification(commID *pbFriend.CommID, contentType int32, m proto.Message) {
log.Info(commID.OperationID, utils.GetSelfFuncName(), "args: ", commID, contentType)
var err error
var tips open_im_sdk.TipsComm
tips.Detail, err = proto.Marshal(m)
if err != nil {
log.Error(commID.OperationID, "Marshal failed ", err.Error(), m.String())
return
}
fromUserNickname, toUserNickname, err := getFromToUserNickname(commID.FromUserID, commID.ToUserID)
if err != nil {
log.Error(commID.OperationID, "getFromToUserNickname failed ", err.Error(), commID.FromUserID, commID.ToUserID)
return
}
cn := config.Config.Notification
switch contentType {
case constant.FriendApplicationNotification:
tips.DefaultTips = fromUserNickname + cn.FriendApplication.DefaultTips.Tips
case constant.FriendApplicationApprovedNotification:
tips.DefaultTips = fromUserNickname + cn.FriendApplicationApproved.DefaultTips.Tips
case constant.FriendApplicationRejectedNotification:
tips.DefaultTips = fromUserNickname + cn.FriendApplicationRejected.DefaultTips.Tips
case constant.FriendAddedNotification:
tips.DefaultTips = cn.FriendAdded.DefaultTips.Tips
case constant.FriendDeletedNotification:
tips.DefaultTips = cn.FriendDeleted.DefaultTips.Tips + toUserNickname
case constant.FriendRemarkSetNotification:
tips.DefaultTips = fromUserNickname + cn.FriendRemarkSet.DefaultTips.Tips
case constant.BlackAddedNotification:
tips.DefaultTips = cn.BlackAdded.DefaultTips.Tips + toUserNickname
case constant.BlackDeletedNotification:
tips.DefaultTips = cn.BlackDeleted.DefaultTips.Tips + toUserNickname
default:
log.Error(commID.OperationID, "contentType failed ", contentType)
return
}
var n NotificationMsg
n.SendID = commID.FromUserID
n.RecvID = commID.ToUserID
n.ContentType = contentType
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = commID.OperationID
n.Content, err = proto.Marshal(&tips)
if err != nil {
log.Error(commID.OperationID, "Marshal failed ", err.Error(), tips.String())
return
}
Notification(&n)
}
func FriendApplicationNotification(req *pbFriend.AddFriendReq) {
FriendApplicationTips := open_im_sdk.FriendApplicationTips{FromToUserID: &open_im_sdk.FromToUserID{}}
FriendApplicationTips.FromToUserID.FromUserID = req.CommID.FromUserID
FriendApplicationTips.FromToUserID.ToUserID = req.CommID.ToUserID
friendNotification(req.CommID, constant.FriendApplicationNotification, &FriendApplicationTips)
}
func FriendApplicationApprovedNotification(req *pbFriend.AddFriendResponseReq) {
FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
FriendApplicationApprovedTips.FromToUserID.FromUserID = req.CommID.FromUserID
FriendApplicationApprovedTips.FromToUserID.ToUserID = req.CommID.ToUserID
FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
friendNotification(req.CommID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
}
func FriendApplicationRejectedNotification(req *pbFriend.AddFriendResponseReq) {
FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
FriendApplicationApprovedTips.FromToUserID.FromUserID = req.CommID.FromUserID
FriendApplicationApprovedTips.FromToUserID.ToUserID = req.CommID.ToUserID
FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
friendNotification(req.CommID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
}
func FriendAddedNotification(operationID, opUserID, fromUserID, toUserID string) {
friendAddedTips := open_im_sdk.FriendAddedTips{Friend: &open_im_sdk.FriendInfo{}, OpUser: &open_im_sdk.PublicUserInfo{}}
user, err := imdb.GetUserByUserID(opUserID)
if err != nil {
log.NewError(operationID, "GetUserByUserID failed ", err.Error(), opUserID)
return
}
utils2.UserDBCopyOpenIMPublicUser(friendAddedTips.OpUser, user)
friend, err := imdb.GetFriendRelationshipFromFriend(fromUserID, toUserID)
if err != nil {
log.NewError(operationID, "GetFriendRelationshipFromFriend failed ", err.Error(), fromUserID, toUserID)
return
}
utils2.FriendDBCopyOpenIM(friendAddedTips.Friend, friend)
commID := pbFriend.CommID{FromUserID: fromUserID, ToUserID: toUserID, OpUserID: opUserID, OperationID: operationID}
friendNotification(&commID, constant.FriendAddedNotification, &friendAddedTips)
}
func FriendDeletedNotification(req *pbFriend.DeleteFriendReq) {
friendDeletedTips := open_im_sdk.FriendDeletedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
friendDeletedTips.FromToUserID.FromUserID = req.CommID.FromUserID
friendDeletedTips.FromToUserID.ToUserID = req.CommID.ToUserID
friendNotification(req.CommID, constant.FriendDeletedNotification, &friendDeletedTips)
}
func FriendRemarkSetNotification(operationID, opUserID, fromUserID, toUserID string) {
friendInfoChangedTips := open_im_sdk.FriendInfoChangedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
friendInfoChangedTips.FromToUserID.FromUserID = fromUserID
friendInfoChangedTips.FromToUserID.ToUserID = toUserID
commID := pbFriend.CommID{FromUserID: fromUserID, ToUserID: toUserID, OpUserID: opUserID, OperationID: operationID}
friendNotification(&commID, constant.FriendRemarkSetNotification, &friendInfoChangedTips)
}
func BlackAddedNotification(req *pbFriend.AddBlacklistReq) {
blackAddedTips := open_im_sdk.BlackAddedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
blackAddedTips.FromToUserID.FromUserID = req.CommID.FromUserID
blackAddedTips.FromToUserID.ToUserID = req.CommID.ToUserID
friendNotification(req.CommID, constant.BlackAddedNotification, &blackAddedTips)
}
func BlackDeletedNotification(req *pbFriend.RemoveBlacklistReq) {
blackDeletedTips := open_im_sdk.BlackDeletedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
blackDeletedTips.FromToUserID.FromUserID = req.CommID.FromUserID
blackDeletedTips.FromToUserID.ToUserID = req.CommID.ToUserID
friendNotification(req.CommID, constant.BlackDeletedNotification, &blackDeletedTips)
}
func UserInfoUpdatedNotification(operationID, userID string, needNotifiedUserID string) {
selfInfoUpdatedTips := open_im_sdk.UserInfoUpdatedTips{UserID: userID}
commID := pbFriend.CommID{FromUserID: userID, ToUserID: userID, OpUserID: needNotifiedUserID, OperationID: operationID}
friendNotification(&commID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
}

@ -0,0 +1,368 @@
package msg
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
utils2 "Open_IM/pkg/common/utils"
pbGroup "Open_IM/pkg/proto/group"
open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"github.com/golang/protobuf/proto"
)
//message GroupCreatedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo Creator = 2;
// repeated GroupMemberFullInfo MemberList = 3;
// uint64 OperationTime = 4;
//} creator->group
func setOpUserInfo(opUserID, groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) error {
if token_verify.IsMangerUserID(opUserID) {
u, err := imdb.GetUserByUserID(opUserID)
if err != nil {
return utils.Wrap(err, "GetUserByUserID failed")
}
utils.CopyStructFields(groupMemberInfo, u)
groupMemberInfo.GroupID = groupID
} else {
u, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, opUserID)
if err != nil {
return utils.Wrap(err, "GetGroupMemberInfoByGroupIDAndUserID failed")
}
if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, u); err != nil {
return utils.Wrap(err, "")
}
}
return nil
}
func setGroupInfo(groupID string, groupInfo *open_im_sdk.GroupInfo) error {
group, err := imdb.GetGroupInfoByGroupID(groupID)
if err != nil {
return utils.Wrap(err, "GetGroupInfoByGroupID failed")
}
err = utils2.GroupDBCopyOpenIM(groupInfo, group)
if err != nil {
return utils.Wrap(err, "GetGroupMemberNumByGroupID failed")
}
return nil
}
func setGroupMemberInfo(groupID, userID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) error {
groupMember, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
if err != nil {
return utils.Wrap(err, "")
}
if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember); err != nil {
return utils.Wrap(err, "")
}
return nil
}
func setGroupOwnerInfo(groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) error {
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(groupID)
if err != nil {
return utils.Wrap(err, "")
}
if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember); err != nil {
return utils.Wrap(err, "")
}
return nil
}
func setPublicUserInfo(userID string, publicUserInfo *open_im_sdk.PublicUserInfo) error {
user, err := imdb.GetUserByUserID(userID)
if err != nil {
return utils.Wrap(err, "")
}
utils2.UserDBCopyOpenIMPublicUser(publicUserInfo, user)
return nil
}
func groupNotification(contentType int32, m proto.Message, sendID, groupID, recvUserID, operationID string) {
log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType)
var err error
var tips open_im_sdk.TipsComm
tips.Detail, err = proto.Marshal(m)
if err != nil {
log.Error(operationID, "Marshal failed ", err.Error(), m.String())
return
}
cn := config.Config.Notification
switch contentType {
case constant.GroupCreatedNotification:
tips.DefaultTips = cn.GroupCreated.DefaultTips.Tips
case constant.GroupInfoSetNotification:
case constant.JoinGroupApplicationNotification:
case constant.MemberQuitNotification:
case constant.GroupApplicationAcceptedNotification:
case constant.GroupApplicationRejectedNotification:
case constant.GroupOwnerTransferredNotification:
case constant.MemberKickedNotification:
case constant.MemberInvitedNotification:
default:
log.Error(operationID, "contentType failed ", contentType)
return
}
var n NotificationMsg
n.SendID = sendID
if groupID != "" {
n.RecvID = groupID
n.SessionType = constant.GroupChatType
} else {
n.RecvID = recvUserID
n.SessionType = constant.SingleChatType
}
n.ContentType = contentType
n.OperationID = operationID
n.Content, err = proto.Marshal(&tips)
if err != nil {
log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
return
}
Notification(&n)
}
//创建群后调用
func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberList []string) {
GroupCreatedTips := open_im_sdk.GroupCreatedTips{Group: &open_im_sdk.GroupInfo{},
OpUser: &open_im_sdk.GroupMemberFullInfo{}, GroupOwnerUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setOpUserInfo(opUserID, groupID, GroupCreatedTips.OpUser); err != nil {
log.NewError(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, GroupCreatedTips.OpUser)
return
}
err := setGroupInfo(groupID, GroupCreatedTips.Group)
if err != nil {
log.Error(operationID, "setGroupInfo failed ", groupID, GroupCreatedTips.Group)
return
}
imdb.GetGroupOwnerInfoByGroupID(groupID)
if err := setGroupOwnerInfo(groupID, GroupCreatedTips.GroupOwnerUser); err != nil {
log.Error(operationID, "setGroupOwnerInfo failed", err.Error(), groupID)
return
}
for _, v := range initMemberList {
var groupMemberInfo open_im_sdk.GroupMemberFullInfo
if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, v)
continue
}
GroupCreatedTips.MemberList = append(GroupCreatedTips.MemberList, &groupMemberInfo)
}
groupNotification(constant.GroupCreatedNotification, &GroupCreatedTips, opUserID, groupID, "", operationID)
}
//群信息改变后掉用
func GroupInfoSetNotification(operationID, opUserID, groupID string) {
GroupInfoChangedTips := open_im_sdk.GroupInfoSetTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(groupID, GroupInfoChangedTips.Group); err != nil {
log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
return
}
if err := setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil {
log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
return
}
groupNotification(constant.GroupInfoSetNotification, &GroupInfoChangedTips, opUserID, groupID, "", operationID)
}
//message ReceiveJoinApplicationTips{
// GroupInfo Group = 1;
// PublicUserInfo Applicant = 2;
// string Reason = 3;
//} apply->all managers GroupID string `protobuf:"bytes,1,opt,name=GroupID" json:"GroupID,omitempty"`
// ReqMessage string `protobuf:"bytes,2,opt,name=ReqMessage" json:"ReqMessage,omitempty"`
// OpUserID string `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"`
// OperationID string `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"`
//申请进群后调用
func JoinGroupApplicationNotification(req *pbGroup.JoinGroupReq) {
JoinGroupApplicationTips := open_im_sdk.JoinGroupApplicationTips{Group: &open_im_sdk.GroupInfo{}, Applicant: &open_im_sdk.PublicUserInfo{}}
err := setGroupInfo(req.GroupID, JoinGroupApplicationTips.Group)
if err != nil {
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
return
}
if err = setPublicUserInfo(req.OpUserID, JoinGroupApplicationTips.Applicant); err != nil {
log.Error(req.OperationID, "setPublicUserInfo failed ", err.Error(), req.OpUserID)
return
}
JoinGroupApplicationTips.ReqMsg = req.ReqMessage
managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
if err != nil {
log.NewError(req.OperationID, "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID)
return
}
for _, v := range managerList {
groupNotification(constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, req.OpUserID, "", v.UserID, req.OperationID)
log.NewInfo(req.OperationID, "Notification ", v)
}
}
func MemberQuitNotification(req *pbGroup.QuitGroupReq) {
MemberQuitTips := open_im_sdk.MemberQuitTips{Group: &open_im_sdk.GroupInfo{}, QuitUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, MemberQuitTips.Group); err != nil {
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberQuitTips.QuitUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID)
return
}
groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, req.GroupID, "", req.OperationID)
groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, "", req.OpUserID, req.OperationID)
}
//message ApplicationProcessedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo OpUser = 2;
// int32 Result = 3;
// string Reason = 4;
//}
//处理进群请求后调用
func GroupApplicationAcceptedNotification(req *pbGroup.GroupApplicationResponseReq) {
GroupApplicationAcceptedTips := open_im_sdk.GroupApplicationAcceptedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
if err := setGroupInfo(req.GroupID, GroupApplicationAcceptedTips.Group); err != nil {
log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationAcceptedTips.Group)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser)
return
}
groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
}
func GroupApplicationRejectedNotification(req *pbGroup.GroupApplicationResponseReq) {
GroupApplicationRejectedTips := open_im_sdk.GroupApplicationRejectedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
if err := setGroupInfo(req.GroupID, GroupApplicationRejectedTips.Group); err != nil {
log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationRejectedTips.Group)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser)
return
}
groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
}
func GroupOwnerTransferredNotification(req *pbGroup.TransferGroupOwnerReq) {
GroupOwnerTransferredTips := open_im_sdk.GroupOwnerTransferredTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}, NewGroupOwner: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, GroupOwnerTransferredTips.Group); err != nil {
log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupOwnerTransferredTips.OpUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID)
return
}
if err := setGroupMemberInfo(req.GroupID, req.NewOwnerUserID, GroupOwnerTransferredTips.NewGroupOwner); err != nil {
log.Error(req.OperationID, "setGroupMemberInfo failed", req.GroupID, req.NewOwnerUserID)
return
}
groupNotification(constant.GroupOwnerTransferredNotification, &GroupOwnerTransferredTips, req.OpUserID, "", req.NewOwnerUserID, req.OperationID)
}
//message MemberKickedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo OpUser = 2;
// GroupMemberFullInfo KickedUser = 3;
// uint64 OperationTime = 4;
//}
//被踢后调用
func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
MemberKickedTips := open_im_sdk.MemberKickedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, MemberKickedTips.Group); err != nil {
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberKickedTips.OpUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID)
return
}
for _, v := range kickedUserIDList {
var groupMemberInfo open_im_sdk.GroupMemberFullInfo
if err := setGroupMemberInfo(req.GroupID, v, &groupMemberInfo); err != nil {
log.Error(req.OperationID, "setGroupMemberInfo failed ", err.Error(), req.GroupID, v)
continue
}
MemberKickedTips.KickedUserList = append(MemberKickedTips.KickedUserList, &groupMemberInfo)
}
groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, req.GroupID, "", req.OperationID)
for _, v := range kickedUserIDList {
groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, "", v, req.OperationID)
}
}
//message MemberInvitedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo OpUser = 2;
// GroupMemberFullInfo InvitedUser = 3;
// uint64 OperationTime = 4;
//}
//被邀请进群后调用
func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) {
MemberInvitedTips := open_im_sdk.MemberInvitedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(groupID, MemberInvitedTips.Group); err != nil {
log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
return
}
if err := setOpUserInfo(opUserID, groupID, MemberInvitedTips.OpUser); err != nil {
log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
return
}
for _, v := range invitedUserIDList {
var groupMemberInfo open_im_sdk.GroupMemberFullInfo
if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID)
continue
}
MemberInvitedTips.InvitedUserList = append(MemberInvitedTips.InvitedUserList, &groupMemberInfo)
}
groupNotification(constant.MemberInvitedNotification, &MemberInvitedTips, opUserID, groupID, "", operationID)
}
//message GroupInfoChangedTips{
// int32 ChangedType = 1; //bitwise operators: 1:groupName; 10:Notification 100:Introduction; 1000:FaceUrl
// GroupInfo Group = 2;
// GroupMemberFullInfo OpUser = 3;
//}
//message MemberLeaveTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo LeaverUser = 2;
// uint64 OperationTime = 3;
//}
//群成员退群后调用
//message MemberEnterTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo EntrantUser = 2;
// uint64 OperationTime = 3;
//}
//群成员主动申请进群,管理员同意后调用,
func MemberEnterNotification(req *pbGroup.GroupApplicationResponseReq) {
MemberEnterTips := open_im_sdk.MemberEnterTips{Group: &open_im_sdk.GroupInfo{}, EntrantUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, MemberEnterTips.Group); err != nil {
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, MemberEnterTips.Group)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberEnterTips.EntrantUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberEnterTips.EntrantUser)
return
}
groupNotification(constant.MemberEnterNotification, &MemberEnterTips, req.OpUserID, req.GroupID, "", req.OperationID)
}

@ -1,616 +0,0 @@
package msg
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
pbFriend "Open_IM/pkg/proto/friend"
pbGroup "Open_IM/pkg/proto/group"
open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"encoding/json"
)
//message GroupCreatedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo Creator = 2;
// repeated GroupMemberFullInfo MemberList = 3;
// uint64 OperationTime = 4;
//} creator->group
func setOpUserInfo(operationID, opUserID, groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) {
return
if token_verify.IsMangerUserID(opUserID) {
u, err := imdb.GetUserByUserID(opUserID)
if err != nil {
log.NewError(operationID, "FindUserByUID failed ", err.Error(), opUserID)
return
}
utils.CopyStructFields(groupMemberInfo, u)
groupMemberInfo.AppMangerLevel = 1
} else {
u, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, opUserID)
if err != nil {
log.NewError(operationID, "FindGroupMemberInfoByGroupIdAndUserId failed ", err.Error(), groupID, opUserID)
return
}
utils.CopyStructFields(groupMemberInfo, u)
}
}
func setGroupInfo(operationID, groupID string, groupInfo *open_im_sdk.GroupInfo, ownerUserID string) {
return
group, err := imdb.GetGroupInfoByGroupID(groupID)
if err != nil {
log.NewError(operationID, "FindGroupInfoByGroupId failed ", err.Error(), groupID)
return
}
utils.CopyStructFields(groupInfo, group)
if ownerUserID != "" {
groupInfo.OwnerUserID = ownerUserID
// setGroupPublicUserInfo(operationID, groupID, ownerUserID, groupInfo.Owner)
}
}
func setGroupMemberInfo(operationID, groupID, userID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) {
return
group, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
if err != nil {
log.NewError(operationID, "FindGroupMemberInfoByGroupIdAndUserId failed ", err.Error(), groupID, userID)
return
}
utils.CopyStructFields(groupMemberInfo, group)
}
//func setGroupPublicUserInfo(operationID, groupID, userID string, publicUserInfo *open_im_sdk.PublicUserInfo) {
// group, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
// if err != nil {
// log.NewError(operationID, "FindGroupMemberInfoByGroupIdAndUserId failed ", err.Error(), groupID, userID)
// return
// }
// utils.CopyStructFields(publicUserInfo, group)
//}
//创建群后调用
func GroupCreatedNotification(operationID, opUserID, OwnerUserID, groupID string, initMemberList []string) {
return
var n NotificationMsg
n.SendID = opUserID
n.RecvID = groupID
n.ContentType = constant.GroupCreatedNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = operationID
GroupCreatedTips := open_im_sdk.GroupCreatedTips{Group: &open_im_sdk.GroupInfo{},
Creator: &open_im_sdk.GroupMemberFullInfo{}}
setOpUserInfo(operationID, GroupCreatedTips.Creator.UserID, groupID, GroupCreatedTips.Creator)
setGroupInfo(operationID, groupID, GroupCreatedTips.Group, OwnerUserID)
for _, v := range initMemberList {
var groupMemberInfo open_im_sdk.GroupMemberFullInfo
setGroupMemberInfo(operationID, groupID, v, &groupMemberInfo)
GroupCreatedTips.MemberList = append(GroupCreatedTips.MemberList, &groupMemberInfo)
}
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(GroupCreatedTips)
tips.DefaultTips = config.Config.Notification.GroupCreated.DefaultTips.Tips
n.Content, _ = json.Marshal(tips)
Notification(&n, false)
}
//message ReceiveJoinApplicationTips{
// GroupInfo Group = 1;
// PublicUserInfo Applicant = 2;
// string Reason = 3;
//} apply->all managers GroupID string `protobuf:"bytes,1,opt,name=GroupID" json:"GroupID,omitempty"`
// ReqMessage string `protobuf:"bytes,2,opt,name=ReqMessage" json:"ReqMessage,omitempty"`
// OpUserID string `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"`
// OperationID string `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"`
//申请进群后调用
func JoinApplicationNotification(req *pbGroup.JoinGroupReq) {
return
managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
if err != nil {
log.NewError(req.OperationID, "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID)
return
}
var n NotificationMsg
n.SendID = req.OpUserID
n.ContentType = constant.JoinApplicationNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.OperationID
JoinGroupApplicationTips := open_im_sdk.JoinGroupApplicationTips{Group: &open_im_sdk.GroupInfo{}, Applicant: &open_im_sdk.PublicUserInfo{}}
setGroupInfo(req.OperationID, req.GroupID, JoinGroupApplicationTips.Group, "")
apply, err := imdb.GetUserByUserID(req.OpUserID)
if err != nil {
log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.OpUserID)
return
}
utils.CopyStructFields(JoinGroupApplicationTips.Applicant, apply)
JoinGroupApplicationTips.Reason = req.ReqMessage
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(JoinGroupApplicationTips)
tips.DefaultTips = "JoinGroupApplicationTips"
n.Content, _ = json.Marshal(tips)
for _, v := range managerList {
n.RecvID = v.UserID
Notification(&n, true)
}
}
//message ApplicationProcessedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo OpUser = 2;
// int32 Result = 3;
// string Reason = 4;
//}
//处理进群请求后调用
func ApplicationProcessedNotification(req *pbGroup.GroupApplicationResponseReq) {
return
var n NotificationMsg
n.SendID = req.OpUserID
n.ContentType = constant.ApplicationProcessedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.OperationID
n.RecvID = req.FromUserID
ApplicationProcessedTips := open_im_sdk.ApplicationProcessedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
setGroupInfo(req.OperationID, req.GroupID, ApplicationProcessedTips.Group, "")
setOpUserInfo(req.OperationID, req.OpUserID, req.GroupID, ApplicationProcessedTips.OpUser)
ApplicationProcessedTips.Reason = req.HandledMsg
ApplicationProcessedTips.Result = req.HandleResult
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(ApplicationProcessedTips)
tips.DefaultTips = "ApplicationProcessedNotification"
n.Content, _ = json.Marshal(tips)
Notification(&n, true)
}
//message MemberInvitedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo OpUser = 2;
// GroupMemberFullInfo InvitedUser = 3;
// uint64 OperationTime = 4;
//}
//被邀请进群后调用
func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) {
return
var n NotificationMsg
n.SendID = opUserID
n.ContentType = constant.MemberInvitedNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = operationID
ApplicationProcessedTips := open_im_sdk.MemberInvitedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
setGroupInfo(operationID, groupID, ApplicationProcessedTips.Group, "")
setOpUserInfo(operationID, opUserID, groupID, ApplicationProcessedTips.OpUser)
for _, v := range invitedUserIDList {
var groupMemberInfo open_im_sdk.GroupMemberFullInfo
setGroupMemberInfo(operationID, groupID, v, &groupMemberInfo)
ApplicationProcessedTips.InvitedUserList = append(ApplicationProcessedTips.InvitedUserList, &groupMemberInfo)
}
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(ApplicationProcessedTips)
tips.DefaultTips = "MemberInvitedNotification"
n.Content, _ = json.Marshal(tips)
n.RecvID = groupID
Notification(&n, true)
}
//message MemberKickedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo OpUser = 2;
// GroupMemberFullInfo KickedUser = 3;
// uint64 OperationTime = 4;
//}
//被踢后调用
func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
return
var n NotificationMsg
n.SendID = req.OpUserID
n.ContentType = constant.MemberKickedNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.OperationID
MemberKickedTips := open_im_sdk.MemberKickedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
setGroupInfo(req.OperationID, req.GroupID, MemberKickedTips.Group, "")
setOpUserInfo(req.OperationID, req.OpUserID, req.GroupID, MemberKickedTips.OpUser)
for _, v := range kickedUserIDList {
var groupMemberInfo open_im_sdk.GroupMemberFullInfo
setGroupMemberInfo(req.OperationID, req.GroupID, v, &groupMemberInfo)
MemberKickedTips.KickedUserList = append(MemberKickedTips.KickedUserList, &groupMemberInfo)
}
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(MemberKickedTips)
tips.DefaultTips = "MemberKickedNotification"
n.Content, _ = json.Marshal(tips)
n.RecvID = req.GroupID
Notification(&n, true)
for _, v := range kickedUserIDList {
n.SessionType = constant.SingleChatType
n.RecvID = v
Notification(&n, true)
}
}
//message GroupInfoChangedTips{
// int32 ChangedType = 1; //bitwise operators: 1:groupName; 10:Notification 100:Introduction; 1000:FaceUrl
// GroupInfo Group = 2;
// GroupMemberFullInfo OpUser = 3;
//}
//群信息改变后掉用
func GroupInfoChangedNotification(operationID, opUserID, groupID string, changedType int32) {
return
var n NotificationMsg
n.SendID = opUserID
n.ContentType = constant.GroupInfoChangedNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = operationID
GroupInfoChangedTips := open_im_sdk.GroupInfoChangedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
setGroupInfo(operationID, groupID, GroupInfoChangedTips.Group, opUserID)
setOpUserInfo(operationID, opUserID, groupID, GroupInfoChangedTips.OpUser)
GroupInfoChangedTips.ChangedType = changedType
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(GroupInfoChangedTips)
tips.DefaultTips = "GroupInfoChangedNotification"
n.Content, _ = json.Marshal(tips)
n.RecvID = groupID
Notification(&n, false)
}
/*
func GroupInfoChangedNotification(operationID string, changedType int32, group *immysql.Group, opUser *immysql.GroupMember) {
var n NotificationMsg
n.SendID = opUser.UserID
n.RecvID = group.GroupID
n.ContentType = constant.ChangeGroupInfoTip
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = operationID
var groupInfoChanged open_im_sdk.GroupInfoChangedTips
groupInfoChanged.Group = &open_im_sdk.GroupInfo{}
utils.CopyStructFields(groupInfoChanged.Group, group)
groupInfoChanged.OpUser = &open_im_sdk.GroupMemberFullInfo{}
utils.CopyStructFields(groupInfoChanged.OpUser, opUser)
groupInfoChanged.ChangedType = changedType
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(groupInfoChanged)
tips.DefaultTips = config.Config.Notification.GroupInfoChanged.DefaultTips.Tips
n.Content, _ = json.Marshal(tips)
Notification(&n, false)
}
*/
//message MemberLeaveTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo LeaverUser = 2;
// uint64 OperationTime = 3;
//}
//群成员退群后调用
func MemberLeaveNotification(req *pbGroup.QuitGroupReq) {
return
var n NotificationMsg
n.SendID = req.OpUserID
n.ContentType = constant.MemberLeaveNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.OperationID
MemberLeaveTips := open_im_sdk.MemberLeaveTips{Group: &open_im_sdk.GroupInfo{}, LeaverUser: &open_im_sdk.GroupMemberFullInfo{}}
setGroupInfo(req.OperationID, req.GroupID, MemberLeaveTips.Group, "")
setOpUserInfo(req.OperationID, req.OpUserID, req.GroupID, MemberLeaveTips.LeaverUser)
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(MemberLeaveTips)
tips.DefaultTips = "MemberLeaveNotification"
n.Content, _ = json.Marshal(tips)
n.RecvID = req.GroupID
Notification(&n, true)
n.SessionType = constant.SingleChatType
n.RecvID = req.OpUserID
Notification(&n, true)
}
//message MemberEnterTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo EntrantUser = 2;
// uint64 OperationTime = 3;
//}
//群成员主动申请进群,管理员同意后调用,
func MemberEnterNotification(req *pbGroup.GroupApplicationResponseReq) {
return
var n NotificationMsg
n.SendID = req.OpUserID
n.ContentType = constant.MemberEnterNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.OperationID
MemberLeaveTips := open_im_sdk.MemberEnterTips{Group: &open_im_sdk.GroupInfo{}, EntrantUser: &open_im_sdk.GroupMemberFullInfo{}}
setGroupInfo(req.OperationID, req.GroupID, MemberLeaveTips.Group, "")
setOpUserInfo(req.OperationID, req.OpUserID, req.GroupID, MemberLeaveTips.EntrantUser)
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(MemberLeaveTips)
tips.DefaultTips = "MemberEnterNotification"
n.Content, _ = json.Marshal(tips)
n.RecvID = req.GroupID
Notification(&n, true)
}
//message MemberInfoChangedTips{
// int32 ChangeType = 1; //1:info changed; 2:mute
// GroupMemberFullInfo OpUser = 2; //who do this
// GroupMemberFullInfo FinalInfo = 3; //
// uint64 MuteTime = 4;
// GroupInfo Group = 5;
//}
//func MemberInfoChangedNotification(operationID string, group *immysql.Group, opUser *immysql.GroupMember, userFinalInfo *immysql.GroupMember) {
//}
//message FriendApplicationAddedTips{
// PublicUserInfo OpUser = 1; //user1
// FriendApplication Application = 2;
// PublicUserInfo OpedUser = 3; //user2
//}
func getFromToUserNickname(operationID, fromUserID, toUserID string) (string, string) {
return "", ""
from, err1 := imdb.GetUserByUserID(fromUserID)
to, err2 := imdb.GetUserByUserID(toUserID)
if err1 != nil || err2 != nil {
log.NewError("FindUserByUID failed ", err1, err2, fromUserID, toUserID)
}
fromNickname, toNickname := "", ""
if from != nil {
fromNickname = from.Nickname
}
if to != nil {
toNickname = to.Nickname
}
return fromNickname, toNickname
}
func FriendApplicationAddedNotification(req *pbFriend.AddFriendReq) {
return
var n NotificationMsg
n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID
n.ContentType = constant.FriendApplicationAddedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.CommID.OperationID
var FriendApplicationAddedTips open_im_sdk.FriendApplicationAddedTips
FriendApplicationAddedTips.FromToUserID.FromUserID = req.CommID.FromUserID
FriendApplicationAddedTips.FromToUserID.ToUserID = req.CommID.ToUserID
fromUserNickname, toUserNickname := getFromToUserNickname(req.CommID.OperationID, req.CommID.FromUserID, req.CommID.ToUserID)
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(FriendApplicationAddedTips)
tips.DefaultTips = fromUserNickname + " FriendApplicationAddedNotification " + toUserNickname
n.Content, _ = json.Marshal(tips)
Notification(&n, true)
}
func FriendApplicationProcessedNotification(req *pbFriend.AddFriendResponseReq) {
return
var n NotificationMsg
n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID
n.ContentType = constant.FriendApplicationProcessedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.CommID.OperationID
var FriendApplicationProcessedTips open_im_sdk.FriendApplicationProcessedTips
FriendApplicationProcessedTips.FromToUserID.FromUserID = req.CommID.FromUserID
FriendApplicationProcessedTips.FromToUserID.ToUserID = req.CommID.ToUserID
fromUserNickname, toUserNickname := getFromToUserNickname(req.CommID.OperationID, req.CommID.FromUserID, req.CommID.ToUserID)
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(FriendApplicationProcessedTips)
tips.DefaultTips = fromUserNickname + " FriendApplicationProcessedNotification " + toUserNickname
n.Content, _ = json.Marshal(tips)
Notification(&n, true)
}
func FriendAddedNotification(operationID, opUserID, fromUserID, toUserID string) {
return
var n NotificationMsg
n.SendID = fromUserID
n.RecvID = toUserID
n.ContentType = constant.FriendAddedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = operationID
var FriendAddedTips open_im_sdk.FriendAddedTips
user, err := imdb.GetUserByUserID(opUserID)
if err != nil {
log.NewError(operationID, "FindUserByUID failed ", err.Error(), opUserID)
} else {
utils.CopyStructFields(FriendAddedTips.OpUser, user)
}
friend, err := imdb.GetFriendRelationshipFromFriend(fromUserID, toUserID)
if err != nil {
log.NewError(operationID, "FindUserByUID failed ", err.Error(), fromUserID, toUserID)
} else {
FriendAddedTips.Friend.Remark = friend.Remark
}
from, err := imdb.GetUserByUserID(fromUserID)
if err != nil {
log.NewError(operationID, "FindUserByUID failed ", err.Error(), fromUserID)
} else {
utils.CopyStructFields(FriendAddedTips.Friend, from)
}
to, err := imdb.GetUserByUserID(toUserID)
if err != nil {
log.NewError(operationID, "FindUserByUID failed ", err.Error(), toUserID)
} else {
utils.CopyStructFields(FriendAddedTips.Friend.FriendUser, to)
}
fromUserNickname, toUserNickname := from.Nickname, to.Nickname
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(FriendAddedTips)
tips.DefaultTips = fromUserNickname + " FriendAddedNotification " + toUserNickname
n.Content, _ = json.Marshal(tips)
Notification(&n, true)
}
//message FriendDeletedTips{
// FriendInfo Friend = 1;
//}
func FriendDeletedNotification(req *pbFriend.DeleteFriendReq) {
return
var n NotificationMsg
n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID
n.ContentType = constant.FriendDeletedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.CommID.OperationID
var FriendDeletedTips open_im_sdk.FriendDeletedTips
FriendDeletedTips.FromToUserID.FromUserID = req.CommID.FromUserID
FriendDeletedTips.FromToUserID.ToUserID = req.CommID.ToUserID
fromUserNickname, toUserNickname := getFromToUserNickname(req.CommID.OperationID, req.CommID.FromUserID, req.CommID.ToUserID)
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(FriendDeletedTips)
tips.DefaultTips = fromUserNickname + " FriendDeletedNotification " + toUserNickname
n.Content, _ = json.Marshal(tips)
Notification(&n, true)
}
//message FriendInfoChangedTips{
// FriendInfo Friend = 1;
// PublicUserInfo OpUser = 2;
// uint64 OperationTime = 3;
//}
func FriendInfoChangedNotification(operationID, opUserID, fromUserID, toUserID string) {
return
var n NotificationMsg
n.SendID = fromUserID
n.RecvID = toUserID
n.ContentType = constant.FriendInfoChangedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = operationID
var FriendInfoChangedTips open_im_sdk.FriendInfoChangedTips
FriendInfoChangedTips.FromToUserID.FromUserID = fromUserID
FriendInfoChangedTips.FromToUserID.ToUserID = toUserID
fromUserNickname, toUserNickname := getFromToUserNickname(operationID, fromUserID, toUserID)
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(FriendInfoChangedTips)
tips.DefaultTips = fromUserNickname + " FriendDeletedNotification " + toUserNickname
n.Content, _ = json.Marshal(tips)
Notification(&n, true)
}
func BlackAddedNotification(req *pbFriend.AddBlacklistReq) {
return
var n NotificationMsg
n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID
n.ContentType = constant.BlackAddedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.CommID.OperationID
var BlackAddedTips open_im_sdk.BlackAddedTips
BlackAddedTips.FromToUserID.FromUserID = req.CommID.FromUserID
BlackAddedTips.FromToUserID.ToUserID = req.CommID.ToUserID
fromUserNickname, toUserNickname := getFromToUserNickname(req.CommID.OperationID, req.CommID.FromUserID, req.CommID.ToUserID)
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(BlackAddedTips)
tips.DefaultTips = fromUserNickname + " BlackAddedNotification " + toUserNickname
n.Content, _ = json.Marshal(tips)
Notification(&n, true)
}
//message BlackDeletedTips{
// BlackInfo Black = 1;
//}
func BlackDeletedNotification(req *pbFriend.RemoveBlacklistReq) {
return
var n NotificationMsg
n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID
n.ContentType = constant.BlackDeletedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.CommID.OperationID
var BlackDeletedTips open_im_sdk.BlackDeletedTips
BlackDeletedTips.FromToUserID.FromUserID = req.CommID.FromUserID
BlackDeletedTips.FromToUserID.ToUserID = req.CommID.ToUserID
fromUserNickname, toUserNickname := getFromToUserNickname(req.CommID.OperationID, req.CommID.FromUserID, req.CommID.ToUserID)
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(BlackDeletedTips)
tips.DefaultTips = fromUserNickname + " BlackDeletedNotification " + toUserNickname
n.Content, _ = json.Marshal(tips)
Notification(&n, true)
}
//message SelfInfoUpdatedTips{
// UserInfo SelfUserInfo = 1;
// PublicUserInfo OpUser = 2;
// uint64 OperationTime = 3;
//}
func SelfInfoUpdatedNotification(operationID, userID string) {
return
var n NotificationMsg
n.SendID = userID
n.RecvID = userID
n.ContentType = constant.SelfInfoUpdatedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = operationID
var SelfInfoUpdatedTips open_im_sdk.SelfInfoUpdatedTips
SelfInfoUpdatedTips.UserID = userID
var tips open_im_sdk.TipsComm
u, err := imdb.GetUserByUserID(userID)
if err != nil {
log.NewError(operationID, "FindUserByUID failed ", err.Error(), userID)
}
tips.Detail, _ = json.Marshal(SelfInfoUpdatedTips)
tips.DefaultTips = u.Nickname + " SelfInfoUpdatedNotification "
n.Content, _ = json.Marshal(tips)
Notification(&n, true)
}

@ -6,7 +6,7 @@ import (
commonDB "Open_IM/pkg/common/db" commonDB "Open_IM/pkg/common/db"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/proto/sdk_ws" open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"sort" "sort"
"strings" "strings"

@ -232,14 +232,14 @@ func modifyMessageByUserMessageReceiveOpt(userID, sourceID string, sessionType i
type NotificationMsg struct { type NotificationMsg struct {
SendID string SendID string
RecvID string RecvID string
Content []byte Content []byte // open_im_sdk.TipsComm
MsgFrom int32 MsgFrom int32
ContentType int32 ContentType int32
SessionType int32 SessionType int32
OperationID string OperationID string
} }
func Notification(n *NotificationMsg, onlineUserOnly bool) { func Notification(n *NotificationMsg) {
var req pbChat.SendMsgReq var req pbChat.SendMsgReq
var msg sdk_ws.MsgData var msg sdk_ws.MsgData
var offlineInfo sdk_ws.OfflinePushInfo var offlineInfo sdk_ws.OfflinePushInfo
@ -259,7 +259,7 @@ func Notification(n *NotificationMsg, onlineUserOnly bool) {
msg.RecvID = "" msg.RecvID = ""
msg.GroupID = n.RecvID msg.GroupID = n.RecvID
} }
if onlineUserOnly { if true {
msg.Options = make(map[string]bool, 10) msg.Options = make(map[string]bool, 10)
//utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false) //utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false)
utils.SetSwitchFromOptions(msg.Options, constant.IsHistory, false) utils.SetSwitchFromOptions(msg.Options, constant.IsHistory, false)
@ -267,23 +267,23 @@ func Notification(n *NotificationMsg, onlineUserOnly bool) {
} }
offlineInfo.IOSBadgeCount = config.Config.IOSPush.BadgeCount offlineInfo.IOSBadgeCount = config.Config.IOSPush.BadgeCount
offlineInfo.IOSPushSound = config.Config.IOSPush.PushSound offlineInfo.IOSPushSound = config.Config.IOSPush.PushSound
switch msg.ContentType { //switch msg.ContentType {
case constant.GroupCreatedNotification: //case constant.GroupCreatedNotification:
pushSwitch = config.Config.Notification.GroupCreated.OfflinePush.PushSwitch // pushSwitch = config.Config.Notification.GroupCreated.OfflinePush.PushSwitch
title = config.Config.Notification.GroupCreated.OfflinePush.Title // title = config.Config.Notification.GroupCreated.OfflinePush.Title
desc = config.Config.Notification.GroupCreated.OfflinePush.Desc // desc = config.Config.Notification.GroupCreated.OfflinePush.Desc
ex = config.Config.Notification.GroupCreated.OfflinePush.Ext // ex = config.Config.Notification.GroupCreated.OfflinePush.Ext
case constant.GroupInfoChangedNotification: //case constant.GroupInfoChangedNotification:
pushSwitch = config.Config.Notification.GroupInfoChanged.OfflinePush.PushSwitch // pushSwitch = config.Config.Notification.GroupInfoChanged.OfflinePush.PushSwitch
title = config.Config.Notification.GroupInfoChanged.OfflinePush.Title // title = config.Config.Notification.GroupInfoChanged.OfflinePush.Title
desc = config.Config.Notification.GroupInfoChanged.OfflinePush.Desc // desc = config.Config.Notification.GroupInfoChanged.OfflinePush.Desc
ex = config.Config.Notification.GroupInfoChanged.OfflinePush.Ext // ex = config.Config.Notification.GroupInfoChanged.OfflinePush.Ext
case constant.JoinApplicationNotification: //case constant.JoinApplicationNotification:
pushSwitch = config.Config.Notification.ApplyJoinGroup.OfflinePush.PushSwitch // pushSwitch = config.Config.Notification.ApplyJoinGroup.OfflinePush.PushSwitch
title = config.Config.Notification.ApplyJoinGroup.OfflinePush.Title // title = config.Config.Notification.ApplyJoinGroup.OfflinePush.Title
desc = config.Config.Notification.ApplyJoinGroup.OfflinePush.Desc // desc = config.Config.Notification.ApplyJoinGroup.OfflinePush.Desc
ex = config.Config.Notification.ApplyJoinGroup.OfflinePush.Ext // ex = config.Config.Notification.ApplyJoinGroup.OfflinePush.Ext
} //}
utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, pushSwitch) utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, pushSwitch)
offlineInfo.Title = title offlineInfo.Title = title
offlineInfo.Desc = desc offlineInfo.Desc = desc

@ -235,8 +235,8 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
} }
for _, v := range RpcResp.FriendInfoList { for _, v := range RpcResp.FriendInfoList {
chat.FriendInfoChangedNotification(req.OperationID, req.OpUserID, req.UserInfo.UserID, v.FriendUser.UserID) chat.UserInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID, v.FriendUser.UserID)
} }
chat.SelfInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID) chat.UserInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID, req.OpUserID)
return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
} }

@ -0,0 +1,18 @@
package base_info
import sts "github.com/tencentyun/qcloud-cos-sts-sdk/go"
type TencentCloudStorageCredentialReq struct {
OperationID string `json:"operationID"`
}
type TencentCloudStorageCredentialRespData struct {
*sts.CredentialResult
Region string `json:"region"`
Bucket string `json:"bucket"`
}
type TencentCloudStorageCredentialResp struct {
CommResp
Data TencentCloudStorageCredentialRespData `json:"data"`
}

@ -54,7 +54,7 @@ type GetJoinedGroupListReq struct {
} }
type GetJoinedGroupListResp struct { type GetJoinedGroupListResp struct {
CommResp CommResp
GroupInfoList []*open_im_sdk.GroupInfo GroupInfoList []*open_im_sdk.GroupInfo `json:"-"`
Data []map[string]interface{} `json:"data"` Data []map[string]interface{} `json:"data"`
} }
@ -67,7 +67,7 @@ type GetGroupMemberListReq struct {
type GetGroupMemberListResp struct { type GetGroupMemberListResp struct {
CommResp CommResp
NextSeq int32 `json:"nextSeq"` NextSeq int32 `json:"nextSeq"`
MemberList []*open_im_sdk.GroupMemberFullInfo MemberList []*open_im_sdk.GroupMemberFullInfo `json:"-"`
Data []map[string]interface{} `json:"data"` Data []map[string]interface{} `json:"data"`
} }
@ -90,7 +90,7 @@ type CreateGroupReq struct {
} }
type CreateGroupResp struct { type CreateGroupResp struct {
CommResp CommResp
GroupInfo open_im_sdk.GroupInfo GroupInfo open_im_sdk.GroupInfo `jason:-`
Data map[string]interface{} `json:"data"` Data map[string]interface{} `json:"data"`
} }
@ -100,7 +100,7 @@ type GetGroupApplicationListReq struct {
} }
type GetGroupApplicationListResp struct { type GetGroupApplicationListResp struct {
CommResp CommResp
GroupRequestList []*open_im_sdk.GroupRequest GroupRequestList []*open_im_sdk.GroupRequest `json:"-"`
Data []map[string]interface{} `json:"data"` Data []map[string]interface{} `json:"data"`
} }
@ -110,7 +110,7 @@ type GetGroupInfoReq struct {
} }
type GetGroupInfoResp struct { type GetGroupInfoResp struct {
CommResp CommResp
GroupInfoList []*open_im_sdk.GroupInfo GroupInfoList []*open_im_sdk.GroupInfo `json:"-"`
Data []map[string]interface{} `json:"data"` Data []map[string]interface{} `json:"data"`
} }

@ -164,19 +164,113 @@ type config struct {
BadgeCount bool `yaml:"badgeCount"` BadgeCount bool `yaml:"badgeCount"`
} }
Notification struct { Notification struct {
///////////////////////group/////////////////////////////
GroupCreated struct { GroupCreated struct {
Conversation PConversation `yaml:"conversation"` Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"` OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"` DefaultTips PDefaultTips `yaml:"defaultTips"`
} }
GroupInfoChanged struct { GroupInfoSet struct {
Conversation PConversation `yaml:"conversation"` Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"` OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"` DefaultTips PDefaultTips `yaml:"defaultTips"`
} }
ApplyJoinGroup struct { JoinGroupApplication struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
MemberQuit struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
GroupApplicationAccepted struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
GroupApplicationRejected struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
GroupOwnerTransferred struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
MemberKicked struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
MemberInvited struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
MemberEnter struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
////////////////////////user///////////////////////
UserInfoUpdated struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
//////////////////////friend///////////////////////
FriendApplication struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
FriendApplicationApproved struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
FriendApplicationRejected struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
FriendAdded struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
FriendDeleted struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
FriendRemarkSet struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
BlackAdded struct {
Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"`
}
BlackDeleted struct {
Conversation PConversation `yaml:"conversation"` Conversation PConversation `yaml:"conversation"`
OfflinePush POfflinePush `yaml:"offlinePush"` OfflinePush POfflinePush `yaml:"offlinePush"`
DefaultTips PDefaultTips `yaml:"defaultTips"` DefaultTips PDefaultTips `yaml:"defaultTips"`
@ -201,7 +295,7 @@ type config struct {
} }
} }
type PConversation struct { type PConversation struct {
ConversationChanged bool `yaml:"conversationChanged"` ReliabilityLevel int `yaml:"reliabilityLevel"`
UnreadCount bool `yaml:"unreadCount"` UnreadCount bool `yaml:"unreadCount"`
} }

@ -45,24 +45,28 @@ const (
GroupMsg = 201 GroupMsg = 201
//SysRelated //SysRelated
FriendApplicationProcessedNotification = 1201 //AcceptFriendApplicationTip = 201
FriendApplicationAddedNotification = 1202 //AddFriendTip = 202 FriendApplicationApprovedNotification = 1201 //add_friend_response
FriendAddedNotification = 1203 FriendApplicationRejectedNotification = 1202 //add_friend_response
FriendDeletedNotification = 1204 FriendApplicationNotification = 1203 //add_friend
FriendInfoChangedNotification = 1205 FriendAddedNotification = 1204
BlackAddedNotification = 1206 FriendDeletedNotification = 1205 //delete_friend
BlackDeletedNotification = 1207 FriendRemarkSetNotification = 1206 //set_friend_remark?
BlackAddedNotification = 1207 //add_black
SelfInfoUpdatedNotification = 1303 //SetSelfInfoTip = 204 BlackDeletedNotification = 1208 //remove_black
GroupCreatedNotification = 1501 //CreateGroupTip = 502 UserInfoUpdatedNotification = 1303 //SetSelfInfoTip = 204
JoinApplicationNotification = 1502 //JoinGroupTip = 504
ApplicationProcessedNotification = 1503 //AcceptGroupApplicationTip = 507 RefuseGroupApplicationTip = 508 GroupCreatedNotification = 1501
MemberInvitedNotification = 1504 //InviteUserToGroupTip = 510 GroupInfoSetNotification = 1502
MemberKickedNotification = 1505 //KickGroupMemberTip = 509 JoinGroupApplicationNotification = 1503
GroupInfoChangedNotification = 1506 //SetGroupInfoTip = 506 TransferGroupOwnerTip = 501 MemberQuitNotification = 1504
MemberLeaveNotification = 1507 //QuitGroupTip = 505 GroupApplicationAcceptedNotification = 1505
MemberEnterNotification = 1508 GroupApplicationRejectedNotification = 1506
GroupOwnerTransferredNotification = 1507
MemberKickedNotification = 1508
MemberInvitedNotification = 1509
MemberEnterNotification = 1510
//MsgFrom //MsgFrom
UserMsgType = 100 UserMsgType = 100
@ -128,6 +132,9 @@ const (
GroupResponseAgree = 1 GroupResponseAgree = 1
GroupResponseRefuse = -1 GroupResponseRefuse = -1
FriendResponseAgree = 1
FriendResponseRefuse = -1
Male = 1 Male = 1
Female = 2 Female = 2
) )

@ -34,7 +34,7 @@ type Friend struct {
//int64 HandleTime = 8; //int64 HandleTime = 8;
//string Ex = 9; //string Ex = 9;
//} //}
//open_im_sdk.FriendRequest == imdb.FriendRequest //open_im_sdk.FriendRequest(nickname, farce url ...) != imdb.FriendRequest
type FriendRequest struct { type FriendRequest struct {
FromUserID string `gorm:"column:from_user_id;primary_key;size:64"` FromUserID string `gorm:"column:from_user_id;primary_key;size:64"`
ToUserID string `gorm:"column:to_user_id;primary_key;size:64"` ToUserID string `gorm:"column:to_user_id;primary_key;size:64"`
@ -138,7 +138,7 @@ type GroupRequest struct {
type User struct { type User struct {
UserID string `gorm:"column:user_id;primary_key;size:64"` UserID string `gorm:"column:user_id;primary_key;size:64"`
Nickname string `gorm:"column:name;size:255"` Nickname string `gorm:"column:name;size:255"`
FaceUrl string `gorm:"column:face_url;size:255"` FaceURL string `gorm:"column:face_url;size:255"`
Gender int32 `gorm:"column:gender"` Gender int32 `gorm:"column:gender"`
PhoneNumber string `gorm:"column:phone_number;size:32"` PhoneNumber string `gorm:"column:phone_number;size:32"`
Birth time.Time `gorm:"column:birth"` Birth time.Time `gorm:"column:birth"`

@ -5,7 +5,7 @@ import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
pbMsg "Open_IM/pkg/proto/chat" pbMsg "Open_IM/pkg/proto/chat"
"Open_IM/pkg/proto/sdk_ws" open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"errors" "errors"
"github.com/garyburd/redigo/redis" "github.com/garyburd/redigo/redis"
"github.com/golang/protobuf/proto" "github.com/golang/protobuf/proto"

@ -3,6 +3,7 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db" "Open_IM/pkg/common/db"
"Open_IM/pkg/utils"
"time" "time"
) )
@ -124,17 +125,17 @@ func GetOwnerManagerByGroupID(groupID string) ([]db.GroupMember, error) {
return groupMemberList, nil return groupMemberList, nil
} }
func GetGroupMemberNumByGroupID(groupID string) uint32 { func GetGroupMemberNumByGroupID(groupID string) (uint32, error) {
dbConn, err := db.DB.MysqlDB.DefaultGormDB() dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil { if err != nil {
return 0 return 0, utils.Wrap(err, "DefaultGormDB failed")
} }
var number uint32 var number uint32
err = dbConn.Table("group_members").Where("group_id=?", groupID).Count(&number).Error err = dbConn.Table("group_members").Where("group_id=?", groupID).Count(&number).Error
if err != nil { if err != nil {
return 0 return 0, utils.Wrap(err, "")
} }
return number return number, nil
} }
func GetGroupOwnerInfoByGroupID(groupID string) (*db.GroupMember, error) { func GetGroupOwnerInfoByGroupID(groupID string) (*db.GroupMember, error) {

@ -2,6 +2,7 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/db" "Open_IM/pkg/common/db"
"Open_IM/pkg/utils"
"time" "time"
) )
@ -37,7 +38,7 @@ func InsertIntoGroup(groupInfo db.Group) error {
func GetGroupInfoByGroupID(groupId string) (*db.Group, error) { func GetGroupInfoByGroupID(groupId string) (*db.Group, error) {
dbConn, err := db.DB.MysqlDB.DefaultGormDB() dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil { if err != nil {
return nil, err return nil, utils.Wrap(err, "")
} }
var groupInfo db.Group var groupInfo db.Group
err = dbConn.Table("groups").Where("group_id=?", groupId).Find(&groupInfo).Error err = dbConn.Table("groups").Where("group_id=?", groupId).Find(&groupInfo).Error

@ -88,33 +88,25 @@ func initRotateLogs(rotationTime time.Duration, maxRemainNum uint, level string,
} }
} }
//Deprecated func Info(OperationID string, args ...interface{}) {
func Info(token, OperationID, format string, args ...interface{}) {
logger.WithFields(logrus.Fields{ logger.WithFields(logrus.Fields{
"PID": logger.Pid,
"OperationID": OperationID, "OperationID": OperationID,
}).Infof(format, args...) "PID": logger.Pid,
}).Infoln(args)
} }
//Deprecated func Error(OperationID string, args ...interface{}) {
func Error(token, OperationID, format string, args ...interface{}) {
logger.WithFields(logrus.Fields{ logger.WithFields(logrus.Fields{
"PID": logger.Pid,
"OperationID": OperationID, "OperationID": OperationID,
}).Errorf(format, args...) "PID": logger.Pid,
}).Errorln(args)
} }
//Deprecated func Debug(OperationID string, args ...interface{}) {
func Debug(token, OperationID, format string, args ...interface{}) {
logger.WithFields(logrus.Fields{ logger.WithFields(logrus.Fields{
"PID": logger.Pid,
"OperationID": OperationID, "OperationID": OperationID,
}).Debugf(format, args...) "PID": logger.Pid,
}).Debugln(args)
} }
//Deprecated //Deprecated

@ -18,57 +18,104 @@ func OperationIDGenerator() string {
func FriendOpenIMCopyDB(dst *db.Friend, src *open_im_sdk.FriendInfo) { func FriendOpenIMCopyDB(dst *db.Friend, src *open_im_sdk.FriendInfo) {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
dst.FriendUserID = src.FriendUser.UserID dst.FriendUserID = src.FriendUser.UserID
dst.CreateTime = utils.UnixSecondToTime(int64(src.CreateTime))
} }
func FriendDBCopyOpenIM(dst *open_im_sdk.FriendInfo, src *db.Friend) { func FriendDBCopyOpenIM(dst *open_im_sdk.FriendInfo, src *db.Friend) error {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
user, _ := imdb.GetUserByUserID(src.FriendUserID) user, err := imdb.GetUserByUserID(src.FriendUserID)
if user != nil { if err != nil {
utils.CopyStructFields(dst.FriendUser, user) return utils.Wrap(err, "")
} }
utils.CopyStructFields(dst.FriendUser, user)
dst.CreateTime = uint32(src.CreateTime.Unix()) dst.CreateTime = uint32(src.CreateTime.Unix())
dst.FriendUser.CreateTime = uint32(user.CreateTime.Unix()) dst.FriendUser.CreateTime = uint32(user.CreateTime.Unix())
return nil
} }
// //
func FriendRequestOpenIMCopyDB(dst *db.FriendRequest, src *open_im_sdk.FriendRequest) { func FriendRequestOpenIMCopyDB(dst *db.FriendRequest, src *open_im_sdk.FriendRequest) {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
dst.CreateTime = utils.UnixSecondToTime(int64(src.CreateTime))
dst.HandleTime = utils.UnixSecondToTime(int64(src.HandleTime))
} }
func FriendRequestDBCopyOpenIM(dst *open_im_sdk.FriendRequest, src *db.FriendRequest) { func FriendRequestDBCopyOpenIM(dst *open_im_sdk.FriendRequest, src *db.FriendRequest) error {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
user, err := imdb.GetUserByUserID(src.FromUserID)
if err != nil {
return utils.Wrap(err, "")
}
dst.FromNickname = user.Nickname
dst.FromFaceURL = user.FaceURL
dst.FromGender = user.Gender
user, err = imdb.GetUserByUserID(src.ToUserID)
if err != nil {
return utils.Wrap(err, "")
}
dst.ToNickname = user.Nickname
dst.ToFaceURL = user.FaceURL
dst.ToGender = user.Gender
dst.CreateTime = uint32(src.CreateTime.Unix()) dst.CreateTime = uint32(src.CreateTime.Unix())
dst.HandleTime = uint32(src.HandleTime.Unix()) dst.HandleTime = uint32(src.HandleTime.Unix())
return nil
}
func BlackOpenIMCopyDB(dst *db.Black, src *open_im_sdk.BlackInfo) {
utils.CopyStructFields(dst, src)
dst.BlockUserID = src.BlackUserInfo.UserID
dst.CreateTime = utils.UnixSecondToTime(int64(src.CreateTime))
}
func BlackDBCopyOpenIM(dst *open_im_sdk.BlackInfo, src *db.Black) error {
utils.CopyStructFields(dst, src)
dst.CreateTime = uint32(src.CreateTime.Unix())
user, err := imdb.GetUserByUserID(src.BlockUserID)
if err != nil {
return utils.Wrap(err, "")
}
utils.CopyStructFields(dst.BlackUserInfo, user)
return nil
} }
func GroupOpenIMCopyDB(dst *db.Group, src *open_im_sdk.GroupInfo) { func GroupOpenIMCopyDB(dst *db.Group, src *open_im_sdk.GroupInfo) {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
} }
func GroupDBCopyOpenIM(dst *open_im_sdk.GroupInfo, src *db.Group) { func GroupDBCopyOpenIM(dst *open_im_sdk.GroupInfo, src *db.Group) error {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
user, _ := imdb.GetGroupOwnerInfoByGroupID(src.GroupID) user, err := imdb.GetGroupOwnerInfoByGroupID(src.GroupID)
if user != nil { if err != nil {
return utils.Wrap(err, "")
}
dst.OwnerUserID = user.UserID dst.OwnerUserID = user.UserID
dst.MemberCount, err = imdb.GetGroupMemberNumByGroupID(src.GroupID)
if err != nil {
return utils.Wrap(err, "")
} }
dst.MemberCount = imdb.GetGroupMemberNumByGroupID(src.GroupID)
dst.CreateTime = uint32(src.CreateTime.Unix()) dst.CreateTime = uint32(src.CreateTime.Unix())
return nil
} }
func GroupMemberOpenIMCopyDB(dst *db.GroupMember, src *open_im_sdk.GroupMemberFullInfo) { func GroupMemberOpenIMCopyDB(dst *db.GroupMember, src *open_im_sdk.GroupMemberFullInfo) {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
} }
func GroupMemberDBCopyOpenIM(dst *open_im_sdk.GroupMemberFullInfo, src *db.GroupMember) { func GroupMemberDBCopyOpenIM(dst *open_im_sdk.GroupMemberFullInfo, src *db.GroupMember) error {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
if token_verify.IsMangerUserID(src.UserID) { if token_verify.IsMangerUserID(src.UserID) {
u, _ := imdb.GetUserByUserID(src.UserID) u, err := imdb.GetUserByUserID(src.UserID)
if u != nil { if err != nil {
utils.CopyStructFields(dst, u) return utils.Wrap(err, "")
} }
utils.CopyStructFields(dst, u)
dst.AppMangerLevel = 1 dst.AppMangerLevel = 1
} }
dst.JoinTime = src.JoinTime.Unix() dst.JoinTime = src.JoinTime.Unix()
return nil
} }
func GroupRequestOpenIMCopyDB(dst *db.GroupRequest, src *open_im_sdk.GroupRequest) { func GroupRequestOpenIMCopyDB(dst *db.GroupRequest, src *open_im_sdk.GroupRequest) {
@ -83,23 +130,21 @@ func GroupRequestDBCopyOpenIM(dst *open_im_sdk.GroupRequest, src *db.GroupReques
func UserOpenIMCopyDB(dst *db.User, src *open_im_sdk.UserInfo) { func UserOpenIMCopyDB(dst *db.User, src *open_im_sdk.UserInfo) {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
dst.Birth = utils.UnixSecondToTime(int64(src.Birth))
dst.CreateTime = utils.UnixSecondToTime(int64(src.CreateTime))
} }
func UserDBCopyOpenIM(dst *open_im_sdk.UserInfo, src *db.User) { func UserDBCopyOpenIM(dst *open_im_sdk.UserInfo, src *db.User) {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
dst.CreateTime = uint32(src.CreateTime.Unix()) dst.CreateTime = uint32(src.CreateTime.Unix())
dst.Birth = uint32(src.Birth.Unix())
} }
func BlackOpenIMCopyDB(dst *db.Black, src *open_im_sdk.BlackInfo) { func UserDBCopyOpenIMPublicUser(dst *open_im_sdk.PublicUserInfo, src *db.User) {
utils.CopyStructFields(dst, src) utils.CopyStructFields(dst, src)
dst.BlockUserID = src.BlackUserInfo.UserID
} }
func BlackDBCopyOpenIM(dst *open_im_sdk.BlackInfo, src *db.Black) { //
utils.CopyStructFields(dst, src) //func PublicUserDBCopyOpenIM(dst *open_im_sdk.PublicUserInfo, src *db.User){
dst.CreateTime = uint32(src.CreateTime.Unix()) //
user, _ := imdb.GetUserByUserID(src.BlockUserID) //}
if user != nil {
utils.CopyStructFields(dst.BlackUserInfo, user)
}
}

@ -36,7 +36,7 @@ func (m *CommonResp) Reset() { *m = CommonResp{} }
func (m *CommonResp) String() string { return proto.CompactTextString(m) } func (m *CommonResp) String() string { return proto.CompactTextString(m) }
func (*CommonResp) ProtoMessage() {} func (*CommonResp) ProtoMessage() {}
func (*CommonResp) Descriptor() ([]byte, []int) { func (*CommonResp) Descriptor() ([]byte, []int) {
return fileDescriptor_auth_6e5d34ffb6edf37a, []int{0} return fileDescriptor_auth_88965eda3ab7f34d, []int{0}
} }
func (m *CommonResp) XXX_Unmarshal(b []byte) error { func (m *CommonResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CommonResp.Unmarshal(m, b) return xxx_messageInfo_CommonResp.Unmarshal(m, b)
@ -82,7 +82,7 @@ func (m *UserRegisterReq) Reset() { *m = UserRegisterReq{} }
func (m *UserRegisterReq) String() string { return proto.CompactTextString(m) } func (m *UserRegisterReq) String() string { return proto.CompactTextString(m) }
func (*UserRegisterReq) ProtoMessage() {} func (*UserRegisterReq) ProtoMessage() {}
func (*UserRegisterReq) Descriptor() ([]byte, []int) { func (*UserRegisterReq) Descriptor() ([]byte, []int) {
return fileDescriptor_auth_6e5d34ffb6edf37a, []int{1} return fileDescriptor_auth_88965eda3ab7f34d, []int{1}
} }
func (m *UserRegisterReq) XXX_Unmarshal(b []byte) error { func (m *UserRegisterReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserRegisterReq.Unmarshal(m, b) return xxx_messageInfo_UserRegisterReq.Unmarshal(m, b)
@ -127,7 +127,7 @@ func (m *UserRegisterResp) Reset() { *m = UserRegisterResp{} }
func (m *UserRegisterResp) String() string { return proto.CompactTextString(m) } func (m *UserRegisterResp) String() string { return proto.CompactTextString(m) }
func (*UserRegisterResp) ProtoMessage() {} func (*UserRegisterResp) ProtoMessage() {}
func (*UserRegisterResp) Descriptor() ([]byte, []int) { func (*UserRegisterResp) Descriptor() ([]byte, []int) {
return fileDescriptor_auth_6e5d34ffb6edf37a, []int{2} return fileDescriptor_auth_88965eda3ab7f34d, []int{2}
} }
func (m *UserRegisterResp) XXX_Unmarshal(b []byte) error { func (m *UserRegisterResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserRegisterResp.Unmarshal(m, b) return xxx_messageInfo_UserRegisterResp.Unmarshal(m, b)
@ -168,7 +168,7 @@ func (m *UserTokenReq) Reset() { *m = UserTokenReq{} }
func (m *UserTokenReq) String() string { return proto.CompactTextString(m) } func (m *UserTokenReq) String() string { return proto.CompactTextString(m) }
func (*UserTokenReq) ProtoMessage() {} func (*UserTokenReq) ProtoMessage() {}
func (*UserTokenReq) Descriptor() ([]byte, []int) { func (*UserTokenReq) Descriptor() ([]byte, []int) {
return fileDescriptor_auth_6e5d34ffb6edf37a, []int{3} return fileDescriptor_auth_88965eda3ab7f34d, []int{3}
} }
func (m *UserTokenReq) XXX_Unmarshal(b []byte) error { func (m *UserTokenReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserTokenReq.Unmarshal(m, b) return xxx_messageInfo_UserTokenReq.Unmarshal(m, b)
@ -229,7 +229,7 @@ func (m *UserTokenResp) Reset() { *m = UserTokenResp{} }
func (m *UserTokenResp) String() string { return proto.CompactTextString(m) } func (m *UserTokenResp) String() string { return proto.CompactTextString(m) }
func (*UserTokenResp) ProtoMessage() {} func (*UserTokenResp) ProtoMessage() {}
func (*UserTokenResp) Descriptor() ([]byte, []int) { func (*UserTokenResp) Descriptor() ([]byte, []int) {
return fileDescriptor_auth_6e5d34ffb6edf37a, []int{4} return fileDescriptor_auth_88965eda3ab7f34d, []int{4}
} }
func (m *UserTokenResp) XXX_Unmarshal(b []byte) error { func (m *UserTokenResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserTokenResp.Unmarshal(m, b) return xxx_messageInfo_UserTokenResp.Unmarshal(m, b)
@ -383,31 +383,32 @@ var _Auth_serviceDesc = grpc.ServiceDesc{
Metadata: "auth/auth.proto", Metadata: "auth/auth.proto",
} }
func init() { proto.RegisterFile("auth/auth.proto", fileDescriptor_auth_6e5d34ffb6edf37a) } func init() { proto.RegisterFile("auth/auth.proto", fileDescriptor_auth_88965eda3ab7f34d) }
var fileDescriptor_auth_6e5d34ffb6edf37a = []byte{ var fileDescriptor_auth_88965eda3ab7f34d = []byte{
// 362 bytes of a gzipped FileDescriptorProto // 369 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x52, 0x4d, 0x4f, 0xc2, 0x40, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x52, 0x4d, 0x4b, 0xc3, 0x40,
0x14, 0x4c, 0xe5, 0x43, 0x78, 0x48, 0x30, 0x2f, 0xa0, 0x4d, 0x0f, 0x06, 0x7b, 0xe2, 0xd4, 0x46, 0x10, 0x25, 0xf6, 0xc3, 0x76, 0x6a, 0xa9, 0x2c, 0x55, 0x43, 0x04, 0xa9, 0x39, 0xf5, 0x94, 0x40,
0xbc, 0x98, 0x98, 0x98, 0x20, 0x4a, 0xc2, 0x81, 0x60, 0x1a, 0xbc, 0x78, 0x21, 0x90, 0x2e, 0xd0, 0x3d, 0x28, 0x08, 0x42, 0xad, 0x16, 0x7a, 0x28, 0x95, 0xa5, 0x5e, 0xbc, 0x84, 0x94, 0x6e, 0xdb,
0xd4, 0x76, 0xd7, 0xdd, 0x12, 0x4c, 0x3c, 0x7a, 0xf1, 0x67, 0x9b, 0xdd, 0x7e, 0xb8, 0x22, 0x27, 0x90, 0x26, 0xbb, 0xee, 0xa6, 0x56, 0xf0, 0xe8, 0xc5, 0x9f, 0x2d, 0xbb, 0xf9, 0x70, 0xad, 0x3d,
0x2f, 0x6d, 0x66, 0xe6, 0xf5, 0xcd, 0xcc, 0x76, 0xa1, 0xb5, 0xd8, 0x26, 0x1b, 0x57, 0x3e, 0x1c, 0x79, 0x49, 0x98, 0x79, 0x2f, 0xf3, 0xde, 0x9b, 0x0c, 0xb4, 0xfc, 0x4d, 0xb2, 0x72, 0xe5, 0xc3,
0xc6, 0x69, 0x42, 0xb1, 0xca, 0x96, 0x83, 0x6d, 0xb2, 0xb1, 0x2e, 0xa7, 0x8c, 0xc4, 0xf3, 0xf1, 0x61, 0x9c, 0x26, 0x14, 0x55, 0xd9, 0xac, 0xbf, 0x49, 0x56, 0xd6, 0xe5, 0x84, 0x91, 0xd8, 0x1b,
0xc4, 0x65, 0xe1, 0xda, 0x55, 0x92, 0x2b, 0xfc, 0x70, 0xbe, 0x13, 0xee, 0x4e, 0xa4, 0xa3, 0xf6, 0x8d, 0x5d, 0x16, 0x2e, 0x5d, 0x05, 0xb9, 0x62, 0x1e, 0x7a, 0x5b, 0xe1, 0x6e, 0x45, 0x4a, 0xb5,
0x1d, 0xc0, 0x90, 0x46, 0x11, 0x8d, 0x3d, 0x22, 0x18, 0x9a, 0x70, 0x4c, 0x38, 0x1f, 0x52, 0x9f, 0xef, 0x00, 0x06, 0x34, 0x8a, 0x68, 0x8c, 0x89, 0x60, 0xc8, 0x84, 0x43, 0xc2, 0xf9, 0x80, 0xce,
0x98, 0x46, 0xd7, 0xe8, 0x55, 0xbc, 0x1c, 0xe2, 0x19, 0x54, 0x09, 0xe7, 0x13, 0xb1, 0x36, 0x8f, 0x89, 0x69, 0x74, 0x8c, 0x6e, 0x05, 0xe7, 0x25, 0x3a, 0x85, 0x2a, 0xe1, 0x7c, 0x2c, 0x96, 0xe6,
0xba, 0x46, 0xaf, 0xee, 0x65, 0xc8, 0x5e, 0x41, 0xeb, 0x59, 0x10, 0xee, 0x91, 0x75, 0x20, 0x12, 0x41, 0xc7, 0xe8, 0xd6, 0x71, 0x56, 0xd9, 0x6b, 0x68, 0x3d, 0x0b, 0xc2, 0x31, 0x59, 0x06, 0x22,
0xf9, 0x7e, 0xc3, 0x2b, 0xa8, 0x49, 0x6a, 0x1c, 0xaf, 0xa8, 0xda, 0xd2, 0xe8, 0x77, 0x1c, 0x2a, 0x91, 0xef, 0x57, 0x74, 0x0d, 0x35, 0xd9, 0x1a, 0xc5, 0x0b, 0xaa, 0xa6, 0x34, 0x7a, 0xe7, 0x8e,
0x83, 0x04, 0xd1, 0x5c, 0xf8, 0xa1, 0x93, 0x8b, 0x5e, 0x31, 0x86, 0x5d, 0x68, 0x4c, 0x19, 0xe1, 0x20, 0xfc, 0x8d, 0x70, 0xcf, 0x67, 0x81, 0xc7, 0x7c, 0xee, 0x47, 0xc2, 0xc9, 0x29, 0xb8, 0x20,
0x8b, 0x24, 0xa0, 0xf1, 0xf8, 0x21, 0xb3, 0xd0, 0x29, 0x7b, 0x04, 0xa7, 0xbf, 0x7d, 0x04, 0xc3, 0xa3, 0x0e, 0x34, 0x26, 0x8c, 0x70, 0x3f, 0x09, 0x68, 0x3c, 0x7a, 0xc8, 0x84, 0xf4, 0x96, 0x3d,
0xbe, 0x9e, 0x3d, 0xb3, 0x42, 0x27, 0xed, 0xee, 0xfc, 0x28, 0x9e, 0x36, 0x65, 0x7f, 0x19, 0x70, 0x84, 0xe3, 0xdf, 0x6a, 0x82, 0xa1, 0x9e, 0x9e, 0x20, 0x13, 0x44, 0x4e, 0xba, 0x01, 0xe7, 0x07,
0x22, 0x17, 0xcd, 0x68, 0x48, 0x62, 0x99, 0xd6, 0x82, 0xda, 0xd3, 0xeb, 0x22, 0x59, 0x51, 0x1e, 0xc1, 0x1a, 0xcb, 0xfe, 0x32, 0xe0, 0x48, 0x0e, 0x9a, 0xd2, 0x90, 0xc4, 0xd2, 0xb3, 0x05, 0xb5,
0x65, 0x9d, 0x0b, 0x8c, 0x17, 0x00, 0x23, 0x4e, 0x23, 0x15, 0x33, 0x4f, 0xa5, 0x31, 0xf2, 0xdb, 0xa7, 0xb5, 0x9f, 0x2c, 0x28, 0x8f, 0xb2, 0xe4, 0x45, 0x8d, 0x2e, 0x00, 0x86, 0x9c, 0x46, 0xca,
0x29, 0xcb, 0xd4, 0x92, 0x52, 0x0b, 0xbc, 0x5f, 0xa9, 0xfc, 0xb7, 0xd2, 0x07, 0x34, 0xb5, 0x24, 0x66, 0xee, 0x4a, 0xeb, 0xc8, 0x6f, 0x27, 0x2c, 0x43, 0x4b, 0x0a, 0x2d, 0xea, 0xdd, 0x48, 0xe5,
0xff, 0xeb, 0x83, 0x6d, 0xa8, 0xa8, 0x05, 0x59, 0xba, 0x14, 0x48, 0xf3, 0xc7, 0x77, 0x16, 0x70, 0xbf, 0x91, 0x3e, 0xa0, 0xa9, 0x39, 0xf9, 0x5f, 0x1e, 0xd4, 0x86, 0x8a, 0x1a, 0x90, 0xb9, 0x4b,
0xe2, 0xcf, 0x82, 0x88, 0xa8, 0x6c, 0x25, 0x4f, 0xa7, 0xfa, 0x9f, 0x06, 0x94, 0xe5, 0x5e, 0x1c, 0x0b, 0x29, 0xfe, 0xf8, 0xce, 0x02, 0x4e, 0xe6, 0xd3, 0x20, 0x22, 0xca, 0x5b, 0x09, 0xeb, 0xad,
0xa4, 0xe7, 0x91, 0x1f, 0x2c, 0x9e, 0xe7, 0x86, 0x7b, 0xbf, 0xd5, 0x32, 0x0f, 0x0b, 0x82, 0xe1, 0xde, 0xa7, 0x01, 0x65, 0x39, 0x17, 0xf5, 0xd3, 0x7d, 0xe4, 0x8b, 0x45, 0x67, 0xb9, 0xe0, 0xce,
0x0d, 0xd4, 0x8b, 0x22, 0xd8, 0xd6, 0xc7, 0xf2, 0x53, 0xb6, 0x3a, 0x07, 0x58, 0xc1, 0xee, 0x5b, 0xcf, 0xb5, 0xcc, 0xfd, 0x80, 0x60, 0xe8, 0x06, 0xea, 0x45, 0x10, 0xd4, 0xd6, 0x69, 0xf9, 0x96,
0x2f, 0x4d, 0x47, 0x5d, 0xdc, 0xdb, 0x54, 0x5e, 0x56, 0xd5, 0xad, 0xbc, 0xfe, 0x0e, 0x00, 0x00, 0xad, 0x93, 0x3d, 0x5d, 0xc1, 0xee, 0x5b, 0x2f, 0x4d, 0x47, 0x9d, 0xef, 0x6d, 0x0a, 0xcf, 0xaa,
0xff, 0xff, 0x8c, 0xd6, 0x72, 0x1f, 0xd3, 0x02, 0x00, 0x00, 0xea, 0x36, 0xaf, 0xbe, 0x03, 0x00, 0x00, 0xff, 0xff, 0x1b, 0x20, 0x74, 0x9f, 0xd9, 0x02, 0x00,
0x00,
} }

@ -9,7 +9,7 @@ message CommonResp{
} }
message UserRegisterReq { message UserRegisterReq {
open_im_sdk.UserInfo UserInfo = 1; server_api_params.UserInfo UserInfo = 1;
string OperationID = 2; string OperationID = 2;
} }
message UserRegisterResp { message UserRegisterResp {

@ -37,7 +37,7 @@ func (m *MsgDataToMQ) Reset() { *m = MsgDataToMQ{} }
func (m *MsgDataToMQ) String() string { return proto.CompactTextString(m) } func (m *MsgDataToMQ) String() string { return proto.CompactTextString(m) }
func (*MsgDataToMQ) ProtoMessage() {} func (*MsgDataToMQ) ProtoMessage() {}
func (*MsgDataToMQ) Descriptor() ([]byte, []int) { func (*MsgDataToMQ) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_6e4ec29226096c3a, []int{0} return fileDescriptor_chat_1eadc66417ed93b5, []int{0}
} }
func (m *MsgDataToMQ) XXX_Unmarshal(b []byte) error { func (m *MsgDataToMQ) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MsgDataToMQ.Unmarshal(m, b) return xxx_messageInfo_MsgDataToMQ.Unmarshal(m, b)
@ -90,7 +90,7 @@ func (m *MsgDataToDB) Reset() { *m = MsgDataToDB{} }
func (m *MsgDataToDB) String() string { return proto.CompactTextString(m) } func (m *MsgDataToDB) String() string { return proto.CompactTextString(m) }
func (*MsgDataToDB) ProtoMessage() {} func (*MsgDataToDB) ProtoMessage() {}
func (*MsgDataToDB) Descriptor() ([]byte, []int) { func (*MsgDataToDB) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_6e4ec29226096c3a, []int{1} return fileDescriptor_chat_1eadc66417ed93b5, []int{1}
} }
func (m *MsgDataToDB) XXX_Unmarshal(b []byte) error { func (m *MsgDataToDB) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MsgDataToDB.Unmarshal(m, b) return xxx_messageInfo_MsgDataToDB.Unmarshal(m, b)
@ -136,7 +136,7 @@ func (m *PushMsgDataToMQ) Reset() { *m = PushMsgDataToMQ{} }
func (m *PushMsgDataToMQ) String() string { return proto.CompactTextString(m) } func (m *PushMsgDataToMQ) String() string { return proto.CompactTextString(m) }
func (*PushMsgDataToMQ) ProtoMessage() {} func (*PushMsgDataToMQ) ProtoMessage() {}
func (*PushMsgDataToMQ) Descriptor() ([]byte, []int) { func (*PushMsgDataToMQ) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_6e4ec29226096c3a, []int{2} return fileDescriptor_chat_1eadc66417ed93b5, []int{2}
} }
func (m *PushMsgDataToMQ) XXX_Unmarshal(b []byte) error { func (m *PushMsgDataToMQ) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PushMsgDataToMQ.Unmarshal(m, b) return xxx_messageInfo_PushMsgDataToMQ.Unmarshal(m, b)
@ -202,7 +202,7 @@ func (m *GetMaxAndMinSeqReq) Reset() { *m = GetMaxAndMinSeqReq{} }
func (m *GetMaxAndMinSeqReq) String() string { return proto.CompactTextString(m) } func (m *GetMaxAndMinSeqReq) String() string { return proto.CompactTextString(m) }
func (*GetMaxAndMinSeqReq) ProtoMessage() {} func (*GetMaxAndMinSeqReq) ProtoMessage() {}
func (*GetMaxAndMinSeqReq) Descriptor() ([]byte, []int) { func (*GetMaxAndMinSeqReq) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_6e4ec29226096c3a, []int{3} return fileDescriptor_chat_1eadc66417ed93b5, []int{3}
} }
func (m *GetMaxAndMinSeqReq) XXX_Unmarshal(b []byte) error { func (m *GetMaxAndMinSeqReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetMaxAndMinSeqReq.Unmarshal(m, b) return xxx_messageInfo_GetMaxAndMinSeqReq.Unmarshal(m, b)
@ -250,7 +250,7 @@ func (m *GetMaxAndMinSeqResp) Reset() { *m = GetMaxAndMinSeqResp{} }
func (m *GetMaxAndMinSeqResp) String() string { return proto.CompactTextString(m) } func (m *GetMaxAndMinSeqResp) String() string { return proto.CompactTextString(m) }
func (*GetMaxAndMinSeqResp) ProtoMessage() {} func (*GetMaxAndMinSeqResp) ProtoMessage() {}
func (*GetMaxAndMinSeqResp) Descriptor() ([]byte, []int) { func (*GetMaxAndMinSeqResp) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_6e4ec29226096c3a, []int{4} return fileDescriptor_chat_1eadc66417ed93b5, []int{4}
} }
func (m *GetMaxAndMinSeqResp) XXX_Unmarshal(b []byte) error { func (m *GetMaxAndMinSeqResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetMaxAndMinSeqResp.Unmarshal(m, b) return xxx_messageInfo_GetMaxAndMinSeqResp.Unmarshal(m, b)
@ -311,7 +311,7 @@ func (m *SendMsgReq) Reset() { *m = SendMsgReq{} }
func (m *SendMsgReq) String() string { return proto.CompactTextString(m) } func (m *SendMsgReq) String() string { return proto.CompactTextString(m) }
func (*SendMsgReq) ProtoMessage() {} func (*SendMsgReq) ProtoMessage() {}
func (*SendMsgReq) Descriptor() ([]byte, []int) { func (*SendMsgReq) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_6e4ec29226096c3a, []int{5} return fileDescriptor_chat_1eadc66417ed93b5, []int{5}
} }
func (m *SendMsgReq) XXX_Unmarshal(b []byte) error { func (m *SendMsgReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SendMsgReq.Unmarshal(m, b) return xxx_messageInfo_SendMsgReq.Unmarshal(m, b)
@ -367,7 +367,7 @@ func (m *SendMsgResp) Reset() { *m = SendMsgResp{} }
func (m *SendMsgResp) String() string { return proto.CompactTextString(m) } func (m *SendMsgResp) String() string { return proto.CompactTextString(m) }
func (*SendMsgResp) ProtoMessage() {} func (*SendMsgResp) ProtoMessage() {}
func (*SendMsgResp) Descriptor() ([]byte, []int) { func (*SendMsgResp) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_6e4ec29226096c3a, []int{6} return fileDescriptor_chat_1eadc66417ed93b5, []int{6}
} }
func (m *SendMsgResp) XXX_Unmarshal(b []byte) error { func (m *SendMsgResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SendMsgResp.Unmarshal(m, b) return xxx_messageInfo_SendMsgResp.Unmarshal(m, b)
@ -603,38 +603,39 @@ var _Chat_serviceDesc = grpc.ServiceDesc{
Metadata: "chat/chat.proto", Metadata: "chat/chat.proto",
} }
func init() { proto.RegisterFile("chat/chat.proto", fileDescriptor_chat_6e4ec29226096c3a) } func init() { proto.RegisterFile("chat/chat.proto", fileDescriptor_chat_1eadc66417ed93b5) }
var fileDescriptor_chat_6e4ec29226096c3a = []byte{ var fileDescriptor_chat_1eadc66417ed93b5 = []byte{
// 477 bytes of a gzipped FileDescriptorProto // 482 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0x4d, 0x6f, 0xda, 0x40, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0x4d, 0x6f, 0xd3, 0x40,
0x10, 0x15, 0x24, 0x40, 0x33, 0x56, 0x85, 0xb4, 0x41, 0x95, 0xe5, 0xf4, 0x40, 0xad, 0x56, 0xca, 0x10, 0x95, 0xd3, 0x26, 0xa1, 0x63, 0xa1, 0x48, 0xdb, 0x0a, 0x59, 0xe6, 0x92, 0xfa, 0x54, 0x81,
0xc9, 0x96, 0xe8, 0xb1, 0xa7, 0x12, 0xa2, 0x96, 0xaa, 0xdb, 0xa4, 0x26, 0xbd, 0xf4, 0x82, 0x1c, 0x64, 0x4b, 0x81, 0x1b, 0x27, 0xd2, 0x54, 0x28, 0x88, 0xa5, 0xc5, 0x09, 0x17, 0x2e, 0xd1, 0xb6,
0x3c, 0x32, 0x16, 0x60, 0x2f, 0x9e, 0xa5, 0xa4, 0xbf, 0xa6, 0xbf, 0xa2, 0xff, 0xaf, 0xda, 0x5d, 0x1e, 0x39, 0x56, 0x12, 0x7b, 0xb3, 0xe3, 0x92, 0x02, 0x3f, 0x86, 0x5f, 0xc4, 0x7f, 0x42, 0xde,
0x43, 0x96, 0x20, 0x54, 0x4e, 0xb9, 0x58, 0x7a, 0x6f, 0x66, 0xde, 0xdb, 0xe7, 0xfd, 0x80, 0xf6, 0x75, 0xd2, 0x6d, 0x03, 0x24, 0x27, 0x2e, 0x96, 0xde, 0x9b, 0xe7, 0x37, 0xf3, 0xf6, 0x0b, 0x3a,
0x64, 0x1a, 0xcb, 0x50, 0x7d, 0x02, 0x51, 0x16, 0xb2, 0x60, 0x4d, 0x71, 0x7f, 0x35, 0x8d, 0xa5, 0x37, 0x53, 0x51, 0x46, 0xd5, 0x27, 0x94, 0xaa, 0x28, 0x0b, 0xd6, 0x92, 0xd7, 0xe7, 0x53, 0x51,
0xf7, 0xe6, 0x46, 0x60, 0x3e, 0x1e, 0xf2, 0x50, 0xcc, 0xd2, 0x50, 0x97, 0x42, 0x4a, 0x66, 0xe3, 0xfa, 0xa7, 0x97, 0x12, 0xf3, 0xc9, 0x90, 0x47, 0x72, 0x96, 0x46, 0xba, 0x14, 0x51, 0x32, 0x9b,
0x35, 0x85, 0x6b, 0x32, 0xad, 0xfe, 0x0a, 0x1c, 0x4e, 0xe9, 0x20, 0x96, 0xf1, 0x5d, 0xc1, 0xbf, 0xac, 0x28, 0x5a, 0x91, 0x91, 0x06, 0x3f, 0xc0, 0xe5, 0x94, 0x0e, 0x44, 0x29, 0xc6, 0x05, 0xff,
0xb3, 0x0e, 0x34, 0x64, 0x31, 0xc3, 0xdc, 0xad, 0x75, 0x6b, 0x97, 0x67, 0x91, 0x01, 0xac, 0x0b, 0xc4, 0x4e, 0xa0, 0x59, 0x16, 0x33, 0xcc, 0x3d, 0xa7, 0xeb, 0x9c, 0x1d, 0xc5, 0x06, 0xb0, 0x2e,
0x4e, 0x21, 0xb0, 0x8c, 0x65, 0x56, 0xe4, 0xc3, 0x81, 0x5b, 0xd7, 0x35, 0x9b, 0x62, 0x01, 0xb4, 0xb8, 0x85, 0x44, 0x25, 0xca, 0xac, 0xc8, 0x87, 0x03, 0xaf, 0xa1, 0x6b, 0x36, 0xc5, 0x5e, 0x43,
0x16, 0x46, 0xc6, 0x3d, 0xe9, 0xd6, 0x2e, 0x9d, 0x5e, 0x27, 0x28, 0x94, 0x77, 0xb6, 0x18, 0x53, 0x7b, 0x61, 0x6c, 0xbc, 0x83, 0xae, 0x73, 0xe6, 0xf6, 0xfc, 0x90, 0x50, 0x7d, 0x45, 0x35, 0x11,
0x32, 0x0b, 0x2a, 0x8b, 0x68, 0xd3, 0xe4, 0x8f, 0x2d, 0xdb, 0x41, 0xdf, 0x1e, 0xaf, 0x1d, 0x31, 0x32, 0x9b, 0x48, 0xa1, 0xc4, 0x82, 0xc2, 0xba, 0x51, 0xbc, 0x96, 0x06, 0x68, 0x35, 0x1f, 0xf4,
0xfe, 0xff, 0x05, 0xf9, 0x13, 0x68, 0xdf, 0xae, 0x68, 0x6a, 0x67, 0xeb, 0x82, 0x73, 0x63, 0x0d, 0x6d, 0x13, 0x67, 0x6f, 0x93, 0xdd, 0xc3, 0x05, 0x19, 0x74, 0xae, 0x6e, 0x69, 0x6a, 0xe7, 0xec,
0x99, 0x84, 0x36, 0x65, 0x2f, 0xa3, 0x7e, 0x4c, 0x8a, 0x6f, 0xc0, 0x3e, 0xa1, 0xe4, 0xf1, 0xc3, 0x82, 0x7b, 0x69, 0xfd, 0x64, 0xd2, 0xda, 0x94, 0x3d, 0x4c, 0x63, 0xff, 0x44, 0x1f, 0x81, 0xbd,
0xc7, 0x3c, 0xe1, 0x59, 0x3e, 0xc2, 0x65, 0x84, 0x4b, 0xf6, 0x0a, 0x9a, 0x3f, 0x08, 0xcb, 0xad, 0xc3, 0x92, 0x8b, 0xbb, 0xb7, 0x79, 0xc2, 0xb3, 0x7c, 0x84, 0xcb, 0x18, 0x97, 0xec, 0x19, 0xb4,
0x45, 0x85, 0x9e, 0xfa, 0xd7, 0xf7, 0xfc, 0xfd, 0x35, 0x9c, 0xef, 0xe9, 0x91, 0x60, 0x2e, 0xb4, 0x3e, 0x13, 0xaa, 0x4d, 0xa3, 0x1a, 0x3d, 0x9e, 0xa2, 0xb1, 0x35, 0x45, 0xb0, 0x82, 0xe3, 0x2d,
0xae, 0xcb, 0xf2, 0xaa, 0x48, 0x50, 0x2b, 0x36, 0xa2, 0x0d, 0x54, 0x56, 0xd7, 0x65, 0xc9, 0x29, 0x3f, 0x92, 0xcc, 0x83, 0xf6, 0x85, 0x52, 0xe7, 0x45, 0x82, 0xda, 0xb1, 0x19, 0xaf, 0x61, 0xd5,
0xad, 0xd4, 0x2a, 0xa4, 0x78, 0x1e, 0x3f, 0x8c, 0x70, 0xa9, 0x77, 0xe3, 0x24, 0xaa, 0x90, 0xe6, 0xea, 0x42, 0x29, 0x4e, 0x69, 0xed, 0x56, 0xa3, 0x8a, 0xe7, 0xe2, 0x6e, 0x84, 0x4b, 0xbd, 0x3f,
0xb5, 0xae, 0x7b, 0x5a, 0xf1, 0x1a, 0xf9, 0x12, 0x60, 0x84, 0x79, 0xc2, 0x29, 0x55, 0x01, 0x9e, 0x07, 0x71, 0x8d, 0x34, 0xaf, 0x7d, 0xbd, 0xc3, 0x9a, 0xd7, 0x28, 0xf8, 0x0e, 0x30, 0xc2, 0x3c,
0xeb, 0x10, 0xfc, 0xa9, 0x81, 0xb3, 0xb5, 0x35, 0x39, 0x71, 0x37, 0x27, 0x3e, 0xe6, 0xc4, 0x9d, 0xe1, 0x94, 0x56, 0x01, 0xfe, 0xef, 0xb1, 0xf8, 0xe9, 0x80, 0xbb, 0x69, 0x6e, 0xd2, 0xe2, 0xc3,
0x9c, 0x06, 0xa9, 0x35, 0x11, 0x96, 0xbf, 0x50, 0x81, 0xe1, 0x40, 0x87, 0x3a, 0x8b, 0x6c, 0x4a, 0xb4, 0x78, 0x9f, 0x16, 0x1f, 0xa4, 0x35, 0xa8, 0x9a, 0xcc, 0xf4, 0xe1, 0x94, 0x0e, 0x07, 0x3a,
0x75, 0x4c, 0xe6, 0x19, 0xe6, 0xd2, 0x74, 0x34, 0x4c, 0x87, 0x45, 0x31, 0x0f, 0x5e, 0x10, 0xe6, 0xda, 0x51, 0x6c, 0x53, 0x95, 0xe2, 0x66, 0x9e, 0x61, 0x5e, 0x1a, 0x45, 0xd3, 0x28, 0x2c, 0x8a,
0xc9, 0x5d, 0xb6, 0x40, 0xb7, 0xa9, 0xff, 0xca, 0x16, 0xf7, 0xfe, 0xd6, 0xe1, 0x54, 0xdd, 0x24, 0xf9, 0xf0, 0x84, 0x30, 0x4f, 0xc6, 0xd9, 0x02, 0xbd, 0x96, 0x5e, 0x9b, 0x0d, 0xee, 0xfd, 0x6a,
0xf6, 0x05, 0xda, 0x4f, 0x76, 0x86, 0x79, 0x81, 0xb9, 0x65, 0xc1, 0xfe, 0x11, 0xf0, 0x2e, 0x0e, 0xc0, 0x61, 0x75, 0xc3, 0xd8, 0x7b, 0xe8, 0x3c, 0xda, 0x1f, 0xe6, 0x87, 0xe6, 0xf6, 0x85, 0xdb,
0xd6, 0x48, 0xb0, 0xcf, 0xe0, 0xdc, 0xae, 0xe6, 0x73, 0x8e, 0x44, 0x71, 0x8a, 0xec, 0x62, 0xe7, 0x07, 0xc1, 0x7f, 0xfe, 0xd7, 0x1a, 0x49, 0x36, 0x06, 0xf7, 0xea, 0x76, 0x3e, 0xe7, 0x48, 0x24,
0x27, 0x59, 0x15, 0x25, 0xf4, 0xfa, 0x70, 0x91, 0x04, 0x9b, 0x40, 0xc7, 0xa2, 0xfa, 0xbf, 0x47, 0x52, 0x64, 0xa7, 0x7f, 0x58, 0x2a, 0xab, 0x5e, 0xd9, 0x05, 0xbb, 0x24, 0x24, 0x59, 0x01, 0x27,
0xb8, 0xfc, 0x9a, 0x91, 0x64, 0x6f, 0x0f, 0x4d, 0x6d, 0x5b, 0x94, 0xf6, 0xbb, 0x23, 0xba, 0x48, 0x16, 0xd5, 0xff, 0x36, 0xc2, 0xe5, 0x87, 0x8c, 0x4a, 0xf6, 0xe2, 0xdf, 0xff, 0x6e, 0x84, 0x55,
0xb0, 0x1e, 0xb4, 0xaa, 0x4d, 0x62, 0x6c, 0x13, 0xeb, 0xf1, 0xb0, 0x78, 0xe7, 0x7b, 0x1c, 0x89, 0x9f, 0x97, 0x7b, 0x6b, 0x49, 0xb2, 0x1e, 0xb4, 0xeb, 0xcd, 0x63, 0x6c, 0x1d, 0xf7, 0xfe, 0x28,
0x7e, 0xfb, 0xe7, 0xcb, 0x40, 0x3f, 0x48, 0x1f, 0x4c, 0xf1, 0xbe, 0xa9, 0x5f, 0x9b, 0xf7, 0xff, 0xf9, 0xc7, 0x5b, 0x1c, 0xc9, 0x7e, 0xe7, 0xcb, 0xd3, 0x50, 0x3f, 0x60, 0x6f, 0x4c, 0xf1, 0xba,
0x02, 0x00, 0x00, 0xff, 0xff, 0xb3, 0x57, 0x8f, 0x13, 0xab, 0x04, 0x00, 0x00, 0xa5, 0x5f, 0xa7, 0x57, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xb4, 0x87, 0x05, 0xdb, 0x04,
0x00, 0x00,
} }

@ -6,18 +6,18 @@ option go_package = "./chat;pbChat";//The generated go pb file is in the current
message MsgDataToMQ{ message MsgDataToMQ{
string token =1; string token =1;
string operationID = 2; string operationID = 2;
open_im_sdk.MsgData msgData = 3; server_api_params.MsgData msgData = 3;
} }
message MsgDataToDB { message MsgDataToDB {
open_im_sdk.MsgData msgData = 1; server_api_params.MsgData msgData = 1;
string operationID = 2; string operationID = 2;
} }
message PushMsgDataToMQ{ message PushMsgDataToMQ{
string OperationID = 1; string OperationID = 1;
open_im_sdk.MsgData msgData = 2; server_api_params.MsgData msgData = 2;
} }
//message PullMessageReq { //message PullMessageReq {
@ -87,7 +87,7 @@ message SendMsgReq {
string token =1; string token =1;
string operationID = 2; string operationID = 2;
open_im_sdk.MsgData msgData = 3; server_api_params.MsgData msgData = 3;
} }
@ -102,7 +102,7 @@ message SendMsgResp {
} }
service Chat { service Chat {
rpc GetMaxAndMinSeq(GetMaxAndMinSeqReq) returns(GetMaxAndMinSeqResp); rpc GetMaxAndMinSeq(GetMaxAndMinSeqReq) returns(GetMaxAndMinSeqResp);
rpc PullMessage(open_im_sdk.PullMessageReq) returns(open_im_sdk.PullMessageResp); rpc PullMessage(server_api_params.PullMessageReq) returns(server_api_params.PullMessageResp);
rpc PullMessageBySeqList(open_im_sdk.PullMessageBySeqListReq) returns(open_im_sdk.PullMessageBySeqListResp); rpc PullMessageBySeqList(server_api_params.PullMessageBySeqListReq) returns(server_api_params.PullMessageBySeqListResp);
rpc SendMsg(SendMsgReq) returns(SendMsgResp); rpc SendMsg(SendMsgReq) returns(SendMsgResp);
} }

@ -36,7 +36,7 @@ func (m *CommonResp) Reset() { *m = CommonResp{} }
func (m *CommonResp) String() string { return proto.CompactTextString(m) } func (m *CommonResp) String() string { return proto.CompactTextString(m) }
func (*CommonResp) ProtoMessage() {} func (*CommonResp) ProtoMessage() {}
func (*CommonResp) Descriptor() ([]byte, []int) { func (*CommonResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{0} return fileDescriptor_friend_74b4824fb8c5de90, []int{0}
} }
func (m *CommonResp) XXX_Unmarshal(b []byte) error { func (m *CommonResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CommonResp.Unmarshal(m, b) return xxx_messageInfo_CommonResp.Unmarshal(m, b)
@ -84,7 +84,7 @@ func (m *CommID) Reset() { *m = CommID{} }
func (m *CommID) String() string { return proto.CompactTextString(m) } func (m *CommID) String() string { return proto.CompactTextString(m) }
func (*CommID) ProtoMessage() {} func (*CommID) ProtoMessage() {}
func (*CommID) Descriptor() ([]byte, []int) { func (*CommID) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{1} return fileDescriptor_friend_74b4824fb8c5de90, []int{1}
} }
func (m *CommID) XXX_Unmarshal(b []byte) error { func (m *CommID) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CommID.Unmarshal(m, b) return xxx_messageInfo_CommID.Unmarshal(m, b)
@ -143,7 +143,7 @@ func (m *GetFriendsInfoReq) Reset() { *m = GetFriendsInfoReq{} }
func (m *GetFriendsInfoReq) String() string { return proto.CompactTextString(m) } func (m *GetFriendsInfoReq) String() string { return proto.CompactTextString(m) }
func (*GetFriendsInfoReq) ProtoMessage() {} func (*GetFriendsInfoReq) ProtoMessage() {}
func (*GetFriendsInfoReq) Descriptor() ([]byte, []int) { func (*GetFriendsInfoReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{2} return fileDescriptor_friend_74b4824fb8c5de90, []int{2}
} }
func (m *GetFriendsInfoReq) XXX_Unmarshal(b []byte) error { func (m *GetFriendsInfoReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetFriendsInfoReq.Unmarshal(m, b) return xxx_messageInfo_GetFriendsInfoReq.Unmarshal(m, b)
@ -183,7 +183,7 @@ func (m *GetFriendInfoResp) Reset() { *m = GetFriendInfoResp{} }
func (m *GetFriendInfoResp) String() string { return proto.CompactTextString(m) } func (m *GetFriendInfoResp) String() string { return proto.CompactTextString(m) }
func (*GetFriendInfoResp) ProtoMessage() {} func (*GetFriendInfoResp) ProtoMessage() {}
func (*GetFriendInfoResp) Descriptor() ([]byte, []int) { func (*GetFriendInfoResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{3} return fileDescriptor_friend_74b4824fb8c5de90, []int{3}
} }
func (m *GetFriendInfoResp) XXX_Unmarshal(b []byte) error { func (m *GetFriendInfoResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetFriendInfoResp.Unmarshal(m, b) return xxx_messageInfo_GetFriendInfoResp.Unmarshal(m, b)
@ -236,7 +236,7 @@ func (m *AddFriendReq) Reset() { *m = AddFriendReq{} }
func (m *AddFriendReq) String() string { return proto.CompactTextString(m) } func (m *AddFriendReq) String() string { return proto.CompactTextString(m) }
func (*AddFriendReq) ProtoMessage() {} func (*AddFriendReq) ProtoMessage() {}
func (*AddFriendReq) Descriptor() ([]byte, []int) { func (*AddFriendReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{4} return fileDescriptor_friend_74b4824fb8c5de90, []int{4}
} }
func (m *AddFriendReq) XXX_Unmarshal(b []byte) error { func (m *AddFriendReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AddFriendReq.Unmarshal(m, b) return xxx_messageInfo_AddFriendReq.Unmarshal(m, b)
@ -281,7 +281,7 @@ func (m *AddFriendResp) Reset() { *m = AddFriendResp{} }
func (m *AddFriendResp) String() string { return proto.CompactTextString(m) } func (m *AddFriendResp) String() string { return proto.CompactTextString(m) }
func (*AddFriendResp) ProtoMessage() {} func (*AddFriendResp) ProtoMessage() {}
func (*AddFriendResp) Descriptor() ([]byte, []int) { func (*AddFriendResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{5} return fileDescriptor_friend_74b4824fb8c5de90, []int{5}
} }
func (m *AddFriendResp) XXX_Unmarshal(b []byte) error { func (m *AddFriendResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AddFriendResp.Unmarshal(m, b) return xxx_messageInfo_AddFriendResp.Unmarshal(m, b)
@ -322,7 +322,7 @@ func (m *ImportFriendReq) Reset() { *m = ImportFriendReq{} }
func (m *ImportFriendReq) String() string { return proto.CompactTextString(m) } func (m *ImportFriendReq) String() string { return proto.CompactTextString(m) }
func (*ImportFriendReq) ProtoMessage() {} func (*ImportFriendReq) ProtoMessage() {}
func (*ImportFriendReq) Descriptor() ([]byte, []int) { func (*ImportFriendReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{6} return fileDescriptor_friend_74b4824fb8c5de90, []int{6}
} }
func (m *ImportFriendReq) XXX_Unmarshal(b []byte) error { func (m *ImportFriendReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ImportFriendReq.Unmarshal(m, b) return xxx_messageInfo_ImportFriendReq.Unmarshal(m, b)
@ -382,7 +382,7 @@ func (m *UserIDResult) Reset() { *m = UserIDResult{} }
func (m *UserIDResult) String() string { return proto.CompactTextString(m) } func (m *UserIDResult) String() string { return proto.CompactTextString(m) }
func (*UserIDResult) ProtoMessage() {} func (*UserIDResult) ProtoMessage() {}
func (*UserIDResult) Descriptor() ([]byte, []int) { func (*UserIDResult) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{7} return fileDescriptor_friend_74b4824fb8c5de90, []int{7}
} }
func (m *UserIDResult) XXX_Unmarshal(b []byte) error { func (m *UserIDResult) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserIDResult.Unmarshal(m, b) return xxx_messageInfo_UserIDResult.Unmarshal(m, b)
@ -428,7 +428,7 @@ func (m *ImportFriendResp) Reset() { *m = ImportFriendResp{} }
func (m *ImportFriendResp) String() string { return proto.CompactTextString(m) } func (m *ImportFriendResp) String() string { return proto.CompactTextString(m) }
func (*ImportFriendResp) ProtoMessage() {} func (*ImportFriendResp) ProtoMessage() {}
func (*ImportFriendResp) Descriptor() ([]byte, []int) { func (*ImportFriendResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{8} return fileDescriptor_friend_74b4824fb8c5de90, []int{8}
} }
func (m *ImportFriendResp) XXX_Unmarshal(b []byte) error { func (m *ImportFriendResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ImportFriendResp.Unmarshal(m, b) return xxx_messageInfo_ImportFriendResp.Unmarshal(m, b)
@ -473,7 +473,7 @@ func (m *GetFriendApplyListReq) Reset() { *m = GetFriendApplyListReq{} }
func (m *GetFriendApplyListReq) String() string { return proto.CompactTextString(m) } func (m *GetFriendApplyListReq) String() string { return proto.CompactTextString(m) }
func (*GetFriendApplyListReq) ProtoMessage() {} func (*GetFriendApplyListReq) ProtoMessage() {}
func (*GetFriendApplyListReq) Descriptor() ([]byte, []int) { func (*GetFriendApplyListReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{9} return fileDescriptor_friend_74b4824fb8c5de90, []int{9}
} }
func (m *GetFriendApplyListReq) XXX_Unmarshal(b []byte) error { func (m *GetFriendApplyListReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetFriendApplyListReq.Unmarshal(m, b) return xxx_messageInfo_GetFriendApplyListReq.Unmarshal(m, b)
@ -513,7 +513,7 @@ func (m *GetFriendApplyListResp) Reset() { *m = GetFriendApplyListResp{}
func (m *GetFriendApplyListResp) String() string { return proto.CompactTextString(m) } func (m *GetFriendApplyListResp) String() string { return proto.CompactTextString(m) }
func (*GetFriendApplyListResp) ProtoMessage() {} func (*GetFriendApplyListResp) ProtoMessage() {}
func (*GetFriendApplyListResp) Descriptor() ([]byte, []int) { func (*GetFriendApplyListResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{10} return fileDescriptor_friend_74b4824fb8c5de90, []int{10}
} }
func (m *GetFriendApplyListResp) XXX_Unmarshal(b []byte) error { func (m *GetFriendApplyListResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetFriendApplyListResp.Unmarshal(m, b) return xxx_messageInfo_GetFriendApplyListResp.Unmarshal(m, b)
@ -565,7 +565,7 @@ func (m *GetFriendListReq) Reset() { *m = GetFriendListReq{} }
func (m *GetFriendListReq) String() string { return proto.CompactTextString(m) } func (m *GetFriendListReq) String() string { return proto.CompactTextString(m) }
func (*GetFriendListReq) ProtoMessage() {} func (*GetFriendListReq) ProtoMessage() {}
func (*GetFriendListReq) Descriptor() ([]byte, []int) { func (*GetFriendListReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{11} return fileDescriptor_friend_74b4824fb8c5de90, []int{11}
} }
func (m *GetFriendListReq) XXX_Unmarshal(b []byte) error { func (m *GetFriendListReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetFriendListReq.Unmarshal(m, b) return xxx_messageInfo_GetFriendListReq.Unmarshal(m, b)
@ -605,7 +605,7 @@ func (m *GetFriendListResp) Reset() { *m = GetFriendListResp{} }
func (m *GetFriendListResp) String() string { return proto.CompactTextString(m) } func (m *GetFriendListResp) String() string { return proto.CompactTextString(m) }
func (*GetFriendListResp) ProtoMessage() {} func (*GetFriendListResp) ProtoMessage() {}
func (*GetFriendListResp) Descriptor() ([]byte, []int) { func (*GetFriendListResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{12} return fileDescriptor_friend_74b4824fb8c5de90, []int{12}
} }
func (m *GetFriendListResp) XXX_Unmarshal(b []byte) error { func (m *GetFriendListResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetFriendListResp.Unmarshal(m, b) return xxx_messageInfo_GetFriendListResp.Unmarshal(m, b)
@ -657,7 +657,7 @@ func (m *AddBlacklistReq) Reset() { *m = AddBlacklistReq{} }
func (m *AddBlacklistReq) String() string { return proto.CompactTextString(m) } func (m *AddBlacklistReq) String() string { return proto.CompactTextString(m) }
func (*AddBlacklistReq) ProtoMessage() {} func (*AddBlacklistReq) ProtoMessage() {}
func (*AddBlacklistReq) Descriptor() ([]byte, []int) { func (*AddBlacklistReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{13} return fileDescriptor_friend_74b4824fb8c5de90, []int{13}
} }
func (m *AddBlacklistReq) XXX_Unmarshal(b []byte) error { func (m *AddBlacklistReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AddBlacklistReq.Unmarshal(m, b) return xxx_messageInfo_AddBlacklistReq.Unmarshal(m, b)
@ -695,7 +695,7 @@ func (m *AddBlacklistResp) Reset() { *m = AddBlacklistResp{} }
func (m *AddBlacklistResp) String() string { return proto.CompactTextString(m) } func (m *AddBlacklistResp) String() string { return proto.CompactTextString(m) }
func (*AddBlacklistResp) ProtoMessage() {} func (*AddBlacklistResp) ProtoMessage() {}
func (*AddBlacklistResp) Descriptor() ([]byte, []int) { func (*AddBlacklistResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{14} return fileDescriptor_friend_74b4824fb8c5de90, []int{14}
} }
func (m *AddBlacklistResp) XXX_Unmarshal(b []byte) error { func (m *AddBlacklistResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AddBlacklistResp.Unmarshal(m, b) return xxx_messageInfo_AddBlacklistResp.Unmarshal(m, b)
@ -733,7 +733,7 @@ func (m *RemoveBlacklistReq) Reset() { *m = RemoveBlacklistReq{} }
func (m *RemoveBlacklistReq) String() string { return proto.CompactTextString(m) } func (m *RemoveBlacklistReq) String() string { return proto.CompactTextString(m) }
func (*RemoveBlacklistReq) ProtoMessage() {} func (*RemoveBlacklistReq) ProtoMessage() {}
func (*RemoveBlacklistReq) Descriptor() ([]byte, []int) { func (*RemoveBlacklistReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{15} return fileDescriptor_friend_74b4824fb8c5de90, []int{15}
} }
func (m *RemoveBlacklistReq) XXX_Unmarshal(b []byte) error { func (m *RemoveBlacklistReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RemoveBlacklistReq.Unmarshal(m, b) return xxx_messageInfo_RemoveBlacklistReq.Unmarshal(m, b)
@ -771,7 +771,7 @@ func (m *RemoveBlacklistResp) Reset() { *m = RemoveBlacklistResp{} }
func (m *RemoveBlacklistResp) String() string { return proto.CompactTextString(m) } func (m *RemoveBlacklistResp) String() string { return proto.CompactTextString(m) }
func (*RemoveBlacklistResp) ProtoMessage() {} func (*RemoveBlacklistResp) ProtoMessage() {}
func (*RemoveBlacklistResp) Descriptor() ([]byte, []int) { func (*RemoveBlacklistResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{16} return fileDescriptor_friend_74b4824fb8c5de90, []int{16}
} }
func (m *RemoveBlacklistResp) XXX_Unmarshal(b []byte) error { func (m *RemoveBlacklistResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RemoveBlacklistResp.Unmarshal(m, b) return xxx_messageInfo_RemoveBlacklistResp.Unmarshal(m, b)
@ -809,7 +809,7 @@ func (m *GetBlacklistReq) Reset() { *m = GetBlacklistReq{} }
func (m *GetBlacklistReq) String() string { return proto.CompactTextString(m) } func (m *GetBlacklistReq) String() string { return proto.CompactTextString(m) }
func (*GetBlacklistReq) ProtoMessage() {} func (*GetBlacklistReq) ProtoMessage() {}
func (*GetBlacklistReq) Descriptor() ([]byte, []int) { func (*GetBlacklistReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{17} return fileDescriptor_friend_74b4824fb8c5de90, []int{17}
} }
func (m *GetBlacklistReq) XXX_Unmarshal(b []byte) error { func (m *GetBlacklistReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetBlacklistReq.Unmarshal(m, b) return xxx_messageInfo_GetBlacklistReq.Unmarshal(m, b)
@ -849,7 +849,7 @@ func (m *GetBlacklistResp) Reset() { *m = GetBlacklistResp{} }
func (m *GetBlacklistResp) String() string { return proto.CompactTextString(m) } func (m *GetBlacklistResp) String() string { return proto.CompactTextString(m) }
func (*GetBlacklistResp) ProtoMessage() {} func (*GetBlacklistResp) ProtoMessage() {}
func (*GetBlacklistResp) Descriptor() ([]byte, []int) { func (*GetBlacklistResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{18} return fileDescriptor_friend_74b4824fb8c5de90, []int{18}
} }
func (m *GetBlacklistResp) XXX_Unmarshal(b []byte) error { func (m *GetBlacklistResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetBlacklistResp.Unmarshal(m, b) return xxx_messageInfo_GetBlacklistResp.Unmarshal(m, b)
@ -901,7 +901,7 @@ func (m *IsFriendReq) Reset() { *m = IsFriendReq{} }
func (m *IsFriendReq) String() string { return proto.CompactTextString(m) } func (m *IsFriendReq) String() string { return proto.CompactTextString(m) }
func (*IsFriendReq) ProtoMessage() {} func (*IsFriendReq) ProtoMessage() {}
func (*IsFriendReq) Descriptor() ([]byte, []int) { func (*IsFriendReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{19} return fileDescriptor_friend_74b4824fb8c5de90, []int{19}
} }
func (m *IsFriendReq) XXX_Unmarshal(b []byte) error { func (m *IsFriendReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_IsFriendReq.Unmarshal(m, b) return xxx_messageInfo_IsFriendReq.Unmarshal(m, b)
@ -941,7 +941,7 @@ func (m *IsFriendResp) Reset() { *m = IsFriendResp{} }
func (m *IsFriendResp) String() string { return proto.CompactTextString(m) } func (m *IsFriendResp) String() string { return proto.CompactTextString(m) }
func (*IsFriendResp) ProtoMessage() {} func (*IsFriendResp) ProtoMessage() {}
func (*IsFriendResp) Descriptor() ([]byte, []int) { func (*IsFriendResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{20} return fileDescriptor_friend_74b4824fb8c5de90, []int{20}
} }
func (m *IsFriendResp) XXX_Unmarshal(b []byte) error { func (m *IsFriendResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_IsFriendResp.Unmarshal(m, b) return xxx_messageInfo_IsFriendResp.Unmarshal(m, b)
@ -993,7 +993,7 @@ func (m *IsInBlackListReq) Reset() { *m = IsInBlackListReq{} }
func (m *IsInBlackListReq) String() string { return proto.CompactTextString(m) } func (m *IsInBlackListReq) String() string { return proto.CompactTextString(m) }
func (*IsInBlackListReq) ProtoMessage() {} func (*IsInBlackListReq) ProtoMessage() {}
func (*IsInBlackListReq) Descriptor() ([]byte, []int) { func (*IsInBlackListReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{21} return fileDescriptor_friend_74b4824fb8c5de90, []int{21}
} }
func (m *IsInBlackListReq) XXX_Unmarshal(b []byte) error { func (m *IsInBlackListReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_IsInBlackListReq.Unmarshal(m, b) return xxx_messageInfo_IsInBlackListReq.Unmarshal(m, b)
@ -1033,7 +1033,7 @@ func (m *IsInBlackListResp) Reset() { *m = IsInBlackListResp{} }
func (m *IsInBlackListResp) String() string { return proto.CompactTextString(m) } func (m *IsInBlackListResp) String() string { return proto.CompactTextString(m) }
func (*IsInBlackListResp) ProtoMessage() {} func (*IsInBlackListResp) ProtoMessage() {}
func (*IsInBlackListResp) Descriptor() ([]byte, []int) { func (*IsInBlackListResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{22} return fileDescriptor_friend_74b4824fb8c5de90, []int{22}
} }
func (m *IsInBlackListResp) XXX_Unmarshal(b []byte) error { func (m *IsInBlackListResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_IsInBlackListResp.Unmarshal(m, b) return xxx_messageInfo_IsInBlackListResp.Unmarshal(m, b)
@ -1085,7 +1085,7 @@ func (m *DeleteFriendReq) Reset() { *m = DeleteFriendReq{} }
func (m *DeleteFriendReq) String() string { return proto.CompactTextString(m) } func (m *DeleteFriendReq) String() string { return proto.CompactTextString(m) }
func (*DeleteFriendReq) ProtoMessage() {} func (*DeleteFriendReq) ProtoMessage() {}
func (*DeleteFriendReq) Descriptor() ([]byte, []int) { func (*DeleteFriendReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{23} return fileDescriptor_friend_74b4824fb8c5de90, []int{23}
} }
func (m *DeleteFriendReq) XXX_Unmarshal(b []byte) error { func (m *DeleteFriendReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteFriendReq.Unmarshal(m, b) return xxx_messageInfo_DeleteFriendReq.Unmarshal(m, b)
@ -1123,7 +1123,7 @@ func (m *DeleteFriendResp) Reset() { *m = DeleteFriendResp{} }
func (m *DeleteFriendResp) String() string { return proto.CompactTextString(m) } func (m *DeleteFriendResp) String() string { return proto.CompactTextString(m) }
func (*DeleteFriendResp) ProtoMessage() {} func (*DeleteFriendResp) ProtoMessage() {}
func (*DeleteFriendResp) Descriptor() ([]byte, []int) { func (*DeleteFriendResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{24} return fileDescriptor_friend_74b4824fb8c5de90, []int{24}
} }
func (m *DeleteFriendResp) XXX_Unmarshal(b []byte) error { func (m *DeleteFriendResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteFriendResp.Unmarshal(m, b) return xxx_messageInfo_DeleteFriendResp.Unmarshal(m, b)
@ -1153,7 +1153,7 @@ func (m *DeleteFriendResp) GetCommonResp() *CommonResp {
// process // process
type AddFriendResponseReq struct { type AddFriendResponseReq struct {
CommID *CommID `protobuf:"bytes,1,opt,name=CommID" json:"CommID,omitempty"` CommID *CommID `protobuf:"bytes,1,opt,name=CommID" json:"CommID,omitempty"`
Flag int32 `protobuf:"varint,2,opt,name=flag" json:"flag,omitempty"` HandleResult int32 `protobuf:"varint,2,opt,name=handleResult" json:"handleResult,omitempty"`
HandleMsg string `protobuf:"bytes,3,opt,name=handleMsg" json:"handleMsg,omitempty"` HandleMsg string `protobuf:"bytes,3,opt,name=handleMsg" json:"handleMsg,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
@ -1164,7 +1164,7 @@ func (m *AddFriendResponseReq) Reset() { *m = AddFriendResponseReq{} }
func (m *AddFriendResponseReq) String() string { return proto.CompactTextString(m) } func (m *AddFriendResponseReq) String() string { return proto.CompactTextString(m) }
func (*AddFriendResponseReq) ProtoMessage() {} func (*AddFriendResponseReq) ProtoMessage() {}
func (*AddFriendResponseReq) Descriptor() ([]byte, []int) { func (*AddFriendResponseReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{25} return fileDescriptor_friend_74b4824fb8c5de90, []int{25}
} }
func (m *AddFriendResponseReq) XXX_Unmarshal(b []byte) error { func (m *AddFriendResponseReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AddFriendResponseReq.Unmarshal(m, b) return xxx_messageInfo_AddFriendResponseReq.Unmarshal(m, b)
@ -1191,9 +1191,9 @@ func (m *AddFriendResponseReq) GetCommID() *CommID {
return nil return nil
} }
func (m *AddFriendResponseReq) GetFlag() int32 { func (m *AddFriendResponseReq) GetHandleResult() int32 {
if m != nil { if m != nil {
return m.Flag return m.HandleResult
} }
return 0 return 0
} }
@ -1216,7 +1216,7 @@ func (m *AddFriendResponseResp) Reset() { *m = AddFriendResponseResp{} }
func (m *AddFriendResponseResp) String() string { return proto.CompactTextString(m) } func (m *AddFriendResponseResp) String() string { return proto.CompactTextString(m) }
func (*AddFriendResponseResp) ProtoMessage() {} func (*AddFriendResponseResp) ProtoMessage() {}
func (*AddFriendResponseResp) Descriptor() ([]byte, []int) { func (*AddFriendResponseResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{26} return fileDescriptor_friend_74b4824fb8c5de90, []int{26}
} }
func (m *AddFriendResponseResp) XXX_Unmarshal(b []byte) error { func (m *AddFriendResponseResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AddFriendResponseResp.Unmarshal(m, b) return xxx_messageInfo_AddFriendResponseResp.Unmarshal(m, b)
@ -1255,7 +1255,7 @@ func (m *SetFriendRemarkReq) Reset() { *m = SetFriendRemarkReq{} }
func (m *SetFriendRemarkReq) String() string { return proto.CompactTextString(m) } func (m *SetFriendRemarkReq) String() string { return proto.CompactTextString(m) }
func (*SetFriendRemarkReq) ProtoMessage() {} func (*SetFriendRemarkReq) ProtoMessage() {}
func (*SetFriendRemarkReq) Descriptor() ([]byte, []int) { func (*SetFriendRemarkReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{27} return fileDescriptor_friend_74b4824fb8c5de90, []int{27}
} }
func (m *SetFriendRemarkReq) XXX_Unmarshal(b []byte) error { func (m *SetFriendRemarkReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetFriendRemarkReq.Unmarshal(m, b) return xxx_messageInfo_SetFriendRemarkReq.Unmarshal(m, b)
@ -1300,7 +1300,7 @@ func (m *SetFriendRemarkResp) Reset() { *m = SetFriendRemarkResp{} }
func (m *SetFriendRemarkResp) String() string { return proto.CompactTextString(m) } func (m *SetFriendRemarkResp) String() string { return proto.CompactTextString(m) }
func (*SetFriendRemarkResp) ProtoMessage() {} func (*SetFriendRemarkResp) ProtoMessage() {}
func (*SetFriendRemarkResp) Descriptor() ([]byte, []int) { func (*SetFriendRemarkResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{28} return fileDescriptor_friend_74b4824fb8c5de90, []int{28}
} }
func (m *SetFriendRemarkResp) XXX_Unmarshal(b []byte) error { func (m *SetFriendRemarkResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetFriendRemarkResp.Unmarshal(m, b) return xxx_messageInfo_SetFriendRemarkResp.Unmarshal(m, b)
@ -1338,7 +1338,7 @@ func (m *GetSelfApplyListReq) Reset() { *m = GetSelfApplyListReq{} }
func (m *GetSelfApplyListReq) String() string { return proto.CompactTextString(m) } func (m *GetSelfApplyListReq) String() string { return proto.CompactTextString(m) }
func (*GetSelfApplyListReq) ProtoMessage() {} func (*GetSelfApplyListReq) ProtoMessage() {}
func (*GetSelfApplyListReq) Descriptor() ([]byte, []int) { func (*GetSelfApplyListReq) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{29} return fileDescriptor_friend_74b4824fb8c5de90, []int{29}
} }
func (m *GetSelfApplyListReq) XXX_Unmarshal(b []byte) error { func (m *GetSelfApplyListReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetSelfApplyListReq.Unmarshal(m, b) return xxx_messageInfo_GetSelfApplyListReq.Unmarshal(m, b)
@ -1378,7 +1378,7 @@ func (m *GetSelfApplyListResp) Reset() { *m = GetSelfApplyListResp{} }
func (m *GetSelfApplyListResp) String() string { return proto.CompactTextString(m) } func (m *GetSelfApplyListResp) String() string { return proto.CompactTextString(m) }
func (*GetSelfApplyListResp) ProtoMessage() {} func (*GetSelfApplyListResp) ProtoMessage() {}
func (*GetSelfApplyListResp) Descriptor() ([]byte, []int) { func (*GetSelfApplyListResp) Descriptor() ([]byte, []int) {
return fileDescriptor_friend_74665a4d507faa8c, []int{30} return fileDescriptor_friend_74b4824fb8c5de90, []int{30}
} }
func (m *GetSelfApplyListResp) XXX_Unmarshal(b []byte) error { func (m *GetSelfApplyListResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetSelfApplyListResp.Unmarshal(m, b) return xxx_messageInfo_GetSelfApplyListResp.Unmarshal(m, b)
@ -1923,68 +1923,68 @@ var _Friend_serviceDesc = grpc.ServiceDesc{
Metadata: "friend/friend.proto", Metadata: "friend/friend.proto",
} }
func init() { proto.RegisterFile("friend/friend.proto", fileDescriptor_friend_74665a4d507faa8c) } func init() { proto.RegisterFile("friend/friend.proto", fileDescriptor_friend_74b4824fb8c5de90) }
var fileDescriptor_friend_74665a4d507faa8c = []byte{ var fileDescriptor_friend_74b4824fb8c5de90 = []byte{
// 945 bytes of a gzipped FileDescriptorProto // 950 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xcf, 0x8f, 0xdb, 0x44, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xcf, 0x8f, 0xdb, 0x44,
0x14, 0x96, 0x9b, 0xdd, 0x34, 0x79, 0x49, 0x9b, 0x64, 0x92, 0x6d, 0x83, 0x77, 0x5b, 0x05, 0x1f, 0x14, 0x96, 0x9b, 0x6e, 0x9a, 0xbc, 0xa4, 0x4d, 0x32, 0xc9, 0x96, 0xe0, 0xee, 0x56, 0xa9, 0x0f,
0x50, 0xc4, 0x21, 0x91, 0x82, 0x2a, 0xb1, 0x14, 0x5a, 0xd2, 0xcd, 0x66, 0x31, 0xb0, 0x6c, 0x35, 0x28, 0xe2, 0x90, 0x48, 0x41, 0x95, 0x58, 0x0a, 0x85, 0x74, 0x93, 0xac, 0x0c, 0x6c, 0x53, 0xcd,
0x5b, 0x2e, 0x08, 0x69, 0xe5, 0xd6, 0x93, 0x60, 0xc5, 0xb1, 0xa7, 0x1e, 0x2f, 0x15, 0x57, 0x0e, 0x96, 0x0b, 0x42, 0x8a, 0xdc, 0x7a, 0x36, 0x58, 0x71, 0xec, 0xa9, 0xc7, 0xdb, 0x15, 0x37, 0xc4,
0x88, 0x1b, 0x12, 0xe2, 0xc6, 0x81, 0x7f, 0x15, 0x79, 0xc6, 0x8e, 0x67, 0x6c, 0x6f, 0x85, 0x5d, 0x89, 0x03, 0x57, 0x24, 0x04, 0x07, 0xfe, 0x55, 0x64, 0x8f, 0x1d, 0xcf, 0xd8, 0xce, 0x0a, 0x9b,
0xa4, 0x9e, 0x92, 0x37, 0xef, 0x87, 0xdf, 0xfb, 0xde, 0x9b, 0xf7, 0xd9, 0xd0, 0x5f, 0x05, 0x0e, 0x3d, 0x70, 0xda, 0x7d, 0xef, 0xcd, 0xf7, 0xf2, 0x7e, 0xcd, 0xfb, 0xc6, 0xd0, 0xbd, 0xf4, 0x2c,
0xf1, 0xec, 0xa9, 0xf8, 0x99, 0xd0, 0xc0, 0x0f, 0x7d, 0x54, 0x17, 0x92, 0xfe, 0xe1, 0x05, 0x25, 0xe2, 0x98, 0x63, 0xfe, 0x67, 0x44, 0x3d, 0xd7, 0x77, 0x51, 0x95, 0x4b, 0xea, 0x93, 0x25, 0x25,
0xde, 0x95, 0x79, 0x3e, 0xa5, 0x9b, 0xf5, 0x94, 0xab, 0xa6, 0xcc, 0xde, 0x5c, 0xbd, 0x61, 0xd3, 0xce, 0x4a, 0x3f, 0x1f, 0xd3, 0xcd, 0x7a, 0x1c, 0x9a, 0xc6, 0xcc, 0xdc, 0xac, 0xae, 0xd9, 0xf8,
0x37, 0x4c, 0x98, 0x1a, 0x4f, 0x00, 0x4e, 0xfc, 0xed, 0xd6, 0xf7, 0x30, 0x61, 0x14, 0x0d, 0xe1, 0x9a, 0xf1, 0xa3, 0xda, 0x73, 0x80, 0x53, 0x77, 0xbb, 0x75, 0x1d, 0x4c, 0x18, 0x45, 0x7d, 0xb8,
0x36, 0x09, 0x82, 0x13, 0xdf, 0x26, 0x43, 0x6d, 0xa4, 0x8d, 0xf7, 0x71, 0x22, 0xa2, 0x7b, 0x50, 0x47, 0x3c, 0xef, 0xd4, 0x35, 0x49, 0x5f, 0x19, 0x28, 0xc3, 0x03, 0x1c, 0x8b, 0xe8, 0x21, 0x54,
0x27, 0x41, 0x70, 0xce, 0xd6, 0xc3, 0x5b, 0x23, 0x6d, 0xdc, 0xc4, 0xb1, 0x64, 0xfc, 0xaa, 0x41, 0x89, 0xe7, 0x9d, 0xb3, 0x75, 0xff, 0xce, 0x40, 0x19, 0xd6, 0x71, 0x24, 0x69, 0xbf, 0x28, 0x50,
0x3d, 0x0a, 0x60, 0x2e, 0x90, 0x0e, 0x8d, 0x0b, 0xfa, 0x3d, 0x23, 0x81, 0xb9, 0xe0, 0xde, 0x4d, 0x0d, 0x1c, 0xe8, 0x33, 0xa4, 0x42, 0x6d, 0x49, 0xbf, 0x63, 0xc4, 0xd3, 0x67, 0x21, 0xba, 0x8e,
0xbc, 0x93, 0xd1, 0x08, 0x5a, 0x17, 0x94, 0x04, 0x56, 0xe8, 0xf8, 0x9e, 0xb9, 0x88, 0x63, 0xc8, 0x77, 0x32, 0x1a, 0x40, 0x63, 0x49, 0x89, 0x67, 0xf8, 0x96, 0xeb, 0xe8, 0xb3, 0xc8, 0x87, 0xa8,
0x47, 0x91, 0xf7, 0x0b, 0x3f, 0xf6, 0xde, 0x13, 0xde, 0x89, 0x8c, 0x1e, 0x02, 0x2c, 0x03, 0x7f, 0x0a, 0xd0, 0xaf, 0xdd, 0x08, 0x7d, 0x97, 0xa3, 0x63, 0x19, 0x3d, 0x06, 0x58, 0x78, 0xee, 0x36,
0x1b, 0x6b, 0xf7, 0xb9, 0x56, 0x3a, 0x31, 0x1e, 0x43, 0xef, 0x8c, 0x84, 0x4b, 0x5e, 0x34, 0x33, 0xb2, 0x1e, 0x84, 0x56, 0x41, 0xa3, 0x3d, 0x83, 0xce, 0x19, 0xf1, 0x17, 0x61, 0xd2, 0x4c, 0x77,
0xbd, 0x95, 0x8f, 0xc9, 0x6b, 0xf4, 0x51, 0x92, 0x18, 0x4f, 0xa6, 0x35, 0xbb, 0x3b, 0x89, 0x31, 0x2e, 0x5d, 0x4c, 0xde, 0xa1, 0x8f, 0xe2, 0xc0, 0xc2, 0x60, 0x1a, 0x93, 0x07, 0xa3, 0xa8, 0x46,
0x12, 0xa7, 0x38, 0xd6, 0x1a, 0xbf, 0x69, 0x92, 0xb7, 0x70, 0x16, 0x48, 0x9c, 0xaa, 0x48, 0x9c, 0x5c, 0x8b, 0x23, 0xab, 0xf6, 0x9b, 0x22, 0xa0, 0x39, 0x98, 0x57, 0x62, 0x2e, 0x57, 0x62, 0x9e,
0xa6, 0x48, 0x9c, 0x2a, 0x48, 0x08, 0x09, 0x3d, 0x85, 0xbb, 0x69, 0x8c, 0x6f, 0x1d, 0x16, 0x0e, 0x54, 0x62, 0x2e, 0x55, 0x82, 0x4b, 0x68, 0x0e, 0x0f, 0x12, 0x1f, 0xdf, 0x5a, 0xcc, 0xef, 0x57,
0x6b, 0xa3, 0xda, 0xb8, 0x35, 0xbb, 0x3f, 0xf1, 0xa3, 0x2e, 0x38, 0xdb, 0x2b, 0x66, 0x6f, 0x26, 0x06, 0x95, 0x61, 0x63, 0x72, 0x3c, 0x62, 0xc4, 0x7b, 0x4f, 0xbc, 0x95, 0x41, 0xad, 0x15, 0x35,
0xd2, 0x63, 0x32, 0xe6, 0xc6, 0x77, 0xd0, 0x9e, 0xdb, 0xb6, 0x38, 0x2c, 0x51, 0x40, 0x94, 0x10, 0x3c, 0x63, 0xcb, 0x46, 0xc2, 0x8f, 0xa5, 0x40, 0xda, 0x4b, 0x68, 0x4e, 0x4d, 0x93, 0x2b, 0x0b,
0x26, 0xaf, 0xa5, 0x84, 0x84, 0x64, 0x9c, 0xc0, 0x1d, 0x29, 0x1e, 0xa3, 0x68, 0x26, 0xf7, 0x3a, 0xa4, 0x11, 0x84, 0x85, 0xc9, 0x3b, 0x21, 0x2c, 0x2e, 0x69, 0xa7, 0x70, 0x5f, 0xf0, 0xc7, 0x28,
0x0e, 0x8a, 0xe4, 0xa0, 0x42, 0x83, 0x25, 0x2b, 0xe3, 0x6f, 0x0d, 0x3a, 0xe6, 0x96, 0xfa, 0x41, 0x9a, 0x88, 0x1d, 0x8f, 0x9c, 0x22, 0xd1, 0x29, 0xb7, 0x60, 0xe1, 0x94, 0xf6, 0x97, 0x02, 0x2d,
0x98, 0x26, 0xf6, 0x31, 0x74, 0x85, 0x20, 0xe0, 0xe7, 0xb5, 0x6a, 0xa3, 0xda, 0xb8, 0x89, 0x73, 0x7d, 0x4b, 0x5d, 0xcf, 0x4f, 0x02, 0xfb, 0x18, 0xda, 0x5c, 0xe0, 0x4d, 0x08, 0x33, 0x56, 0x06,
0xe7, 0xff, 0xa1, 0xf1, 0x6a, 0x73, 0x6b, 0xd9, 0xe6, 0x2a, 0x63, 0xb5, 0xa7, 0x8e, 0x95, 0xf1, 0x95, 0x61, 0x1d, 0x67, 0xf4, 0xff, 0xa2, 0xfd, 0x72, 0x8b, 0x2b, 0xe9, 0x16, 0x4b, 0xc3, 0x75,
0x04, 0xda, 0xe2, 0x1f, 0x26, 0xec, 0xda, 0x0d, 0x23, 0x28, 0x94, 0x01, 0x8c, 0x25, 0x01, 0x51, 0x57, 0x1e, 0x2e, 0xed, 0x39, 0x34, 0xf9, 0x7f, 0x98, 0xb0, 0x2b, 0xdb, 0x0f, 0x4a, 0x21, 0x8d,
0x64, 0xc1, 0x13, 0xd8, 0xc7, 0xb1, 0x64, 0xfc, 0xae, 0x41, 0x57, 0xad, 0xae, 0x1a, 0x4c, 0xe8, 0x61, 0x24, 0xf1, 0x12, 0x05, 0x27, 0xc2, 0x00, 0x0e, 0x70, 0x24, 0x69, 0xbf, 0x2a, 0xd0, 0x96,
0x4b, 0xe8, 0xca, 0x89, 0x70, 0x48, 0x6e, 0xf1, 0xf6, 0x0f, 0x12, 0x4f, 0x59, 0x8f, 0x73, 0xd6, 0xb3, 0x2b, 0x57, 0x26, 0xf4, 0x15, 0xb4, 0xc5, 0x40, 0xc2, 0x92, 0xdc, 0x09, 0x87, 0xa0, 0x17,
0xc6, 0x53, 0x38, 0xd8, 0x4d, 0xe1, 0x9c, 0x52, 0xf7, 0x97, 0xe8, 0xb4, 0xcc, 0x1c, 0xff, 0xa5, 0x23, 0x45, 0x3b, 0xce, 0x9c, 0xd6, 0xbe, 0x84, 0xc3, 0xdd, 0x2c, 0x4e, 0x29, 0xb5, 0x7f, 0x0a,
0xc1, 0xbd, 0xa2, 0x08, 0x95, 0x86, 0xf9, 0x2b, 0xe8, 0xed, 0xfa, 0x7d, 0x4d, 0x58, 0x28, 0xcd, 0xb4, 0x45, 0xa6, 0xf9, 0x4f, 0x05, 0x1e, 0xe6, 0x79, 0x28, 0x35, 0xd2, 0x2f, 0xa1, 0xb3, 0xeb,
0xb3, 0x5e, 0x30, 0xcf, 0xb1, 0x15, 0xce, 0x3b, 0x19, 0x9f, 0x41, 0x77, 0x97, 0x55, 0xd9, 0x92, 0xf7, 0x15, 0x61, 0xbe, 0x30, 0xd5, 0x83, 0xbd, 0x53, 0x1d, 0x9d, 0xc5, 0x59, 0xa8, 0xf6, 0x19,
0x94, 0xab, 0xf9, 0x0e, 0xd5, 0xbc, 0xf3, 0xd5, 0x3c, 0x86, 0xce, 0xdc, 0xb6, 0x9f, 0xb9, 0xd6, 0xb4, 0x77, 0xb1, 0x15, 0x4d, 0x4c, 0xba, 0xa6, 0xff, 0x21, 0xa7, 0x5b, 0xba, 0xa6, 0x27, 0xd0,
0xab, 0x8d, 0x5b, 0xb2, 0x86, 0x25, 0x74, 0x55, 0xd7, 0x8a, 0x17, 0xf1, 0x73, 0x40, 0x98, 0x6c, 0x9a, 0x9a, 0xe6, 0x0b, 0xdb, 0x78, 0xbb, 0xb1, 0x0b, 0x66, 0xb2, 0x80, 0xb6, 0x0c, 0x2d, 0x79,
0xfd, 0x9f, 0x49, 0xa5, 0x2c, 0x4c, 0xe8, 0xe7, 0xbc, 0x2b, 0x26, 0x72, 0x0c, 0x9d, 0x33, 0x12, 0x29, 0x3f, 0x07, 0x84, 0xc9, 0xd6, 0x7d, 0x4f, 0x4a, 0x45, 0xa1, 0x43, 0x37, 0x83, 0x2e, 0x19,
0x56, 0xca, 0xe2, 0x0f, 0x8d, 0x0f, 0x83, 0x9a, 0x43, 0xf9, 0x76, 0x9a, 0xd0, 0xe3, 0x21, 0xf8, 0xc8, 0x09, 0xb4, 0xce, 0x88, 0x5f, 0x2a, 0x8a, 0xdf, 0x95, 0x70, 0x24, 0xe4, 0x18, 0x8a, 0x37,
0x1d, 0x52, 0x3b, 0x7a, 0xa8, 0x74, 0xf4, 0xf9, 0xf5, 0x4b, 0xd7, 0x79, 0x95, 0x98, 0xe1, 0xbc, 0x75, 0x09, 0x9d, 0xd0, 0x45, 0x78, 0x9f, 0xe4, 0xbe, 0x3e, 0xc9, 0xe9, 0xeb, 0xab, 0xab, 0x37,
0x97, 0xf1, 0x08, 0x5a, 0x26, 0x2b, 0xbd, 0x72, 0x8d, 0x1f, 0xa1, 0x9d, 0xba, 0x55, 0xaa, 0x41, 0xb6, 0xf5, 0x36, 0x3e, 0x8c, 0xb3, 0x58, 0xed, 0x29, 0x34, 0x74, 0x56, 0x78, 0x09, 0x6b, 0x3f,
0x87, 0x46, 0xe4, 0xe9, 0x7b, 0x8c, 0xf0, 0x9d, 0xd7, 0xc0, 0x3b, 0x39, 0xba, 0x32, 0x26, 0x33, 0x40, 0x33, 0x81, 0x95, 0xca, 0x44, 0x85, 0x5a, 0x80, 0x74, 0x1d, 0x46, 0xc2, 0x2d, 0x58, 0xc3,
0x3d, 0x9e, 0x6d, 0xd9, 0x2b, 0x63, 0x41, 0x2f, 0xe3, 0xfb, 0xbf, 0xa7, 0x77, 0x0c, 0x9d, 0x05, 0x3b, 0x39, 0xb8, 0x3e, 0x3a, 0xd3, 0x9d, 0x30, 0xda, 0xa2, 0xd7, 0xc7, 0x80, 0x4e, 0x0a, 0x7b,
0x71, 0x49, 0x48, 0xca, 0xe3, 0xb6, 0x84, 0xae, 0xea, 0x5a, 0x71, 0x06, 0x29, 0x0c, 0x14, 0x6a, 0xeb, 0xe1, 0x9d, 0x40, 0x6b, 0x46, 0x6c, 0xe2, 0x93, 0xe2, 0x75, 0x5b, 0x40, 0x5b, 0x86, 0x96,
0x8b, 0xf2, 0x2a, 0x43, 0x99, 0x08, 0xf6, 0x56, 0xae, 0xb5, 0x8e, 0xd9, 0x80, 0xff, 0x47, 0x47, 0x9c, 0xc4, 0x9f, 0x15, 0xe8, 0x49, 0x6c, 0x17, 0x04, 0x56, 0x84, 0x45, 0x35, 0x68, 0xfe, 0x68,
0xd0, 0xfc, 0xc9, 0xf2, 0x6c, 0x97, 0x44, 0x68, 0x08, 0x1a, 0x4a, 0x0f, 0x8c, 0x6f, 0xe0, 0xa0, 0x38, 0xa6, 0x4d, 0x24, 0xa2, 0x90, 0x74, 0xe8, 0x08, 0xea, 0x5c, 0x0e, 0xca, 0xc3, 0x99, 0x2a,
0xe0, 0x89, 0x15, 0xd3, 0x7f, 0x01, 0xe8, 0x92, 0xec, 0x28, 0x67, 0x6b, 0x05, 0x9b, 0xd2, 0x7c, 0x51, 0x68, 0xdf, 0xc0, 0x61, 0x4e, 0x04, 0x25, 0xf3, 0x79, 0x0d, 0xe8, 0x82, 0xec, 0x58, 0x69,
0x1f, 0x39, 0xa5, 0x7c, 0x1f, 0x49, 0xd1, 0x1d, 0xcf, 0x45, 0xad, 0x98, 0xe0, 0x17, 0xd0, 0x3f, 0x6b, 0x78, 0x9b, 0xc2, 0x4f, 0x82, 0x00, 0x94, 0x3c, 0x09, 0x02, 0x29, 0xb8, 0xfa, 0x19, 0xaf,
0x23, 0xe1, 0x25, 0x71, 0x57, 0x95, 0xa8, 0xe8, 0x4f, 0x0d, 0x06, 0x79, 0xff, 0xf7, 0x4b, 0x44, 0x25, 0x03, 0xfc, 0x02, 0xba, 0x67, 0xc4, 0xbf, 0x20, 0xf6, 0x65, 0x29, 0xb6, 0xfa, 0x43, 0x81,
0xb3, 0x7f, 0x6e, 0x43, 0xfc, 0x5e, 0x8c, 0x3e, 0x85, 0xa6, 0x95, 0x34, 0x13, 0xed, 0x08, 0x5a, 0x5e, 0x16, 0xff, 0x7f, 0xe0, 0xaa, 0xc9, 0xdf, 0xf7, 0x20, 0x7a, 0x46, 0xa3, 0x4f, 0xa1, 0x6e,
0x7e, 0xf9, 0xd2, 0x0f, 0x0a, 0x4e, 0x19, 0x45, 0x97, 0x80, 0xd6, 0x39, 0x8e, 0x45, 0x0f, 0x12, 0xc4, 0x2d, 0x45, 0x3b, 0x26, 0x17, 0x5f, 0x69, 0xea, 0x61, 0x8e, 0x96, 0x51, 0x74, 0x01, 0x68,
0xe3, 0x42, 0x06, 0xd7, 0x1f, 0xbe, 0x4d, 0xcd, 0x28, 0x3a, 0x87, 0xee, 0x3a, 0x83, 0x16, 0x3a, 0x9d, 0x21, 0x63, 0x74, 0x1c, 0x1f, 0xce, 0xa5, 0x7a, 0xf5, 0xf1, 0x4d, 0x66, 0x46, 0xd1, 0x39,
0x94, 0x7c, 0xb2, 0x7d, 0xd0, 0x8f, 0x6e, 0x56, 0x32, 0x8a, 0x16, 0x70, 0x67, 0x2d, 0x93, 0x26, 0xb4, 0xd7, 0xa9, 0x9a, 0xa1, 0x47, 0x02, 0x26, 0xdd, 0x0d, 0xf5, 0x68, 0xbf, 0x91, 0x51, 0x34,
0x1a, 0xe6, 0x9e, 0x9f, 0x04, 0xfa, 0xe0, 0x06, 0x0d, 0xa3, 0x68, 0x0e, 0x6d, 0x4b, 0xe2, 0x2d, 0x83, 0xfb, 0x6b, 0x91, 0x57, 0x51, 0x3f, 0xf3, 0xfb, 0xb1, 0xa3, 0x0f, 0xf7, 0x58, 0x18, 0x45,
0x74, 0x5f, 0x02, 0x44, 0x5e, 0xfe, 0xfa, 0xb0, 0x58, 0xc1, 0x28, 0xfa, 0x1a, 0x3a, 0x81, 0x4a, 0x53, 0x68, 0x1a, 0x02, 0xa9, 0xa1, 0x0f, 0x84, 0x82, 0x88, 0xcc, 0xa0, 0xf6, 0xf3, 0x0d, 0x8c,
0x3a, 0x48, 0x4f, 0x8c, 0xf3, 0x5c, 0xa6, 0x1f, 0xde, 0xa8, 0x63, 0x14, 0x3d, 0x82, 0x86, 0x13, 0xa2, 0xaf, 0xa1, 0xe5, 0xc9, 0x8c, 0x84, 0xd4, 0xf8, 0x70, 0x96, 0xe8, 0xd4, 0x47, 0x7b, 0x6d,
0x6f, 0x5c, 0xd4, 0x4f, 0x0c, 0xa5, 0xd5, 0xad, 0x0f, 0xf2, 0x87, 0x02, 0x0b, 0x47, 0x5e, 0x87, 0x8c, 0xa2, 0xa7, 0x50, 0xb3, 0xa2, 0x45, 0x8c, 0xba, 0xf1, 0x41, 0x61, 0xa3, 0xab, 0xbd, 0xac,
0x29, 0x16, 0xd9, 0x0d, 0x9b, 0x62, 0x91, 0xdf, 0x9f, 0x73, 0x68, 0xaf, 0x25, 0xda, 0x4a, 0xb1, 0x92, 0xd7, 0xc2, 0x12, 0xb7, 0x64, 0x52, 0x8b, 0xf4, 0xe2, 0x4d, 0x6a, 0x91, 0x5d, 0xab, 0x53,
0xc8, 0x10, 0xa1, 0x3e, 0x2c, 0x56, 0x88, 0x10, 0xb6, 0xb4, 0xf9, 0xd2, 0x10, 0x99, 0x55, 0x9a, 0x68, 0xae, 0x05, 0x4e, 0x4b, 0x6a, 0x91, 0x62, 0x49, 0xb5, 0x9f, 0x6f, 0xe0, 0x2e, 0x4c, 0x61,
0x86, 0xc8, 0x2d, 0xca, 0xe7, 0xd0, 0xb3, 0xb2, 0x2b, 0x08, 0x1d, 0x15, 0xce, 0x69, 0xbc, 0x0f, 0x21, 0x26, 0x2e, 0x52, 0x1b, 0x36, 0x71, 0x91, 0xd9, 0x9f, 0xaf, 0xa0, 0x63, 0xa4, 0x17, 0x11,
0xf5, 0x07, 0x6f, 0xd1, 0x8a, 0x06, 0x31, 0x75, 0x63, 0xa4, 0x0d, 0xca, 0x2f, 0xa8, 0xb4, 0x41, 0x3a, 0xca, 0x9d, 0xd3, 0x68, 0x4b, 0xaa, 0xc7, 0x37, 0x58, 0x79, 0x83, 0x98, 0xbc, 0x37, 0x92,
0x45, 0x6b, 0x66, 0x0e, 0x6d, 0x47, 0x7a, 0x93, 0x4e, 0x0b, 0xcc, 0x7c, 0x3d, 0xa4, 0x05, 0x66, 0x06, 0x65, 0xd7, 0x54, 0xd2, 0xa0, 0xbc, 0x65, 0x33, 0x85, 0xa6, 0x25, 0x3c, 0xb9, 0x93, 0x04,
0x5f, 0xbc, 0x9f, 0xf5, 0x7e, 0xe8, 0x4c, 0xe2, 0x0f, 0xd9, 0xc7, 0xe2, 0xe7, 0x65, 0x9d, 0x7f, 0x53, 0x9f, 0x19, 0x49, 0x82, 0xe9, 0x17, 0xfa, 0x8b, 0xce, 0xf7, 0xad, 0x51, 0xf4, 0xdd, 0xfb,
0xa5, 0x7e, 0xf2, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdf, 0x16, 0xf8, 0xb5, 0xe7, 0x0e, 0x00, 0x8c, 0xff, 0x79, 0x53, 0x0d, 0x3f, 0x6a, 0x3f, 0xf9, 0x27, 0x00, 0x00, 0xff, 0xff, 0x26, 0xd5,
0x00, 0xdf, 0x90, 0x16, 0x0f, 0x00, 0x00,
} }

@ -22,7 +22,7 @@ message GetFriendsInfoReq{
message GetFriendInfoResp{ message GetFriendInfoResp{
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.FriendInfo FriendInfoList = 3; repeated server_api_params.FriendInfo FriendInfoList = 3;
// int32 IsBlack = 4; // int32 IsBlack = 4;
} }
@ -58,7 +58,7 @@ message GetFriendApplyListReq{
message GetFriendApplyListResp{ message GetFriendApplyListResp{
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.FriendRequest FriendRequestList = 3; repeated server_api_params.FriendRequest FriendRequestList = 3;
} }
@ -68,7 +68,7 @@ message GetFriendListReq{
message GetFriendListResp{ message GetFriendListResp{
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.FriendInfo FriendInfoList = 3; repeated server_api_params.FriendInfo FriendInfoList = 3;
} }
@ -93,7 +93,7 @@ message GetBlacklistReq{
message GetBlacklistResp{ message GetBlacklistResp{
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.PublicUserInfo BlackUserInfoList = 3; repeated server_api_params.PublicUserInfo BlackUserInfoList = 3;
} }
@ -127,7 +127,7 @@ message DeleteFriendResp{
//process //process
message AddFriendResponseReq{ message AddFriendResponseReq{
CommID CommID = 1; CommID CommID = 1;
int32 flag = 2; int32 handleResult = 2;
string handleMsg = 3; string handleMsg = 3;
} }
message AddFriendResponseResp{ message AddFriendResponseResp{
@ -148,7 +148,7 @@ message GetSelfApplyListReq{
message GetSelfApplyListResp{ message GetSelfApplyListResp{
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.FriendRequest FriendRequestList = 3; repeated server_api_params.FriendRequest FriendRequestList = 3;
} }
service friend{ service friend{

@ -36,7 +36,7 @@ func (m *CommonResp) Reset() { *m = CommonResp{} }
func (m *CommonResp) String() string { return proto.CompactTextString(m) } func (m *CommonResp) String() string { return proto.CompactTextString(m) }
func (*CommonResp) ProtoMessage() {} func (*CommonResp) ProtoMessage() {}
func (*CommonResp) Descriptor() ([]byte, []int) { func (*CommonResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{0} return fileDescriptor_group_a130b5186d308ee6, []int{0}
} }
func (m *CommonResp) XXX_Unmarshal(b []byte) error { func (m *CommonResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CommonResp.Unmarshal(m, b) return xxx_messageInfo_CommonResp.Unmarshal(m, b)
@ -82,7 +82,7 @@ func (m *GroupAddMemberInfo) Reset() { *m = GroupAddMemberInfo{} }
func (m *GroupAddMemberInfo) String() string { return proto.CompactTextString(m) } func (m *GroupAddMemberInfo) String() string { return proto.CompactTextString(m) }
func (*GroupAddMemberInfo) ProtoMessage() {} func (*GroupAddMemberInfo) ProtoMessage() {}
func (*GroupAddMemberInfo) Descriptor() ([]byte, []int) { func (*GroupAddMemberInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{1} return fileDescriptor_group_a130b5186d308ee6, []int{1}
} }
func (m *GroupAddMemberInfo) XXX_Unmarshal(b []byte) error { func (m *GroupAddMemberInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GroupAddMemberInfo.Unmarshal(m, b) return xxx_messageInfo_GroupAddMemberInfo.Unmarshal(m, b)
@ -131,7 +131,7 @@ func (m *CreateGroupReq) Reset() { *m = CreateGroupReq{} }
func (m *CreateGroupReq) String() string { return proto.CompactTextString(m) } func (m *CreateGroupReq) String() string { return proto.CompactTextString(m) }
func (*CreateGroupReq) ProtoMessage() {} func (*CreateGroupReq) ProtoMessage() {}
func (*CreateGroupReq) Descriptor() ([]byte, []int) { func (*CreateGroupReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{2} return fileDescriptor_group_a130b5186d308ee6, []int{2}
} }
func (m *CreateGroupReq) XXX_Unmarshal(b []byte) error { func (m *CreateGroupReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateGroupReq.Unmarshal(m, b) return xxx_messageInfo_CreateGroupReq.Unmarshal(m, b)
@ -199,7 +199,7 @@ func (m *CreateGroupResp) Reset() { *m = CreateGroupResp{} }
func (m *CreateGroupResp) String() string { return proto.CompactTextString(m) } func (m *CreateGroupResp) String() string { return proto.CompactTextString(m) }
func (*CreateGroupResp) ProtoMessage() {} func (*CreateGroupResp) ProtoMessage() {}
func (*CreateGroupResp) Descriptor() ([]byte, []int) { func (*CreateGroupResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{3} return fileDescriptor_group_a130b5186d308ee6, []int{3}
} }
func (m *CreateGroupResp) XXX_Unmarshal(b []byte) error { func (m *CreateGroupResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateGroupResp.Unmarshal(m, b) return xxx_messageInfo_CreateGroupResp.Unmarshal(m, b)
@ -253,7 +253,7 @@ func (m *GetGroupsInfoReq) Reset() { *m = GetGroupsInfoReq{} }
func (m *GetGroupsInfoReq) String() string { return proto.CompactTextString(m) } func (m *GetGroupsInfoReq) String() string { return proto.CompactTextString(m) }
func (*GetGroupsInfoReq) ProtoMessage() {} func (*GetGroupsInfoReq) ProtoMessage() {}
func (*GetGroupsInfoReq) Descriptor() ([]byte, []int) { func (*GetGroupsInfoReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{4} return fileDescriptor_group_a130b5186d308ee6, []int{4}
} }
func (m *GetGroupsInfoReq) XXX_Unmarshal(b []byte) error { func (m *GetGroupsInfoReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupsInfoReq.Unmarshal(m, b) return xxx_messageInfo_GetGroupsInfoReq.Unmarshal(m, b)
@ -307,7 +307,7 @@ func (m *GetGroupsInfoResp) Reset() { *m = GetGroupsInfoResp{} }
func (m *GetGroupsInfoResp) String() string { return proto.CompactTextString(m) } func (m *GetGroupsInfoResp) String() string { return proto.CompactTextString(m) }
func (*GetGroupsInfoResp) ProtoMessage() {} func (*GetGroupsInfoResp) ProtoMessage() {}
func (*GetGroupsInfoResp) Descriptor() ([]byte, []int) { func (*GetGroupsInfoResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{5} return fileDescriptor_group_a130b5186d308ee6, []int{5}
} }
func (m *GetGroupsInfoResp) XXX_Unmarshal(b []byte) error { func (m *GetGroupsInfoResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupsInfoResp.Unmarshal(m, b) return xxx_messageInfo_GetGroupsInfoResp.Unmarshal(m, b)
@ -361,7 +361,7 @@ func (m *SetGroupInfoReq) Reset() { *m = SetGroupInfoReq{} }
func (m *SetGroupInfoReq) String() string { return proto.CompactTextString(m) } func (m *SetGroupInfoReq) String() string { return proto.CompactTextString(m) }
func (*SetGroupInfoReq) ProtoMessage() {} func (*SetGroupInfoReq) ProtoMessage() {}
func (*SetGroupInfoReq) Descriptor() ([]byte, []int) { func (*SetGroupInfoReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{6} return fileDescriptor_group_a130b5186d308ee6, []int{6}
} }
func (m *SetGroupInfoReq) XXX_Unmarshal(b []byte) error { func (m *SetGroupInfoReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetGroupInfoReq.Unmarshal(m, b) return xxx_messageInfo_SetGroupInfoReq.Unmarshal(m, b)
@ -413,7 +413,7 @@ func (m *SetGroupInfoResp) Reset() { *m = SetGroupInfoResp{} }
func (m *SetGroupInfoResp) String() string { return proto.CompactTextString(m) } func (m *SetGroupInfoResp) String() string { return proto.CompactTextString(m) }
func (*SetGroupInfoResp) ProtoMessage() {} func (*SetGroupInfoResp) ProtoMessage() {}
func (*SetGroupInfoResp) Descriptor() ([]byte, []int) { func (*SetGroupInfoResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{7} return fileDescriptor_group_a130b5186d308ee6, []int{7}
} }
func (m *SetGroupInfoResp) XXX_Unmarshal(b []byte) error { func (m *SetGroupInfoResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetGroupInfoResp.Unmarshal(m, b) return xxx_messageInfo_SetGroupInfoResp.Unmarshal(m, b)
@ -453,7 +453,7 @@ func (m *GetGroupApplicationListReq) Reset() { *m = GetGroupApplicationL
func (m *GetGroupApplicationListReq) String() string { return proto.CompactTextString(m) } func (m *GetGroupApplicationListReq) String() string { return proto.CompactTextString(m) }
func (*GetGroupApplicationListReq) ProtoMessage() {} func (*GetGroupApplicationListReq) ProtoMessage() {}
func (*GetGroupApplicationListReq) Descriptor() ([]byte, []int) { func (*GetGroupApplicationListReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{8} return fileDescriptor_group_a130b5186d308ee6, []int{8}
} }
func (m *GetGroupApplicationListReq) XXX_Unmarshal(b []byte) error { func (m *GetGroupApplicationListReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupApplicationListReq.Unmarshal(m, b) return xxx_messageInfo_GetGroupApplicationListReq.Unmarshal(m, b)
@ -507,7 +507,7 @@ func (m *GetGroupApplicationListResp) Reset() { *m = GetGroupApplication
func (m *GetGroupApplicationListResp) String() string { return proto.CompactTextString(m) } func (m *GetGroupApplicationListResp) String() string { return proto.CompactTextString(m) }
func (*GetGroupApplicationListResp) ProtoMessage() {} func (*GetGroupApplicationListResp) ProtoMessage() {}
func (*GetGroupApplicationListResp) Descriptor() ([]byte, []int) { func (*GetGroupApplicationListResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{9} return fileDescriptor_group_a130b5186d308ee6, []int{9}
} }
func (m *GetGroupApplicationListResp) XXX_Unmarshal(b []byte) error { func (m *GetGroupApplicationListResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupApplicationListResp.Unmarshal(m, b) return xxx_messageInfo_GetGroupApplicationListResp.Unmarshal(m, b)
@ -563,7 +563,7 @@ func (m *TransferGroupOwnerReq) Reset() { *m = TransferGroupOwnerReq{} }
func (m *TransferGroupOwnerReq) String() string { return proto.CompactTextString(m) } func (m *TransferGroupOwnerReq) String() string { return proto.CompactTextString(m) }
func (*TransferGroupOwnerReq) ProtoMessage() {} func (*TransferGroupOwnerReq) ProtoMessage() {}
func (*TransferGroupOwnerReq) Descriptor() ([]byte, []int) { func (*TransferGroupOwnerReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{10} return fileDescriptor_group_a130b5186d308ee6, []int{10}
} }
func (m *TransferGroupOwnerReq) XXX_Unmarshal(b []byte) error { func (m *TransferGroupOwnerReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TransferGroupOwnerReq.Unmarshal(m, b) return xxx_messageInfo_TransferGroupOwnerReq.Unmarshal(m, b)
@ -629,7 +629,7 @@ func (m *TransferGroupOwnerResp) Reset() { *m = TransferGroupOwnerResp{}
func (m *TransferGroupOwnerResp) String() string { return proto.CompactTextString(m) } func (m *TransferGroupOwnerResp) String() string { return proto.CompactTextString(m) }
func (*TransferGroupOwnerResp) ProtoMessage() {} func (*TransferGroupOwnerResp) ProtoMessage() {}
func (*TransferGroupOwnerResp) Descriptor() ([]byte, []int) { func (*TransferGroupOwnerResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{11} return fileDescriptor_group_a130b5186d308ee6, []int{11}
} }
func (m *TransferGroupOwnerResp) XXX_Unmarshal(b []byte) error { func (m *TransferGroupOwnerResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TransferGroupOwnerResp.Unmarshal(m, b) return xxx_messageInfo_TransferGroupOwnerResp.Unmarshal(m, b)
@ -670,7 +670,7 @@ func (m *JoinGroupReq) Reset() { *m = JoinGroupReq{} }
func (m *JoinGroupReq) String() string { return proto.CompactTextString(m) } func (m *JoinGroupReq) String() string { return proto.CompactTextString(m) }
func (*JoinGroupReq) ProtoMessage() {} func (*JoinGroupReq) ProtoMessage() {}
func (*JoinGroupReq) Descriptor() ([]byte, []int) { func (*JoinGroupReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{12} return fileDescriptor_group_a130b5186d308ee6, []int{12}
} }
func (m *JoinGroupReq) XXX_Unmarshal(b []byte) error { func (m *JoinGroupReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_JoinGroupReq.Unmarshal(m, b) return xxx_messageInfo_JoinGroupReq.Unmarshal(m, b)
@ -729,7 +729,7 @@ func (m *JoinGroupResp) Reset() { *m = JoinGroupResp{} }
func (m *JoinGroupResp) String() string { return proto.CompactTextString(m) } func (m *JoinGroupResp) String() string { return proto.CompactTextString(m) }
func (*JoinGroupResp) ProtoMessage() {} func (*JoinGroupResp) ProtoMessage() {}
func (*JoinGroupResp) Descriptor() ([]byte, []int) { func (*JoinGroupResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{13} return fileDescriptor_group_a130b5186d308ee6, []int{13}
} }
func (m *JoinGroupResp) XXX_Unmarshal(b []byte) error { func (m *JoinGroupResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_JoinGroupResp.Unmarshal(m, b) return xxx_messageInfo_JoinGroupResp.Unmarshal(m, b)
@ -772,7 +772,7 @@ func (m *GroupApplicationResponseReq) Reset() { *m = GroupApplicationRes
func (m *GroupApplicationResponseReq) String() string { return proto.CompactTextString(m) } func (m *GroupApplicationResponseReq) String() string { return proto.CompactTextString(m) }
func (*GroupApplicationResponseReq) ProtoMessage() {} func (*GroupApplicationResponseReq) ProtoMessage() {}
func (*GroupApplicationResponseReq) Descriptor() ([]byte, []int) { func (*GroupApplicationResponseReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{14} return fileDescriptor_group_a130b5186d308ee6, []int{14}
} }
func (m *GroupApplicationResponseReq) XXX_Unmarshal(b []byte) error { func (m *GroupApplicationResponseReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GroupApplicationResponseReq.Unmarshal(m, b) return xxx_messageInfo_GroupApplicationResponseReq.Unmarshal(m, b)
@ -845,7 +845,7 @@ func (m *GroupApplicationResponseResp) Reset() { *m = GroupApplicationRe
func (m *GroupApplicationResponseResp) String() string { return proto.CompactTextString(m) } func (m *GroupApplicationResponseResp) String() string { return proto.CompactTextString(m) }
func (*GroupApplicationResponseResp) ProtoMessage() {} func (*GroupApplicationResponseResp) ProtoMessage() {}
func (*GroupApplicationResponseResp) Descriptor() ([]byte, []int) { func (*GroupApplicationResponseResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{15} return fileDescriptor_group_a130b5186d308ee6, []int{15}
} }
func (m *GroupApplicationResponseResp) XXX_Unmarshal(b []byte) error { func (m *GroupApplicationResponseResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GroupApplicationResponseResp.Unmarshal(m, b) return xxx_messageInfo_GroupApplicationResponseResp.Unmarshal(m, b)
@ -885,7 +885,7 @@ func (m *QuitGroupReq) Reset() { *m = QuitGroupReq{} }
func (m *QuitGroupReq) String() string { return proto.CompactTextString(m) } func (m *QuitGroupReq) String() string { return proto.CompactTextString(m) }
func (*QuitGroupReq) ProtoMessage() {} func (*QuitGroupReq) ProtoMessage() {}
func (*QuitGroupReq) Descriptor() ([]byte, []int) { func (*QuitGroupReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{16} return fileDescriptor_group_a130b5186d308ee6, []int{16}
} }
func (m *QuitGroupReq) XXX_Unmarshal(b []byte) error { func (m *QuitGroupReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_QuitGroupReq.Unmarshal(m, b) return xxx_messageInfo_QuitGroupReq.Unmarshal(m, b)
@ -937,7 +937,7 @@ func (m *QuitGroupResp) Reset() { *m = QuitGroupResp{} }
func (m *QuitGroupResp) String() string { return proto.CompactTextString(m) } func (m *QuitGroupResp) String() string { return proto.CompactTextString(m) }
func (*QuitGroupResp) ProtoMessage() {} func (*QuitGroupResp) ProtoMessage() {}
func (*QuitGroupResp) Descriptor() ([]byte, []int) { func (*QuitGroupResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{17} return fileDescriptor_group_a130b5186d308ee6, []int{17}
} }
func (m *QuitGroupResp) XXX_Unmarshal(b []byte) error { func (m *QuitGroupResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_QuitGroupResp.Unmarshal(m, b) return xxx_messageInfo_QuitGroupResp.Unmarshal(m, b)
@ -979,7 +979,7 @@ func (m *GetGroupMemberListReq) Reset() { *m = GetGroupMemberListReq{} }
func (m *GetGroupMemberListReq) String() string { return proto.CompactTextString(m) } func (m *GetGroupMemberListReq) String() string { return proto.CompactTextString(m) }
func (*GetGroupMemberListReq) ProtoMessage() {} func (*GetGroupMemberListReq) ProtoMessage() {}
func (*GetGroupMemberListReq) Descriptor() ([]byte, []int) { func (*GetGroupMemberListReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{18} return fileDescriptor_group_a130b5186d308ee6, []int{18}
} }
func (m *GetGroupMemberListReq) XXX_Unmarshal(b []byte) error { func (m *GetGroupMemberListReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupMemberListReq.Unmarshal(m, b) return xxx_messageInfo_GetGroupMemberListReq.Unmarshal(m, b)
@ -1048,7 +1048,7 @@ func (m *GetGroupMemberListResp) Reset() { *m = GetGroupMemberListResp{}
func (m *GetGroupMemberListResp) String() string { return proto.CompactTextString(m) } func (m *GetGroupMemberListResp) String() string { return proto.CompactTextString(m) }
func (*GetGroupMemberListResp) ProtoMessage() {} func (*GetGroupMemberListResp) ProtoMessage() {}
func (*GetGroupMemberListResp) Descriptor() ([]byte, []int) { func (*GetGroupMemberListResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{19} return fileDescriptor_group_a130b5186d308ee6, []int{19}
} }
func (m *GetGroupMemberListResp) XXX_Unmarshal(b []byte) error { func (m *GetGroupMemberListResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupMemberListResp.Unmarshal(m, b) return xxx_messageInfo_GetGroupMemberListResp.Unmarshal(m, b)
@ -1110,7 +1110,7 @@ func (m *GetGroupMembersInfoReq) Reset() { *m = GetGroupMembersInfoReq{}
func (m *GetGroupMembersInfoReq) String() string { return proto.CompactTextString(m) } func (m *GetGroupMembersInfoReq) String() string { return proto.CompactTextString(m) }
func (*GetGroupMembersInfoReq) ProtoMessage() {} func (*GetGroupMembersInfoReq) ProtoMessage() {}
func (*GetGroupMembersInfoReq) Descriptor() ([]byte, []int) { func (*GetGroupMembersInfoReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{20} return fileDescriptor_group_a130b5186d308ee6, []int{20}
} }
func (m *GetGroupMembersInfoReq) XXX_Unmarshal(b []byte) error { func (m *GetGroupMembersInfoReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupMembersInfoReq.Unmarshal(m, b) return xxx_messageInfo_GetGroupMembersInfoReq.Unmarshal(m, b)
@ -1171,7 +1171,7 @@ func (m *GetGroupMembersInfoResp) Reset() { *m = GetGroupMembersInfoResp
func (m *GetGroupMembersInfoResp) String() string { return proto.CompactTextString(m) } func (m *GetGroupMembersInfoResp) String() string { return proto.CompactTextString(m) }
func (*GetGroupMembersInfoResp) ProtoMessage() {} func (*GetGroupMembersInfoResp) ProtoMessage() {}
func (*GetGroupMembersInfoResp) Descriptor() ([]byte, []int) { func (*GetGroupMembersInfoResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{21} return fileDescriptor_group_a130b5186d308ee6, []int{21}
} }
func (m *GetGroupMembersInfoResp) XXX_Unmarshal(b []byte) error { func (m *GetGroupMembersInfoResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupMembersInfoResp.Unmarshal(m, b) return xxx_messageInfo_GetGroupMembersInfoResp.Unmarshal(m, b)
@ -1227,7 +1227,7 @@ func (m *KickGroupMemberReq) Reset() { *m = KickGroupMemberReq{} }
func (m *KickGroupMemberReq) String() string { return proto.CompactTextString(m) } func (m *KickGroupMemberReq) String() string { return proto.CompactTextString(m) }
func (*KickGroupMemberReq) ProtoMessage() {} func (*KickGroupMemberReq) ProtoMessage() {}
func (*KickGroupMemberReq) Descriptor() ([]byte, []int) { func (*KickGroupMemberReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{22} return fileDescriptor_group_a130b5186d308ee6, []int{22}
} }
func (m *KickGroupMemberReq) XXX_Unmarshal(b []byte) error { func (m *KickGroupMemberReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_KickGroupMemberReq.Unmarshal(m, b) return xxx_messageInfo_KickGroupMemberReq.Unmarshal(m, b)
@ -1294,7 +1294,7 @@ func (m *Id2Result) Reset() { *m = Id2Result{} }
func (m *Id2Result) String() string { return proto.CompactTextString(m) } func (m *Id2Result) String() string { return proto.CompactTextString(m) }
func (*Id2Result) ProtoMessage() {} func (*Id2Result) ProtoMessage() {}
func (*Id2Result) Descriptor() ([]byte, []int) { func (*Id2Result) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{23} return fileDescriptor_group_a130b5186d308ee6, []int{23}
} }
func (m *Id2Result) XXX_Unmarshal(b []byte) error { func (m *Id2Result) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Id2Result.Unmarshal(m, b) return xxx_messageInfo_Id2Result.Unmarshal(m, b)
@ -1341,7 +1341,7 @@ func (m *KickGroupMemberResp) Reset() { *m = KickGroupMemberResp{} }
func (m *KickGroupMemberResp) String() string { return proto.CompactTextString(m) } func (m *KickGroupMemberResp) String() string { return proto.CompactTextString(m) }
func (*KickGroupMemberResp) ProtoMessage() {} func (*KickGroupMemberResp) ProtoMessage() {}
func (*KickGroupMemberResp) Descriptor() ([]byte, []int) { func (*KickGroupMemberResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{24} return fileDescriptor_group_a130b5186d308ee6, []int{24}
} }
func (m *KickGroupMemberResp) XXX_Unmarshal(b []byte) error { func (m *KickGroupMemberResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_KickGroupMemberResp.Unmarshal(m, b) return xxx_messageInfo_KickGroupMemberResp.Unmarshal(m, b)
@ -1395,7 +1395,7 @@ func (m *GetJoinedGroupListReq) Reset() { *m = GetJoinedGroupListReq{} }
func (m *GetJoinedGroupListReq) String() string { return proto.CompactTextString(m) } func (m *GetJoinedGroupListReq) String() string { return proto.CompactTextString(m) }
func (*GetJoinedGroupListReq) ProtoMessage() {} func (*GetJoinedGroupListReq) ProtoMessage() {}
func (*GetJoinedGroupListReq) Descriptor() ([]byte, []int) { func (*GetJoinedGroupListReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{25} return fileDescriptor_group_a130b5186d308ee6, []int{25}
} }
func (m *GetJoinedGroupListReq) XXX_Unmarshal(b []byte) error { func (m *GetJoinedGroupListReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetJoinedGroupListReq.Unmarshal(m, b) return xxx_messageInfo_GetJoinedGroupListReq.Unmarshal(m, b)
@ -1449,7 +1449,7 @@ func (m *GetJoinedGroupListResp) Reset() { *m = GetJoinedGroupListResp{}
func (m *GetJoinedGroupListResp) String() string { return proto.CompactTextString(m) } func (m *GetJoinedGroupListResp) String() string { return proto.CompactTextString(m) }
func (*GetJoinedGroupListResp) ProtoMessage() {} func (*GetJoinedGroupListResp) ProtoMessage() {}
func (*GetJoinedGroupListResp) Descriptor() ([]byte, []int) { func (*GetJoinedGroupListResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{26} return fileDescriptor_group_a130b5186d308ee6, []int{26}
} }
func (m *GetJoinedGroupListResp) XXX_Unmarshal(b []byte) error { func (m *GetJoinedGroupListResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetJoinedGroupListResp.Unmarshal(m, b) return xxx_messageInfo_GetJoinedGroupListResp.Unmarshal(m, b)
@ -1505,7 +1505,7 @@ func (m *InviteUserToGroupReq) Reset() { *m = InviteUserToGroupReq{} }
func (m *InviteUserToGroupReq) String() string { return proto.CompactTextString(m) } func (m *InviteUserToGroupReq) String() string { return proto.CompactTextString(m) }
func (*InviteUserToGroupReq) ProtoMessage() {} func (*InviteUserToGroupReq) ProtoMessage() {}
func (*InviteUserToGroupReq) Descriptor() ([]byte, []int) { func (*InviteUserToGroupReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{27} return fileDescriptor_group_a130b5186d308ee6, []int{27}
} }
func (m *InviteUserToGroupReq) XXX_Unmarshal(b []byte) error { func (m *InviteUserToGroupReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InviteUserToGroupReq.Unmarshal(m, b) return xxx_messageInfo_InviteUserToGroupReq.Unmarshal(m, b)
@ -1573,7 +1573,7 @@ func (m *InviteUserToGroupResp) Reset() { *m = InviteUserToGroupResp{} }
func (m *InviteUserToGroupResp) String() string { return proto.CompactTextString(m) } func (m *InviteUserToGroupResp) String() string { return proto.CompactTextString(m) }
func (*InviteUserToGroupResp) ProtoMessage() {} func (*InviteUserToGroupResp) ProtoMessage() {}
func (*InviteUserToGroupResp) Descriptor() ([]byte, []int) { func (*InviteUserToGroupResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{28} return fileDescriptor_group_a130b5186d308ee6, []int{28}
} }
func (m *InviteUserToGroupResp) XXX_Unmarshal(b []byte) error { func (m *InviteUserToGroupResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InviteUserToGroupResp.Unmarshal(m, b) return xxx_messageInfo_InviteUserToGroupResp.Unmarshal(m, b)
@ -1627,7 +1627,7 @@ func (m *GetGroupAllMemberReq) Reset() { *m = GetGroupAllMemberReq{} }
func (m *GetGroupAllMemberReq) String() string { return proto.CompactTextString(m) } func (m *GetGroupAllMemberReq) String() string { return proto.CompactTextString(m) }
func (*GetGroupAllMemberReq) ProtoMessage() {} func (*GetGroupAllMemberReq) ProtoMessage() {}
func (*GetGroupAllMemberReq) Descriptor() ([]byte, []int) { func (*GetGroupAllMemberReq) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{29} return fileDescriptor_group_a130b5186d308ee6, []int{29}
} }
func (m *GetGroupAllMemberReq) XXX_Unmarshal(b []byte) error { func (m *GetGroupAllMemberReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupAllMemberReq.Unmarshal(m, b) return xxx_messageInfo_GetGroupAllMemberReq.Unmarshal(m, b)
@ -1681,7 +1681,7 @@ func (m *GetGroupAllMemberResp) Reset() { *m = GetGroupAllMemberResp{} }
func (m *GetGroupAllMemberResp) String() string { return proto.CompactTextString(m) } func (m *GetGroupAllMemberResp) String() string { return proto.CompactTextString(m) }
func (*GetGroupAllMemberResp) ProtoMessage() {} func (*GetGroupAllMemberResp) ProtoMessage() {}
func (*GetGroupAllMemberResp) Descriptor() ([]byte, []int) { func (*GetGroupAllMemberResp) Descriptor() ([]byte, []int) {
return fileDescriptor_group_5b7911b898fdd5c5, []int{30} return fileDescriptor_group_a130b5186d308ee6, []int{30}
} }
func (m *GetGroupAllMemberResp) XXX_Unmarshal(b []byte) error { func (m *GetGroupAllMemberResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupAllMemberResp.Unmarshal(m, b) return xxx_messageInfo_GetGroupAllMemberResp.Unmarshal(m, b)
@ -2257,86 +2257,86 @@ var _Group_serviceDesc = grpc.ServiceDesc{
Metadata: "group/group.proto", Metadata: "group/group.proto",
} }
func init() { proto.RegisterFile("group/group.proto", fileDescriptor_group_5b7911b898fdd5c5) } func init() { proto.RegisterFile("group/group.proto", fileDescriptor_group_a130b5186d308ee6) }
var fileDescriptor_group_5b7911b898fdd5c5 = []byte{ var fileDescriptor_group_a130b5186d308ee6 = []byte{
// 1235 bytes of a gzipped FileDescriptorProto // 1246 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x49, 0x6f, 0x1c, 0x45, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x4b, 0x6f, 0x23, 0xc5,
0x14, 0x56, 0x79, 0x3c, 0x4e, 0xe6, 0xd9, 0xe3, 0xa5, 0xbc, 0x4d, 0x3a, 0xc6, 0x9a, 0x14, 0x12, 0x13, 0x57, 0xc7, 0x71, 0x76, 0x5d, 0x89, 0xf3, 0xe8, 0xbc, 0xfc, 0x9f, 0xf5, 0x3f, 0x64, 0x1b,
0xb2, 0x10, 0xb2, 0x85, 0x41, 0xb9, 0x24, 0x02, 0xbc, 0x26, 0x93, 0xc4, 0xb6, 0xdc, 0x31, 0x17, 0x69, 0x15, 0x21, 0x64, 0x8b, 0x20, 0xed, 0x81, 0x45, 0xa0, 0x38, 0x8f, 0x5d, 0x6f, 0x36, 0x89,
0x2e, 0x66, 0xe2, 0x2e, 0xb7, 0x1a, 0xf7, 0x74, 0xb7, 0xbb, 0x7a, 0x62, 0xe0, 0x02, 0x08, 0xc1, 0x32, 0x1b, 0x2e, 0x5c, 0x82, 0x37, 0xd3, 0x19, 0x0d, 0x19, 0xcf, 0x8c, 0xa7, 0xc7, 0x09, 0xe2,
0x05, 0x21, 0x71, 0xe2, 0xce, 0x85, 0x33, 0x07, 0x4e, 0x5c, 0xf8, 0x1d, 0xfc, 0x04, 0xfe, 0x05, 0xb2, 0xe2, 0xb2, 0x12, 0xe2, 0x02, 0xe2, 0xca, 0x85, 0x3b, 0x07, 0x0e, 0x9c, 0xb8, 0xf0, 0x39,
0xaa, 0xa5, 0x7b, 0xaa, 0x57, 0x8f, 0x66, 0x24, 0x72, 0x19, 0xe9, 0x2d, 0xd5, 0xef, 0xbd, 0xaf, 0xf8, 0x14, 0x7c, 0x05, 0x34, 0xdd, 0x3d, 0xe3, 0x9e, 0x67, 0xb2, 0xb6, 0xc4, 0x5e, 0x2c, 0x75,
0xde, 0x56, 0x03, 0x0b, 0x76, 0xe8, 0xf7, 0x83, 0x2d, 0xf1, 0xbb, 0x19, 0x84, 0x7e, 0xe4, 0xe3, 0x55, 0xf5, 0xd4, 0xfb, 0x57, 0xd5, 0x86, 0x25, 0xd3, 0x77, 0x87, 0x5e, 0x9b, 0xff, 0xb6, 0x3c,
0xba, 0x20, 0x8c, 0x07, 0x27, 0x01, 0xf5, 0xce, 0x3b, 0x47, 0x5b, 0xc1, 0x95, 0xbd, 0x25, 0x24, 0xdf, 0x0d, 0x5c, 0x5c, 0xe5, 0x07, 0xed, 0xe1, 0x89, 0x47, 0x9d, 0xf3, 0xee, 0x51, 0xdb, 0xbb,
0x5b, 0xcc, 0xba, 0x3a, 0xbf, 0x61, 0x5b, 0x37, 0x4c, 0x6a, 0x92, 0x8f, 0x00, 0xf6, 0xfc, 0x5e, 0x32, 0xdb, 0x9c, 0xd3, 0x66, 0xc6, 0xd5, 0xf9, 0x0d, 0x6b, 0xdf, 0x30, 0x21, 0x49, 0x3e, 0x03,
0xcf, 0xf7, 0x4c, 0xca, 0x02, 0xdc, 0x82, 0x3b, 0x07, 0x61, 0xb8, 0xe7, 0x5b, 0xb4, 0x85, 0xda, 0xd8, 0x75, 0xfb, 0x7d, 0xd7, 0xd1, 0x29, 0xf3, 0x70, 0x03, 0xee, 0xed, 0xfb, 0xfe, 0xae, 0x6b,
0x68, 0xa3, 0x6e, 0xc6, 0x24, 0x5e, 0x81, 0xa9, 0x83, 0x30, 0x3c, 0x62, 0x76, 0x6b, 0xa2, 0x8d, 0xd0, 0x06, 0xda, 0x44, 0x5b, 0x55, 0x3d, 0x3a, 0xe2, 0x35, 0x98, 0xd9, 0xf7, 0xfd, 0x23, 0x66,
0x36, 0x1a, 0xa6, 0xa2, 0xc8, 0x33, 0xc0, 0x4f, 0xb8, 0xad, 0x1d, 0xcb, 0x3a, 0xa2, 0xbd, 0x57, 0x36, 0xa6, 0x36, 0xd1, 0x56, 0x4d, 0x97, 0x27, 0xf2, 0x1c, 0xf0, 0xd3, 0x50, 0xd7, 0x8e, 0x61,
0x34, 0xec, 0x78, 0x97, 0x3e, 0xd7, 0xfe, 0x94, 0xd1, 0xb0, 0xb3, 0x2f, 0x3e, 0xd3, 0x30, 0x15, 0x1c, 0xd1, 0xfe, 0x2b, 0xea, 0x77, 0x9d, 0x4b, 0x37, 0x94, 0xfe, 0x82, 0x51, 0xbf, 0xbb, 0xc7,
0x85, 0xd7, 0xa0, 0x61, 0xfa, 0x2e, 0x7d, 0x41, 0x5f, 0x53, 0x57, 0x7c, 0xa8, 0x6e, 0x0e, 0x18, 0x3f, 0x53, 0xd3, 0xe5, 0x09, 0x37, 0xa1, 0xa6, 0xbb, 0x36, 0x7d, 0x41, 0xaf, 0xa9, 0xcd, 0x3f,
0xe4, 0x5f, 0x04, 0xb3, 0x7b, 0x21, 0xed, 0x46, 0x54, 0x7c, 0xd2, 0xa4, 0xd7, 0x78, 0x07, 0x66, 0x54, 0xd5, 0x47, 0x04, 0xf2, 0x0f, 0x82, 0xf9, 0x5d, 0x9f, 0xf6, 0x02, 0xca, 0x3f, 0xa9, 0xd3,
0x3b, 0x9e, 0x13, 0xc9, 0x4f, 0xbf, 0x70, 0x58, 0xd4, 0x42, 0xed, 0xda, 0xc6, 0xf4, 0xf6, 0xbd, 0x01, 0xde, 0x81, 0xf9, 0xae, 0x63, 0x05, 0xe2, 0xd3, 0x2f, 0x2c, 0x16, 0x34, 0xd0, 0x66, 0x65,
0x4d, 0x19, 0x6e, 0xde, 0xb6, 0x99, 0x39, 0x80, 0x3f, 0x84, 0x86, 0xd0, 0xe2, 0x42, 0x61, 0x73, 0x6b, 0x76, 0xfb, 0x7f, 0x2d, 0xe1, 0x6e, 0x56, 0xb7, 0x9e, 0xba, 0x80, 0x3f, 0x81, 0x1a, 0x97,
0x7a, 0x7b, 0x65, 0xd3, 0xe7, 0xc0, 0x38, 0xbd, 0x73, 0x66, 0x5d, 0x6d, 0x26, 0x52, 0x73, 0xa0, 0x0a, 0x99, 0x5c, 0xe7, 0xec, 0x76, 0xb3, 0xc5, 0xa8, 0x7f, 0x4d, 0xfd, 0xf3, 0x9e, 0x67, 0x9d,
0x88, 0xdb, 0x30, 0x7d, 0x12, 0xd0, 0xb0, 0x1b, 0x39, 0xbe, 0xd7, 0xd9, 0x6f, 0xd5, 0x44, 0x18, 0x7b, 0x3d, 0xbf, 0xd7, 0x67, 0xad, 0x58, 0x46, 0x1f, 0x89, 0xe3, 0x4d, 0x98, 0x3d, 0xf1, 0xa8,
0x3a, 0x0b, 0x1b, 0x70, 0xf7, 0x24, 0x50, 0x51, 0x4e, 0x0a, 0x71, 0x42, 0x8b, 0xd3, 0x37, 0x1e, 0xdf, 0x0b, 0x2c, 0xd7, 0xe9, 0xee, 0x35, 0x2a, 0xdc, 0x19, 0x95, 0x84, 0x35, 0xb8, 0x7f, 0xe2,
0x0d, 0x95, 0xb8, 0xae, 0x4e, 0x0f, 0x58, 0xe4, 0x2b, 0x98, 0x4b, 0x85, 0x3a, 0x0a, 0xf8, 0xe9, 0x49, 0x5f, 0xa7, 0x39, 0x3b, 0x3e, 0xf3, 0xdb, 0x37, 0x0e, 0xf5, 0x25, 0xbb, 0x2a, 0x6f, 0x8f,
0xd0, 0x6a, 0x43, 0x86, 0x46, 0x42, 0x98, 0x7f, 0x42, 0x23, 0x41, 0x33, 0x21, 0xa3, 0xd7, 0xdc, 0x48, 0xe4, 0x35, 0x2c, 0x24, 0x1c, 0x1e, 0x27, 0x05, 0x49, 0x07, 0x2b, 0x6f, 0xe5, 0x20, 0xf1,
0x61, 0xa9, 0xb0, 0x9f, 0x80, 0xdc, 0x30, 0x75, 0x56, 0x16, 0x90, 0x89, 0x6a, 0x40, 0x6a, 0x69, 0x61, 0xf1, 0x29, 0x0d, 0xf8, 0x99, 0x71, 0x1e, 0x1d, 0x84, 0x66, 0x0b, 0x81, 0xbd, 0x38, 0xe0,
0x40, 0xc8, 0xf7, 0x08, 0x16, 0x32, 0x46, 0x47, 0x8a, 0xf8, 0x31, 0x34, 0x93, 0x40, 0x84, 0xa7, 0x35, 0x5d, 0x25, 0xa5, 0xc3, 0x32, 0x55, 0x1e, 0x96, 0x4a, 0x32, 0x2c, 0xe4, 0x7b, 0x04, 0x4b,
0x35, 0x91, 0x0e, 0x65, 0x51, 0xa7, 0x95, 0xc9, 0x0f, 0x08, 0xe6, 0x5e, 0x2a, 0x2f, 0xe2, 0xc8, 0x29, 0xa5, 0x63, 0xf9, 0xdd, 0x81, 0x7a, 0xec, 0x08, 0xb7, 0xb4, 0xc2, 0x4b, 0xa3, 0xdc, 0xf7,
0x53, 0x18, 0xa2, 0x61, 0xd3, 0x43, 0x8f, 0x75, 0xa2, 0xe0, 0xf2, 0x2b, 0x53, 0x87, 0x1c, 0xc0, 0xe4, 0x15, 0xf2, 0x03, 0x82, 0x85, 0x97, 0xd2, 0x96, 0xc8, 0xff, 0x44, 0x3c, 0xd1, 0xdb, 0x15,
0x7c, 0xda, 0x0d, 0x16, 0xe0, 0xf7, 0xf5, 0x42, 0x54, 0x8e, 0x2c, 0xa8, 0x2c, 0x1f, 0x08, 0x4c, 0x8c, 0xea, 0xf7, 0x54, 0x4e, 0x39, 0x94, 0x16, 0x13, 0xd9, 0x87, 0xc5, 0xa4, 0x31, 0xcc, 0xc3,
0x4d, 0x89, 0x7c, 0x0d, 0x46, 0x8c, 0xe9, 0x4e, 0x10, 0xb8, 0xce, 0x85, 0xf8, 0x3e, 0x8f, 0x94, 0x1f, 0xa9, 0x0d, 0x2a, 0xcd, 0x59, 0x92, 0xd5, 0x3f, 0x62, 0xe8, 0x8a, 0x10, 0xf9, 0x16, 0xb4,
0x07, 0xa6, 0xbb, 0x88, 0xaa, 0x5d, 0x2c, 0xb8, 0xcc, 0x75, 0x80, 0xc3, 0xd0, 0xef, 0xa5, 0xae, 0x28, 0xbe, 0x3b, 0x9e, 0x67, 0x5b, 0x17, 0xfc, 0xfb, 0xa1, 0xbf, 0xa1, 0x7b, 0xaa, 0x89, 0xa8,
0x53, 0xe3, 0x90, 0x5f, 0x11, 0xdc, 0x2f, 0x35, 0x3e, 0xd2, 0xd5, 0x1e, 0xc0, 0x7c, 0x5c, 0xf6, 0xdc, 0xc4, 0x9c, 0xc4, 0x6e, 0x00, 0x1c, 0xf8, 0x6e, 0x3f, 0x91, 0x5a, 0x85, 0x42, 0x7e, 0x41,
0x7d, 0xca, 0x22, 0xed, 0x76, 0xef, 0xe5, 0xef, 0x43, 0x29, 0x99, 0xb9, 0x23, 0xe4, 0x6f, 0x04, 0xf0, 0xa0, 0x50, 0xf9, 0x58, 0x69, 0x3e, 0x84, 0xc5, 0x08, 0x0e, 0x86, 0x94, 0x05, 0x4a, 0xa6,
0xcb, 0x67, 0x61, 0xd7, 0x63, 0x97, 0x34, 0x14, 0x42, 0x51, 0x75, 0x1c, 0x90, 0x16, 0xdc, 0x51, 0xdf, 0x2b, 0xca, 0x8a, 0x14, 0xd5, 0x33, 0x17, 0xc9, 0x5f, 0x08, 0x56, 0xcf, 0xfc, 0x9e, 0xc3,
0x09, 0xad, 0xf0, 0x88, 0x49, 0xfc, 0x0e, 0xcc, 0x9e, 0xb8, 0x96, 0x5e, 0xb1, 0xd2, 0xb5, 0x0c, 0x2e, 0xa9, 0xcf, 0x99, 0xbc, 0x1b, 0xc3, 0xb0, 0x34, 0xe0, 0x9e, 0x2c, 0x71, 0x19, 0x95, 0xe8,
0x97, 0xeb, 0x1d, 0xd3, 0x1b, 0x5d, 0x4f, 0x02, 0x93, 0xe1, 0x66, 0xe1, 0x9d, 0xac, 0xae, 0x95, 0x88, 0x1f, 0xc1, 0xfc, 0x89, 0x6d, 0xa8, 0x9d, 0x2c, 0x0c, 0x4c, 0x51, 0x43, 0xb9, 0x63, 0x7a,
0x7a, 0xa6, 0x56, 0x9e, 0xc3, 0x4a, 0x51, 0x00, 0xa3, 0xe5, 0xc8, 0x8f, 0x08, 0x66, 0x9e, 0xf9, 0xa3, 0xca, 0x89, 0xf0, 0xa4, 0xa8, 0xe9, 0x20, 0x4f, 0x97, 0x77, 0x4f, 0x35, 0xd5, 0x3d, 0x87,
0x8e, 0x97, 0x74, 0xd4, 0x72, 0x14, 0xd6, 0x01, 0x4c, 0x7a, 0x7d, 0x44, 0x19, 0xeb, 0xda, 0x54, 0xb0, 0x96, 0xe7, 0xc0, 0x78, 0x95, 0xf2, 0x06, 0xc1, 0xdc, 0x73, 0xd7, 0x72, 0x62, 0xbc, 0x2d,
0x21, 0xa0, 0x71, 0xaa, 0xea, 0xfb, 0xf6, 0x88, 0xc9, 0x2e, 0x34, 0x35, 0x3f, 0x46, 0x0b, 0xe6, 0x8e, 0xc2, 0x06, 0x80, 0x4e, 0x07, 0x47, 0x94, 0xb1, 0x9e, 0x49, 0x65, 0x04, 0x14, 0x4a, 0x59,
0x1f, 0x9e, 0x74, 0x99, 0x8c, 0xe3, 0x02, 0xdf, 0x63, 0x54, 0x75, 0x31, 0xdd, 0x0b, 0x54, 0x8d, 0xc7, 0xdf, 0xee, 0x31, 0xe9, 0x40, 0x5d, 0xb1, 0x63, 0x3c, 0x67, 0xfe, 0x0e, 0x4b, 0x2f, 0x55,
0x7b, 0xb6, 0x6e, 0x35, 0x64, 0x6a, 0x39, 0x64, 0xb4, 0x62, 0x98, 0xcc, 0x16, 0x03, 0x97, 0x3f, 0x77, 0x21, 0xc3, 0x75, 0x18, 0x95, 0xb8, 0xa6, 0x5a, 0x81, 0xca, 0xe3, 0x9e, 0xee, 0x5e, 0x25,
0xed, 0x7a, 0x96, 0x4b, 0x2d, 0x9e, 0xd6, 0xf2, 0x3e, 0x35, 0x0e, 0x26, 0x30, 0x23, 0x29, 0x93, 0x32, 0x95, 0x4c, 0x64, 0x94, 0x96, 0x98, 0x4e, 0xb7, 0x44, 0xc8, 0x7f, 0xd6, 0x73, 0x0c, 0x9b,
0xb2, 0xbe, 0x1b, 0xb5, 0xa6, 0x44, 0x45, 0xa4, 0x78, 0xe4, 0x14, 0xd6, 0xca, 0x43, 0x1b, 0x0d, 0x1a, 0x61, 0x71, 0x8b, 0x7c, 0x2a, 0x14, 0x4c, 0x60, 0x4e, 0x9c, 0x74, 0xca, 0x86, 0x76, 0xd0,
0xae, 0x4b, 0x98, 0x39, 0xed, 0x3b, 0xd1, 0x10, 0x57, 0x3f, 0x5e, 0x73, 0xdf, 0x85, 0xa6, 0x66, 0x98, 0xe1, 0x7d, 0x91, 0xa0, 0x91, 0x53, 0x68, 0x16, 0xbb, 0x36, 0x5e, 0xb8, 0x2e, 0x61, 0xee,
0x67, 0x34, 0x5f, 0x7f, 0x43, 0xb0, 0x1c, 0xf7, 0x93, 0xc1, 0xf0, 0xae, 0xf6, 0x7a, 0xac, 0x26, 0x74, 0x68, 0x05, 0x77, 0x48, 0xfd, 0x64, 0x70, 0xdf, 0x81, 0xba, 0xa2, 0x67, 0x3c, 0x5b, 0x7f,
0xcc, 0xfb, 0xd0, 0xa1, 0xe3, 0x46, 0x34, 0x14, 0x17, 0x5a, 0x37, 0x15, 0xc5, 0xed, 0x1d, 0xd3, 0x45, 0xb0, 0x1a, 0xa1, 0xca, 0x68, 0xb4, 0x97, 0x5b, 0x3d, 0x11, 0x14, 0x87, 0x68, 0x74, 0x60,
0x2f, 0xa3, 0x97, 0xf4, 0x5a, 0xdc, 0x64, 0xdd, 0x8c, 0x49, 0xf2, 0x3b, 0x82, 0x95, 0x22, 0x1f, 0xd9, 0x01, 0xf5, 0x79, 0x42, 0xab, 0xba, 0x3c, 0x85, 0xfa, 0x8e, 0xe9, 0x37, 0xc1, 0x4b, 0x3a,
0x47, 0x6a, 0x77, 0x9f, 0x00, 0xf4, 0x06, 0x5b, 0x8d, 0x6c, 0x74, 0xed, 0x7c, 0xa3, 0x93, 0x76, 0xe0, 0x99, 0xac, 0xea, 0xd1, 0x91, 0xfc, 0x86, 0x60, 0x2d, 0xcf, 0xc6, 0xb1, 0x40, 0xef, 0x00,
0x0e, 0xfb, 0xae, 0x2b, 0x26, 0x85, 0x76, 0x86, 0xdb, 0xf4, 0x94, 0xa3, 0x32, 0x82, 0x98, 0x24, 0xa0, 0x3f, 0xda, 0x79, 0x04, 0xdc, 0x3d, 0x2a, 0x82, 0x3b, 0xa1, 0xed, 0x60, 0x68, 0xdb, 0x7c,
0xbf, 0xe4, 0x1c, 0x4d, 0x06, 0x7d, 0x65, 0xf9, 0x6b, 0x0e, 0x4d, 0x88, 0x0d, 0x40, 0x37, 0x37, 0x6a, 0x28, 0x37, 0x43, 0xcd, 0x8e, 0x34, 0x57, 0xf8, 0x11, 0x1d, 0xc9, 0x8f, 0x19, 0x73, 0xe3,
0x5e, 0xf9, 0xff, 0x8c, 0x60, 0xb5, 0xd0, 0xa5, 0x37, 0x03, 0x1e, 0xf9, 0x03, 0x01, 0x7e, 0xee, 0x05, 0xa0, 0x14, 0x04, 0x14, 0xb3, 0xa6, 0xf8, 0x66, 0xa0, 0xaa, 0x9b, 0x0c, 0x04, 0x7e, 0x46,
0x5c, 0x5c, 0x69, 0x7a, 0xd5, 0xf0, 0xbc, 0x0b, 0xf3, 0x5c, 0x9f, 0x5a, 0x32, 0x64, 0x0d, 0xa4, 0xb0, 0x9e, 0x6b, 0xd2, 0xbb, 0x0c, 0x21, 0xf9, 0x1d, 0x01, 0x3e, 0xb4, 0x2e, 0xae, 0x14, 0xb9,
0x1c, 0x9f, 0xbb, 0x6d, 0xd2, 0x2e, 0xf3, 0x3d, 0x05, 0x94, 0xa2, 0xb2, 0x30, 0xd5, 0xab, 0xcb, 0xf2, 0x20, 0x7d, 0x00, 0x8b, 0xa1, 0x3c, 0x35, 0x84, 0xe3, 0x4a, 0xa8, 0x32, 0xf4, 0xd0, 0x78,
0x6c, 0x2a, 0x53, 0x66, 0x8f, 0xa0, 0xd1, 0xb1, 0xb6, 0x65, 0xbb, 0x28, 0xdd, 0xb0, 0x85, 0x69, 0x9d, 0xf6, 0x98, 0xeb, 0xc8, 0x70, 0xc9, 0x53, 0x3a, 0x58, 0xd5, 0xf2, 0x96, 0x9b, 0x49, 0xb5,
0xd1, 0x64, 0xe4, 0x7a, 0xad, 0x28, 0xf2, 0x0d, 0x2c, 0xe6, 0xc2, 0x1d, 0x09, 0xfa, 0x87, 0xd0, 0xdc, 0x13, 0xa8, 0x75, 0x8d, 0x6d, 0x01, 0x1d, 0x85, 0xbb, 0x38, 0x57, 0xcd, 0x01, 0x47, 0x2c,
0x4c, 0xbc, 0xd0, 0xd0, 0x9f, 0x57, 0xe5, 0x9d, 0xc8, 0xcc, 0xb4, 0x1a, 0xe9, 0x8b, 0xfa, 0xe6, 0xe2, 0xf2, 0x44, 0x5e, 0xc3, 0x72, 0xc6, 0xdd, 0xb1, 0x12, 0xf0, 0x18, 0xea, 0xb1, 0x15, 0x4a,
0x23, 0x80, 0x5a, 0xc2, 0x8b, 0xb8, 0xbe, 0xd3, 0xcd, 0x15, 0xe5, 0x9a, 0x6b, 0x1b, 0xa6, 0xfd, 0x0e, 0x16, 0x65, 0xab, 0xc7, 0x3c, 0x3d, 0x29, 0x46, 0x86, 0xbc, 0xd7, 0xc3, 0x71, 0x40, 0x0d,
0x7c, 0x6f, 0xf2, 0x87, 0xec, 0x4d, 0xdf, 0xca, 0x52, 0xc8, 0xd9, 0x1d, 0x6b, 0xdf, 0x1e, 0x62, 0x6e, 0x45, 0xd4, 0xeb, 0x49, 0xa0, 0x45, 0x19, 0xa0, 0xdd, 0x84, 0x59, 0x37, 0x8b, 0x53, 0xee,
0xf3, 0x1c, 0x28, 0x92, 0x3f, 0x11, 0x2c, 0x75, 0xbc, 0xd7, 0x4e, 0x44, 0xb9, 0x4f, 0x67, 0x7e, 0x1d, 0x71, 0xea, 0x8d, 0x68, 0x88, 0x8c, 0xde, 0x89, 0x76, 0xf2, 0x3b, 0xef, 0xa5, 0x23, 0x71,
0xd2, 0x8f, 0x6f, 0xef, 0xba, 0xe5, 0x23, 0x69, 0x90, 0x62, 0x93, 0xa9, 0x14, 0x7b, 0x0f, 0x16, 0xf2, 0x07, 0x82, 0x95, 0xae, 0x73, 0x6d, 0x05, 0x34, 0xb4, 0xec, 0xcc, 0x8d, 0x11, 0xfa, 0x76,
0xa4, 0x2d, 0x3d, 0x4f, 0xeb, 0x22, 0x4f, 0xf3, 0x82, 0xca, 0x74, 0xfb, 0x0e, 0xc1, 0x72, 0x81, 0x1c, 0x2e, 0x1e, 0x52, 0xa3, 0x42, 0x9b, 0x4e, 0x14, 0xda, 0x87, 0xb0, 0x24, 0x74, 0xa9, 0xd5,
0xdb, 0xff, 0x6b, 0xd2, 0x78, 0xb0, 0x94, 0x2c, 0x99, 0xae, 0x3b, 0x4c, 0x99, 0x8e, 0xb7, 0x98, 0x5a, 0xe5, 0xd5, 0x9a, 0x65, 0x94, 0x16, 0xdd, 0x77, 0x08, 0x56, 0x73, 0xcc, 0xfe, 0x4f, 0x4b,
0xff, 0xa4, 0x4d, 0x21, 0xcd, 0xe0, 0x9b, 0xe9, 0x51, 0xdb, 0x7f, 0xdd, 0x05, 0xf9, 0x90, 0xc7, 0xc7, 0x81, 0x95, 0x78, 0xf9, 0xb4, 0xed, 0xbb, 0x34, 0xeb, 0x64, 0x0b, 0xfb, 0x4f, 0xca, 0x5c,
0x8f, 0x61, 0xfa, 0x62, 0xf0, 0x5a, 0xc4, 0xcb, 0xf1, 0x2c, 0x4d, 0x3d, 0x96, 0x8d, 0x95, 0x22, 0x52, 0x14, 0xbe, 0x4b, 0xbc, 0xda, 0xfe, 0xf3, 0x3e, 0x88, 0xe7, 0x3f, 0xfe, 0x14, 0x66, 0x2f,
0x36, 0x0b, 0xf0, 0x43, 0x68, 0x7c, 0x11, 0xaf, 0x5e, 0x78, 0x51, 0x29, 0xe9, 0x4b, 0xa1, 0xb1, 0x46, 0xaf, 0x4b, 0xbc, 0x1a, 0xcd, 0xd8, 0xc4, 0x13, 0x5b, 0x5b, 0xcb, 0x23, 0x33, 0x0f, 0x3f,
0x94, 0x67, 0xca, 0x73, 0xd7, 0xf1, 0x5c, 0x4f, 0xce, 0xe9, 0x1b, 0x45, 0x72, 0x2e, 0x3d, 0xfe, 0x86, 0xda, 0xd7, 0xd1, 0x4a, 0x86, 0x97, 0xa5, 0x90, 0xba, 0x2c, 0x6a, 0x2b, 0x59, 0xa2, 0xb8,
0x77, 0xa1, 0x69, 0xeb, 0x6f, 0x3d, 0xbc, 0x1a, 0xbf, 0xd6, 0x33, 0xcf, 0x4e, 0xa3, 0x55, 0x2c, 0x37, 0x88, 0xe6, 0x7d, 0x7c, 0x4f, 0xdd, 0x34, 0xe2, 0x7b, 0xc9, 0xb5, 0xa0, 0x03, 0x75, 0x53,
0x60, 0x01, 0xfe, 0x18, 0x66, 0x98, 0xf6, 0x44, 0xc2, 0x71, 0x6c, 0x99, 0xe7, 0x9b, 0xb1, 0x5a, 0x7d, 0x15, 0xe2, 0xf5, 0xe8, 0x8d, 0x9f, 0x7a, 0xa0, 0x6a, 0x8d, 0x7c, 0x06, 0xf3, 0xf0, 0xe7,
0xc8, 0x67, 0x01, 0xfe, 0x1c, 0x56, 0xed, 0xe2, 0xf7, 0x09, 0x7e, 0x90, 0xb1, 0x9a, 0x7f, 0x3c, 0x30, 0xc7, 0x94, 0x07, 0x14, 0x8e, 0x7c, 0x4b, 0x3d, 0xf1, 0xb4, 0xf5, 0x5c, 0x3a, 0xf3, 0xf0,
0x19, 0xe4, 0x36, 0x15, 0x16, 0xe0, 0x53, 0xc0, 0x51, 0x6e, 0x4f, 0xc7, 0x6b, 0xea, 0x64, 0xe1, 0x57, 0xb0, 0x6e, 0xe6, 0xbf, 0x5e, 0xf0, 0xc3, 0x94, 0xd6, 0xec, 0xd3, 0x4a, 0x23, 0xb7, 0x89,
0x1b, 0xc4, 0x78, 0xab, 0x42, 0xca, 0x02, 0x7c, 0x01, 0x2d, 0xbb, 0x64, 0x09, 0xc4, 0x24, 0xf5, 0x30, 0x0f, 0x9f, 0x02, 0x0e, 0x32, 0xfb, 0x3b, 0x6e, 0xca, 0x9b, 0xb9, 0x6f, 0x13, 0xed, 0xff,
0x97, 0x47, 0xe1, 0x02, 0x6c, 0xbc, 0x7d, 0xab, 0x8e, 0xf4, 0xdb, 0xce, 0x6d, 0x31, 0x89, 0xdf, 0x25, 0x5c, 0xe6, 0xe1, 0x0b, 0x68, 0x98, 0x05, 0xcb, 0x21, 0x26, 0x89, 0x3f, 0x4a, 0x72, 0x17,
0x85, 0x4b, 0x58, 0xe2, 0x77, 0xc9, 0xfa, 0x73, 0x06, 0x8b, 0x76, 0x7e, 0xb8, 0xe3, 0xe2, 0x53, 0x63, 0xed, 0xfd, 0x5b, 0x65, 0x84, 0xdd, 0x66, 0x66, 0xbb, 0x89, 0xed, 0xce, 0x5d, 0xce, 0x62,
0xc9, 0xed, 0xaf, 0x57, 0x89, 0x59, 0x80, 0x9f, 0xc2, 0xdc, 0x55, 0x7a, 0x66, 0xe1, 0xf8, 0x7f, 0xbb, 0x0b, 0xd6, 0xa2, 0x33, 0x58, 0x36, 0xb3, 0xe3, 0x1e, 0xe7, 0xdf, 0x8a, 0xb3, 0xbf, 0x51,
0x9f, 0xfc, 0xe8, 0x36, 0x8c, 0x32, 0x51, 0x12, 0x72, 0x66, 0x08, 0xe8, 0x21, 0xe7, 0xe7, 0x92, 0xc6, 0x66, 0x1e, 0x7e, 0x06, 0x0b, 0x57, 0xc9, 0xf9, 0x85, 0xa3, 0x7f, 0x8b, 0xb2, 0x63, 0x5c,
0x1e, 0x72, 0xd1, 0xf4, 0x38, 0x86, 0x05, 0x27, 0xdb, 0x1d, 0xf1, 0xfd, 0xb8, 0xa1, 0x15, 0xb4, 0xd3, 0x8a, 0x58, 0xb1, 0xcb, 0xa9, 0x81, 0xa0, 0xba, 0x9c, 0x9d, 0x51, 0xaa, 0xcb, 0x79, 0x93,
0x7b, 0x63, 0xad, 0x5c, 0x28, 0xbf, 0x67, 0x67, 0x3b, 0x4f, 0xf2, 0xbd, 0xa2, 0x26, 0x68, 0xac, 0xe4, 0x18, 0x96, 0xac, 0x34, 0x46, 0xe2, 0x07, 0x11, 0xac, 0xe5, 0x80, 0xbe, 0xd6, 0x2c, 0x66,
0x95, 0x0b, 0x59, 0xb0, 0x3b, 0xf7, 0x59, 0x73, 0x53, 0xfe, 0x27, 0xf8, 0x48, 0xfc, 0xbe, 0x9a, 0x8a, 0xef, 0x99, 0x69, 0xfc, 0x89, 0xbf, 0x97, 0x07, 0x85, 0x5a, 0xb3, 0x98, 0xc9, 0xbc, 0xce,
0x12, 0x7f, 0xf8, 0x7d, 0xf0, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xac, 0x58, 0xf3, 0xe0, 0x2f, 0xc2, 0x97, 0xf5, 0x96, 0xf8, 0x27, 0xf1, 0x09, 0xff, 0x7d, 0x35, 0xc3, 0xff, 0x26, 0xfc, 0xf8,
0x14, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf6, 0x24, 0x19, 0x44, 0x65, 0x14, 0x00, 0x00,
} }

@ -16,7 +16,7 @@ message GroupAddMemberInfo{
message CreateGroupReq{ message CreateGroupReq{
repeated GroupAddMemberInfo InitMemberList = 1; repeated GroupAddMemberInfo InitMemberList = 1;
open_im_sdk.GroupInfo GroupInfo = 2; server_api_params.GroupInfo GroupInfo = 2;
string OperationID = 3; string OperationID = 3;
string OpUserID = 4; //app manager or group owner string OpUserID = 4; //app manager or group owner
string OwnerUserID = 5; //owner string OwnerUserID = 5; //owner
@ -24,7 +24,7 @@ message CreateGroupReq{
message CreateGroupResp{ message CreateGroupResp{
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
open_im_sdk.GroupInfo GroupInfo = 3; server_api_params.GroupInfo GroupInfo = 3;
} }
@ -36,12 +36,12 @@ message GetGroupsInfoReq{
message GetGroupsInfoResp{ message GetGroupsInfoResp{
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.GroupInfo GroupInfoList = 3; repeated server_api_params.GroupInfo GroupInfoList = 3;
} }
message SetGroupInfoReq{ message SetGroupInfoReq{
open_im_sdk.GroupInfo GroupInfo = 1; server_api_params.GroupInfo GroupInfo = 1;
string OpUserID = 2; //app manager or group owner string OpUserID = 2; //app manager or group owner
string OperationID = 3; string OperationID = 3;
} }
@ -58,7 +58,7 @@ message GetGroupApplicationListReq {
message GetGroupApplicationListResp { message GetGroupApplicationListResp {
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.GroupRequest GroupRequestList = 3; repeated server_api_params.GroupRequest GroupRequestList = 3;
} }
@ -120,7 +120,7 @@ message GetGroupMemberListReq {
message GetGroupMemberListResp { message GetGroupMemberListResp {
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.GroupMemberFullInfo memberList = 3; repeated server_api_params.GroupMemberFullInfo memberList = 3;
int32 nextSeq = 4; int32 nextSeq = 4;
} }
@ -135,7 +135,7 @@ message GetGroupMembersInfoReq {
message GetGroupMembersInfoResp { message GetGroupMembersInfoResp {
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.GroupMemberFullInfo memberList = 3; repeated server_api_params.GroupMemberFullInfo memberList = 3;
} }
message KickGroupMemberReq { message KickGroupMemberReq {
@ -166,7 +166,7 @@ message GetJoinedGroupListReq {
message GetJoinedGroupListResp{ message GetJoinedGroupListResp{
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.GroupInfo GroupList = 3; repeated server_api_params.GroupInfo GroupList = 3;
} }
@ -192,7 +192,7 @@ message GetGroupAllMemberReq {
message GetGroupAllMemberResp { message GetGroupAllMemberResp {
int32 ErrCode = 1; int32 ErrCode = 1;
string ErrMsg = 2; string ErrMsg = 2;
repeated open_im_sdk.GroupMemberFullInfo memberList = 3; repeated server_api_params.GroupMemberFullInfo memberList = 3;
} }

@ -36,7 +36,7 @@ func (m *PushMsgReq) Reset() { *m = PushMsgReq{} }
func (m *PushMsgReq) String() string { return proto.CompactTextString(m) } func (m *PushMsgReq) String() string { return proto.CompactTextString(m) }
func (*PushMsgReq) ProtoMessage() {} func (*PushMsgReq) ProtoMessage() {}
func (*PushMsgReq) Descriptor() ([]byte, []int) { func (*PushMsgReq) Descriptor() ([]byte, []int) {
return fileDescriptor_push_e9dec9fedbbc6360, []int{0} return fileDescriptor_push_3a8dbda4109fac8a, []int{0}
} }
func (m *PushMsgReq) XXX_Unmarshal(b []byte) error { func (m *PushMsgReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PushMsgReq.Unmarshal(m, b) return xxx_messageInfo_PushMsgReq.Unmarshal(m, b)
@ -81,7 +81,7 @@ func (m *PushMsgResp) Reset() { *m = PushMsgResp{} }
func (m *PushMsgResp) String() string { return proto.CompactTextString(m) } func (m *PushMsgResp) String() string { return proto.CompactTextString(m) }
func (*PushMsgResp) ProtoMessage() {} func (*PushMsgResp) ProtoMessage() {}
func (*PushMsgResp) Descriptor() ([]byte, []int) { func (*PushMsgResp) Descriptor() ([]byte, []int) {
return fileDescriptor_push_e9dec9fedbbc6360, []int{1} return fileDescriptor_push_3a8dbda4109fac8a, []int{1}
} }
func (m *PushMsgResp) XXX_Unmarshal(b []byte) error { func (m *PushMsgResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PushMsgResp.Unmarshal(m, b) return xxx_messageInfo_PushMsgResp.Unmarshal(m, b)
@ -185,22 +185,23 @@ var _PushMsgService_serviceDesc = grpc.ServiceDesc{
Metadata: "push/push.proto", Metadata: "push/push.proto",
} }
func init() { proto.RegisterFile("push/push.proto", fileDescriptor_push_e9dec9fedbbc6360) } func init() { proto.RegisterFile("push/push.proto", fileDescriptor_push_3a8dbda4109fac8a) }
var fileDescriptor_push_e9dec9fedbbc6360 = []byte{ var fileDescriptor_push_3a8dbda4109fac8a = []byte{
// 221 bytes of a gzipped FileDescriptorProto // 229 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2f, 0x28, 0x2d, 0xce, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x90, 0x31, 0x4f, 0xc3, 0x30,
0xd0, 0x07, 0x11, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x2c, 0x20, 0xb6, 0x94, 0xa2, 0x7f, 0x10, 0x85, 0x15, 0x04, 0x54, 0x5c, 0x04, 0x05, 0x4f, 0x55, 0x06, 0x14, 0x3a, 0x75, 0xc1, 0x96,
0x41, 0x6a, 0x5e, 0xbc, 0xa7, 0xaf, 0x7e, 0x41, 0x76, 0xba, 0x3e, 0x58, 0x42, 0xbf, 0x38, 0x25, 0x0a, 0x1b, 0x0b, 0x82, 0x2e, 0x1d, 0x22, 0x90, 0xd9, 0x58, 0x2c, 0x97, 0x9c, 0xd2, 0xa8, 0xb4,
0x3b, 0xbe, 0xbc, 0x58, 0xbf, 0xbc, 0x18, 0xa2, 0x50, 0x29, 0x8e, 0x8b, 0x2b, 0xa0, 0xb4, 0x38, 0x3e, 0x7c, 0x4e, 0xfb, 0xf7, 0x51, 0x9c, 0x00, 0x11, 0x8b, 0x65, 0x7d, 0xf7, 0x49, 0xef, 0xde,
0xc3, 0xb7, 0x38, 0x3d, 0x28, 0xb5, 0x50, 0x48, 0x81, 0x8b, 0x3b, 0xbf, 0x20, 0xb5, 0x28, 0xb1, 0xc1, 0x98, 0x1a, 0x5e, 0xab, 0xf6, 0x91, 0xe4, 0x5d, 0x70, 0xe2, 0xb8, 0xfd, 0x67, 0x37, 0x2f,
0x24, 0x33, 0x3f, 0xcf, 0xd3, 0x45, 0x82, 0x51, 0x81, 0x51, 0x83, 0x33, 0x08, 0x59, 0x48, 0x48, 0x84, 0x3b, 0xb3, 0x2c, 0x14, 0x6d, 0x2a, 0x15, 0x07, 0x8a, 0xcb, 0x8d, 0x39, 0xb0, 0x3a, 0x70,
0x8f, 0x8b, 0x3d, 0xb7, 0x38, 0xdd, 0x25, 0xb1, 0x24, 0x51, 0x82, 0x49, 0x81, 0x51, 0x83, 0xdb, 0x27, 0x4e, 0x4b, 0x80, 0xd7, 0x86, 0xd7, 0x05, 0x57, 0x1a, 0xbf, 0x44, 0x0e, 0xa9, 0x23, 0xf4,
0x48, 0x44, 0x2f, 0x1f, 0x64, 0x49, 0x66, 0x6e, 0x7c, 0x71, 0x4a, 0xb6, 0x9e, 0x2f, 0x44, 0x2e, 0x36, 0xd4, 0x6e, 0xb7, 0x5c, 0x4c, 0x92, 0x3c, 0x99, 0x9d, 0xe9, 0x21, 0x12, 0xf7, 0x30, 0xda,
0x08, 0xa6, 0x48, 0x49, 0x97, 0x8b, 0x1b, 0x6e, 0x7e, 0x71, 0x81, 0x90, 0x1c, 0x17, 0x57, 0x50, 0x72, 0xb5, 0xb0, 0xc1, 0x4e, 0x8e, 0xf2, 0x64, 0x96, 0xce, 0x33, 0xc9, 0xe8, 0xf7, 0xe8, 0x8d,
0x6a, 0x71, 0x69, 0x4e, 0x89, 0x73, 0x7e, 0x4a, 0x2a, 0xd8, 0x7c, 0xd6, 0x20, 0x24, 0x11, 0x23, 0xa5, 0xda, 0x90, 0xf5, 0x76, 0xcb, 0xb2, 0xe8, 0x0c, 0xfd, 0xa3, 0x4e, 0x6f, 0x21, 0xfd, 0x4d,
0x07, 0x2e, 0x3e, 0xa8, 0xf2, 0xe0, 0xd4, 0xa2, 0xb2, 0xcc, 0xe4, 0x54, 0x90, 0x85, 0x50, 0x11, 0x61, 0x12, 0xd7, 0x00, 0x1a, 0xb9, 0xf9, 0x0c, 0xcf, 0xae, 0xc4, 0x98, 0x72, 0xa2, 0x07, 0x64,
0x21, 0x01, 0x3d, 0xb0, 0x0f, 0x11, 0xee, 0x95, 0x12, 0x44, 0x13, 0x29, 0x2e, 0x70, 0xe2, 0x8f, 0xfe, 0x08, 0x17, 0xbd, 0xfe, 0x86, 0x7e, 0x5f, 0x7f, 0xa0, 0x90, 0x30, 0xea, 0x89, 0xb8, 0x94,
0xe2, 0xd5, 0x03, 0x87, 0x84, 0x75, 0x41, 0x12, 0x48, 0x3c, 0x89, 0x0d, 0xec, 0x51, 0x63, 0x40, 0xb1, 0xe7, 0xdf, 0xd6, 0xd9, 0xd5, 0x3f, 0xc2, 0xf4, 0x34, 0x7e, 0x3f, 0x97, 0xf1, 0x1e, 0x0f,
0x00, 0x00, 0x00, 0xff, 0xff, 0x02, 0x62, 0xa4, 0x3d, 0x24, 0x01, 0x00, 0x00, 0xb4, 0x6a, 0xf9, 0xea, 0x34, 0xd6, 0xbd, 0xfb, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xa1, 0x97, 0x1e,
0x77, 0x2a, 0x01, 0x00, 0x00,
} }

@ -5,7 +5,7 @@ package push;
message PushMsgReq { message PushMsgReq {
string operationID = 1; string operationID = 1;
open_im_sdk.MsgData msgData = 2; server_api_params.MsgData msgData = 2;
} }
message PushMsgResp{ message PushMsgResp{
int32 ResultCode = 1; int32 ResultCode = 1;

@ -36,7 +36,7 @@ func (m *OnlinePushMsgReq) Reset() { *m = OnlinePushMsgReq{} }
func (m *OnlinePushMsgReq) String() string { return proto.CompactTextString(m) } func (m *OnlinePushMsgReq) String() string { return proto.CompactTextString(m) }
func (*OnlinePushMsgReq) ProtoMessage() {} func (*OnlinePushMsgReq) ProtoMessage() {}
func (*OnlinePushMsgReq) Descriptor() ([]byte, []int) { func (*OnlinePushMsgReq) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_de3bbbc2d62c0c49, []int{0} return fileDescriptor_relay_aeddd7666fcf4cae, []int{0}
} }
func (m *OnlinePushMsgReq) XXX_Unmarshal(b []byte) error { func (m *OnlinePushMsgReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OnlinePushMsgReq.Unmarshal(m, b) return xxx_messageInfo_OnlinePushMsgReq.Unmarshal(m, b)
@ -81,7 +81,7 @@ func (m *OnlinePushMsgResp) Reset() { *m = OnlinePushMsgResp{} }
func (m *OnlinePushMsgResp) String() string { return proto.CompactTextString(m) } func (m *OnlinePushMsgResp) String() string { return proto.CompactTextString(m) }
func (*OnlinePushMsgResp) ProtoMessage() {} func (*OnlinePushMsgResp) ProtoMessage() {}
func (*OnlinePushMsgResp) Descriptor() ([]byte, []int) { func (*OnlinePushMsgResp) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_de3bbbc2d62c0c49, []int{1} return fileDescriptor_relay_aeddd7666fcf4cae, []int{1}
} }
func (m *OnlinePushMsgResp) XXX_Unmarshal(b []byte) error { func (m *OnlinePushMsgResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OnlinePushMsgResp.Unmarshal(m, b) return xxx_messageInfo_OnlinePushMsgResp.Unmarshal(m, b)
@ -121,7 +121,7 @@ func (m *SingleMsgToUser) Reset() { *m = SingleMsgToUser{} }
func (m *SingleMsgToUser) String() string { return proto.CompactTextString(m) } func (m *SingleMsgToUser) String() string { return proto.CompactTextString(m) }
func (*SingleMsgToUser) ProtoMessage() {} func (*SingleMsgToUser) ProtoMessage() {}
func (*SingleMsgToUser) Descriptor() ([]byte, []int) { func (*SingleMsgToUser) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_de3bbbc2d62c0c49, []int{2} return fileDescriptor_relay_aeddd7666fcf4cae, []int{2}
} }
func (m *SingleMsgToUser) XXX_Unmarshal(b []byte) error { func (m *SingleMsgToUser) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SingleMsgToUser.Unmarshal(m, b) return xxx_messageInfo_SingleMsgToUser.Unmarshal(m, b)
@ -175,7 +175,7 @@ func (m *GetUsersOnlineStatusReq) Reset() { *m = GetUsersOnlineStatusReq
func (m *GetUsersOnlineStatusReq) String() string { return proto.CompactTextString(m) } func (m *GetUsersOnlineStatusReq) String() string { return proto.CompactTextString(m) }
func (*GetUsersOnlineStatusReq) ProtoMessage() {} func (*GetUsersOnlineStatusReq) ProtoMessage() {}
func (*GetUsersOnlineStatusReq) Descriptor() ([]byte, []int) { func (*GetUsersOnlineStatusReq) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_de3bbbc2d62c0c49, []int{3} return fileDescriptor_relay_aeddd7666fcf4cae, []int{3}
} }
func (m *GetUsersOnlineStatusReq) XXX_Unmarshal(b []byte) error { func (m *GetUsersOnlineStatusReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUsersOnlineStatusReq.Unmarshal(m, b) return xxx_messageInfo_GetUsersOnlineStatusReq.Unmarshal(m, b)
@ -230,7 +230,7 @@ func (m *GetUsersOnlineStatusResp) Reset() { *m = GetUsersOnlineStatusRe
func (m *GetUsersOnlineStatusResp) String() string { return proto.CompactTextString(m) } func (m *GetUsersOnlineStatusResp) String() string { return proto.CompactTextString(m) }
func (*GetUsersOnlineStatusResp) ProtoMessage() {} func (*GetUsersOnlineStatusResp) ProtoMessage() {}
func (*GetUsersOnlineStatusResp) Descriptor() ([]byte, []int) { func (*GetUsersOnlineStatusResp) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_de3bbbc2d62c0c49, []int{4} return fileDescriptor_relay_aeddd7666fcf4cae, []int{4}
} }
func (m *GetUsersOnlineStatusResp) XXX_Unmarshal(b []byte) error { func (m *GetUsersOnlineStatusResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUsersOnlineStatusResp.Unmarshal(m, b) return xxx_messageInfo_GetUsersOnlineStatusResp.Unmarshal(m, b)
@ -292,7 +292,7 @@ func (m *GetUsersOnlineStatusResp_SuccessDetail) Reset() {
func (m *GetUsersOnlineStatusResp_SuccessDetail) String() string { return proto.CompactTextString(m) } func (m *GetUsersOnlineStatusResp_SuccessDetail) String() string { return proto.CompactTextString(m) }
func (*GetUsersOnlineStatusResp_SuccessDetail) ProtoMessage() {} func (*GetUsersOnlineStatusResp_SuccessDetail) ProtoMessage() {}
func (*GetUsersOnlineStatusResp_SuccessDetail) Descriptor() ([]byte, []int) { func (*GetUsersOnlineStatusResp_SuccessDetail) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_de3bbbc2d62c0c49, []int{4, 0} return fileDescriptor_relay_aeddd7666fcf4cae, []int{4, 0}
} }
func (m *GetUsersOnlineStatusResp_SuccessDetail) XXX_Unmarshal(b []byte) error { func (m *GetUsersOnlineStatusResp_SuccessDetail) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUsersOnlineStatusResp_SuccessDetail.Unmarshal(m, b) return xxx_messageInfo_GetUsersOnlineStatusResp_SuccessDetail.Unmarshal(m, b)
@ -339,7 +339,7 @@ func (m *GetUsersOnlineStatusResp_FailedDetail) Reset() { *m = GetUsersO
func (m *GetUsersOnlineStatusResp_FailedDetail) String() string { return proto.CompactTextString(m) } func (m *GetUsersOnlineStatusResp_FailedDetail) String() string { return proto.CompactTextString(m) }
func (*GetUsersOnlineStatusResp_FailedDetail) ProtoMessage() {} func (*GetUsersOnlineStatusResp_FailedDetail) ProtoMessage() {}
func (*GetUsersOnlineStatusResp_FailedDetail) Descriptor() ([]byte, []int) { func (*GetUsersOnlineStatusResp_FailedDetail) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_de3bbbc2d62c0c49, []int{4, 1} return fileDescriptor_relay_aeddd7666fcf4cae, []int{4, 1}
} }
func (m *GetUsersOnlineStatusResp_FailedDetail) XXX_Unmarshal(b []byte) error { func (m *GetUsersOnlineStatusResp_FailedDetail) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUsersOnlineStatusResp_FailedDetail.Unmarshal(m, b) return xxx_messageInfo_GetUsersOnlineStatusResp_FailedDetail.Unmarshal(m, b)
@ -395,7 +395,7 @@ func (m *GetUsersOnlineStatusResp_SuccessResult) Reset() {
func (m *GetUsersOnlineStatusResp_SuccessResult) String() string { return proto.CompactTextString(m) } func (m *GetUsersOnlineStatusResp_SuccessResult) String() string { return proto.CompactTextString(m) }
func (*GetUsersOnlineStatusResp_SuccessResult) ProtoMessage() {} func (*GetUsersOnlineStatusResp_SuccessResult) ProtoMessage() {}
func (*GetUsersOnlineStatusResp_SuccessResult) Descriptor() ([]byte, []int) { func (*GetUsersOnlineStatusResp_SuccessResult) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_de3bbbc2d62c0c49, []int{4, 2} return fileDescriptor_relay_aeddd7666fcf4cae, []int{4, 2}
} }
func (m *GetUsersOnlineStatusResp_SuccessResult) XXX_Unmarshal(b []byte) error { func (m *GetUsersOnlineStatusResp_SuccessResult) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUsersOnlineStatusResp_SuccessResult.Unmarshal(m, b) return xxx_messageInfo_GetUsersOnlineStatusResp_SuccessResult.Unmarshal(m, b)
@ -552,42 +552,42 @@ var _OnlineMessageRelayService_serviceDesc = grpc.ServiceDesc{
Metadata: "relay/relay.proto", Metadata: "relay/relay.proto",
} }
func init() { proto.RegisterFile("relay/relay.proto", fileDescriptor_relay_de3bbbc2d62c0c49) } func init() { proto.RegisterFile("relay/relay.proto", fileDescriptor_relay_aeddd7666fcf4cae) }
var fileDescriptor_relay_de3bbbc2d62c0c49 = []byte{ var fileDescriptor_relay_aeddd7666fcf4cae = []byte{
// 539 bytes of a gzipped FileDescriptorProto // 544 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x5f, 0x8f, 0xd2, 0x40, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x5f, 0x6f, 0xd2, 0x50,
0x10, 0x4f, 0xe5, 0xfe, 0xc8, 0x70, 0x78, 0xb2, 0x21, 0x77, 0xb5, 0x0f, 0x88, 0x3c, 0x18, 0x62, 0x14, 0x4f, 0x05, 0x36, 0x39, 0x0c, 0x27, 0x37, 0xcb, 0x56, 0xfb, 0x80, 0xc8, 0x83, 0x21, 0x46,
0xb4, 0x24, 0xf8, 0xe8, 0x83, 0xc9, 0x5d, 0x73, 0x86, 0xc4, 0x06, 0xb2, 0x78, 0xd1, 0xf8, 0x42, 0x4b, 0x82, 0xbe, 0xf9, 0x60, 0xb2, 0x35, 0x33, 0x24, 0x36, 0x90, 0x8b, 0x8b, 0xc6, 0x17, 0x72,
0x7a, 0x74, 0xae, 0x36, 0x14, 0xba, 0xec, 0x6c, 0x8f, 0xf8, 0x75, 0xfc, 0x12, 0xfa, 0xf1, 0x4c, 0x07, 0x67, 0xb5, 0xae, 0xd0, 0xcb, 0x3d, 0x2d, 0xc4, 0xaf, 0xe3, 0x97, 0xd0, 0x8f, 0x67, 0x7a,
0x77, 0x0b, 0x16, 0xc2, 0x79, 0xb9, 0x17, 0xc2, 0xcc, 0xec, 0xfc, 0xfe, 0xb5, 0x5d, 0x68, 0x48, 0x6f, 0xc1, 0x42, 0x98, 0xcb, 0x5e, 0x08, 0xe7, 0xdc, 0x73, 0x7e, 0xff, 0xda, 0x5e, 0x68, 0x28,
0x4c, 0x82, 0x9f, 0x3d, 0xfd, 0xeb, 0x0a, 0x99, 0xaa, 0x94, 0x1d, 0xea, 0xc2, 0x79, 0x35, 0x14, 0x8c, 0xc4, 0xcf, 0xae, 0xfe, 0x75, 0xa5, 0x8a, 0x93, 0x98, 0x55, 0x74, 0xe1, 0xbc, 0x18, 0x48,
0xb8, 0x98, 0x0c, 0xfc, 0x9e, 0x98, 0x45, 0x3d, 0x3d, 0xe9, 0x51, 0x38, 0x9b, 0xac, 0xa8, 0xb7, 0x9c, 0x8f, 0xfb, 0x7e, 0x57, 0xde, 0x06, 0x5d, 0x7d, 0xd2, 0xa5, 0xe9, 0xed, 0x78, 0x45, 0xdd,
0x22, 0x73, 0xb2, 0x13, 0xc2, 0xf3, 0xe1, 0x22, 0x89, 0x17, 0x38, 0xca, 0xe8, 0x87, 0x4f, 0x11, 0x15, 0x99, 0xc9, 0xf6, 0x0f, 0x78, 0x3a, 0x98, 0x47, 0xe1, 0x1c, 0x87, 0x29, 0x7d, 0xf7, 0x29,
0xc7, 0x25, 0x6b, 0x43, 0x6d, 0x28, 0x50, 0x06, 0x2a, 0x4e, 0x17, 0x03, 0xcf, 0xb6, 0xda, 0x56, 0xe0, 0xb8, 0x60, 0x2d, 0xa8, 0x0d, 0x24, 0x2a, 0x91, 0x84, 0xf1, 0xbc, 0xef, 0xd9, 0x56, 0xcb,
0xb7, 0xca, 0xcb, 0x2d, 0xe6, 0xc2, 0xf1, 0x9c, 0x22, 0x2f, 0x50, 0x81, 0xfd, 0xa4, 0x6d, 0x75, 0xea, 0x54, 0x79, 0xb1, 0xc5, 0xde, 0xc1, 0xe1, 0x8c, 0x02, 0x4f, 0x24, 0xc2, 0x7e, 0xd4, 0xb2,
0x6b, 0xfd, 0xa6, 0x9b, 0xe6, 0x54, 0xf1, 0x7c, 0x42, 0xe1, 0xcc, 0xf5, 0xcd, 0x8c, 0xaf, 0x0f, 0x3a, 0xb5, 0x9e, 0xe3, 0x12, 0xaa, 0x25, 0xaa, 0xb1, 0x90, 0xe1, 0x58, 0x0a, 0x25, 0x66, 0xe4,
0x75, 0x3e, 0x42, 0x63, 0x87, 0x85, 0x04, 0x7b, 0x03, 0x07, 0x12, 0x49, 0xd8, 0x56, 0xbb, 0xd2, 0xfa, 0x66, 0x82, 0xaf, 0x47, 0xdb, 0x1f, 0xa0, 0xb1, 0xc3, 0x45, 0x92, 0xbd, 0x82, 0xb2, 0x42,
0xad, 0xf5, 0xcf, 0x5c, 0x63, 0x60, 0x1c, 0x2f, 0xa2, 0x04, 0x7d, 0x8a, 0xbe, 0xa4, 0xd7, 0x84, 0x92, 0xb6, 0xd5, 0x2a, 0x75, 0x6a, 0xbd, 0x53, 0xd7, 0xd8, 0x18, 0x85, 0xf3, 0x20, 0x42, 0x9f,
0x92, 0xeb, 0x33, 0x9d, 0x25, 0x9c, 0xee, 0x0c, 0x58, 0x0b, 0x80, 0x23, 0x65, 0x89, 0xba, 0x4c, 0x82, 0xcf, 0xf1, 0x15, 0xa1, 0xe2, 0x7a, 0xa6, 0xbd, 0x80, 0xe3, 0x9d, 0x03, 0xd6, 0x04, 0xe0,
0x43, 0xd4, 0x22, 0x2b, 0xbc, 0xd4, 0x61, 0x67, 0x70, 0xc4, 0x71, 0x7a, 0x37, 0xf0, 0xb4, 0xc4, 0x48, 0x69, 0x94, 0x5c, 0xc4, 0x53, 0xd4, 0x52, 0x4b, 0xbc, 0xd0, 0x61, 0xa7, 0x70, 0xc0, 0x71,
0x2a, 0x2f, 0x2a, 0xf6, 0x1a, 0x9e, 0xe5, 0xff, 0x46, 0x49, 0xa0, 0xae, 0x52, 0x39, 0x1f, 0x78, 0xb2, 0xec, 0x7b, 0x5a, 0x68, 0x95, 0xe7, 0x15, 0x7b, 0x09, 0x4f, 0xb2, 0x7f, 0xc3, 0x48, 0x24,
0x76, 0xa5, 0x6d, 0x75, 0x0f, 0xf9, 0x4e, 0xb7, 0xb3, 0x82, 0xf3, 0x4f, 0xa8, 0x72, 0x2a, 0x32, 0x97, 0xb1, 0x9a, 0xf5, 0x3d, 0xbb, 0xd4, 0xb2, 0x3a, 0x15, 0xbe, 0xd3, 0x6d, 0xaf, 0xe0, 0xec,
0xda, 0xc7, 0x2a, 0x50, 0x19, 0xe5, 0x01, 0xb5, 0x00, 0x32, 0x42, 0x39, 0xf0, 0x3e, 0xc7, 0xa4, 0x23, 0x26, 0x19, 0x15, 0x19, 0xed, 0xa3, 0x44, 0x24, 0x29, 0x65, 0x31, 0x35, 0x01, 0x52, 0x42,
0xb4, 0xfe, 0x2a, 0x2f, 0x75, 0xf2, 0x00, 0xd3, 0x52, 0x80, 0x86, 0xbf, 0xdc, 0x62, 0x0e, 0x3c, 0xd5, 0xf7, 0x3e, 0x85, 0x94, 0x68, 0xfd, 0x55, 0x5e, 0xe8, 0x64, 0x31, 0xc6, 0x85, 0x18, 0x0d,
0x4d, 0xc5, 0xb5, 0xde, 0xd0, 0xf4, 0x55, 0xbe, 0xa9, 0x3b, 0xbf, 0x0f, 0xc0, 0xde, 0xcf, 0x4c, 0x7f, 0xb1, 0xc5, 0x1c, 0x78, 0x1c, 0xcb, 0x2b, 0xbd, 0xa1, 0xe9, 0xab, 0x7c, 0x53, 0xb7, 0x7f,
0x82, 0xd9, 0x70, 0x8c, 0x52, 0x6e, 0x2c, 0x1f, 0xf2, 0x75, 0x99, 0xfb, 0x45, 0x29, 0x7d, 0x8a, 0x97, 0xc1, 0xde, 0xcf, 0x4c, 0x92, 0xd9, 0x70, 0x88, 0x4a, 0x6d, 0x2c, 0x57, 0xf8, 0xba, 0xcc,
0xd6, 0x7e, 0x4d, 0xc5, 0xc6, 0x50, 0xa7, 0x6c, 0x3a, 0x45, 0x22, 0x13, 0x8e, 0x5d, 0xd1, 0x79, 0xfc, 0xa2, 0x52, 0x3e, 0x05, 0x6b, 0xbf, 0xa6, 0x62, 0x23, 0xa8, 0x53, 0x3a, 0x99, 0x20, 0x91,
0xbf, 0x2b, 0xf2, 0xbe, 0x8f, 0xc9, 0x1d, 0x97, 0x97, 0xf8, 0x36, 0x06, 0x1b, 0xc1, 0xc9, 0x6d, 0x09, 0xc7, 0x2e, 0xe9, 0xbc, 0xdf, 0xe4, 0x79, 0xdf, 0xc5, 0xe4, 0x8e, 0x8a, 0x4b, 0x7c, 0x1b,
0x10, 0x27, 0x18, 0x16, 0x98, 0x07, 0x1a, 0xf3, 0xed, 0x43, 0x98, 0x57, 0x7a, 0xc7, 0x43, 0x15, 0x83, 0x0d, 0xe1, 0xe8, 0x46, 0x84, 0x11, 0x4e, 0x73, 0xcc, 0xb2, 0xc6, 0x7c, 0x7d, 0x1f, 0xe6,
0xc4, 0x09, 0xdf, 0x42, 0x70, 0x2e, 0xa1, 0x5e, 0x30, 0x9a, 0x71, 0x1e, 0x91, 0x48, 0x02, 0x75, 0xa5, 0xde, 0xf1, 0x30, 0x11, 0x61, 0xc4, 0xb7, 0x10, 0x9c, 0x0b, 0xa8, 0xe7, 0x8c, 0xe6, 0x38,
0x9b, 0xca, 0x79, 0xf1, 0x0a, 0x6e, 0xea, 0xdc, 0x2b, 0x69, 0xd4, 0xb5, 0x57, 0x53, 0x39, 0xdf, 0x8b, 0x48, 0x46, 0x22, 0xb9, 0x89, 0xd5, 0x2c, 0x7f, 0x11, 0x37, 0x75, 0xe6, 0x95, 0x34, 0xea,
0xe0, 0xa4, 0x4c, 0x91, 0x9f, 0xcb, 0xca, 0x21, 0x17, 0xd5, 0xe3, 0x53, 0x74, 0x7e, 0x59, 0x1b, 0xda, 0xab, 0xa9, 0x9c, 0xaf, 0x70, 0x54, 0xa4, 0xc8, 0xe6, 0xd2, 0x62, 0xc8, 0x79, 0xf5, 0xf0,
0x7d, 0x45, 0x04, 0xff, 0xb0, 0xad, 0x2d, 0xec, 0x7b, 0xb4, 0xb1, 0x00, 0x9a, 0xa1, 0x56, 0x35, 0x14, 0x9d, 0x5f, 0xd6, 0x46, 0x5f, 0x1e, 0xc1, 0x3f, 0x6c, 0x6b, 0x0b, 0xfb, 0x0e, 0x6d, 0x4c,
0x2a, 0x5c, 0x98, 0x5c, 0x1e, 0xf9, 0x38, 0x8a, 0xec, 0xf6, 0x42, 0xf5, 0xff, 0x58, 0xf0, 0xc2, 0xc0, 0xc9, 0x54, 0xab, 0x1a, 0xe6, 0x2e, 0x4c, 0x2e, 0x0f, 0x7c, 0x1c, 0x79, 0x76, 0x7b, 0xa1,
0x2c, 0xfa, 0x48, 0x14, 0x44, 0xc8, 0x73, 0xcc, 0x31, 0xca, 0xbb, 0x78, 0x8a, 0xec, 0x02, 0xea, 0x7a, 0x7f, 0x2c, 0x78, 0x66, 0x16, 0x7d, 0x24, 0x12, 0x01, 0xf2, 0x0c, 0x73, 0x84, 0x6a, 0x19,
0x5b, 0x1f, 0x21, 0x3b, 0x2f, 0x38, 0x77, 0x2f, 0x00, 0xc7, 0xde, 0x3f, 0x20, 0xc1, 0xbe, 0x42, 0x4e, 0x90, 0x9d, 0x43, 0x7d, 0xeb, 0x23, 0x64, 0x67, 0x39, 0xe7, 0xee, 0x35, 0xe0, 0xd8, 0xfb,
0x73, 0x9f, 0x42, 0xd6, 0xfa, 0xaf, 0xfc, 0xa5, 0xf3, 0xf2, 0x01, 0x7b, 0x17, 0x8d, 0xef, 0xa7, 0x0f, 0x48, 0xb2, 0x2f, 0x70, 0xb2, 0x4f, 0x21, 0x6b, 0xfe, 0x57, 0xfe, 0xc2, 0x79, 0x7e, 0x8f,
0xae, 0xb9, 0xc2, 0x3e, 0x88, 0x1b, 0x2d, 0xfb, 0xe6, 0x48, 0xdf, 0x50, 0xef, 0xff, 0x06, 0x00, 0xbd, 0xf3, 0xc6, 0xb7, 0x63, 0xd7, 0x5c, 0x64, 0xef, 0xe5, 0xb5, 0x96, 0x7d, 0x7d, 0xa0, 0xef,
0x00, 0xff, 0xff, 0x6d, 0x5a, 0x23, 0x8f, 0xe0, 0x04, 0x00, 0x00, 0xa9, 0xb7, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x60, 0xd7, 0x1d, 0xf3, 0xe6, 0x04, 0x00, 0x00,
} }

@ -5,7 +5,7 @@ package relay;
message OnlinePushMsgReq { message OnlinePushMsgReq {
string OperationID = 1; string OperationID = 1;
open_im_sdk.MsgData msgData = 2; server_api_params.MsgData msgData = 2;
} }
message OnlinePushMsgResp{ message OnlinePushMsgResp{
repeated SingleMsgToUser resp = 1; repeated SingleMsgToUser resp = 1;

File diff suppressed because it is too large Load Diff

@ -1,5 +1,5 @@
syntax = "proto3"; syntax = "proto3";
package open_im_sdk;//The package name to which the proto file belongs package server_api_params;//The package name to which the proto file belongs
//option go_package = "./sdk_ws;open_im_sdk";//The generated go pb file is in the current directory, and the package name is open_im_sdk //option go_package = "./sdk_ws;open_im_sdk";//The generated go pb file is in the current directory, and the package name is open_im_sdk
////////////////////////////////base/////////////////////////////// ////////////////////////////////base///////////////////////////////
@ -75,8 +75,8 @@ message BlackInfo{
} }
message GroupRequest{ message GroupRequest{
string userID = 1; PublicUserInfo userInfo = 1;
string groupID = 2; GroupInfo groupInfo = 2;
string handleResult = 3; string handleResult = 3;
string reqMsg = 4; string reqMsg = 4;
string handleMsg = 5; string handleMsg = 5;
@ -88,14 +88,20 @@ message GroupRequest{
message FriendRequest{ message FriendRequest{
string fromUserID = 1; string fromUserID = 1;
string toUserID = 2; string fromNickname = 2;
int32 handleResult = 3; string fromFaceURL = 3;
string reqMsg = 4; int32 fromGender = 4;
uint32 createTime = 5; string toUserID = 5;
string handlerUserID = 6; string toNickname = 6;
string handleMsg = 7; string toFaceURL = 7;
uint32 handleTime = 8; int32 toGender = 8;
string ex = 9; int32 handleResult = 9;
string reqMsg = 10;
uint32 createTime = 11;
string handlerUserID = 12;
string handleMsg = 13;
uint32 handleTime = 14;
string ex = 15;
} }
///////////////////////////////////base end///////////////////////////////////// ///////////////////////////////////base end/////////////////////////////////////
@ -217,68 +223,96 @@ message TipsComm{
} }
//////////////////////group///////////////////// //////////////////////group/////////////////////
//Actively join the group
message MemberEnterTips{
// OnGroupCreated()
message GroupCreatedTips{
GroupInfo group = 1; GroupInfo group = 1;
GroupMemberFullInfo entrantUser = 2; GroupMemberFullInfo opUser = 2;
int64 operationTime = 3; repeated GroupMemberFullInfo memberList = 3;
int64 operationTime = 4;
GroupMemberFullInfo groupOwnerUser = 5;
}
// OnGroupInfoSet()
message GroupInfoSetTips{
GroupMemberFullInfo opUser = 1; //who do this
int64 muteTime = 2;
GroupInfo group = 3;
} }
// OnJoinGroupApplication()
message JoinGroupApplicationTips{
GroupInfo group = 1;
PublicUserInfo applicant = 2;
string reqMsg = 3;
}
// OnQuitGroup()
//Actively leave the group //Actively leave the group
message MemberLeaveTips{ message MemberQuitTips{
GroupInfo group = 1; GroupInfo group = 1;
GroupMemberFullInfo leaverUser = 2; GroupMemberFullInfo quitUser = 2;
int64 operationTime = 3; int64 operationTime = 3;
} }
message MemberInvitedTips{
// OnApplicationGroupAccepted()
message GroupApplicationAcceptedTips{
GroupInfo group = 1; GroupInfo group = 1;
GroupMemberFullInfo opUser = 2; GroupMemberFullInfo opUser = 2;
repeated GroupMemberFullInfo invitedUserList = 3; string handleMsg = 4;
int64 operationTime = 4;
} }
message MemberKickedTips{ // OnApplicationGroupRejected()
message GroupApplicationRejectedTips{
GroupInfo group = 1; GroupInfo group = 1;
GroupMemberFullInfo opUser = 2; GroupMemberFullInfo opUser = 2;
repeated GroupMemberFullInfo kickedUserList = 3; string handleMsg = 4;
int64 operationTime = 4;
} }
message MemberInfoChangedTips{ // OnTransferGroupOwner()
int32 changeType = 1; ///bitwise operators 0001:member info changed; 0010:mute ; message GroupOwnerTransferredTips{
GroupMemberFullInfo opUser = 2; //who do this
GroupMemberFullInfo finalInfo = 3; //
int64 muteTime = 4;
GroupInfo group = 5;
}
message GroupCreatedTips{
GroupInfo group = 1; GroupInfo group = 1;
GroupMemberFullInfo creator = 2; GroupMemberFullInfo opUser = 2;
repeated GroupMemberFullInfo memberList = 3; GroupMemberFullInfo newGroupOwner = 3;
int64 operationTime = 4; int64 operationTime = 4;
} }
message GroupInfoChangedTips{
int32 changedType = 1; //bitwise operators: 0001:groupName; 0010:Notification 0100:Introduction; 1000:FaceUrl
GroupInfo group = 2;
GroupMemberFullInfo opUser = 3;
}
message JoinGroupApplicationTips{ // OnMemberKicked()
message MemberKickedTips{
GroupInfo group = 1; GroupInfo group = 1;
PublicUserInfo applicant = 2; GroupMemberFullInfo opUser = 2;
string reason = 3; repeated GroupMemberFullInfo kickedUserList = 3;
int64 operationTime = 4;
} }
message ApplicationProcessedTips{ // OnMemberInvited()
message MemberInvitedTips{
GroupInfo group = 1; GroupInfo group = 1;
GroupMemberFullInfo opUser = 2; GroupMemberFullInfo opUser = 2;
int32 result = 3; repeated GroupMemberFullInfo invitedUserList = 3;
string reason = 4; int64 operationTime = 4;
} }
//Actively join the group
message MemberEnterTips{
GroupInfo group = 1;
GroupMemberFullInfo entrantUser = 2;
int64 operationTime = 3;
}
//////////////////////friend///////////////////// //////////////////////friend/////////////////////
//message FriendInfo{ //message FriendInfo{
// UserInfo OwnerUser = 1; // UserInfo OwnerUser = 1;
@ -299,15 +333,23 @@ message FromToUserID{
} }
//FromUserID apply to add ToUserID //FromUserID apply to add ToUserID
message FriendApplicationAddedTips{ message FriendApplicationTips{
FromToUserID fromToUserID = 1;
}
//FromUserID accept or reject ToUserID
message FriendApplicationApprovedTips{
FromToUserID fromToUserID = 1; FromToUserID fromToUserID = 1;
string handleMsg = 2;
} }
//FromUserID accept or reject ToUserID //FromUserID accept or reject ToUserID
message FriendApplicationProcessedTips{ message FriendApplicationRejectedTips{
FromToUserID fromToUserID = 1; FromToUserID fromToUserID = 1;
string handleMsg = 2;
} }
// FromUserID Added a friend ToUserID // FromUserID Added a friend ToUserID
message FriendAddedTips{ message FriendAddedTips{
FriendInfo friend = 1; FriendInfo friend = 1;
@ -335,6 +377,6 @@ message FriendInfoChangedTips{
FromToUserID fromToUserID = 1; FromToUserID fromToUserID = 1;
} }
//////////////////////user///////////////////// //////////////////////user/////////////////////
message SelfInfoUpdatedTips{ message UserInfoUpdatedTips{
string userID = 1; string userID = 1;
} }

@ -36,7 +36,7 @@ func (m *CommonResp) Reset() { *m = CommonResp{} }
func (m *CommonResp) String() string { return proto.CompactTextString(m) } func (m *CommonResp) String() string { return proto.CompactTextString(m) }
func (*CommonResp) ProtoMessage() {} func (*CommonResp) ProtoMessage() {}
func (*CommonResp) Descriptor() ([]byte, []int) { func (*CommonResp) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{0} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{0}
} }
func (m *CommonResp) XXX_Unmarshal(b []byte) error { func (m *CommonResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CommonResp.Unmarshal(m, b) return xxx_messageInfo_CommonResp.Unmarshal(m, b)
@ -83,7 +83,7 @@ func (m *DeleteUsersReq) Reset() { *m = DeleteUsersReq{} }
func (m *DeleteUsersReq) String() string { return proto.CompactTextString(m) } func (m *DeleteUsersReq) String() string { return proto.CompactTextString(m) }
func (*DeleteUsersReq) ProtoMessage() {} func (*DeleteUsersReq) ProtoMessage() {}
func (*DeleteUsersReq) Descriptor() ([]byte, []int) { func (*DeleteUsersReq) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{1} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{1}
} }
func (m *DeleteUsersReq) XXX_Unmarshal(b []byte) error { func (m *DeleteUsersReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteUsersReq.Unmarshal(m, b) return xxx_messageInfo_DeleteUsersReq.Unmarshal(m, b)
@ -136,7 +136,7 @@ func (m *DeleteUsersResp) Reset() { *m = DeleteUsersResp{} }
func (m *DeleteUsersResp) String() string { return proto.CompactTextString(m) } func (m *DeleteUsersResp) String() string { return proto.CompactTextString(m) }
func (*DeleteUsersResp) ProtoMessage() {} func (*DeleteUsersResp) ProtoMessage() {}
func (*DeleteUsersResp) Descriptor() ([]byte, []int) { func (*DeleteUsersResp) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{2} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{2}
} }
func (m *DeleteUsersResp) XXX_Unmarshal(b []byte) error { func (m *DeleteUsersResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteUsersResp.Unmarshal(m, b) return xxx_messageInfo_DeleteUsersResp.Unmarshal(m, b)
@ -182,7 +182,7 @@ func (m *GetAllUserIDReq) Reset() { *m = GetAllUserIDReq{} }
func (m *GetAllUserIDReq) String() string { return proto.CompactTextString(m) } func (m *GetAllUserIDReq) String() string { return proto.CompactTextString(m) }
func (*GetAllUserIDReq) ProtoMessage() {} func (*GetAllUserIDReq) ProtoMessage() {}
func (*GetAllUserIDReq) Descriptor() ([]byte, []int) { func (*GetAllUserIDReq) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{3} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{3}
} }
func (m *GetAllUserIDReq) XXX_Unmarshal(b []byte) error { func (m *GetAllUserIDReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetAllUserIDReq.Unmarshal(m, b) return xxx_messageInfo_GetAllUserIDReq.Unmarshal(m, b)
@ -228,7 +228,7 @@ func (m *GetAllUserIDResp) Reset() { *m = GetAllUserIDResp{} }
func (m *GetAllUserIDResp) String() string { return proto.CompactTextString(m) } func (m *GetAllUserIDResp) String() string { return proto.CompactTextString(m) }
func (*GetAllUserIDResp) ProtoMessage() {} func (*GetAllUserIDResp) ProtoMessage() {}
func (*GetAllUserIDResp) Descriptor() ([]byte, []int) { func (*GetAllUserIDResp) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{4} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{4}
} }
func (m *GetAllUserIDResp) XXX_Unmarshal(b []byte) error { func (m *GetAllUserIDResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetAllUserIDResp.Unmarshal(m, b) return xxx_messageInfo_GetAllUserIDResp.Unmarshal(m, b)
@ -275,7 +275,7 @@ func (m *AccountCheckReq) Reset() { *m = AccountCheckReq{} }
func (m *AccountCheckReq) String() string { return proto.CompactTextString(m) } func (m *AccountCheckReq) String() string { return proto.CompactTextString(m) }
func (*AccountCheckReq) ProtoMessage() {} func (*AccountCheckReq) ProtoMessage() {}
func (*AccountCheckReq) Descriptor() ([]byte, []int) { func (*AccountCheckReq) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{5} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{5}
} }
func (m *AccountCheckReq) XXX_Unmarshal(b []byte) error { func (m *AccountCheckReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AccountCheckReq.Unmarshal(m, b) return xxx_messageInfo_AccountCheckReq.Unmarshal(m, b)
@ -328,7 +328,7 @@ func (m *AccountCheckResp) Reset() { *m = AccountCheckResp{} }
func (m *AccountCheckResp) String() string { return proto.CompactTextString(m) } func (m *AccountCheckResp) String() string { return proto.CompactTextString(m) }
func (*AccountCheckResp) ProtoMessage() {} func (*AccountCheckResp) ProtoMessage() {}
func (*AccountCheckResp) Descriptor() ([]byte, []int) { func (*AccountCheckResp) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{6} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{6}
} }
func (m *AccountCheckResp) XXX_Unmarshal(b []byte) error { func (m *AccountCheckResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AccountCheckResp.Unmarshal(m, b) return xxx_messageInfo_AccountCheckResp.Unmarshal(m, b)
@ -374,7 +374,7 @@ func (m *AccountCheckResp_SingleUserStatus) Reset() { *m = AccountCheckR
func (m *AccountCheckResp_SingleUserStatus) String() string { return proto.CompactTextString(m) } func (m *AccountCheckResp_SingleUserStatus) String() string { return proto.CompactTextString(m) }
func (*AccountCheckResp_SingleUserStatus) ProtoMessage() {} func (*AccountCheckResp_SingleUserStatus) ProtoMessage() {}
func (*AccountCheckResp_SingleUserStatus) Descriptor() ([]byte, []int) { func (*AccountCheckResp_SingleUserStatus) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{6, 0} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{6, 0}
} }
func (m *AccountCheckResp_SingleUserStatus) XXX_Unmarshal(b []byte) error { func (m *AccountCheckResp_SingleUserStatus) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AccountCheckResp_SingleUserStatus.Unmarshal(m, b) return xxx_messageInfo_AccountCheckResp_SingleUserStatus.Unmarshal(m, b)
@ -421,7 +421,7 @@ func (m *GetUserInfoReq) Reset() { *m = GetUserInfoReq{} }
func (m *GetUserInfoReq) String() string { return proto.CompactTextString(m) } func (m *GetUserInfoReq) String() string { return proto.CompactTextString(m) }
func (*GetUserInfoReq) ProtoMessage() {} func (*GetUserInfoReq) ProtoMessage() {}
func (*GetUserInfoReq) Descriptor() ([]byte, []int) { func (*GetUserInfoReq) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{7} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{7}
} }
func (m *GetUserInfoReq) XXX_Unmarshal(b []byte) error { func (m *GetUserInfoReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUserInfoReq.Unmarshal(m, b) return xxx_messageInfo_GetUserInfoReq.Unmarshal(m, b)
@ -474,7 +474,7 @@ func (m *GetUserInfoResp) Reset() { *m = GetUserInfoResp{} }
func (m *GetUserInfoResp) String() string { return proto.CompactTextString(m) } func (m *GetUserInfoResp) String() string { return proto.CompactTextString(m) }
func (*GetUserInfoResp) ProtoMessage() {} func (*GetUserInfoResp) ProtoMessage() {}
func (*GetUserInfoResp) Descriptor() ([]byte, []int) { func (*GetUserInfoResp) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{8} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{8}
} }
func (m *GetUserInfoResp) XXX_Unmarshal(b []byte) error { func (m *GetUserInfoResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUserInfoResp.Unmarshal(m, b) return xxx_messageInfo_GetUserInfoResp.Unmarshal(m, b)
@ -521,7 +521,7 @@ func (m *UpdateUserInfoReq) Reset() { *m = UpdateUserInfoReq{} }
func (m *UpdateUserInfoReq) String() string { return proto.CompactTextString(m) } func (m *UpdateUserInfoReq) String() string { return proto.CompactTextString(m) }
func (*UpdateUserInfoReq) ProtoMessage() {} func (*UpdateUserInfoReq) ProtoMessage() {}
func (*UpdateUserInfoReq) Descriptor() ([]byte, []int) { func (*UpdateUserInfoReq) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{9} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{9}
} }
func (m *UpdateUserInfoReq) XXX_Unmarshal(b []byte) error { func (m *UpdateUserInfoReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateUserInfoReq.Unmarshal(m, b) return xxx_messageInfo_UpdateUserInfoReq.Unmarshal(m, b)
@ -573,7 +573,7 @@ func (m *UpdateUserInfoResp) Reset() { *m = UpdateUserInfoResp{} }
func (m *UpdateUserInfoResp) String() string { return proto.CompactTextString(m) } func (m *UpdateUserInfoResp) String() string { return proto.CompactTextString(m) }
func (*UpdateUserInfoResp) ProtoMessage() {} func (*UpdateUserInfoResp) ProtoMessage() {}
func (*UpdateUserInfoResp) Descriptor() ([]byte, []int) { func (*UpdateUserInfoResp) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{10} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{10}
} }
func (m *UpdateUserInfoResp) XXX_Unmarshal(b []byte) error { func (m *UpdateUserInfoResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateUserInfoResp.Unmarshal(m, b) return xxx_messageInfo_UpdateUserInfoResp.Unmarshal(m, b)
@ -615,7 +615,7 @@ func (m *SetReceiveMessageOptReq) Reset() { *m = SetReceiveMessageOptReq
func (m *SetReceiveMessageOptReq) String() string { return proto.CompactTextString(m) } func (m *SetReceiveMessageOptReq) String() string { return proto.CompactTextString(m) }
func (*SetReceiveMessageOptReq) ProtoMessage() {} func (*SetReceiveMessageOptReq) ProtoMessage() {}
func (*SetReceiveMessageOptReq) Descriptor() ([]byte, []int) { func (*SetReceiveMessageOptReq) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{11} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{11}
} }
func (m *SetReceiveMessageOptReq) XXX_Unmarshal(b []byte) error { func (m *SetReceiveMessageOptReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetReceiveMessageOptReq.Unmarshal(m, b) return xxx_messageInfo_SetReceiveMessageOptReq.Unmarshal(m, b)
@ -682,7 +682,7 @@ func (m *OptResult) Reset() { *m = OptResult{} }
func (m *OptResult) String() string { return proto.CompactTextString(m) } func (m *OptResult) String() string { return proto.CompactTextString(m) }
func (*OptResult) ProtoMessage() {} func (*OptResult) ProtoMessage() {}
func (*OptResult) Descriptor() ([]byte, []int) { func (*OptResult) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{12} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{12}
} }
func (m *OptResult) XXX_Unmarshal(b []byte) error { func (m *OptResult) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OptResult.Unmarshal(m, b) return xxx_messageInfo_OptResult.Unmarshal(m, b)
@ -728,7 +728,7 @@ func (m *SetReceiveMessageOptResp) Reset() { *m = SetReceiveMessageOptRe
func (m *SetReceiveMessageOptResp) String() string { return proto.CompactTextString(m) } func (m *SetReceiveMessageOptResp) String() string { return proto.CompactTextString(m) }
func (*SetReceiveMessageOptResp) ProtoMessage() {} func (*SetReceiveMessageOptResp) ProtoMessage() {}
func (*SetReceiveMessageOptResp) Descriptor() ([]byte, []int) { func (*SetReceiveMessageOptResp) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{13} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{13}
} }
func (m *SetReceiveMessageOptResp) XXX_Unmarshal(b []byte) error { func (m *SetReceiveMessageOptResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetReceiveMessageOptResp.Unmarshal(m, b) return xxx_messageInfo_SetReceiveMessageOptResp.Unmarshal(m, b)
@ -776,7 +776,7 @@ func (m *GetReceiveMessageOptReq) Reset() { *m = GetReceiveMessageOptReq
func (m *GetReceiveMessageOptReq) String() string { return proto.CompactTextString(m) } func (m *GetReceiveMessageOptReq) String() string { return proto.CompactTextString(m) }
func (*GetReceiveMessageOptReq) ProtoMessage() {} func (*GetReceiveMessageOptReq) ProtoMessage() {}
func (*GetReceiveMessageOptReq) Descriptor() ([]byte, []int) { func (*GetReceiveMessageOptReq) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{14} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{14}
} }
func (m *GetReceiveMessageOptReq) XXX_Unmarshal(b []byte) error { func (m *GetReceiveMessageOptReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetReceiveMessageOptReq.Unmarshal(m, b) return xxx_messageInfo_GetReceiveMessageOptReq.Unmarshal(m, b)
@ -836,7 +836,7 @@ func (m *GetReceiveMessageOptResp) Reset() { *m = GetReceiveMessageOptRe
func (m *GetReceiveMessageOptResp) String() string { return proto.CompactTextString(m) } func (m *GetReceiveMessageOptResp) String() string { return proto.CompactTextString(m) }
func (*GetReceiveMessageOptResp) ProtoMessage() {} func (*GetReceiveMessageOptResp) ProtoMessage() {}
func (*GetReceiveMessageOptResp) Descriptor() ([]byte, []int) { func (*GetReceiveMessageOptResp) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{15} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{15}
} }
func (m *GetReceiveMessageOptResp) XXX_Unmarshal(b []byte) error { func (m *GetReceiveMessageOptResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetReceiveMessageOptResp.Unmarshal(m, b) return xxx_messageInfo_GetReceiveMessageOptResp.Unmarshal(m, b)
@ -883,7 +883,7 @@ func (m *GetAllConversationMsgOptReq) Reset() { *m = GetAllConversationM
func (m *GetAllConversationMsgOptReq) String() string { return proto.CompactTextString(m) } func (m *GetAllConversationMsgOptReq) String() string { return proto.CompactTextString(m) }
func (*GetAllConversationMsgOptReq) ProtoMessage() {} func (*GetAllConversationMsgOptReq) ProtoMessage() {}
func (*GetAllConversationMsgOptReq) Descriptor() ([]byte, []int) { func (*GetAllConversationMsgOptReq) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{16} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{16}
} }
func (m *GetAllConversationMsgOptReq) XXX_Unmarshal(b []byte) error { func (m *GetAllConversationMsgOptReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetAllConversationMsgOptReq.Unmarshal(m, b) return xxx_messageInfo_GetAllConversationMsgOptReq.Unmarshal(m, b)
@ -936,7 +936,7 @@ func (m *GetAllConversationMsgOptResp) Reset() { *m = GetAllConversation
func (m *GetAllConversationMsgOptResp) String() string { return proto.CompactTextString(m) } func (m *GetAllConversationMsgOptResp) String() string { return proto.CompactTextString(m) }
func (*GetAllConversationMsgOptResp) ProtoMessage() {} func (*GetAllConversationMsgOptResp) ProtoMessage() {}
func (*GetAllConversationMsgOptResp) Descriptor() ([]byte, []int) { func (*GetAllConversationMsgOptResp) Descriptor() ([]byte, []int) {
return fileDescriptor_user_9cc4371b0c883611, []int{17} return fileDescriptor_user_9cd4aaf870b6d3b5, []int{17}
} }
func (m *GetAllConversationMsgOptResp) XXX_Unmarshal(b []byte) error { func (m *GetAllConversationMsgOptResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetAllConversationMsgOptResp.Unmarshal(m, b) return xxx_messageInfo_GetAllConversationMsgOptResp.Unmarshal(m, b)
@ -1295,59 +1295,60 @@ var _User_serviceDesc = grpc.ServiceDesc{
Metadata: "user/user.proto", Metadata: "user/user.proto",
} }
func init() { proto.RegisterFile("user/user.proto", fileDescriptor_user_9cc4371b0c883611) } func init() { proto.RegisterFile("user/user.proto", fileDescriptor_user_9cd4aaf870b6d3b5) }
var fileDescriptor_user_9cc4371b0c883611 = []byte{ var fileDescriptor_user_9cd4aaf870b6d3b5 = []byte{
// 812 bytes of a gzipped FileDescriptorProto // 819 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcd, 0x6e, 0xd3, 0x4a, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcd, 0x6e, 0x13, 0x3b,
0x14, 0x96, 0xe3, 0xb4, 0xb7, 0x39, 0x69, 0x13, 0xdf, 0x51, 0x7f, 0x7c, 0x7d, 0xa1, 0x4a, 0x47, 0x14, 0xd6, 0x24, 0x69, 0x6f, 0x73, 0xd2, 0x26, 0xb9, 0x56, 0x6f, 0x3b, 0x77, 0x0a, 0x55, 0x6a,
0x08, 0xa2, 0x2e, 0x1c, 0x28, 0x2b, 0x40, 0x20, 0x95, 0x54, 0xb5, 0x2a, 0x88, 0x82, 0x5c, 0x75, 0x21, 0x88, 0xba, 0x48, 0x50, 0x59, 0x20, 0x81, 0x00, 0x95, 0x54, 0x8d, 0x2a, 0x88, 0x82, 0xa6,
0xc3, 0xa6, 0x32, 0xc9, 0x10, 0xa2, 0x24, 0x1e, 0xe3, 0x71, 0x5a, 0x01, 0x12, 0x2b, 0xde, 0x82, 0xea, 0x86, 0x4d, 0x34, 0x24, 0x26, 0x44, 0x4d, 0xc6, 0xc6, 0x9e, 0xb4, 0x02, 0xb6, 0xac, 0x78,
0x05, 0x4b, 0x9e, 0x81, 0xd7, 0xe0, 0x05, 0x78, 0x15, 0xe4, 0x19, 0xdb, 0x19, 0xff, 0x24, 0x2d, 0x05, 0x16, 0x2c, 0x79, 0x06, 0x5e, 0x83, 0x17, 0xe0, 0x55, 0xd0, 0xd8, 0x33, 0x89, 0xe7, 0x27,
0x41, 0x42, 0x6c, 0x2c, 0xcf, 0x99, 0x33, 0x67, 0xbe, 0xef, 0x3b, 0x67, 0x66, 0x0e, 0xd4, 0xa7, 0xd3, 0x12, 0x24, 0xc4, 0x66, 0x34, 0x3e, 0x3e, 0x3e, 0xfe, 0xbe, 0xef, 0x1c, 0xdb, 0x07, 0x2a,
0x8c, 0xf8, 0xad, 0xf0, 0x63, 0x7a, 0x3e, 0x0d, 0x28, 0x2a, 0x87, 0xff, 0xc6, 0x5e, 0xd7, 0x23, 0x53, 0x41, 0x78, 0xd3, 0xff, 0x34, 0x18, 0xa7, 0x1e, 0x45, 0x05, 0xff, 0xdf, 0xda, 0xeb, 0x32,
0xee, 0xf9, 0x49, 0xa7, 0xe5, 0x8d, 0x06, 0x2d, 0x3e, 0xd1, 0x62, 0xfd, 0xd1, 0xf9, 0x25, 0x6b, 0xe2, 0xf6, 0x4e, 0x3a, 0x4d, 0x76, 0x3e, 0x6c, 0xca, 0x89, 0xa6, 0x18, 0x9c, 0xf7, 0x2e, 0x45,
0x5d, 0x32, 0xe1, 0x88, 0x9f, 0x00, 0xb4, 0xe9, 0x64, 0x42, 0x5d, 0x9b, 0x30, 0x0f, 0xe9, 0xf0, 0xf3, 0x52, 0x28, 0x47, 0xfc, 0x18, 0xa0, 0x45, 0x27, 0x13, 0xea, 0xda, 0x44, 0x30, 0x64, 0xc2,
0x0f, 0xf1, 0xfd, 0x36, 0xed, 0x13, 0x5d, 0x69, 0x28, 0xcd, 0x15, 0x3b, 0x1e, 0xa2, 0x6d, 0x58, 0x3f, 0x84, 0xf3, 0x16, 0x1d, 0x10, 0xd3, 0xa8, 0x19, 0xf5, 0x15, 0x3b, 0x1c, 0xa2, 0x2d, 0x58,
0x25, 0xbe, 0xdf, 0x61, 0x03, 0xbd, 0xd4, 0x50, 0x9a, 0x15, 0x3b, 0x1a, 0xe1, 0xf7, 0x50, 0x3b, 0x25, 0x9c, 0x77, 0xc4, 0xd0, 0xcc, 0xd5, 0x8c, 0x7a, 0xd1, 0x0e, 0x46, 0xf8, 0x3d, 0x94, 0x8f,
0x22, 0x63, 0x12, 0x90, 0x33, 0x46, 0x7c, 0x66, 0x93, 0xb7, 0x68, 0x1f, 0xb4, 0x99, 0xe5, 0xe4, 0xc8, 0x98, 0x78, 0xe4, 0x4c, 0x10, 0x2e, 0x6c, 0xf2, 0x16, 0xed, 0x43, 0x75, 0x6e, 0x39, 0x39,
0xe8, 0xf9, 0x90, 0x05, 0x7a, 0xa9, 0xa1, 0x36, 0x2b, 0x76, 0xce, 0x8e, 0x0c, 0x58, 0xeb, 0x7a, 0x7a, 0x3e, 0x12, 0x9e, 0x99, 0xab, 0xe5, 0xeb, 0x45, 0x3b, 0x61, 0x47, 0x16, 0xac, 0x75, 0x99,
0x62, 0xac, 0xab, 0x3c, 0x6e, 0x32, 0x46, 0x0d, 0xa8, 0x76, 0x3d, 0xe2, 0x3b, 0xc1, 0x90, 0xba, 0x1a, 0x9b, 0x79, 0x19, 0x77, 0x36, 0x46, 0x35, 0x28, 0x75, 0x19, 0xe1, 0x8e, 0x37, 0xa2, 0xee,
0x27, 0x47, 0x7a, 0x99, 0x4f, 0xcb, 0x26, 0x4c, 0xa1, 0x9e, 0xda, 0x9b, 0x79, 0xe8, 0xae, 0x4c, 0xc9, 0x91, 0x59, 0x90, 0xd3, 0xba, 0x09, 0x53, 0xa8, 0x44, 0xf6, 0x16, 0x0c, 0xdd, 0xd5, 0xe9,
0x87, 0x73, 0xa8, 0x1e, 0x68, 0x26, 0x17, 0x66, 0x66, 0xb7, 0x65, 0xca, 0xfb, 0xa0, 0x1d, 0x3b, 0x48, 0x0e, 0xa5, 0x83, 0x6a, 0x43, 0x0a, 0x33, 0xb7, 0xdb, 0x3a, 0xe5, 0x7d, 0xa8, 0x1e, 0x3b,
0xc3, 0x31, 0xe9, 0xe7, 0xe1, 0x66, 0xed, 0xb8, 0x0b, 0x75, 0x8b, 0x04, 0x87, 0xe3, 0xb1, 0xb0, 0xa3, 0x31, 0x19, 0x24, 0xe1, 0xc6, 0xed, 0xb8, 0x0b, 0x95, 0x36, 0xf1, 0x0e, 0xc7, 0x63, 0x65,
0x85, 0x6c, 0x0d, 0x58, 0xa3, 0x31, 0x03, 0x45, 0x30, 0xa0, 0x12, 0x03, 0x2a, 0x31, 0x10, 0xc2, 0xf3, 0xd9, 0x5a, 0xb0, 0x46, 0x43, 0x06, 0x86, 0x62, 0x40, 0x35, 0x06, 0x54, 0x63, 0xa0, 0x84,
0xc9, 0x26, 0xdc, 0x07, 0x2d, 0x1d, 0x70, 0x29, 0x0a, 0xbb, 0x00, 0x39, 0xf0, 0x92, 0x05, 0xbf, 0xd3, 0x4d, 0x78, 0x00, 0xd5, 0x68, 0xc0, 0xa5, 0x28, 0xec, 0x02, 0x24, 0xc0, 0x6b, 0x16, 0xfc,
0x83, 0xfa, 0x61, 0xaf, 0x47, 0xa7, 0x6e, 0xd0, 0x7e, 0x43, 0x7a, 0xa3, 0x10, 0x76, 0x13, 0xea, 0x0e, 0x2a, 0x87, 0xfd, 0x3e, 0x9d, 0xba, 0x5e, 0xeb, 0x0d, 0xe9, 0x9f, 0xfb, 0xb0, 0xeb, 0x50,
0xfc, 0x5f, 0x5a, 0xa7, 0xf0, 0x75, 0x59, 0x73, 0x2a, 0x45, 0xa5, 0xc5, 0x29, 0x52, 0xf3, 0x29, 0x91, 0xff, 0xda, 0x3a, 0x43, 0xae, 0x8b, 0x9b, 0x23, 0x29, 0xca, 0x65, 0xa7, 0x28, 0x9f, 0x4c,
0xfa, 0xa1, 0x80, 0x96, 0xde, 0x5b, 0x30, 0xec, 0x5d, 0x83, 0xe1, 0xcc, 0x07, 0x59, 0x00, 0x36, 0xd1, 0x0f, 0x03, 0xaa, 0xd1, 0xbd, 0x15, 0xc3, 0xfe, 0x35, 0x18, 0xce, 0x7d, 0x50, 0x1b, 0xc0,
0x61, 0xd3, 0x71, 0x90, 0x30, 0xac, 0x1e, 0xdc, 0x11, 0x2b, 0xb2, 0xd1, 0xcd, 0xd3, 0xa1, 0x3b, 0x26, 0x62, 0x3a, 0xf6, 0x66, 0x0c, 0x4b, 0x07, 0x77, 0xd4, 0x8a, 0x78, 0xf4, 0xc6, 0xe9, 0xc8,
0x18, 0xf3, 0x92, 0x38, 0x0d, 0x9c, 0x60, 0xca, 0x6c, 0x69, 0xa9, 0xf1, 0x02, 0xb4, 0xec, 0x7c, 0x1d, 0x8e, 0x65, 0x49, 0x9c, 0x7a, 0x8e, 0x37, 0x15, 0xb6, 0xb6, 0xd4, 0x7a, 0x01, 0xd5, 0xf8,
0x58, 0xda, 0x53, 0x39, 0x81, 0xd1, 0x08, 0xdd, 0x82, 0x0d, 0x47, 0x04, 0x17, 0x8e, 0x11, 0xfd, 0xbc, 0x5f, 0xda, 0x53, 0x3d, 0x81, 0xc1, 0x08, 0xdd, 0x82, 0x0d, 0x47, 0x05, 0x57, 0x8e, 0x01,
0xb4, 0x11, 0xbb, 0x50, 0xb3, 0x48, 0xc0, 0x05, 0x71, 0x5f, 0xd3, 0x50, 0xdb, 0x5d, 0x80, 0x69, 0xfd, 0xa8, 0x11, 0xbb, 0x50, 0x6e, 0x13, 0x4f, 0x0a, 0xe2, 0xbe, 0xa6, 0xbe, 0xb6, 0xbb, 0x00,
0x56, 0x56, 0xc9, 0xf2, 0x9b, 0x8a, 0x7e, 0xe4, 0x35, 0x38, 0xdb, 0x6f, 0x29, 0x3d, 0x1f, 0xc0, 0xd3, 0xb8, 0xac, 0x9a, 0xe5, 0x37, 0x15, 0xfd, 0x68, 0xc8, 0x22, 0x9c, 0x6f, 0xb8, 0x94, 0xa0,
0x7a, 0x1c, 0x81, 0x83, 0x54, 0xb9, 0xa2, 0x5b, 0x26, 0x0d, 0xef, 0x8b, 0xe1, 0xe4, 0x9c, 0xf5, 0x4f, 0x60, 0x3d, 0x8c, 0x20, 0x51, 0xe6, 0xa5, 0xa4, 0x3b, 0x0d, 0x41, 0xf8, 0x05, 0xe1, 0x3d,
0x47, 0x66, 0xb2, 0x45, 0xca, 0x15, 0x7f, 0x52, 0xe0, 0xdf, 0x33, 0xaf, 0xef, 0x44, 0xe7, 0x38, 0x87, 0x8d, 0x7a, 0xcc, 0xe1, 0xce, 0x44, 0x34, 0x66, 0x1b, 0x45, 0x16, 0xe0, 0x4f, 0x06, 0xfc,
0xe2, 0x7c, 0x0f, 0xd6, 0xe2, 0x61, 0x04, 0x60, 0x4e, 0xb0, 0xc4, 0xed, 0x2a, 0x19, 0x68, 0x5e, 0x7b, 0xc6, 0x06, 0x4e, 0x70, 0x9c, 0x03, 0xea, 0xf7, 0x61, 0x2d, 0x1c, 0x06, 0x30, 0x32, 0x43,
0x06, 0xf9, 0xe4, 0x1c, 0x03, 0xca, 0xa2, 0x58, 0x46, 0x09, 0xfc, 0x4d, 0x81, 0x9d, 0x53, 0x12, 0xce, 0x9c, 0xaf, 0xd2, 0x84, 0x26, 0x35, 0xd1, 0x8f, 0xd1, 0x31, 0xa0, 0x38, 0x96, 0x65, 0x54,
0xd8, 0xa4, 0x47, 0x86, 0x17, 0xa4, 0x43, 0x18, 0x73, 0x06, 0xa4, 0xeb, 0x05, 0x51, 0x22, 0x8f, 0xc1, 0xdf, 0x0c, 0xd8, 0x3e, 0x25, 0x9e, 0x4d, 0xfa, 0x64, 0x74, 0x41, 0x3a, 0x44, 0x08, 0x67,
0x7d, 0x3a, 0x49, 0x9d, 0x6e, 0xc9, 0x82, 0x34, 0x50, 0xa9, 0x17, 0x70, 0xf0, 0x2b, 0x76, 0xf8, 0x48, 0xba, 0xcc, 0x0b, 0xb2, 0x7a, 0xcc, 0xe9, 0x24, 0x72, 0xd4, 0x35, 0x0b, 0xaa, 0x42, 0x9e,
0x8b, 0x4c, 0x40, 0x3d, 0xea, 0x5e, 0x10, 0x9f, 0x45, 0x38, 0x13, 0x75, 0x2b, 0x76, 0xc1, 0x4c, 0x32, 0x4f, 0x82, 0x5f, 0xb1, 0xfd, 0x5f, 0xd4, 0x00, 0xd4, 0xa7, 0xee, 0x05, 0xe1, 0x22, 0xc0,
0x96, 0x67, 0x39, 0xc7, 0x33, 0xa5, 0xd2, 0x4a, 0x5a, 0x25, 0xfc, 0x0c, 0x2a, 0x1c, 0x69, 0x58, 0x39, 0x53, 0xba, 0x68, 0xa7, 0xcc, 0xc4, 0x79, 0x16, 0x12, 0x3c, 0x23, 0x2a, 0xad, 0x44, 0x55,
0xdd, 0xe8, 0x36, 0xd4, 0xd2, 0x1b, 0x44, 0x80, 0x33, 0xd6, 0xb0, 0xda, 0x7d, 0xbe, 0x22, 0xc2, 0xc2, 0xcf, 0xa0, 0x28, 0x91, 0xfa, 0xa5, 0x8e, 0x6e, 0x43, 0x39, 0xba, 0x41, 0x00, 0x38, 0x66,
0x1d, 0x8d, 0xf0, 0x67, 0x05, 0xf4, 0x62, 0x21, 0x96, 0xaa, 0xb0, 0x0e, 0xfc, 0x27, 0x6f, 0x9c, 0xf5, 0x4b, 0x9f, 0xcb, 0x15, 0x01, 0xee, 0x60, 0x84, 0x3f, 0x1b, 0x60, 0xa6, 0x0b, 0xb1, 0x54,
0xe0, 0x94, 0x0e, 0x70, 0x5d, 0x04, 0x48, 0xa6, 0xec, 0xf9, 0x2b, 0xf0, 0x57, 0x05, 0x76, 0xac, 0xb5, 0x75, 0xe0, 0x7f, 0x7d, 0xe3, 0x19, 0x4e, 0xed, 0x34, 0x57, 0x54, 0x80, 0xd9, 0x94, 0xbd,
0x25, 0xd3, 0x54, 0x9c, 0x94, 0xd2, 0x75, 0x93, 0xa2, 0x2e, 0x4e, 0x4a, 0x39, 0x93, 0x94, 0x50, 0x78, 0x05, 0xfe, 0x6a, 0xc0, 0x76, 0x7b, 0xc9, 0x34, 0xa5, 0x27, 0x25, 0x77, 0xdd, 0xa4, 0xe4,
0x47, 0xeb, 0x0f, 0xe9, 0xa8, 0xfe, 0xb2, 0x8e, 0x1f, 0xe0, 0x7f, 0xf1, 0xe0, 0xb4, 0x25, 0x97, 0xb3, 0x93, 0x52, 0x88, 0x25, 0xc5, 0xd7, 0xb1, 0xfd, 0x87, 0x74, 0xcc, 0xff, 0xb2, 0x8e, 0x1f,
0x0e, 0x1b, 0x5c, 0x53, 0xca, 0x2b, 0x5f, 0xb4, 0x45, 0x2f, 0x3a, 0xfe, 0xa2, 0xc0, 0x8d, 0xf9, 0x60, 0x47, 0xbd, 0x3e, 0x2d, 0xcd, 0xa5, 0x23, 0x86, 0xd7, 0x94, 0xf2, 0xca, 0xe7, 0x2d, 0xeb,
0xbb, 0xff, 0x05, 0xf2, 0x1c, 0x7c, 0x2f, 0x03, 0xef, 0x9c, 0xd0, 0x43, 0xa8, 0x4a, 0xb7, 0x2c, 0x79, 0xc7, 0x5f, 0x0c, 0xb8, 0xb1, 0x78, 0xf7, 0xbf, 0x40, 0x9e, 0x83, 0xef, 0x05, 0x90, 0x6d,
0xda, 0x14, 0x31, 0xd2, 0x17, 0xbd, 0xb1, 0x55, 0x60, 0x65, 0x1e, 0x6a, 0x43, 0x2d, 0x7d, 0x35, 0x14, 0x7a, 0x00, 0x25, 0xed, 0xc6, 0x45, 0x9b, 0x2a, 0x46, 0xf4, 0xd6, 0xb7, 0xfe, 0x4b, 0xb1,
0xa1, 0x1d, 0xe1, 0x98, 0xbb, 0x36, 0x0d, 0xbd, 0x78, 0x82, 0x79, 0x21, 0x00, 0xa9, 0xb7, 0x89, 0x0a, 0x86, 0x5a, 0x50, 0x8e, 0x5e, 0x4d, 0x68, 0x5b, 0x39, 0x26, 0x2e, 0x4f, 0xcb, 0x4c, 0x9f,
0x01, 0xa4, 0x5b, 0xad, 0x18, 0x40, 0xb6, 0x09, 0x7a, 0x0c, 0xeb, 0x72, 0x57, 0x81, 0x66, 0x38, 0x10, 0xcc, 0x07, 0xa0, 0x35, 0x3a, 0x21, 0x80, 0x68, 0xdf, 0x15, 0x02, 0x88, 0x77, 0x44, 0x8f,
0xe5, 0xd6, 0xc5, 0xd8, 0x2e, 0x32, 0x33, 0x0f, 0x9d, 0xc1, 0x66, 0xd1, 0x45, 0x80, 0x6e, 0x0a, 0x60, 0x5d, 0x6f, 0x31, 0xd0, 0x1c, 0xa7, 0xde, 0xc7, 0x58, 0x5b, 0x69, 0x66, 0xc1, 0xd0, 0x19,
0xff, 0x39, 0xb7, 0xa5, 0xb1, 0xbb, 0x68, 0x5a, 0x84, 0xb5, 0x16, 0x84, 0xb5, 0x16, 0x87, 0x9d, 0x6c, 0xa6, 0x5d, 0x04, 0xe8, 0xa6, 0xf2, 0x5f, 0x70, 0x5b, 0x5a, 0xbb, 0x59, 0xd3, 0x2a, 0x6c,
0x7b, 0xa4, 0x1c, 0x7e, 0xdc, 0x0a, 0x6b, 0x0a, 0xed, 0xc9, 0x0c, 0x0b, 0x2b, 0xde, 0xc0, 0x57, 0x3b, 0x23, 0x6c, 0x3b, 0x3b, 0xec, 0xc2, 0x23, 0xe5, 0xc8, 0xe3, 0x96, 0x5a, 0x53, 0x68, 0x4f,
0xb9, 0x08, 0x3d, 0xe5, 0x2e, 0x23, 0xd6, 0x33, 0xd3, 0x53, 0xc5, 0x7a, 0x66, 0x1b, 0x92, 0xa7, 0x67, 0x98, 0x5a, 0xf1, 0x16, 0xbe, 0xca, 0x45, 0xe9, 0xa9, 0xb7, 0x1c, 0xa1, 0x9e, 0xb1, 0x06,
0x1b, 0x2f, 0xab, 0x26, 0xef, 0xcd, 0x1f, 0x85, 0x9f, 0x57, 0xab, 0xbc, 0xf1, 0xbe, 0xff, 0x33, 0x2b, 0xd4, 0x33, 0xde, 0x9d, 0x3c, 0xdd, 0x78, 0x59, 0x6a, 0xc8, 0x46, 0xfd, 0xa1, 0xff, 0x79,
0x00, 0x00, 0xff, 0xff, 0xaa, 0x27, 0xa9, 0x62, 0xb4, 0x0b, 0x00, 0x00, 0xb5, 0x2a, 0xbb, 0xf0, 0x7b, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x95, 0x5e, 0xfc, 0xe6, 0xc1,
0x0b, 0x00, 0x00,
} }

@ -52,13 +52,13 @@ message GetUserInfoReq{
} }
message GetUserInfoResp{ message GetUserInfoResp{
CommonResp commonResp = 1; CommonResp commonResp = 1;
repeated open_im_sdk.UserInfo UserInfoList = 3; repeated server_api_params.UserInfo UserInfoList = 3;
} }
message UpdateUserInfoReq{ message UpdateUserInfoReq{
open_im_sdk.UserInfo UserInfo = 1; server_api_params.UserInfo UserInfo = 1;
string OpUserID = 2; string OpUserID = 2;
string operationID = 3; string operationID = 3;
} }

@ -31,7 +31,6 @@ func Int32ToString(i int32) string {
//judge a string whether in the string list //judge a string whether in the string list
func IsContain(target string, List []string) bool { func IsContain(target string, List []string) bool {
for _, element := range List { for _, element := range List {
if target == element { if target == element {
@ -39,7 +38,6 @@ func IsContain(target string, List []string) bool {
} }
} }
return false return false
} }
func InterfaceArrayToStringArray(data []interface{}) (i []string) { func InterfaceArrayToStringArray(data []interface{}) (i []string) {

@ -5,6 +5,7 @@ import (
"github.com/pkg/errors" "github.com/pkg/errors"
"runtime" "runtime"
"strconv" "strconv"
"strings"
) )
// copy a by b b->a // copy a by b b->a
@ -24,3 +25,15 @@ func printCallerNameAndLine() string {
pc, _, line, _ := runtime.Caller(2) pc, _, line, _ := runtime.Caller(2)
return runtime.FuncForPC(pc).Name() + "()@" + strconv.Itoa(line) + ": " return runtime.FuncForPC(pc).Name() + "()@" + strconv.Itoa(line) + ": "
} }
func GetSelfFuncName() string {
pc, _, _, _ := runtime.Caller(1)
return cleanUpFuncName(runtime.FuncForPC(pc).Name())
}
func cleanUpFuncName(funcName string) string {
end := strings.LastIndex(funcName, ".")
if end == -1 {
return ""
}
return funcName[end+1:]
}

Loading…
Cancel
Save