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

cmd/open_im_api/main.go

@@ -26,25 +26,27 @@ func main() {
 	userRouterGroup := r.Group("/user")
 	{
 		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
 	}
 	//friend routing group
 	friendRouterGroup := r.Group("/friend")
 	{
 		//	friendRouterGroup.POST("/get_friends_info", friend.GetFriendsInfo)
-		friendRouterGroup.POST("/add_friend", friend.AddFriend)                     //1
-		friendRouterGroup.POST("/get_friend_apply_list", friend.GetFriendApplyList) //1
-		friendRouterGroup.POST("/get_self_apply_list", friend.GetSelfApplyList)     //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("/set_friend_remark", friend.SetFriendRemark)        //1
-		friendRouterGroup.POST("/is_friend", friend.IsFriend)                       //1
-		friendRouterGroup.POST("/import_friend", friend.ImportFriend)               //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_self_friend_apply_list", friend.GetSelfFriendApplyList) //1
+		friendRouterGroup.POST("/get_friend_list", friend.GetFriendList)                     //1
+		friendRouterGroup.POST("/add_friend_response", friend.AddFriendResponse)             //1
+		friendRouterGroup.POST("/set_friend_remark", friend.SetFriendRemark)                 //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("/is_friend", friend.IsFriend)         //1
 	}
 	//group related routing group
 	groupRouterGroup := r.Group("/group")

config/config.yaml

@@ -85,9 +85,9 @@ credential:
 rpcport:
   openImUserPort: [ 10100 ]
   openImFriendPort: [ 10200 ]
-  openImOfflineMessagePort: [ 10300]
+  openImOfflineMessagePort: [ 10300 ]
   openImOnlineRelayPort: [ 10400 ]
-  openImGroupPort: [ 10500  ]
+  openImGroupPort: [ 10500 ]
   openImAuthPort: [ 10600 ]
   openImPushPort: [ 10700 ]
   c2c:
@@ -144,8 +144,8 @@ push:
     pushUrl: "https://api.jpush.cn/v3/push"
     pushIntent: "intent:#Intent;component=io.openim.app.enterprisechat/io.openim.app.enterprisechat.MainActivity;end"
 manager:
-  appManagerUid: ["openIM123456","openIM654321"]
-  secrets: ["openIM1","openIM2"]
+  appManagerUid: [ "openIM123456","openIM654321" ]
+  secrets: [ "openIM1","openIM2" ]
 
 secret: tuoyun
 
@@ -176,30 +176,251 @@ iOSPush:
   badgeCount: true
 
 notification:
+
   groupCreated:
     conversation:
-      conversationChanged: true
+      reliabilityLevel: 1
       unreadCount: true
     offlinePush:
       switch: true
-      title: "create group title"
+      title: "create group title" # xx create the group
       desc: "create group desc"
       ext: "create group ext"
     defaultTips:
       tips: "create the group"  # xx create the group
 
-  groupInfoChanged:
+  groupInfoSet:
     conversation:
-      conversationChanged: true
-      unreadCount: true
+      reliabilityLevel: 1
+      unreadCount: false
     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
-      conversationChanged: 0
+
+  joinGroupApplication:
+    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
+
+  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---------------------#
@@ -215,9 +436,9 @@ demo:
   superCode: 666666
   mail:
     title: "openIM"
-    senderMail: "1765567899@qq.com"
-    senderAuthorizationCode: "1gxyausfoevlzbfag"
-    smtpAddr: "smtp.qq.com"
-    smtpPort: 25
+senderMail: "1765567899@qq.com"
+senderAuthorizationCode: "1gxyausfoevlzbfag"
+smtpAddr: "smtp.qq.com"
+smtpPort: 25
 
 

internal/api/chat/pull_msg.go

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

internal/api/chat/send_msg.go

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

internal/api/friend/friend.go

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

internal/api/third/tencent_cloud_storage_credential.go

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

internal/rpc/friend/firend.go

@@ -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) {
 	log.NewInfo(req.CommID.OperationID, "AddBlacklist args ", req.String())
 	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
 	}
 
-	chat.FriendApplicationAddedNotification(req)
+	chat.FriendApplicationNotification(req)
 	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)
 		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.Unix()
 	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
-	if req.Flag == constant.FriendFlag {
+	if req.HandleResult == constant.FriendFlag {
 		//Establish friendship after find friend relationship not exists
 		_, err := imdb.GetFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
 		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.FriendApplicationProcessedNotification(req)
+	if req.HandleResult == constant.FriendResponseAgree {
+		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")
 	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
 	}
 	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
 }
 
@@ -442,8 +405,26 @@ func (s *friendServer) GetFriendApplyList(ctx context.Context, req *pbFriend.Get
 	for _, applyUserInfo := range ApplyUsersInfo {
 		var userInfo sdkws.FriendRequest
 		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)
 	}
+
 	log.NewInfo(req.CommID.OperationID, "rpc GetFriendApplyList ok", pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList})
 	return &pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList}, nil
 }
@@ -466,8 +447,68 @@ func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetSe
 	for _, selfApplyOtherUserInfo := range usersInfo {
 		var userInfo sdkws.FriendRequest // pbFriend.ApplyUserInfo
 		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)
 	}
 	log.NewInfo(req.CommID.OperationID, "rpc GetSelfApplyList ok", pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList})
 	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
+////
+//}

internal/rpc/group/group.go

@@ -141,12 +141,18 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 		resp.ErrMsg = constant.ErrDB.ErrMsg
 		return resp, nil
 	}
-	chat.GroupCreatedNotification(req.OperationID, req.OpUserID, req.OwnerUserID, groupId, okUserIDList)
 	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
 
 	log.NewInfo(req.OperationID, "rpc CreateGroup return ", resp.String())
+	chat.GroupCreatedNotification(req.OperationID, req.OpUserID, groupId, okUserIDList)
 	return resp, nil
 }
 
@@ -166,7 +172,7 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 	var resp pbGroup.GetJoinedGroupListResp
 	for _, v := range joinedGroupList {
 		var groupNode open_im_sdk.GroupInfo
-		num := imdb.GetGroupMemberNumByGroupID(v)
+		num, err := imdb.GetGroupMemberNumByGroupID(v)
 		owner, err2 := imdb.GetGroupOwnerInfoByGroupID(v)
 		group, err := imdb.GetGroupInfoByGroupID(v)
 		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
 		err = imdb.InsertIntoGroupMember(toInsertInfo)
 		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
 			resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
 			continue
@@ -401,8 +407,21 @@ func (s *groupServer) GetGroupApplicationList(_ context.Context, req *pbGroup.Ge
 	log.NewDebug(req.OperationID, "GetGroupApplicationList reply ", reply)
 	resp := pbGroup.GetGroupApplicationListResp{}
 	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.UserDBCopyOpenIMPublicUser(node.UserInfo, user)
+		cp.GroupDBCopyOpenIM(node.GroupInfo, group)
 		log.NewDebug(req.OperationID, "node ", node, "v ", v)
 		resp.GroupRequestList = append(resp.GroupRequestList, &node)
 	}
@@ -447,30 +466,33 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
 		log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), groupRequest)
 		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 {
-			user, err := imdb.GetUserByUserID(req.FromUserID)
-			if err != nil {
-				log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), req.FromUserID)
-				return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
-			}
-			member := db.GroupMember{}
-			member.GroupID = req.GroupID
-			member.UserID = req.FromUserID
-			member.RoleLevel = constant.GroupOrdinaryUsers
-			member.OperatorUserID = req.OpUserID
-			member.FaceUrl = user.FaceUrl
-			member.Nickname = user.Nickname
-
-			err = imdb.InsertIntoGroupMember(member)
-			if err != nil {
-				log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), member)
-				return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
-			}
+		user, err := imdb.GetUserByUserID(req.FromUserID)
+		if err != nil {
+			log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), req.FromUserID)
+			return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 		}
+		member := db.GroupMember{}
+		member.GroupID = req.GroupID
+		member.UserID = req.FromUserID
+		member.RoleLevel = constant.GroupOrdinaryUsers
+		member.OperatorUserID = req.OpUserID
+		member.FaceUrl = user.FaceURL
+		member.Nickname = user.Nickname
+
+		err = imdb.InsertIntoGroupMember(member)
+		if err != nil {
+			log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), member)
+			return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+		}
+		chat.GroupApplicationAcceptedNotification(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{}})
@@ -502,7 +524,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
 	}
 
-	chat.JoinApplicationNotification(req)
+	chat.JoinGroupApplicationNotification(req)
 
 	log.NewInfo(req.OperationID, "ReceiveJoinApplicationNotification rpc return ")
 	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
 	}
 
-	chat.MemberLeaveNotification(req)
+	chat.MemberQuitNotification(req)
 	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
 }
@@ -584,11 +606,10 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		log.NewError(req.OperationID, "SetGroupInfo failed ", err.Error(), groupInfo)
 		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-
-	if changedType != 0 {
-		chat.GroupInfoChangedNotification(req.OperationID, req.OpUserID, req.GroupInfo.GroupID, changedType)
-	}
 	log.NewInfo(req.OperationID, "SetGroupInfo rpc return ", pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}})
+	if changedType != 0 {
+		chat.GroupInfoSetNotification(req.OperationID, req.OpUserID, req.GroupInfo.GroupID)
+	}
 	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)
 		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-	changedType := int32(1) << 4
-	chat.GroupInfoChangedNotification(req.OperationID, req.OpUserID, req.GroupID, changedType)
+	chat.GroupOwnerTransferredNotification(req)
 
 	return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
 

internal/rpc/msg/friend_notification.go

@@ -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)
+}

internal/rpc/msg/group_notification.go

@@ -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)
+
+}

internal/rpc/msg/notification.go

@@ -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)
-}

internal/rpc/msg/pull_message.go

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

internal/rpc/msg/send_msg.go

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

internal/rpc/user/user.go

@@ -235,8 +235,8 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 		return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
 	}
 	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
 }

pkg/base_info/cos_api_struct.go

@@ -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"`
+}

pkg/base_info/group_api_struct.go

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

pkg/common/config/config.go

@@ -164,19 +164,113 @@ type config struct {
 		BadgeCount bool   `yaml:"badgeCount"`
 	}
 	Notification struct {
+		///////////////////////group/////////////////////////////
 		GroupCreated struct {
 			Conversation PConversation `yaml:"conversation"`
 			OfflinePush  POfflinePush  `yaml:"offlinePush"`
 			DefaultTips  PDefaultTips  `yaml:"defaultTips"`
 		}
 
-		GroupInfoChanged struct {
+		GroupInfoSet struct {
 			Conversation PConversation `yaml:"conversation"`
 			OfflinePush  POfflinePush  `yaml:"offlinePush"`
 			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"`
 			OfflinePush  POfflinePush  `yaml:"offlinePush"`
 			DefaultTips  PDefaultTips  `yaml:"defaultTips"`
@@ -201,8 +295,8 @@ type config struct {
 	}
 }
 type PConversation struct {
-	ConversationChanged bool `yaml:"conversationChanged"`
-	UnreadCount         bool `yaml:"unreadCount"`
+	ReliabilityLevel int  `yaml:"reliabilityLevel"`
+	UnreadCount      bool `yaml:"unreadCount"`
 }
 
 type POfflinePush struct {

pkg/common/constant/constant.go

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

pkg/common/db/model_struct.go

@@ -34,7 +34,7 @@ type Friend struct {
 //int64 HandleTime = 8;
 //string Ex = 9;
 //}
-//open_im_sdk.FriendRequest == imdb.FriendRequest
+//open_im_sdk.FriendRequest(nickname, farce url ...) != imdb.FriendRequest
 type FriendRequest struct {
 	FromUserID    string    `gorm:"column:from_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 {
 	UserID         string    `gorm:"column:user_id;primary_key;size:64"`
 	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"`
 	PhoneNumber    string    `gorm:"column:phone_number;size:32"`
 	Birth          time.Time `gorm:"column:birth"`

pkg/common/db/mongoModel.go

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

pkg/common/db/mysql_model/im_mysql_model/group_member_model.go

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

pkg/common/db/mysql_model/im_mysql_model/group_model.go

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

pkg/common/log/logrus.go

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

pkg/common/utils/utils.go

@@ -18,57 +18,104 @@ func OperationIDGenerator() string {
 func FriendOpenIMCopyDB(dst *db.Friend, src *open_im_sdk.FriendInfo) {
 	utils.CopyStructFields(dst, src)
 	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)
-	user, _ := imdb.GetUserByUserID(src.FriendUserID)
-	if user != nil {
-		utils.CopyStructFields(dst.FriendUser, user)
+	user, err := imdb.GetUserByUserID(src.FriendUserID)
+	if err != nil {
+		return utils.Wrap(err, "")
 	}
+	utils.CopyStructFields(dst.FriendUser, user)
 	dst.CreateTime = uint32(src.CreateTime.Unix())
 	dst.FriendUser.CreateTime = uint32(user.CreateTime.Unix())
+	return nil
 }
 
 //
 func FriendRequestOpenIMCopyDB(dst *db.FriendRequest, src *open_im_sdk.FriendRequest) {
 	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)
+	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.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) {
 	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)
-	user, _ := imdb.GetGroupOwnerInfoByGroupID(src.GroupID)
-	if user != nil {
-		dst.OwnerUserID = user.UserID
+	user, err := imdb.GetGroupOwnerInfoByGroupID(src.GroupID)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	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())
+	return nil
 }
 
 func GroupMemberOpenIMCopyDB(dst *db.GroupMember, src *open_im_sdk.GroupMemberFullInfo) {
 	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)
 	if token_verify.IsMangerUserID(src.UserID) {
-		u, _ := imdb.GetUserByUserID(src.UserID)
-		if u != nil {
-			utils.CopyStructFields(dst, u)
+		u, err := imdb.GetUserByUserID(src.UserID)
+		if err != nil {
+			return utils.Wrap(err, "")
 		}
+
+		utils.CopyStructFields(dst, u)
+
 		dst.AppMangerLevel = 1
 	}
 	dst.JoinTime = src.JoinTime.Unix()
+	return nil
 }
 
 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) {
 	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) {
 	utils.CopyStructFields(dst, src)
 	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)
-	dst.BlockUserID = src.BlackUserInfo.UserID
 }
 
-func BlackDBCopyOpenIM(dst *open_im_sdk.BlackInfo, src *db.Black) {
-	utils.CopyStructFields(dst, src)
-	dst.CreateTime = uint32(src.CreateTime.Unix())
-	user, _ := imdb.GetUserByUserID(src.BlockUserID)
-	if user != nil {
-		utils.CopyStructFields(dst.BlackUserInfo, user)
-	}
-}
+//
+//func PublicUserDBCopyOpenIM(dst *open_im_sdk.PublicUserInfo, src *db.User){
+//
+//}

pkg/proto/auth/auth.pb.go

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

pkg/proto/auth/auth.proto

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

pkg/proto/chat/chat.pb.go

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

pkg/proto/chat/chat.proto

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

pkg/proto/friend/friend.pb.go

@@ -36,7 +36,7 @@ func (m *CommonResp) Reset()         { *m = CommonResp{} }
 func (m *CommonResp) String() string { return proto.CompactTextString(m) }
 func (*CommonResp) ProtoMessage()    {}
 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 {
 	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 (*CommID) ProtoMessage()    {}
 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 {
 	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 (*GetFriendsInfoReq) ProtoMessage()    {}
 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 {
 	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 (*GetFriendInfoResp) ProtoMessage()    {}
 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 {
 	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 (*AddFriendReq) ProtoMessage()    {}
 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 {
 	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 (*AddFriendResp) ProtoMessage()    {}
 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 {
 	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 (*ImportFriendReq) ProtoMessage()    {}
 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 {
 	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 (*UserIDResult) ProtoMessage()    {}
 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 {
 	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 (*ImportFriendResp) ProtoMessage()    {}
 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 {
 	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 (*GetFriendApplyListReq) ProtoMessage()    {}
 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 {
 	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 (*GetFriendApplyListResp) ProtoMessage()    {}
 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 {
 	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 (*GetFriendListReq) ProtoMessage()    {}
 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 {
 	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 (*GetFriendListResp) ProtoMessage()    {}
 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 {
 	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 (*AddBlacklistReq) ProtoMessage()    {}
 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 {
 	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 (*AddBlacklistResp) ProtoMessage()    {}
 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 {
 	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 (*RemoveBlacklistReq) ProtoMessage()    {}
 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 {
 	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 (*RemoveBlacklistResp) ProtoMessage()    {}
 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 {
 	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 (*GetBlacklistReq) ProtoMessage()    {}
 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 {
 	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 (*GetBlacklistResp) ProtoMessage()    {}
 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 {
 	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 (*IsFriendReq) ProtoMessage()    {}
 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 {
 	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 (*IsFriendResp) ProtoMessage()    {}
 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 {
 	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 (*IsInBlackListReq) ProtoMessage()    {}
 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 {
 	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 (*IsInBlackListResp) ProtoMessage()    {}
 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 {
 	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 (*DeleteFriendReq) ProtoMessage()    {}
 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 {
 	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 (*DeleteFriendResp) ProtoMessage()    {}
 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 {
 	return xxx_messageInfo_DeleteFriendResp.Unmarshal(m, b)
@@ -1153,7 +1153,7 @@ func (m *DeleteFriendResp) GetCommonResp() *CommonResp {
 // process
 type AddFriendResponseReq struct {
 	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"`
 	XXX_NoUnkeyedLiteral struct{} `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 (*AddFriendResponseReq) ProtoMessage()    {}
 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 {
 	return xxx_messageInfo_AddFriendResponseReq.Unmarshal(m, b)
@@ -1191,9 +1191,9 @@ func (m *AddFriendResponseReq) GetCommID() *CommID {
 	return nil
 }
 
-func (m *AddFriendResponseReq) GetFlag() int32 {
+func (m *AddFriendResponseReq) GetHandleResult() int32 {
 	if m != nil {
-		return m.Flag
+		return m.HandleResult
 	}
 	return 0
 }
@@ -1216,7 +1216,7 @@ func (m *AddFriendResponseResp) Reset()         { *m = AddFriendResponseResp{} }
 func (m *AddFriendResponseResp) String() string { return proto.CompactTextString(m) }
 func (*AddFriendResponseResp) ProtoMessage()    {}
 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 {
 	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 (*SetFriendRemarkReq) ProtoMessage()    {}
 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 {
 	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 (*SetFriendRemarkResp) ProtoMessage()    {}
 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 {
 	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 (*GetSelfApplyListReq) ProtoMessage()    {}
 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 {
 	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 (*GetSelfApplyListResp) ProtoMessage()    {}
 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 {
 	return xxx_messageInfo_GetSelfApplyListResp.Unmarshal(m, b)
@@ -1923,68 +1923,68 @@ var _Friend_serviceDesc = grpc.ServiceDesc{
 	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{
-	// 945 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xcf, 0x8f, 0xdb, 0x44,
-	0x14, 0x96, 0x9b, 0xdd, 0x34, 0x79, 0x49, 0x9b, 0x64, 0x92, 0x6d, 0x83, 0x77, 0x5b, 0x05, 0x1f,
-	0x50, 0xc4, 0x21, 0x91, 0x82, 0x2a, 0xb1, 0x14, 0x5a, 0xd2, 0xcd, 0x66, 0x31, 0xb0, 0x6c, 0x35,
-	0x5b, 0x2e, 0x08, 0x69, 0xe5, 0xd6, 0x93, 0x60, 0xc5, 0xb1, 0xa7, 0x1e, 0x2f, 0x15, 0x57, 0x0e,
-	0x88, 0x1b, 0x12, 0xe2, 0xc6, 0x81, 0x7f, 0x15, 0x79, 0xc6, 0x8e, 0x67, 0x6c, 0x6f, 0x85, 0x5d,
-	0xa4, 0x9e, 0x92, 0x37, 0xef, 0x87, 0xdf, 0xfb, 0xde, 0x9b, 0xf7, 0xd9, 0xd0, 0x5f, 0x05, 0x0e,
-	0xf1, 0xec, 0xa9, 0xf8, 0x99, 0xd0, 0xc0, 0x0f, 0x7d, 0x54, 0x17, 0x92, 0xfe, 0xe1, 0x05, 0x25,
-	0xde, 0x95, 0x79, 0x3e, 0xa5, 0x9b, 0xf5, 0x94, 0xab, 0xa6, 0xcc, 0xde, 0x5c, 0xbd, 0x61, 0xd3,
-	0x37, 0x4c, 0x98, 0x1a, 0x4f, 0x00, 0x4e, 0xfc, 0xed, 0xd6, 0xf7, 0x30, 0x61, 0x14, 0x0d, 0xe1,
-	0x36, 0x09, 0x82, 0x13, 0xdf, 0x26, 0x43, 0x6d, 0xa4, 0x8d, 0xf7, 0x71, 0x22, 0xa2, 0x7b, 0x50,
-	0x27, 0x41, 0x70, 0xce, 0xd6, 0xc3, 0x5b, 0x23, 0x6d, 0xdc, 0xc4, 0xb1, 0x64, 0xfc, 0xaa, 0x41,
-	0x3d, 0x0a, 0x60, 0x2e, 0x90, 0x0e, 0x8d, 0x0b, 0xfa, 0x3d, 0x23, 0x81, 0xb9, 0xe0, 0xde, 0x4d,
-	0xbc, 0x93, 0xd1, 0x08, 0x5a, 0x17, 0x94, 0x04, 0x56, 0xe8, 0xf8, 0x9e, 0xb9, 0x88, 0x63, 0xc8,
-	0x47, 0x91, 0xf7, 0x0b, 0x3f, 0xf6, 0xde, 0x13, 0xde, 0x89, 0x8c, 0x1e, 0x02, 0x2c, 0x03, 0x7f,
-	0x1b, 0x6b, 0xf7, 0xb9, 0x56, 0x3a, 0x31, 0x1e, 0x43, 0xef, 0x8c, 0x84, 0x4b, 0x5e, 0x34, 0x33,
-	0xbd, 0x95, 0x8f, 0xc9, 0x6b, 0xf4, 0x51, 0x92, 0x18, 0x4f, 0xa6, 0x35, 0xbb, 0x3b, 0x89, 0x31,
-	0x12, 0xa7, 0x38, 0xd6, 0x1a, 0xbf, 0x69, 0x92, 0xb7, 0x70, 0x16, 0x48, 0x9c, 0xaa, 0x48, 0x9c,
-	0xa6, 0x48, 0x9c, 0x2a, 0x48, 0x08, 0x09, 0x3d, 0x85, 0xbb, 0x69, 0x8c, 0x6f, 0x1d, 0x16, 0x0e,
-	0x6b, 0xa3, 0xda, 0xb8, 0x35, 0xbb, 0x3f, 0xf1, 0xa3, 0x2e, 0x38, 0xdb, 0x2b, 0x66, 0x6f, 0x26,
-	0xd2, 0x63, 0x32, 0xe6, 0xc6, 0x77, 0xd0, 0x9e, 0xdb, 0xb6, 0x38, 0x2c, 0x51, 0x40, 0x94, 0x10,
-	0x26, 0xaf, 0xa5, 0x84, 0x84, 0x64, 0x9c, 0xc0, 0x1d, 0x29, 0x1e, 0xa3, 0x68, 0x26, 0xf7, 0x3a,
-	0x0e, 0x8a, 0xe4, 0xa0, 0x42, 0x83, 0x25, 0x2b, 0xe3, 0x6f, 0x0d, 0x3a, 0xe6, 0x96, 0xfa, 0x41,
-	0x98, 0x26, 0xf6, 0x31, 0x74, 0x85, 0x20, 0xe0, 0xe7, 0xb5, 0x6a, 0xa3, 0xda, 0xb8, 0x89, 0x73,
-	0xe7, 0xff, 0xa1, 0xf1, 0x6a, 0x73, 0x6b, 0xd9, 0xe6, 0x2a, 0x63, 0xb5, 0xa7, 0x8e, 0x95, 0xf1,
-	0x04, 0xda, 0xe2, 0x1f, 0x26, 0xec, 0xda, 0x0d, 0x23, 0x28, 0x94, 0x01, 0x8c, 0x25, 0x01, 0x51,
-	0x64, 0xc1, 0x13, 0xd8, 0xc7, 0xb1, 0x64, 0xfc, 0xae, 0x41, 0x57, 0xad, 0xae, 0x1a, 0x4c, 0xe8,
-	0x4b, 0xe8, 0xca, 0x89, 0x70, 0x48, 0x6e, 0xf1, 0xf6, 0x0f, 0x12, 0x4f, 0x59, 0x8f, 0x73, 0xd6,
-	0xc6, 0x53, 0x38, 0xd8, 0x4d, 0xe1, 0x9c, 0x52, 0xf7, 0x97, 0xe8, 0xb4, 0xcc, 0x1c, 0xff, 0xa5,
-	0xc1, 0xbd, 0xa2, 0x08, 0x95, 0x86, 0xf9, 0x2b, 0xe8, 0xed, 0xfa, 0x7d, 0x4d, 0x58, 0x28, 0xcd,
-	0xb3, 0x5e, 0x30, 0xcf, 0xb1, 0x15, 0xce, 0x3b, 0x19, 0x9f, 0x41, 0x77, 0x97, 0x55, 0xd9, 0x92,
-	0x94, 0xab, 0xf9, 0x0e, 0xd5, 0xbc, 0xf3, 0xd5, 0x3c, 0x86, 0xce, 0xdc, 0xb6, 0x9f, 0xb9, 0xd6,
-	0xab, 0x8d, 0x5b, 0xb2, 0x86, 0x25, 0x74, 0x55, 0xd7, 0x8a, 0x17, 0xf1, 0x73, 0x40, 0x98, 0x6c,
-	0xfd, 0x9f, 0x49, 0xa5, 0x2c, 0x4c, 0xe8, 0xe7, 0xbc, 0x2b, 0x26, 0x72, 0x0c, 0x9d, 0x33, 0x12,
-	0x56, 0xca, 0xe2, 0x0f, 0x8d, 0x0f, 0x83, 0x9a, 0x43, 0xf9, 0x76, 0x9a, 0xd0, 0xe3, 0x21, 0xf8,
-	0x1d, 0x52, 0x3b, 0x7a, 0xa8, 0x74, 0xf4, 0xf9, 0xf5, 0x4b, 0xd7, 0x79, 0x95, 0x98, 0xe1, 0xbc,
-	0x97, 0xf1, 0x08, 0x5a, 0x26, 0x2b, 0xbd, 0x72, 0x8d, 0x1f, 0xa1, 0x9d, 0xba, 0x55, 0xaa, 0x41,
-	0x87, 0x46, 0xe4, 0xe9, 0x7b, 0x8c, 0xf0, 0x9d, 0xd7, 0xc0, 0x3b, 0x39, 0xba, 0x32, 0x26, 0x33,
-	0x3d, 0x9e, 0x6d, 0xd9, 0x2b, 0x63, 0x41, 0x2f, 0xe3, 0xfb, 0xbf, 0xa7, 0x77, 0x0c, 0x9d, 0x05,
-	0x71, 0x49, 0x48, 0xca, 0xe3, 0xb6, 0x84, 0xae, 0xea, 0x5a, 0x71, 0x06, 0x29, 0x0c, 0x14, 0x6a,
-	0x8b, 0xf2, 0x2a, 0x43, 0x99, 0x08, 0xf6, 0x56, 0xae, 0xb5, 0x8e, 0xd9, 0x80, 0xff, 0x47, 0x47,
-	0xd0, 0xfc, 0xc9, 0xf2, 0x6c, 0x97, 0x44, 0x68, 0x08, 0x1a, 0x4a, 0x0f, 0x8c, 0x6f, 0xe0, 0xa0,
-	0xe0, 0x89, 0x15, 0xd3, 0x7f, 0x01, 0xe8, 0x92, 0xec, 0x28, 0x67, 0x6b, 0x05, 0x9b, 0xd2, 0x7c,
-	0x1f, 0x39, 0xa5, 0x7c, 0x1f, 0x49, 0xd1, 0x1d, 0xcf, 0x45, 0xad, 0x98, 0xe0, 0x17, 0xd0, 0x3f,
-	0x23, 0xe1, 0x25, 0x71, 0x57, 0x95, 0xa8, 0xe8, 0x4f, 0x0d, 0x06, 0x79, 0xff, 0xf7, 0x4b, 0x44,
-	0xb3, 0x7f, 0x6e, 0x43, 0xfc, 0x5e, 0x8c, 0x3e, 0x85, 0xa6, 0x95, 0x34, 0x13, 0xed, 0x08, 0x5a,
-	0x7e, 0xf9, 0xd2, 0x0f, 0x0a, 0x4e, 0x19, 0x45, 0x97, 0x80, 0xd6, 0x39, 0x8e, 0x45, 0x0f, 0x12,
-	0xe3, 0x42, 0x06, 0xd7, 0x1f, 0xbe, 0x4d, 0xcd, 0x28, 0x3a, 0x87, 0xee, 0x3a, 0x83, 0x16, 0x3a,
-	0x94, 0x7c, 0xb2, 0x7d, 0xd0, 0x8f, 0x6e, 0x56, 0x32, 0x8a, 0x16, 0x70, 0x67, 0x2d, 0x93, 0x26,
-	0x1a, 0xe6, 0x9e, 0x9f, 0x04, 0xfa, 0xe0, 0x06, 0x0d, 0xa3, 0x68, 0x0e, 0x6d, 0x4b, 0xe2, 0x2d,
-	0x74, 0x5f, 0x02, 0x44, 0x5e, 0xfe, 0xfa, 0xb0, 0x58, 0xc1, 0x28, 0xfa, 0x1a, 0x3a, 0x81, 0x4a,
-	0x3a, 0x48, 0x4f, 0x8c, 0xf3, 0x5c, 0xa6, 0x1f, 0xde, 0xa8, 0x63, 0x14, 0x3d, 0x82, 0x86, 0x13,
-	0x6f, 0x5c, 0xd4, 0x4f, 0x0c, 0xa5, 0xd5, 0xad, 0x0f, 0xf2, 0x87, 0x02, 0x0b, 0x47, 0x5e, 0x87,
-	0x29, 0x16, 0xd9, 0x0d, 0x9b, 0x62, 0x91, 0xdf, 0x9f, 0x73, 0x68, 0xaf, 0x25, 0xda, 0x4a, 0xb1,
-	0xc8, 0x10, 0xa1, 0x3e, 0x2c, 0x56, 0x88, 0x10, 0xb6, 0xb4, 0xf9, 0xd2, 0x10, 0x99, 0x55, 0x9a,
-	0x86, 0xc8, 0x2d, 0xca, 0xe7, 0xd0, 0xb3, 0xb2, 0x2b, 0x08, 0x1d, 0x15, 0xce, 0x69, 0xbc, 0x0f,
-	0xf5, 0x07, 0x6f, 0xd1, 0x8a, 0x06, 0x31, 0x75, 0x63, 0xa4, 0x0d, 0xca, 0x2f, 0xa8, 0xb4, 0x41,
-	0x45, 0x6b, 0x66, 0x0e, 0x6d, 0x47, 0x7a, 0x93, 0x4e, 0x0b, 0xcc, 0x7c, 0x3d, 0xa4, 0x05, 0x66,
-	0x5f, 0xbc, 0x9f, 0xf5, 0x7e, 0xe8, 0x4c, 0xe2, 0x0f, 0xd9, 0xc7, 0xe2, 0xe7, 0x65, 0x9d, 0x7f,
-	0xa5, 0x7e, 0xf2, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdf, 0x16, 0xf8, 0xb5, 0xe7, 0x0e, 0x00,
-	0x00,
+var fileDescriptor_friend_74b4824fb8c5de90 = []byte{
+	// 950 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xcf, 0x8f, 0xdb, 0x44,
+	0x14, 0x96, 0x9b, 0x6e, 0x9a, 0xbc, 0xa4, 0x4d, 0x32, 0xc9, 0x96, 0xe0, 0xee, 0x56, 0xa9, 0x0f,
+	0x28, 0xe2, 0x90, 0x48, 0x41, 0x95, 0x58, 0x0a, 0x85, 0x74, 0x93, 0xac, 0x0c, 0x6c, 0x53, 0xcd,
+	0x96, 0x0b, 0x42, 0x8a, 0xdc, 0x7a, 0x36, 0x58, 0x71, 0xec, 0xa9, 0xc7, 0xdb, 0x15, 0x37, 0xc4,
+	0x89, 0x03, 0x57, 0x24, 0x04, 0x07, 0xfe, 0x55, 0x64, 0x8f, 0x1d, 0xcf, 0xd8, 0xce, 0x0a, 0x9b,
+	0x3d, 0x70, 0xda, 0x7d, 0xef, 0xcd, 0xf7, 0xf2, 0x7e, 0xcd, 0xfb, 0xc6, 0xd0, 0xbd, 0xf4, 0x2c,
+	0xe2, 0x98, 0x63, 0xfe, 0x67, 0x44, 0x3d, 0xd7, 0x77, 0x51, 0x95, 0x4b, 0xea, 0x93, 0x25, 0x25,
+	0xce, 0x4a, 0x3f, 0x1f, 0xd3, 0xcd, 0x7a, 0x1c, 0x9a, 0xc6, 0xcc, 0xdc, 0xac, 0xae, 0xd9, 0xf8,
+	0x9a, 0xf1, 0xa3, 0xda, 0x73, 0x80, 0x53, 0x77, 0xbb, 0x75, 0x1d, 0x4c, 0x18, 0x45, 0x7d, 0xb8,
+	0x47, 0x3c, 0xef, 0xd4, 0x35, 0x49, 0x5f, 0x19, 0x28, 0xc3, 0x03, 0x1c, 0x8b, 0xe8, 0x21, 0x54,
+	0x89, 0xe7, 0x9d, 0xb3, 0x75, 0xff, 0xce, 0x40, 0x19, 0xd6, 0x71, 0x24, 0x69, 0xbf, 0x28, 0x50,
+	0x0d, 0x1c, 0xe8, 0x33, 0xa4, 0x42, 0x6d, 0x49, 0xbf, 0x63, 0xc4, 0xd3, 0x67, 0x21, 0xba, 0x8e,
+	0x77, 0x32, 0x1a, 0x40, 0x63, 0x49, 0x89, 0x67, 0xf8, 0x96, 0xeb, 0xe8, 0xb3, 0xc8, 0x87, 0xa8,
+	0x0a, 0xd0, 0xaf, 0xdd, 0x08, 0x7d, 0x97, 0xa3, 0x63, 0x19, 0x3d, 0x06, 0x58, 0x78, 0xee, 0x36,
+	0xb2, 0x1e, 0x84, 0x56, 0x41, 0xa3, 0x3d, 0x83, 0xce, 0x19, 0xf1, 0x17, 0x61, 0xd2, 0x4c, 0x77,
+	0x2e, 0x5d, 0x4c, 0xde, 0xa1, 0x8f, 0xe2, 0xc0, 0xc2, 0x60, 0x1a, 0x93, 0x07, 0xa3, 0xa8, 0x46,
+	0x5c, 0x8b, 0x23, 0xab, 0xf6, 0x9b, 0x22, 0xa0, 0x39, 0x98, 0x57, 0x62, 0x2e, 0x57, 0x62, 0x9e,
+	0x54, 0x62, 0x2e, 0x55, 0x82, 0x4b, 0x68, 0x0e, 0x0f, 0x12, 0x1f, 0xdf, 0x5a, 0xcc, 0xef, 0x57,
+	0x06, 0x95, 0x61, 0x63, 0x72, 0x3c, 0x62, 0xc4, 0x7b, 0x4f, 0xbc, 0x95, 0x41, 0xad, 0x15, 0x35,
+	0x3c, 0x63, 0xcb, 0x46, 0xc2, 0x8f, 0xa5, 0x40, 0xda, 0x4b, 0x68, 0x4e, 0x4d, 0x93, 0x2b, 0x0b,
+	0xa4, 0x11, 0x84, 0x85, 0xc9, 0x3b, 0x21, 0x2c, 0x2e, 0x69, 0xa7, 0x70, 0x5f, 0xf0, 0xc7, 0x28,
+	0x9a, 0x88, 0x1d, 0x8f, 0x9c, 0x22, 0xd1, 0x29, 0xb7, 0x60, 0xe1, 0x94, 0xf6, 0x97, 0x02, 0x2d,
+	0x7d, 0x4b, 0x5d, 0xcf, 0x4f, 0x02, 0xfb, 0x18, 0xda, 0x5c, 0xe0, 0x4d, 0x08, 0x33, 0x56, 0x06,
+	0x95, 0x61, 0x1d, 0x67, 0xf4, 0xff, 0xa2, 0xfd, 0x72, 0x8b, 0x2b, 0xe9, 0x16, 0x4b, 0xc3, 0x75,
+	0x57, 0x1e, 0x2e, 0xed, 0x39, 0x34, 0xf9, 0x7f, 0x98, 0xb0, 0x2b, 0xdb, 0x0f, 0x4a, 0x21, 0x8d,
+	0x61, 0x24, 0xf1, 0x12, 0x05, 0x27, 0xc2, 0x00, 0x0e, 0x70, 0x24, 0x69, 0xbf, 0x2a, 0xd0, 0x96,
+	0xb3, 0x2b, 0x57, 0x26, 0xf4, 0x15, 0xb4, 0xc5, 0x40, 0xc2, 0x92, 0xdc, 0x09, 0x87, 0xa0, 0x17,
+	0x23, 0x45, 0x3b, 0xce, 0x9c, 0xd6, 0xbe, 0x84, 0xc3, 0xdd, 0x2c, 0x4e, 0x29, 0xb5, 0x7f, 0x0a,
+	0xb4, 0x45, 0xa6, 0xf9, 0x4f, 0x05, 0x1e, 0xe6, 0x79, 0x28, 0x35, 0xd2, 0x2f, 0xa1, 0xb3, 0xeb,
+	0xf7, 0x15, 0x61, 0xbe, 0x30, 0xd5, 0x83, 0xbd, 0x53, 0x1d, 0x9d, 0xc5, 0x59, 0xa8, 0xf6, 0x19,
+	0xb4, 0x77, 0xb1, 0x15, 0x4d, 0x4c, 0xba, 0xa6, 0xff, 0x21, 0xa7, 0x5b, 0xba, 0xa6, 0x27, 0xd0,
+	0x9a, 0x9a, 0xe6, 0x0b, 0xdb, 0x78, 0xbb, 0xb1, 0x0b, 0x66, 0xb2, 0x80, 0xb6, 0x0c, 0x2d, 0x79,
+	0x29, 0x3f, 0x07, 0x84, 0xc9, 0xd6, 0x7d, 0x4f, 0x4a, 0x45, 0xa1, 0x43, 0x37, 0x83, 0x2e, 0x19,
+	0xc8, 0x09, 0xb4, 0xce, 0x88, 0x5f, 0x2a, 0x8a, 0xdf, 0x95, 0x70, 0x24, 0xe4, 0x18, 0x8a, 0x37,
+	0x75, 0x09, 0x9d, 0xd0, 0x45, 0x78, 0x9f, 0xe4, 0xbe, 0x3e, 0xc9, 0xe9, 0xeb, 0xab, 0xab, 0x37,
+	0xb6, 0xf5, 0x36, 0x3e, 0x8c, 0xb3, 0x58, 0xed, 0x29, 0x34, 0x74, 0x56, 0x78, 0x09, 0x6b, 0x3f,
+	0x40, 0x33, 0x81, 0x95, 0xca, 0x44, 0x85, 0x5a, 0x80, 0x74, 0x1d, 0x46, 0xc2, 0x2d, 0x58, 0xc3,
+	0x3b, 0x39, 0xb8, 0x3e, 0x3a, 0xd3, 0x9d, 0x30, 0xda, 0xa2, 0xd7, 0xc7, 0x80, 0x4e, 0x0a, 0x7b,
+	0xeb, 0xe1, 0x9d, 0x40, 0x6b, 0x46, 0x6c, 0xe2, 0x93, 0xe2, 0x75, 0x5b, 0x40, 0x5b, 0x86, 0x96,
+	0x9c, 0xc4, 0x9f, 0x15, 0xe8, 0x49, 0x6c, 0x17, 0x04, 0x56, 0x84, 0x45, 0x35, 0x68, 0xfe, 0x68,
+	0x38, 0xa6, 0x4d, 0x24, 0xa2, 0x90, 0x74, 0xe8, 0x08, 0xea, 0x5c, 0x0e, 0xca, 0xc3, 0x99, 0x2a,
+	0x51, 0x68, 0xdf, 0xc0, 0x61, 0x4e, 0x04, 0x25, 0xf3, 0x79, 0x0d, 0xe8, 0x82, 0xec, 0x58, 0x69,
+	0x6b, 0x78, 0x9b, 0xc2, 0x4f, 0x82, 0x00, 0x94, 0x3c, 0x09, 0x02, 0x29, 0xb8, 0xfa, 0x19, 0xaf,
+	0x25, 0x03, 0xfc, 0x02, 0xba, 0x67, 0xc4, 0xbf, 0x20, 0xf6, 0x65, 0x29, 0xb6, 0xfa, 0x43, 0x81,
+	0x5e, 0x16, 0xff, 0x7f, 0xe0, 0xaa, 0xc9, 0xdf, 0xf7, 0x20, 0x7a, 0x46, 0xa3, 0x4f, 0xa1, 0x6e,
+	0xc4, 0x2d, 0x45, 0x3b, 0x26, 0x17, 0x5f, 0x69, 0xea, 0x61, 0x8e, 0x96, 0x51, 0x74, 0x01, 0x68,
+	0x9d, 0x21, 0x63, 0x74, 0x1c, 0x1f, 0xce, 0xa5, 0x7a, 0xf5, 0xf1, 0x4d, 0x66, 0x46, 0xd1, 0x39,
+	0xb4, 0xd7, 0xa9, 0x9a, 0xa1, 0x47, 0x02, 0x26, 0xdd, 0x0d, 0xf5, 0x68, 0xbf, 0x91, 0x51, 0x34,
+	0x83, 0xfb, 0x6b, 0x91, 0x57, 0x51, 0x3f, 0xf3, 0xfb, 0xb1, 0xa3, 0x0f, 0xf7, 0x58, 0x18, 0x45,
+	0x53, 0x68, 0x1a, 0x02, 0xa9, 0xa1, 0x0f, 0x84, 0x82, 0x88, 0xcc, 0xa0, 0xf6, 0xf3, 0x0d, 0x8c,
+	0xa2, 0xaf, 0xa1, 0xe5, 0xc9, 0x8c, 0x84, 0xd4, 0xf8, 0x70, 0x96, 0xe8, 0xd4, 0x47, 0x7b, 0x6d,
+	0x8c, 0xa2, 0xa7, 0x50, 0xb3, 0xa2, 0x45, 0x8c, 0xba, 0xf1, 0x41, 0x61, 0xa3, 0xab, 0xbd, 0xac,
+	0x92, 0xd7, 0xc2, 0x12, 0xb7, 0x64, 0x52, 0x8b, 0xf4, 0xe2, 0x4d, 0x6a, 0x91, 0x5d, 0xab, 0x53,
+	0x68, 0xae, 0x05, 0x4e, 0x4b, 0x6a, 0x91, 0x62, 0x49, 0xb5, 0x9f, 0x6f, 0xe0, 0x2e, 0x4c, 0x61,
+	0x21, 0x26, 0x2e, 0x52, 0x1b, 0x36, 0x71, 0x91, 0xd9, 0x9f, 0xaf, 0xa0, 0x63, 0xa4, 0x17, 0x11,
+	0x3a, 0xca, 0x9d, 0xd3, 0x68, 0x4b, 0xaa, 0xc7, 0x37, 0x58, 0x79, 0x83, 0x98, 0xbc, 0x37, 0x92,
+	0x06, 0x65, 0xd7, 0x54, 0xd2, 0xa0, 0xbc, 0x65, 0x33, 0x85, 0xa6, 0x25, 0x3c, 0xb9, 0x93, 0x04,
+	0x53, 0x9f, 0x19, 0x49, 0x82, 0xe9, 0x17, 0xfa, 0x8b, 0xce, 0xf7, 0xad, 0x51, 0xf4, 0xdd, 0xfb,
+	0x8c, 0xff, 0x79, 0x53, 0x0d, 0x3f, 0x6a, 0x3f, 0xf9, 0x27, 0x00, 0x00, 0xff, 0xff, 0x26, 0xd5,
+	0xdf, 0x90, 0x16, 0x0f, 0x00, 0x00,
 }

pkg/proto/friend/friend.proto

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

pkg/proto/group/group.pb.go

@@ -36,7 +36,7 @@ func (m *CommonResp) Reset()         { *m = CommonResp{} }
 func (m *CommonResp) String() string { return proto.CompactTextString(m) }
 func (*CommonResp) ProtoMessage()    {}
 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 {
 	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 (*GroupAddMemberInfo) ProtoMessage()    {}
 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 {
 	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 (*CreateGroupReq) ProtoMessage()    {}
 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 {
 	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 (*CreateGroupResp) ProtoMessage()    {}
 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 {
 	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 (*GetGroupsInfoReq) ProtoMessage()    {}
 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 {
 	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 (*GetGroupsInfoResp) ProtoMessage()    {}
 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 {
 	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 (*SetGroupInfoReq) ProtoMessage()    {}
 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 {
 	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 (*SetGroupInfoResp) ProtoMessage()    {}
 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 {
 	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 (*GetGroupApplicationListReq) ProtoMessage()    {}
 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 {
 	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 (*GetGroupApplicationListResp) ProtoMessage()    {}
 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 {
 	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 (*TransferGroupOwnerReq) ProtoMessage()    {}
 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 {
 	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 (*TransferGroupOwnerResp) ProtoMessage()    {}
 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 {
 	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 (*JoinGroupReq) ProtoMessage()    {}
 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 {
 	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 (*JoinGroupResp) ProtoMessage()    {}
 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 {
 	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 (*GroupApplicationResponseReq) ProtoMessage()    {}
 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 {
 	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 (*GroupApplicationResponseResp) ProtoMessage()    {}
 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 {
 	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 (*QuitGroupReq) ProtoMessage()    {}
 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 {
 	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 (*QuitGroupResp) ProtoMessage()    {}
 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 {
 	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 (*GetGroupMemberListReq) ProtoMessage()    {}
 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 {
 	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 (*GetGroupMemberListResp) ProtoMessage()    {}
 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 {
 	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 (*GetGroupMembersInfoReq) ProtoMessage()    {}
 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 {
 	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 (*GetGroupMembersInfoResp) ProtoMessage()    {}
 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 {
 	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 (*KickGroupMemberReq) ProtoMessage()    {}
 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 {
 	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 (*Id2Result) ProtoMessage()    {}
 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 {
 	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 (*KickGroupMemberResp) ProtoMessage()    {}
 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 {
 	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 (*GetJoinedGroupListReq) ProtoMessage()    {}
 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 {
 	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 (*GetJoinedGroupListResp) ProtoMessage()    {}
 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 {
 	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 (*InviteUserToGroupReq) ProtoMessage()    {}
 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 {
 	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 (*InviteUserToGroupResp) ProtoMessage()    {}
 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 {
 	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 (*GetGroupAllMemberReq) ProtoMessage()    {}
 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 {
 	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 (*GetGroupAllMemberResp) ProtoMessage()    {}
 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 {
 	return xxx_messageInfo_GetGroupAllMemberResp.Unmarshal(m, b)
@@ -2257,86 +2257,86 @@ var _Group_serviceDesc = grpc.ServiceDesc{
 	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{
-	// 1235 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x49, 0x6f, 0x1c, 0x45,
-	0x14, 0x56, 0x79, 0x3c, 0x4e, 0xe6, 0xd9, 0xe3, 0xa5, 0xbc, 0x4d, 0x3a, 0xc6, 0x9a, 0x14, 0x12,
-	0xb2, 0x10, 0xb2, 0x85, 0x41, 0xb9, 0x24, 0x02, 0xbc, 0x26, 0x93, 0xc4, 0xb6, 0xdc, 0x31, 0x17,
-	0x2e, 0x66, 0xe2, 0x2e, 0xb7, 0x1a, 0xf7, 0x74, 0xb7, 0xbb, 0x7a, 0x62, 0xe0, 0x02, 0x08, 0xc1,
-	0x05, 0x21, 0x71, 0xe2, 0xce, 0x85, 0x33, 0x07, 0x4e, 0x5c, 0xf8, 0x1d, 0xfc, 0x04, 0xfe, 0x05,
-	0xaa, 0xa5, 0x7b, 0xaa, 0x57, 0x8f, 0x66, 0x24, 0x72, 0x19, 0xe9, 0x2d, 0xd5, 0xef, 0xbd, 0xaf,
-	0xde, 0x56, 0x03, 0x0b, 0x76, 0xe8, 0xf7, 0x83, 0x2d, 0xf1, 0xbb, 0x19, 0x84, 0x7e, 0xe4, 0xe3,
-	0xba, 0x20, 0x8c, 0x07, 0x27, 0x01, 0xf5, 0xce, 0x3b, 0x47, 0x5b, 0xc1, 0x95, 0xbd, 0x25, 0x24,
-	0x5b, 0xcc, 0xba, 0x3a, 0xbf, 0x61, 0x5b, 0x37, 0x4c, 0x6a, 0x92, 0x8f, 0x00, 0xf6, 0xfc, 0x5e,
-	0xcf, 0xf7, 0x4c, 0xca, 0x02, 0xdc, 0x82, 0x3b, 0x07, 0x61, 0xb8, 0xe7, 0x5b, 0xb4, 0x85, 0xda,
-	0x68, 0xa3, 0x6e, 0xc6, 0x24, 0x5e, 0x81, 0xa9, 0x83, 0x30, 0x3c, 0x62, 0x76, 0x6b, 0xa2, 0x8d,
-	0x36, 0x1a, 0xa6, 0xa2, 0xc8, 0x33, 0xc0, 0x4f, 0xb8, 0xad, 0x1d, 0xcb, 0x3a, 0xa2, 0xbd, 0x57,
-	0x34, 0xec, 0x78, 0x97, 0x3e, 0xd7, 0xfe, 0x94, 0xd1, 0xb0, 0xb3, 0x2f, 0x3e, 0xd3, 0x30, 0x15,
-	0x85, 0xd7, 0xa0, 0x61, 0xfa, 0x2e, 0x7d, 0x41, 0x5f, 0x53, 0x57, 0x7c, 0xa8, 0x6e, 0x0e, 0x18,
-	0xe4, 0x5f, 0x04, 0xb3, 0x7b, 0x21, 0xed, 0x46, 0x54, 0x7c, 0xd2, 0xa4, 0xd7, 0x78, 0x07, 0x66,
-	0x3b, 0x9e, 0x13, 0xc9, 0x4f, 0xbf, 0x70, 0x58, 0xd4, 0x42, 0xed, 0xda, 0xc6, 0xf4, 0xf6, 0xbd,
-	0x4d, 0x19, 0x6e, 0xde, 0xb6, 0x99, 0x39, 0x80, 0x3f, 0x84, 0x86, 0xd0, 0xe2, 0x42, 0x61, 0x73,
-	0x7a, 0x7b, 0x65, 0xd3, 0xe7, 0xc0, 0x38, 0xbd, 0x73, 0x66, 0x5d, 0x6d, 0x26, 0x52, 0x73, 0xa0,
-	0x88, 0xdb, 0x30, 0x7d, 0x12, 0xd0, 0xb0, 0x1b, 0x39, 0xbe, 0xd7, 0xd9, 0x6f, 0xd5, 0x44, 0x18,
-	0x3a, 0x0b, 0x1b, 0x70, 0xf7, 0x24, 0x50, 0x51, 0x4e, 0x0a, 0x71, 0x42, 0x8b, 0xd3, 0x37, 0x1e,
-	0x0d, 0x95, 0xb8, 0xae, 0x4e, 0x0f, 0x58, 0xe4, 0x2b, 0x98, 0x4b, 0x85, 0x3a, 0x0a, 0xf8, 0xe9,
-	0xd0, 0x6a, 0x43, 0x86, 0x46, 0x42, 0x98, 0x7f, 0x42, 0x23, 0x41, 0x33, 0x21, 0xa3, 0xd7, 0xdc,
-	0x61, 0xa9, 0xb0, 0x9f, 0x80, 0xdc, 0x30, 0x75, 0x56, 0x16, 0x90, 0x89, 0x6a, 0x40, 0x6a, 0x69,
-	0x40, 0xc8, 0xf7, 0x08, 0x16, 0x32, 0x46, 0x47, 0x8a, 0xf8, 0x31, 0x34, 0x93, 0x40, 0x84, 0xa7,
-	0x35, 0x91, 0x0e, 0x65, 0x51, 0xa7, 0x95, 0xc9, 0x0f, 0x08, 0xe6, 0x5e, 0x2a, 0x2f, 0xe2, 0xc8,
-	0x53, 0x18, 0xa2, 0x61, 0xd3, 0x43, 0x8f, 0x75, 0xa2, 0xe0, 0xf2, 0x2b, 0x53, 0x87, 0x1c, 0xc0,
-	0x7c, 0xda, 0x0d, 0x16, 0xe0, 0xf7, 0xf5, 0x42, 0x54, 0x8e, 0x2c, 0xa8, 0x2c, 0x1f, 0x08, 0x4c,
-	0x4d, 0x89, 0x7c, 0x0d, 0x46, 0x8c, 0xe9, 0x4e, 0x10, 0xb8, 0xce, 0x85, 0xf8, 0x3e, 0x8f, 0x94,
-	0x07, 0xa6, 0xbb, 0x88, 0xaa, 0x5d, 0x2c, 0xb8, 0xcc, 0x75, 0x80, 0xc3, 0xd0, 0xef, 0xa5, 0xae,
-	0x53, 0xe3, 0x90, 0x5f, 0x11, 0xdc, 0x2f, 0x35, 0x3e, 0xd2, 0xd5, 0x1e, 0xc0, 0x7c, 0x5c, 0xf6,
-	0x7d, 0xca, 0x22, 0xed, 0x76, 0xef, 0xe5, 0xef, 0x43, 0x29, 0x99, 0xb9, 0x23, 0xe4, 0x6f, 0x04,
-	0xcb, 0x67, 0x61, 0xd7, 0x63, 0x97, 0x34, 0x14, 0x42, 0x51, 0x75, 0x1c, 0x90, 0x16, 0xdc, 0x51,
-	0x09, 0xad, 0xf0, 0x88, 0x49, 0xfc, 0x0e, 0xcc, 0x9e, 0xb8, 0x96, 0x5e, 0xb1, 0xd2, 0xb5, 0x0c,
-	0x97, 0xeb, 0x1d, 0xd3, 0x1b, 0x5d, 0x4f, 0x02, 0x93, 0xe1, 0x66, 0xe1, 0x9d, 0xac, 0xae, 0x95,
-	0x7a, 0xa6, 0x56, 0x9e, 0xc3, 0x4a, 0x51, 0x00, 0xa3, 0xe5, 0xc8, 0x8f, 0x08, 0x66, 0x9e, 0xf9,
-	0x8e, 0x97, 0x74, 0xd4, 0x72, 0x14, 0xd6, 0x01, 0x4c, 0x7a, 0x7d, 0x44, 0x19, 0xeb, 0xda, 0x54,
-	0x21, 0xa0, 0x71, 0xaa, 0xea, 0xfb, 0xf6, 0x88, 0xc9, 0x2e, 0x34, 0x35, 0x3f, 0x46, 0x0b, 0xe6,
-	0x1f, 0x9e, 0x74, 0x99, 0x8c, 0xe3, 0x02, 0xdf, 0x63, 0x54, 0x75, 0x31, 0xdd, 0x0b, 0x54, 0x8d,
-	0x7b, 0xb6, 0x6e, 0x35, 0x64, 0x6a, 0x39, 0x64, 0xb4, 0x62, 0x98, 0xcc, 0x16, 0x03, 0x97, 0x3f,
-	0xed, 0x7a, 0x96, 0x4b, 0x2d, 0x9e, 0xd6, 0xf2, 0x3e, 0x35, 0x0e, 0x26, 0x30, 0x23, 0x29, 0x93,
-	0xb2, 0xbe, 0x1b, 0xb5, 0xa6, 0x44, 0x45, 0xa4, 0x78, 0xe4, 0x14, 0xd6, 0xca, 0x43, 0x1b, 0x0d,
-	0xae, 0x4b, 0x98, 0x39, 0xed, 0x3b, 0xd1, 0x10, 0x57, 0x3f, 0x5e, 0x73, 0xdf, 0x85, 0xa6, 0x66,
-	0x67, 0x34, 0x5f, 0x7f, 0x43, 0xb0, 0x1c, 0xf7, 0x93, 0xc1, 0xf0, 0xae, 0xf6, 0x7a, 0xac, 0x26,
-	0xcc, 0xfb, 0xd0, 0xa1, 0xe3, 0x46, 0x34, 0x14, 0x17, 0x5a, 0x37, 0x15, 0xc5, 0xed, 0x1d, 0xd3,
-	0x2f, 0xa3, 0x97, 0xf4, 0x5a, 0xdc, 0x64, 0xdd, 0x8c, 0x49, 0xf2, 0x3b, 0x82, 0x95, 0x22, 0x1f,
-	0x47, 0x6a, 0x77, 0x9f, 0x00, 0xf4, 0x06, 0x5b, 0x8d, 0x6c, 0x74, 0xed, 0x7c, 0xa3, 0x93, 0x76,
-	0x0e, 0xfb, 0xae, 0x2b, 0x26, 0x85, 0x76, 0x86, 0xdb, 0xf4, 0x94, 0xa3, 0x32, 0x82, 0x98, 0x24,
-	0xbf, 0xe4, 0x1c, 0x4d, 0x06, 0x7d, 0x65, 0xf9, 0x6b, 0x0e, 0x4d, 0x88, 0x0d, 0x40, 0x37, 0x37,
-	0x5e, 0xf9, 0xff, 0x8c, 0x60, 0xb5, 0xd0, 0xa5, 0x37, 0x03, 0x1e, 0xf9, 0x03, 0x01, 0x7e, 0xee,
-	0x5c, 0x5c, 0x69, 0x7a, 0xd5, 0xf0, 0xbc, 0x0b, 0xf3, 0x5c, 0x9f, 0x5a, 0x32, 0x64, 0x0d, 0xa4,
-	0x1c, 0x9f, 0xbb, 0x6d, 0xd2, 0x2e, 0xf3, 0x3d, 0x05, 0x94, 0xa2, 0xb2, 0x30, 0xd5, 0xab, 0xcb,
-	0x6c, 0x2a, 0x53, 0x66, 0x8f, 0xa0, 0xd1, 0xb1, 0xb6, 0x65, 0xbb, 0x28, 0xdd, 0xb0, 0x85, 0x69,
-	0xd1, 0x64, 0xe4, 0x7a, 0xad, 0x28, 0xf2, 0x0d, 0x2c, 0xe6, 0xc2, 0x1d, 0x09, 0xfa, 0x87, 0xd0,
-	0x4c, 0xbc, 0xd0, 0xd0, 0x9f, 0x57, 0xe5, 0x9d, 0xc8, 0xcc, 0xb4, 0x1a, 0xe9, 0x8b, 0xfa, 0xe6,
-	0x23, 0x80, 0x5a, 0xc2, 0x8b, 0xb8, 0xbe, 0xd3, 0xcd, 0x15, 0xe5, 0x9a, 0x6b, 0x1b, 0xa6, 0xfd,
-	0x7c, 0x6f, 0xf2, 0x87, 0xec, 0x4d, 0xdf, 0xca, 0x52, 0xc8, 0xd9, 0x1d, 0x6b, 0xdf, 0x1e, 0x62,
-	0xf3, 0x1c, 0x28, 0x92, 0x3f, 0x11, 0x2c, 0x75, 0xbc, 0xd7, 0x4e, 0x44, 0xb9, 0x4f, 0x67, 0x7e,
-	0xd2, 0x8f, 0x6f, 0xef, 0xba, 0xe5, 0x23, 0x69, 0x90, 0x62, 0x93, 0xa9, 0x14, 0x7b, 0x0f, 0x16,
-	0xa4, 0x2d, 0x3d, 0x4f, 0xeb, 0x22, 0x4f, 0xf3, 0x82, 0xca, 0x74, 0xfb, 0x0e, 0xc1, 0x72, 0x81,
-	0xdb, 0xff, 0x6b, 0xd2, 0x78, 0xb0, 0x94, 0x2c, 0x99, 0xae, 0x3b, 0x4c, 0x99, 0x8e, 0xb7, 0x98,
-	0xff, 0xa4, 0x4d, 0x21, 0xcd, 0xe0, 0x9b, 0xe9, 0x51, 0xdb, 0x7f, 0xdd, 0x05, 0xf9, 0x90, 0xc7,
-	0x8f, 0x61, 0xfa, 0x62, 0xf0, 0x5a, 0xc4, 0xcb, 0xf1, 0x2c, 0x4d, 0x3d, 0x96, 0x8d, 0x95, 0x22,
-	0x36, 0x0b, 0xf0, 0x43, 0x68, 0x7c, 0x11, 0xaf, 0x5e, 0x78, 0x51, 0x29, 0xe9, 0x4b, 0xa1, 0xb1,
-	0x94, 0x67, 0xca, 0x73, 0xd7, 0xf1, 0x5c, 0x4f, 0xce, 0xe9, 0x1b, 0x45, 0x72, 0x2e, 0x3d, 0xfe,
-	0x77, 0xa1, 0x69, 0xeb, 0x6f, 0x3d, 0xbc, 0x1a, 0xbf, 0xd6, 0x33, 0xcf, 0x4e, 0xa3, 0x55, 0x2c,
-	0x60, 0x01, 0xfe, 0x18, 0x66, 0x98, 0xf6, 0x44, 0xc2, 0x71, 0x6c, 0x99, 0xe7, 0x9b, 0xb1, 0x5a,
-	0xc8, 0x67, 0x01, 0xfe, 0x1c, 0x56, 0xed, 0xe2, 0xf7, 0x09, 0x7e, 0x90, 0xb1, 0x9a, 0x7f, 0x3c,
-	0x19, 0xe4, 0x36, 0x15, 0x16, 0xe0, 0x53, 0xc0, 0x51, 0x6e, 0x4f, 0xc7, 0x6b, 0xea, 0x64, 0xe1,
-	0x1b, 0xc4, 0x78, 0xab, 0x42, 0xca, 0x02, 0x7c, 0x01, 0x2d, 0xbb, 0x64, 0x09, 0xc4, 0x24, 0xf5,
-	0x97, 0x47, 0xe1, 0x02, 0x6c, 0xbc, 0x7d, 0xab, 0x8e, 0xf4, 0xdb, 0xce, 0x6d, 0x31, 0x89, 0xdf,
-	0x85, 0x4b, 0x58, 0xe2, 0x77, 0xc9, 0xfa, 0x73, 0x06, 0x8b, 0x76, 0x7e, 0xb8, 0xe3, 0xe2, 0x53,
-	0xc9, 0xed, 0xaf, 0x57, 0x89, 0x59, 0x80, 0x9f, 0xc2, 0xdc, 0x55, 0x7a, 0x66, 0xe1, 0xf8, 0x7f,
-	0x9f, 0xfc, 0xe8, 0x36, 0x8c, 0x32, 0x51, 0x12, 0x72, 0x66, 0x08, 0xe8, 0x21, 0xe7, 0xe7, 0x92,
-	0x1e, 0x72, 0xd1, 0xf4, 0x38, 0x86, 0x05, 0x27, 0xdb, 0x1d, 0xf1, 0xfd, 0xb8, 0xa1, 0x15, 0xb4,
-	0x7b, 0x63, 0xad, 0x5c, 0x28, 0xbf, 0x67, 0x67, 0x3b, 0x4f, 0xf2, 0xbd, 0xa2, 0x26, 0x68, 0xac,
-	0x95, 0x0b, 0x59, 0xb0, 0x3b, 0xf7, 0x59, 0x73, 0x53, 0xfe, 0x27, 0xf8, 0x48, 0xfc, 0xbe, 0x9a,
-	0x12, 0x7f, 0xf8, 0x7d, 0xf0, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xac, 0x58, 0xf3, 0xe0, 0x2f,
-	0x14, 0x00, 0x00,
+var fileDescriptor_group_a130b5186d308ee6 = []byte{
+	// 1246 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x4b, 0x6f, 0x23, 0xc5,
+	0x13, 0x57, 0xc7, 0x71, 0x76, 0x5d, 0x89, 0xf3, 0xe8, 0xbc, 0xfc, 0x9f, 0xf5, 0x3f, 0x64, 0x1b,
+	0x69, 0x15, 0x21, 0x64, 0x8b, 0x20, 0xed, 0x81, 0x45, 0xa0, 0x38, 0x8f, 0x5d, 0x6f, 0x36, 0x89,
+	0x32, 0x1b, 0x2e, 0x5c, 0x82, 0x37, 0xd3, 0x19, 0x0d, 0x19, 0xcf, 0x8c, 0xa7, 0xc7, 0x09, 0xe2,
+	0xb2, 0xe2, 0xb2, 0x12, 0xe2, 0x02, 0xe2, 0xca, 0x85, 0x3b, 0x07, 0x0e, 0x9c, 0xb8, 0xf0, 0x39,
+	0xf8, 0x14, 0x7c, 0x05, 0x34, 0xdd, 0x3d, 0xe3, 0x9e, 0x67, 0xb2, 0xb6, 0xc4, 0x5e, 0x2c, 0x75,
+	0x55, 0xf5, 0xd4, 0xfb, 0x57, 0xd5, 0x86, 0x25, 0xd3, 0x77, 0x87, 0x5e, 0x9b, 0xff, 0xb6, 0x3c,
+	0xdf, 0x0d, 0x5c, 0x5c, 0xe5, 0x07, 0xed, 0xe1, 0x89, 0x47, 0x9d, 0xf3, 0xee, 0x51, 0xdb, 0xbb,
+	0x32, 0xdb, 0x9c, 0xd3, 0x66, 0xc6, 0xd5, 0xf9, 0x0d, 0x6b, 0xdf, 0x30, 0x21, 0x49, 0x3e, 0x03,
+	0xd8, 0x75, 0xfb, 0x7d, 0xd7, 0xd1, 0x29, 0xf3, 0x70, 0x03, 0xee, 0xed, 0xfb, 0xfe, 0xae, 0x6b,
+	0xd0, 0x06, 0xda, 0x44, 0x5b, 0x55, 0x3d, 0x3a, 0xe2, 0x35, 0x98, 0xd9, 0xf7, 0xfd, 0x23, 0x66,
+	0x36, 0xa6, 0x36, 0xd1, 0x56, 0x4d, 0x97, 0x27, 0xf2, 0x1c, 0xf0, 0xd3, 0x50, 0xd7, 0x8e, 0x61,
+	0x1c, 0xd1, 0xfe, 0x2b, 0xea, 0x77, 0x9d, 0x4b, 0x37, 0x94, 0xfe, 0x82, 0x51, 0xbf, 0xbb, 0xc7,
+	0x3f, 0x53, 0xd3, 0xe5, 0x09, 0x37, 0xa1, 0xa6, 0xbb, 0x36, 0x7d, 0x41, 0xaf, 0xa9, 0xcd, 0x3f,
+	0x54, 0xd5, 0x47, 0x04, 0xf2, 0x0f, 0x82, 0xf9, 0x5d, 0x9f, 0xf6, 0x02, 0xca, 0x3f, 0xa9, 0xd3,
+	0x01, 0xde, 0x81, 0xf9, 0xae, 0x63, 0x05, 0xe2, 0xd3, 0x2f, 0x2c, 0x16, 0x34, 0xd0, 0x66, 0x65,
+	0x6b, 0x76, 0xfb, 0x7f, 0x2d, 0xe1, 0x6e, 0x56, 0xb7, 0x9e, 0xba, 0x80, 0x3f, 0x81, 0x1a, 0x97,
+	0x0a, 0x99, 0x5c, 0xe7, 0xec, 0x76, 0xb3, 0xc5, 0xa8, 0x7f, 0x4d, 0xfd, 0xf3, 0x9e, 0x67, 0x9d,
+	0x7b, 0x3d, 0xbf, 0xd7, 0x67, 0xad, 0x58, 0x46, 0x1f, 0x89, 0xe3, 0x4d, 0x98, 0x3d, 0xf1, 0xa8,
+	0xdf, 0x0b, 0x2c, 0xd7, 0xe9, 0xee, 0x35, 0x2a, 0xdc, 0x19, 0x95, 0x84, 0x35, 0xb8, 0x7f, 0xe2,
+	0x49, 0x5f, 0xa7, 0x39, 0x3b, 0x3e, 0xf3, 0xdb, 0x37, 0x0e, 0xf5, 0x25, 0xbb, 0x2a, 0x6f, 0x8f,
+	0x48, 0xe4, 0x35, 0x2c, 0x24, 0x1c, 0x1e, 0x27, 0x05, 0x49, 0x07, 0x2b, 0x6f, 0xe5, 0x20, 0xf1,
+	0x61, 0xf1, 0x29, 0x0d, 0xf8, 0x99, 0x71, 0x1e, 0x1d, 0x84, 0x66, 0x0b, 0x81, 0xbd, 0x38, 0xe0,
+	0x35, 0x5d, 0x25, 0xa5, 0xc3, 0x32, 0x55, 0x1e, 0x96, 0x4a, 0x32, 0x2c, 0xe4, 0x7b, 0x04, 0x4b,
+	0x29, 0xa5, 0x63, 0xf9, 0xdd, 0x81, 0x7a, 0xec, 0x08, 0xb7, 0xb4, 0xc2, 0x4b, 0xa3, 0xdc, 0xf7,
+	0xe4, 0x15, 0xf2, 0x03, 0x82, 0x85, 0x97, 0xd2, 0x96, 0xc8, 0xff, 0x44, 0x3c, 0xd1, 0xdb, 0x15,
+	0x8c, 0xea, 0xf7, 0x54, 0x4e, 0x39, 0x94, 0x16, 0x13, 0xd9, 0x87, 0xc5, 0xa4, 0x31, 0xcc, 0xc3,
+	0x1f, 0xa9, 0x0d, 0x2a, 0xcd, 0x59, 0x92, 0xd5, 0x3f, 0x62, 0xe8, 0x8a, 0x10, 0xf9, 0x16, 0xb4,
+	0x28, 0xbe, 0x3b, 0x9e, 0x67, 0x5b, 0x17, 0xfc, 0xfb, 0xa1, 0xbf, 0xa1, 0x7b, 0xaa, 0x89, 0xa8,
+	0xdc, 0xc4, 0x9c, 0xc4, 0x6e, 0x00, 0x1c, 0xf8, 0x6e, 0x3f, 0x91, 0x5a, 0x85, 0x42, 0x7e, 0x41,
+	0xf0, 0xa0, 0x50, 0xf9, 0x58, 0x69, 0x3e, 0x84, 0xc5, 0x08, 0x0e, 0x86, 0x94, 0x05, 0x4a, 0xa6,
+	0xdf, 0x2b, 0xca, 0x8a, 0x14, 0xd5, 0x33, 0x17, 0xc9, 0x5f, 0x08, 0x56, 0xcf, 0xfc, 0x9e, 0xc3,
+	0x2e, 0xa9, 0xcf, 0x99, 0xbc, 0x1b, 0xc3, 0xb0, 0x34, 0xe0, 0x9e, 0x2c, 0x71, 0x19, 0x95, 0xe8,
+	0x88, 0x1f, 0xc1, 0xfc, 0x89, 0x6d, 0xa8, 0x9d, 0x2c, 0x0c, 0x4c, 0x51, 0x43, 0xb9, 0x63, 0x7a,
+	0xa3, 0xca, 0x89, 0xf0, 0xa4, 0xa8, 0xe9, 0x20, 0x4f, 0x97, 0x77, 0x4f, 0x35, 0xd5, 0x3d, 0x87,
+	0xb0, 0x96, 0xe7, 0xc0, 0x78, 0x95, 0xf2, 0x06, 0xc1, 0xdc, 0x73, 0xd7, 0x72, 0x62, 0xbc, 0x2d,
+	0x8e, 0xc2, 0x06, 0x80, 0x4e, 0x07, 0x47, 0x94, 0xb1, 0x9e, 0x49, 0x65, 0x04, 0x14, 0x4a, 0x59,
+	0xc7, 0xdf, 0xee, 0x31, 0xe9, 0x40, 0x5d, 0xb1, 0x63, 0x3c, 0x67, 0xfe, 0x0e, 0x4b, 0x2f, 0x55,
+	0x77, 0x21, 0xc3, 0x75, 0x18, 0x95, 0xb8, 0xa6, 0x5a, 0x81, 0xca, 0xe3, 0x9e, 0xee, 0x5e, 0x25,
+	0x32, 0x95, 0x4c, 0x64, 0x94, 0x96, 0x98, 0x4e, 0xb7, 0x44, 0xc8, 0x7f, 0xd6, 0x73, 0x0c, 0x9b,
+	0x1a, 0x61, 0x71, 0x8b, 0x7c, 0x2a, 0x14, 0x4c, 0x60, 0x4e, 0x9c, 0x74, 0xca, 0x86, 0x76, 0xd0,
+	0x98, 0xe1, 0x7d, 0x91, 0xa0, 0x91, 0x53, 0x68, 0x16, 0xbb, 0x36, 0x5e, 0xb8, 0x2e, 0x61, 0xee,
+	0x74, 0x68, 0x05, 0x77, 0x48, 0xfd, 0x64, 0x70, 0xdf, 0x81, 0xba, 0xa2, 0x67, 0x3c, 0x5b, 0x7f,
+	0x45, 0xb0, 0x1a, 0xa1, 0xca, 0x68, 0xb4, 0x97, 0x5b, 0x3d, 0x11, 0x14, 0x87, 0x68, 0x74, 0x60,
+	0xd9, 0x01, 0xf5, 0x79, 0x42, 0xab, 0xba, 0x3c, 0x85, 0xfa, 0x8e, 0xe9, 0x37, 0xc1, 0x4b, 0x3a,
+	0xe0, 0x99, 0xac, 0xea, 0xd1, 0x91, 0xfc, 0x86, 0x60, 0x2d, 0xcf, 0xc6, 0xb1, 0x40, 0xef, 0x00,
+	0xa0, 0x3f, 0xda, 0x79, 0x04, 0xdc, 0x3d, 0x2a, 0x82, 0x3b, 0xa1, 0xed, 0x60, 0x68, 0xdb, 0x7c,
+	0x6a, 0x28, 0x37, 0x43, 0xcd, 0x8e, 0x34, 0x57, 0xf8, 0x11, 0x1d, 0xc9, 0x8f, 0x19, 0x73, 0xe3,
+	0x05, 0xa0, 0x14, 0x04, 0x14, 0xb3, 0xa6, 0xf8, 0x66, 0xa0, 0xaa, 0x9b, 0x0c, 0x04, 0x7e, 0x46,
+	0xb0, 0x9e, 0x6b, 0xd2, 0xbb, 0x0c, 0x21, 0xf9, 0x1d, 0x01, 0x3e, 0xb4, 0x2e, 0xae, 0x14, 0xb9,
+	0xf2, 0x20, 0x7d, 0x00, 0x8b, 0xa1, 0x3c, 0x35, 0x84, 0xe3, 0x4a, 0xa8, 0x32, 0xf4, 0xd0, 0x78,
+	0x9d, 0xf6, 0x98, 0xeb, 0xc8, 0x70, 0xc9, 0x53, 0x3a, 0x58, 0xd5, 0xf2, 0x96, 0x9b, 0x49, 0xb5,
+	0xdc, 0x13, 0xa8, 0x75, 0x8d, 0x6d, 0x01, 0x1d, 0x85, 0xbb, 0x38, 0x57, 0xcd, 0x01, 0x47, 0x2c,
+	0xe2, 0xf2, 0x44, 0x5e, 0xc3, 0x72, 0xc6, 0xdd, 0xb1, 0x12, 0xf0, 0x18, 0xea, 0xb1, 0x15, 0x4a,
+	0x0e, 0x16, 0x65, 0xab, 0xc7, 0x3c, 0x3d, 0x29, 0x46, 0x86, 0xbc, 0xd7, 0xc3, 0x71, 0x40, 0x0d,
+	0x6e, 0x45, 0xd4, 0xeb, 0x49, 0xa0, 0x45, 0x19, 0xa0, 0xdd, 0x84, 0x59, 0x37, 0x8b, 0x53, 0xee,
+	0x1d, 0x71, 0xea, 0x8d, 0x68, 0x88, 0x8c, 0xde, 0x89, 0x76, 0xf2, 0x3b, 0xef, 0xa5, 0x23, 0x71,
+	0xf2, 0x07, 0x82, 0x95, 0xae, 0x73, 0x6d, 0x05, 0x34, 0xb4, 0xec, 0xcc, 0x8d, 0x11, 0xfa, 0x76,
+	0x1c, 0x2e, 0x1e, 0x52, 0xa3, 0x42, 0x9b, 0x4e, 0x14, 0xda, 0x87, 0xb0, 0x24, 0x74, 0xa9, 0xd5,
+	0x5a, 0xe5, 0xd5, 0x9a, 0x65, 0x94, 0x16, 0xdd, 0x77, 0x08, 0x56, 0x73, 0xcc, 0xfe, 0x4f, 0x4b,
+	0xc7, 0x81, 0x95, 0x78, 0xf9, 0xb4, 0xed, 0xbb, 0x34, 0xeb, 0x64, 0x0b, 0xfb, 0x4f, 0xca, 0x5c,
+	0x52, 0x14, 0xbe, 0x4b, 0xbc, 0xda, 0xfe, 0xf3, 0x3e, 0x88, 0xe7, 0x3f, 0xfe, 0x14, 0x66, 0x2f,
+	0x46, 0xaf, 0x4b, 0xbc, 0x1a, 0xcd, 0xd8, 0xc4, 0x13, 0x5b, 0x5b, 0xcb, 0x23, 0x33, 0x0f, 0x3f,
+	0x86, 0xda, 0xd7, 0xd1, 0x4a, 0x86, 0x97, 0xa5, 0x90, 0xba, 0x2c, 0x6a, 0x2b, 0x59, 0xa2, 0xb8,
+	0x37, 0x88, 0xe6, 0x7d, 0x7c, 0x4f, 0xdd, 0x34, 0xe2, 0x7b, 0xc9, 0xb5, 0xa0, 0x03, 0x75, 0x53,
+	0x7d, 0x15, 0xe2, 0xf5, 0xe8, 0x8d, 0x9f, 0x7a, 0xa0, 0x6a, 0x8d, 0x7c, 0x06, 0xf3, 0xf0, 0xe7,
+	0x30, 0xc7, 0x94, 0x07, 0x14, 0x8e, 0x7c, 0x4b, 0x3d, 0xf1, 0xb4, 0xf5, 0x5c, 0x3a, 0xf3, 0xf0,
+	0x57, 0xb0, 0x6e, 0xe6, 0xbf, 0x5e, 0xf0, 0xc3, 0x94, 0xd6, 0xec, 0xd3, 0x4a, 0x23, 0xb7, 0x89,
+	0x30, 0x0f, 0x9f, 0x02, 0x0e, 0x32, 0xfb, 0x3b, 0x6e, 0xca, 0x9b, 0xb9, 0x6f, 0x13, 0xed, 0xff,
+	0x25, 0x5c, 0xe6, 0xe1, 0x0b, 0x68, 0x98, 0x05, 0xcb, 0x21, 0x26, 0x89, 0x3f, 0x4a, 0x72, 0x17,
+	0x63, 0xed, 0xfd, 0x5b, 0x65, 0x84, 0xdd, 0x66, 0x66, 0xbb, 0x89, 0xed, 0xce, 0x5d, 0xce, 0x62,
+	0xbb, 0x0b, 0xd6, 0xa2, 0x33, 0x58, 0x36, 0xb3, 0xe3, 0x1e, 0xe7, 0xdf, 0x8a, 0xb3, 0xbf, 0x51,
+	0xc6, 0x66, 0x1e, 0x7e, 0x06, 0x0b, 0x57, 0xc9, 0xf9, 0x85, 0xa3, 0x7f, 0x8b, 0xb2, 0x63, 0x5c,
+	0xd3, 0x8a, 0x58, 0xb1, 0xcb, 0xa9, 0x81, 0xa0, 0xba, 0x9c, 0x9d, 0x51, 0xaa, 0xcb, 0x79, 0x93,
+	0xe4, 0x18, 0x96, 0xac, 0x34, 0x46, 0xe2, 0x07, 0x11, 0xac, 0xe5, 0x80, 0xbe, 0xd6, 0x2c, 0x66,
+	0x8a, 0xef, 0x99, 0x69, 0xfc, 0x89, 0xbf, 0x97, 0x07, 0x85, 0x5a, 0xb3, 0x98, 0xc9, 0xbc, 0xce,
+	0xc2, 0x97, 0xf5, 0x96, 0xf8, 0x27, 0xf1, 0x09, 0xff, 0x7d, 0x35, 0xc3, 0xff, 0x26, 0xfc, 0xf8,
+	0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf6, 0x24, 0x19, 0x44, 0x65, 0x14, 0x00, 0x00,
 }

pkg/proto/group/group.proto

@@ -16,7 +16,7 @@ message GroupAddMemberInfo{
 
 message CreateGroupReq{
   repeated GroupAddMemberInfo InitMemberList = 1;
-  open_im_sdk.GroupInfo GroupInfo = 2;
+  server_api_params.GroupInfo GroupInfo = 2;
   string OperationID = 3;
   string OpUserID = 4;  //app manager or group owner
   string OwnerUserID = 5; //owner
@@ -24,7 +24,7 @@ message CreateGroupReq{
 message CreateGroupResp{
   int32   ErrCode = 1;
   string  ErrMsg = 2;
-  open_im_sdk.GroupInfo GroupInfo = 3;
+  server_api_params.GroupInfo GroupInfo = 3;
 }
 
 
@@ -36,12 +36,12 @@ message GetGroupsInfoReq{
 message GetGroupsInfoResp{
   int32   ErrCode = 1;
   string  ErrMsg = 2;
-  repeated open_im_sdk.GroupInfo GroupInfoList = 3;
+  repeated server_api_params.GroupInfo GroupInfoList = 3;
 }
 
 
 message SetGroupInfoReq{
-  open_im_sdk.GroupInfo GroupInfo = 1;
+  server_api_params.GroupInfo GroupInfo = 1;
   string OpUserID = 2; //app manager or group owner
   string OperationID = 3;
 }
@@ -58,7 +58,7 @@ message GetGroupApplicationListReq {
 message GetGroupApplicationListResp {
   int32   ErrCode = 1;
   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 {
   int32   ErrCode = 1;
   string  ErrMsg = 2;
-  repeated open_im_sdk.GroupMemberFullInfo memberList = 3;
+  repeated server_api_params.GroupMemberFullInfo memberList = 3;
   int32 nextSeq = 4;
 }
 
@@ -135,7 +135,7 @@ message GetGroupMembersInfoReq {
 message GetGroupMembersInfoResp {
   int32   ErrCode = 1;
   string  ErrMsg = 2;
-  repeated open_im_sdk.GroupMemberFullInfo memberList = 3;
+  repeated server_api_params.GroupMemberFullInfo memberList = 3;
 }
 
 message KickGroupMemberReq {
@@ -166,7 +166,7 @@ message GetJoinedGroupListReq {
 message GetJoinedGroupListResp{
   int32   ErrCode = 1;
   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 {
   int32   ErrCode = 1;
   string  ErrMsg = 2;
-  repeated open_im_sdk.GroupMemberFullInfo memberList = 3;
+  repeated server_api_params.GroupMemberFullInfo memberList = 3;
 }
 
 

pkg/proto/push/push.pb.go

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

pkg/proto/push/push.proto

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

pkg/proto/relay/relay.pb.go

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

pkg/proto/relay/relay.proto

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

pkg/proto/sdk_ws/ws.proto

@@ -1,5 +1,5 @@
 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
 
 ////////////////////////////////base///////////////////////////////
@@ -75,8 +75,8 @@ message BlackInfo{
 }
 
 message GroupRequest{
-  string userID = 1;
-  string groupID = 2;
+  PublicUserInfo userInfo = 1;
+  GroupInfo groupInfo = 2;
   string handleResult = 3;
   string reqMsg = 4;
   string  handleMsg = 5;
@@ -87,15 +87,21 @@ message GroupRequest{
 }
 
 message FriendRequest{
-  string  fromUserID = 1;
-  string toUserID = 2;
-  int32 handleResult = 3;
-  string reqMsg = 4;
-  uint32 createTime = 5;
-  string handlerUserID = 6;
-  string handleMsg = 7;
-  uint32 handleTime = 8;
-  string ex = 9;
+  string fromUserID = 1;
+  string fromNickname = 2;
+  string fromFaceURL = 3;
+  int32 fromGender = 4;
+  string toUserID = 5;
+  string toNickname = 6;
+  string toFaceURL = 7;
+  int32 toGender = 8;
+  int32 handleResult = 9;
+  string reqMsg = 10;
+  uint32 createTime = 11;
+  string handlerUserID = 12;
+  string handleMsg = 13;
+  uint32 handleTime = 14;
+  string ex = 15;
 }
 
 ///////////////////////////////////base end/////////////////////////////////////
@@ -217,27 +223,64 @@ message TipsComm{
 }
 
 //////////////////////group/////////////////////
-//Actively join the group
-message MemberEnterTips{
-  GroupInfo group = 1;
-  GroupMemberFullInfo entrantUser = 2;
-  int64 operationTime = 3;
-}
 
-//Actively leave the group
-message MemberLeaveTips{
-  GroupInfo group = 1;
-  GroupMemberFullInfo leaverUser = 2;
-  int64 operationTime = 3;
-}
 
-message MemberInvitedTips{
+//	OnGroupCreated()
+message GroupCreatedTips{
   GroupInfo group = 1;
   GroupMemberFullInfo opUser = 2;
-  repeated GroupMemberFullInfo invitedUserList = 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
+message MemberQuitTips{
+  GroupInfo group = 1;
+  GroupMemberFullInfo quitUser = 2;
+  int64 operationTime = 3;
+}
+
+
+//	OnApplicationGroupAccepted()
+message GroupApplicationAcceptedTips{
+  GroupInfo group = 1;
+  GroupMemberFullInfo opUser = 2;
+  string  handleMsg = 4;
+}
+
+//	OnApplicationGroupRejected()
+message GroupApplicationRejectedTips{
+  GroupInfo group = 1;
+  GroupMemberFullInfo opUser = 2;
+  string  handleMsg = 4;
+}
+
+//	OnTransferGroupOwner()
+message GroupOwnerTransferredTips{
+  GroupInfo group = 1;
+  GroupMemberFullInfo opUser = 2;
+  GroupMemberFullInfo newGroupOwner = 3;
   int64 operationTime = 4;
 }
 
+
+//	OnMemberKicked()
 message MemberKickedTips{
   GroupInfo group = 1;
   GroupMemberFullInfo opUser = 2;
@@ -245,39 +288,30 @@ message MemberKickedTips{
   int64 operationTime = 4;
 }
 
-message MemberInfoChangedTips{
-  int32 changeType = 1; ///bitwise operators 0001:member info changed; 0010:mute ;
-  GroupMemberFullInfo opUser = 2; //who do this
-  GroupMemberFullInfo finalInfo = 3; //
-  int64 muteTime = 4;
-  GroupInfo group = 5;
-}
-
-message GroupCreatedTips{
+//	OnMemberInvited()
+message MemberInvitedTips{
   GroupInfo group = 1;
-  GroupMemberFullInfo creator = 2;
-  repeated GroupMemberFullInfo memberList = 3;
+  GroupMemberFullInfo opUser = 2;
+  repeated GroupMemberFullInfo invitedUserList = 3;
   int64 operationTime = 4;
 }
 
-message GroupInfoChangedTips{
-  int32 changedType = 1; //bitwise operators: 0001:groupName; 0010:Notification  0100:Introduction; 1000:FaceUrl
-  GroupInfo group = 2;
-  GroupMemberFullInfo opUser = 3;
+//Actively join the group
+message MemberEnterTips{
+  GroupInfo group = 1;
+  GroupMemberFullInfo entrantUser = 2;
+  int64 operationTime = 3;
 }
 
-message JoinGroupApplicationTips{
-  GroupInfo group = 1;
-  PublicUserInfo applicant = 2;
-  string  reason = 3;
-}
 
-message ApplicationProcessedTips{
-  GroupInfo group = 1;
-  GroupMemberFullInfo opUser = 2;
-  int32 result = 3;
-  string  reason = 4;
-}
+
+
+
+
+
+
+
+
 
 //////////////////////friend/////////////////////
 //message FriendInfo{
@@ -299,15 +333,23 @@ message FromToUserID{
 }
 
 //FromUserID apply to add ToUserID
-message FriendApplicationAddedTips{
+message FriendApplicationTips{
   FromToUserID fromToUserID = 1;
 }
 
 //FromUserID accept or reject ToUserID
-message FriendApplicationProcessedTips{
+message FriendApplicationApprovedTips{
   FromToUserID fromToUserID = 1;
+  string handleMsg = 2;
 }
 
+//FromUserID accept or reject ToUserID
+message FriendApplicationRejectedTips{
+  FromToUserID fromToUserID = 1;
+   string handleMsg = 2;
+}
+
+
 // FromUserID  Added a friend ToUserID
 message FriendAddedTips{
   FriendInfo friend = 1;
@@ -335,6 +377,6 @@ message FriendInfoChangedTips{
   FromToUserID fromToUserID = 1;
 }
 //////////////////////user/////////////////////
-message SelfInfoUpdatedTips{
+message UserInfoUpdatedTips{
   string userID = 1;
 }

pkg/proto/user/user.pb.go

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

pkg/proto/user/user.proto

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

pkg/utils/strings.go

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

pkg/utils/utils.go

@@ -5,6 +5,7 @@ import (
 	"github.com/pkg/errors"
 	"runtime"
 	"strconv"
+	"strings"
 )
 
 // copy a by b  b->a
@@ -24,3 +25,15 @@ func printCallerNameAndLine() string {
 	pc, _, line, _ := runtime.Caller(2)
 	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:]
+}