Merge branch 'superGroup' into tuoyun

# Conflicts:
#	internal/push/logic/push_to_client.go

internal/api/auth/auth.go

@@ -36,7 +36,13 @@ func UserRegister(c *gin.Context) {
 	//copier.Copy(req.UserInfo, &params)
 	req.OperationID = params.OperationID
 	log.NewInfo(req.OperationID, "UserRegister args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewAuthClient(etcdConn)
 	reply, err := client.UserRegister(context.Background(), req)
 	if err != nil {
@@ -84,7 +90,13 @@ func UserToken(c *gin.Context) {
 	}
 	req := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID}
 	log.NewInfo(req.OperationID, "UserToken args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewAuthClient(etcdConn)
 	reply, err := client.UserToken(context.Background(), req)
 	if err != nil {
@@ -124,3 +136,46 @@ func ParseToken(c *gin.Context) {
 	log.NewInfo(params.OperationID, "ParseToken return ", resp)
 	c.JSON(http.StatusOK, resp)
 }
+
+func ForceLogout(c *gin.Context) {
+	params := api.ForceLogoutReq{}
+	if err := c.BindJSON(&params); err != nil {
+		errMsg := " BindJSON failed " + err.Error()
+		log.NewError("0", errMsg)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
+		return
+	}
+
+	req := &rpc.ForceLogoutReq{}
+	utils.CopyStructFields(req, &params)
+
+	var ok bool
+	var errInfo string
+	ok, req.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, "ForceLogout args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := rpc.NewAuthClient(etcdConn)
+	reply, err := client.ForceLogout(context.Background(), req)
+	if err != nil {
+		errMsg := req.OperationID + " UserToken failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	resp := api.ForceLogoutResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(params.OperationID, utils.GetSelfFuncName(), " return ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/chat/del_msg.go

@@ -5,8 +5,9 @@ import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbChat "Open_IM/pkg/proto/chat"
+	rpc "Open_IM/pkg/proto/chat"
 	pbCommon "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"context"
@@ -29,8 +30,14 @@ func DelMsg(c *gin.Context) {
 	if err := utils.CopyStructFields(&reqPb, &req); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields", err.Error())
 	}
-	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
-	msgClient := pbChat.NewChatClient(grpcConn)
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, req.OperationID)
+	if grpcConn == nil {
+		errMsg := req.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	msgClient := rpc.NewChatClient(grpcConn)
 	respPb, err := msgClient.DelMsgList(context.Background(), &reqPb)
 	if err != nil {
 		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelMsgList failed", err.Error(), reqPb)
@@ -42,3 +49,47 @@ func DelMsg(c *gin.Context) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp)
 	c.JSON(http.StatusOK, resp)
 }
+
+func ClearMsg(c *gin.Context) {
+	params := api.CleanUpMsgReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	//
+	req := &rpc.ClearMsgReq{}
+	utils.CopyStructFields(req, &params)
+
+	var ok bool
+	var errInfo string
+	ok, req.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := rpc.NewChatClient(etcdConn)
+	RpcResp, err := client.ClearMsg(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, " CleanUpMsg failed ", err.Error(), req.String(), RpcResp.ErrMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": RpcResp.ErrMsg})
+		return
+	}
+
+	resp := api.CleanUpMsgResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/chat/get_max_min_seq.go

@@ -5,7 +5,8 @@ import (
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbMsg "Open_IM/pkg/proto/chat"
+	pbChat "Open_IM/pkg/proto/chat"
+	sdk_ws "Open_IM/pkg/proto/sdk_ws"
 	"context"
 	"github.com/gin-gonic/gin"
 	"net/http"
@@ -31,11 +32,18 @@ func GetSeq(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()})
 		return
 	}
-	pbData := pbMsg.GetMaxAndMinSeqReq{}
+	pbData := sdk_ws.GetMaxAndMinSeqReq{}
 	pbData.UserID = params.SendID
 	pbData.OperationID = params.OperationID
-	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
-	msgClient := pbMsg.NewChatClient(grpcConn)
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, pbData.OperationID)
+	if grpcConn == nil {
+		errMsg := pbData.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(pbData.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	msgClient := pbChat.NewChatClient(grpcConn)
 	reply, err := msgClient.GetMaxAndMinSeq(context.Background(), &pbData)
 	if err != nil {
 		log.NewError(params.OperationID, "UserGetSeq rpc failed, ", params, err.Error())

internal/api/chat/pull_msg.go

@@ -51,7 +51,13 @@ func PullMsgBySeqList(c *gin.Context) {
 	pbData.OperationID = params.OperationID
 	pbData.SeqList = params.SeqList
 
-	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, pbData.OperationID)
+	if grpcConn == nil {
+		errMsg := pbData.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(pbData.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	msgClient := pbChat.NewChatClient(grpcConn)
 	reply, err := msgClient.PullMessageBySeqList(context.Background(), &pbData)
 	if err != nil {

internal/api/chat/send_msg.go

@@ -69,9 +69,15 @@ func SendMsg(c *gin.Context) {
 	token := c.Request.Header.Get("token")
 	log.NewInfo(params.OperationID, "api call success to sendMsgReq", params)
 	pbData := newUserSendMsgReq(token, &params)
-	log.Info("", "", "api SendMsg call start..., [data: %s]", pbData.String())
+	log.Info(params.OperationID, "", "api SendMsg call start..., [data: %s]", pbData.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, params.OperationID)
+	if etcdConn == nil {
+		errMsg := params.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(params.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbChat.NewChatClient(etcdConn)
 
 	log.Info("", "", "api SendMsg call, api call rpc...")
@@ -82,7 +88,7 @@ func SendMsg(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "SendMsg rpc failed, " + err.Error()})
 		return
 	}
-	log.Info("", "", "api SendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
+	log.Info(params.OperationID, "", "api SendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
 
 	c.JSON(http.StatusOK, gin.H{
 		"errCode": reply.ErrCode,

internal/api/conversation/conversation.go

@@ -32,7 +32,13 @@ func SetConversation(c *gin.Context) {
 	if err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbUser.NewUserClient(etcdConn)
 	respPb, err := client.SetConversation(context.Background(), &reqPb)
 	if err != nil {
@@ -63,7 +69,13 @@ func ModifyConversationField(c *gin.Context) {
 	if err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbConversation.NewConversationClient(etcdConn)
 	respPb, err := client.ModifyConversationField(context.Background(), &reqPb)
 	if err != nil {
@@ -92,7 +104,13 @@ func BatchSetConversations(c *gin.Context) {
 	if err := utils.CopyStructFields(&reqPb, req); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbUser.NewUserClient(etcdConn)
 	respPb, err := client.BatchSetConversations(context.Background(), &reqPb)
 	if err != nil {
@@ -124,7 +142,13 @@ func GetAllConversations(c *gin.Context) {
 	if err := utils.CopyStructFields(&reqPb, req); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbUser.NewUserClient(etcdConn)
 	respPb, err := client.GetAllConversations(context.Background(), &reqPb)
 	if err != nil {
@@ -156,7 +180,13 @@ func GetConversation(c *gin.Context) {
 	if err := utils.CopyStructFields(&reqPb, req); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbUser.NewUserClient(etcdConn)
 	respPb, err := client.GetConversation(context.Background(), &reqPb)
 	if err != nil {
@@ -188,7 +218,13 @@ func GetConversations(c *gin.Context) {
 	if err := utils.CopyStructFields(&reqPb, req); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbUser.NewUserClient(etcdConn)
 	respPb, err := client.GetConversations(context.Background(), &reqPb)
 	if err != nil {
@@ -220,7 +256,13 @@ func SetRecvMsgOpt(c *gin.Context) {
 	if err := utils.CopyStructFields(&reqPb, req); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbUser.NewUserClient(etcdConn)
 	respPb, err := client.SetRecvMsgOpt(context.Background(), &reqPb)
 	if err != nil {

internal/api/friend/friend.go

@@ -36,7 +36,7 @@ func AddBlack(c *gin.Context) {
 	}
 	log.NewInfo(params.OperationID, "AddBlacklist args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.AddBlacklist(context.Background(), req)
 	if err != nil {
@@ -69,8 +69,14 @@ func ImportFriend(c *gin.Context) {
 	}
 
 	log.NewInfo(req.OperationID, "ImportFriend args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.ImportFriend(context.Background(), req)
 	if err != nil {
@@ -114,7 +120,13 @@ func AddFriend(c *gin.Context) {
 
 	log.NewInfo(req.CommID.OperationID, "AddFriend args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.AddFriend(context.Background(), req)
 	if err != nil {
@@ -153,7 +165,14 @@ func AddFriendResponse(c *gin.Context) {
 	utils.CopyStructFields(req, &params)
 	log.NewInfo(req.CommID.OperationID, "AddFriendResponse args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.AddFriendResponse(context.Background(), req)
 	if err != nil {
@@ -189,7 +208,13 @@ func DeleteFriend(c *gin.Context) {
 
 	log.NewInfo(req.CommID.OperationID, "DeleteFriend args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.DeleteFriend(context.Background(), req)
 	if err != nil {
@@ -225,7 +250,13 @@ func GetBlacklist(c *gin.Context) {
 
 	log.NewInfo(req.CommID.OperationID, "GetBlacklist args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.GetBlacklist(context.Background(), req)
 	if err != nil {
@@ -268,7 +299,13 @@ func SetFriendRemark(c *gin.Context) {
 
 	log.NewInfo(req.CommID.OperationID, "SetFriendComment args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.SetFriendRemark(context.Background(), req)
 	if err != nil {
@@ -303,7 +340,14 @@ func RemoveBlack(c *gin.Context) {
 	}
 
 	log.NewInfo(req.CommID.OperationID, "RemoveBlacklist args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.RemoveBlacklist(context.Background(), req)
 	if err != nil {
@@ -338,7 +382,13 @@ func IsFriend(c *gin.Context) {
 
 	log.NewInfo(req.CommID.OperationID, "IsFriend args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.IsFriend(context.Background(), req)
 	if err != nil {
@@ -375,7 +425,13 @@ func GetFriendList(c *gin.Context) {
 
 	log.NewInfo(req.CommID.OperationID, "GetFriendList args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.GetFriendList(context.Background(), req)
 	if err != nil {
@@ -413,7 +469,13 @@ func GetFriendApplyList(c *gin.Context) {
 
 	log.NewInfo(req.CommID.OperationID, "GetFriendApplyList args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewFriendClient(etcdConn)
 
 	RpcResp, err := client.GetFriendApplyList(context.Background(), req)
@@ -451,7 +513,13 @@ func GetSelfFriendApplyList(c *gin.Context) {
 
 	log.NewInfo(req.CommID.OperationID, "GetSelfApplyList args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewFriendClient(etcdConn)
 	RpcResp, err := client.GetSelfApplyList(context.Background(), req)
 	if err != nil {

internal/api/group/group.go

@@ -43,7 +43,13 @@ func KickGroupMember(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "KickGroupMember args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	RpcResp, err := client.KickGroupMember(context.Background(), req)
 	if err != nil {
@@ -88,7 +94,13 @@ func GetGroupMembersInfo(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "GetGroupMembersInfo args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 
 	RpcResp, err := client.GetGroupMembersInfo(context.Background(), req)
@@ -126,7 +138,13 @@ func GetGroupMemberList(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "GetGroupMemberList args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 
 	RpcResp, err := client.GetGroupMemberList(context.Background(), req)
@@ -165,7 +183,13 @@ func GetGroupAllMemberList(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "GetGroupAllMember args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	RpcResp, err := client.GetGroupAllMember(context.Background(), req)
 	if err != nil {
@@ -202,7 +226,13 @@ func GetJoinedGroupList(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "GetJoinedGroupList args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	RpcResp, err := client.GetJoinedGroupList(context.Background(), req)
 	if err != nil {
@@ -239,7 +269,13 @@ func InviteUserToGroup(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "InviteUserToGroup args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	RpcResp, err := client.InviteUserToGroup(context.Background(), req)
 	if err != nil {
@@ -291,7 +327,13 @@ func CreateGroup(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "CreateGroup args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	RpcResp, err := client.CreateGroup(context.Background(), req)
 	if err != nil {
@@ -328,7 +370,13 @@ func GetRecvGroupApplicationList(c *gin.Context) {
 	//}
 	log.NewInfo(req.OperationID, "GetGroupApplicationList args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	reply, err := client.GetGroupApplicationList(context.Background(), req)
 	if err != nil {
@@ -359,7 +407,13 @@ func GetUserReqGroupApplicationList(c *gin.Context) {
 	//	return
 	//}
 	log.NewInfo(req.OperationID, "GetGroupsInfo args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	RpcResp, err := client.GetUserReqApplicationList(context.Background(), req)
 	if err != nil {
@@ -395,7 +449,13 @@ func GetGroupsInfo(c *gin.Context) {
 	}
 
 	log.NewInfo(req.OperationID, "GetGroupsInfo args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	RpcResp, err := client.GetGroupsInfo(context.Background(), req)
 	if err != nil {
@@ -433,7 +493,13 @@ func ApplicationGroupResponse(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "ApplicationGroupResponse args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	reply, err := client.GroupApplicationResponse(context.Background(), req)
 	if err != nil {
@@ -468,7 +534,13 @@ func JoinGroup(c *gin.Context) {
 	}
 
 	log.NewInfo(req.OperationID, "JoinGroup args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 
 	RpcResp, err := client.JoinGroup(context.Background(), req)
@@ -504,7 +576,13 @@ func QuitGroup(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "QuitGroup args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	RpcResp, err := client.QuitGroup(context.Background(), req)
 	if err != nil {
@@ -540,7 +618,13 @@ func SetGroupInfo(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "SetGroupInfo args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	RpcResp, err := client.SetGroupInfo(context.Background(), req)
 	if err != nil {
@@ -575,7 +659,13 @@ func TransferGroupOwner(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, "TransferGroupOwner args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	reply, err := client.TransferGroupOwner(context.Background(), req)
 	if err != nil {
@@ -611,7 +701,13 @@ func DismissGroup(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	reply, err := client.DismissGroup(context.Background(), req)
 	if err != nil {
@@ -647,7 +743,13 @@ func MuteGroupMember(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	reply, err := client.MuteGroupMember(context.Background(), req)
 	if err != nil {
@@ -683,7 +785,13 @@ func CancelMuteGroupMember(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	reply, err := client.CancelMuteGroupMember(context.Background(), req)
 	if err != nil {
@@ -719,7 +827,13 @@ func MuteGroup(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	reply, err := client.MuteGroup(context.Background(), req)
 	if err != nil {
@@ -755,7 +869,13 @@ func CancelMuteGroup(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	reply, err := client.CancelMuteGroup(context.Background(), req)
 	if err != nil {
@@ -793,7 +913,13 @@ func SetGroupMemberNickname(c *gin.Context) {
 
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	reply, err := client.SetGroupMemberNickname(context.Background(), req)
 	if err != nil {
@@ -846,7 +972,13 @@ func SetGroupMemberInfo(c *gin.Context) {
 		reqPb.RoleLevel = &wrappers.Int32Value{Value: *req.RoleLevel}
 	}
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewGroupClient(etcdConn)
 	respPb, err := client.SetGroupMemberInfo(context.Background(), reqPb)
 	if err != nil {

internal/api/group/super_group.go

@@ -0,0 +1,88 @@
+package group
+
+import (
+	jsonData "Open_IM/internal/utils"
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	rpc "Open_IM/pkg/proto/group"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func GetJoinedSuperGroupList(c *gin.Context) {
+	req := api.GetJoinedSuperGroupListReq{}
+	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
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, opUserID, errInfo := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	reqPb := rpc.GetJoinedSuperGroupListReq{OperationID: req.OperationID, OpUserID: opUserID, UserID: req.FromUserID}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := rpc.NewGroupClient(etcdConn)
+	rpcResp, err := client.GetJoinedSuperGroupList(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, "InviteUserToGroup failed ", err.Error(), reqPb.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+	GroupListResp := api.GetJoinedSuperGroupListResp{GetJoinedGroupListResp: api.GetJoinedGroupListResp{CommResp: api.CommResp{ErrCode: rpcResp.CommonResp.ErrCode, ErrMsg: rpcResp.CommonResp.ErrMsg}, GroupInfoList: rpcResp.GroupList}}
+	GroupListResp.Data = jsonData.JsonDataList(GroupListResp.GroupInfoList)
+	log.NewInfo(req.OperationID, "GetJoinedGroupList api return ", GroupListResp)
+	c.JSON(http.StatusOK, GroupListResp)
+}
+
+func GetSuperGroupsInfo(c *gin.Context) {
+	req := api.GetSuperGroupsInfoReq{}
+	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
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, opUserID, errInfo := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	reqPb := rpc.GetSuperGroupsInfoReq{OperationID: req.OperationID, OpUserID: opUserID, GroupIDList: req.GroupIDList}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := rpc.NewGroupClient(etcdConn)
+	rpcResp, err := client.GetSuperGroupsInfo(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, "InviteUserToGroup failed ", err.Error(), reqPb.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+	resp := api.GetSuperGroupsInfoResp{GetGroupInfoResp: api.GetGroupInfoResp{CommResp: api.CommResp{ErrCode: rpcResp.CommonResp.ErrCode, ErrMsg: rpcResp.CommonResp.ErrMsg}, GroupInfoList: rpcResp.GroupInfoList}}
+	resp.Data = jsonData.JsonDataList(resp.GroupInfoList)
+	log.NewInfo(req.OperationID, "GetGroupsInfo api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/manage/management_chat.go

@@ -138,7 +138,7 @@ func ManagementSendMsg(c *gin.Context) {
 		log.Error(c.PostForm("operationID"), "data args validate  err", err.Error())
 		return
 	}
-	log.NewInfo("", data, params)
+	log.NewInfo(params.OperationID, data, params)
 	token := c.Request.Header.Get("token")
 	claims, err := token_verify.ParseToken(token, params.OperationID)
 	if err != nil {
@@ -169,12 +169,18 @@ func ManagementSendMsg(c *gin.Context) {
 	log.NewInfo(params.OperationID, "Ws call success to ManagementSendMsgReq", params)
 
 	pbData := newUserSendMsgReq(&params)
-	log.Info("", "", "api ManagementSendMsg call start..., [data: %s]", pbData.String())
+	log.Info(params.OperationID, "", "api ManagementSendMsg call start..., [data: %s]", pbData.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, params.OperationID)
+	if etcdConn == nil {
+		errMsg := params.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(params.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbChat.NewChatClient(etcdConn)
 
-	log.Info("", "", "api ManagementSendMsg call, api call rpc...")
+	log.Info(params.OperationID, "", "api ManagementSendMsg call, api call rpc...")
 
 	RpcResp, err := client.SendMsg(context.Background(), pbData)
 	if err != nil {
@@ -182,7 +188,7 @@ func ManagementSendMsg(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call UserSendMsg  rpc server failed"})
 		return
 	}
-	log.Info("", "", "api ManagementSendMsg call end..., [data: %s] [reply: %s]", pbData.String(), RpcResp.String())
+	log.Info(params.OperationID, "", "api ManagementSendMsg call end..., [data: %s] [reply: %s]", pbData.String(), RpcResp.String())
 	resp := api.ManagementSendMsgResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, ResultList: server_api_params.UserSendMsgResp{ServerMsgID: RpcResp.ServerMsgID, ClientMsgID: RpcResp.ClientMsgID, SendTime: RpcResp.SendTime}}
 	log.Info(params.OperationID, "ManagementSendMsg return", resp)
 	c.JSON(http.StatusOK, resp)
@@ -239,7 +245,7 @@ func ManagementBatchSendMsg(c *gin.Context) {
 		log.Error(c.PostForm("operationID"), "data args validate  err", err.Error())
 		return
 	}
-	log.NewInfo("", data, params)
+	log.NewInfo(params.OperationID, data, params)
 	token := c.Request.Header.Get("token")
 	claims, err := token_verify.ParseToken(token, params.OperationID)
 	if err != nil {
@@ -256,8 +262,14 @@ func ManagementBatchSendMsg(c *gin.Context) {
 	for _, recvID := range params.RecvIDList {
 		pbData := newUserSendMsgReq(&params.ManagementSendMsgReq)
 		pbData.MsgData.RecvID = recvID
-		log.Info("", "", "api ManagementSendMsg call start..., [data: %s]", pbData.String())
-		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+		log.Info(params.OperationID, "", "api ManagementSendMsg call start..., ", pbData.String())
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, params.OperationID)
+		if etcdConn == nil {
+			errMsg := params.OperationID + "getcdv3.GetConn == nil"
+			log.NewError(params.OperationID, errMsg)
+			resp.Data.FailedIDList = append(resp.Data.FailedIDList, recvID)
+			continue
+		}
 		client := pbChat.NewChatClient(etcdConn)
 		rpcResp, err := client.SendMsg(context.Background(), pbData)
 		if err != nil {
@@ -266,7 +278,7 @@ func ManagementBatchSendMsg(c *gin.Context) {
 			continue
 		}
 		if rpcResp.ErrCode != 0 {
-			log.NewError(params.OperationID, utils.GetSelfFuncName(), "rpc failed", pbData)
+			log.NewError(params.OperationID, utils.GetSelfFuncName(), "rpc failed", pbData, rpcResp)
 			resp.Data.FailedIDList = append(resp.Data.FailedIDList, recvID)
 			continue
 		}
@@ -347,15 +359,15 @@ type RevokeElem struct {
 	RevokeMsgClientID string `mapstructure:"revokeMsgClientID" validate:"required"`
 }
 type OANotificationElem struct {
-	NotificationName    string      `mapstructure:"notificationName" validate:"required"`
-	NotificationFaceURL string      `mapstructure:"notificationFaceURL" validate:"required"`
-	NotificationType    int32       `mapstructure:"notificationType" validate:"required"`
-	Text                string      `mapstructure:"text" validate:"required"`
-	Url                 string      `mapstructure:"url"`
-	MixType             int32       `mapstructure:"mixType"`
-	PictureElem         PictureElem `mapstructure:"pictureElem"`
-	SoundElem           SoundElem   `mapstructure:"soundElem"`
-	VideoElem           VideoElem   `mapstructure:"videoElem"`
-	FileElem            FileElem    `mapstructure:"fileElem"`
-	Ex                  string      `mapstructure:"ex"`
+	NotificationName    string      `mapstructure:"notificationName" json:"notificationName" validate:"required"`
+	NotificationFaceURL string      `mapstructure:"notificationFaceURL" json:"notificationFaceURL" validate:"required"`
+	NotificationType    int32       `mapstructure:"notificationType" json:"notificationType" validate:"required"`
+	Text                string      `mapstructure:"text" json:"text" validate:"required"`
+	Url                 string      `mapstructure:"url" json:"url"`
+	MixType             int32       `mapstructure:"mixType" json:"mixType"`
+	PictureElem         PictureElem `mapstructure:"pictureElem" json:"pictureElem"`
+	SoundElem           SoundElem   `mapstructure:"soundElem" json:"soundElem"`
+	VideoElem           VideoElem   `mapstructure:"videoElem" json:"videoElem"`
+	FileElem            FileElem    `mapstructure:"fileElem" json:"fileElem"`
+	Ex                  string      `mapstructure:"ex" json:"ex"`
 }

internal/api/manage/management_user.go

@@ -42,7 +42,13 @@ func DeleteUser(c *gin.Context) {
 	}
 
 	log.NewInfo(params.OperationID, "DeleteUser args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewUserClient(etcdConn)
 
 	RpcResp, err := client.DeleteUsers(context.Background(), req)
@@ -78,7 +84,13 @@ func GetAllUsersUid(c *gin.Context) {
 	}
 
 	log.NewInfo(params.OperationID, "GetAllUsersUid args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewUserClient(etcdConn)
 	RpcResp, err := client.GetAllUserID(context.Background(), req)
 	if err != nil {
@@ -114,7 +126,13 @@ func AccountCheck(c *gin.Context) {
 	}
 
 	log.NewInfo(params.OperationID, "AccountCheck args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewUserClient(etcdConn)
 
 	RpcResp, err := client.AccountCheck(context.Background(), req)

internal/api/office/tag.go

@@ -42,7 +42,13 @@ func GetUserTags(c *gin.Context) {
 
 	reqPb.UserID = userID
 	reqPb.OperationID = req.OperationID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.GetUserTags(context.Background(), &reqPb)
 	if err != nil {
@@ -89,7 +95,13 @@ func CreateTag(c *gin.Context) {
 	}
 
 	reqPb.UserID = userID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.CreateTag(context.Background(), &reqPb)
 	if err != nil {
@@ -131,7 +143,13 @@ func DeleteTag(c *gin.Context) {
 	}
 
 	reqPb.UserID = userID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.DeleteTag(context.Background(), &reqPb)
 	if err != nil {
@@ -173,7 +191,13 @@ func SetTag(c *gin.Context) {
 	}
 
 	reqPb.UserID = userID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.SetTag(context.Background(), &reqPb)
 	if err != nil {
@@ -215,7 +239,13 @@ func SendMsg2Tag(c *gin.Context) {
 	}
 
 	reqPb.SendID = userID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.SendMsg2Tag(context.Background(), &reqPb)
 	if err != nil {
@@ -259,7 +289,13 @@ func GetTagSendLogs(c *gin.Context) {
 		PageNumber: req.PageNumber,
 		ShowNumber: req.ShowNumber,
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	maxSizeOption := grpc.MaxCallRecvMsgSize(1024 * 1024 * 20)
 	respPb, err := client.GetTagSendLogs(context.Background(), &reqPb, maxSizeOption)
@@ -308,7 +344,13 @@ func GetUserTagByID(c *gin.Context) {
 	reqPb.UserID = userID
 	reqPb.OperationID = req.OperationID
 	reqPb.TagID = req.TagID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.GetUserTagByID(context.Background(), &reqPb)
 	if err != nil {

internal/api/office/work_moments.go

@@ -44,7 +44,14 @@ func CreateOneWorkMoment(c *gin.Context) {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
 	reqPb.WorkMoment.UserID = userID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.CreateOneWorkMoment(context.Background(), &reqPb)
 	if err != nil {
@@ -89,7 +96,14 @@ func DeleteOneWorkMoment(c *gin.Context) {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
 	reqPb.UserID = userID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.DeleteOneWorkMoment(context.Background(), &reqPb)
 	if err != nil {
@@ -133,7 +147,13 @@ func LikeOneWorkMoment(c *gin.Context) {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
 	reqPb.UserID = userID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.LikeOneWorkMoment(context.Background(), &reqPb)
 	if err != nil {
@@ -177,7 +197,13 @@ func CommentOneWorkMoment(c *gin.Context) {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
 	reqPb.UserID = userID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.CommentOneWorkMoment(context.Background(), &reqPb)
 	if err != nil {
@@ -219,7 +245,13 @@ func DeleteComment(c *gin.Context) {
 		return
 	}
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.DeleteComment(context.Background(), &reqPb)
 	if err != nil {
@@ -262,7 +294,13 @@ func GetWorkMomentByID(c *gin.Context) {
 	reqPb.OperationID = req.OperationID
 	reqPb.OpUserID = userID
 	reqPb.WorkMomentID = req.WorkMomentID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.GetWorkMomentByID(context.Background(), &reqPb)
 	if err != nil {
@@ -314,7 +352,13 @@ func GetUserWorkMoments(c *gin.Context) {
 	}
 	reqPb.OpUserID = opUserID
 	reqPb.UserID = req.UserID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.GetUserWorkMoments(context.Background(), &reqPb)
 	if err != nil {
@@ -411,7 +455,13 @@ func GetUserFriendWorkMoments(c *gin.Context) {
 		ShowNumber: req.ShowNumber,
 	}
 	reqPb.UserID = userID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.GetUserFriendWorkMoments(context.Background(), &reqPb)
 	if err != nil {
@@ -506,7 +556,13 @@ func SetUserWorkMomentsLevel(c *gin.Context) {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
 	reqPb.UserID = userID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.SetUserWorkMomentsLevel(context.Background(), &reqPb)
 	if err != nil {

internal/api/organization/organization.go

@@ -36,7 +36,14 @@ func CreateDepartment(c *gin.Context) {
 	}
 
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.CreateDepartment(context.Background(), req)
 	if err != nil {
@@ -72,7 +79,14 @@ func UpdateDepartment(c *gin.Context) {
 	}
 
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.UpdateDepartment(context.Background(), req)
 	if err != nil {
@@ -106,7 +120,13 @@ func GetSubDepartment(c *gin.Context) {
 	}
 
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.GetSubDepartment(context.Background(), req)
 	if err != nil {
@@ -144,7 +164,13 @@ func DeleteDepartment(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.DeleteDepartment(context.Background(), req)
 	if err != nil {
@@ -180,7 +206,13 @@ func CreateOrganizationUser(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.CreateOrganizationUser(context.Background(), req)
 	if err != nil {
@@ -215,7 +247,13 @@ func UpdateOrganizationUser(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.UpdateOrganizationUser(context.Background(), req)
 	if err != nil {
@@ -251,7 +289,13 @@ func CreateDepartmentMember(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.CreateDepartmentMember(context.Background(), req)
 	if err != nil {
@@ -286,7 +330,13 @@ func GetUserInDepartment(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.GetUserInDepartment(context.Background(), req)
 	if err != nil {
@@ -322,7 +372,13 @@ func UpdateUserInDepartment(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.UpdateUserInDepartment(context.Background(), req)
 	if err != nil {
@@ -357,7 +413,13 @@ func DeleteOrganizationUser(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.DeleteOrganizationUser(context.Background(), req)
 	if err != nil {
@@ -392,7 +454,13 @@ func GetDepartmentMember(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.GetDepartmentMember(context.Background(), req)
 	if err != nil {
@@ -427,7 +495,13 @@ func DeleteUserInDepartment(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewOrganizationClient(etcdConn)
 	RpcResp, err := client.DeleteUserInDepartment(context.Background(), req)
 	if err != nil {

internal/api/third/minio_storage_credential.go

@@ -87,7 +87,7 @@ func MinioUploadFile(c *gin.Context) {
 	log.Debug(req.OperationID, utils.GetSelfFuncName(), config.Config.Credential.Minio.Bucket, newName, fileObj, file.Size, newType, MinioClient.EndpointURL())
 	_, err = MinioClient.PutObject(context.Background(), config.Config.Credential.Minio.Bucket, newName, fileObj, file.Size, minio.PutObjectOptions{ContentType: newType})
 	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "upload file error")
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "upload file error", err.Error())
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "upload file error" + err.Error()})
 		return
 	}

internal/api/user/user.go

@@ -38,7 +38,13 @@ func GetUsersInfoFromCache(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewUserClient(etcdConn)
 	RpcResp, err := client.GetUserInfo(context.Background(), req)
 	if err != nil {
@@ -80,7 +86,13 @@ func GetFriendIDListFromCache(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := cacheRpc.NewCacheClient(etcdConn)
 	respPb, err := client.GetFriendIDListFromCache(context.Background(), &reqPb)
 	if err != nil {
@@ -116,7 +128,13 @@ func GetBlackIDListFromCache(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := cacheRpc.NewCacheClient(etcdConn)
 	respPb, err := client.GetBlackIDListFromCache(context.Background(), &reqPb)
 	if err != nil {
@@ -151,7 +169,13 @@ func GetUsersInfo(c *gin.Context) {
 
 	log.NewInfo(params.OperationID, "GetUserInfo args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewUserClient(etcdConn)
 	RpcResp, err := client.GetUserInfo(context.Background(), req)
 	if err != nil {
@@ -191,8 +215,13 @@ func UpdateUserInfo(c *gin.Context) {
 		return
 	}
 	log.NewInfo(params.OperationID, "UpdateUserInfo args ", req.String())
-
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewUserClient(etcdConn)
 	RpcResp, err := client.UpdateUserInfo(context.Background(), req)
 	if err != nil {
@@ -204,6 +233,44 @@ func UpdateUserInfo(c *gin.Context) {
 	log.NewInfo(req.OperationID, "UpdateUserInfo api return ", resp)
 	c.JSON(http.StatusOK, resp)
 }
+func SetGlobalRecvMessageOpt(c *gin.Context) {
+	params := api.SetGlobalRecvMessageOptReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.SetGlobalRecvMessageOptReq{}
+	utils.CopyStructFields(req, &params)
+	req.OperationID = params.OperationID
+	var ok bool
+	var errInfo string
+	ok, req.UserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(params.OperationID, "SetGlobalRecvMessageOpt args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := rpc.NewUserClient(etcdConn)
+	RpcResp, err := client.SetGlobalRecvMessageOpt(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "SetGlobalRecvMessageOpt failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	resp := api.UpdateUserInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, "SetGlobalRecvMessageOpt api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
 
 func GetSelfUserInfo(c *gin.Context) {
 	params := api.GetSelfUserInfoReq{}
@@ -229,7 +296,13 @@ func GetSelfUserInfo(c *gin.Context) {
 	req.UserIDList = append(req.UserIDList, req.OpUserID)
 	log.NewInfo(params.OperationID, "GetUserInfo args ", req.String())
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := rpc.NewUserClient(etcdConn)
 	RpcResp, err := client.GetUserInfo(context.Background(), req)
 	if err != nil {

internal/cms_api/admin/admin.go

@@ -12,6 +12,7 @@ import (
 	"context"
 	"github.com/minio/minio-go/v7"
 	"github.com/minio/minio-go/v7/pkg/credentials"
+	"net/http"
 	"strings"
 
 	"github.com/gin-gonic/gin"
@@ -68,7 +69,14 @@ func AdminLogin(c *gin.Context) {
 	}
 	reqPb.Secret = req.Secret
 	reqPb.AdminID = req.AdminName
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAdminCMSName)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAdminCMSName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbAdmin.NewAdminCMSClient(etcdConn)
 	respPb, err := client.AdminLogin(context.Background(), &reqPb)
 	if err != nil {

internal/cms_api/group/group.go

@@ -10,6 +10,7 @@ import (
 	commonPb "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"context"
+	"net/http"
 	"strings"
 
 	pbGroup "Open_IM/pkg/proto/group"
@@ -28,9 +29,16 @@ func GetGroupById(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.GroupId = req.GroupId
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.GetGroupById(context.Background(), &reqPb)
 	if err != nil {
@@ -60,10 +68,17 @@ func GetGroups(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.Pagination = &commonPb.RequestPagination{}
 	utils.CopyStructFields(&reqPb.Pagination, req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.GetGroups(context.Background(), &reqPb)
 	if err != nil {
@@ -101,11 +116,18 @@ func GetGroupByName(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.GroupName = req.GroupName
 	reqPb.Pagination = &commonPb.RequestPagination{}
 	utils.CopyStructFields(&reqPb.Pagination, req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.GetGroup(context.Background(), &reqPb)
 	if err != nil {
@@ -143,7 +165,8 @@ func CreateGroup(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.GroupInfo = &commonPb.GroupInfo{}
 	reqPb.GroupInfo.GroupName = req.GroupName
 	reqPb.GroupInfo.CreatorUserID = req.GroupMasterId
@@ -155,7 +178,13 @@ func CreateGroup(c *gin.Context) {
 			RoleLevel: 1,
 		})
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.CreateGroup(context.Background(), &reqPb)
 	if err != nil {
@@ -176,10 +205,18 @@ func BanGroupChat(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.GroupId = req.GroupId
 	reqPb.Status = constant.GroupBanChat
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
 	if err != nil {
@@ -201,10 +238,17 @@ func BanPrivateChat(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.GroupId = req.GroupId
 	reqPb.Status = constant.GroupBanPrivateChat
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
 	if err != nil {
@@ -225,10 +269,17 @@ func OpenGroupChat(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.GroupId = req.GroupId
 	reqPb.Status = constant.GroupOk
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
 	if err != nil {
@@ -249,10 +300,18 @@ func OpenPrivateChat(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.GroupId = req.GroupId
 	reqPb.Status = constant.GroupOk
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
 	if err != nil {
@@ -274,14 +333,21 @@ func GetGroupMembers(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.Pagination = &commonPb.RequestPagination{
 		PageNumber: int32(req.PageNumber),
 		ShowNumber: int32(req.ShowNumber),
 	}
 	reqPb.GroupId = req.GroupId
 	reqPb.UserName = req.UserName
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.GetGroupMembersCMS(context.Background(), &reqPb)
 	if err != nil {
@@ -317,10 +383,17 @@ func AddGroupMembers(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
+	reqPb.OperationId = utils.OperationIDGenerator()
 	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
 	reqPb.UserIds = req.Members
 	reqPb.GroupId = req.GroupId
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationId)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationId + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationId, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.AddGroupMembersCMS(context.Background(), &reqPb)
 	if err != nil {
@@ -345,10 +418,17 @@ func RemoveGroupMembers(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.UserIds = req.Members
 	reqPb.GroupId = req.GroupId
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.RemoveGroupMembersCMS(context.Background(), &reqPb)
 	if err != nil {
@@ -373,9 +453,16 @@ func DeleteGroup(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.GroupId = req.GroupId
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.DeleteGroup(context.Background(), &reqPb)
 	if err != nil {
@@ -397,11 +484,18 @@ func SetGroupMaster(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.GroupId = req.GroupId
 	reqPb.UserId = req.UserId
 	reqPb.RoleLevel = constant.GroupOwner
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.OperateUserRole(context.Background(), &reqPb)
 	if err != nil {
@@ -423,11 +517,18 @@ func SetGroupOrdinaryUsers(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.GroupId = req.GroupId
 	reqPb.UserId = req.UserId
 	reqPb.RoleLevel = constant.GroupOrdinaryUsers
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.OperateUserRole(context.Background(), &reqPb)
 	if err != nil {
@@ -444,7 +545,8 @@ func AlterGroupInfo(c *gin.Context) {
 		_     cms_api_struct.SetGroupMasterResponse
 		reqPb pbGroup.SetGroupInfoReq
 	)
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	if err := c.BindJSON(&req); err != nil {
 		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
@@ -459,7 +561,13 @@ func AlterGroupInfo(c *gin.Context) {
 		FaceURL:      req.ProfilePhoto,
 		GroupType:    int32(req.GroupType),
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.SetGroupInfo(context.Background(), &reqPb)
 	if err != nil {

internal/cms_api/message_cms/message.go

@@ -10,6 +10,7 @@ import (
 	pbCommon "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"context"
+	"net/http"
 	"strings"
 
 	"Open_IM/pkg/common/constant"
@@ -21,7 +22,14 @@ func BroadcastMessage(c *gin.Context) {
 	var (
 		reqPb pbMessage.BoradcastMessageReq
 	)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbMessage.NewMessageCMSClient(etcdConn)
 	_, err := client.BoradcastMessage(context.Background(), &reqPb)
 	if err != nil {
@@ -36,7 +44,14 @@ func MassSendMassage(c *gin.Context) {
 	var (
 		reqPb pbMessage.MassSendMessageReq
 	)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbMessage.NewMessageCMSClient(etcdConn)
 	_, err := client.MassSendMessage(context.Background(), &reqPb)
 	if err != nil {
@@ -51,7 +66,14 @@ func WithdrawMessage(c *gin.Context) {
 	var (
 		reqPb pbMessage.WithdrawMessageReq
 	)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbMessage.NewMessageCMSClient(etcdConn)
 	_, err := client.WithdrawMessage(context.Background(), &reqPb)
 	if err != nil {
@@ -78,8 +100,14 @@ func GetChatLogs(c *gin.Context) {
 		ShowNumber: int32(req.ShowNumber),
 	}
 	utils.CopyStructFields(&reqPb, &req)
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pbMessage.NewMessageCMSClient(etcdConn)
 	respPb, err := client.GetChatLogs(context.Background(), &reqPb)
 	if err != nil {
@@ -106,6 +134,6 @@ func GetChatLogs(c *gin.Context) {
 	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
 	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
 	resp.ChatLogsNum = int(respPb.ChatLogsNum)
-	log.NewInfo("", utils.GetSelfFuncName(), "resp", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }

internal/cms_api/statistics/statistics.go

@@ -10,6 +10,7 @@ import (
 	pb "Open_IM/pkg/proto/statistics"
 	"Open_IM/pkg/utils"
 	"context"
+	"net/http"
 	"strings"
 
 	"github.com/gin-gonic/gin"
@@ -27,9 +28,16 @@ func GetMessagesStatistics(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb.StatisticsReq, &req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetMessageStatistics(context.Background(), &reqPb)
 	if err != nil {
@@ -58,7 +66,7 @@ func GetMessagesStatistics(c *gin.Context) {
 			MessageNum: int(v.Num),
 		})
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -74,13 +82,20 @@ func GetUserStatistics(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb.StatisticsReq, &req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetUserStatistics(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("0", utils.GetSelfFuncName(), "GetUserStatistics failed", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetUserStatistics failed", err.Error())
 		openIMHttp.RespHttp200(c, err, nil)
 		return
 	}
@@ -115,7 +130,7 @@ func GetUserStatistics(c *gin.Context) {
 			TotalUserNum: int(v.Num),
 		})
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -131,9 +146,16 @@ func GetGroupStatistics(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb.StatisticsReq, &req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetGroupStatistics(context.Background(), &reqPb)
 	if err != nil {
@@ -165,7 +187,7 @@ func GetGroupStatistics(c *gin.Context) {
 			})
 
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -181,9 +203,16 @@ func GetActiveUser(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb.StatisticsReq, req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetActiveUser(context.Background(), &reqPb)
 	if err != nil {
@@ -192,7 +221,7 @@ func GetActiveUser(c *gin.Context) {
 		return
 	}
 	utils.CopyStructFields(&resp.ActiveUserList, respPb.Users)
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -208,13 +237,20 @@ func GetActiveGroup(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb.StatisticsReq, req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetActiveGroup(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("0", utils.GetSelfFuncName(), "GetActiveGroup failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetActiveGroup failed ", err.Error())
 		openIMHttp.RespHttp200(c, err, nil)
 		return
 	}
@@ -229,6 +265,6 @@ func GetActiveGroup(c *gin.Context) {
 			MessageNum: int(group.MessageNum),
 		})
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }

internal/cms_api/user/user.go

@@ -29,9 +29,17 @@ func GetUserById(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb, &req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetUserById(context.Background(), &reqPb)
 	if err != nil {
@@ -44,7 +52,7 @@ func GetUserById(c *gin.Context) {
 		return
 	}
 	utils.CopyStructFields(&resp, respPb.User)
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -54,7 +62,8 @@ func GetUsersByName(c *gin.Context) {
 		resp  cms_api_struct.GetUsersByNameResponse
 		reqPb pb.GetUsersByNameReq
 	)
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	if err := c.ShouldBindQuery(&req); err != nil {
 		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
@@ -65,7 +74,13 @@ func GetUsersByName(c *gin.Context) {
 		PageNumber: int32(req.PageNumber),
 		ShowNumber: int32(req.ShowNumber),
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetUsersByName(context.Background(), &reqPb)
 	if err != nil {
@@ -77,7 +92,7 @@ func GetUsersByName(c *gin.Context) {
 	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
 	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
 	resp.UserNums = respPb.UserNums
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -93,9 +108,16 @@ func GetUsers(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb.Pagination, &req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetUsers(context.Background(), &reqPb)
 	if err != nil {
@@ -106,7 +128,7 @@ func GetUsers(c *gin.Context) {
 	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
 	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
 	resp.UserNums = respPb.UserNums
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 
 }
@@ -122,15 +144,22 @@ func ResignUser(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb, &req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	_, err := client.ResignUser(context.Background(), &reqPb)
 	if err != nil {
 		openIMHttp.RespHttp200(c, err, resp)
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -145,13 +174,20 @@ func AlterUser(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb, &req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	_, err := client.AlterUser(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("0", "microserver failed ", err.Error())
+		log.NewError(reqPb.OperationID, "microserver failed ", err.Error())
 		openIMHttp.RespHttp200(c, err, nil)
 	}
 	openIMHttp.RespHttp200(c, constant.OK, nil)
@@ -167,9 +203,16 @@ func AddUser(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb, &req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	_, err := client.AddUser(context.Background(), &reqPb)
 	if err != nil {
@@ -191,9 +234,16 @@ func BlockUser(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb, &req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	fmt.Println(reqPb)
 	_, err := client.BlockUser(context.Background(), &reqPb)
@@ -215,16 +265,23 @@ func UnblockUser(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb, &req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	_, err := client.UnBlockUser(context.Background(), &reqPb)
 	if err != nil {
 		openIMHttp.RespHttp200(c, err, resp)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -241,10 +298,17 @@ func GetBlockUsers(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	utils.CopyStructFields(&reqPb.Pagination, &req)
 	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "blockUsers", reqPb.Pagination, req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetBlockUsers(context.Background(), &reqPb)
 	if err != nil {
@@ -268,7 +332,7 @@ func GetBlockUsers(c *gin.Context) {
 	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
 	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
 	resp.UserNums = respPb.UserNums
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -283,20 +347,27 @@ func GetBlockUserById(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.UserId = req.UserId
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetBlockUserById(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("0", "GetBlockUserById rpc failed ", err.Error())
+		log.NewError(reqPb.OperationID, "GetBlockUserById rpc failed ", err.Error())
 		openIMHttp.RespHttp200(c, err, nil)
 		return
 	}
 	resp.EndDisableTime = respPb.BlockUser.EndDisableTime
 	resp.BeginDisableTime = respPb.BlockUser.BeginDisableTime
 	utils.CopyStructFields(&resp, respPb.BlockUser.User)
-	log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -310,13 +381,20 @@ func DeleteUser(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
-	log.NewInfo("", utils.GetSelfFuncName(), "req: ", req)
+	reqPb.OperationID = utils.OperationIDGenerator()
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
 	reqPb.UserId = req.UserId
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	client := pb.NewUserClient(etcdConn)
 	_, err := client.DeleteUser(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("0", "DeleteUser rpc failed ", err.Error())
+		log.NewError(reqPb.OperationID, "DeleteUser rpc failed ", err.Error())
 		openIMHttp.RespHttp200(c, err, nil)
 		return
 	}

internal/demo/register/login.go

@@ -46,12 +46,18 @@ func Login(c *gin.Context) {
 		c.JSON(http.StatusOK, gin.H{"errCode": constant.PasswordErr, "errMsg": "password err"})
 		return
 	}
+	var userID string
+	if r.UserID != "" {
+		userID = r.UserID
+	} else {
+		userID = r.Account
+	}
 	url := fmt.Sprintf("http://%s:%d/auth/user_token", utils.ServerIP, config.Config.Api.GinPort[0])
 	openIMGetUserToken := api.UserTokenReq{}
 	openIMGetUserToken.OperationID = params.OperationID
 	openIMGetUserToken.Platform = params.Platform
 	openIMGetUserToken.Secret = config.Config.Secret
-	openIMGetUserToken.UserID = account
+	openIMGetUserToken.UserID = userID
 	openIMGetUserTokenResp := api.UserTokenResp{}
 	bMsg, err := http2.Post(url, openIMGetUserToken, 2)
 	if err != nil {

internal/demo/register/onboarding_process.go

@@ -1,9 +1,11 @@
 package register
 
 import (
+	"Open_IM/internal/api/manage"
 	"Open_IM/internal/rpc/msg"
 	"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/grpc-etcdv3/getcdv3"
 	groupRpc "Open_IM/pkg/proto/group"
@@ -23,23 +25,37 @@ func onboardingProcess(operationID, userID, userName string) {
 	if err := createOrganizationUser(operationID, userID, userName); err != nil {
 		log.NewError(operationID, utils.GetSelfFuncName(), "createOrganizationUser failed", err.Error())
 	}
-	departmentID := config.Config.Demo.TestDepartMentID
+	departmentID, err := imdb.GetRandomDepartmentID()
+
 	if err := joinTestDepartment(operationID, userID, departmentID); err != nil {
 		log.NewError(operationID, utils.GetSelfFuncName(), "joinTestDepartment failed", err.Error())
 	}
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "random departmentID", departmentID)
+	if err != nil {
+		log.NewError(utils.GetSelfFuncName(), "GetRandomDepartmentID failed", err.Error())
+		return
+	}
 	groupIDList, err := GetDepartmentGroupIDList(operationID, departmentID)
 	if err != nil {
 		log.NewError(operationID, utils.GetSelfFuncName(), err.Error())
 	}
+	log.NewInfo(operationID, utils.GetSelfFuncName(), groupIDList)
 	joinGroups(operationID, userID, userName, groupIDList)
 	log.NewInfo(operationID, utils.GetSelfFuncName(), "fineshed")
+	oaNotification(operationID, userID)
 }
 
 func createOrganizationUser(operationID, userID, userName string) error {
 	defer func() {
 		log.NewInfo(operationID, utils.GetSelfFuncName(), userID)
 	}()
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "start createOrganizationUser")
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, operationID)
+	if etcdConn == nil {
+		errMsg := operationID + "getcdv3.GetConn == nil"
+		log.NewError(operationID, errMsg)
+		return errors.New(errMsg)
+	}
 	client := organizationRpc.NewOrganizationClient(etcdConn)
 	req := &organizationRpc.CreateOrganizationUserReq{
 		OrganizationUser: &commonPb.OrganizationUser{
@@ -50,7 +66,8 @@ func createOrganizationUser(operationID, userID, userName string) error {
 			CreateTime:  uint32(time.Now().Unix()),
 		},
 		OperationID: operationID,
-		OpUserID:    userID,
+		OpUserID:    config.Config.Manager.AppManagerUid[0],
+		IsRegister:  false,
 	}
 	if strings.Contains("@", userID) {
 		req.OrganizationUser.Email = userID
@@ -73,7 +90,12 @@ func joinTestDepartment(operationID, userID, departmentID string) error {
 	defer func() {
 		log.NewInfo(operationID, utils.GetSelfFuncName(), userID)
 	}()
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, operationID)
+	if etcdConn == nil {
+		errMsg := operationID + "getcdv3.GetConn == nil"
+		log.NewError(operationID, errMsg)
+		return errors.New(errMsg)
+	}
 	client := organizationRpc.NewOrganizationClient(etcdConn)
 	req := &organizationRpc.CreateDepartmentMemberReq{
 		DepartmentMember: &commonPb.DepartmentMember{
@@ -97,7 +119,15 @@ func joinTestDepartment(operationID, userID, departmentID string) error {
 }
 
 func GetDepartmentGroupIDList(operationID, departmentID string) ([]string, error) {
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	defer func() {
+		log.NewInfo(operationID, utils.GetSelfFuncName(), departmentID)
+	}()
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, operationID)
+	if etcdConn == nil {
+		errMsg := operationID + "getcdv3.GetConn == nil"
+		log.NewError(operationID, errMsg)
+		return nil, errors.New(errMsg)
+	}
 	client := organizationRpc.NewOrganizationClient(etcdConn)
 	req := organizationRpc.GetDepartmentParentIDListReq{
 		DepartmentID: departmentID,
@@ -131,7 +161,12 @@ func joinGroups(operationID, userID, userName string, groupIDList []string) {
 	defer func() {
 		log.NewInfo(operationID, utils.GetSelfFuncName(), userID, groupIDList)
 	}()
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, operationID)
+	if etcdConn == nil {
+		errMsg := operationID + "getcdv3.GetConn == nil"
+		log.NewError(operationID, errMsg)
+		return
+	}
 	client := groupRpc.NewGroupClient(etcdConn)
 	for _, groupID := range groupIDList {
 		req := &groupRpc.InviteUserToGroupReq{
@@ -139,7 +174,7 @@ func joinGroups(operationID, userID, userName string, groupIDList []string) {
 			GroupID:           groupID,
 			Reason:            "register auto join",
 			InvitedUserIDList: []string{userID},
-			OpUserID:          userID,
+			OpUserID:          config.Config.Manager.AppManagerUid[1],
 		}
 		resp, err := client.InviteUserToGroup(context.Background(), req)
 		if err != nil {
@@ -150,34 +185,71 @@ func joinGroups(operationID, userID, userName string, groupIDList []string) {
 			log.NewError(req.OperationID, utils.GetSelfFuncName(), resp)
 			continue
 		}
-		onboardingProcessNotification(operationID, userID, groupID)
+		onboardingProcessNotification(operationID, userID, groupID, userName)
 	}
 }
 
 // welcome user join department notification
-func onboardingProcessNotification(operationID, userID, groupID string) {
+func onboardingProcessNotification(operationID, userID, groupID, userName string) {
 	defer func() {
 		log.NewInfo(operationID, utils.GetSelfFuncName(), userID, groupID)
 	}()
-	var tips commonPb.TipsComm
-	tips.DefaultTips = config.Config.Notification.JoinDepartmentNotification.DefaultTips.Tips
-	tips.JsonDetail = ""
-	content, err := proto.Marshal(&tips)
-	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), "proto marshal failed")
-		return
-	}
+	//var tips commonPb.TipsComm
+	//tips.DefaultTips = config.Config.Notification.JoinDepartmentNotification.DefaultTips.Tips
+	//tips.JsonDetail = ""
+	//content, err := proto.Marshal(&tips)
+	//if err != nil {
+	//	log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), "proto marshal failed")
+	//	return
+	//}
+	welcomeString := fmt.Sprintf("欢迎%s加入部门", userName)
 	notification := &msg.NotificationMsg{
 		SendID:      userID,
 		RecvID:      groupID,
-		Content:     content,
+		Content:     []byte(welcomeString),
 		MsgFrom:     constant.UserMsgType,
 		ContentType: constant.Text,
-		SessionType: constant.SingleChatType,
+		SessionType: constant.GroupChatType,
 		OperationID: operationID,
 	}
+
 	// notification user join group
 	msg.Notification(notification)
+
+}
+
+func oaNotification(operationID, userID string) {
+	var err error
+	elem := manage.OANotificationElem{
+		NotificationName:    "入职通知",
+		NotificationFaceURL: "",
+		NotificationType:    1,
+		Text:                "欢迎你入职公司",
+		Url:                 "",
+		MixType:             0,
+		PictureElem:         manage.PictureElem{},
+		SoundElem:           manage.SoundElem{},
+		VideoElem:           manage.VideoElem{},
+		FileElem:            manage.FileElem{},
+		Ex:                  "",
+	}
+	sysNotification := &msg.NotificationMsg{
+		SendID:      config.Config.Manager.AppManagerUid[0],
+		RecvID:      userID,
+		MsgFrom:     constant.SysMsgType,
+		ContentType: constant.OANotification,
+		SessionType: constant.NotificationChatType,
+		OperationID: operationID,
+	}
+	var tips commonPb.TipsComm
+	tips.JsonDetail = utils.StructToJsonString(elem)
+	sysNotification.Content, err = proto.Marshal(&tips)
+	if err != nil {
+		log.NewError(operationID, utils.GetSelfFuncName(), "elem: ", elem, err.Error())
+		return
+	}
+
+	msg.Notification(sysNotification)
 }
 
 func randomEnglishName() string {
@@ -185,14 +257,12 @@ func randomEnglishName() string {
 		"feudal", "adverse", "exploit", "occupy", "solve", "amazing", "fantasy", "orchid", "spiky", "approve", "flap"}
 	rand.Seed(time.Now().UnixNano())
 	index := rand.Intn(len(l) - 1)
-	fmt.Println(index)
 	return l[index]
 }
 
 func randomPosition() string {
-	l := []string{"Golang工程师", "前端工程师", "后端工程师", "产品经理", "测试开发工程师", "运维开发工程师"}
+	l := []string{"后端工程师", "前端工程师", "设计师"}
 	rand.Seed(time.Now().UnixNano())
 	index := rand.Intn(len(l) - 1)
-	fmt.Println(index)
 	return l[index]
 }

internal/demo/register/reset_password.go

@@ -15,8 +15,8 @@ type resetPasswordRequest struct {
 	VerificationCode string `json:"verificationCode" binding:"required"`
 	Email            string `json:"email"`
 	PhoneNumber      string `json:"phoneNumber"`
-	NewPassword string `json:"newPassword" binding:"required"`
-	OperationID string `json:"operationID"`
+	NewPassword      string `json:"newPassword" binding:"required"`
+	OperationID      string `json:"operationID"`
 }
 
 func ResetPassword(c *gin.Context) {
@@ -44,12 +44,14 @@ func ResetPassword(c *gin.Context) {
 	}
 	user, err := im_mysql_model.GetRegister(account)
 	if err != nil || user.Account == "" {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "get register error", err.Error())
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "get register error", err.Error())
+		}
 		c.JSON(http.StatusOK, gin.H{"errCode": constant.NotRegistered, "errMsg": "user not register!"})
 		return
 	}
 	if err := im_mysql_model.ResetPassword(account, req.NewPassword); err != nil {
-		c.JSON(http.StatusOK, gin.H{"errCode": constant.ResetPasswordFailed, "errMsg": "reset password failed: "+err.Error()})
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.ResetPasswordFailed, "errMsg": "reset password failed: " + err.Error()})
 		return
 	}
 	c.JSON(http.StatusOK, gin.H{"errCode": constant.NoError, "errMsg": "reset password success"})

internal/demo/register/set_password.go

@@ -11,17 +11,21 @@ import (
 	"Open_IM/pkg/utils"
 	"encoding/json"
 	"github.com/gin-gonic/gin"
+	"math/big"
 	"net/http"
+	"strconv"
+	"time"
 )
 
 type ParamsSetPassword struct {
 	Email            string `json:"email"`
-	Name             string `json:"name"`
+	Nickname         string `json:"nickname"`
 	PhoneNumber      string `json:"phoneNumber"`
-	Password         string `json:"password"`
+	Password         string `json:"password" binding:"required"`
 	VerificationCode string `json:"verificationCode"`
 	Platform         int32  `json:"platform" binding:"required,min=1,max=7"`
 	Ex               string `json:"ex"`
+	FaceURL          string `json:"faceURL"`
 	OperationID      string `json:"operationID" binding:"required"`
 }
 
@@ -38,8 +42,8 @@ func SetPassword(c *gin.Context) {
 	} else {
 		account = params.PhoneNumber
 	}
-	if params.Name == "" {
-		params.Name = account
+	if params.Nickname == "" {
+		params.Nickname = account
 	}
 	if params.VerificationCode != config.Config.Demo.SuperCode {
 		accountKey := account + "_" + constant.VerificationCodeForRegisterSuffix
@@ -52,13 +56,21 @@ func SetPassword(c *gin.Context) {
 			return
 		}
 	}
+	//userID := utils.Base64Encode(account)
+
+	userID := utils.Md5(params.OperationID + strconv.FormatInt(time.Now().UnixNano(), 10))
+	bi := big.NewInt(0)
+	bi.SetString(userID[0:8], 16)
+	userID = bi.String()
+
 	url := config.Config.Demo.ImAPIURL + "/auth/user_register"
 	openIMRegisterReq := api.UserRegisterReq{}
 	openIMRegisterReq.OperationID = params.OperationID
 	openIMRegisterReq.Platform = params.Platform
-	openIMRegisterReq.UserID = account
-	openIMRegisterReq.Nickname = params.Name
+	openIMRegisterReq.UserID = userID
+	openIMRegisterReq.Nickname = params.Nickname
 	openIMRegisterReq.Secret = config.Config.Secret
+	openIMRegisterReq.FaceURL = params.FaceURL
 	openIMRegisterResp := api.UserRegisterResp{}
 	bMsg, err := http2.Post(url, openIMRegisterReq, 2)
 	if err != nil {
@@ -76,7 +88,7 @@ func SetPassword(c *gin.Context) {
 		return
 	}
 	log.Info(params.OperationID, "begin store mysql", account, params.Password)
-	err = im_mysql_model.SetPassword(account, params.Password, params.Ex)
+	err = im_mysql_model.SetPassword(account, params.Password, params.Ex, userID)
 	if err != nil {
 		log.NewError(params.OperationID, "set phone number password error", account, "err", err.Error())
 		c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterFailed, "errMsg": err.Error()})
@@ -84,7 +96,7 @@ func SetPassword(c *gin.Context) {
 	}
 	log.Info(params.OperationID, "end setPassword", account, params.Password)
 	// demo onboarding
-	onboardingProcess(params.OperationID, account, params.Name)
+	onboardingProcess(params.OperationID, userID, params.Nickname)
 	c.JSON(http.StatusOK, gin.H{"errCode": constant.NoError, "errMsg": "", "data": openIMRegisterResp.UserToken})
 	return
 }

internal/msg_gateway/gate/batch_push.go

@@ -0,0 +1,117 @@
+package gate
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	sdk_ws "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"strings"
+)
+
+var MaxPullMsgNum = 100
+
+func (r *RPCServer) GenPullSeqList(currentSeq uint32, operationID string, userID string) ([]uint32, error) {
+	maxSeq, err := db.DB.GetUserMaxSeq(userID)
+	if err != nil {
+		log.Error(operationID, "GetUserMaxSeq failed ", userID, err.Error())
+		return nil, utils.Wrap(err, "")
+	}
+
+	var seqList []uint32
+	num := 0
+	for i := currentSeq + 1; i < uint32(maxSeq); i++ {
+		seqList = append(seqList, i)
+		num++
+		if num == MaxPullMsgNum {
+			break
+		}
+	}
+	log.Info(operationID, "GenPullSeqList ", seqList, "current seq", currentSeq)
+	return seqList, nil
+}
+
+func (r *RPCServer) GetSingleUserMsgForPushPlatforms(operationID string, msgData *sdk_ws.MsgData, pushToUserID string, platformIDList []int) map[int]*sdk_ws.MsgDataList {
+	user2PushMsg := make(map[int]*sdk_ws.MsgDataList, 0)
+	for _, v := range platformIDList {
+		user2PushMsg[v] = r.GetSingleUserMsgForPush(operationID, msgData, pushToUserID, v)
+		//log.Info(operationID, "GetSingleUserMsgForPush", msgData.Seq, pushToUserID, v, "len:", len(user2PushMsg[v]))
+	}
+	return user2PushMsg
+}
+
+func (r *RPCServer) GetSingleUserMsgForPush(operationID string, msgData *sdk_ws.MsgData, pushToUserID string, platformID int) *sdk_ws.MsgDataList {
+	//msgData.MsgDataList = nil
+	return &sdk_ws.MsgDataList{MsgDataList: []*sdk_ws.MsgData{msgData}}
+
+	//userConn := ws.getUserConn(pushToUserID, platformID)
+	//if userConn == nil {
+	//	log.Debug(operationID, "userConn == nil")
+	//	return []*sdk_ws.MsgData{msgData}
+	//}
+	//
+	//if msgData.Seq <= userConn.PushedMaxSeq {
+	//	log.Debug(operationID, "msgData.Seq <= userConn.PushedMaxSeq", msgData.Seq, userConn.PushedMaxSeq)
+	//	return nil
+	//}
+	//
+	//msgList := r.GetSingleUserMsg(operationID, msgData.Seq, pushToUserID)
+	//if msgList == nil {
+	//	log.Debug(operationID, "GetSingleUserMsg msgList == nil", msgData.Seq, userConn.PushedMaxSeq)
+	//	userConn.PushedMaxSeq = msgData.Seq
+	//	return []*sdk_ws.MsgData{msgData}
+	//}
+	//msgList = append(msgList, msgData)
+	//
+	//for _, v := range msgList {
+	//	if v.Seq > userConn.PushedMaxSeq {
+	//		userConn.PushedMaxSeq = v.Seq
+	//	}
+	//}
+	//log.Debug(operationID, "GetSingleUserMsg msgList len ", len(msgList), userConn.PushedMaxSeq)
+	//return msgList
+}
+
+func (r *RPCServer) GetSingleUserMsg(operationID string, currentMsgSeq uint32, userID string) []*sdk_ws.MsgData {
+	seqList, err := r.GenPullSeqList(currentMsgSeq, operationID, userID)
+	if err != nil {
+		log.Error(operationID, "GenPullSeqList failed ", err.Error(), currentMsgSeq, userID)
+		return nil
+	}
+	if len(seqList) == 0 {
+		log.Error(operationID, "GenPullSeqList len == 0 ", currentMsgSeq, userID)
+		return nil
+	}
+	rpcReq := sdk_ws.PullMessageBySeqListReq{}
+	rpcReq.SeqList = seqList
+	rpcReq.UserID = userID
+	rpcReq.OperationID = operationID
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, rpcReq.OperationID)
+	if grpcConn == nil {
+		errMsg := "getcdv3.GetConn == nil"
+		log.NewError(rpcReq.OperationID, errMsg)
+		return nil
+	}
+
+	msgClient := pbChat.NewChatClient(grpcConn)
+	reply, err := msgClient.PullMessageBySeqList(context.Background(), &rpcReq)
+	if err != nil {
+		log.Error(operationID, "PullMessageBySeqList failed ", err.Error(), rpcReq.String())
+		return nil
+	}
+	if len(reply.List) == 0 {
+		return nil
+	}
+	return reply.List
+}
+
+//func (r *RPCServer) GetBatchUserMsgForPush(operationID string, msgData *sdk_ws.MsgData, pushToUserIDList []string, platformID int) map[string][]*sdk_ws.MsgData {
+//	user2PushMsg := make(map[string][]*sdk_ws.MsgData, 0)
+//	for _, v := range pushToUserIDList {
+//		user2PushMsg[v] = r.GetSingleUserMsgForPush(operationID, msgData, v, platformID)
+//	}
+//	return user2PushMsg
+//}

internal/msg_gateway/gate/callback.go

@@ -9,7 +9,7 @@ import (
 	"time"
 )
 
-func callbackUserOnline(operationID, userID string, platformID int32, token string) cbApi.CommonCallbackResp {
+func callbackUserOnline(operationID, userID string, platformID int, token string) cbApi.CommonCallbackResp {
 	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
 	if !config.Config.Callback.CallbackUserOnline.Enable {
 		return callbackResp
@@ -20,7 +20,7 @@ func callbackUserOnline(operationID, userID string, platformID int32, token stri
 			CallbackCommand: constant.CallbackUserOnlineCommand,
 			OperationID:     operationID,
 			UserID:          userID,
-			PlatformID:      platformID,
+			PlatformID:      int32(platformID),
 			Platform:        constant.PlatformIDToName(platformID),
 		},
 		Seq: time.Now().Nanosecond() / 1e6,
@@ -33,7 +33,7 @@ func callbackUserOnline(operationID, userID string, platformID int32, token stri
 	return callbackResp
 }
 
-func callbackUserOffline(operationID, userID string, platform string) cbApi.CommonCallbackResp {
+func callbackUserOffline(operationID, userID string, platformID int) cbApi.CommonCallbackResp {
 	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
 	if !config.Config.Callback.CallbackUserOffline.Enable {
 		return callbackResp
@@ -43,8 +43,8 @@ func callbackUserOffline(operationID, userID string, platform string) cbApi.Comm
 			CallbackCommand: constant.CallbackUserOfflineCommand,
 			OperationID:     operationID,
 			UserID:          userID,
-			PlatformID:      constant.PlatformNameToID(platform),
-			Platform:        platform,
+			PlatformID:      int32(platformID),
+			Platform:        constant.PlatformIDToName(platformID),
 		},
 		Seq: time.Now().Nanosecond() / 1e6,
 	}

internal/msg_gateway/gate/logic.go

@@ -19,19 +19,12 @@ import (
 )
 
 func (ws *WServer) msgParse(conn *UserConn, binaryMsg []byte) {
-	//ws online debug data
-	//{"ReqIdentifier":1001,"Token":"123","SendID":"c4ca4238a0b923820dcc509a6f75849b","Time":"123","OperationID":"123","MsgIncr":0}
-	//{"ReqIdentifier":1002,"Token":"123","SendID":"c4ca4238a0b923820dcc509a6f75849b","Time":"123","OperationID":"123","MsgIncr":0,"SeqBegin":1,"SeqEnd":6}
-	//{"ReqIdentifier":1003,"Token":"123","SendID":"c4ca4238a0b923820dcc509a6f75849b",
-	//"RecvID":"a87ff679a2f3e71d9181a67b7542122c","ClientMsgID":"2343","Time":"147878787","OperationID":
-	//"123","MsgIncr":0,"SubMsgType":101,"MsgType":100,"MsgFrom":1,"Content":"sdfsdf"}
 	b := bytes.NewBuffer(binaryMsg)
 	m := Req{}
 	dec := gob.NewDecoder(b)
 	err := dec.Decode(&m)
 	if err != nil {
 		log.NewError("", "ws Decode  err", err.Error())
-		ws.sendErrMsg(conn, 200, err.Error(), constant.WSDataError, "", "")
 		err = conn.Close()
 		if err != nil {
 			log.NewError("", "ws close err", err.Error())
@@ -43,49 +36,69 @@ func (ws *WServer) msgParse(conn *UserConn, binaryMsg []byte) {
 		ws.sendErrMsg(conn, 201, err.Error(), m.ReqIdentifier, m.MsgIncr, m.OperationID)
 		return
 	}
-	//if !utils.VerifyToken(m.Token, m.SendID) {
-	//	ws.sendErrMsg(conn, 202, "token validate err", m.ReqIdentifier, m.MsgIncr,m.OperationID)
-	//	return
-	//}
-	log.NewInfo(m.OperationID, "Basic Info Authentication Success", m)
+	log.NewInfo(m.OperationID, "Basic Info Authentication Success", m.SendID, m.MsgIncr, m.ReqIdentifier)
 
 	switch m.ReqIdentifier {
 	case constant.WSGetNewestSeq:
+		log.NewInfo(m.OperationID, "getSeqReq ", m.SendID, m.MsgIncr, m.ReqIdentifier)
 		ws.getSeqReq(conn, &m)
 	case constant.WSSendMsg:
+		log.NewInfo(m.OperationID, "sendMsgReq ", m.SendID, m.MsgIncr, m.ReqIdentifier)
 		ws.sendMsgReq(conn, &m)
 	case constant.WSSendSignalMsg:
+		log.NewInfo(m.OperationID, "sendSignalMsgReq ", m.SendID, m.MsgIncr, m.ReqIdentifier)
 		ws.sendSignalMsgReq(conn, &m)
 	case constant.WSPullMsgBySeqList:
+		log.NewInfo(m.OperationID, "pullMsgBySeqListReq ", m.SendID, m.MsgIncr, m.ReqIdentifier)
 		ws.pullMsgBySeqListReq(conn, &m)
 	default:
+		log.Error(m.OperationID, "ReqIdentifier failed ", m.SendID, m.MsgIncr, m.ReqIdentifier)
 	}
 	log.NewInfo(m.OperationID, "goroutine num is ", runtime.NumGoroutine())
 }
+
 func (ws *WServer) getSeqReq(conn *UserConn, m *Req) {
-	log.NewInfo(m.OperationID, "Ws call success to getNewSeq", m.MsgIncr, m.SendID, m.ReqIdentifier, m.Data)
-	rpcReq := pbChat.GetMaxAndMinSeqReq{}
-	nReply := new(pbChat.GetMaxAndMinSeqResp)
-	rpcReq.UserID = m.SendID
-	rpcReq.OperationID = m.OperationID
-	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
-	msgClient := pbChat.NewChatClient(grpcConn)
-	rpcReply, err := msgClient.GetMaxAndMinSeq(context.Background(), &rpcReq)
-	if err != nil {
-		log.Error(rpcReq.OperationID, "rpc call failed to getSeqReq", err, rpcReq.String())
-		nReply.ErrCode = 500
-		nReply.ErrMsg = err.Error()
-		ws.getSeqResp(conn, m, nReply)
+	log.NewInfo(m.OperationID, "Ws call success to getNewSeq", m.MsgIncr, m.SendID, m.ReqIdentifier)
+	nReply := new(sdk_ws.GetMaxAndMinSeqResp)
+	isPass, errCode, errMsg, data := ws.argsValidate(m, constant.WSGetNewestSeq, m.OperationID)
+	log.Info(m.OperationID, "argsValidate ", isPass, errCode, errMsg)
+	if isPass {
+		rpcReq := sdk_ws.GetMaxAndMinSeqReq{}
+		rpcReq.GroupIDList = data.(sdk_ws.GetMaxAndMinSeqReq).GroupIDList
+		rpcReq.UserID = m.SendID
+		rpcReq.OperationID = m.OperationID
+		log.Debug(m.OperationID, "Ws call success to getMaxAndMinSeq", m.SendID, m.ReqIdentifier, m.MsgIncr, data.(sdk_ws.GetMaxAndMinSeqReq).GroupIDList)
+		grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, rpcReq.OperationID)
+		if grpcConn == nil {
+			errMsg := rpcReq.OperationID + "getcdv3.GetConn == nil"
+			nReply.ErrCode = 500
+			nReply.ErrMsg = errMsg
+			log.NewError(rpcReq.OperationID, errMsg)
+			ws.getSeqResp(conn, m, nReply)
+			return
+		}
+		msgClient := pbChat.NewChatClient(grpcConn)
+		rpcReply, err := msgClient.GetMaxAndMinSeq(context.Background(), &rpcReq)
+		if err != nil {
+			nReply.ErrCode = 500
+			nReply.ErrMsg = err.Error()
+			log.Error(rpcReq.OperationID, "rpc call failed to GetMaxAndMinSeq ", nReply.String())
+			ws.getSeqResp(conn, m, nReply)
+		} else {
+			log.NewInfo(rpcReq.OperationID, "rpc call success to getSeqReq", rpcReply.String())
+			ws.getSeqResp(conn, m, rpcReply)
+		}
 	} else {
-		log.NewInfo(rpcReq.OperationID, "rpc call success to getSeqReq", rpcReply.String())
-		ws.getSeqResp(conn, m, rpcReply)
+		nReply.ErrCode = errCode
+		nReply.ErrMsg = errMsg
+		log.Error(m.OperationID, "argsValidate failed send resp: ", nReply.String())
+		ws.getSeqResp(conn, m, nReply)
 	}
 }
-func (ws *WServer) getSeqResp(conn *UserConn, m *Req, pb *pbChat.GetMaxAndMinSeqResp) {
-	var mReplyData sdk_ws.GetMaxAndMinSeqResp
-	mReplyData.MaxSeq = pb.GetMaxSeq()
-	mReplyData.MinSeq = pb.GetMinSeq()
-	b, _ := proto.Marshal(&mReplyData)
+
+func (ws *WServer) getSeqResp(conn *UserConn, m *Req, pb *sdk_ws.GetMaxAndMinSeqResp) {
+
+	b, _ := proto.Marshal(pb)
 	mReply := Resp{
 		ReqIdentifier: m.ReqIdentifier,
 		MsgIncr:       m.MsgIncr,
@@ -94,20 +107,31 @@ func (ws *WServer) getSeqResp(conn *UserConn, m *Req, pb *pbChat.GetMaxAndMinSeq
 		OperationID:   m.OperationID,
 		Data:          b,
 	}
+	log.Debug(m.OperationID, "getSeqResp come  here req: ", pb.String(), "send resp: ",
+		mReply.ReqIdentifier, mReply.MsgIncr, mReply.ErrCode, mReply.ErrMsg)
 	ws.sendMsg(conn, mReply)
 }
 
 func (ws *WServer) pullMsgBySeqListReq(conn *UserConn, m *Req) {
-	log.NewInfo(m.OperationID, "Ws call success to pullMsgBySeqListReq start", m.SendID, m.ReqIdentifier, m.MsgIncr, m.Data)
+	log.NewInfo(m.OperationID, "Ws call success to pullMsgBySeqListReq start", m.SendID, m.ReqIdentifier, m.MsgIncr, string(m.Data))
 	nReply := new(sdk_ws.PullMessageBySeqListResp)
-	isPass, errCode, errMsg, data := ws.argsValidate(m, constant.WSPullMsgBySeqList)
+	isPass, errCode, errMsg, data := ws.argsValidate(m, constant.WSPullMsgBySeqList, m.OperationID)
 	if isPass {
 		rpcReq := sdk_ws.PullMessageBySeqListReq{}
 		rpcReq.SeqList = data.(sdk_ws.PullMessageBySeqListReq).SeqList
 		rpcReq.UserID = m.SendID
 		rpcReq.OperationID = m.OperationID
+		rpcReq.GroupSeqList = data.(sdk_ws.PullMessageBySeqListReq).GroupSeqList
 		log.NewInfo(m.OperationID, "Ws call success to pullMsgBySeqListReq middle", m.SendID, m.ReqIdentifier, m.MsgIncr, data.(sdk_ws.PullMessageBySeqListReq).SeqList)
-		grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+		grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, m.OperationID)
+		if grpcConn == nil {
+			errMsg := rpcReq.OperationID + "getcdv3.GetConn == nil"
+			nReply.ErrCode = 500
+			nReply.ErrMsg = errMsg
+			log.NewError(rpcReq.OperationID, errMsg)
+			ws.pullMsgBySeqListResp(conn, m, nReply)
+			return
+		}
 		msgClient := pbChat.NewChatClient(grpcConn)
 		reply, err := msgClient.PullMessageBySeqList(context.Background(), &rpcReq)
 		if err != nil {
@@ -149,7 +173,7 @@ func (ws *WServer) sendMsgReq(conn *UserConn, m *Req) {
 	log.NewInfo(m.OperationID, "Ws call success to sendMsgReq start", m.MsgIncr, m.ReqIdentifier, m.SendID, m.Data)
 
 	nReply := new(pbChat.SendMsgResp)
-	isPass, errCode, errMsg, pData := ws.argsValidate(m, constant.WSSendMsg)
+	isPass, errCode, errMsg, pData := ws.argsValidate(m, constant.WSSendMsg, m.OperationID)
 	if isPass {
 		data := pData.(sdk_ws.MsgData)
 		pbData := pbChat.SendMsgReq{
@@ -158,7 +182,15 @@ func (ws *WServer) sendMsgReq(conn *UserConn, m *Req) {
 			MsgData:     &data,
 		}
 		log.NewInfo(m.OperationID, "Ws call success to sendMsgReq middle", m.ReqIdentifier, m.SendID, m.MsgIncr, data)
-		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, m.OperationID)
+		if etcdConn == nil {
+			errMsg := m.OperationID + "getcdv3.GetConn == nil"
+			nReply.ErrCode = 500
+			nReply.ErrMsg = errMsg
+			log.NewError(m.OperationID, errMsg)
+			ws.sendMsgResp(conn, m, nReply)
+			return
+		}
 		client := pbChat.NewChatClient(etcdConn)
 		reply, err := client.SendMsg(context.Background(), &pbData)
 		if err != nil {
@@ -179,8 +211,6 @@ func (ws *WServer) sendMsgReq(conn *UserConn, m *Req) {
 
 }
 func (ws *WServer) sendMsgResp(conn *UserConn, m *Req, pb *pbChat.SendMsgResp) {
-	// := make(map[string]interface{})
-
 	var mReplyData sdk_ws.UserSendMsgResp
 	mReplyData.ClientMsgID = pb.GetClientMsgID()
 	mReplyData.ServerMsgID = pb.GetServerMsgID()
@@ -198,12 +228,18 @@ func (ws *WServer) sendMsgResp(conn *UserConn, m *Req, pb *pbChat.SendMsgResp) {
 }
 
 func (ws *WServer) sendSignalMsgReq(conn *UserConn, m *Req) {
-	log.NewInfo(m.OperationID, "Ws call success to sendSignalMsgReq start", m.MsgIncr, m.ReqIdentifier, m.SendID, string(m.Data), m.Token)
+	log.NewInfo(m.OperationID, "Ws call success to sendSignalMsgReq start", m.MsgIncr, m.ReqIdentifier, m.SendID, string(m.Data))
 	nReply := new(pbChat.SendMsgResp)
-	isPass, errCode, errMsg, pData := ws.argsValidate(m, constant.WSSendSignalMsg)
+	isPass, errCode, errMsg, pData := ws.argsValidate(m, constant.WSSendSignalMsg, m.OperationID)
 	if isPass {
 		signalResp := pbRtc.SignalResp{}
-		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImRealTimeCommName)
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImRealTimeCommName, m.OperationID)
+		if etcdConn == nil {
+			errMsg := m.OperationID + "getcdv3.GetConn == nil"
+			log.NewError(m.OperationID, errMsg)
+			ws.sendSignalMsgResp(conn, 204, errMsg, m, &signalResp)
+			return
+		}
 		rtcClient := pbRtc.NewRtcServiceClient(etcdConn)
 		req := &pbRtc.SignalMessageAssembleReq{
 			SignalReq:   pData.(*pbRtc.SignalReq),
@@ -226,8 +262,14 @@ func (ws *WServer) sendSignalMsgReq(conn *UserConn, m *Req) {
 				MsgData:     &msgData,
 			}
 			log.NewInfo(m.OperationID, utils.GetSelfFuncName(), "pbData: ", pbData)
-			log.NewInfo(m.OperationID, "Ws call success to sendSignalMsgReq middle", m.ReqIdentifier, m.SendID, m.MsgIncr, "session Type", msgData.SessionType)
-			etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+			log.NewInfo(m.OperationID, "Ws call success to sendSignalMsgReq middle", m.ReqIdentifier, m.SendID, m.MsgIncr, msgData)
+			etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, m.OperationID)
+			if etcdConn == nil {
+				errMsg := m.OperationID + "getcdv3.GetConn == nil"
+				log.NewError(m.OperationID, errMsg)
+				ws.sendSignalMsgResp(conn, 200, errMsg, m, &signalResp)
+				return
+			}
 			client := pbChat.NewChatClient(etcdConn)
 			reply, err := client.SendMsg(context.Background(), &pbData)
 			if err != nil {
@@ -250,7 +292,7 @@ func (ws *WServer) sendSignalMsgReq(conn *UserConn, m *Req) {
 }
 func (ws *WServer) sendSignalMsgResp(conn *UserConn, errCode int32, errMsg string, m *Req, pb *pbRtc.SignalResp) {
 	// := make(map[string]interface{})
-	log.Debug(m.OperationID, "SignalMsgResp is", pb.String())
+	log.Debug(m.OperationID, "sendSignalMsgResp is", pb.String())
 	b, _ := proto.Marshal(pb)
 	mReply := Resp{
 		ReqIdentifier: m.ReqIdentifier,
@@ -267,14 +309,16 @@ func (ws *WServer) sendMsg(conn *UserConn, mReply interface{}) {
 	enc := gob.NewEncoder(&b)
 	err := enc.Encode(mReply)
 	if err != nil {
-		uid, platform := ws.getUserUid(conn)
-		log.NewError(mReply.(Resp).OperationID, mReply.(Resp).ReqIdentifier, mReply.(Resp).ErrCode, mReply.(Resp).ErrMsg, "Encode Msg error", conn.RemoteAddr().String(), uid, platform, err.Error())
+		//	uid, platform := ws.getUserUid(conn)
+		log.NewError(mReply.(Resp).OperationID, mReply.(Resp).ReqIdentifier, mReply.(Resp).ErrCode, mReply.(Resp).ErrMsg, "Encode Msg error", conn.RemoteAddr().String(), err.Error())
 		return
 	}
 	err = ws.writeMsg(conn, websocket.BinaryMessage, b.Bytes())
 	if err != nil {
-		uid, platform := ws.getUserUid(conn)
-		log.NewError(mReply.(Resp).OperationID, mReply.(Resp).ReqIdentifier, mReply.(Resp).ErrCode, mReply.(Resp).ErrMsg, "WS WriteMsg error", conn.RemoteAddr().String(), uid, platform, err.Error())
+		//	uid, platform := ws.getUserUid(conn)
+		log.NewError(mReply.(Resp).OperationID, mReply.(Resp).ReqIdentifier, mReply.(Resp).ErrCode, mReply.(Resp).ErrMsg, "ws writeMsg error", conn.RemoteAddr().String(), err.Error())
+	} else {
+		log.Debug(mReply.(Resp).OperationID, mReply.(Resp).ReqIdentifier, mReply.(Resp).ErrCode, mReply.(Resp).ErrMsg, "ws write response success")
 	}
 }
 func (ws *WServer) sendErrMsg(conn *UserConn, errCode int32, errMsg string, reqIdentifier int32, msgIncr string, operationID string) {

internal/msg_gateway/gate/rpc_server.go

@@ -7,6 +7,7 @@ import (
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	pbRelay "Open_IM/pkg/proto/relay"
+	sdk_ws "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"bytes"
 	"context"
@@ -25,6 +26,8 @@ type RPCServer struct {
 	rpcRegisterName string
 	etcdSchema      string
 	etcdAddr        []string
+	platformList    []int
+	pushTerminal    []int
 }
 
 func (r *RPCServer) onInit(rpcPort int) {
@@ -32,6 +35,8 @@ func (r *RPCServer) onInit(rpcPort int) {
 	r.rpcRegisterName = config.Config.RpcRegisterName.OpenImOnlineMessageRelayName
 	r.etcdSchema = config.Config.Etcd.EtcdSchema
 	r.etcdAddr = config.Config.Etcd.EtcdAddr
+	r.platformList = genPlatformArray()
+	r.pushTerminal = []int{constant.IOSPlatformID, constant.AndroidPlatformID}
 }
 func (r *RPCServer) run() {
 	listenIP := ""
@@ -69,7 +74,7 @@ func (r *RPCServer) run() {
 }
 func (r *RPCServer) OnlinePushMsg(_ context.Context, in *pbRelay.OnlinePushMsgReq) (*pbRelay.OnlinePushMsgResp, error) {
 	log.NewInfo(in.OperationID, "PushMsgToUser is arriving", in.String())
-	var resp []*pbRelay.SingleMsgToUser
+	var resp []*pbRelay.SingleMsgToUserPlatform
 	msgBytes, _ := proto.Marshal(in.MsgData)
 	mReply := Resp{
 		ReqIdentifier: constant.WSPushMsg,
@@ -84,22 +89,21 @@ func (r *RPCServer) OnlinePushMsg(_ context.Context, in *pbRelay.OnlinePushMsgRe
 	}
 	var tag bool
 	recvID := in.PushToUserID
-	platformList := genPlatformArray()
-	for _, v := range platformList {
+	for _, v := range r.platformList {
 		if conn := ws.getUserConn(recvID, v); conn != nil {
 			tag = true
 			resultCode := sendMsgToUser(conn, replyBytes.Bytes(), in, v, recvID)
-			temp := &pbRelay.SingleMsgToUser{
+			temp := &pbRelay.SingleMsgToUserPlatform{
 				ResultCode:     resultCode,
 				RecvID:         recvID,
-				RecvPlatFormID: constant.PlatformNameToID(v),
+				RecvPlatFormID: int32(v),
 			}
 			resp = append(resp, temp)
 		} else {
-			temp := &pbRelay.SingleMsgToUser{
+			temp := &pbRelay.SingleMsgToUserPlatform{
 				ResultCode:     -1,
 				RecvID:         recvID,
-				RecvPlatFormID: constant.PlatformNameToID(v),
+				RecvPlatFormID: int32(v),
 			}
 			resp = append(resp, temp)
 		}
@@ -119,19 +123,19 @@ func (r *RPCServer) GetUsersOnlineStatus(_ context.Context, req *pbRelay.GetUser
 	}
 	var resp pbRelay.GetUsersOnlineStatusResp
 	for _, userID := range req.UserIDList {
-		platformList := genPlatformArray()
 		temp := new(pbRelay.GetUsersOnlineStatusResp_SuccessResult)
 		temp.UserID = userID
-		for _, platform := range platformList {
-			if conn := ws.getUserConn(userID, platform); conn != nil {
+		userConnMap := ws.getUserAllCons(userID)
+		for platform, userConn := range userConnMap {
+			if userConn != nil {
 				ps := new(pbRelay.GetUsersOnlineStatusResp_SuccessDetail)
-				ps.Platform = platform
+				ps.Platform = constant.PlatformIDToName(platform)
 				ps.Status = constant.OnlineStatus
 				temp.Status = constant.OnlineStatus
 				temp.DetailPlatformStatus = append(temp.DetailPlatformStatus, ps)
-
 			}
 		}
+
 		if temp.Status == constant.OnlineStatus {
 			resp.SuccessResult = append(resp.SuccessResult, temp)
 		}
@@ -139,11 +143,165 @@ func (r *RPCServer) GetUsersOnlineStatus(_ context.Context, req *pbRelay.GetUser
 	log.NewInfo(req.OperationID, "GetUsersOnlineStatus rpc return ", resp.String())
 	return &resp, nil
 }
-func sendMsgToUser(conn *UserConn, bMsg []byte, in *pbRelay.OnlinePushMsgReq, RecvPlatForm, RecvID string) (ResultCode int64) {
+
+func (r *RPCServer) SuperGroupOnlineBatchPushOneMsg(_ context.Context, req *pbRelay.OnlineBatchPushOneMsgReq) (*pbRelay.OnlineBatchPushOneMsgResp, error) {
+	log.NewInfo(req.OperationID, "BatchPushMsgToUser is arriving", req.String())
+	var singleUserResult []*pbRelay.SingelMsgToUserResultList
+	//r.GetBatchMsgForPush(req.OperationID,req.MsgData,req.PushToUserIDList,)
+	msgBytes, _ := proto.Marshal(req.MsgData)
+	mReply := Resp{
+		ReqIdentifier: constant.WSPushMsg,
+		OperationID:   req.OperationID,
+		Data:          msgBytes,
+	}
+	var replyBytes bytes.Buffer
+	enc := gob.NewEncoder(&replyBytes)
+	err := enc.Encode(mReply)
+	if err != nil {
+		log.NewError(req.OperationID, "data encode err", err.Error())
+	}
+	for _, v := range req.PushToUserIDList {
+		var resp []*pbRelay.SingleMsgToUserPlatform
+		tempT := &pbRelay.SingelMsgToUserResultList{
+			UserID: v,
+		}
+		userConnMap := ws.getUserAllCons(v)
+		for platform, userConn := range userConnMap {
+			if userConn != nil {
+				resultCode := sendMsgBatchToUser(userConn, replyBytes.Bytes(), req, platform, v)
+				if resultCode == 0 && utils.IsContainInt(platform, r.pushTerminal) {
+					tempT.OnlinePush = true
+					log.Info(req.OperationID, "PushSuperMsgToUser is success By Ws", "args", req.String(), "recvPlatForm", constant.PlatformIDToName(platform), "recvID", v)
+					temp := &pbRelay.SingleMsgToUserPlatform{
+						ResultCode:     resultCode,
+						RecvID:         v,
+						RecvPlatFormID: int32(platform),
+					}
+					resp = append(resp, temp)
+				}
+
+			}
+		}
+		tempT.Resp = resp
+		singleUserResult = append(singleUserResult, tempT)
+
+	}
+
+	return &pbRelay.OnlineBatchPushOneMsgResp{
+		SinglePushResult: singleUserResult,
+	}, nil
+}
+func (r *RPCServer) OnlineBatchPushOneMsg(_ context.Context, req *pbRelay.OnlineBatchPushOneMsgReq) (*pbRelay.OnlineBatchPushOneMsgResp, error) {
+	log.NewInfo(req.OperationID, "BatchPushMsgToUser is arriving", req.String())
+	var singleUserResult []*pbRelay.SingelMsgToUserResultList
+
+	for _, v := range req.PushToUserIDList {
+		var resp []*pbRelay.SingleMsgToUserPlatform
+		tempT := &pbRelay.SingelMsgToUserResultList{
+			UserID: v,
+		}
+		userConnMap := ws.getUserAllCons(v)
+		var platformList []int
+		for k, _ := range userConnMap {
+			platformList = append(platformList, k)
+		}
+		log.Debug(req.OperationID, "GetSingleUserMsgForPushPlatforms begin", req.MsgData.Seq, v, platformList, req.MsgData.String())
+		needPushMapList := r.GetSingleUserMsgForPushPlatforms(req.OperationID, req.MsgData, v, platformList)
+		log.Debug(req.OperationID, "GetSingleUserMsgForPushPlatforms end", req.MsgData.Seq, v, platformList, len(needPushMapList))
+		for platform, list := range needPushMapList {
+			if list != nil {
+				log.Debug(req.OperationID, "needPushMapList ", "userID: ", v, "platform: ", platform, "push msg num:")
+				//for _, v := range list {
+				//	log.Debug(req.OperationID, "req.MsgData.MsgDataList begin", "len: ", len(req.MsgData.MsgDataList), v.String())
+				//	req.MsgData.MsgDataList = append(req.MsgData.MsgDataList, v)
+				//	log.Debug(req.OperationID, "req.MsgData.MsgDataList end", "len: ", len(req.MsgData.MsgDataList))
+				//}
+				msgBytes, err := proto.Marshal(list)
+				if err != nil {
+					log.Error(req.OperationID, "proto marshal err", err.Error())
+					continue
+				}
+				req.MsgData.MsgDataList = msgBytes
+				//req.MsgData.MsgDataList = append(req.MsgData.MsgDataList, v)
+				log.Debug(req.OperationID, "r.encodeWsData  no string")
+				//log.Debug(req.OperationID, "r.encodeWsData  data0 list ", req.MsgData.MsgDataList[0].String())
+
+				log.Debug(req.OperationID, "r.encodeWsData  ", req.MsgData.String())
+				replyBytes, err := r.encodeWsData(req.MsgData, req.OperationID)
+				if err != nil {
+					log.Error(req.OperationID, "encodeWsData failed ", req.MsgData.String())
+					continue
+				}
+				log.Debug(req.OperationID, "encodeWsData", "len: ", replyBytes.Len())
+				resultCode := sendMsgBatchToUser(userConnMap[platform], replyBytes.Bytes(), req, platform, v)
+				if resultCode == 0 && utils.IsContainInt(platform, r.pushTerminal) {
+					tempT.OnlinePush = true
+					log.Info(req.OperationID, "PushSuperMsgToUser is success By Ws", "args", req.String(), "recv PlatForm", constant.PlatformIDToName(platform), "recvID", v)
+					temp := &pbRelay.SingleMsgToUserPlatform{
+						ResultCode:     resultCode,
+						RecvID:         v,
+						RecvPlatFormID: int32(platform),
+					}
+					resp = append(resp, temp)
+				}
+			} else {
+				if utils.IsContainInt(platform, r.pushTerminal) {
+					tempT.OnlinePush = true
+					temp := &pbRelay.SingleMsgToUserPlatform{
+						ResultCode:     0,
+						RecvID:         v,
+						RecvPlatFormID: int32(platform),
+					}
+					resp = append(resp, temp)
+				}
+			}
+		}
+		tempT.Resp = resp
+		singleUserResult = append(singleUserResult, tempT)
+	}
+	return &pbRelay.OnlineBatchPushOneMsgResp{
+		SinglePushResult: singleUserResult,
+	}, nil
+}
+func (r *RPCServer) encodeWsData(wsData *sdk_ws.MsgData, operationID string) (bytes.Buffer, error) {
+	log.Debug(operationID, "encodeWsData begin", wsData.String())
+	msgBytes, err := proto.Marshal(wsData)
+	if err != nil {
+		log.NewError(operationID, "Marshal", err.Error())
+		return bytes.Buffer{}, utils.Wrap(err, "")
+	}
+	log.Debug(operationID, "encodeWsData begin", wsData.String())
+	mReply := Resp{
+		ReqIdentifier: constant.WSPushMsg,
+		OperationID:   operationID,
+		Data:          msgBytes,
+	}
+	var replyBytes bytes.Buffer
+	enc := gob.NewEncoder(&replyBytes)
+	err = enc.Encode(mReply)
+	if err != nil {
+		log.NewError(operationID, "data encode err", err.Error())
+		return bytes.Buffer{}, utils.Wrap(err, "")
+	}
+	return replyBytes, nil
+}
+
+func (r *RPCServer) KickUserOffline(_ context.Context, req *pbRelay.KickUserOfflineReq) (*pbRelay.KickUserOfflineResp, error) {
+	log.NewInfo(req.OperationID, "KickUserOffline is arriving", req.String())
+	for _, v := range req.KickUserIDList {
+		oldConnMap := ws.getUserAllCons(v)
+		if conn, ok := oldConnMap[int(req.PlatformID)]; ok { // user->map[platform->conn]
+			ws.sendKickMsg(conn, &UserConn{})
+		}
+	}
+	return &pbRelay.KickUserOfflineResp{}, nil
+
+}
+func sendMsgToUser(conn *UserConn, bMsg []byte, in *pbRelay.OnlinePushMsgReq, RecvPlatForm int, RecvID string) (ResultCode int64) {
 	err := ws.writeMsg(conn, websocket.BinaryMessage, bMsg)
 	if err != nil {
 		log.NewError(in.OperationID, "PushMsgToUser is failed By Ws", "Addr", conn.RemoteAddr().String(),
-			"error", err, "senderPlatform", constant.PlatformIDToName(in.MsgData.SenderPlatformID), "recvPlatform", RecvPlatForm, "args", in.String(), "recvID", RecvID)
+			"error", err, "senderPlatform", constant.PlatformIDToName(int(in.MsgData.SenderPlatformID)), "recvPlatform", RecvPlatForm, "args", in.String(), "recvID", RecvID)
 		ResultCode = -2
 		return ResultCode
 	} else {
@@ -153,9 +311,23 @@ func sendMsgToUser(conn *UserConn, bMsg []byte, in *pbRelay.OnlinePushMsgReq, Re
 	}
 
 }
-func genPlatformArray() (array []string) {
+func sendMsgBatchToUser(conn *UserConn, bMsg []byte, in *pbRelay.OnlineBatchPushOneMsgReq, RecvPlatForm int, RecvID string) (ResultCode int64) {
+	err := ws.writeMsg(conn, websocket.BinaryMessage, bMsg)
+	if err != nil {
+		log.NewError(in.OperationID, "PushMsgToUser is failed By Ws", "Addr", conn.RemoteAddr().String(),
+			"error", err, "senderPlatform", constant.PlatformIDToName(int(in.MsgData.SenderPlatformID)), "recv Platform", RecvPlatForm, "args", in.String(), "recvID", RecvID)
+		ResultCode = -2
+		return ResultCode
+	} else {
+		log.NewDebug(in.OperationID, "PushMsgToUser is success By Ws", "args", in.String(), "recv PlatForm", RecvPlatForm, "recvID", RecvID)
+		ResultCode = 0
+		return ResultCode
+	}
+
+}
+func genPlatformArray() (array []int) {
 	for i := 1; i <= constant.LinuxPlatformID; i++ {
-		array = append(array, constant.PlatformIDToName(int32(i)))
+		array = append(array, i)
 	}
 	return array
 }

internal/msg_gateway/gate/validate.go

@@ -57,16 +57,28 @@ type SeqListData struct {
 	SeqList []int64 `mapstructure:"seqList" validate:"required"`
 }
 
-func (ws *WServer) argsValidate(m *Req, r int32) (isPass bool, errCode int32, errMsg string, returnData interface{}) {
+func (ws *WServer) argsValidate(m *Req, r int32, operationID string) (isPass bool, errCode int32, errMsg string, returnData interface{}) {
 	switch r {
-	case constant.WSSendMsg:
-		data := open_im_sdk.MsgData{}
+	case constant.WSGetNewestSeq:
+		data := open_im_sdk.GetMaxAndMinSeqReq{}
 		if err := proto.Unmarshal(m.Data, &data); err != nil {
-			log.Error("", "Decode Data struct  err", err.Error(), r)
+			log.Error(operationID, "Decode Data struct  err", err.Error(), r)
 			return false, 203, err.Error(), nil
 		}
 		if err := validate.Struct(data); err != nil {
-			log.Error("", "data args validate  err", err.Error(), r)
+			log.Error(operationID, "data args validate  err", err.Error(), r)
+			return false, 204, err.Error(), nil
+
+		}
+		return true, 0, "", data
+	case constant.WSSendMsg:
+		data := open_im_sdk.MsgData{}
+		if err := proto.Unmarshal(m.Data, &data); err != nil {
+			log.Error(operationID, "Decode Data struct  err", err.Error(), r)
+			return false, 203, err.Error(), nil
+		}
+		if err := validate.Struct(data); err != nil {
+			log.Error(operationID, "data args validate  err", err.Error(), r)
 			return false, 204, err.Error(), nil
 
 		}
@@ -74,11 +86,11 @@ func (ws *WServer) argsValidate(m *Req, r int32) (isPass bool, errCode int32, er
 	case constant.WSSendSignalMsg:
 		data := pbRtc.SignalReq{}
 		if err := proto.Unmarshal(m.Data, &data); err != nil {
-			log.Error("", "Decode Data struct  err", err.Error(), r)
+			log.Error(operationID, "Decode Data struct  err", err.Error(), r)
 			return false, 203, err.Error(), nil
 		}
 		if err := validate.Struct(data); err != nil {
-			log.Error("", "data args validate  err", err.Error(), r)
+			log.Error(operationID, "data args validate  err", err.Error(), r)
 			return false, 204, err.Error(), nil
 
 		}
@@ -86,31 +98,16 @@ func (ws *WServer) argsValidate(m *Req, r int32) (isPass bool, errCode int32, er
 	case constant.WSPullMsgBySeqList:
 		data := open_im_sdk.PullMessageBySeqListReq{}
 		if err := proto.Unmarshal(m.Data, &data); err != nil {
-			log.Error("", "Decode Data struct  err", err.Error(), r)
+			log.Error(operationID, "Decode Data struct  err", err.Error(), r)
 			return false, 203, err.Error(), nil
 		}
 		if err := validate.Struct(data); err != nil {
-			log.Error("", "data args validate  err", err.Error(), r)
+			log.Error(operationID, "data args validate  err", err.Error(), r)
 			return false, 204, err.Error(), nil
 
 		}
 		return true, 0, "", data
-
 	default:
 	}
-
 	return false, 204, "args err", nil
-
-	//b := bytes.NewBuffer(m.Data)
-	//dec := gob.NewDecoder(b)
-	//err := dec.Decode(&data)
-	//if err != nil {
-	//	log.ErrorByKv("Decode Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
-	//	return false, 203, err.Error(), nil
-	//}
-	//if err := mapstructure.WeakDecode(m.Data, &data); err != nil {
-	//	log.ErrorByKv("map to Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
-	//	return false, 203, err.Error(), nil
-	//} else
-
 }

internal/msg_gateway/gate/ws_server.go

@@ -9,7 +9,7 @@ import (
 	"Open_IM/pkg/utils"
 	"bytes"
 	"encoding/gob"
-	"github.com/garyburd/redigo/redis"
+	go_redis "github.com/go-redis/redis/v8"
 	"net/http"
 	"sync"
 	"time"
@@ -19,21 +19,22 @@ import (
 
 type UserConn struct {
 	*websocket.Conn
-	w *sync.Mutex
+	w            *sync.Mutex
+	PushedMaxSeq uint32
 }
 type WServer struct {
 	wsAddr       string
 	wsMaxConnNum int
 	wsUpGrader   *websocket.Upgrader
-	wsConnToUser map[*UserConn]map[string]string
-	wsUserToConn map[string]map[string]*UserConn
+	wsConnToUser map[*UserConn]map[int]string
+	wsUserToConn map[string]map[int]*UserConn
 }
 
 func (ws *WServer) onInit(wsPort int) {
 	ws.wsAddr = ":" + utils.IntToString(wsPort)
 	ws.wsMaxConnNum = config.Config.LongConnSvr.WebsocketMaxConnNum
-	ws.wsConnToUser = make(map[*UserConn]map[string]string)
-	ws.wsUserToConn = make(map[string]map[string]*UserConn)
+	ws.wsConnToUser = make(map[*UserConn]map[int]string)
+	ws.wsUserToConn = make(map[string]map[int]*UserConn)
 	ws.wsUpGrader = &websocket.Upgrader{
 		HandshakeTimeout: time.Duration(config.Config.LongConnSvr.WebsocketTimeOut) * time.Second,
 		ReadBufferSize:   config.Config.LongConnSvr.WebsocketMaxMsgLen,
@@ -50,21 +51,27 @@ func (ws *WServer) run() {
 }
 
 func (ws *WServer) wsHandler(w http.ResponseWriter, r *http.Request) {
-	if ws.headerCheck(w, r) {
-		query := r.URL.Query()
+	query := r.URL.Query()
+	operationID := ""
+	if len(query["operationID"]) != 0 {
+		operationID = query["operationID"][0]
+	} else {
+		operationID = utils.OperationIDGenerator()
+	}
+	log.Debug(operationID, utils.GetSelfFuncName(), " args: ", query)
+	if ws.headerCheck(w, r, operationID) {
 		conn, err := ws.wsUpGrader.Upgrade(w, r, nil) //Conn is obtained through the upgraded escalator
 		if err != nil {
-			log.Error("", "upgrade http conn err", err, query)
+			log.Error(operationID, "upgrade http conn err", err.Error(), query)
 			return
 		} else {
-			//Connection mapping relationship,
-			//userID+" "+platformID->conn
-			//Initialize a lock for each user
-			newConn := &UserConn{conn, new(sync.Mutex)}
+			newConn := &UserConn{conn, new(sync.Mutex), 0}
 			userCount++
-			ws.addUserConn(query["sendID"][0], int32(utils.StringToInt64(query["platformID"][0])), newConn, query["token"][0])
+			ws.addUserConn(query["sendID"][0], utils.StringToInt(query["platformID"][0]), newConn, query["token"][0], operationID)
 			go ws.readMsg(newConn)
 		}
+	} else {
+		log.Error(operationID, "headerCheck failed ")
 	}
 }
 
@@ -75,18 +82,13 @@ func (ws *WServer) readMsg(conn *UserConn) {
 			log.NewInfo("", "this is a  pingMessage")
 		}
 		if err != nil {
-			uid, platform := ws.getUserUid(conn)
-			log.Error("", "WS ReadMsg error", "userIP", conn.RemoteAddr().String(), "userUid", uid, "platform", platform, "error", err.Error())
+			log.Error("", "WS ReadMsg error ", " userIP", conn.RemoteAddr().String(), "userUid", "platform", "error", err.Error())
 			userCount--
 			ws.delUserConn(conn)
 			return
-		} else {
-			//log.ErrorByKv("test", "", "msgType", msgType, "userIP", conn.RemoteAddr().String(), "userUid", ws.getUserUid(conn))
 		}
 		ws.msgParse(conn, msg)
-		//ws.writeMsg(conn, 1, chat)
 	}
-
 }
 
 func (ws *WServer) SetWriteTimeout(conn *UserConn, timeout int) {
@@ -108,37 +110,37 @@ func (ws *WServer) SetWriteTimeoutWriteMsg(conn *UserConn, a int, msg []byte, ti
 	conn.SetWriteDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
 	return conn.WriteMessage(a, msg)
 }
-
-func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int32, newConn *UserConn, token string, operationID string) {
+func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int, newConn *UserConn, token string, operationID string) {
 	switch config.Config.MultiLoginPolicy {
 	case constant.AllLoginButSameTermKick:
 		if oldConnMap, ok := ws.wsUserToConn[uid]; ok { // user->map[platform->conn]
-			if oldConn, ok := oldConnMap[constant.PlatformIDToName(platformID)]; ok {
-				log.NewWarn(operationID, uid, platformID, "kick old conn begin")
+			if oldConn, ok := oldConnMap[platformID]; ok {
+				log.NewDebug(operationID, uid, platformID, "kick old conn")
 				//	ws.sendKickMsg(oldConn, newConn)
-				log.NewWarn(operationID, uid, platformID, "kick old conn end")
 				m, err := db.DB.GetTokenMapByUidPid(uid, constant.PlatformIDToName(platformID))
-				if err != nil && err != redis.ErrNil {
-					log.NewError(operationID, "get token from redis err", err.Error(), uid)
+				if err != nil && err != go_redis.Nil {
+					log.NewError(operationID, "get token from redis err", err.Error(), uid, constant.PlatformIDToName(platformID))
 					return
 				}
 				if m == nil {
-					log.NewError(operationID, "get token from redis err", "m is nil")
+					log.NewError(operationID, "get token from redis err", "m is nil", uid, constant.PlatformIDToName(platformID))
 					return
 				}
+				log.NewDebug(operationID, "get token map is ", m, uid, constant.PlatformIDToName(platformID))
+
 				for k, _ := range m {
 					if k != token {
 						m[k] = constant.KickedToken
 					}
 				}
-				log.NewDebug(operationID, "get map is ", m)
+				log.NewDebug(operationID, "set token map is ", m, uid, constant.PlatformIDToName(platformID))
 				err = db.DB.SetTokenMapByUidPid(uid, platformID, m)
 				if err != nil {
-					log.NewError(operationID, "SetTokenMapByUidPid err", err.Error())
+					log.NewError(operationID, "SetTokenMapByUidPid err", err.Error(), uid, platformID, m)
 					return
 				}
 				err = oldConn.Close()
-				delete(oldConnMap, constant.PlatformIDToName(platformID))
+				delete(oldConnMap, platformID)
 				ws.wsUserToConn[uid] = oldConnMap
 				if len(oldConnMap) == 0 {
 					delete(ws.wsUserToConn, uid)
@@ -147,9 +149,8 @@ func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int32, newCo
 				if err != nil {
 					log.NewError(operationID, "conn close err", err.Error(), uid, platformID)
 				}
-
 			} else {
-				log.NewWarn(operationID, "abnormal uid-conn  ", uid, platformID, oldConnMap[constant.PlatformIDToName(platformID)])
+				log.NewWarn(operationID, "abnormal uid-conn  ", uid, platformID, oldConnMap[platformID])
 			}
 
 		} else {
@@ -173,37 +174,37 @@ func (ws *WServer) sendKickMsg(oldConn, newConn *UserConn) {
 		log.NewError(mReply.OperationID, mReply.ReqIdentifier, mReply.ErrCode, mReply.ErrMsg, "Encode Msg error", oldConn.RemoteAddr().String(), newConn.RemoteAddr().String(), err.Error())
 		return
 	}
-	//	ws.SetWriteTimeout(oldConn, 5)
 	err = ws.writeMsg(oldConn, websocket.BinaryMessage, b.Bytes())
 	if err != nil {
 		log.NewError(mReply.OperationID, mReply.ReqIdentifier, mReply.ErrCode, mReply.ErrMsg, "sendKickMsg WS WriteMsg error", oldConn.RemoteAddr().String(), newConn.RemoteAddr().String(), err.Error())
 	}
 }
-func (ws *WServer) addUserConn(uid string, platformID int32, conn *UserConn, token string) {
+
+func (ws *WServer) addUserConn(uid string, platformID int, conn *UserConn, token string, operationID string) {
 	rwLock.Lock()
 	defer rwLock.Unlock()
-	operationID := utils.OperationIDGenerator()
+	log.Info(operationID, utils.GetSelfFuncName(), " args: ", uid, platformID, conn, token)
 	callbackResp := callbackUserOnline(operationID, uid, platformID, token)
 	if callbackResp.ErrCode != 0 {
 		log.NewError(operationID, utils.GetSelfFuncName(), "callbackUserOnline resp:", callbackResp)
 	}
 	ws.MultiTerminalLoginChecker(uid, platformID, conn, token, operationID)
 	if oldConnMap, ok := ws.wsUserToConn[uid]; ok {
-		oldConnMap[constant.PlatformIDToName(platformID)] = conn
+		oldConnMap[platformID] = conn
 		ws.wsUserToConn[uid] = oldConnMap
 		log.Debug(operationID, "user not first come in, add conn ", uid, platformID, conn, oldConnMap)
 	} else {
-		i := make(map[string]*UserConn)
-		i[constant.PlatformIDToName(platformID)] = conn
+		i := make(map[int]*UserConn)
+		i[platformID] = conn
 		ws.wsUserToConn[uid] = i
 		log.Debug(operationID, "user first come in, new user, conn", uid, platformID, conn, ws.wsUserToConn[uid])
 	}
 	if oldStringMap, ok := ws.wsConnToUser[conn]; ok {
-		oldStringMap[constant.PlatformIDToName(platformID)] = uid
+		oldStringMap[platformID] = uid
 		ws.wsConnToUser[conn] = oldStringMap
 	} else {
-		i := make(map[string]string)
-		i[constant.PlatformIDToName(platformID)] = uid
+		i := make(map[int]string)
+		i[platformID] = uid
 		ws.wsConnToUser[conn] = i
 	}
 	count := 0
@@ -217,7 +218,8 @@ func (ws *WServer) delUserConn(conn *UserConn) {
 	rwLock.Lock()
 	defer rwLock.Unlock()
 	operationID := utils.OperationIDGenerator()
-	var platform, uid string
+	var uid string
+	var platform int
 	if oldStringMap, ok := ws.wsConnToUser[conn]; ok {
 		for k, v := range oldStringMap {
 			platform = k
@@ -250,7 +252,7 @@ func (ws *WServer) delUserConn(conn *UserConn) {
 	}
 }
 
-func (ws *WServer) getUserConn(uid string, platform string) *UserConn {
+func (ws *WServer) getUserConn(uid string, platform int) *UserConn {
 	rwLock.RLock()
 	defer rwLock.RUnlock()
 	if connMap, ok := ws.wsUserToConn[uid]; ok {
@@ -260,7 +262,7 @@ func (ws *WServer) getUserConn(uid string, platform string) *UserConn {
 	}
 	return nil
 }
-func (ws *WServer) getSingleUserAllConn(uid string) map[string]*UserConn {
+func (ws *WServer) getUserAllCons(uid string) map[int]*UserConn {
 	rwLock.RLock()
 	defer rwLock.RUnlock()
 	if connMap, ok := ws.wsUserToConn[uid]; ok {
@@ -268,46 +270,40 @@ func (ws *WServer) getSingleUserAllConn(uid string) map[string]*UserConn {
 	}
 	return nil
 }
-func (ws *WServer) getUserUid(conn *UserConn) (uid, platform string) {
-	rwLock.RLock()
-	defer rwLock.RUnlock()
 
-	if stringMap, ok := ws.wsConnToUser[conn]; ok {
-		for k, v := range stringMap {
-			platform = k
-			uid = v
-		}
-		return uid, platform
-	}
-	return "", ""
-}
-func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request) bool {
+//func (ws *WServer) getUserUid(conn *UserConn) (uid string, platform int) {
+//	rwLock.RLock()
+//	defer rwLock.RUnlock()
+//
+//	if stringMap, ok := ws.wsConnToUser[conn]; ok {
+//		for k, v := range stringMap {
+//			platform = k
+//			uid = v
+//		}
+//		return uid, platform
+//	}
+//	return "", 0
+//}
+func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request, operationID string) bool {
 	status := http.StatusUnauthorized
 	query := r.URL.Query()
-	operationID := ""
-	if len(query["operationID"]) != 0 {
-		operationID = query["operationID"][0]
-	}
 	if len(query["token"]) != 0 && len(query["sendID"]) != 0 && len(query["platformID"]) != 0 {
 		if ok, err, msg := token_verify.WsVerifyToken(query["token"][0], query["sendID"][0], query["platformID"][0], operationID); !ok {
-			//	e := err.(*constant.ErrInfo)
 			log.Error(operationID, "Token verify failed ", "query ", query, msg, err.Error())
 			w.Header().Set("Sec-Websocket-Version", "13")
 			w.Header().Set("ws_err_msg", err.Error())
 			http.Error(w, err.Error(), status)
 			return false
 		} else {
-			log.Info(operationID, "Connection Authentication Success", "", "token", query["token"][0], "userID", query["sendID"][0])
+			log.Info(operationID, "Connection Authentication Success", "", "token ", query["token"][0], "userID ", query["sendID"][0], "platformID ", query["platformID"][0])
 			return true
 		}
 	} else {
-		log.Error(operationID, "Args err", "query", query)
+		log.Error(operationID, "Args err ", "query ", query)
 		w.Header().Set("Sec-Websocket-Version", "13")
-		w.Header().Set("ws_err_msg", "args err, need token, sendID, platformID")
-		http.Error(w, http.StatusText(status), status)
+		errMsg := "args err, need token, sendID, platformID"
+		w.Header().Set("ws_err_msg", errMsg)
+		http.Error(w, errMsg, status)
 		return false
 	}
 }
-func genMapKey(uid string, platformID int32) string {
-	return uid + " " + constant.PlatformIDToName(platformID)
-}

internal/msg_transfer/logic/init.go

@@ -4,7 +4,6 @@ import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/kafka"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/statistics"
 	"fmt"
 	"sync"
@@ -14,15 +13,16 @@ const OnlineTopicBusy = 1
 const OnlineTopicVacancy = 0
 const Msg = 2
 const ConsumerMsgs = 3
-const UserMessages = 4
+const AggregationMessages = 4
 const MongoMessages = 5
 const ChannelNum = 100
 
 var (
 	persistentCH          PersistentConsumerHandler
-	historyCH             OnlineHistoryConsumerHandler
-	offlineHistoryCH      OfflineHistoryConsumerHandler
+	historyCH             OnlineHistoryRedisConsumerHandler
+	historyMongoCH        OnlineHistoryMongoConsumerHandler
 	producer              *kafka.Producer
+	producerToMongo       *kafka.Producer
 	cmdCh                 chan Cmd2Value
 	onlineTopicStatus     int
 	w                     *sync.Mutex
@@ -38,12 +38,13 @@ func Init() {
 	w = new(sync.Mutex)
 	persistentCH.Init()
 	historyCH.Init(cmdCh)
+	historyMongoCH.Init()
 	onlineTopicStatus = OnlineTopicVacancy
-	log.Debug("come msg transfer ts", config.Config.Kafka.ConsumerGroupID.MsgToMongoOffline, config.Config.Kafka.Ws2mschatOffline.Topic)
 	//offlineHistoryCH.Init(cmdCh)
 	statistics.NewStatistics(&singleMsgSuccessCount, config.Config.ModuleName.MsgTransferName, fmt.Sprintf("%d second singleMsgCount insert to mongo", constant.StatisticsTimeInterval), constant.StatisticsTimeInterval)
 	statistics.NewStatistics(&groupMsgCount, config.Config.ModuleName.MsgTransferName, fmt.Sprintf("%d second groupMsgCount insert to mongo", constant.StatisticsTimeInterval), constant.StatisticsTimeInterval)
 	producer = kafka.NewKafkaProducer(config.Config.Kafka.Ms2pschat.Addr, config.Config.Kafka.Ms2pschat.Topic)
+	producerToMongo = kafka.NewKafkaProducer(config.Config.Kafka.MsgToMongo.Addr, config.Config.Kafka.MsgToMongo.Topic)
 }
 func Run() {
 	//register mysqlConsumerHandler to
@@ -53,6 +54,7 @@ func Run() {
 		fmt.Println("not start mysql consumer")
 	}
 	go historyCH.historyConsumerGroup.RegisterHandleAndConsumer(&historyCH)
+	go historyMongoCH.historyConsumerGroup.RegisterHandleAndConsumer(&historyMongoCH)
 	//go offlineHistoryCH.historyConsumerGroup.RegisterHandleAndConsumer(&offlineHistoryCH)
 }
 func SetOnlineTopicStatus(status int) {

internal/msg_transfer/logic/offline_history_msg_handler.go

@@ -1,313 +0,0 @@
-package logic
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	kfk "Open_IM/pkg/common/kafka"
-	"Open_IM/pkg/common/log"
-	pbMsg "Open_IM/pkg/proto/chat"
-	"Open_IM/pkg/utils"
-	"github.com/Shopify/sarama"
-	"github.com/golang/protobuf/proto"
-	"time"
-)
-
-type OfflineHistoryConsumerHandler struct {
-	msgHandle            map[string]fcb
-	historyConsumerGroup *kfk.MConsumerGroup
-	cmdCh                chan Cmd2Value
-	msgCh                chan Cmd2Value
-	chArrays             [ChannelNum]chan Cmd2Value
-	msgDistributionCh    chan Cmd2Value
-}
-
-func (mc *OfflineHistoryConsumerHandler) Init(cmdCh chan Cmd2Value) {
-	mc.msgHandle = make(map[string]fcb)
-	mc.msgDistributionCh = make(chan Cmd2Value) //no buffer channel
-	go mc.MessagesDistributionHandle()
-	mc.cmdCh = cmdCh
-	mc.msgCh = make(chan Cmd2Value, 1000)
-	for i := 0; i < ChannelNum; i++ {
-		mc.chArrays[i] = make(chan Cmd2Value, 1000)
-		go mc.Run(i)
-	}
-	if config.Config.ReliableStorage {
-		mc.msgHandle[config.Config.Kafka.Ws2mschat.Topic] = mc.handleChatWs2Mongo
-	} else {
-		mc.msgHandle[config.Config.Kafka.Ws2mschat.Topic] = mc.handleChatWs2MongoLowReliability
-
-	}
-	mc.historyConsumerGroup = kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{KafkaVersion: sarama.V2_0_0_0,
-		OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.Ws2mschatOffline.Topic},
-		config.Config.Kafka.Ws2mschatOffline.Addr, config.Config.Kafka.ConsumerGroupID.MsgToMongoOffline)
-
-}
-func (och *OfflineHistoryConsumerHandler) Run(channelID int) {
-	for {
-		select {
-		case cmd := <-och.chArrays[channelID]:
-			switch cmd.Cmd {
-			case UserMessages:
-				msgChannelValue := cmd.Value.(MsgChannelValue)
-				msgList := msgChannelValue.msgList
-				triggerID := msgChannelValue.triggerID
-				storageMsgList := make([]*pbMsg.MsgDataToMQ, 0, 80)
-				pushMsgList := make([]*pbMsg.MsgDataToMQ, 0, 80)
-				log.Debug(triggerID, "msg arrived channel", "channel id", channelID, msgList, msgChannelValue.userID, len(msgList))
-				for _, v := range msgList {
-					log.Debug(triggerID, "msg come to storage center", v.String())
-					isHistory := utils.GetSwitchFromOptions(v.MsgData.Options, constant.IsHistory)
-					isSenderSync := utils.GetSwitchFromOptions(v.MsgData.Options, constant.IsSenderSync)
-					if isHistory {
-						storageMsgList = append(storageMsgList, v)
-					}
-					if !(!isSenderSync && msgChannelValue.userID == v.MsgData.SendID) {
-						pushMsgList = append(pushMsgList, v)
-					}
-				}
-
-				//switch msgChannelValue.msg.MsgData.SessionType {
-				//case constant.SingleChatType:
-				//case constant.GroupChatType:
-				//case constant.NotificationChatType:
-				//default:
-				//	log.NewError(msgFromMQ.OperationID, "SessionType error", msgFromMQ.String())
-				//	return
-				//}
-
-				err, _ := saveUserChatList(msgChannelValue.userID, storageMsgList, triggerID)
-				if err != nil {
-					singleMsgFailedCount += uint64(len(storageMsgList))
-					log.NewError(triggerID, "single data insert to mongo err", err.Error(), storageMsgList)
-				} else {
-					singleMsgSuccessCountMutex.Lock()
-					singleMsgSuccessCount += uint64(len(storageMsgList))
-					singleMsgSuccessCountMutex.Unlock()
-					for _, v := range pushMsgList {
-						sendMessageToPush(v, msgChannelValue.userID)
-					}
-
-				}
-			}
-		}
-	}
-}
-func (och *OfflineHistoryConsumerHandler) MessagesDistributionHandle() {
-	UserAggregationMsgs := make(map[string][]*pbMsg.MsgDataToMQ, ChannelNum)
-	for {
-		select {
-		case cmd := <-och.msgDistributionCh:
-			switch cmd.Cmd {
-			case ConsumerMsgs:
-				triggerChannelValue := cmd.Value.(TriggerChannelValue)
-				triggerID := triggerChannelValue.triggerID
-				consumerMessages := triggerChannelValue.cmsgList
-				//Aggregation map[userid]message list
-				log.Debug(triggerID, "batch messages come to distribution center", len(consumerMessages))
-				for i := 0; i < len(consumerMessages); i++ {
-					msgFromMQ := pbMsg.MsgDataToMQ{}
-					err := proto.Unmarshal(consumerMessages[i].Value, &msgFromMQ)
-					if err != nil {
-						log.Error(triggerID, "msg_transfer Unmarshal msg err", "msg", string(consumerMessages[i].Value), "err", err.Error())
-						return
-					}
-					log.Debug(triggerID, "single msg come to distribution center", msgFromMQ.String())
-					if oldM, ok := UserAggregationMsgs[string(consumerMessages[i].Key)]; ok {
-						oldM = append(oldM, &msgFromMQ)
-						UserAggregationMsgs[string(consumerMessages[i].Key)] = oldM
-					} else {
-						m := make([]*pbMsg.MsgDataToMQ, 0, 100)
-						m = append(m, &msgFromMQ)
-						UserAggregationMsgs[string(consumerMessages[i].Key)] = m
-					}
-				}
-				log.Debug(triggerID, "generate map list users len", len(UserAggregationMsgs))
-				for userID, v := range UserAggregationMsgs {
-					if len(v) >= 0 {
-						channelID := getHashCode(userID) % ChannelNum
-						go func(cID uint32, userID string, messages []*pbMsg.MsgDataToMQ) {
-							och.chArrays[cID] <- Cmd2Value{Cmd: UserMessages, Value: MsgChannelValue{userID: userID, msgList: messages, triggerID: triggerID}}
-						}(channelID, userID, v)
-					}
-				}
-			}
-		}
-	}
-
-}
-func (mc *OfflineHistoryConsumerHandler) handleChatWs2Mongo(cMsg *sarama.ConsumerMessage, msgKey string, sess sarama.ConsumerGroupSession) {
-	msg := cMsg.Value
-	now := time.Now()
-	msgFromMQ := pbMsg.MsgDataToMQ{}
-	err := proto.Unmarshal(msg, &msgFromMQ)
-	if err != nil {
-		log.Error("msg_transfer Unmarshal msg err", "", "msg", string(msg), "err", err.Error())
-		return
-	}
-	operationID := msgFromMQ.OperationID
-	log.NewInfo(operationID, "msg come mongo!!!", "", "msg", string(msg))
-	//Control whether to store offline messages (mongo)
-	isHistory := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsHistory)
-	//Control whether to store history messages (mysql)
-	isPersist := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsPersistent)
-	isSenderSync := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsSenderSync)
-	switch msgFromMQ.MsgData.SessionType {
-	case constant.SingleChatType:
-		log.NewDebug(msgFromMQ.OperationID, "msg_transfer msg type = SingleChatType", isHistory, isPersist)
-		if isHistory {
-			err := saveUserChat(msgKey, &msgFromMQ)
-			if err != nil {
-				singleMsgFailedCount++
-				log.NewError(operationID, "single data insert to mongo err", err.Error(), msgFromMQ.String())
-				return
-			}
-			singleMsgSuccessCountMutex.Lock()
-			singleMsgSuccessCount++
-			singleMsgSuccessCountMutex.Unlock()
-			log.NewDebug(msgFromMQ.OperationID, "sendMessageToPush cost time ", time.Since(now))
-		}
-		if !isSenderSync && msgKey == msgFromMQ.MsgData.SendID {
-		} else {
-			go sendMessageToPush(&msgFromMQ, msgKey)
-		}
-		log.NewDebug(operationID, "saveSingleMsg cost time ", time.Since(now))
-	case constant.GroupChatType:
-		log.NewDebug(msgFromMQ.OperationID, "msg_transfer msg type = GroupChatType", isHistory, isPersist)
-		if isHistory {
-			err := saveUserChat(msgFromMQ.MsgData.RecvID, &msgFromMQ)
-			if err != nil {
-				log.NewError(operationID, "group data insert to mongo err", msgFromMQ.String(), msgFromMQ.MsgData.RecvID, err.Error())
-				return
-			}
-			groupMsgCount++
-		}
-		go sendMessageToPush(&msgFromMQ, msgFromMQ.MsgData.RecvID)
-		log.NewDebug(operationID, "saveGroupMsg cost time ", time.Since(now))
-
-	case constant.NotificationChatType:
-		log.NewDebug(msgFromMQ.OperationID, "msg_transfer msg type = NotificationChatType", isHistory, isPersist)
-		if isHistory {
-			err := saveUserChat(msgKey, &msgFromMQ)
-			if err != nil {
-				log.NewError(operationID, "single data insert to mongo err", err.Error(), msgFromMQ.String())
-				return
-			}
-			log.NewDebug(msgFromMQ.OperationID, "sendMessageToPush cost time ", time.Since(now))
-		}
-		if !isSenderSync && msgKey == msgFromMQ.MsgData.SendID {
-		} else {
-			go sendMessageToPush(&msgFromMQ, msgKey)
-		}
-		log.NewDebug(operationID, "saveUserChat cost time ", time.Since(now))
-	default:
-		log.NewError(msgFromMQ.OperationID, "SessionType error", msgFromMQ.String())
-		return
-	}
-	sess.MarkMessage(cMsg, "")
-	log.NewDebug(msgFromMQ.OperationID, "msg_transfer handle topic data to database success...", msgFromMQ.String())
-}
-func (mc *OfflineHistoryConsumerHandler) handleChatWs2MongoLowReliability(cMsg *sarama.ConsumerMessage, msgKey string, sess sarama.ConsumerGroupSession) {
-	msg := cMsg.Value
-	msgFromMQ := pbMsg.MsgDataToMQ{}
-	err := proto.Unmarshal(msg, &msgFromMQ)
-	if err != nil {
-		log.Error("msg_transfer Unmarshal msg err", "", "msg", string(msg), "err", err.Error())
-		return
-	}
-	operationID := msgFromMQ.OperationID
-	log.NewInfo(operationID, "msg come mongo!!!", "", "msg", string(msg))
-	//Control whether to store offline messages (mongo)
-	isHistory := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsHistory)
-	isSenderSync := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsSenderSync)
-	if isHistory {
-		seq, err := db.DB.IncrUserSeq(msgKey)
-		if err != nil {
-			log.NewError(operationID, "data insert to redis err", err.Error(), string(msg))
-			return
-		}
-		sess.MarkMessage(cMsg, "")
-		msgFromMQ.MsgData.Seq = uint32(seq)
-		log.Debug(operationID, "send ch msg is ", msgFromMQ.String())
-		//mc.msgCh <- Cmd2Value{Cmd: Msg, Value: MsgChannelValue{msgKey, msgFromMQ}}
-		//err := saveUserChat(msgKey, &msgFromMQ)
-		//if err != nil {
-		//	singleMsgFailedCount++
-		//	log.NewError(operationID, "single data insert to mongo err", err.Error(), msgFromMQ.String())
-		//	return
-		//}
-		//singleMsgSuccessCountMutex.Lock()
-		//singleMsgSuccessCount++
-		//singleMsgSuccessCountMutex.Unlock()
-		//log.NewDebug(msgFromMQ.OperationID, "sendMessageToPush cost time ", time.Since(now))
-	} else {
-		if !(!isSenderSync && msgKey == msgFromMQ.MsgData.SendID) {
-			go sendMessageToPush(&msgFromMQ, msgKey)
-		}
-	}
-}
-
-func (OfflineHistoryConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
-func (OfflineHistoryConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
-
-//func (mc *OfflineHistoryConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
-//	claim sarama.ConsumerGroupClaim) error { // a instance in the consumer group
-//	//log.NewDebug("", "offline new session msg come", claim.HighWaterMarkOffset(), claim.Topic(), claim.Partition())
-//	//for msg := range claim.Messages() {
-//	//	log.NewDebug("", "kafka get info to delay mongo", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "offline")
-//	//	//mc.msgHandle[msg.Topic](msg.Value, string(msg.Key))
-//	//}
-//	for msg := range claim.Messages() {
-//		if GetOnlineTopicStatus() == OnlineTopicVacancy {
-//			log.NewDebug("", "vacancy offline kafka get info to mongo", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value))
-//			mc.msgHandle[msg.Topic](msg, string(msg.Key), sess)
-//		} else {
-//			select {
-//			case <-mc.cmdCh:
-//				log.NewDebug("", "cmd offline kafka get info to mongo", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value))
-//			case <-time.After(time.Millisecond * time.Duration(100)):
-//				log.NewDebug("", "timeout offline kafka get info to mongo", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value))
-//			}
-//			mc.msgHandle[msg.Topic](msg, string(msg.Key), sess)
-//		}
-//	}
-//
-//	return nil
-//}
-func (och *OfflineHistoryConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
-	claim sarama.ConsumerGroupClaim) error { // a instance in the consumer group
-	log.NewDebug("", "online new session msg come", claim.HighWaterMarkOffset(), claim.Topic(), claim.Partition())
-	cMsg := make([]*sarama.ConsumerMessage, 0, 500)
-	t := time.NewTicker(time.Duration(500) * time.Millisecond)
-	var triggerID string
-	for msg := range claim.Messages() {
-		//och.TriggerCmd(OnlineTopicBusy)
-		cMsg = append(cMsg, msg)
-		select {
-		case <-t.C:
-			if len(cMsg) >= 0 {
-				triggerID = utils.OperationIDGenerator()
-				log.Debug(triggerID, "timer trigger msg consumer start", len(cMsg))
-				och.msgDistributionCh <- Cmd2Value{Cmd: ConsumerMsgs, Value: TriggerChannelValue{
-					triggerID: triggerID, cmsgList: cMsg}}
-				sess.MarkMessage(msg, "")
-				cMsg = cMsg[0:0]
-				log.Debug(triggerID, "timer trigger msg consumer end", len(cMsg))
-			}
-		default:
-			if len(cMsg) >= 500 {
-				triggerID = utils.OperationIDGenerator()
-				log.Debug(triggerID, "length trigger msg consumer start", len(cMsg))
-				och.msgDistributionCh <- Cmd2Value{Cmd: ConsumerMsgs, Value: TriggerChannelValue{
-					triggerID: triggerID, cmsgList: cMsg}}
-				sess.MarkMessage(msg, "")
-				cMsg = cMsg[0:0]
-				log.Debug(triggerID, "length trigger msg consumer end", len(cMsg))
-			}
-
-		}
-		log.NewDebug("", "online kafka get info to mongo", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "online", msg.Offset, claim.HighWaterMarkOffset())
-
-	}
-	return nil
-}

internal/msg_transfer/logic/online_history_msg_handler.go

@@ -9,10 +9,8 @@ import (
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	pbMsg "Open_IM/pkg/proto/chat"
 	pbPush "Open_IM/pkg/proto/push"
-	server_api_params "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"context"
-	"errors"
 	"github.com/Shopify/sarama"
 	"github.com/golang/protobuf/proto"
 	"hash/crc32"
@@ -22,10 +20,10 @@ import (
 )
 
 type MsgChannelValue struct {
-	userID    string
-	triggerID string
-	msgList   []*pbMsg.MsgDataToMQ
-	lastSeq   uint64
+	aggregationID string //maybe userID or super groupID
+	triggerID     string
+	msgList       []*pbMsg.MsgDataToMQ
+	lastSeq       uint64
 }
 type TriggerChannelValue struct {
 	triggerID string
@@ -36,28 +34,21 @@ type Cmd2Value struct {
 	Cmd   int
 	Value interface{}
 }
-type OnlineHistoryConsumerHandler struct {
+type OnlineHistoryRedisConsumerHandler struct {
 	msgHandle            map[string]fcb
 	historyConsumerGroup *kfk.MConsumerGroup
-	cmdCh                chan Cmd2Value
 	chArrays             [ChannelNum]chan Cmd2Value
-	chMongoArrays        [ChannelNum]chan Cmd2Value
 	msgDistributionCh    chan Cmd2Value
 }
 
-func (och *OnlineHistoryConsumerHandler) Init(cmdCh chan Cmd2Value) {
+func (och *OnlineHistoryRedisConsumerHandler) Init(cmdCh chan Cmd2Value) {
 	och.msgHandle = make(map[string]fcb)
 	och.msgDistributionCh = make(chan Cmd2Value) //no buffer channel
 	go och.MessagesDistributionHandle()
-	och.cmdCh = cmdCh
 	for i := 0; i < ChannelNum; i++ {
 		och.chArrays[i] = make(chan Cmd2Value, 50)
 		go och.Run(i)
 	}
-	for i := 0; i < ChannelNum; i++ {
-		och.chMongoArrays[i] = make(chan Cmd2Value, 10000)
-		go och.MongoMessageRun(i)
-	}
 	if config.Config.ReliableStorage {
 		och.msgHandle[config.Config.Kafka.Ws2mschat.Topic] = och.handleChatWs2Mongo
 	} else {
@@ -66,60 +57,33 @@ func (och *OnlineHistoryConsumerHandler) Init(cmdCh chan Cmd2Value) {
 	}
 	och.historyConsumerGroup = kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{KafkaVersion: sarama.V2_0_0_0,
 		OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.Ws2mschat.Topic},
-		config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.ConsumerGroupID.MsgToMongo)
+		config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.ConsumerGroupID.MsgToRedis)
 
 }
-func (och *OnlineHistoryConsumerHandler) TriggerCmd(status int) {
-	operationID := utils.OperationIDGenerator()
-	err := sendCmd(och.cmdCh, Cmd2Value{Cmd: status, Value: ""}, 1)
-	if err != nil {
-		log.Error(operationID, "TriggerCmd failed ", err.Error(), status)
-		return
-	}
-	log.Debug(operationID, "TriggerCmd success", status)
-
-}
-func sendCmd(ch chan Cmd2Value, value Cmd2Value, timeout int64) error {
-	var flag = 0
-	select {
-	case ch <- value:
-		flag = 1
-	case <-time.After(time.Second * time.Duration(timeout)):
-		flag = 2
-	}
-	if flag == 1 {
-		return nil
-	} else {
-		return errors.New("send cmd timeout")
-	}
-}
-func (och *OnlineHistoryConsumerHandler) Run(channelID int) {
+func (och *OnlineHistoryRedisConsumerHandler) Run(channelID int) {
 	for {
 		select {
 		case cmd := <-och.chArrays[channelID]:
 			switch cmd.Cmd {
-			case UserMessages:
+			case AggregationMessages:
 				msgChannelValue := cmd.Value.(MsgChannelValue)
 				msgList := msgChannelValue.msgList
 				triggerID := msgChannelValue.triggerID
 				storageMsgList := make([]*pbMsg.MsgDataToMQ, 0, 80)
-				notStoragepushMsgList := make([]*pbMsg.MsgDataToMQ, 0, 80)
-				log.Debug(triggerID, "msg arrived channel", "channel id", channelID, msgList, msgChannelValue.userID, len(msgList))
+				notStoragePushMsgList := make([]*pbMsg.MsgDataToMQ, 0, 80)
+				log.Debug(triggerID, "msg arrived channel", "channel id", channelID, msgList, msgChannelValue.aggregationID, len(msgList))
 				for _, v := range msgList {
 					log.Debug(triggerID, "msg come to storage center", v.String())
-					if v.MsgData == nil {
-						log.NewWarn(triggerID, "msg come to storage center nil", v.String(), v.OperationID, msgChannelValue.userID)
-						continue
-					}
 					isHistory := utils.GetSwitchFromOptions(v.MsgData.Options, constant.IsHistory)
 					isSenderSync := utils.GetSwitchFromOptions(v.MsgData.Options, constant.IsSenderSync)
 					if isHistory {
 						storageMsgList = append(storageMsgList, v)
 						//log.NewWarn(triggerID, "storageMsgList to mongodb  client msgID: ", v.MsgData.ClientMsgID)
 					} else {
-						if !(!isSenderSync && msgChannelValue.userID == v.MsgData.SendID) {
-							notStoragepushMsgList = append(notStoragepushMsgList, v)
+						if !(!isSenderSync && msgChannelValue.aggregationID == v.MsgData.SendID) {
+							notStoragePushMsgList = append(notStoragePushMsgList, v)
 						}
+
 					}
 
 				}
@@ -132,8 +96,8 @@ func (och *OnlineHistoryConsumerHandler) Run(channelID int) {
 				//	log.NewError(msgFromMQ.OperationID, "SessionType error", msgFromMQ.String())
 				//	return
 				//}
-				log.Debug(triggerID, "msg storage length", len(storageMsgList), "push length", len(notStoragepushMsgList))
-				err, lastSeq := saveUserChatList(msgChannelValue.userID, storageMsgList, triggerID)
+				log.Debug(triggerID, "msg storage length", len(storageMsgList), "push length", len(notStoragePushMsgList))
+				err, lastSeq := saveUserChatList(msgChannelValue.aggregationID, storageMsgList, triggerID)
 				if err != nil {
 					singleMsgFailedCount += uint64(len(storageMsgList))
 					log.NewError(triggerID, "single data insert to redis err", err.Error(), storageMsgList)
@@ -141,72 +105,79 @@ func (och *OnlineHistoryConsumerHandler) Run(channelID int) {
 					singleMsgSuccessCountMutex.Lock()
 					singleMsgSuccessCount += uint64(len(storageMsgList))
 					singleMsgSuccessCountMutex.Unlock()
-					och.SendMessageToMongoCH(msgChannelValue.userID, triggerID, storageMsgList, lastSeq)
+					och.SendMessageToMongoCH(msgChannelValue.aggregationID, triggerID, storageMsgList, lastSeq)
 					go func(push, storage []*pbMsg.MsgDataToMQ) {
 						for _, v := range storage {
-							sendMessageToPush(v, msgChannelValue.userID)
+							sendMessageToPush(v, msgChannelValue.aggregationID)
 						}
 						for _, x := range push {
-							sendMessageToPush(x, msgChannelValue.userID)
+							sendMessageToPush(x, msgChannelValue.aggregationID)
 						}
 
-					}(notStoragepushMsgList, storageMsgList)
+					}(notStoragePushMsgList, storageMsgList)
 
 				}
 			}
 		}
 	}
 }
-func (och *OnlineHistoryConsumerHandler) SendMessageToMongoCH(userID string, triggerID string, messages []*pbMsg.MsgDataToMQ, lastSeq uint64) {
-	hashCode := getHashCode(userID)
-	channelID := hashCode % ChannelNum
-	log.Debug(triggerID, "generate channelID", hashCode, channelID, userID)
-	//go func(cID uint32, userID string, messages []*pbMsg.MsgDataToMQ) {
-	och.chMongoArrays[channelID] <- Cmd2Value{Cmd: MongoMessages, Value: MsgChannelValue{userID: userID, msgList: messages, triggerID: triggerID, lastSeq: lastSeq}}
-}
-func (och *OnlineHistoryConsumerHandler) MongoMessageRun(channelID int) {
-	for {
-		select {
-		case cmd := <-och.chMongoArrays[channelID]:
-			switch cmd.Cmd {
-			case MongoMessages:
-				msgChannelValue := cmd.Value.(MsgChannelValue)
-				msgList := msgChannelValue.msgList
-				triggerID := msgChannelValue.triggerID
-				userID := msgChannelValue.userID
-				lastSeq := msgChannelValue.lastSeq
-				err := db.DB.BatchInsertChat2DB(userID, msgList, triggerID, lastSeq)
-				if err != nil {
-					log.NewError(triggerID, "single data insert to mongo err", err.Error(), msgList)
-				}
-				for _, v := range msgList {
-					if v.MsgData.ContentType == constant.DeleteMessageNotification {
-						tips := server_api_params.TipsComm{}
-						DeleteMessageTips := server_api_params.DeleteMessageTips{}
-						err := proto.Unmarshal(v.MsgData.Content, &tips)
-						if err != nil {
-							log.NewError(triggerID, "tips unmarshal err:", err.Error(), v.String())
-							continue
-						}
-						err = proto.Unmarshal(tips.Detail, &DeleteMessageTips)
-						if err != nil {
-							log.NewError(triggerID, "deleteMessageTips unmarshal err:", err.Error(), v.String())
-							continue
-						}
-						if unexistSeqList, err := db.DB.DelMsgBySeqList(DeleteMessageTips.UserID, DeleteMessageTips.SeqList, v.OperationID); err != nil {
-							log.NewError(v.OperationID, utils.GetSelfFuncName(), "DelMsgBySeqList args: ", DeleteMessageTips.UserID, DeleteMessageTips.SeqList, v.OperationID, err.Error(), unexistSeqList)
-						}
-
-					}
-				}
-			}
-		}
+func (och *OnlineHistoryRedisConsumerHandler) SendMessageToMongoCH(aggregationID string, triggerID string, messages []*pbMsg.MsgDataToMQ, lastSeq uint64) {
+	pid, offset, err := producerToMongo.SendMessage(&pbMsg.MsgDataToMongoByMQ{LastSeq: lastSeq, AggregationID: aggregationID, MessageList: messages, TriggerID: triggerID}, aggregationID, triggerID)
+	if err != nil {
+		log.Error(triggerID, "kafka send failed", "send data", len(messages), "pid", pid, "offset", offset, "err", err.Error(), "key", aggregationID)
+	} else {
+		//	log.NewWarn(m.OperationID, "sendMsgToKafka   client msgID ", m.MsgData.ClientMsgID)
 	}
+	//hashCode := getHashCode(aggregationID)
+	//channelID := hashCode % ChannelNum
+	//log.Debug(triggerID, "generate channelID", hashCode, channelID, aggregationID)
+	////go func(cID uint32, userID string, messages []*pbMsg.MsgDataToMQ) {
+	//och.chMongoArrays[channelID] <- Cmd2Value{Cmd: MongoMessages, Value: MsgChannelValue{aggregationID: aggregationID, msgList: messages, triggerID: triggerID, lastSeq: lastSeq}}
 }
 
-func (och *OnlineHistoryConsumerHandler) MessagesDistributionHandle() {
+//func (och *OnlineHistoryRedisConsumerHandler) MongoMessageRun(channelID int) {
+//	for {
+//		select {
+//		case cmd := <-och.chMongoArrays[channelID]:
+//			switch cmd.Cmd {
+//			case MongoMessages:
+//				msgChannelValue := cmd.Value.(MsgChannelValue)
+//				msgList := msgChannelValue.msgList
+//				triggerID := msgChannelValue.triggerID
+//				aggregationID := msgChannelValue.aggregationID
+//				lastSeq := msgChannelValue.lastSeq
+//				err := db.DB.BatchInsertChat2DB(aggregationID, msgList, triggerID, lastSeq)
+//				if err != nil {
+//					log.NewError(triggerID, "single data insert to mongo err", err.Error(), msgList)
+//				}
+//				for _, v := range msgList {
+//					if v.MsgData.ContentType == constant.DeleteMessageNotification {
+//						tips := server_api_params.TipsComm{}
+//						DeleteMessageTips := server_api_params.DeleteMessageTips{}
+//						err := proto.Unmarshal(v.MsgData.Content, &tips)
+//						if err != nil {
+//							log.NewError(triggerID, "tips unmarshal err:", err.Error(), v.String())
+//							continue
+//						}
+//						err = proto.Unmarshal(tips.Detail, &DeleteMessageTips)
+//						if err != nil {
+//							log.NewError(triggerID, "deleteMessageTips unmarshal err:", err.Error(), v.String())
+//							continue
+//						}
+//						if unexistSeqList, err := db.DB.DelMsgBySeqList(DeleteMessageTips.UserID, DeleteMessageTips.SeqList, v.OperationID); err != nil {
+//							log.NewError(v.OperationID, utils.GetSelfFuncName(), "DelMsgBySeqList args: ", DeleteMessageTips.UserID, DeleteMessageTips.SeqList, v.OperationID, err.Error(), unexistSeqList)
+//						}
+//
+//					}
+//				}
+//			}
+//		}
+//	}
+//}
+
+func (och *OnlineHistoryRedisConsumerHandler) MessagesDistributionHandle() {
 	for {
-		UserAggregationMsgs := make(map[string][]*pbMsg.MsgDataToMQ, ChannelNum)
+		aggregationMsgs := make(map[string][]*pbMsg.MsgDataToMQ, ChannelNum)
 		select {
 		case cmd := <-och.msgDistributionCh:
 			switch cmd.Cmd {
@@ -223,27 +194,24 @@ func (och *OnlineHistoryConsumerHandler) MessagesDistributionHandle() {
 						log.Error(triggerID, "msg_transfer Unmarshal msg err", "msg", string(consumerMessages[i].Value), "err", err.Error())
 						return
 					}
-					log.Debug(triggerID, "single msg come to distribution center", string(consumerMessages[i].Key))
-					if oldM, ok := UserAggregationMsgs[string(consumerMessages[i].Key)]; ok {
+					log.Debug(triggerID, "single msg come to distribution center", msgFromMQ.String(), string(consumerMessages[i].Key))
+					if oldM, ok := aggregationMsgs[string(consumerMessages[i].Key)]; ok {
 						oldM = append(oldM, &msgFromMQ)
-						UserAggregationMsgs[string(consumerMessages[i].Key)] = oldM
+						aggregationMsgs[string(consumerMessages[i].Key)] = oldM
 					} else {
 						m := make([]*pbMsg.MsgDataToMQ, 0, 100)
 						m = append(m, &msgFromMQ)
-						UserAggregationMsgs[string(consumerMessages[i].Key)] = m
+						aggregationMsgs[string(consumerMessages[i].Key)] = m
 					}
 				}
-				log.Debug(triggerID, "generate map list users len", len(UserAggregationMsgs), UserAggregationMsgs)
-				for userID, v := range UserAggregationMsgs {
+				log.Debug(triggerID, "generate map list users len", len(aggregationMsgs))
+				for aggregationID, v := range aggregationMsgs {
 					if len(v) >= 0 {
-						hashCode := getHashCode(userID)
+						hashCode := getHashCode(aggregationID)
 						channelID := hashCode % ChannelNum
-						log.Debug(triggerID, "generate channelID", hashCode, channelID, userID, len(v))
-						for _, y := range v {
-							log.Debug(triggerID, "single user slice is ", y.String())
-						}
+						log.Debug(triggerID, "generate channelID", hashCode, channelID, aggregationID)
 						//go func(cID uint32, userID string, messages []*pbMsg.MsgDataToMQ) {
-						och.chArrays[channelID] <- Cmd2Value{Cmd: UserMessages, Value: MsgChannelValue{userID: userID, msgList: v, triggerID: triggerID}}
+						och.chArrays[channelID] <- Cmd2Value{Cmd: AggregationMessages, Value: MsgChannelValue{aggregationID: aggregationID, msgList: v, triggerID: triggerID}}
 						//}(channelID, userID, v)
 					}
 				}
@@ -253,7 +221,7 @@ func (och *OnlineHistoryConsumerHandler) MessagesDistributionHandle() {
 	}
 
 }
-func (mc *OnlineHistoryConsumerHandler) handleChatWs2Mongo(cMsg *sarama.ConsumerMessage, msgKey string, sess sarama.ConsumerGroupSession) {
+func (mc *OnlineHistoryRedisConsumerHandler) handleChatWs2Mongo(cMsg *sarama.ConsumerMessage, msgKey string, sess sarama.ConsumerGroupSession) {
 	msg := cMsg.Value
 	now := time.Now()
 	msgFromMQ := pbMsg.MsgDataToMQ{}
@@ -325,7 +293,7 @@ func (mc *OnlineHistoryConsumerHandler) handleChatWs2Mongo(cMsg *sarama.Consumer
 	log.NewDebug(msgFromMQ.OperationID, "msg_transfer handle topic data to database success...", msgFromMQ.String())
 }
 
-func (och *OnlineHistoryConsumerHandler) handleChatWs2MongoLowReliability(cMsg *sarama.ConsumerMessage, msgKey string, sess sarama.ConsumerGroupSession) {
+func (och *OnlineHistoryRedisConsumerHandler) handleChatWs2MongoLowReliability(cMsg *sarama.ConsumerMessage, msgKey string, sess sarama.ConsumerGroupSession) {
 	msg := cMsg.Value
 	msgFromMQ := pbMsg.MsgDataToMQ{}
 	err := proto.Unmarshal(msg, &msgFromMQ)
@@ -365,10 +333,10 @@ func (och *OnlineHistoryConsumerHandler) handleChatWs2MongoLowReliability(cMsg *
 	}
 }
 
-func (OnlineHistoryConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
-func (OnlineHistoryConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
+func (OnlineHistoryRedisConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
+func (OnlineHistoryRedisConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
 
-//func (och *OnlineHistoryConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
+//func (och *OnlineHistoryRedisConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
 //	claim sarama.ConsumerGroupClaim) error { // a instance in the consumer group
 //	log.NewDebug("", "online new session msg come", claim.HighWaterMarkOffset(), claim.Topic(), claim.Partition())
 //	for msg := range claim.Messages() {
@@ -385,7 +353,7 @@ func (OnlineHistoryConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error
 //	return nil
 //}
 
-func (och *OnlineHistoryConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
+func (och *OnlineHistoryRedisConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
 	claim sarama.ConsumerGroupClaim) error { // a instance in the consumer group
 
 	for {
@@ -480,7 +448,7 @@ func (och *OnlineHistoryConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupS
 	return nil
 }
 
-//func (och *OnlineHistoryConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
+//func (och *OnlineHistoryRedisConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
 //	claim sarama.ConsumerGroupClaim) error { // a instance in the consumer group
 //
 //	for {
@@ -544,7 +512,7 @@ func sendMessageToPush(message *pbMsg.MsgDataToMQ, pushToUserID string) {
 	log.Info(message.OperationID, "msg_transfer send message to push", "message", message.String())
 	rpcPushMsg := pbPush.PushMsgReq{OperationID: message.OperationID, MsgData: message.MsgData, PushToUserID: pushToUserID}
 	mqPushMsg := pbMsg.PushMsgDataToMQ{OperationID: message.OperationID, MsgData: message.MsgData, PushToUserID: pushToUserID}
-	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImPushName)
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImPushName, message.OperationID)
 	if grpcConn == nil {
 		log.Error(rpcPushMsg.OperationID, "rpc dial failed", "push data", rpcPushMsg.String())
 		pid, offset, err := producer.SendMessage(&mqPushMsg, mqPushMsg.PushToUserID, rpcPushMsg.OperationID)

internal/msg_transfer/logic/online_msg_to_mongo_handler.go

@@ -0,0 +1,79 @@
+package logic
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	kfk "Open_IM/pkg/common/kafka"
+	"Open_IM/pkg/common/log"
+	pbMsg "Open_IM/pkg/proto/chat"
+	server_api_params "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"github.com/Shopify/sarama"
+	"github.com/golang/protobuf/proto"
+)
+
+type OnlineHistoryMongoConsumerHandler struct {
+	msgHandle            map[string]fcb
+	historyConsumerGroup *kfk.MConsumerGroup
+}
+
+func (och *OnlineHistoryMongoConsumerHandler) Init() {
+	och.msgHandle = make(map[string]fcb)
+	och.msgHandle[config.Config.Kafka.MsgToMongo.Topic] = och.handleChatWs2Mongo
+	och.historyConsumerGroup = kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{KafkaVersion: sarama.V2_0_0_0,
+		OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.MsgToMongo.Topic},
+		config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.ConsumerGroupID.MsgToMongo)
+
+}
+func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(cMsg *sarama.ConsumerMessage, msgKey string, _ sarama.ConsumerGroupSession) {
+	msg := cMsg.Value
+	msgFromMQ := pbMsg.MsgDataToMongoByMQ{}
+	err := proto.Unmarshal(msg, &msgFromMQ)
+	if err != nil {
+		log.Error("msg_transfer Unmarshal msg err", "", "msg", string(msg), "err", err.Error())
+		return
+	}
+	err = db.DB.BatchInsertChat2DB(msgFromMQ.AggregationID, msgFromMQ.MessageList, msgFromMQ.TriggerID, msgFromMQ.LastSeq)
+	if err != nil {
+		log.NewError(msgFromMQ.TriggerID, "single data insert to mongo err", err.Error(), msgFromMQ.MessageList)
+	}
+	for _, v := range msgFromMQ.MessageList {
+		if v.MsgData.ContentType == constant.DeleteMessageNotification {
+			tips := server_api_params.TipsComm{}
+			DeleteMessageTips := server_api_params.DeleteMessageTips{}
+			err := proto.Unmarshal(v.MsgData.Content, &tips)
+			if err != nil {
+				log.NewError(msgFromMQ.TriggerID, "tips unmarshal err:", err.Error(), v.String())
+				continue
+			}
+			err = proto.Unmarshal(tips.Detail, &DeleteMessageTips)
+			if err != nil {
+				log.NewError(msgFromMQ.TriggerID, "deleteMessageTips unmarshal err:", err.Error(), v.String())
+				continue
+			}
+			if unexistSeqList, err := db.DB.DelMsgBySeqList(DeleteMessageTips.UserID, DeleteMessageTips.SeqList, v.OperationID); err != nil {
+				log.NewError(v.OperationID, utils.GetSelfFuncName(), "DelMsgBySeqList args: ", DeleteMessageTips.UserID, DeleteMessageTips.SeqList, v.OperationID, err.Error(), unexistSeqList)
+			}
+
+		}
+	}
+}
+
+func (OnlineHistoryMongoConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
+func (OnlineHistoryMongoConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
+
+func (och *OnlineHistoryMongoConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
+	claim sarama.ConsumerGroupClaim) error { // a instance in the consumer group
+	log.NewDebug("", "online new session msg come", claim.HighWaterMarkOffset(), claim.Topic(), claim.Partition())
+	for msg := range claim.Messages() {
+		log.NewDebug("", "kafka get info to mongo", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value), "key", string(msg.Key))
+		if len(msg.Value) != 0 {
+			och.msgHandle[msg.Topic](msg, string(msg.Key), sess)
+		} else {
+			log.Error("", "mongo msg get from kafka but is nil", msg.Key)
+		}
+		sess.MarkMessage(msg, "")
+	}
+	return nil
+}

internal/msg_transfer/logic/persistent_msg_handler.go

@@ -56,6 +56,8 @@ func (pc *PersistentConsumerHandler) handleChatWs2Mysql(cMsg *sarama.ConsumerMes
 			if msgKey == msgFromMQ.MsgData.SendID {
 				tag = true
 			}
+		case constant.SuperGroupChatType:
+			tag = true
 		}
 		if tag {
 			log.NewInfo(msgFromMQ.OperationID, "msg_transfer msg persisting", string(msg))

internal/push/logic/callback.go

@@ -20,7 +20,7 @@ func callbackOfflinePush(operationID, userID string, msg *commonPb.MsgData) cbAp
 			OperationID:     operationID,
 			UserID:          userID,
 			PlatformID:      msg.SenderPlatformID,
-			Platform:        constant.PlatformIDToName(msg.SenderPlatformID),
+			Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
 		},
 		OfflinePushInfo: msg.OfflinePushInfo,
 		SendID:          msg.SendID,

internal/push/logic/push_rpc_server.go

@@ -2,6 +2,7 @@ package logic
 
 import (
 	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	"Open_IM/pkg/proto/push"
@@ -63,7 +64,12 @@ func (r *RPCServer) run() {
 }
 func (r *RPCServer) PushMsg(_ context.Context, pbData *pbPush.PushMsgReq) (*pbPush.PushMsgResp, error) {
 	//Call push module to send message to the user
-	MsgToUser(pbData)
+	switch pbData.MsgData.SessionType {
+	case constant.SuperGroupChatType:
+		MsgToSuperGroupUser(pbData)
+	default:
+		MsgToUser(pbData)
+	}
 	return &pbPush.PushMsgResp{
 		ResultCode: 0,
 	}, nil

internal/push/logic/push_to_client.go

@@ -39,7 +39,7 @@ type AtContent struct {
 var grpcCons []*grpc.ClientConn
 
 func MsgToUser(pushMsg *pbPush.PushMsgReq) {
-	var wsResult []*pbRelay.SingleMsgToUser
+	var wsResult []*pbRelay.SingelMsgToUserResultList
 	isOfflinePush := utils.GetSwitchFromOptions(pushMsg.MsgData.Options, constant.IsOfflinePush)
 	log.Debug(pushMsg.OperationID, "Get msg from msg_transfer And push msg", pushMsg.String())
 	if len(grpcCons) == 0 {
@@ -47,107 +47,215 @@ func MsgToUser(pushMsg *pbPush.PushMsgReq) {
 		grpcCons = getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName)
 	}
 	//Online push message
+	log.Debug(pushMsg.OperationID, "len  grpc", len(grpcCons), "data", pushMsg.String())
+	for _, v := range grpcCons {
+		msgClient := pbRelay.NewOnlineMessageRelayServiceClient(v)
+		reply, err := msgClient.SuperGroupOnlineBatchPushOneMsg(context.Background(), &pbRelay.OnlineBatchPushOneMsgReq{OperationID: pushMsg.OperationID, MsgData: pushMsg.MsgData, PushToUserIDList: []string{pushMsg.PushToUserID}})
+		if err != nil {
+			log.NewError("SuperGroupOnlineBatchPushOneMsg push data to client rpc err", pushMsg.OperationID, "err", err)
+			continue
+		}
+		if reply != nil && reply.SinglePushResult != nil {
+			wsResult = append(wsResult, reply.SinglePushResult...)
+		}
+	}
+	log.NewInfo(pushMsg.OperationID, "push_result", wsResult, "sendData", pushMsg.MsgData)
+	successCount++
+	if isOfflinePush && pushMsg.PushToUserID != pushMsg.MsgData.SendID {
+		// save invitation info for offline push
+		for _, v := range wsResult {
+			if v.OnlinePush {
+				return
+			}
+		}
+		if pushMsg.MsgData.ContentType == constant.SignalingNotification {
+			if err := db.DB.HandleSignalInfo(pushMsg.OperationID, pushMsg.MsgData); err != nil {
+				log.NewError(pushMsg.OperationID, utils.GetSelfFuncName(), err.Error(), pushMsg.MsgData)
+				return
+			}
+		}
+		//Use offline push messaging
+		var UIDList []string
+		UIDList = append(UIDList, pushMsg.PushToUserID)
+		customContent := OpenIMContent{
+			SessionType: int(pushMsg.MsgData.SessionType),
+			From:        pushMsg.MsgData.SendID,
+			To:          pushMsg.MsgData.RecvID,
+			Seq:         pushMsg.MsgData.Seq,
+		}
+		bCustomContent, _ := json.Marshal(customContent)
+		jsonCustomContent := string(bCustomContent)
+		var content string
+		if pushMsg.MsgData.OfflinePushInfo != nil {
+			content = pushMsg.MsgData.OfflinePushInfo.Title
+
+		} else {
+			switch pushMsg.MsgData.ContentType {
+			case constant.Text:
+				content = constant.ContentType2PushContent[constant.Text]
+			case constant.Picture:
+				content = constant.ContentType2PushContent[constant.Picture]
+			case constant.Voice:
+				content = constant.ContentType2PushContent[constant.Voice]
+			case constant.Video:
+				content = constant.ContentType2PushContent[constant.Video]
+			case constant.File:
+				content = constant.ContentType2PushContent[constant.File]
+			case constant.AtText:
+				a := AtContent{}
+				_ = utils.JsonStringToStruct(string(pushMsg.MsgData.Content), &a)
+				if utils.IsContain(pushMsg.PushToUserID, a.AtUserList) {
+					content = constant.ContentType2PushContent[constant.AtText] + constant.ContentType2PushContent[constant.Common]
+				} else {
+					content = constant.ContentType2PushContent[constant.GroupMsg]
+				}
+			case constant.SignalingNotification:
+				content = constant.ContentType2PushContent[constant.SignalMsg]
+			default:
+				content = constant.ContentType2PushContent[constant.Common]
+
+			}
+		}
+
+		callbackResp := callbackOfflinePush(pushMsg.OperationID, UIDList[0], pushMsg.MsgData)
+		log.NewDebug(pushMsg.OperationID, utils.GetSelfFuncName(), "offline callback Resp")
+		if callbackResp.ErrCode != 0 {
+			log.NewError(pushMsg.OperationID, utils.GetSelfFuncName(), "callbackOfflinePush result: ", callbackResp)
+		}
+		if callbackResp.ActionCode != constant.ActionAllow {
+			log.NewDebug(pushMsg.OperationID, utils.GetSelfFuncName(), "offlinePush stop")
+			return
+		}
+		if offlinePusher == nil {
+			return
+		}
+		opts, err := GetOfflinePushOpts(pushMsg)
+		if err != nil {
+			log.NewError(pushMsg.OperationID, utils.GetSelfFuncName(), "GetOfflinePushOpts failed", pushMsg, err.Error())
+		}
+		log.NewInfo(pushMsg.OperationID, utils.GetSelfFuncName(), UIDList, content, jsonCustomContent, "opts:", opts)
+		pushResult, err := offlinePusher.Push(UIDList, content, jsonCustomContent, pushMsg.OperationID, opts)
+		if err != nil {
+			log.NewError(pushMsg.OperationID, "offline push error", pushMsg.String(), err.Error())
+		} else {
+			log.NewDebug(pushMsg.OperationID, "offline push return result is ", pushResult, pushMsg.MsgData)
+		}
+	}
+}
+
+func MsgToSuperGroupUser(pushMsg *pbPush.PushMsgReq) {
+	var wsResult []*pbRelay.SingelMsgToUserResultList
+	isOfflinePush := utils.GetSwitchFromOptions(pushMsg.MsgData.Options, constant.IsOfflinePush)
+	log.Debug(pushMsg.OperationID, "Get super group msg from msg_transfer And push msg", pushMsg.String())
+	getGroupMemberIDListFromCacheReq := &pbCache.GetGroupMemberIDListFromCacheReq{OperationID: pushMsg.OperationID, GroupID: pushMsg.MsgData.GroupID}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, pushMsg.OperationID)
+	if etcdConn == nil {
+		errMsg := pushMsg.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(pushMsg.OperationID, errMsg)
+		return
+	}
+	client := pbCache.NewCacheClient(etcdConn)
+	cacheResp, err := client.GetGroupMemberIDListFromCache(context.Background(), getGroupMemberIDListFromCacheReq)
+	if err != nil {
+		log.NewError(pushMsg.OperationID, "GetGroupMemberIDListFromCache rpc call failed ", err.Error())
+		return
+	}
+	if cacheResp.CommonResp.ErrCode != 0 {
+		log.NewError(pushMsg.OperationID, "GetGroupMemberIDListFromCache rpc logic call failed ", cacheResp.String())
+		return
+	}
+	if len(grpcCons) == 0 {
+		log.NewWarn(pushMsg.OperationID, "first GetConn4Unique ")
+		grpcCons = getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName)
+	}
+	//Online push message
 	log.Debug("test", pushMsg.OperationID, "len  grpc", len(grpcCons), "data", pushMsg.String())
 	for _, v := range grpcCons {
 		msgClient := pbRelay.NewOnlineMessageRelayServiceClient(v)
-		reply, err := msgClient.OnlinePushMsg(context.Background(), &pbRelay.OnlinePushMsgReq{OperationID: pushMsg.OperationID, MsgData: pushMsg.MsgData, PushToUserID: pushMsg.PushToUserID})
+		reply, err := msgClient.SuperGroupOnlineBatchPushOneMsg(context.Background(), &pbRelay.OnlineBatchPushOneMsgReq{OperationID: pushMsg.OperationID, MsgData: pushMsg.MsgData, PushToUserIDList: cacheResp.UserIDList})
 		if err != nil {
 			log.NewError("push data to client rpc err", pushMsg.OperationID, "err", err)
 			continue
 		}
-		if reply != nil && reply.Resp != nil {
-			wsResult = append(wsResult, reply.Resp...)
+		if reply != nil && reply.SinglePushResult != nil {
+			wsResult = append(wsResult, reply.SinglePushResult...)
 		}
 	}
-	log.NewInfo(pushMsg.OperationID, "push_result", wsResult, "sendData", pushMsg.MsgData)
+	log.Debug(pushMsg.OperationID, "push_result", wsResult, "sendData", pushMsg.MsgData)
 	successCount++
-	if isOfflinePush && pushMsg.PushToUserID != pushMsg.MsgData.SendID {
-		// save invitation info for offline push
-		if pushMsg.MsgData.ContentType == constant.SignalingNotification {
-			if err := db.DB.HandleSignalInfo(pushMsg.OperationID, pushMsg.MsgData); err != nil {
-				log.NewError(pushMsg.OperationID, utils.GetSelfFuncName(), err.Error(), pushMsg.MsgData)
-				return
-			}
-		}
+	if isOfflinePush {
+		var onlineSuccessUserIDList []string
+		onlineSuccessUserIDList = append(onlineSuccessUserIDList, pushMsg.MsgData.SendID)
 		for _, v := range wsResult {
-			if v.ResultCode == 0 {
-				if utils.IsContainInt32(v.RecvPlatFormID, pushTerminal) {
-					break
-				}
-				continue
+			if v.OnlinePush && v.UserID != pushMsg.MsgData.SendID {
+				onlineSuccessUserIDList = append(onlineSuccessUserIDList, v.UserID)
 			}
-			if utils.IsContainInt32(v.RecvPlatFormID, pushTerminal) {
-				//Use offline push messaging
-				var UIDList []string
-				UIDList = append(UIDList, v.RecvID)
-				customContent := OpenIMContent{
-					SessionType: int(pushMsg.MsgData.SessionType),
-					From:        pushMsg.MsgData.SendID,
-					To:          pushMsg.MsgData.RecvID,
-					Seq:         pushMsg.MsgData.Seq,
-				}
-				bCustomContent, _ := json.Marshal(customContent)
-				jsonCustomContent := string(bCustomContent)
-				var content string
-				if pushMsg.MsgData.OfflinePushInfo != nil {
-					content = pushMsg.MsgData.OfflinePushInfo.Title
-					log.NewDebug(pushMsg.OperationID, utils.GetSelfFuncName(), "xxxx OfflinePushInfo", content)
-				} else {
-					switch pushMsg.MsgData.ContentType {
-					case constant.Text:
-						content = constant.ContentType2PushContent[constant.Text]
-					case constant.Picture:
-						content = constant.ContentType2PushContent[constant.Picture]
-					case constant.Voice:
-						content = constant.ContentType2PushContent[constant.Voice]
-					case constant.Video:
-						content = constant.ContentType2PushContent[constant.Video]
-					case constant.File:
-						content = constant.ContentType2PushContent[constant.File]
-					case constant.AtText:
-						a := AtContent{}
-						_ = utils.JsonStringToStruct(string(pushMsg.MsgData.Content), &a)
-						if utils.IsContain(v.RecvID, a.AtUserList) {
-							content = constant.ContentType2PushContent[constant.AtText] + constant.ContentType2PushContent[constant.Common]
-						} else {
-							content = constant.ContentType2PushContent[constant.GroupMsg]
-						}
-					case constant.SignalingNotification:
-						content = constant.ContentType2PushContent[constant.SignalMsg]
-					default:
-						content = constant.ContentType2PushContent[constant.Common]
-					}
-				}
-				callbackResp := callbackOfflinePush(pushMsg.OperationID, UIDList[0], pushMsg.MsgData)
-				log.NewDebug(pushMsg.OperationID, utils.GetSelfFuncName(), "offline callback Resp")
-				if callbackResp.ErrCode != 0 {
-					log.NewError(pushMsg.OperationID, utils.GetSelfFuncName(), "callbackOfflinePush result: ", callbackResp)
-				}
-				if callbackResp.ActionCode != constant.ActionAllow {
-					log.NewDebug(pushMsg.OperationID, utils.GetSelfFuncName(), "offlinePush stop")
-					break
-				}
-				if offlinePusher == nil {
-					break
-				}
+		}
+		onlineFailedUserIDList := utils.DifferenceString(onlineSuccessUserIDList, cacheResp.UserIDList)
+		//Use offline push messaging
+		customContent := OpenIMContent{
+			SessionType: int(pushMsg.MsgData.SessionType),
+			From:        pushMsg.MsgData.SendID,
+			To:          pushMsg.MsgData.RecvID,
+			Seq:         pushMsg.MsgData.Seq,
+		}
+		bCustomContent, _ := json.Marshal(customContent)
+		jsonCustomContent := string(bCustomContent)
+		var content string
+		if pushMsg.MsgData.OfflinePushInfo != nil {
+			content = pushMsg.MsgData.OfflinePushInfo.Title
 
-				opts, err := GetOfflinePushOpts(pushMsg)
-				if err != nil {
-					log.NewError(pushMsg.OperationID, utils.GetSelfFuncName(), "GetOfflinePushOpts failed", pushMsg, err.Error())
-				}
-				log.NewInfo(pushMsg.OperationID, utils.GetSelfFuncName(), UIDList, content, jsonCustomContent, "opts:", opts)
-				pushResult, err := offlinePusher.Push(UIDList, content, jsonCustomContent, pushMsg.OperationID, opts)
-				log.NewDebug(pushMsg.OperationID, utils.GetSelfFuncName(), "offline pushResult: ", pushResult)
-				if err != nil {
-					log.NewError(pushMsg.OperationID, "offline push error", pushMsg.String(), err.Error())
+		} else {
+			switch pushMsg.MsgData.ContentType {
+			case constant.Text:
+				content = constant.ContentType2PushContent[constant.Text]
+			case constant.Picture:
+				content = constant.ContentType2PushContent[constant.Picture]
+			case constant.Voice:
+				content = constant.ContentType2PushContent[constant.Voice]
+			case constant.Video:
+				content = constant.ContentType2PushContent[constant.Video]
+			case constant.File:
+				content = constant.ContentType2PushContent[constant.File]
+			case constant.AtText:
+				a := AtContent{}
+				_ = utils.JsonStringToStruct(string(pushMsg.MsgData.Content), &a)
+				if utils.IsContain(pushMsg.PushToUserID, a.AtUserList) {
+					content = constant.ContentType2PushContent[constant.AtText] + constant.ContentType2PushContent[constant.Common]
 				} else {
-					log.NewDebug(pushMsg.OperationID, "offline push return result is ", pushResult, pushMsg.MsgData)
+					content = constant.ContentType2PushContent[constant.GroupMsg]
 				}
-				break
+			case constant.SignalingNotification:
+				content = constant.ContentType2PushContent[constant.SignalMsg]
+			default:
+				content = constant.ContentType2PushContent[constant.Common]
+
 			}
-
 		}
 
+		callbackResp := callbackOfflinePush(pushMsg.OperationID, onlineFailedUserIDList[0], pushMsg.MsgData)
+		log.NewDebug(pushMsg.OperationID, utils.GetSelfFuncName(), "offline callback Resp")
+		if callbackResp.ErrCode != 0 {
+			log.NewError(pushMsg.OperationID, utils.GetSelfFuncName(), "callbackOfflinePush result: ", callbackResp)
+		}
+		if callbackResp.ActionCode != constant.ActionAllow {
+			log.NewDebug(pushMsg.OperationID, utils.GetSelfFuncName(), "offlinePush stop")
+			return
+		}
+		if offlinePusher == nil {
+			return
+		}
+		opts, err := GetOfflinePushOpts(pushMsg)
+		if err != nil {
+			log.NewError(pushMsg.OperationID, utils.GetSelfFuncName(), "GetOfflinePushOpts failed", pushMsg, err.Error())
+		}
+		log.NewInfo(pushMsg.OperationID, utils.GetSelfFuncName(), onlineFailedUserIDList, content, jsonCustomContent, "opts:", opts)
+		pushResult, err := offlinePusher.Push(onlineFailedUserIDList, content, jsonCustomContent, pushMsg.OperationID, opts)
+		if err != nil {
+			log.NewError(pushMsg.OperationID, "offline push error", pushMsg.String(), err.Error())
+		} else {
+			log.NewDebug(pushMsg.OperationID, "offline push return result is ", pushResult, pushMsg.MsgData)
+		}
 	}
 }
 

internal/rpc/auth/auth.go

@@ -8,8 +8,10 @@ import (
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	pbAuth "Open_IM/pkg/proto/auth"
+	pbRelay "Open_IM/pkg/proto/relay"
 	"Open_IM/pkg/utils"
 	"context"
+	"errors"
 	"net"
 	"strconv"
 	"strings"
@@ -47,7 +49,7 @@ func (rpc *rpcAuth) UserToken(_ context.Context, req *pbAuth.UserTokenReq) (*pbA
 		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}}, nil
 	}
 
-	tokens, expTime, err := token_verify.CreateToken(req.FromUserID, req.Platform)
+	tokens, expTime, err := token_verify.CreateToken(req.FromUserID, int(req.Platform))
 	if err != nil {
 		errMsg := req.OperationID + " token_verify.CreateToken failed " + err.Error() + req.FromUserID + utils.Int32ToString(req.Platform)
 		log.NewError(req.OperationID, errMsg)
@@ -58,6 +60,41 @@ func (rpc *rpcAuth) UserToken(_ context.Context, req *pbAuth.UserTokenReq) (*pbA
 	return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{}, Token: tokens, ExpiredTime: expTime}, nil
 }
 
+func (rpc *rpcAuth) ForceLogout(_ context.Context, req *pbAuth.ForceLogoutReq) (*pbAuth.ForceLogoutResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " IsManagerUserID false " + req.OpUserID
+		log.NewError(req.OperationID, errMsg)
+		return &pbAuth.ForceLogoutResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
+	}
+	if err := token_verify.DeleteToken(req.FromUserID, int(req.Platform)); err != nil {
+		errMsg := req.OperationID + " DeleteToken failed " + err.Error() + req.FromUserID + utils.Int32ToString(req.Platform)
+		log.NewError(req.OperationID, errMsg)
+		return &pbAuth.ForceLogoutResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}}, nil
+	}
+	if err := rpc.forceKickOff(req.FromUserID, req.Platform, req.OperationID); err != nil {
+		errMsg := req.OperationID + " forceKickOff failed " + err.Error() + req.FromUserID + utils.Int32ToString(req.Platform)
+		log.NewError(req.OperationID, errMsg)
+		return &pbAuth.ForceLogoutResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}}, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{}})
+	return &pbAuth.ForceLogoutResp{CommonResp: &pbAuth.CommonResp{}}, nil
+}
+
+func (rpc *rpcAuth) forceKickOff(userID string, platformID int32, operationID string) error {
+
+	grpcCons := getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName)
+	for _, v := range grpcCons {
+		client := pbRelay.NewOnlineMessageRelayServiceClient(v)
+		kickReq := &pbRelay.KickUserOfflineReq{OperationID: operationID, KickUserIDList: []string{userID}, PlatformID: platformID}
+		log.NewInfo(operationID, "KickUserOffline ", client, kickReq.String())
+		_, err := client.KickUserOffline(context.Background(), kickReq)
+		return utils.Wrap(err, "")
+	}
+
+	return errors.New("no rpc node ")
+}
+
 type rpcAuth struct {
 	rpcPort         int
 	rpcRegisterName string

internal/rpc/friend/firend.go

@@ -63,7 +63,7 @@ func (s *friendServer) Run() {
 	defer srv.GracefulStop()
 	//User friend related services register to etcd
 	pbFriend.RegisterFriendServer(srv, s)
-	rpcRegisterIP := ""
+	rpcRegisterIP := config.Config.RpcRegisterIP
 	if config.Config.RpcRegisterIP == "" {
 		rpcRegisterIP, err = utils.GetLocalIP()
 		if err != nil {
@@ -99,7 +99,12 @@ func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlackl
 	}
 	log.NewInfo(req.CommID.OperationID, "AddBlacklist rpc ok ", req.CommID.FromUserID, req.CommID.ToUserID)
 	reqAddBlackUserToCache := &pbCache.AddBlackUserToCacheReq{UserID: req.CommID.FromUserID, BlackUserID: req.CommID.ToUserID, OperationID: req.CommID.OperationID}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: errMsg}}, nil
+	}
 	cacheClient := pbCache.NewCacheClient(etcdConn)
 	cacheResp, err := cacheClient.AddBlackUserToCache(context.Background(), reqAddBlackUserToCache)
 	if err != nil {
@@ -263,7 +268,12 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
 			}
 			// cache rpc
 			addFriendToCacheReq := &pbCache.AddFriendToCacheReq{OperationID: req.CommID.OperationID}
-			etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+			etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.CommID.OperationID)
+			if etcdConn == nil {
+				errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+				log.NewError(req.CommID.OperationID, errMsg)
+				return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: errMsg}}, nil
+			}
 			client := pbCache.NewCacheClient(etcdConn)
 			addFriendToCacheReq.UserID = req.CommID.ToUserID
 			addFriendToCacheReq.FriendID = req.CommID.FromUserID
@@ -318,7 +328,12 @@ func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFri
 	}
 	log.NewInfo(req.CommID.OperationID, "DeleteFriend rpc ok")
 	reduceFriendFromCache := &pbCache.ReduceFriendFromCacheReq{OperationID: req.CommID.OperationID, UserID: req.CommID.FromUserID, FriendID: req.CommID.ToUserID}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: errMsg}}, nil
+	}
 	client := pbCache.NewCacheClient(etcdConn)
 	respPb, err := client.ReduceFriendFromCache(context.Background(), reduceFriendFromCache)
 	if err != nil {
@@ -399,7 +414,13 @@ func (s *friendServer) RemoveBlacklist(ctx context.Context, req *pbFriend.Remove
 	}
 	log.NewInfo(req.CommID.OperationID, "rpc RemoveBlacklist ok ")
 	reqReduceBlackUserFromCache := &pbCache.ReduceBlackUserFromCacheReq{UserID: req.CommID.FromUserID, BlackUserID: req.CommID.ToUserID, OperationID: req.CommID.OperationID}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		return &pbFriend.RemoveBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: errMsg}}, nil
+	}
+
 	cacheClient := pbCache.NewCacheClient(etcdConn)
 	cacheResp, err := cacheClient.ReduceBlackUserFromCache(context.Background(), reqReduceBlackUserFromCache)
 	if err != nil {

internal/rpc/group/super_group.go

@@ -0,0 +1,64 @@
+package group
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	cp "Open_IM/pkg/common/utils"
+	pbGroup "Open_IM/pkg/proto/group"
+	commonPb "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+)
+
+func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.GetJoinedSuperGroupListReq) (*pbGroup.GetJoinedSuperGroupListResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &pbGroup.GetJoinedSuperGroupListResp{CommonResp: &pbGroup.CommonResp{}}
+	userToSuperGroup, err := db.DB.GetSuperGroupByUserID(req.UserID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetSuperGroupByUserID failed", err.Error())
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
+		return resp, nil
+	}
+	for _, groupID := range userToSuperGroup.GroupIDList {
+		groupInfoDB, err := imdb.GetGroupInfoByGroupID(groupID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupInfoByGroupID failed", groupID, err.Error())
+			continue
+		}
+		groupInfo := &commonPb.GroupInfo{}
+		if err := utils.CopyStructFields(groupInfo, groupInfoDB); err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+		}
+		group, err := db.DB.GetSuperGroup(groupID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetSuperGroup failed", groupID, err.Error())
+			continue
+		}
+		groupInfo.MemberCount = uint32(len(group.MemberIDList))
+		resp.GroupList = append(resp.GroupList, groupInfo)
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *groupServer) GetSuperGroupsInfo(_ context.Context, req *pbGroup.GetSuperGroupsInfoReq) (resp *pbGroup.GetSuperGroupsInfoResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbGroup.GetSuperGroupsInfoResp{CommonResp: &pbGroup.CommonResp{}}
+	groupsInfoList := make([]*commonPb.GroupInfo, 0)
+	for _, groupID := range req.GroupIDList {
+		groupInfoFromMysql, err := imdb.GetGroupInfoByGroupID(groupID)
+		if err != nil {
+			log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", err.Error(), groupID)
+			continue
+		}
+		var groupInfo commonPb.GroupInfo
+		cp.GroupDBCopyOpenIM(&groupInfo, groupInfoFromMysql)
+		groupsInfoList = append(groupsInfoList, &groupInfo)
+	}
+	resp.GroupInfoList = groupsInfoList
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}

internal/rpc/msg/chat.go

@@ -0,0 +1,38 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/utils"
+	"context"
+)
+
+func (rpc *rpcChat) ClearMsg(_ context.Context, req *pbChat.ClearMsgReq) (*pbChat.ClearMsgResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc req: ", req.String())
+	if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.UserID) {
+		errMsg := "No permission" + req.OpUserID + req.UserID
+		log.Error(req.OperationID, errMsg)
+		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "CleanUpOneUserAllMsgFromRedis args", req.UserID)
+	err := db.DB.CleanUpOneUserAllMsgFromRedis(req.UserID, req.OperationID)
+	if err != nil {
+		errMsg := "CleanUpOneUserAllMsgFromRedis failed " + err.Error() + req.OperationID + req.UserID
+		log.Error(req.OperationID, errMsg)
+		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "CleanUpUserMsgFromMongo args", req.UserID)
+	err = db.DB.CleanUpUserMsgFromMongo(req.UserID, req.OperationID)
+	if err != nil {
+		errMsg := "CleanUpUserMsgFromMongo failed " + err.Error() + req.OperationID + req.UserID
+		log.Error(req.OperationID, errMsg)
+		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	resp := pbChat.ClearMsgResp{ErrCode: 0}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return &resp, nil
+}

internal/rpc/msg/conversation_notification.go

@@ -49,12 +49,6 @@ func ConversationSetPrivateNotification(operationID, sendID, recvID string, isPr
 	}
 	var tips open_im_sdk.TipsComm
 	var tipsMsg string
-	//var senderName string
-	//senderName, err := im_mysql_model.GetUserNameByUserID(sendID)
-	//if err != nil {
-	//	log.NewError(operationID, utils.GetSelfFuncName(), err.Error())
-	//	senderName = sendID
-	//}
 	if isPrivateChat == true {
 		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.OpenTips
 	} else {

internal/rpc/msg/group_notification.go

@@ -36,7 +36,6 @@ func setOpUserInfo(opUserID, groupID string, groupMemberInfo *open_im_sdk.GroupM
 				return utils.Wrap(err, "")
 			}
 		}
-
 		user, err := imdb.GetUserByUserID(opUserID)
 		if err != nil {
 			return utils.Wrap(err, "")
@@ -101,7 +100,7 @@ func setPublicUserInfo(userID string, publicUserInfo *open_im_sdk.PublicUserInfo
 }
 
 func groupNotification(contentType int32, m proto.Message, sendID, groupID, recvUserID, operationID string) {
-	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType)
+	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType, sendID, groupID, recvUserID)
 
 	var err error
 	var tips open_im_sdk.TipsComm
@@ -117,19 +116,19 @@ func groupNotification(contentType int32, m proto.Message, sendID, groupID, recv
 	}
 
 	tips.JsonDetail, _ = marshaler.MarshalToString(m)
+	var nickname string
 
 	from, err := imdb.GetUserByUserID(sendID)
 	if err != nil {
 		log.Error(operationID, "GetUserByUserID failed ", err.Error(), sendID)
 	}
-	nickname := ""
 	if from != nil {
 		nickname = from.Nickname
 	}
 
 	to, err := imdb.GetUserByUserID(recvUserID)
 	if err != nil {
-		log.Error(operationID, "GetUserByUserID failed ", err.Error(), recvUserID)
+		log.NewWarn(operationID, "GetUserByUserID failed ", err.Error(), recvUserID)
 	}
 	toNickname := ""
 	if to != nil {
@@ -170,7 +169,10 @@ func groupNotification(contentType int32, m proto.Message, sendID, groupID, recv
 		tips.DefaultTips = toNickname + "" + cn.GroupMemberCancelMuted.DefaultTips.Tips
 	case constant.GroupMemberInfoSetNotification:
 		tips.DefaultTips = toNickname + "" + cn.GroupMemberInfoSet.DefaultTips.Tips
-
+	case constant.GroupMemberSetToAdminNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToAdmin.DefaultTips.Tips
+	case constant.GroupMemberSetToOrdinaryUserNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToOrdinary.DefaultTips.Tips
 	default:
 		log.Error(operationID, "contentType failed ", contentType)
 		return
@@ -225,12 +227,20 @@ func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberL
 }
 
 //群信息改变后掉用
-func GroupInfoSetNotification(operationID, opUserID, groupID string) {
+//groupName := ""
+//	notification := ""
+//	introduction := ""
+//	faceURL := ""
+func GroupInfoSetNotification(operationID, opUserID, groupID string, groupName, notification, introduction, faceURL 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
 	}
+	GroupInfoChangedTips.Group.GroupName = groupName
+	GroupInfoChangedTips.Group.Notification = notification
+	GroupInfoChangedTips.Group.Introduction = introduction
+	GroupInfoChangedTips.Group.FaceURL = faceURL
 	if err := setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil {
 		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
 		return
@@ -303,6 +313,28 @@ func GroupMemberInfoSetNotification(operationID, opUserID, groupID, groupMemberU
 	groupNotification(constant.GroupMemberInfoSetNotification, &tips, opUserID, groupID, "", operationID)
 }
 
+func GroupMemberRoleLevelChangeNotification(operationID, opUserID, groupID, groupMemberUserID string, notificationType int32) {
+	if notificationType != constant.GroupMemberSetToAdminNotification && notificationType != constant.GroupMemberSetToOrdinaryUserNotification {
+		log.NewError(operationID, utils.GetSelfFuncName(), "invalid notificationType: ", notificationType)
+		return
+	}
+	tips := open_im_sdk.GroupMemberInfoSetTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}, ChangedUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(groupID, tips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
+		return
+	}
+	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
+		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
+		return
+	}
+	groupNotification(notificationType, &tips, opUserID, groupID, "", operationID)
+}
+
 func GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMemberUserID string) {
 	tips := open_im_sdk.GroupMemberCancelMutedTips{Group: &open_im_sdk.GroupInfo{},
 		OpUser: &open_im_sdk.GroupMemberFullInfo{}, MutedUser: &open_im_sdk.GroupMemberFullInfo{}}

internal/rpc/msg/pull_message.go

@@ -2,47 +2,55 @@ package msg
 
 import (
 	"context"
-	"github.com/garyburd/redigo/redis"
+	go_redis "github.com/go-redis/redis/v8"
 
 	commonDB "Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/log"
-	pbMsg "Open_IM/pkg/proto/chat"
 	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
 )
 
-func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *pbMsg.GetMaxAndMinSeqReq) (*pbMsg.GetMaxAndMinSeqResp, error) {
+func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *open_im_sdk.GetMaxAndMinSeqReq) (*open_im_sdk.GetMaxAndMinSeqResp, error) {
 	log.NewInfo(in.OperationID, "rpc getMaxAndMinSeq is arriving", in.String())
+	resp := new(open_im_sdk.GetMaxAndMinSeqResp)
+	m := make(map[string]*open_im_sdk.MaxAndMinSeq)
 	//seq, err := model.GetBiggestSeqFromReceive(in.UserID)
 	maxSeq, err1 := commonDB.DB.GetUserMaxSeq(in.UserID)
-	minSeq, err2 := commonDB.DB.GetUserMinSeq(in.UserID)
-	resp := new(pbMsg.GetMaxAndMinSeqResp)
+	//minSeq, err2 := commonDB.DB.GetUserMinSeq(in.UserID)
 	if err1 == nil {
 		resp.MaxSeq = uint32(maxSeq)
-	} else if err1 == redis.ErrNil {
+		for _, v := range in.GroupIDList {
+			x := new(open_im_sdk.MaxAndMinSeq)
+			maxSeq, _ := commonDB.DB.GetUserMaxSeq(v)
+			x.MaxSeq = uint32(maxSeq)
+			m[v] = x
+		}
+		resp.GroupMaxAndMinSeq = m
+	} else if err1 == go_redis.Nil {
 		resp.MaxSeq = 0
 	} else {
 		log.NewError(in.OperationID, "getMaxSeq from redis error", in.String(), err1.Error())
 		resp.ErrCode = 200
 		resp.ErrMsg = "redis get err"
 	}
-	if err2 == nil {
-		resp.MinSeq = uint32(minSeq)
-	} else if err2 == redis.ErrNil {
-		resp.MinSeq = 0
-	} else {
-		log.NewError(in.OperationID, "getMaxSeq from redis error", in.String(), err2.Error())
-		resp.ErrCode = 201
-		resp.ErrMsg = "redis get err"
-	}
+	//if err2 == nil {
+	//	resp.MinSeq = uint32(minSeq)
+	//} else if err2 == redis.ErrNil {
+	//	resp.MinSeq = 0
+	//} else {
+	//	log.NewError(in.OperationID, "getMaxSeq from redis error", in.String(), err2.Error())
+	//	resp.ErrCode = 201
+	//	resp.ErrMsg = "redis get err"
+	//}
 	return resp, nil
 }
 func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *open_im_sdk.PullMessageBySeqListReq) (*open_im_sdk.PullMessageBySeqListResp, error) {
 	log.NewInfo(in.OperationID, "rpc PullMessageBySeqList is arriving", in.String())
 	resp := new(open_im_sdk.PullMessageBySeqListResp)
+	m := make(map[string]*open_im_sdk.MsgDataList)
 	//msgList, err := commonDB.DB.GetMsgBySeqList(in.UserID, in.SeqList, in.OperationID)
 	redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(in.UserID, in.SeqList, in.OperationID)
 	if err != nil {
-		if err != redis.ErrNil {
+		if err != go_redis.Nil {
 			log.Error(in.OperationID, "get message from redis exception", err.Error(), failedSeqList)
 		} else {
 			log.Debug(in.OperationID, "get message from redis is nil", failedSeqList)
@@ -60,6 +68,32 @@ func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *open_im_sdk.Pull
 	} else {
 		resp.List = redisMsgList
 	}
+	for k, v := range in.GroupSeqList {
+		x := new(open_im_sdk.MsgDataList)
+		redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(k, v.SeqList, in.OperationID)
+		if err != nil {
+			if err != go_redis.Nil {
+				log.Error(in.OperationID, "get message from redis exception", err.Error(), failedSeqList)
+			} else {
+				log.Debug(in.OperationID, "get message from redis is nil", failedSeqList)
+			}
+			msgList, err1 := commonDB.DB.GetSuperGroupMsgBySeqListMongo(k, failedSeqList, in.OperationID)
+			if err1 != nil {
+				log.Error(in.OperationID, "PullMessageBySeqList data error", in.String(), err.Error())
+				resp.ErrCode = 201
+				resp.ErrMsg = err.Error()
+				return resp, nil
+			} else {
+				redisMsgList = append(redisMsgList, msgList...)
+				x.MsgDataList = redisMsgList
+				m[k] = x
+			}
+		} else {
+			x.MsgDataList = redisMsgList
+			m[k] = x
+		}
+	}
+	resp.GroupMsgDataList = m
 	//respSingleMsgFormat = singleMsgHandleByUser(SingleMsgFormat, in.UserID)
 	//respGroupMsgFormat = groupMsgHandleByUser(GroupMsgFormat)
 	return resp, nil

internal/rpc/msg/send_msg.go

@@ -15,7 +15,7 @@ import (
 	"Open_IM/pkg/utils"
 	"context"
 	"errors"
-	"github.com/garyburd/redigo/redis"
+	go_redis "github.com/go-redis/redis/v8"
 	"github.com/golang/protobuf/proto"
 	"math/rand"
 	"strconv"
@@ -68,43 +68,62 @@ func isMessageHasReadEnabled(pb *pbChat.SendMsgReq) (bool, int32, string) {
 }
 
 func userRelationshipVerification(data *pbChat.SendMsgReq) (bool, int32, string) {
-	if data.MsgData.SessionType == constant.GroupChatType {
-		return true, 0, ""
-	}
-	log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify)
-	reqGetBlackIDListFromCache := &cacheRpc.GetBlackIDListFromCacheReq{UserID: data.MsgData.RecvID, OperationID: data.OperationID}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
-	cacheClient := cacheRpc.NewCacheClient(etcdConn)
-	cacheResp, err := cacheClient.GetBlackIDListFromCache(context.Background(), reqGetBlackIDListFromCache)
-	if err != nil {
-		log.NewError(data.OperationID, "GetBlackIDListFromCache rpc call failed ", err.Error())
-	} else {
-		if cacheResp.CommonResp.ErrCode != 0 {
-			log.NewError(data.OperationID, "GetBlackIDListFromCache rpc logic call failed ", cacheResp.String())
-		} else {
-			if utils.IsContain(data.MsgData.SendID, cacheResp.UserIDList) {
-				return false, 600, "in black list"
-			}
+	if data.MsgData.SessionType == constant.SingleChatType {
+		if utils.IsContain(data.MsgData.SendID, config.Config.Manager.AppManagerUid) {
+			return true, 0, ""
 		}
-	}
-	log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify)
-	if config.Config.MessageVerify.FriendVerify {
-		reqGetFriendIDListFromCache := &cacheRpc.GetFriendIDListFromCacheReq{UserID: data.MsgData.RecvID, OperationID: data.OperationID}
-		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+		if data.MsgData.ContentType <= constant.FriendApplicationNotification && data.MsgData.ContentType >= constant.FriendApplicationApprovedNotification {
+			return true, 0, ""
+		}
+		log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify)
+		reqGetBlackIDListFromCache := &cacheRpc.GetBlackIDListFromCacheReq{UserID: data.MsgData.RecvID, OperationID: data.OperationID}
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, data.OperationID)
+		if etcdConn == nil {
+			errMsg := data.OperationID + "getcdv3.GetConn == nil"
+			log.NewError(data.OperationID, errMsg)
+			return true, 0, ""
+		}
+
 		cacheClient := cacheRpc.NewCacheClient(etcdConn)
-		cacheResp, err := cacheClient.GetFriendIDListFromCache(context.Background(), reqGetFriendIDListFromCache)
+		cacheResp, err := cacheClient.GetBlackIDListFromCache(context.Background(), reqGetBlackIDListFromCache)
 		if err != nil {
-			log.NewError(data.OperationID, "GetFriendIDListFromCache rpc call failed ", err.Error())
+			log.NewError(data.OperationID, "GetBlackIDListFromCache rpc call failed ", err.Error())
 		} else {
 			if cacheResp.CommonResp.ErrCode != 0 {
-				log.NewError(data.OperationID, "GetFriendIDListFromCache rpc logic call failed ", cacheResp.String())
+				log.NewError(data.OperationID, "GetBlackIDListFromCache rpc logic call failed ", cacheResp.String())
 			} else {
-				if !utils.IsContain(data.MsgData.SendID, cacheResp.UserIDList) {
-					return false, 601, "not friend"
+				if utils.IsContain(data.MsgData.SendID, cacheResp.UserIDList) {
+					return false, 600, "in black list"
 				}
 			}
 		}
-		return true, 0, ""
+		log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify)
+		if config.Config.MessageVerify.FriendVerify {
+			reqGetFriendIDListFromCache := &cacheRpc.GetFriendIDListFromCacheReq{UserID: data.MsgData.RecvID, OperationID: data.OperationID}
+			etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, data.OperationID)
+			if etcdConn == nil {
+				errMsg := data.OperationID + "getcdv3.GetConn == nil"
+				log.NewError(data.OperationID, errMsg)
+				return true, 0, ""
+			}
+			cacheClient := cacheRpc.NewCacheClient(etcdConn)
+			cacheResp, err := cacheClient.GetFriendIDListFromCache(context.Background(), reqGetFriendIDListFromCache)
+			if err != nil {
+				log.NewError(data.OperationID, "GetFriendIDListFromCache rpc call failed ", err.Error())
+			} else {
+				if cacheResp.CommonResp.ErrCode != 0 {
+					log.NewError(data.OperationID, "GetFriendIDListFromCache rpc logic call failed ", cacheResp.String())
+				} else {
+					if !utils.IsContain(data.MsgData.SendID, cacheResp.UserIDList) {
+						return false, 601, "not friend"
+					}
+				}
+			}
+			return true, 0, ""
+		} else {
+			return true, 0, ""
+		}
+
 	} else {
 		return true, 0, ""
 	}
@@ -155,30 +174,29 @@ func (rpc *rpcChat) encapsulateMsgData(msg *sdk_ws.MsgData) {
 		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
 		utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, false)
 		utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false)
-
 	}
 }
 func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.SendMsgResp, error) {
 	replay := pbChat.SendMsgResp{}
 	newTime := db.GetCurrentTimestampByMill()
-	log.NewWarn(pb.OperationID, "rpc sendMsg come here", pb.String(), pb.MsgData.ClientMsgID)
+	log.Info(pb.OperationID, "rpc sendMsg come here ", pb.String())
 	flag, errCode, errMsg := isMessageHasReadEnabled(pb)
+	log.Info(pb.OperationID, "isMessageHasReadEnabled ", flag)
 	if !flag {
 		return returnMsg(&replay, pb, errCode, errMsg, "", 0)
 	}
-	log.Debug(pb.OperationID, "flag ", flag, config.Config.SingleMessageHasReadReceiptEnable, config.Config.GroupMessageHasReadReceiptEnable)
 	flag, errCode, errMsg = userRelationshipVerification(pb)
+	log.Info(pb.OperationID, "userRelationshipVerification ", flag)
 	if !flag {
 		return returnMsg(&replay, pb, errCode, errMsg, "", 0)
 	}
 	rpc.encapsulateMsgData(pb.MsgData)
-	log.Info("", "this is a test MsgData ", pb.MsgData)
 	msgToMQSingle := pbChat.MsgDataToMQ{Token: pb.Token, OperationID: pb.OperationID, MsgData: pb.MsgData}
-
 	// callback
 	callbackResp := callbackWordFilter(pb)
+	log.Info(pb.OperationID, "callbackWordFilter ", callbackResp)
 	if callbackResp.ErrCode != 0 {
-		log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackWordFilter resp: ", callbackResp)
+		log.Error(pb.OperationID, utils.GetSelfFuncName(), "callbackWordFilter resp: ", callbackResp)
 	}
 	log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackResp: ", callbackResp)
 	if callbackResp.ActionCode != constant.ActionAllow {
@@ -208,7 +226,7 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
 			log.NewInfo(msgToMQSingle.OperationID, msgToMQSingle)
 			err1 := rpc.sendMsgToKafka(&msgToMQSingle, msgToMQSingle.MsgData.RecvID, constant.OnlineStatus)
 			if err1 != nil {
-				log.NewError(msgToMQSingle.OperationID, "kafka send msg err:RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String())
+				log.NewError(msgToMQSingle.OperationID, "kafka send msg err :RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String(), err1.Error())
 				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
 			}
 		}
@@ -239,7 +257,12 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
 			return returnMsg(&replay, pb, int32(callbackResp.ErrCode), callbackResp.ErrMsg, "", 0)
 		}
 		getGroupMemberIDListFromCacheReq := &pbCache.GetGroupMemberIDListFromCacheReq{OperationID: pb.OperationID, GroupID: pb.MsgData.GroupID}
-		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, msgToMQSingle.OperationID)
+		if etcdConn == nil {
+			errMsg := msgToMQSingle.OperationID + "getcdv3.GetConn == nil"
+			log.NewError(msgToMQSingle.OperationID, errMsg)
+			return returnMsg(&replay, pb, 201, errMsg, "", 0)
+		}
 		client := pbCache.NewCacheClient(etcdConn)
 		cacheResp, err := client.GetGroupMemberIDListFromCache(context.Background(), getGroupMemberIDListFromCacheReq)
 		if err != nil {
@@ -347,7 +370,12 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
 						conversationReq.UserIDList = pb.MsgData.AtUserIDList
 						conversation.GroupAtType = constant.AtMe
 					}
-					etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName)
+					etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName, pb.OperationID)
+					if etcdConn == nil {
+						errMsg := pb.OperationID + "getcdv3.GetConn == nil"
+						log.NewError(pb.OperationID, errMsg)
+						return
+					}
 					client := pbConversation.NewConversationClient(etcdConn)
 					conversationReply, err := client.ModifyConversationField(context.Background(), &conversationReq)
 					if err != nil {
@@ -358,7 +386,12 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
 					if tag {
 						conversationReq.UserIDList = utils.DifferenceString(atUserID, memberUserIDList)
 						conversation.GroupAtType = constant.AtAll
-						etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName)
+						etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName, pb.OperationID)
+						if etcdConn == nil {
+							errMsg := pb.OperationID + "getcdv3.GetConn == nil"
+							log.NewError(pb.OperationID, errMsg)
+							return
+						}
 						client := pbConversation.NewConversationClient(etcdConn)
 						conversationReply, err := client.ModifyConversationField(context.Background(), &conversationReq)
 						if err != nil {
@@ -391,6 +424,34 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
 
 		log.Debug(pb.OperationID, "send msg cost time ", db.GetCurrentTimestampByMill()-newTime, pb.MsgData.ClientMsgID)
 		return returnMsg(&replay, pb, 0, "", msgToMQSingle.MsgData.ServerMsgID, msgToMQSingle.MsgData.SendTime)
+	case constant.SuperGroupChatType:
+		// callback
+		callbackResp := callbackBeforeSendSingleMsg(pb)
+		if callbackResp.ErrCode != 0 {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSuperGroupMsg resp: ", callbackResp)
+		}
+		if callbackResp.ActionCode != constant.ActionAllow {
+			if callbackResp.ErrCode == 0 {
+				callbackResp.ErrCode = 201
+			}
+			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSuperGroupMsg result", "end rpc and return", callbackResp)
+			return returnMsg(&replay, pb, int32(callbackResp.ErrCode), callbackResp.ErrMsg, "", 0)
+		}
+		msgToMQSingle.MsgData = pb.MsgData
+		log.NewInfo(msgToMQSingle.OperationID, msgToMQSingle)
+		err1 := rpc.sendMsgToKafka(&msgToMQSingle, msgToMQSingle.MsgData.GroupID, constant.OnlineStatus)
+		if err1 != nil {
+			log.NewError(msgToMQSingle.OperationID, "kafka send msg err:RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String())
+			return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+		}
+
+		// callback
+		callbackResp = callbackAfterSendSingleMsg(pb)
+		if callbackResp.ErrCode != 0 {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendSuperGroupMsg resp: ", callbackResp)
+		}
+		return returnMsg(&replay, pb, 0, "", msgToMQSingle.MsgData.ServerMsgID, msgToMQSingle.MsgData.SendTime)
+
 	default:
 		return returnMsg(&replay, pb, 203, "unknown sessionType", "", 0)
 	}
@@ -430,13 +491,29 @@ func returnMsg(replay *pbChat.SendMsgResp, pb *pbChat.SendMsgReq, errCode int32,
 }
 
 func modifyMessageByUserMessageReceiveOpt(userID, sourceID string, sessionType int, pb *pbChat.SendMsgReq) bool {
-	conversationID := utils.GetConversationIDBySessionType(sourceID, sessionType)
-	opt, err := db.DB.GetSingleConversationRecvMsgOpt(userID, conversationID)
-	if err != nil && err != redis.ErrNil {
-		log.NewError(pb.OperationID, "GetSingleConversationMsgOpt from redis err", conversationID, pb.String(), err.Error())
-		return true
+	opt, err := db.DB.GetUserGlobalMsgRecvOpt(userID)
+	if err != nil {
+		log.NewError(pb.OperationID, "GetUserGlobalMsgRecvOpt from redis err", userID, pb.String(), err.Error())
+
 	}
 	switch opt {
+	case constant.ReceiveMessage:
+	case constant.NotReceiveMessage:
+		return false
+	case constant.ReceiveNotNotifyMessage:
+		if pb.MsgData.Options == nil {
+			pb.MsgData.Options = make(map[string]bool, 10)
+		}
+		utils.SetSwitchFromOptions(pb.MsgData.Options, constant.IsOfflinePush, false)
+		return true
+	}
+	conversationID := utils.GetConversationIDBySessionType(sourceID, sessionType)
+	singleOpt, sErr := db.DB.GetSingleConversationRecvMsgOpt(userID, conversationID)
+	if sErr != nil && sErr != go_redis.Nil {
+		log.NewError(pb.OperationID, "GetSingleConversationMsgOpt from redis err", conversationID, pb.String(), sErr.Error())
+		return true
+	}
+	switch singleOpt {
 	case constant.ReceiveMessage:
 		return true
 	case constant.NotReceiveMessage:
@@ -455,7 +532,7 @@ func modifyMessageByUserMessageReceiveOpt(userID, sourceID string, sessionType i
 func modifyMessageByUserMessageReceiveOptoptimization(userID, sourceID string, sessionType int, operationID string, options *map[string]bool) bool {
 	conversationID := utils.GetConversationIDBySessionType(sourceID, sessionType)
 	opt, err := db.DB.GetSingleConversationRecvMsgOpt(userID, conversationID)
-	if err != nil && err != redis.ErrNil {
+	if err != nil && err != go_redis.Nil {
 		log.NewError(operationID, "GetSingleConversationMsgOpt from redis err", userID, conversationID, err.Error())
 		return true
 	}
@@ -503,7 +580,7 @@ func Notification(n *NotificationMsg) {
 	msg.ClientMsgID = utils.GetMsgID(n.SendID)
 	msg.Options = make(map[string]bool, 7)
 	switch n.SessionType {
-	case constant.GroupChatType:
+	case constant.GroupChatType, constant.SuperGroupChatType:
 		msg.RecvID = ""
 		msg.GroupID = n.RecvID
 	}
@@ -724,6 +801,8 @@ func Notification(n *NotificationMsg) {
 		unReadCount = config.Config.Notification.ConversationSetPrivate.Conversation.UnreadCount
 	case constant.DeleteMessageNotification:
 		reliabilityLevel = constant.ReliableNotificationNoMsg
+	case constant.SuperGroupUpdateNotification:
+		reliabilityLevel = constant.UnreliableNotification
 	}
 	switch reliabilityLevel {
 	case constant.UnreliableNotification:
@@ -744,7 +823,13 @@ func Notification(n *NotificationMsg) {
 	offlineInfo.Ex = ex
 	msg.OfflinePushInfo = &offlineInfo
 	req.MsgData = &msg
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		return
+	}
+
 	client := pbChat.NewChatClient(etcdConn)
 	reply, err := client.SendMsg(context.Background(), &req)
 	if err != nil {

internal/rpc/msg/super_group_notification.go

@@ -0,0 +1,37 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	//sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	//"github.com/golang/protobuf/jsonpb"
+	//"github.com/golang/protobuf/proto"
+)
+
+func SuperGroupNotification(operationID, sendID, groupID string) {
+
+	//var tips sdk.TipsComm
+	//var err error
+	//marshaler := jsonpb.Marshaler{
+	//	OrigName:     true,
+	//	EnumsAsInts:  false,
+	//	EmitDefaults: false,
+	//}
+	//tips.JsonDetail, _ = marshaler.MarshalToString(m)
+	n := &NotificationMsg{
+		SendID:      sendID,
+		RecvID:      groupID,
+		MsgFrom:     constant.SysMsgType,
+		ContentType: constant.SuperGroupUpdateNotification,
+		SessionType: constant.SuperGroupChatType,
+		OperationID: operationID,
+	}
+	//n.Content, err = proto.Marshal(&tips)
+	//if err != nil {
+	//	log.NewError(operationID, utils.GetSelfFuncName(), "proto.Marshal failed")
+	//	return
+	//}
+	log.NewInfo(operationID, utils.GetSelfFuncName(), string(n.Content))
+	Notification(n)
+}

internal/rpc/msg/tag_send_msg.go

@@ -33,7 +33,13 @@ func TagSendMessage(operationID string, user *db.User, recvID, content string, s
 	msgData.SenderPlatformID = senderPlatformID
 	req.MsgData = &msgData
 	req.OperationID = operationID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, operationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		return
+	}
+
 	client := pbChat.NewChatClient(etcdConn)
 	respPb, err := client.SendMsg(context.Background(), &req)
 	if err != nil {

internal/rpc/office/office.go

@@ -205,7 +205,15 @@ func (s *officeServer) SendMsg2Tag(_ context.Context, req *pbOffice.SendMsg2TagR
 	}
 	var groupUserIDList []string
 	for _, groupID := range req.GroupList {
-		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
+		if etcdConn == nil {
+			errMsg := req.OperationID + "getcdv3.GetConn == nil"
+			log.NewError(req.OperationID, errMsg)
+			resp.CommonResp.ErrCode = constant.ErrInternal.ErrCode
+			resp.CommonResp.ErrMsg = errMsg
+			return resp, nil
+		}
+
 		cacheClient := pbCache.NewCacheClient(etcdConn)
 		req := pbCache.GetGroupMemberIDListFromCacheReq{
 			OperationID: req.OperationID,

internal/rpc/organization/organization.go

@@ -102,7 +102,7 @@ func (s *organizationServer) CreateDepartment(ctx context.Context, req *rpc.Crea
 		log.Error(req.OperationID, errMsg)
 		return &rpc.CreateDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
 	}
-	err, createdDepartment := imdb.GetDepartment(department.DepartmentID)
+	createdDepartment, err := imdb.GetDepartment(department.DepartmentID)
 	if err != nil {
 		errMsg := req.OperationID + " " + "GetDepartment failed " + err.Error() + department.DepartmentID
 		log.Error(req.OperationID, errMsg)
@@ -114,19 +114,29 @@ func (s *organizationServer) CreateDepartment(ctx context.Context, req *rpc.Crea
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
 	chat.OrganizationNotificationToAll(req.OpUserID, req.OperationID)
 
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		resp.ErrCode = constant.ErrInternal.ErrCode
+		resp.ErrMsg = errMsg
+		return resp, nil
+	}
 	client := groupRpc.NewGroupClient(etcdConn)
 	createGroupReq := &groupRpc.CreateGroupReq{
-		InitMemberList: nil,
+		InitMemberList: []*groupRpc.GroupAddMemberInfo{},
 		GroupInfo: &open_im_sdk.GroupInfo{
+			Introduction:  req.DepartmentInfo.Name,
 			GroupName:     req.DepartmentInfo.Name,
 			FaceURL:       req.DepartmentInfo.FaceURL,
 			CreateTime:    uint32(time.Now().Unix()),
 			CreatorUserID: req.OpUserID,
-			GroupType:     constant.DepartmentGroup,
+			GroupType:     constant.NormalGroup,
+			OwnerUserID:   req.OpUserID,
 		},
 		OperationID: req.OperationID,
 		OpUserID:    req.OpUserID,
+		OwnerUserID: req.OpUserID,
 	}
 	createGroupResp, err := client.CreateGroup(context.Background(), createGroupReq)
 	if err != nil {
@@ -141,6 +151,9 @@ func (s *organizationServer) CreateDepartment(ctx context.Context, req *rpc.Crea
 		resp.ErrMsg = constant.ErrDB.ErrMsg + " createGroup failed " + createGroupResp.ErrMsg
 		return resp, nil
 	}
+	if err := imdb.SetDepartmentRelatedGroupID(createGroupResp.GroupInfo.GroupID, department.DepartmentID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetDepartmentRelatedGroupID failed", err.Error())
+	}
 	return resp, nil
 }
 
@@ -221,21 +234,26 @@ func (s *organizationServer) CreateOrganizationUser(ctx context.Context, req *rp
 	authReq := &pbAuth.UserRegisterReq{UserInfo: &open_im_sdk.UserInfo{}}
 	utils.CopyStructFields(authReq.UserInfo, req.OrganizationUser)
 	authReq.OperationID = req.OperationID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName)
-	client := pbAuth.NewAuthClient(etcdConn)
-
-	reply, err := client.UserRegister(context.Background(), authReq)
-	if err != nil {
-		errMsg := "UserRegister failed " + err.Error()
-		log.NewError(req.OperationID, errMsg)
-		return &rpc.CreateOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	if req.IsRegister {
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
+		if etcdConn == nil {
+			errMsg := req.OperationID + "getcdv3.GetConn == nil"
+			log.NewError(req.OperationID, errMsg)
+			return &rpc.CreateOrganizationUserResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: errMsg}, nil
+		}
+		client := pbAuth.NewAuthClient(etcdConn)
+		reply, err := client.UserRegister(context.Background(), authReq)
+		if err != nil {
+			errMsg := "UserRegister failed " + err.Error()
+			log.NewError(req.OperationID, errMsg)
+			return &rpc.CreateOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+		}
+		if reply.CommonResp.ErrCode != 0 {
+			errMsg := "UserRegister failed " + reply.CommonResp.ErrMsg
+			log.NewError(req.OperationID, errMsg)
+			return &rpc.CreateOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+		}
 	}
-	if reply.CommonResp.ErrCode != 0 {
-		errMsg := "UserRegister failed " + reply.CommonResp.ErrMsg
-		log.NewError(req.OperationID, errMsg)
-		return &rpc.CreateOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
-	}
-
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
 	if !token_verify.IsManagerUserID(req.OpUserID) {
 		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
@@ -246,7 +264,7 @@ func (s *organizationServer) CreateOrganizationUser(ctx context.Context, req *rp
 	utils.CopyStructFields(&organizationUser, req.OrganizationUser)
 	organizationUser.Birth = utils.UnixSecondToTime(int64(req.OrganizationUser.Birth))
 	log.Debug(req.OperationID, "src ", *req.OrganizationUser, "dst ", organizationUser)
-	err = imdb.CreateOrganizationUser(&organizationUser)
+	err := imdb.CreateOrganizationUser(&organizationUser)
 	if err != nil {
 		errMsg := req.OperationID + " " + "CreateOrganizationUser failed " + err.Error()
 		log.Error(req.OperationID, errMsg, organizationUser)
@@ -263,7 +281,12 @@ func (s *organizationServer) UpdateOrganizationUser(ctx context.Context, req *rp
 	authReq := &pbAuth.UserRegisterReq{UserInfo: &open_im_sdk.UserInfo{}}
 	utils.CopyStructFields(authReq.UserInfo, req.OrganizationUser)
 	authReq.OperationID = req.OperationID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		return &rpc.UpdateOrganizationUserResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: errMsg}, nil
+	}
 	client := pbAuth.NewAuthClient(etcdConn)
 
 	reply, err := client.UserRegister(context.Background(), authReq)
@@ -340,13 +363,14 @@ func (s *organizationServer) CreateDepartmentMember(ctx context.Context, req *rp
 func (s *organizationServer) GetDepartmentParentIDList(_ context.Context, req *rpc.GetDepartmentParentIDListReq) (resp *rpc.GetDepartmentParentIDListResp, err error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req.String())
 	resp = &rpc.GetDepartmentParentIDListResp{}
-	resp.ParentIDList, err = imdb.GetDepartmentParentIDList(req.DepartmentID)
+	parentIDList, err := imdb.GetDepartmentParentIDList(req.DepartmentID)
 	if err != nil {
 		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetDepartmentParentIDList failed", err.Error())
 		resp.ErrMsg = constant.ErrDB.ErrMsg + ": " + err.Error()
 		resp.ErrCode = constant.ErrDB.ErrCode
 		return resp, nil
 	}
+	resp.ParentIDList = parentIDList
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp:", resp.String())
 	return resp, nil
 }

internal/rpc/user/user.go

@@ -383,12 +383,19 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	if req.UserInfo.Birth != 0 {
 		user.Birth = utils.UnixSecondToTime(int64(req.UserInfo.Birth))
 	}
+
 	err := imdb.UpdateUserInfo(user)
 	if err != nil {
 		log.NewError(req.OperationID, "UpdateUserInfo failed ", err.Error(), user)
 		return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: errMsg}}, nil
+	}
+
 	client := pbFriend.NewFriendClient(etcdConn)
 	newReq := &pbFriend.GetFriendListReq{
 		CommID: &pbFriend.CommID{OperationID: req.OperationID, FromUserID: req.UserInfo.UserID, OpUserID: req.OpUserID},
@@ -426,7 +433,28 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	//}
 	return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
 }
+func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbUser.SetGlobalRecvMessageOptReq) (*pbUser.SetGlobalRecvMessageOptResp, error) {
+	log.NewInfo(req.OperationID, "SetGlobalRecvMessageOpt args ", req.String())
 
+	var user db.User
+	user.UserID = req.UserID
+	m := make(map[string]interface{}, 1)
+
+	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), req.GlobalRecvMsgOpt, "set GlobalRecvMsgOpt")
+	m["global_recv_msg_opt"] = req.GlobalRecvMsgOpt
+	err := db.DB.SetUserGlobalMsgRecvOpt(user.UserID, req.GlobalRecvMsgOpt)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetGlobalRecvMessageOpt failed ", err.Error(), user)
+		return &pbUser.SetGlobalRecvMessageOptResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	err = imdb.UpdateUserInfoByMap(user, m)
+	if err != nil {
+		log.NewError(req.OperationID, "SetGlobalRecvMessageOpt failed ", err.Error(), user)
+		return &pbUser.SetGlobalRecvMessageOptResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	chat.UserInfoUpdatedNotification(req.OperationID, req.UserID, req.UserID)
+	return &pbUser.SetGlobalRecvMessageOptResp{CommonResp: &pbUser.CommonResp{}}, nil
+}
 func (s *userServer) SyncJoinedGroupMemberFaceURL(userID string, faceURL string, operationID string, opUserID string) {
 	joinedGroupIDList, err := imdb.GetJoinedGroupIDListByUserID(userID)
 	if err != nil {