style: add format

Signed-off-by: Xinwei Xiong(cubxxw-openim) <3293172751nss@gmail.com>
2026-05-08 02:55:58 +08:00 · 2023-07-03 16:29:22 +08:00
parent 187ee9a375
commit 166ddb1e34
170 changed files with 4816 additions and 1279 deletions
@@ -1,11 +1,12 @@
 package api

 import (
+	"github.com/gin-gonic/gin"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/auth"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
-	"github.com/gin-gonic/gin"
 )

 type AuthApi rpcclient.Auth
@@ -1,11 +1,12 @@
 package api

 import (
+	"github.com/gin-gonic/gin"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
-	"github.com/gin-gonic/gin"
 )

 type ConversationApi rpcclient.Conversation
@@ -1,8 +1,9 @@
 package api

 import (
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/go-playground/validator/v10"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 )

 func RequiredIf(fl validator.FieldLevel) bool {
@@ -1,6 +1,11 @@
 package api

 import (
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
+	"github.com/mitchellh/mapstructure"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/apiresp"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/apistruct"
@@ -12,10 +17,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
-	"github.com/mitchellh/mapstructure"
-	"google.golang.org/protobuf/proto"
 )

 type MessageApi struct {
@@ -3,17 +3,18 @@ package api
 import (
 	"context"

-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mw"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
 	"github.com/go-playground/validator/v10"
 	"github.com/redis/go-redis/v9"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mw"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 )

 func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.UniversalClient) *gin.Engine {
@@ -1,11 +1,12 @@
 package api

 import (
+	"github.com/gin-gonic/gin"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/user"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
-	"github.com/gin-gonic/gin"
 )

 type StatisticsApi rpcclient.User
@@ -5,6 +5,8 @@ import (
 	"net/http"
 	"strconv"

+	"github.com/gin-gonic/gin"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
@@ -12,7 +14,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/third"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
-	"github.com/gin-gonic/gin"
 )

 type ThirdApi rpcclient.Third
@@ -65,7 +66,10 @@ func (o *ThirdApi) GetURL(c *gin.Context) {
 	}
 	attachment, _ := strconv.ParseBool(c.Query("attachment"))
 	c.Set(constant.OperationID, operationID)
-	resp, err := o.Client.GetUrl(mcontext.SetOperationID(c, operationID), &third.GetUrlReq{Name: name, Expires: expires, Attachment: attachment})
+	resp, err := o.Client.GetUrl(
+		mcontext.SetOperationID(c, operationID),
+		&third.GetUrlReq{Name: name, Expires: expires, Attachment: attachment},
+	)
 	if err != nil {
 		if errs.ErrArgs.Is(err) {
 			c.String(http.StatusBadRequest, err.Error())
@@ -1,6 +1,8 @@
 package api

 import (
+	"github.com/gin-gonic/gin"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/apiresp"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/apistruct"
@@ -9,7 +11,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/user"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
-	"github.com/gin-gonic/gin"
 )

 type UserApi rpcclient.User
@@ -78,7 +78,8 @@ func CallbackUserKickOff(ctx context.Context, userID string, platformID int) err
 	return http.CallBackPostReturn(ctx, url(), req, resp, config.Config.Callback.CallbackUserOffline)
 }

-//func callbackUserOnline(operationID, userID string, platformID int, token string, isAppBackground bool, connID string) cbApi.CommonCallbackResp {
+// func callbackUserOnline(operationID, userID string, platformID int, token string, isAppBackground bool, connID
+// string) cbApi.CommonCallbackResp {
 //	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
 //	if !config.Config.Callback.CallbackUserOnline.Enable {
 //		return callbackResp
@@ -99,7 +100,9 @@ func CallbackUserKickOff(ctx context.Context, userID string, platformID int) err
 //		ConnID:          connID,
 //	}
 //	callbackUserOnlineResp := &cbApi.CallbackUserOnlineResp{CommonCallbackResp: &callbackResp}
-//	if err := http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, constant.CallbackUserOnlineCommand, callbackUserOnlineReq, callbackUserOnlineResp, config.Config.Callback.CallbackUserOnline.CallbackTimeOut); err != nil {
+// 	if err := http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, constant.CallbackUserOnlineCommand,
+// callbackUserOnlineReq, callbackUserOnlineResp, config.Config.Callback.CallbackUserOnline.CallbackTimeOut); err != nil
+// {
 //		callbackResp.ErrCode = http2.StatusInternalServerError
 //		callbackResp.ErrMsg = err.Error()
 //	}
@@ -124,7 +127,9 @@ func CallbackUserKickOff(ctx context.Context, userID string, platformID int) err
 //		ConnID: connID,
 //	}
 //	callbackUserOfflineResp := &cbApi.CallbackUserOfflineResp{CommonCallbackResp: &callbackResp}
-//	if err := http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, constant.CallbackUserOfflineCommand, callbackOfflineReq, callbackUserOfflineResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil {
+// 	if err := http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, constant.CallbackUserOfflineCommand,
+// callbackOfflineReq, callbackUserOfflineResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil
+// {
 //		callbackResp.ErrCode = http2.StatusInternalServerError
 //		callbackResp.ErrMsg = err.Error()
 //	}
@@ -148,7 +153,9 @@ func CallbackUserKickOff(ctx context.Context, userID string, platformID int) err
 //		Seq: int(time.Now().UnixNano() / 1e6),
 //	}
 //	callbackUserKickOffResp := &cbApi.CallbackUserKickOffResp{CommonCallbackResp: &callbackResp}
-//	if err := http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, constant.CallbackUserKickOffCommand, callbackUserKickOffReq, callbackUserKickOffResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil {
+// 	if err := http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, constant.CallbackUserKickOffCommand,
+// callbackUserKickOffReq, callbackUserKickOffResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err !=
+// nil {
 //		callbackResp.ErrCode = http2.StatusInternalServerError
 //		callbackResp.ErrMsg = err.Error()
 //	}
@@ -7,13 +7,14 @@ import (
 	"runtime/debug"
 	"sync"

+	"google.golang.org/protobuf/proto"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/apiresp"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"google.golang.org/protobuf/proto"
 )

 var ErrConnClosed = errors.New("conn has closed")
@@ -65,7 +66,13 @@ func newClient(ctx *UserConnContext, conn LongConn, isCompress bool) *Client {
 		ctx:        ctx,
 	}
 }
-func (c *Client) ResetClient(ctx *UserConnContext, conn LongConn, isBackground, isCompress bool, longConnServer LongConnServer) {
+
+func (c *Client) ResetClient(
+	ctx *UserConnContext,
+	conn LongConn,
+	isBackground, isCompress bool,
+	longConnServer LongConnServer,
+) {
 	c.w = new(sync.Mutex)
 	c.conn = conn
 	c.PlatformID = utils.StringToInt(ctx.GetPlatformID())
@@ -145,7 +152,9 @@ func (c *Client) handleMessage(message []byte) error {
 	if binaryReq.SendID != c.UserID {
 		return utils.Wrap(errors.New("exception conn userID not same to req userID"), binaryReq.String())
 	}
-	ctx := mcontext.WithMustInfoCtx([]string{binaryReq.OperationID, binaryReq.SendID, constant.PlatformIDToName(c.PlatformID), c.ctx.GetConnID()})
+	ctx := mcontext.WithMustInfoCtx(
+		[]string{binaryReq.OperationID, binaryReq.SendID, constant.PlatformIDToName(c.PlatformID), c.ctx.GetConnID()},
+	)
 	log.ZDebug(ctx, "gateway req message", "req", binaryReq.String())
 	var messageErr error
 	var resp []byte
@@ -163,7 +172,12 @@ func (c *Client) handleMessage(message []byte) error {
 	case WsSetBackgroundStatus:
 		resp, messageErr = c.setAppBackgroundStatus(ctx, binaryReq)
 	default:
-		return fmt.Errorf("ReqIdentifier failed,sendID:%s,msgIncr:%s,reqIdentifier:%d", binaryReq.SendID, binaryReq.MsgIncr, binaryReq.ReqIdentifier)
+		return fmt.Errorf(
+			"ReqIdentifier failed,sendID:%s,msgIncr:%s,reqIdentifier:%d",
+			binaryReq.SendID,
+			binaryReq.MsgIncr,
+			binaryReq.ReqIdentifier,
+		)
 	}
 	c.replyMessage(ctx, &binaryReq, messageErr, resp)
 	return nil
@@ -5,6 +5,8 @@ import (

 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"

+	"google.golang.org/grpc"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
@@ -15,7 +17,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msggateway"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/startrpc"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"google.golang.org/grpc"
 )

 func (s *Server) InitServer(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
@@ -31,7 +32,12 @@ func (s *Server) InitServer(client discoveryregistry.SvcDiscoveryRegistry, serve
 }

 func (s *Server) Start() error {
-	return startrpc.Start(s.rpcPort, config.Config.RpcRegisterName.OpenImMessageGatewayName, s.prometheusPort, s.InitServer)
+	return startrpc.Start(
+		s.rpcPort,
+		config.Config.RpcRegisterName.OpenImMessageGatewayName,
+		s.prometheusPort,
+		s.InitServer,
+	)
 }

 type Server struct {
@@ -46,14 +52,24 @@ func (s *Server) SetLongConnServer(LongConnServer LongConnServer) {
 }

 func NewServer(rpcPort int, longConnServer LongConnServer) *Server {
-	return &Server{rpcPort: rpcPort, LongConnServer: longConnServer, pushTerminal: []int{constant.IOSPlatformID, constant.AndroidPlatformID}}
+	return &Server{
+		rpcPort:        rpcPort,
+		LongConnServer: longConnServer,
+		pushTerminal:   []int{constant.IOSPlatformID, constant.AndroidPlatformID},
+	}
 }

-func (s *Server) OnlinePushMsg(context context.Context, req *msggateway.OnlinePushMsgReq) (*msggateway.OnlinePushMsgResp, error) {
+func (s *Server) OnlinePushMsg(
+	context context.Context,
+	req *msggateway.OnlinePushMsgReq,
+) (*msggateway.OnlinePushMsgResp, error) {
 	panic("implement me")
 }

-func (s *Server) GetUsersOnlineStatus(ctx context.Context, req *msggateway.GetUsersOnlineStatusReq) (*msggateway.GetUsersOnlineStatusResp, error) {
+func (s *Server) GetUsersOnlineStatus(
+	ctx context.Context,
+	req *msggateway.GetUsersOnlineStatusReq,
+) (*msggateway.GetUsersOnlineStatusResp, error) {
 	if !tokenverify.IsAppManagerUid(ctx) {
 		return nil, errs.ErrNoPermission.Wrap("only app manager")
 	}
@@ -83,11 +99,17 @@ func (s *Server) GetUsersOnlineStatus(ctx context.Context, req *msggateway.GetUs
 	return &resp, nil
 }

-func (s *Server) OnlineBatchPushOneMsg(ctx context.Context, req *msggateway.OnlineBatchPushOneMsgReq) (*msggateway.OnlineBatchPushOneMsgResp, error) {
+func (s *Server) OnlineBatchPushOneMsg(
+	ctx context.Context,
+	req *msggateway.OnlineBatchPushOneMsgReq,
+) (*msggateway.OnlineBatchPushOneMsgResp, error) {
 	panic("implement me")
 }

-func (s *Server) SuperGroupOnlineBatchPushOneMsg(ctx context.Context, req *msggateway.OnlineBatchPushOneMsgReq) (*msggateway.OnlineBatchPushOneMsgResp, error) {
+func (s *Server) SuperGroupOnlineBatchPushOneMsg(
+	ctx context.Context,
+	req *msggateway.OnlineBatchPushOneMsgReq,
+) (*msggateway.OnlineBatchPushOneMsgResp, error) {
 	var singleUserResult []*msggateway.SingleMsgToUserResults
 	for _, v := range req.PushToUserIDs {
 		var resp []*msggateway.SingleMsgToUserPlatform
@@ -108,7 +130,8 @@ func (s *Server) SuperGroupOnlineBatchPushOneMsg(ctx context.Context, req *msgga
 					RecvID:         v,
 					RecvPlatFormID: int32(client.PlatformID),
 				}
-				if !client.IsBackground || (client.IsBackground == true && client.PlatformID != constant.IOSPlatformID) {
+				if !client.IsBackground ||
+					(client.IsBackground == true && client.PlatformID != constant.IOSPlatformID) {
 					err := client.PushMessage(ctx, req.MsgData)
 					if err != nil {
 						temp.ResultCode = -2
@@ -135,7 +158,10 @@ func (s *Server) SuperGroupOnlineBatchPushOneMsg(ctx context.Context, req *msgga
 	}, nil
 }

-func (s *Server) KickUserOffline(ctx context.Context, req *msggateway.KickUserOfflineReq) (*msggateway.KickUserOfflineResp, error) {
+func (s *Server) KickUserOffline(
+	ctx context.Context,
+	req *msggateway.KickUserOfflineReq,
+) (*msggateway.KickUserOfflineResp, error) {
 	for _, v := range req.KickUserIDList {
 		if clients, _, ok := s.LongConnServer.GetUserPlatformCons(v, int(req.PlatformID)); ok {
 			for _, client := range clients {
@@ -149,7 +175,10 @@ func (s *Server) KickUserOffline(ctx context.Context, req *msggateway.KickUserOf
 	return &msggateway.KickUserOfflineResp{}, nil
 }

-func (s *Server) MultiTerminalLoginCheck(ctx context.Context, req *msggateway.MultiTerminalLoginCheckReq) (*msggateway.MultiTerminalLoginCheckResp, error) {
+func (s *Server) MultiTerminalLoginCheck(
+	ctx context.Context,
+	req *msggateway.MultiTerminalLoginCheckReq,
+) (*msggateway.MultiTerminalLoginCheckResp, error) {
 	//TODO implement me
 	panic("implement me")
 }
@@ -8,7 +8,14 @@ import (
 )

 func RunWsAndServer(rpcPort, wsPort, prometheusPort int) error {
-	fmt.Println("start rpc/msg_gateway server, port: ", rpcPort, wsPort, prometheusPort, ", OpenIM version: ", config.Version)
+	fmt.Println(
+		"start rpc/msg_gateway server, port: ",
+		rpcPort,
+		wsPort,
+		prometheusPort,
+		", OpenIM version: ",
+		config.Version,
+	)
 	longServer, err := NewWsServer(
 		WithPort(wsPort),
 		WithMaxConnNum(int64(config.Config.LongConnSvr.WebsocketMaxConnNum)),
@@ -6,20 +6,21 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/push"

+	"github.com/go-playground/validator/v10"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"github.com/go-playground/validator/v10"
-	"google.golang.org/protobuf/proto"
 )

 type Req struct {
 	ReqIdentifier int32  `json:"reqIdentifier" validate:"required"`
-	Token         string `json:"token" `
-	SendID        string `json:"sendID" validate:"required"`
-	OperationID   string `json:"operationID" validate:"required"`
-	MsgIncr       string `json:"msgIncr" validate:"required"`
+	Token         string `json:"token"`
+	SendID        string `json:"sendID"        validate:"required"`
+	OperationID   string `json:"operationID"   validate:"required"`
+	MsgIncr       string `json:"msgIncr"       validate:"required"`
 	Data          []byte `json:"data"`
 }

@@ -160,7 +161,8 @@ func (g GrpcHandler) SetUserDeviceBackground(_ context.Context, data Req) ([]byt
 	return nil, req.IsBackground, nil
 }

-//func (g GrpcHandler) call[T any](ctx context.Context, data Req, m proto.Message, rpc func(ctx context.Context, req proto.Message)) ([]byte, error) {
+// func (g GrpcHandler) call[T any](ctx context.Context, data Req, m proto.Message, rpc func(ctx context.Context, req
+// proto.Message)) ([]byte, error) {
 //	if err := proto.Unmarshal(data.Data, m); err != nil {
 //		return nil, err
 //	}
@@ -13,14 +13,16 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"

-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/redis/go-redis/v9"

+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+
+	"github.com/go-playground/validator/v10"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"github.com/go-playground/validator/v10"
 )

 type LongConnServer interface {
@@ -169,7 +171,14 @@ func (ws *WsServer) registerClient(client *Client) {
 			atomic.AddInt64(&ws.onlineUserConnNum, 1)
 		}
 	}
-	log.ZInfo(client.ctx, "user online", "online user Num", ws.onlineUserNum, "online user conn Num", ws.onlineUserConnNum)
+	log.ZInfo(
+		client.ctx,
+		"user online",
+		"online user Num",
+		ws.onlineUserNum,
+		"online user conn Num",
+		ws.onlineUserConnNum,
+	)
 }
 func getRemoteAdders(client []*Client) string {
 	var ret string
@@ -200,18 +209,47 @@ func (ws *WsServer) multiTerminalLoginChecker(info *kickHandler) {
 					log.ZWarn(c.ctx, "KickOnlineMessage", err)
 				}
 			}
-			m, err := ws.cache.GetTokensWithoutError(info.newClient.ctx, info.newClient.UserID, info.newClient.PlatformID)
+			m, err := ws.cache.GetTokensWithoutError(
+				info.newClient.ctx,
+				info.newClient.UserID,
+				info.newClient.PlatformID,
+			)
 			if err != nil && err != redis.Nil {
-				log.ZWarn(info.newClient.ctx, "get token from redis err", err, "userID", info.newClient.UserID, "platformID", info.newClient.PlatformID)
+				log.ZWarn(
+					info.newClient.ctx,
+					"get token from redis err",
+					err,
+					"userID",
+					info.newClient.UserID,
+					"platformID",
+					info.newClient.PlatformID,
+				)
 				return
 			}
 			if m == nil {
-				log.ZWarn(info.newClient.ctx, "m is nil", errors.New("m is nil"), "userID", info.newClient.UserID, "platformID", info.newClient.PlatformID)
+				log.ZWarn(
+					info.newClient.ctx,
+					"m is nil",
+					errors.New("m is nil"),
+					"userID",
+					info.newClient.UserID,
+					"platformID",
+					info.newClient.PlatformID,
+				)
 				return
 			}
-			log.ZDebug(info.newClient.ctx, "get token from redis", "userID", info.newClient.UserID, "platformID", info.newClient.PlatformID, "tokenMap", m)
+			log.ZDebug(
+				info.newClient.ctx,
+				"get token from redis",
+				"userID",
+				info.newClient.UserID,
+				"platformID",
+				info.newClient.PlatformID,
+				"tokenMap",
+				m,
+			)

-			for k, _ := range m {
+			for k := range m {
 				if k != info.newClient.ctx.GetToken() {
 					m[k] = constant.KickedToken
 				}
@@ -219,7 +257,15 @@ func (ws *WsServer) multiTerminalLoginChecker(info *kickHandler) {
 			log.ZDebug(info.newClient.ctx, "set token map is ", "token map", m, "userID", info.newClient.UserID)
 			err = ws.cache.SetTokenMapByUidPid(info.newClient.ctx, info.newClient.UserID, info.newClient.PlatformID, m)
 			if err != nil {
-				log.ZWarn(info.newClient.ctx, "SetTokenMapByUidPid err", err, "userID", info.newClient.UserID, "platformID", info.newClient.PlatformID)
+				log.ZWarn(
+					info.newClient.ctx,
+					"SetTokenMapByUidPid err",
+					err,
+					"userID",
+					info.newClient.UserID,
+					"platformID",
+					info.newClient.PlatformID,
+				)
 				return
 			}
 		}
@@ -233,7 +279,16 @@ func (ws *WsServer) unregisterClient(client *Client) {
 		atomic.AddInt64(&ws.onlineUserNum, -1)
 	}
 	atomic.AddInt64(&ws.onlineUserConnNum, -1)
-	log.ZInfo(client.ctx, "user offline", "close reason", client.closedErr, "online user Num", ws.onlineUserNum, "online user conn Num", ws.onlineUserConnNum)
+	log.ZInfo(
+		client.ctx,
+		"user offline",
+		"close reason",
+		client.closedErr,
+		"online user Num",
+		ws.onlineUserNum,
+		"online user conn Num",
+		ws.onlineUserConnNum,
+	)
 }

 func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
@@ -5,6 +5,9 @@ import (
 	"sync"
 	"time"

+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
@@ -17,8 +20,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
 	openKeeper "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry/zookeeper"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
 )

 type MsgTransfer struct {
@@ -47,9 +48,18 @@ func StartTransfer(prometheusPort int) error {
 	if err := mongo.CreateMsgIndex(); err != nil {
 		return err
 	}
-	client, err := openKeeper.NewClient(config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema,
-		openKeeper.WithFreq(time.Hour), openKeeper.WithRoundRobin(), openKeeper.WithUserNameAndPassword(config.Config.Zookeeper.Username,
-			config.Config.Zookeeper.Password), openKeeper.WithTimeout(10), openKeeper.WithLogger(log.NewZkLogger()))
+	client, err := openKeeper.NewClient(
+		config.Config.Zookeeper.ZkAddr,
+		config.Config.Zookeeper.Schema,
+		openKeeper.WithFreq(
+			time.Hour,
+		),
+		openKeeper.WithRoundRobin(),
+		openKeeper.WithUserNameAndPassword(config.Config.Zookeeper.Username,
+			config.Config.Zookeeper.Password),
+		openKeeper.WithTimeout(10),
+		openKeeper.WithLogger(log.NewZkLogger()),
+	)
 	if err != nil {
 		return err
 	}
@@ -66,7 +76,13 @@ func StartTransfer(prometheusPort int) error {
 	msgDatabase := controller.NewCommonMsgDatabase(msgDocModel, msgModel)
 	conversationRpcClient := rpcclient.NewConversationRpcClient(client)
 	groupRpcClient := rpcclient.NewGroupRpcClient(client)
-	msgTransfer := NewMsgTransfer(chatLogDatabase, extendMsgDatabase, msgDatabase, &conversationRpcClient, &groupRpcClient)
+	msgTransfer := NewMsgTransfer(
+		chatLogDatabase,
+		extendMsgDatabase,
+		msgDatabase,
+		&conversationRpcClient,
+		&groupRpcClient,
+	)
 	msgTransfer.initPrometheus()
 	return msgTransfer.Start(prometheusPort)
 }
@@ -74,8 +90,14 @@ func StartTransfer(prometheusPort int) error {
 func NewMsgTransfer(chatLogDatabase controller.ChatLogDatabase,
 	extendMsgDatabase controller.ExtendMsgDatabase, msgDatabase controller.CommonMsgDatabase,
 	conversationRpcClient *rpcclient.ConversationRpcClient, groupRpcClient *rpcclient.GroupRpcClient) *MsgTransfer {
-	return &MsgTransfer{persistentCH: NewPersistentConsumerHandler(chatLogDatabase), historyCH: NewOnlineHistoryRedisConsumerHandler(msgDatabase, conversationRpcClient, groupRpcClient),
-		historyMongoCH: NewOnlineHistoryMongoConsumerHandler(msgDatabase), modifyCH: NewModifyMsgConsumerHandler(extendMsgDatabase)}
+	return &MsgTransfer{
+		persistentCH: NewPersistentConsumerHandler(chatLogDatabase),
+		historyCH:    NewOnlineHistoryRedisConsumerHandler(msgDatabase, conversationRpcClient, groupRpcClient),
+		historyMongoCH: NewOnlineHistoryMongoConsumerHandler(
+			msgDatabase,
+		),
+		modifyCH: NewModifyMsgConsumerHandler(extendMsgDatabase),
+	}
 }

 func (m *MsgTransfer) initPrometheus() {
@@ -4,6 +4,8 @@ import (
 	"context"
 	"encoding/json"

+	"github.com/Shopify/sarama"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
@@ -14,7 +16,6 @@ import (
 	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"github.com/Shopify/sarama"

 	"google.golang.org/protobuf/proto"
 )
@@ -41,7 +42,18 @@ func (mmc *ModifyMsgConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSessi
 	claim sarama.ConsumerGroupClaim) error {
 	for msg := range claim.Messages() {
 		ctx := mmc.modifyMsgConsumerGroup.GetContextFromMsg(msg)
-		log.ZDebug(ctx, "kafka get info to mysql", "ModifyMsgConsumerHandler", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value), "key", string(msg.Key))
+		log.ZDebug(
+			ctx,
+			"kafka get info to mysql",
+			"ModifyMsgConsumerHandler",
+			msg.Topic,
+			"msgPartition",
+			msg.Partition,
+			"msg",
+			string(msg.Value),
+			"key",
+			string(msg.Key),
+		)
 		if len(msg.Value) != 0 {
 			mmc.ModifyMsg(ctx, msg, string(msg.Key), sess)
 		} else {
@@ -52,7 +64,12 @@ func (mmc *ModifyMsgConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSessi
 	return nil
 }

-func (mmc *ModifyMsgConsumerHandler) ModifyMsg(ctx context.Context, cMsg *sarama.ConsumerMessage, msgKey string, _ sarama.ConsumerGroupSession) {
+func (mmc *ModifyMsgConsumerHandler) ModifyMsg(
+	ctx context.Context,
+	cMsg *sarama.ConsumerMessage,
+	msgKey string,
+	_ sarama.ConsumerGroupSession,
+) {
 	msgFromMQ := pbMsg.MsgDataToModifyByMQ{}
 	operationID := mcontext.GetOperationID(ctx)
 	err := proto.Unmarshal(cMsg.Value, &msgFromMQ)
@@ -92,7 +109,8 @@ func (mmc *ModifyMsgConsumerHandler) ModifyMsg(ctx context.Context, cMsg *sarama
 				}

 				if err := mmc.extendMsgDatabase.InsertExtendMsg(ctx, notification.ConversationID, notification.SessionType, &extendMsg); err != nil {
-					// log.ZError(ctx, "MsgFirstModify InsertExtendMsg failed",  notification.ConversationID, notification.SessionType, extendMsg, err.Error())
+					// log.ZError(ctx, "MsgFirstModify InsertExtendMsg failed",  notification.ConversationID,
+					// notification.SessionType, extendMsg, err.Error())
 					continue
 				}
 			} else {
@@ -9,6 +9,10 @@ import (

 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"

+	"github.com/Shopify/sarama"
+	"github.com/go-redis/redis"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
@@ -18,9 +22,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"github.com/Shopify/sarama"
-	"github.com/go-redis/redis"
-	"google.golang.org/protobuf/proto"
 )

 const ConsumerMsgs = 3
@@ -63,7 +64,11 @@ type OnlineHistoryRedisConsumerHandler struct {
 	groupRpcClient        *rpcclient.GroupRpcClient
 }

-func NewOnlineHistoryRedisConsumerHandler(database controller.CommonMsgDatabase, conversationRpcClient *rpcclient.ConversationRpcClient, groupRpcClient *rpcclient.GroupRpcClient) *OnlineHistoryRedisConsumerHandler {
+func NewOnlineHistoryRedisConsumerHandler(
+	database controller.CommonMsgDatabase,
+	conversationRpcClient *rpcclient.ConversationRpcClient,
+	groupRpcClient *rpcclient.GroupRpcClient,
+) *OnlineHistoryRedisConsumerHandler {
 	var och OnlineHistoryRedisConsumerHandler
 	och.msgDatabase = database
 	och.msgDistributionCh = make(chan Cmd2Value) //no buffer channel
@@ -77,7 +82,8 @@ func NewOnlineHistoryRedisConsumerHandler(database controller.CommonMsgDatabase,
 	och.historyConsumerGroup = kafka.NewMConsumerGroup(&kafka.MConsumerGroupConfig{KafkaVersion: sarama.V2_0_0_0,
 		OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.LatestMsgToRedis.Topic},
 		config.Config.Kafka.Addr, config.Config.Kafka.ConsumerGroupID.MsgToRedis)
-	//statistics.NewStatistics(&och.singleMsgSuccessCount, config.Config.ModuleName.MsgTransferName, fmt.Sprintf("%d second singleMsgCount insert to mongo", constant.StatisticsTimeInterval), constant.StatisticsTimeInterval)
+	// statistics.NewStatistics(&och.singleMsgSuccessCount, config.Config.ModuleName.MsgTransferName, fmt.Sprintf("%d
+	// second singleMsgCount insert to mongo", constant.StatisticsTimeInterval), constant.StatisticsTimeInterval)
 	return &och
 }

@@ -90,16 +96,53 @@ func (och *OnlineHistoryRedisConsumerHandler) Run(channelID int) {
 				msgChannelValue := cmd.Value.(MsgChannelValue)
 				ctxMsgList := msgChannelValue.ctxMsgList
 				ctx := msgChannelValue.ctx
-				log.ZDebug(ctx, "msg arrived channel", "channel id", channelID, "msgList length", len(ctxMsgList), "uniqueKey", msgChannelValue.uniqueKey)
-				storageMsgList, notStorageMsgList, storageNotificationList, notStorageNotificationList, modifyMsgList := och.getPushStorageMsgList(ctxMsgList)
-				log.ZDebug(ctx, "msg lens", "storageMsgList", len(storageMsgList), "notStorageMsgList", len(notStorageMsgList),
-					"storageNotificationList", len(storageNotificationList), "notStorageNotificationList", len(notStorageNotificationList), "modifyMsgList", len(modifyMsgList))
+				log.ZDebug(
+					ctx,
+					"msg arrived channel",
+					"channel id",
+					channelID,
+					"msgList length",
+					len(ctxMsgList),
+					"uniqueKey",
+					msgChannelValue.uniqueKey,
+				)
+				storageMsgList, notStorageMsgList, storageNotificationList, notStorageNotificationList, modifyMsgList := och.getPushStorageMsgList(
+					ctxMsgList,
+				)
+				log.ZDebug(
+					ctx,
+					"msg lens",
+					"storageMsgList",
+					len(storageMsgList),
+					"notStorageMsgList",
+					len(notStorageMsgList),
+					"storageNotificationList",
+					len(storageNotificationList),
+					"notStorageNotificationList",
+					len(notStorageNotificationList),
+					"modifyMsgList",
+					len(modifyMsgList),
+				)
 				conversationIDMsg := utils.GetChatConversationIDByMsg(ctxMsgList[0].message)
 				conversationIDNotification := utils.GetNotificationConversationID(ctxMsgList[0].message)
 				och.handleMsg(ctx, msgChannelValue.uniqueKey, conversationIDMsg, storageMsgList, notStorageMsgList)
-				och.handleNotification(ctx, msgChannelValue.uniqueKey, conversationIDNotification, storageNotificationList, notStorageNotificationList)
+				och.handleNotification(
+					ctx,
+					msgChannelValue.uniqueKey,
+					conversationIDNotification,
+					storageNotificationList,
+					notStorageNotificationList,
+				)
 				if err := och.msgDatabase.MsgToModifyMQ(ctx, msgChannelValue.uniqueKey, conversationIDNotification, modifyMsgList); err != nil {
-					log.ZError(ctx, "msg to modify mq error", err, "uniqueKey", msgChannelValue.uniqueKey, "modifyMsgList", modifyMsgList)
+					log.ZError(
+						ctx,
+						"msg to modify mq error",
+						err,
+						"uniqueKey",
+						msgChannelValue.uniqueKey,
+						"modifyMsgList",
+						modifyMsgList,
+					)
 				}
 			}
 		}
@@ -107,7 +150,9 @@ func (och *OnlineHistoryRedisConsumerHandler) Run(channelID int) {
 }

 // 获取消息/通知 存储的消息列表， 不存储并且推送的消息列表，
-func (och *OnlineHistoryRedisConsumerHandler) getPushStorageMsgList(totalMsgs []*ContextMsg) (storageMsgList, notStorageMsgList, storageNotificatoinList, notStorageNotificationList, modifyMsgList []*sdkws.MsgData) {
+func (och *OnlineHistoryRedisConsumerHandler) getPushStorageMsgList(
+	totalMsgs []*ContextMsg,
+) (storageMsgList, notStorageMsgList, storageNotificatoinList, notStorageNotificationList, modifyMsgList []*sdkws.MsgData) {
 	isStorage := func(msg *sdkws.MsgData) bool {
 		options2 := utils.Options(msg.Options)
 		if options2.IsHistory() {
@@ -130,11 +175,17 @@ func (och *OnlineHistoryRedisConsumerHandler) getPushStorageMsgList(totalMsgs []
 					msg.Options = utils.NewMsgOptions()
 				}
 				if options.IsOfflinePush() {
-					v.message.Options = utils.WithOptions(utils.Options(v.message.Options), utils.WithOfflinePush(false))
+					v.message.Options = utils.WithOptions(
+						utils.Options(v.message.Options),
+						utils.WithOfflinePush(false),
+					)
 					msg.Options = utils.WithOptions(utils.Options(msg.Options), utils.WithOfflinePush(true))
 				}
 				if options.IsUnreadCount() {
-					v.message.Options = utils.WithOptions(utils.Options(v.message.Options), utils.WithUnreadCount(false))
+					v.message.Options = utils.WithOptions(
+						utils.Options(v.message.Options),
+						utils.WithUnreadCount(false),
+					)
 					msg.Options = utils.WithOptions(utils.Options(msg.Options), utils.WithUnreadCount(true))
 				}
 				storageMsgList = append(storageMsgList, msg)
@@ -151,19 +202,32 @@ func (och *OnlineHistoryRedisConsumerHandler) getPushStorageMsgList(totalMsgs []
 				notStorageMsgList = append(notStorageMsgList, v.message)
 			}
 		}
-		if v.message.ContentType == constant.ReactionMessageModifier || v.message.ContentType == constant.ReactionMessageDeleter {
+		if v.message.ContentType == constant.ReactionMessageModifier ||
+			v.message.ContentType == constant.ReactionMessageDeleter {
 			modifyMsgList = append(modifyMsgList, v.message)
 		}
 	}
 	return
 }

-func (och *OnlineHistoryRedisConsumerHandler) handleNotification(ctx context.Context, key, conversationID string, storageList, notStorageList []*sdkws.MsgData) {
+func (och *OnlineHistoryRedisConsumerHandler) handleNotification(
+	ctx context.Context,
+	key, conversationID string,
+	storageList, notStorageList []*sdkws.MsgData,
+) {
 	och.toPushTopic(ctx, key, conversationID, notStorageList)
 	if len(storageList) > 0 {
 		lastSeq, _, err := och.msgDatabase.BatchInsertChat2Cache(ctx, conversationID, storageList)
 		if err != nil {
-			log.ZError(ctx, "notification batch insert to redis error", err, "conversationID", conversationID, "storageList", storageList)
+			log.ZError(
+				ctx,
+				"notification batch insert to redis error",
+				err,
+				"conversationID",
+				conversationID,
+				"storageList",
+				storageList,
+			)
 			return
 		}
 		log.ZDebug(ctx, "success to next topic", "conversationID", conversationID)
@@ -172,13 +236,21 @@ func (och *OnlineHistoryRedisConsumerHandler) handleNotification(ctx context.Con
 	}
 }

-func (och *OnlineHistoryRedisConsumerHandler) toPushTopic(ctx context.Context, key, conversationID string, msgs []*sdkws.MsgData) {
+func (och *OnlineHistoryRedisConsumerHandler) toPushTopic(
+	ctx context.Context,
+	key, conversationID string,
+	msgs []*sdkws.MsgData,
+) {
 	for _, v := range msgs {
 		och.msgDatabase.MsgToPushMQ(ctx, key, conversationID, v)
 	}
 }

-func (och *OnlineHistoryRedisConsumerHandler) handleMsg(ctx context.Context, key, conversationID string, storageList, notStorageList []*sdkws.MsgData) {
+func (och *OnlineHistoryRedisConsumerHandler) handleMsg(
+	ctx context.Context,
+	key, conversationID string,
+	storageList, notStorageList []*sdkws.MsgData,
+) {
 	och.toPushTopic(ctx, key, conversationID, notStorageList)
 	if len(storageList) > 0 {
 		lastSeq, isNewConversation, err := och.msgDatabase.BatchInsertChat2Cache(ctx, conversationID, storageList)
@@ -240,11 +312,26 @@ func (och *OnlineHistoryRedisConsumerHandler) MessagesDistributionHandle() {
 					for i, header := range consumerMessages[i].Headers {
 						arr = append(arr, strconv.Itoa(i), string(header.Key), string(header.Value))
 					}
-					log.ZInfo(ctx, "consumer.kafka.GetContextWithMQHeader", "len", len(consumerMessages[i].Headers), "header", strings.Join(arr, ", "))
+					log.ZInfo(
+						ctx,
+						"consumer.kafka.GetContextWithMQHeader",
+						"len",
+						len(consumerMessages[i].Headers),
+						"header",
+						strings.Join(arr, ", "),
+					)
 					ctxMsg.ctx = kafka.GetContextWithMQHeader(consumerMessages[i].Headers)
 					ctxMsg.message = msgFromMQ
-					log.ZDebug(ctx, "single msg come to distribution center", "message", msgFromMQ, "key", string(consumerMessages[i].Key))
-					//aggregationMsgs[string(consumerMessages[i].Key)] = append(aggregationMsgs[string(consumerMessages[i].Key)], ctxMsg)
+					log.ZDebug(
+						ctx,
+						"single msg come to distribution center",
+						"message",
+						msgFromMQ,
+						"key",
+						string(consumerMessages[i].Key),
+					)
+					// aggregationMsgs[string(consumerMessages[i].Key)] =
+					// append(aggregationMsgs[string(consumerMessages[i].Key)], ctxMsg)
 					if oldM, ok := aggregationMsgs[string(consumerMessages[i].Key)]; ok {
 						oldM = append(oldM, ctxMsg)
 						aggregationMsgs[string(consumerMessages[i].Key)] = oldM
@@ -260,7 +347,16 @@ func (och *OnlineHistoryRedisConsumerHandler) MessagesDistributionHandle() {
 						hashCode := utils.GetHashCode(uniqueKey)
 						channelID := hashCode % ChannelNum
 						newCtx := withAggregationCtx(ctx, v)
-						log.ZDebug(newCtx, "generate channelID", "hashCode", hashCode, "channelID", channelID, "uniqueKey", uniqueKey)
+						log.ZDebug(
+							newCtx,
+							"generate channelID",
+							"hashCode",
+							hashCode,
+							"channelID",
+							channelID,
+							"uniqueKey",
+							uniqueKey,
+						)
 						och.chArrays[channelID] <- Cmd2Value{Cmd: SourceMessages, Value: MsgChannelValue{uniqueKey: uniqueKey, ctxMsgList: v, ctx: newCtx}}
 					}
 				}
@@ -288,7 +384,10 @@ func (och *OnlineHistoryRedisConsumerHandler) Cleanup(_ sarama.ConsumerGroupSess
 	return nil
 }

-func (och *OnlineHistoryRedisConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error { // a instance in the consumer group
+func (och *OnlineHistoryRedisConsumerHandler) ConsumeClaim(
+	sess sarama.ConsumerGroupSession,
+	claim sarama.ConsumerGroupClaim,
+) error { // a instance in the consumer group
 	for {
 		if sess == nil {
 			log.ZWarn(context.Background(), "sess == nil, waiting", nil)
@@ -3,13 +3,14 @@ package msgtransfer
 import (
 	"context"

+	"github.com/Shopify/sarama"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	kfk "github.com/OpenIMSDK/Open-IM-Server/pkg/common/kafka"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
-	"github.com/Shopify/sarama"
-	"google.golang.org/protobuf/proto"
 )

 type OnlineHistoryMongoConsumerHandler struct {
@@ -27,7 +28,12 @@ func NewOnlineHistoryMongoConsumerHandler(database controller.CommonMsgDatabase)
 	return mc
 }

-func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(ctx context.Context, cMsg *sarama.ConsumerMessage, key string, session sarama.ConsumerGroupSession) {
+func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(
+	ctx context.Context,
+	cMsg *sarama.ConsumerMessage,
+	key string,
+	session sarama.ConsumerGroupSession,
+) {
 	msg := cMsg.Value
 	msgFromMQ := pbMsg.MsgDataToMongoByMQ{}
 	err := proto.Unmarshal(msg, &msgFromMQ)
@@ -42,7 +48,15 @@ func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(ctx context.Cont
 	log.ZInfo(ctx, "mongo consumer recv msg", "msgs", msgFromMQ.MsgData)
 	err = mc.msgDatabase.BatchInsertChat2DB(ctx, msgFromMQ.ConversationID, msgFromMQ.MsgData, msgFromMQ.LastSeq)
 	if err != nil {
-		log.ZError(ctx, "single data insert to mongo err", err, "msg", msgFromMQ.MsgData, "conversationID", msgFromMQ.ConversationID)
+		log.ZError(
+			ctx,
+			"single data insert to mongo err",
+			err,
+			"msg",
+			msgFromMQ.MsgData,
+			"conversationID",
+			msgFromMQ.ConversationID,
+		)
 	}
 	var seqs []int64
 	for _, msg := range msgFromMQ.MsgData {
@@ -50,14 +64,26 @@ func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(ctx context.Cont
 	}
 	err = mc.msgDatabase.DeleteMessagesFromCache(ctx, msgFromMQ.ConversationID, seqs)
 	if err != nil {
-		log.ZError(ctx, "remove cache msg from redis err", err, "msg", msgFromMQ.MsgData, "conversationID", msgFromMQ.ConversationID)
+		log.ZError(
+			ctx,
+			"remove cache msg from redis err",
+			err,
+			"msg",
+			msgFromMQ.MsgData,
+			"conversationID",
+			msgFromMQ.ConversationID,
+		)
 	}
 	mc.msgDatabase.DelUserDeleteMsgsList(ctx, msgFromMQ.ConversationID, seqs)
 }

 func (OnlineHistoryMongoConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
 func (OnlineHistoryMongoConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
-func (mc *OnlineHistoryMongoConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error { // a instance in the consumer group
+
+func (mc *OnlineHistoryMongoConsumerHandler) ConsumeClaim(
+	sess sarama.ConsumerGroupSession,
+	claim sarama.ConsumerGroupClaim,
+) error { // a instance in the consumer group
 	log.ZDebug(context.Background(), "online new session msg come", "highWaterMarkOffset",
 		claim.HighWaterMarkOffset(), "topic", claim.Topic(), "partition", claim.Partition())
 	for msg := range claim.Messages() {
@@ -3,8 +3,7 @@
 ** copyright('tuoyun,www.tuoyun.net').
 ** author("fg,Gordon@tuoyun.net").
 ** time(2021/5/11 15:37).
- */
-package msgtransfer
+ */package msgtransfer

 import (
 	"context"
@@ -35,7 +34,12 @@ func NewPersistentConsumerHandler(database controller.ChatLogDatabase) *Persiste
 	}
 }

-func (pc *PersistentConsumerHandler) handleChatWs2Mysql(ctx context.Context, cMsg *sarama.ConsumerMessage, msgKey string, _ sarama.ConsumerGroupSession) {
+func (pc *PersistentConsumerHandler) handleChatWs2Mysql(
+	ctx context.Context,
+	cMsg *sarama.ConsumerMessage,
+	msgKey string,
+	_ sarama.ConsumerGroupSession,
+) {
 	msg := cMsg.Value
 	var tag bool
 	msgFromMQ := pbMsg.MsgDataToMQ{}
@@ -73,10 +77,25 @@ func (pc *PersistentConsumerHandler) handleChatWs2Mysql(ctx context.Context, cMs
 }
 func (PersistentConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
 func (PersistentConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
-func (pc *PersistentConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error {
+
+func (pc *PersistentConsumerHandler) ConsumeClaim(
+	sess sarama.ConsumerGroupSession,
+	claim sarama.ConsumerGroupClaim,
+) error {
 	for msg := range claim.Messages() {
 		ctx := pc.persistentConsumerGroup.GetContextFromMsg(msg)
-		log.ZDebug(ctx, "kafka get info to mysql", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value), "key", string(msg.Key))
+		log.ZDebug(
+			ctx,
+			"kafka get info to mysql",
+			"msgTopic",
+			msg.Topic,
+			"msgPartition",
+			msg.Partition,
+			"msg",
+			string(msg.Value),
+			"key",
+			string(msg.Key),
+		)
 		if len(msg.Value) != 0 {
 			pc.handleChatWs2Mysql(ctx, msg, string(msg.Key), sess)
 		} else {
@@ -17,7 +17,12 @@ func url() string {
 	return config.Config.Callback.CallbackUrl
 }

-func callbackOfflinePush(ctx context.Context, userIDs []string, msg *sdkws.MsgData, offlinePushUserIDs *[]string) error {
+func callbackOfflinePush(
+	ctx context.Context,
+	userIDs []string,
+	msg *sdkws.MsgData,
+	offlinePushUserIDs *[]string,
+) error {
 	if !config.Config.Callback.CallbackOfflinePush.Enable {
 		return nil
 	}
@@ -82,7 +87,12 @@ func callbackOnlinePush(ctx context.Context, userIDs []string, msg *sdkws.MsgDat
 	return http.CallBackPostReturn(ctx, url(), req, resp, config.Config.Callback.CallbackOnlinePush)
 }

-func callbackBeforeSuperGroupOnlinePush(ctx context.Context, groupID string, msg *sdkws.MsgData, pushToUserIDs *[]string) error {
+func callbackBeforeSuperGroupOnlinePush(
+	ctx context.Context,
+	groupID string,
+	msg *sdkws.MsgData,
+	pushToUserIDs *[]string,
+) error {
 	if !config.Config.Callback.CallbackBeforeSuperGroupOnlinePush.Enable {
 		return nil
 	}
@@ -21,6 +21,7 @@ func (c *Consumer) initPrometheus() {
 }

 func (c *Consumer) Start() {
-	//statistics.NewStatistics(&c.successCount, config.Config.ModuleName.PushName, fmt.Sprintf("%d second push to msg_gateway count", constant.StatisticsTimeInterval), constant.StatisticsTimeInterval)
+	// statistics.NewStatistics(&c.successCount, config.Config.ModuleName.PushName, fmt.Sprintf("%d second push to
+	// msg_gateway count", constant.StatisticsTimeInterval), constant.StatisticsTimeInterval)
 	go c.pushCh.pushConsumerGroup.RegisterHandleAndConsumer(&c.pushCh)
 }
@@ -6,12 +6,13 @@ import (

 	firebase "firebase.google.com/go"
 	"firebase.google.com/go/messaging"
+	"github.com/redis/go-redis/v9"
+	"google.golang.org/api/option"
+
 	"github.com/OpenIMSDK/Open-IM-Server/internal/push/offlinepush"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
-	"github.com/redis/go-redis/v9"
-	"google.golang.org/api/option"
 )

 const SinglePushCountLimit = 400
@@ -4,9 +4,10 @@ import (
 	"context"
 	"testing"

+	"github.com/stretchr/testify/assert"
+
 	"github.com/OpenIMSDK/Open-IM-Server/internal/push/offlinepush"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
-	"github.com/stretchr/testify/assert"
 )

 func Test_Push(t *testing.T) {
@@ -99,7 +99,9 @@ func (g *Client) Push(ctx context.Context, userIDs []string, title, content stri

 func (g *Client) Auth(ctx context.Context, timeStamp int64) (token string, expireTime int64, err error) {
 	h := sha256.New()
-	h.Write([]byte(config.Config.Push.GeTui.AppKey + strconv.Itoa(int(timeStamp)) + config.Config.Push.GeTui.MasterSecret))
+	h.Write(
+		[]byte(config.Config.Push.GeTui.AppKey + strconv.Itoa(int(timeStamp)) + config.Config.Push.GeTui.MasterSecret),
+	)
 	sign := hex.EncodeToString(h.Sum(nil))
 	reqAuth := AuthReq{
 		Sign:      sign,
@@ -150,7 +152,14 @@ func (g *Client) request(ctx context.Context, url string, input interface{}, tok
 	return g.postReturn(ctx, config.Config.Push.GeTui.PushUrl+url, header, input, resp, 3)
 }

-func (g *Client) postReturn(ctx context.Context, url string, header map[string]string, input interface{}, output RespI, timeout int) error {
+func (g *Client) postReturn(
+	ctx context.Context,
+	url string,
+	header map[string]string,
+	input interface{},
+	output RespI,
+	timeout int,
+) error {
 	err := http2.PostReturn(ctx, url, header, input, output, timeout)
 	if err != nil {
 		return err
@@ -60,5 +60,14 @@ func (j *JPush) Push(ctx context.Context, userIDs []string, title, content strin
 }

 func (j *JPush) request(ctx context.Context, po body.PushObj, resp interface{}, timeout int) error {
-	return http2.PostReturn(ctx, config.Config.Push.Jpns.PushUrl, map[string]string{"Authorization": j.getAuthorization(config.Config.Push.Jpns.AppKey, config.Config.Push.Jpns.MasterSecret)}, po, resp, timeout)
+	return http2.PostReturn(
+		ctx,
+		config.Config.Push.Jpns.PushUrl,
+		map[string]string{
+			"Authorization": j.getAuthorization(config.Config.Push.Jpns.AppKey, config.Config.Push.Jpns.MasterSecret),
+		},
+		po,
+		resp,
+		timeout,
+	)
 }
@@ -3,6 +3,9 @@ package push
 import (
 	"context"

+	"github.com/Shopify/sarama"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	kfk "github.com/OpenIMSDK/Open-IM-Server/pkg/common/kafka"
@@ -10,8 +13,6 @@ import (
 	pbChat "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	pbPush "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/push"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"github.com/Shopify/sarama"
-	"google.golang.org/protobuf/proto"
 )

 type ConsumerHandler struct {
@@ -4,6 +4,8 @@ import (
 	"context"
 	"sync"

+	"google.golang.org/grpc"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
@@ -12,7 +14,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	pbPush "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/push"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
-	"google.golang.org/grpc"
 )

 type pushServer struct {
@@ -30,7 +31,16 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	groupRpcClient := rpcclient.NewGroupRpcClient(client)
 	conversationRpcClient := rpcclient.NewConversationRpcClient(client)
 	msgRpcClient := rpcclient.NewMessageRpcClient(client)
-	pusher := NewPusher(client, offlinePusher, database, localcache.NewGroupLocalCache(&groupRpcClient), localcache.NewConversationLocalCache(&conversationRpcClient), &conversationRpcClient, &groupRpcClient, &msgRpcClient)
+	pusher := NewPusher(
+		client,
+		offlinePusher,
+		database,
+		localcache.NewGroupLocalCache(&groupRpcClient),
+		localcache.NewConversationLocalCache(&conversationRpcClient),
+		&conversationRpcClient,
+		&groupRpcClient,
+		&msgRpcClient,
+	)
 	var wg sync.WaitGroup
 	wg.Add(2)
 	go func() {
@@ -66,7 +76,10 @@ func (r *pushServer) PushMsg(ctx context.Context, pbData *pbPush.PushMsgReq) (re
 	return &pbPush.PushMsgResp{}, nil
 }

-func (r *pushServer) DelUserPushToken(ctx context.Context, req *pbPush.DelUserPushTokenReq) (resp *pbPush.DelUserPushTokenResp, err error) {
+func (r *pushServer) DelUserPushToken(
+	ctx context.Context,
+	req *pbPush.DelUserPushTokenReq,
+) (resp *pbPush.DelUserPushTokenResp, err error) {
 	if err = r.pusher.database.DelFcmToken(ctx, req.UserID, int(req.PlatformID)); err != nil {
 		return nil, err
 	}
@@ -38,9 +38,16 @@ type Pusher struct {

 var errNoOfflinePusher = errors.New("no offlinePusher is configured")

-func NewPusher(discov discoveryregistry.SvcDiscoveryRegistry, offlinePusher offlinepush.OfflinePusher, database controller.PushDatabase,
-	groupLocalCache *localcache.GroupLocalCache, conversationLocalCache *localcache.ConversationLocalCache,
-	conversationRpcClient *rpcclient.ConversationRpcClient, groupRpcClient *rpcclient.GroupRpcClient, msgRpcClient *rpcclient.MessageRpcClient) *Pusher {
+func NewPusher(
+	discov discoveryregistry.SvcDiscoveryRegistry,
+	offlinePusher offlinepush.OfflinePusher,
+	database controller.PushDatabase,
+	groupLocalCache *localcache.GroupLocalCache,
+	conversationLocalCache *localcache.ConversationLocalCache,
+	conversationRpcClient *rpcclient.ConversationRpcClient,
+	groupRpcClient *rpcclient.GroupRpcClient,
+	msgRpcClient *rpcclient.MessageRpcClient,
+) *Pusher {
 	return &Pusher{
 		discov:                 discov,
 		database:               database,
@@ -87,7 +94,18 @@ func (p *Pusher) Push2User(ctx context.Context, userIDs []string, msg *sdkws.Msg
 		return err
 	}
 	isOfflinePush := utils.GetSwitchFromOptions(msg.Options, constant.IsOfflinePush)
-	log.ZDebug(ctx, "push_result", "ws push result", wsResults, "sendData", msg, "isOfflinePush", isOfflinePush, "push_to_userID", userIDs)
+	log.ZDebug(
+		ctx,
+		"push_result",
+		"ws push result",
+		wsResults,
+		"sendData",
+		msg,
+		"isOfflinePush",
+		isOfflinePush,
+		"push_to_userID",
+		userIDs,
+	)
 	p.successCount++
 	for _, userID := range userIDs {
 		if isOfflinePush && userID != msg.SendID {
@@ -138,7 +156,15 @@ func (p *Pusher) Push2SuperGroup(ctx context.Context, groupID string, msg *sdkws
 			}
 			defer func(groupID string, userIDs []string) {
 				if err := p.DeleteMemberAndSetConversationSeq(ctx, groupID, userIDs); err != nil {
-					log.ZError(ctx, "MemberQuitNotification DeleteMemberAndSetConversationSeq", err, "groupID", groupID, "userIDs", userIDs)
+					log.ZError(
+						ctx,
+						"MemberQuitNotification DeleteMemberAndSetConversationSeq",
+						err,
+						"groupID",
+						groupID,
+						"userIDs",
+						userIDs,
+					)
 				}
 			}(groupID, []string{tips.QuitUser.UserID})
 			pushToUserIDs = append(pushToUserIDs, tips.QuitUser.UserID)
@@ -147,10 +173,21 @@ func (p *Pusher) Push2SuperGroup(ctx context.Context, groupID string, msg *sdkws
 			if p.UnmarshalNotificationElem(msg.Content, &tips) != nil {
 				return err
 			}
-			kickedUsers := utils.Slice(tips.KickedUserList, func(e *sdkws.GroupMemberFullInfo) string { return e.UserID })
+			kickedUsers := utils.Slice(
+				tips.KickedUserList,
+				func(e *sdkws.GroupMemberFullInfo) string { return e.UserID },
+			)
 			defer func(groupID string, userIDs []string) {
 				if err := p.DeleteMemberAndSetConversationSeq(ctx, groupID, userIDs); err != nil {
-					log.ZError(ctx, "MemberKickedNotification DeleteMemberAndSetConversationSeq", err, "groupID", groupID, "userIDs", userIDs)
+					log.ZError(
+						ctx,
+						"MemberKickedNotification DeleteMemberAndSetConversationSeq",
+						err,
+						"groupID",
+						groupID,
+						"userIDs",
+						userIDs,
+					)
 				}
 			}(groupID, kickedUsers)
 			pushToUserIDs = append(pushToUserIDs, kickedUsers...)
@@ -160,7 +197,16 @@ func (p *Pusher) Push2SuperGroup(ctx context.Context, groupID string, msg *sdkws
 				if p.UnmarshalNotificationElem(msg.Content, &tips) != nil {
 					return err
 				}
-				log.ZInfo(ctx, "GroupDismissedNotificationInfo****", "groupID", groupID, "num", len(pushToUserIDs), "list", pushToUserIDs)
+				log.ZInfo(
+					ctx,
+					"GroupDismissedNotificationInfo****",
+					"groupID",
+					groupID,
+					"num",
+					len(pushToUserIDs),
+					"list",
+					pushToUserIDs,
+				)
 				if len(config.Config.Manager.UserID) > 0 {
 					ctx = mcontext.WithOpUserIDContext(ctx, config.Config.Manager.UserID[0])
 				}
@@ -224,9 +270,23 @@ func (p *Pusher) Push2SuperGroup(ctx context.Context, groupID string, msg *sdkws
 				log.ZError(ctx, "offlinePushMsg failed", err, "groupID", groupID, "msg", msg)
 				return err
 			}
-			_, err := p.GetConnsAndOnlinePush(ctx, msg, utils.IntersectString(needOfflinePushUserIDs, WebAndPcBackgroundUserIDs))
+			_, err := p.GetConnsAndOnlinePush(
+				ctx,
+				msg,
+				utils.IntersectString(needOfflinePushUserIDs, WebAndPcBackgroundUserIDs),
+			)
 			if err != nil {
-				log.ZError(ctx, "offlinePushMsg failed", err, "groupID", groupID, "msg", msg, "userIDs", utils.IntersectString(needOfflinePushUserIDs, WebAndPcBackgroundUserIDs))
+				log.ZError(
+					ctx,
+					"offlinePushMsg failed",
+					err,
+					"groupID",
+					groupID,
+					"msg",
+					msg,
+					"userIDs",
+					utils.IntersectString(needOfflinePushUserIDs, WebAndPcBackgroundUserIDs),
+				)
 				return err
 			}
 		}
@@ -234,7 +294,11 @@ func (p *Pusher) Push2SuperGroup(ctx context.Context, groupID string, msg *sdkws
 	return nil
 }

-func (p *Pusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData, pushToUserIDs []string) (wsResults []*msggateway.SingleMsgToUserResults, err error) {
+func (p *Pusher) GetConnsAndOnlinePush(
+	ctx context.Context,
+	msg *sdkws.MsgData,
+	pushToUserIDs []string,
+) (wsResults []*msggateway.SingleMsgToUserResults, err error) {
 	conns, err := p.discov.GetConns(ctx, config.Config.RpcRegisterName.OpenImMessageGatewayName)
 	log.ZDebug(ctx, "get gateway conn", "conn length", len(conns))
 	if err != nil {
@@ -243,7 +307,10 @@ func (p *Pusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
 	//Online push message
 	for _, v := range conns {
 		msgClient := msggateway.NewMsgGatewayClient(v)
-		reply, err := msgClient.SuperGroupOnlineBatchPushOneMsg(ctx, &msggateway.OnlineBatchPushOneMsgReq{MsgData: msg, PushToUserIDs: pushToUserIDs})
+		reply, err := msgClient.SuperGroupOnlineBatchPushOneMsg(
+			ctx,
+			&msggateway.OnlineBatchPushOneMsgReq{MsgData: msg, PushToUserIDs: pushToUserIDs},
+		)
 		p.discov.CloseConn(v)
 		if err != nil {
 			continue
@@ -257,7 +324,12 @@ func (p *Pusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
 	return wsResults, nil
 }

-func (p *Pusher) offlinePushMsg(ctx context.Context, conversationID string, msg *sdkws.MsgData, offlinePushUserIDs []string) error {
+func (p *Pusher) offlinePushMsg(
+	ctx context.Context,
+	conversationID string,
+	msg *sdkws.MsgData,
+	offlinePushUserIDs []string,
+) error {
 	title, content, opts, err := p.getOfflinePushInfos(conversationID, msg)
 	if err != nil {
 		return err
@@ -291,7 +363,10 @@ func (p *Pusher) GetOfflinePushOpts(msg *sdkws.MsgData) (opts *offlinepush.Opts,
 	return opts, nil
 }

-func (p *Pusher) getOfflinePushInfos(conversationID string, msg *sdkws.MsgData) (title, content string, opts *offlinepush.Opts, err error) {
+func (p *Pusher) getOfflinePushInfos(
+	conversationID string,
+	msg *sdkws.MsgData,
+) (title, content string, opts *offlinepush.Opts, err error) {
 	if p.offlinePusher == nil {
 		err = errNoOfflinePusher
 		return
@@ -3,6 +3,8 @@ package auth
 import (
 	"context"

+	"google.golang.org/grpc"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
@@ -15,7 +17,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msggateway"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"google.golang.org/grpc"
 )

 type authServer struct {
@@ -33,7 +34,11 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	pbAuth.RegisterAuthServer(server, &authServer{
 		userRpcClient:  &userRpcClient,
 		RegisterCenter: client,
-		authDatabase:   controller.NewAuthDatabase(cache.NewMsgCacheModel(rdb), config.Config.Secret, config.Config.TokenPolicy.Expire),
+		authDatabase: controller.NewAuthDatabase(
+			cache.NewMsgCacheModel(rdb),
+			config.Config.Secret,
+			config.Config.TokenPolicy.Expire,
+		),
 	})
 	return nil
 }
@@ -80,7 +85,10 @@ func (s *authServer) parseToken(ctx context.Context, tokensString string) (claim
 	return nil, errs.ErrTokenNotExist.Wrap()
 }

-func (s *authServer) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (resp *pbAuth.ParseTokenResp, err error) {
+func (s *authServer) ParseToken(
+	ctx context.Context,
+	req *pbAuth.ParseTokenReq,
+) (resp *pbAuth.ParseTokenResp, err error) {
 	resp = &pbAuth.ParseTokenResp{}
 	claims, err := s.parseToken(ctx, req.Token)
 	if err != nil {
@@ -3,6 +3,8 @@ package conversation
 import (
 	"context"

+	"google.golang.org/grpc"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
@@ -17,7 +19,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"google.golang.org/grpc"
 )

 type conversationServer struct {
@@ -44,12 +45,19 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	pbConversation.RegisterConversationServer(server, &conversationServer{
 		conversationNotificationSender: notification.NewConversationNotificationSender(&msgRpcClient),
 		groupRpcClient:                 &groupRpcClient,
-		conversationDatabase:           controller.NewConversationDatabase(conversationDB, cache.NewConversationRedis(rdb, cache.GetDefaultOpt(), conversationDB), tx.NewGorm(db)),
+		conversationDatabase: controller.NewConversationDatabase(
+			conversationDB,
+			cache.NewConversationRedis(rdb, cache.GetDefaultOpt(), conversationDB),
+			tx.NewGorm(db),
+		),
 	})
 	return nil
 }

-func (c *conversationServer) GetConversation(ctx context.Context, req *pbConversation.GetConversationReq) (*pbConversation.GetConversationResp, error) {
+func (c *conversationServer) GetConversation(
+	ctx context.Context,
+	req *pbConversation.GetConversationReq,
+) (*pbConversation.GetConversationResp, error) {
 	conversations, err := c.conversationDatabase.FindConversations(ctx, req.OwnerUserID, []string{req.ConversationID})
 	if err != nil {
 		return nil, err
@@ -62,7 +70,10 @@ func (c *conversationServer) GetConversation(ctx context.Context, req *pbConvers
 	return resp, nil
 }

-func (c *conversationServer) GetAllConversations(ctx context.Context, req *pbConversation.GetAllConversationsReq) (*pbConversation.GetAllConversationsResp, error) {
+func (c *conversationServer) GetAllConversations(
+	ctx context.Context,
+	req *pbConversation.GetAllConversationsReq,
+) (*pbConversation.GetAllConversationsResp, error) {
 	conversations, err := c.conversationDatabase.GetUserAllConversation(ctx, req.OwnerUserID)
 	if err != nil {
 		return nil, err
@@ -72,7 +83,10 @@ func (c *conversationServer) GetAllConversations(ctx context.Context, req *pbCon
 	return resp, nil
 }

-func (c *conversationServer) GetConversations(ctx context.Context, req *pbConversation.GetConversationsReq) (*pbConversation.GetConversationsResp, error) {
+func (c *conversationServer) GetConversations(
+	ctx context.Context,
+	req *pbConversation.GetConversationsReq,
+) (*pbConversation.GetConversationsResp, error) {
 	conversations, err := c.conversationDatabase.FindConversations(ctx, req.OwnerUserID, req.ConversationIDs)
 	if err != nil {
 		return nil, err
@@ -82,7 +96,10 @@ func (c *conversationServer) GetConversations(ctx context.Context, req *pbConver
 	return resp, nil
 }

-func (c *conversationServer) BatchSetConversations(ctx context.Context, req *pbConversation.BatchSetConversationsReq) (*pbConversation.BatchSetConversationsResp, error) {
+func (c *conversationServer) BatchSetConversations(
+	ctx context.Context,
+	req *pbConversation.BatchSetConversationsReq,
+) (*pbConversation.BatchSetConversationsResp, error) {
 	conversations := convert.ConversationsPb2DB(req.Conversations)
 	err := c.conversationDatabase.SetUserConversations(ctx, req.OwnerUserID, conversations)
 	if err != nil {
@@ -92,12 +109,19 @@ func (c *conversationServer) BatchSetConversations(ctx context.Context, req *pbC
 	return &pbConversation.BatchSetConversationsResp{}, nil
 }

-func (c *conversationServer) SetConversation(ctx context.Context, req *pbConversation.SetConversationReq) (*pbConversation.SetConversationResp, error) {
+func (c *conversationServer) SetConversation(
+	ctx context.Context,
+	req *pbConversation.SetConversationReq,
+) (*pbConversation.SetConversationResp, error) {
 	var conversation tableRelation.ConversationModel
 	if err := utils.CopyStructFields(&conversation, req.Conversation); err != nil {
 		return nil, err
 	}
-	err := c.conversationDatabase.SetUserConversations(ctx, req.Conversation.OwnerUserID, []*tableRelation.ConversationModel{&conversation})
+	err := c.conversationDatabase.SetUserConversations(
+		ctx,
+		req.Conversation.OwnerUserID,
+		[]*tableRelation.ConversationModel{&conversation},
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -106,7 +130,10 @@ func (c *conversationServer) SetConversation(ctx context.Context, req *pbConvers
 	return resp, nil
 }

-func (c *conversationServer) SetRecvMsgOpt(ctx context.Context, req *pbConversation.SetRecvMsgOptReq) (*pbConversation.SetRecvMsgOptResp, error) {
+func (c *conversationServer) SetRecvMsgOpt(
+	ctx context.Context,
+	req *pbConversation.SetRecvMsgOptReq,
+) (*pbConversation.SetRecvMsgOptResp, error) {
 	if err := c.conversationDatabase.SetUsersConversationFiledTx(ctx, []string{req.OwnerUserID}, &tableRelation.ConversationModel{OwnerUserID: req.OwnerUserID, ConversationID: req.ConversationID, RecvMsgOpt: req.RecvMsgOpt}, map[string]interface{}{"recv_msg_opt": req.RecvMsgOpt}); err != nil {
 		return nil, err
 	}
@@ -115,7 +142,10 @@ func (c *conversationServer) SetRecvMsgOpt(ctx context.Context, req *pbConversat
 }

 // deprecated
-func (c *conversationServer) ModifyConversationField(ctx context.Context, req *pbConversation.ModifyConversationFieldReq) (*pbConversation.ModifyConversationFieldResp, error) {
+func (c *conversationServer) ModifyConversationField(
+	ctx context.Context,
+	req *pbConversation.ModifyConversationFieldReq,
+) (*pbConversation.ModifyConversationFieldResp, error) {
 	resp := &pbConversation.ModifyConversationFieldResp{}
 	var err error
 	if req.Conversation.ConversationType == constant.GroupChatType {
@@ -129,11 +159,19 @@ func (c *conversationServer) ModifyConversationField(ctx context.Context, req *p
 	}
 	conversation := convert.ConversationPb2DB(req.Conversation)
 	if req.FieldType == constant.FieldIsPrivateChat {
-		err := c.conversationDatabase.SyncPeerUserPrivateConversationTx(ctx, []*tableRelation.ConversationModel{conversation})
+		err := c.conversationDatabase.SyncPeerUserPrivateConversationTx(
+			ctx,
+			[]*tableRelation.ConversationModel{conversation},
+		)
 		if err != nil {
 			return nil, err
 		}
-		c.conversationNotificationSender.ConversationSetPrivateNotification(ctx, req.Conversation.OwnerUserID, req.Conversation.UserID, req.Conversation.IsPrivateChat)
+		c.conversationNotificationSender.ConversationSetPrivateNotification(
+			ctx,
+			req.Conversation.OwnerUserID,
+			req.Conversation.UserID,
+			req.Conversation.IsPrivateChat,
+		)
 		return resp, nil
 	}
 	filedMap := make(map[string]interface{})
@@ -161,7 +199,10 @@ func (c *conversationServer) ModifyConversationField(ctx context.Context, req *p
 	return resp, nil
 }

-func (c *conversationServer) SetConversations(ctx context.Context, req *pbConversation.SetConversationsReq) (*pbConversation.SetConversationsResp, error) {
+func (c *conversationServer) SetConversations(
+	ctx context.Context,
+	req *pbConversation.SetConversationsReq,
+) (*pbConversation.SetConversationsResp, error) {
 	if req.Conversation == nil {
 		return nil, errs.ErrArgs.Wrap("conversation must not be nil")
 	}
@@ -207,7 +248,12 @@ func (c *conversationServer) SetConversations(ctx context.Context, req *pbConver
 			return nil, err
 		}
 		for _, ownerUserID := range req.UserIDs {
-			c.conversationNotificationSender.ConversationSetPrivateNotification(ctx, ownerUserID, req.Conversation.UserID, req.Conversation.IsPrivateChat.Value)
+			c.conversationNotificationSender.ConversationSetPrivateNotification(
+				ctx,
+				ownerUserID,
+				req.Conversation.UserID,
+				req.Conversation.IsPrivateChat.Value,
+			)
 		}
 	}
 	if req.Conversation.BurnDuration != nil {
@@ -224,7 +270,10 @@ func (c *conversationServer) SetConversations(ctx context.Context, req *pbConver
 }

 // 获取超级大群开启免打扰的用户ID
-func (c *conversationServer) GetRecvMsgNotNotifyUserIDs(ctx context.Context, req *pbConversation.GetRecvMsgNotNotifyUserIDsReq) (*pbConversation.GetRecvMsgNotNotifyUserIDsResp, error) {
+func (c *conversationServer) GetRecvMsgNotNotifyUserIDs(
+	ctx context.Context,
+	req *pbConversation.GetRecvMsgNotNotifyUserIDsReq,
+) (*pbConversation.GetRecvMsgNotNotifyUserIDsResp, error) {
 	userIDs, err := c.conversationDatabase.FindRecvMsgNotNotifyUserIDs(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
@@ -233,7 +282,10 @@ func (c *conversationServer) GetRecvMsgNotNotifyUserIDs(ctx context.Context, req
 }

 // create conversation without notification for msg redis transfer
-func (c *conversationServer) CreateSingleChatConversations(ctx context.Context, req *pbConversation.CreateSingleChatConversationsReq) (*pbConversation.CreateSingleChatConversationsResp, error) {
+func (c *conversationServer) CreateSingleChatConversations(
+	ctx context.Context,
+	req *pbConversation.CreateSingleChatConversationsReq,
+) (*pbConversation.CreateSingleChatConversationsResp, error) {
 	var conversation tableRelation.ConversationModel
 	conversation.ConversationID = utils.GetConversationIDBySessionType(constant.SingleChatType, req.RecvID, req.SendID)
 	conversation.ConversationType = constant.SingleChatType
@@ -254,7 +306,10 @@ func (c *conversationServer) CreateSingleChatConversations(ctx context.Context,
 	return &pbConversation.CreateSingleChatConversationsResp{}, nil
 }

-func (c *conversationServer) CreateGroupChatConversations(ctx context.Context, req *pbConversation.CreateGroupChatConversationsReq) (*pbConversation.CreateGroupChatConversationsResp, error) {
+func (c *conversationServer) CreateGroupChatConversations(
+	ctx context.Context,
+	req *pbConversation.CreateGroupChatConversationsReq,
+) (*pbConversation.CreateGroupChatConversationsResp, error) {
 	err := c.conversationDatabase.CreateGroupChatConversation(ctx, req.GroupID, req.UserIDs)
 	if err != nil {
 		return nil, err
@@ -262,7 +317,10 @@ func (c *conversationServer) CreateGroupChatConversations(ctx context.Context, r
 	return &pbConversation.CreateGroupChatConversationsResp{}, nil
 }

-func (c *conversationServer) SetConversationMaxSeq(ctx context.Context, req *pbConversation.SetConversationMaxSeqReq) (*pbConversation.SetConversationMaxSeqResp, error) {
+func (c *conversationServer) SetConversationMaxSeq(
+	ctx context.Context,
+	req *pbConversation.SetConversationMaxSeqReq,
+) (*pbConversation.SetConversationMaxSeqResp, error) {
 	if err := c.conversationDatabase.UpdateUsersConversationFiled(ctx, req.OwnerUserID, req.ConversationID,
 		map[string]interface{}{"max_seq": req.MaxSeq}); err != nil {
 		return nil, err
@@ -270,7 +328,10 @@ func (c *conversationServer) SetConversationMaxSeq(ctx context.Context, req *pbC
 	return &pbConversation.SetConversationMaxSeqResp{}, nil
 }

-func (c *conversationServer) GetConversationIDs(ctx context.Context, req *pbConversation.GetConversationIDsReq) (*pbConversation.GetConversationIDsResp, error) {
+func (c *conversationServer) GetConversationIDs(
+	ctx context.Context,
+	req *pbConversation.GetConversationIDsReq,
+) (*pbConversation.GetConversationIDsResp, error) {
 	conversationIDs, err := c.conversationDatabase.GetConversationIDs(ctx, req.UserID)
 	if err != nil {
 		return nil, err
@@ -278,7 +339,10 @@ func (c *conversationServer) GetConversationIDs(ctx context.Context, req *pbConv
 	return &pbConversation.GetConversationIDsResp{ConversationIDs: conversationIDs}, nil
 }

-func (c *conversationServer) GetUserConversationIDsHash(ctx context.Context, req *pbConversation.GetUserConversationIDsHashReq) (*pbConversation.GetUserConversationIDsHashResp, error) {
+func (c *conversationServer) GetUserConversationIDsHash(
+	ctx context.Context,
+	req *pbConversation.GetUserConversationIDsHashReq,
+) (*pbConversation.GetUserConversationIDsHashResp, error) {
 	hash, err := c.conversationDatabase.GetUserConversationIDsHash(ctx, req.OwnerUserID)
 	if err != nil {
 		return nil, err
@@ -286,10 +350,15 @@ func (c *conversationServer) GetUserConversationIDsHash(ctx context.Context, req
 	return &pbConversation.GetUserConversationIDsHashResp{Hash: hash}, nil
 }

-func (c *conversationServer) GetConversationsByConversationID(ctx context.Context, req *pbConversation.GetConversationsByConversationIDReq) (*pbConversation.GetConversationsByConversationIDResp, error) {
+func (c *conversationServer) GetConversationsByConversationID(
+	ctx context.Context,
+	req *pbConversation.GetConversationsByConversationIDReq,
+) (*pbConversation.GetConversationsByConversationIDResp, error) {
 	conversations, err := c.conversationDatabase.GetConversationsByConversationID(ctx, req.ConversationIDs)
 	if err != nil {
 		return nil, err
 	}
-	return &pbConversation.GetConversationsByConversationIDResp{Conversations: convert.ConversationsDB2Pb(conversations)}, nil
+	return &pbConversation.GetConversationsByConversationIDResp{
+		Conversations: convert.ConversationsDB2Pb(conversations),
+	}, nil
 }
@@ -11,7 +11,10 @@ import (
 	pbFriend "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
 )

-func (s *friendServer) GetPaginationBlacks(ctx context.Context, req *pbFriend.GetPaginationBlacksReq) (resp *pbFriend.GetPaginationBlacksResp, err error) {
+func (s *friendServer) GetPaginationBlacks(
+	ctx context.Context,
+	req *pbFriend.GetPaginationBlacksReq,
+) (resp *pbFriend.GetPaginationBlacksResp, err error) {
 	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
@@ -44,7 +47,10 @@ func (s *friendServer) IsBlack(ctx context.Context, req *pbFriend.IsBlackReq) (*
 	return resp, nil
 }

-func (s *friendServer) RemoveBlack(ctx context.Context, req *pbFriend.RemoveBlackReq) (*pbFriend.RemoveBlackResp, error) {
+func (s *friendServer) RemoveBlack(
+	ctx context.Context,
+	req *pbFriend.RemoveBlackReq,
+) (*pbFriend.RemoveBlackResp, error) {
 	if err := s.userRpcClient.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
@@ -63,7 +69,12 @@ func (s *friendServer) AddBlack(ctx context.Context, req *pbFriend.AddBlackReq)
 	if err != nil {
 		return nil, err
 	}
-	black := relation.BlackModel{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: mcontext.GetOpUserID(ctx), CreateTime: time.Now()}
+	black := relation.BlackModel{
+		OwnerUserID:    req.OwnerUserID,
+		BlockUserID:    req.BlackUserID,
+		OperatorUserID: mcontext.GetOpUserID(ctx),
+		CreateTime:     time.Now(),
+	}
 	if err := s.blackDatabase.Create(ctx, []*relation.BlackModel{&black}); err != nil {
 		return nil, err
 	}
@@ -7,6 +7,8 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"

+	"google.golang.org/grpc"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
@@ -19,7 +21,6 @@ import (
 	pbfriend "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"google.golang.org/grpc"
 )

 type friendServer struct {
@@ -46,10 +47,21 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 	friendDB := relation.NewFriendGorm(db)
 	userRpcClient := rpcclient.NewUserRpcClient(client)
 	msgRpcClient := rpcclient.NewMessageRpcClient(client)
-	notificationSender := notification.NewFriendNotificationSender(&msgRpcClient, notification.WithRpcFunc(userRpcClient.GetUsersInfo))
+	notificationSender := notification.NewFriendNotificationSender(
+		&msgRpcClient,
+		notification.WithRpcFunc(userRpcClient.GetUsersInfo),
+	)
 	pbfriend.RegisterFriendServer(server, &friendServer{
-		friendDatabase:     controller.NewFriendDatabase(friendDB, relation.NewFriendRequestGorm(db), cache.NewFriendCacheRedis(rdb, friendDB, cache.GetDefaultOpt()), tx.NewGorm(db)),
-		blackDatabase:      controller.NewBlackDatabase(blackDB, cache.NewBlackCacheRedis(rdb, blackDB, cache.GetDefaultOpt())),
+		friendDatabase: controller.NewFriendDatabase(
+			friendDB,
+			relation.NewFriendRequestGorm(db),
+			cache.NewFriendCacheRedis(rdb, friendDB, cache.GetDefaultOpt()),
+			tx.NewGorm(db),
+		),
+		blackDatabase: controller.NewBlackDatabase(
+			blackDB,
+			cache.NewBlackCacheRedis(rdb, blackDB, cache.GetDefaultOpt()),
+		),
 		userRpcClient:      &userRpcClient,
 		notificationSender: notificationSender,
 		RegisterCenter:     client,
@@ -58,7 +70,10 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 }

 // ok
-func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.ApplyToAddFriendReq) (resp *pbfriend.ApplyToAddFriendResp, err error) {
+func (s *friendServer) ApplyToAddFriend(
+	ctx context.Context,
+	req *pbfriend.ApplyToAddFriendReq,
+) (resp *pbfriend.ApplyToAddFriendResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	resp = &pbfriend.ApplyToAddFriendResp{}
 	if err := tokenverify.CheckAccessV3(ctx, req.FromUserID); err != nil {
@@ -88,7 +103,10 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.Apply
 }

 // ok
-func (s *friendServer) ImportFriends(ctx context.Context, req *pbfriend.ImportFriendReq) (resp *pbfriend.ImportFriendResp, err error) {
+func (s *friendServer) ImportFriends(
+	ctx context.Context,
+	req *pbfriend.ImportFriendReq,
+) (resp *pbfriend.ImportFriendResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	if err := tokenverify.CheckAdmin(ctx); err != nil {
 		return nil, err
@@ -111,14 +129,22 @@ func (s *friendServer) ImportFriends(ctx context.Context, req *pbfriend.ImportFr
 }

 // ok
-func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbfriend.RespondFriendApplyReq) (resp *pbfriend.RespondFriendApplyResp, err error) {
+func (s *friendServer) RespondFriendApply(
+	ctx context.Context,
+	req *pbfriend.RespondFriendApplyReq,
+) (resp *pbfriend.RespondFriendApplyResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	resp = &pbfriend.RespondFriendApplyResp{}
 	if err := tokenverify.CheckAccessV3(ctx, req.ToUserID); err != nil {
 		return nil, err
 	}

-	friendRequest := tablerelation.FriendRequestModel{FromUserID: req.FromUserID, ToUserID: req.ToUserID, HandleMsg: req.HandleMsg, HandleResult: req.HandleResult}
+	friendRequest := tablerelation.FriendRequestModel{
+		FromUserID:   req.FromUserID,
+		ToUserID:     req.ToUserID,
+		HandleMsg:    req.HandleMsg,
+		HandleResult: req.HandleResult,
+	}
 	if req.HandleResult == constant.FriendResponseAgree {
 		err := s.friendDatabase.AgreeFriendRequest(ctx, &friendRequest)
 		if err != nil {
@@ -139,7 +165,10 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbfriend.Res
 }

 // ok
-func (s *friendServer) DeleteFriend(ctx context.Context, req *pbfriend.DeleteFriendReq) (resp *pbfriend.DeleteFriendResp, err error) {
+func (s *friendServer) DeleteFriend(
+	ctx context.Context,
+	req *pbfriend.DeleteFriendReq,
+) (resp *pbfriend.DeleteFriendResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	resp = &pbfriend.DeleteFriendResp{}
 	if err := s.userRpcClient.Access(ctx, req.OwnerUserID); err != nil {
@@ -157,7 +186,10 @@ func (s *friendServer) DeleteFriend(ctx context.Context, req *pbfriend.DeleteFri
 }

 // ok
-func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbfriend.SetFriendRemarkReq) (resp *pbfriend.SetFriendRemarkResp, err error) {
+func (s *friendServer) SetFriendRemark(
+	ctx context.Context,
+	req *pbfriend.SetFriendRemarkReq,
+) (resp *pbfriend.SetFriendRemarkResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	resp = &pbfriend.SetFriendRemarkResp{}
 	if err := s.userRpcClient.Access(ctx, req.OwnerUserID); err != nil {
@@ -175,7 +207,10 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbfriend.SetFri
 }

 // ok
-func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbfriend.GetDesignatedFriendsReq) (resp *pbfriend.GetDesignatedFriendsResp, err error) {
+func (s *friendServer) GetDesignatedFriends(
+	ctx context.Context,
+	req *pbfriend.GetDesignatedFriendsReq,
+) (resp *pbfriend.GetDesignatedFriendsResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	resp = &pbfriend.GetDesignatedFriendsResp{}
 	if utils.Duplicate(req.FriendUserIDs) {
@@ -192,7 +227,10 @@ func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbfriend.G
 }

 // ok 获取接收到的好友申请（即别人主动申请的）
-func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *pbfriend.GetPaginationFriendsApplyToReq) (resp *pbfriend.GetPaginationFriendsApplyToResp, err error) {
+func (s *friendServer) GetPaginationFriendsApplyTo(
+	ctx context.Context,
+	req *pbfriend.GetPaginationFriendsApplyToReq,
+) (resp *pbfriend.GetPaginationFriendsApplyToResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	resp = &pbfriend.GetPaginationFriendsApplyToResp{}
 	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
@@ -212,7 +250,10 @@ func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *pbf
 }

 // ok 获取主动发出去的好友申请列表
-func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *pbfriend.GetPaginationFriendsApplyFromReq) (resp *pbfriend.GetPaginationFriendsApplyFromResp, err error) {
+func (s *friendServer) GetPaginationFriendsApplyFrom(
+	ctx context.Context,
+	req *pbfriend.GetPaginationFriendsApplyFromReq,
+) (resp *pbfriend.GetPaginationFriendsApplyFromResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	resp = &pbfriend.GetPaginationFriendsApplyFromResp{}
 	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
@@ -232,7 +273,10 @@ func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *p
 }

 // ok
-func (s *friendServer) IsFriend(ctx context.Context, req *pbfriend.IsFriendReq) (resp *pbfriend.IsFriendResp, err error) {
+func (s *friendServer) IsFriend(
+	ctx context.Context,
+	req *pbfriend.IsFriendReq,
+) (resp *pbfriend.IsFriendResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	resp = &pbfriend.IsFriendResp{}
 	resp.InUser1Friends, resp.InUser2Friends, err = s.friendDatabase.CheckIn(ctx, req.UserID1, req.UserID2)
@@ -243,7 +287,10 @@ func (s *friendServer) IsFriend(ctx context.Context, req *pbfriend.IsFriendReq)
 }

 // ok
-func (s *friendServer) GetPaginationFriends(ctx context.Context, req *pbfriend.GetPaginationFriendsReq) (resp *pbfriend.GetPaginationFriendsResp, err error) {
+func (s *friendServer) GetPaginationFriends(
+	ctx context.Context,
+	req *pbfriend.GetPaginationFriendsReq,
+) (resp *pbfriend.GetPaginationFriendsResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
 		return nil, err
@@ -262,7 +309,10 @@ func (s *friendServer) GetPaginationFriends(ctx context.Context, req *pbfriend.G
 	return resp, nil
 }

-func (s *friendServer) GetFriendIDs(ctx context.Context, req *pbfriend.GetFriendIDsReq) (resp *pbfriend.GetFriendIDsResp, err error) {
+func (s *friendServer) GetFriendIDs(
+	ctx context.Context,
+	req *pbfriend.GetFriendIDsReq,
+) (resp *pbfriend.GetFriendIDsResp, err error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
 		return nil, err
@@ -7,7 +7,10 @@ import (
 	pbGroup "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
 )

-func (s *groupServer) GetGroupInfoCache(ctx context.Context, req *pbGroup.GetGroupInfoCacheReq) (resp *pbGroup.GetGroupInfoCacheResp, err error) {
+func (s *groupServer) GetGroupInfoCache(
+	ctx context.Context,
+	req *pbGroup.GetGroupInfoCacheReq,
+) (resp *pbGroup.GetGroupInfoCacheResp, err error) {
 	group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
@@ -16,7 +19,10 @@ func (s *groupServer) GetGroupInfoCache(ctx context.Context, req *pbGroup.GetGro
 	return resp, nil
 }

-func (s *groupServer) GetGroupMemberCache(ctx context.Context, req *pbGroup.GetGroupMemberCacheReq) (resp *pbGroup.GetGroupMemberCacheResp, err error) {
+func (s *groupServer) GetGroupMemberCache(
+	ctx context.Context,
+	req *pbGroup.GetGroupMemberCacheReq,
+) (resp *pbGroup.GetGroupMemberCacheResp, err error) {
 	members, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.GroupMemberID)
 	if err != nil {
 		return nil, err
@@ -43,7 +43,13 @@ func CallbackBeforeCreateGroup(ctx context.Context, req *group.CreateGroupReq) (
 		})
 	}
 	resp := &callbackstruct.CallbackBeforeCreateGroupResp{}
-	err = http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeCreateGroup)
+	err = http.CallBackPostReturn(
+		ctx,
+		config.Config.Callback.CallbackUrl,
+		cbReq,
+		resp,
+		config.Config.Callback.CallbackBeforeCreateGroup,
+	)
 	if err != nil {
 		if err == errs.ErrCallbackContinue {
 			return nil
@@ -65,7 +71,11 @@ func CallbackBeforeCreateGroup(ctx context.Context, req *group.CreateGroupReq) (
 	return nil
 }

-func CallbackBeforeMemberJoinGroup(ctx context.Context, groupMember *relation.GroupMemberModel, groupEx string) (err error) {
+func CallbackBeforeMemberJoinGroup(
+	ctx context.Context,
+	groupMember *relation.GroupMemberModel,
+	groupEx string,
+) (err error) {
 	if !config.Config.Callback.CallbackBeforeMemberJoinGroup.Enable {
 		return nil
 	}
@@ -78,7 +88,13 @@ func CallbackBeforeMemberJoinGroup(ctx context.Context, groupMember *relation.Gr
 		GroupEx:         groupEx,
 	}
 	resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{}
-	err = http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeMemberJoinGroup)
+	err = http.CallBackPostReturn(
+		ctx,
+		config.Config.Callback.CallbackUrl,
+		callbackReq,
+		resp,
+		config.Config.Callback.CallbackBeforeMemberJoinGroup,
+	)
 	if err != nil {
 		if err == errs.ErrCallbackContinue {
 			return nil
@@ -118,7 +134,13 @@ func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *group.SetGroupMe
 		callbackReq.Ex = &req.Ex.Value
 	}
 	resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{}
-	err = http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeSetGroupMemberInfo)
+	err = http.CallBackPostReturn(
+		ctx,
+		config.Config.Callback.CallbackUrl,
+		callbackReq,
+		resp,
+		config.Config.Callback.CallbackBeforeSetGroupMemberInfo,
+	)
 	if err != nil {
 		if err == errs.ErrCallbackContinue {
 			return nil
@@ -27,7 +27,10 @@ func (s *groupServer) groupDB2PB(group *relation.GroupModel, ownerUserID string,
 	}
 }

-func (s *groupServer) groupMemberDB2PB(member *relation.GroupMemberModel, appMangerLevel int32) *sdkws.GroupMemberFullInfo {
+func (s *groupServer) groupMemberDB2PB(
+	member *relation.GroupMemberModel,
+	appMangerLevel int32,
+) *sdkws.GroupMemberFullInfo {
 	return &sdkws.GroupMemberFullInfo{
 		GroupID:        member.GroupID,
 		UserID:         member.UserID,
@@ -7,7 +7,12 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 )

-func (s *groupServer) FindGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) ([]*relationTb.GroupMemberModel, error) {
+func (s *groupServer) FindGroupMember(
+	ctx context.Context,
+	groupIDs []string,
+	userIDs []string,
+	roleLevels []int32,
+) ([]*relationTb.GroupMemberModel, error) {
 	members, err := s.GroupDatabase.FindGroupMember(ctx, groupIDs, userIDs, roleLevels)
 	if err != nil {
 		return nil, err
@@ -39,7 +44,11 @@ func (s *groupServer) FindGroupMember(ctx context.Context, groupIDs []string, us
 	return members, nil
 }

-func (s *groupServer) TakeGroupMember(ctx context.Context, groupID string, userID string) (*relationTb.GroupMemberModel, error) {
+func (s *groupServer) TakeGroupMember(
+	ctx context.Context,
+	groupID string,
+	userID string,
+) (*relationTb.GroupMemberModel, error) {
 	member, err := s.GroupDatabase.TakeGroupMember(ctx, groupID, userID)
 	if err != nil {
 		return nil, err
@@ -79,7 +88,11 @@ func (s *groupServer) TakeGroupOwner(ctx context.Context, groupID string) (*rela
 	return owner, nil
 }

-func (s *groupServer) PageGetGroupMember(ctx context.Context, groupID string, pageNumber, showNumber int32) (uint32, []*relationTb.GroupMemberModel, error) {
+func (s *groupServer) PageGetGroupMember(
+	ctx context.Context,
+	groupID string,
+	pageNumber, showNumber int32,
+) (uint32, []*relationTb.GroupMemberModel, error) {
 	total, members, err := s.GroupDatabase.PageGetGroupMember(ctx, groupID, pageNumber, showNumber)
 	if err != nil {
 		return 0, nil, err
@@ -15,6 +15,8 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mw/specialerror"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"

+	"google.golang.org/grpc"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
@@ -29,7 +31,6 @@ import (
 	pbGroup "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"google.golang.org/grpc"
 )

 func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
@@ -55,13 +56,17 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	pbGroup.RegisterGroupServer(server, &groupServer{
 		GroupDatabase: database,
 		User:          userRpcClient,
-		Notification: notification.NewGroupNotificationSender(database, &msgRpcClient, func(ctx context.Context, userIDs []string) ([]notification.CommonUser, error) {
-			users, err := userRpcClient.GetUsersInfo(ctx, userIDs)
-			if err != nil {
-				return nil, err
-			}
-			return utils.Slice(users, func(e *sdkws.UserInfo) notification.CommonUser { return e }), nil
-		}),
+		Notification: notification.NewGroupNotificationSender(
+			database,
+			&msgRpcClient,
+			func(ctx context.Context, userIDs []string) ([]notification.CommonUser, error) {
+				users, err := userRpcClient.GetUsersInfo(ctx, userIDs)
+				if err != nil {
+					return nil, err
+				}
+				return utils.Slice(users, func(e *sdkws.UserInfo) notification.CommonUser { return e }), nil
+			},
+		),
 		conversationRpcClient: conversationRpcClient,
 		msgRpcClient:          msgRpcClient,
 	})
@@ -118,7 +123,16 @@ func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
 		}
 	}
 	for i := 0; i < 10; i++ {
-		id := utils.Md5(strings.Join([]string{mcontext.GetOperationID(ctx), strconv.FormatInt(time.Now().UnixNano(), 10), strconv.Itoa(rand.Int())}, ",;,"))
+		id := utils.Md5(
+			strings.Join(
+				[]string{
+					mcontext.GetOperationID(ctx),
+					strconv.FormatInt(time.Now().UnixNano(), 10),
+					strconv.Itoa(rand.Int()),
+				},
+				",;,",
+			),
+		)
 		bi := big.NewInt(0)
 		bi.SetString(id[0:8], 16)
 		id = bi.String()
@@ -232,7 +246,10 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	return resp, nil
 }

-func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJoinedGroupListReq) (*pbGroup.GetJoinedGroupListResp, error) {
+func (s *groupServer) GetJoinedGroupList(
+	ctx context.Context,
+	req *pbGroup.GetJoinedGroupListReq,
+) (*pbGroup.GetJoinedGroupListResp, error) {
 	resp := &pbGroup.GetJoinedGroupListResp{}
 	if err := tokenverify.CheckAccessV3(ctx, req.FromUserID); err != nil {
 		return nil, err
@@ -242,7 +259,8 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 		pageNumber = req.Pagination.PageNumber
 		showNumber = req.Pagination.ShowNumber
 	}
-	//total, members, err := s.GroupDatabase.PageGroupMember(ctx, nil, []string{req.FromUserID}, nil, pageNumber, showNumber)
+	// total, members, err := s.GroupDatabase.PageGroupMember(ctx, nil, []string{req.FromUserID}, nil, pageNumber,
+	// showNumber)
 	total, members, err := s.GroupDatabase.PageGetJoinGroup(ctx, req.FromUserID, pageNumber, showNumber)
 	if err != nil {
 		return nil, err
@@ -281,7 +299,10 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 	return resp, nil
 }

-func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) {
+func (s *groupServer) InviteUserToGroup(
+	ctx context.Context,
+	req *pbGroup.InviteUserToGroupReq,
+) (*pbGroup.InviteUserToGroupResp, error) {
 	resp := &pbGroup.InviteUserToGroupResp{}
 	if len(req.InvitedUserIDs) == 0 {
 		return nil, errs.ErrArgs.Wrap("user empty")
@@ -382,7 +403,10 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	return resp, nil
 }

-func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGroupAllMemberReq) (*pbGroup.GetGroupAllMemberResp, error) {
+func (s *groupServer) GetGroupAllMember(
+	ctx context.Context,
+	req *pbGroup.GetGroupAllMemberReq,
+) (*pbGroup.GetGroupAllMemberResp, error) {
 	resp := &pbGroup.GetGroupAllMemberResp{}
 	group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
 	if err != nil {
@@ -410,7 +434,10 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
 	return resp, nil
 }

-func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGroupMemberListReq) (*pbGroup.GetGroupMemberListResp, error) {
+func (s *groupServer) GetGroupMemberList(
+	ctx context.Context,
+	req *pbGroup.GetGroupMemberListReq,
+) (*pbGroup.GetGroupMemberListResp, error) {
 	resp := &pbGroup.GetGroupMemberListResp{}
 	total, members, err := s.PageGetGroupMember(ctx, req.GroupID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	log.ZDebug(ctx, "GetGroupMemberList", "total", total, "members", members, "length", len(members))
@@ -423,7 +450,10 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
 	return resp, nil
 }

-func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (*pbGroup.KickGroupMemberResp, error) {
+func (s *groupServer) KickGroupMember(
+	ctx context.Context,
+	req *pbGroup.KickGroupMemberReq,
+) (*pbGroup.KickGroupMemberResp, error) {
 	resp := &pbGroup.KickGroupMemberResp{}
 	group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
 	if err != nil {
@@ -531,7 +561,10 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 	return resp, nil
 }

-func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetGroupMembersInfoReq) (*pbGroup.GetGroupMembersInfoResp, error) {
+func (s *groupServer) GetGroupMembersInfo(
+	ctx context.Context,
+	req *pbGroup.GetGroupMembersInfoReq,
+) (*pbGroup.GetGroupMembersInfoResp, error) {
 	resp := &pbGroup.GetGroupMembersInfoResp{}
 	if len(req.UserIDs) == 0 {
 		return nil, errs.ErrArgs.Wrap("userIDs empty")
@@ -558,7 +591,10 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 	return resp, nil
 }

-func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.GetGroupApplicationListReq) (*pbGroup.GetGroupApplicationListResp, error) {
+func (s *groupServer) GetGroupApplicationList(
+	ctx context.Context,
+	req *pbGroup.GetGroupApplicationListReq,
+) (*pbGroup.GetGroupApplicationListResp, error) {
 	pageNumber, showNumber := utils.GetPage(req.Pagination)

 	groupIDs, err := s.GroupDatabase.FindUserManagedGroupID(ctx, req.FromUserID)
@@ -609,12 +645,19 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 		return e.GroupID
 	})
 	resp.GroupRequests = utils.Slice(groupRequests, func(e *relationTb.GroupRequestModel) *sdkws.GroupRequest {
-		return convert.Db2PbGroupRequest(e, userMap[e.UserID], convert.Db2PbGroupInfo(groupMap[e.GroupID], ownerMap[e.GroupID].UserID, groupMemberNumMap[e.GroupID]))
+		return convert.Db2PbGroupRequest(
+			e,
+			userMap[e.UserID],
+			convert.Db2PbGroupInfo(groupMap[e.GroupID], ownerMap[e.GroupID].UserID, groupMemberNumMap[e.GroupID]),
+		)
 	})
 	return resp, nil
 }

-func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (*pbGroup.GetGroupsInfoResp, error) {
+func (s *groupServer) GetGroupsInfo(
+	ctx context.Context,
+	req *pbGroup.GetGroupsInfoReq,
+) (*pbGroup.GetGroupsInfoResp, error) {
 	resp := &pbGroup.GetGroupsInfoResp{}
 	if len(req.GroupIDs) == 0 {
 		return nil, errs.ErrArgs.Wrap("groupID is empty")
@@ -644,7 +687,10 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
 	return resp, nil
 }

-func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) {
+func (s *groupServer) GroupApplicationResponse(
+	ctx context.Context,
+	req *pbGroup.GroupApplicationResponseReq,
+) (*pbGroup.GroupApplicationResponseResp, error) {
 	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	if !utils.Contain(req.HandleResult, constant.GroupResponseAgree, constant.GroupResponseRefuse) {
 		return nil, errs.ErrArgs.Wrap("HandleResult unknown")
@@ -716,7 +762,10 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 	return &pbGroup.GroupApplicationResponseResp{}, nil
 }

-func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (resp *pbGroup.JoinGroupResp, err error) {
+func (s *groupServer) JoinGroup(
+	ctx context.Context,
+	req *pbGroup.JoinGroupReq,
+) (resp *pbGroup.JoinGroupResp, err error) {
 	defer log.ZInfo(ctx, "JoinGroup.Return")
 	user, err := s.User.GetUserInfo(ctx, req.InviterUserID)
 	if err != nil {
@@ -816,7 +865,10 @@ func (s *groupServer) deleteMemberAndSetConversationSeq(ctx context.Context, gro
 	return s.conversationRpcClient.SetConversationMaxSeq(ctx, userIDs, conevrsationID, maxSeq)
 }

-func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInfoReq) (*pbGroup.SetGroupInfoResp, error) {
+func (s *groupServer) SetGroupInfo(
+	ctx context.Context,
+	req *pbGroup.SetGroupInfoReq,
+) (*pbGroup.SetGroupInfoResp, error) {
 	var opMember *relationTb.GroupMemberModel
 	if !tokenverify.IsAppManagerUid(ctx) {
 		var err error
@@ -866,7 +918,10 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 	var num int
 	if req.GroupInfoForSet.Notification != "" {
 		num++
-		s.Notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser})
+		s.Notification.GroupInfoSetAnnouncementNotification(
+			ctx,
+			&sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser},
+		)

 	}
 	switch len(data) - num {
@@ -883,7 +938,10 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 	return resp, nil
 }

-func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.TransferGroupOwnerReq) (*pbGroup.TransferGroupOwnerResp, error) {
+func (s *groupServer) TransferGroupOwner(
+	ctx context.Context,
+	req *pbGroup.TransferGroupOwnerReq,
+) (*pbGroup.TransferGroupOwnerResp, error) {
 	resp := &pbGroup.TransferGroupOwnerResp{}
 	group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
 	if err != nil {
@@ -962,9 +1020,20 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
 	return resp, nil
 }

-func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGroupMembersCMSReq) (*pbGroup.GetGroupMembersCMSResp, error) {
+func (s *groupServer) GetGroupMembersCMS(
+	ctx context.Context,
+	req *pbGroup.GetGroupMembersCMSReq,
+) (*pbGroup.GetGroupMembersCMSResp, error) {
 	resp := &pbGroup.GetGroupMembersCMSResp{}
-	total, members, err := s.GroupDatabase.SearchGroupMember(ctx, req.UserName, []string{req.GroupID}, nil, nil, req.Pagination.PageNumber, req.Pagination.ShowNumber)
+	total, members, err := s.GroupDatabase.SearchGroupMember(
+		ctx,
+		req.UserName,
+		[]string{req.GroupID},
+		nil,
+		nil,
+		req.Pagination.PageNumber,
+		req.Pagination.ShowNumber,
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -984,7 +1053,10 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
 	return resp, nil
 }

-func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGroup.GetUserReqApplicationListReq) (*pbGroup.GetUserReqApplicationListResp, error) {
+func (s *groupServer) GetUserReqApplicationList(
+	ctx context.Context,
+	req *pbGroup.GetUserReqApplicationListReq,
+) (*pbGroup.GetUserReqApplicationListResp, error) {
 	resp := &pbGroup.GetUserReqApplicationListResp{}
 	user, err := s.User.GetPublicUserInfo(ctx, req.UserID)
 	if err != nil {
@@ -1031,12 +1103,19 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
 		return nil, err
 	}
 	resp.GroupRequests = utils.Slice(requests, func(e *relationTb.GroupRequestModel) *sdkws.GroupRequest {
-		return convert.Db2PbGroupRequest(e, user, convert.Db2PbGroupInfo(groupMap[e.GroupID], ownerMap[e.GroupID].UserID, uint32(groupMemberNum[e.GroupID])))
+		return convert.Db2PbGroupRequest(
+			e,
+			user,
+			convert.Db2PbGroupInfo(groupMap[e.GroupID], ownerMap[e.GroupID].UserID, uint32(groupMemberNum[e.GroupID])),
+		)
 	})
 	return resp, nil
 }

-func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (*pbGroup.DismissGroupResp, error) {
+func (s *groupServer) DismissGroup(
+	ctx context.Context,
+	req *pbGroup.DismissGroupReq,
+) (*pbGroup.DismissGroupResp, error) {
 	defer log.ZInfo(ctx, "DismissGroup.return")
 	resp := &pbGroup.DismissGroupResp{}
 	owner, err := s.TakeGroupOwner(ctx, req.GroupID)
@@ -1085,7 +1164,10 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 	return resp, nil
 }

-func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (*pbGroup.MuteGroupMemberResp, error) {
+func (s *groupServer) MuteGroupMember(
+	ctx context.Context,
+	req *pbGroup.MuteGroupMemberReq,
+) (*pbGroup.MuteGroupMemberResp, error) {
 	resp := &pbGroup.MuteGroupMemberResp{}
 	//if err := tokenverify.CheckAccessV3(ctx, req.UserID); err != nil {
 	//	return nil, err
@@ -1120,7 +1202,10 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
 	return resp, nil
 }

-func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (*pbGroup.CancelMuteGroupMemberResp, error) {
+func (s *groupServer) CancelMuteGroupMember(
+	ctx context.Context,
+	req *pbGroup.CancelMuteGroupMemberReq,
+) (*pbGroup.CancelMuteGroupMemberResp, error) {
 	resp := &pbGroup.CancelMuteGroupMemberResp{}
 	//member, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.UserID)
 	//if err != nil {
@@ -1132,7 +1217,8 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 	//		return nil, err
 	//	}
 	//	if opMember.RoleLevel <= member.RoleLevel {
-	//		return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
+	// 		return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel,
+	// member.RoleLevel))
 	//	}
 	//}
 	//if err := tokenverify.CheckAccessV3(ctx, req.UserID); err != nil {
@@ -1180,7 +1266,10 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq)
 	return resp, nil
 }

-func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (*pbGroup.CancelMuteGroupResp, error) {
+func (s *groupServer) CancelMuteGroup(
+	ctx context.Context,
+	req *pbGroup.CancelMuteGroupReq,
+) (*pbGroup.CancelMuteGroupResp, error) {
 	resp := &pbGroup.CancelMuteGroupResp{}
 	if err := s.CheckGroupAdmin(ctx, req.GroupID); err != nil {
 		return nil, err
@@ -1192,7 +1281,10 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
 	return resp, nil
 }

-func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (*pbGroup.SetGroupMemberInfoResp, error) {
+func (s *groupServer) SetGroupMemberInfo(
+	ctx context.Context,
+	req *pbGroup.SetGroupMemberInfoReq,
+) (*pbGroup.SetGroupMemberInfoResp, error) {
 	resp := &pbGroup.SetGroupMemberInfoResp{}
 	if len(req.Members) == 0 {
 		return nil, errs.ErrArgs.Wrap("members empty")
@@ -1219,9 +1311,11 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 		delete(duplicateMap, [...]string{member.GroupID, member.UserID})
 	}
 	if len(duplicateMap) > 0 {
-		return nil, errs.ErrArgs.Wrap("user not found" + strings.Join(utils.Slice(utils.Keys(duplicateMap), func(e [2]string) string {
-			return fmt.Sprintf("[group: %s user: %s]", e[0], e[1])
-		}), ","))
+		return nil, errs.ErrArgs.Wrap(
+			"user not found" + strings.Join(utils.Slice(utils.Keys(duplicateMap), func(e [2]string) string {
+				return fmt.Sprintf("[group: %s user: %s]", e[0], e[1])
+			}), ","),
+		)
 	}
 	memberMap := utils.SliceToMap(members, func(e *relationTb.GroupMemberModel) [2]string {
 		return [...]string{e.GroupID, e.UserID}
@@ -1251,7 +1345,9 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 			}
 			dbMember, ok := memberMap[[...]string{member.GroupID, member.UserID}]
 			if !ok {
-				return nil, errs.ErrRecordNotFound.Wrap(fmt.Sprintf("user %s not in group %s", member.UserID, member.GroupID))
+				return nil, errs.ErrRecordNotFound.Wrap(
+					fmt.Sprintf("user %s not in group %s", member.UserID, member.GroupID),
+				)
 			}
 			//if opMember.RoleLevel == constant.GroupOwner {
 			//	continue
@@ -1313,14 +1409,25 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 		if member.Nickname != nil || member.FaceURL != nil || member.Ex != nil {
 			log.ZDebug(ctx, "setGroupMemberInfo notification", "member", member.UserID)
 			if err := s.Notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID); err != nil {
-				log.ZError(ctx, "setGroupMemberInfo notification failed", err, "member", member.UserID, "groupID", member.GroupID)
+				log.ZError(
+					ctx,
+					"setGroupMemberInfo notification failed",
+					err,
+					"member",
+					member.UserID,
+					"groupID",
+					member.GroupID,
+				)
 			}
 		}
 	}
 	return resp, nil
 }

-func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.GetGroupAbstractInfoReq) (*pbGroup.GetGroupAbstractInfoResp, error) {
+func (s *groupServer) GetGroupAbstractInfo(
+	ctx context.Context,
+	req *pbGroup.GetGroupAbstractInfoReq,
+) (*pbGroup.GetGroupAbstractInfoResp, error) {
 	resp := &pbGroup.GetGroupAbstractInfoResp{}
 	if len(req.GroupIDs) == 0 {
 		return nil, errs.ErrArgs.Wrap("groupIDs empty")
@@ -1351,7 +1458,10 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
 	return resp, nil
 }

-func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.GetUserInGroupMembersReq) (*pbGroup.GetUserInGroupMembersResp, error) {
+func (s *groupServer) GetUserInGroupMembers(
+	ctx context.Context,
+	req *pbGroup.GetUserInGroupMembersReq,
+) (*pbGroup.GetUserInGroupMembersResp, error) {
 	resp := &pbGroup.GetUserInGroupMembersResp{}
 	if len(req.GroupIDs) == 0 {
 		return nil, errs.ErrArgs.Wrap("groupIDs empty")
@@ -1375,7 +1485,10 @@ func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.Ge
 	return resp, nil
 }

-func (s *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbGroup.GetGroupMemberUserIDsReq) (resp *pbGroup.GetGroupMemberUserIDsResp, err error) {
+func (s *groupServer) GetGroupMemberUserIDs(
+	ctx context.Context,
+	req *pbGroup.GetGroupMemberUserIDsReq,
+) (resp *pbGroup.GetGroupMemberUserIDsResp, err error) {
 	resp = &pbGroup.GetGroupMemberUserIDsResp{}
 	resp.UserIDs, err = s.GroupDatabase.FindGroupMemberUserID(ctx, req.GroupID)
 	if err != nil {
@@ -1384,7 +1497,10 @@ func (s *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbGroup.Ge
 	return resp, nil
 }

-func (s *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbGroup.GetGroupMemberRoleLevelReq) (*pbGroup.GetGroupMemberRoleLevelResp, error) {
+func (s *groupServer) GetGroupMemberRoleLevel(
+	ctx context.Context,
+	req *pbGroup.GetGroupMemberRoleLevelReq,
+) (*pbGroup.GetGroupMemberRoleLevelResp, error) {
 	resp := &pbGroup.GetGroupMemberRoleLevelResp{}
 	if len(req.RoleLevels) == 0 {
 		return nil, errs.ErrArgs.Wrap("RoleLevels empty")
@@ -15,7 +15,10 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 )

-func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.GetJoinedSuperGroupListReq) (*pbGroup.GetJoinedSuperGroupListResp, error) {
+func (s *groupServer) GetJoinedSuperGroupList(
+	ctx context.Context,
+	req *pbGroup.GetJoinedSuperGroupListReq,
+) (*pbGroup.GetJoinedSuperGroupListResp, error) {
 	resp := &pbGroup.GetJoinedSuperGroupListResp{}
 	groupIDs, err := s.GroupDatabase.FindJoinSuperGroup(ctx, req.UserID)
 	if err != nil {
@@ -48,16 +51,22 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
 	if err != nil {
 		return nil, err
 	}
-	superGroupMemberMap := utils.SliceToMapAny(superGroupMembers, func(e *unrelation.SuperGroupModel) (string, []string) {
-		return e.GroupID, e.MemberIDs
-	})
+	superGroupMemberMap := utils.SliceToMapAny(
+		superGroupMembers,
+		func(e *unrelation.SuperGroupModel) (string, []string) {
+			return e.GroupID, e.MemberIDs
+		},
+	)
 	resp.Groups = utils.Slice(groupIDs, func(groupID string) *sdkws.GroupInfo {
 		return convert.Db2PbGroupInfo(groupMap[groupID], ownerMap[groupID].UserID, uint32(len(superGroupMemberMap)))
 	})
 	return resp, nil
 }

-func (s *groupServer) GetSuperGroupsInfo(ctx context.Context, req *pbGroup.GetSuperGroupsInfoReq) (resp *pbGroup.GetSuperGroupsInfoResp, err error) {
+func (s *groupServer) GetSuperGroupsInfo(
+	ctx context.Context,
+	req *pbGroup.GetSuperGroupsInfoReq,
+) (resp *pbGroup.GetSuperGroupsInfoResp, err error) {
 	resp = &pbGroup.GetSuperGroupsInfoResp{}
 	if len(req.GroupIDs) == 0 {
 		return nil, errs.ErrArgs.Wrap("groupIDs empty")
@@ -70,9 +79,12 @@ func (s *groupServer) GetSuperGroupsInfo(ctx context.Context, req *pbGroup.GetSu
 	if err != nil {
 		return nil, err
 	}
-	superGroupMemberMap := utils.SliceToMapAny(superGroupMembers, func(e *unrelation.SuperGroupModel) (string, []string) {
-		return e.GroupID, e.MemberIDs
-	})
+	superGroupMemberMap := utils.SliceToMapAny(
+		superGroupMembers,
+		func(e *unrelation.SuperGroupModel) (string, []string) {
+			return e.GroupID, e.MemberIDs
+		},
+	)
 	owners, err := s.FindGroupMember(ctx, req.GroupIDs, nil, []int32{constant.GroupOwner})
 	if err != nil {
 		return nil, err
@@ -3,15 +3,19 @@ package msg
 import (
 	"context"

+	"github.com/redis/go-redis/v9"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-	"github.com/redis/go-redis/v9"
 )

-func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *msg.GetConversationsHasReadAndMaxSeqReq) (*msg.GetConversationsHasReadAndMaxSeqResp, error) {
+func (m *msgServer) GetConversationsHasReadAndMaxSeq(
+	ctx context.Context,
+	req *msg.GetConversationsHasReadAndMaxSeqReq,
+) (*msg.GetConversationsHasReadAndMaxSeqResp, error) {
 	conversationIDs, err := m.ConversationLocalCache.GetConversationIDs(ctx, req.UserID)
 	if err != nil {
 		return nil, err
@@ -47,7 +51,10 @@ func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *m
 	return resp, nil
 }

-func (m *msgServer) SetConversationHasReadSeq(ctx context.Context, req *msg.SetConversationHasReadSeqReq) (resp *msg.SetConversationHasReadSeqResp, err error) {
+func (m *msgServer) SetConversationHasReadSeq(
+	ctx context.Context,
+	req *msg.SetConversationHasReadSeqReq,
+) (resp *msg.SetConversationHasReadSeqResp, err error) {
 	maxSeq, err := m.MsgDatabase.GetMaxSeq(ctx, req.ConversationID)
 	if err != nil {
 		return
@@ -64,7 +71,10 @@ func (m *msgServer) SetConversationHasReadSeq(ctx context.Context, req *msg.SetC
 	return &msg.SetConversationHasReadSeqResp{}, nil
 }

-func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadReq) (resp *msg.MarkMsgsAsReadResp, err error) {
+func (m *msgServer) MarkMsgsAsRead(
+	ctx context.Context,
+	req *msg.MarkMsgsAsReadReq,
+) (resp *msg.MarkMsgsAsReadResp, err error) {
 	if len(req.Seqs) < 1 {
 		return nil, errs.ErrArgs.Wrap("seqs must not be empty")
 	}
@@ -99,7 +109,10 @@ func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadR
 	return &msg.MarkMsgsAsReadResp{}, nil
 }

-func (m *msgServer) MarkConversationAsRead(ctx context.Context, req *msg.MarkConversationAsReadReq) (resp *msg.MarkConversationAsReadResp, err error) {
+func (m *msgServer) MarkConversationAsRead(
+	ctx context.Context,
+	req *msg.MarkConversationAsReadReq,
+) (resp *msg.MarkConversationAsReadResp, err error) {
 	conversation, err := m.Conversation.GetConversation(ctx, req.UserID, req.ConversationID)
 	if err != nil {
 		return
@@ -136,7 +149,14 @@ func (m *msgServer) MarkConversationAsRead(ctx context.Context, req *msg.MarkCon
 	return &msg.MarkConversationAsReadResp{}, nil
 }

-func (m *msgServer) sendMarkAsReadNotification(ctx context.Context, conversationID string, sesstionType int32, sendID, recvID string, seqs []int64, hasReadSeq int64) error {
+func (m *msgServer) sendMarkAsReadNotification(
+	ctx context.Context,
+	conversationID string,
+	sesstionType int32,
+	sendID, recvID string,
+	seqs []int64,
+	hasReadSeq int64,
+) error {
 	tips := &sdkws.MarkAsReadTips{
 		MarkAsReadUserID: sendID,
 		ConversationID:   conversationID,
@@ -27,7 +27,10 @@ func (m *msgServer) validateDeleteSyncOpt(opt *msg.DeleteSyncOpt) (isSyncSelf, i
 	return opt.IsSyncSelf, opt.IsSyncOther
 }

-func (m *msgServer) ClearConversationsMsg(ctx context.Context, req *msg.ClearConversationsMsgReq) (*msg.ClearConversationsMsgResp, error) {
+func (m *msgServer) ClearConversationsMsg(
+	ctx context.Context,
+	req *msg.ClearConversationsMsgReq,
+) (*msg.ClearConversationsMsgResp, error) {
 	if err := tokenverify.CheckAccessV3(ctx, req.UserID); err != nil {
 		return nil, err
 	}
@@ -37,7 +40,10 @@ func (m *msgServer) ClearConversationsMsg(ctx context.Context, req *msg.ClearCon
 	return &msg.ClearConversationsMsgResp{}, nil
 }

-func (m *msgServer) UserClearAllMsg(ctx context.Context, req *msg.UserClearAllMsgReq) (*msg.UserClearAllMsgResp, error) {
+func (m *msgServer) UserClearAllMsg(
+	ctx context.Context,
+	req *msg.UserClearAllMsgReq,
+) (*msg.UserClearAllMsgResp, error) {
 	if err := tokenverify.CheckAccessV3(ctx, req.UserID); err != nil {
 		return nil, err
 	}
@@ -66,7 +72,14 @@ func (m *msgServer) DeleteMsgs(ctx context.Context, req *msg.DeleteMsgsReq) (*ms
 			return nil, err
 		}
 		tips := &sdkws.DeleteMsgsTips{UserID: req.UserID, ConversationID: req.ConversationID, Seqs: req.Seqs}
-		m.notificationSender.NotificationWithSesstionType(ctx, req.UserID, m.conversationAndGetRecvID(conversations[0], req.UserID), constant.DeleteMsgsNotification, conversations[0].ConversationType, tips)
+		m.notificationSender.NotificationWithSesstionType(
+			ctx,
+			req.UserID,
+			m.conversationAndGetRecvID(conversations[0], req.UserID),
+			constant.DeleteMsgsNotification,
+			conversations[0].ConversationType,
+			tips,
+		)
 	} else {
 		if err := m.MsgDatabase.DeleteUserMsgsBySeqs(ctx, req.UserID, req.ConversationID, req.Seqs); err != nil {
 			return nil, err
@@ -79,7 +92,10 @@ func (m *msgServer) DeleteMsgs(ctx context.Context, req *msg.DeleteMsgsReq) (*ms
 	return &msg.DeleteMsgsResp{}, nil
 }

-func (m *msgServer) DeleteMsgPhysicalBySeq(ctx context.Context, req *msg.DeleteMsgPhysicalBySeqReq) (*msg.DeleteMsgPhysicalBySeqResp, error) {
+func (m *msgServer) DeleteMsgPhysicalBySeq(
+	ctx context.Context,
+	req *msg.DeleteMsgPhysicalBySeqReq,
+) (*msg.DeleteMsgPhysicalBySeqResp, error) {
 	err := m.MsgDatabase.DeleteMsgsPhysicalBySeqs(ctx, req.ConversationID, req.Seqs)
 	if err != nil {
 		return nil, err
@@ -87,20 +103,36 @@ func (m *msgServer) DeleteMsgPhysicalBySeq(ctx context.Context, req *msg.DeleteM
 	return &msg.DeleteMsgPhysicalBySeqResp{}, nil
 }

-func (m *msgServer) DeleteMsgPhysical(ctx context.Context, req *msg.DeleteMsgPhysicalReq) (*msg.DeleteMsgPhysicalResp, error) {
+func (m *msgServer) DeleteMsgPhysical(
+	ctx context.Context,
+	req *msg.DeleteMsgPhysicalReq,
+) (*msg.DeleteMsgPhysicalResp, error) {
 	if err := tokenverify.CheckAdmin(ctx); err != nil {
 		return nil, err
 	}
 	remainTime := utils.GetCurrentTimestampBySecond() - req.Timestamp
 	for _, conversationID := range req.ConversationIDs {
 		if err := m.MsgDatabase.DeleteConversationMsgsAndSetMinSeq(ctx, conversationID, remainTime); err != nil {
-			log.ZWarn(ctx, "DeleteConversationMsgsAndSetMinSeq error", err, "conversationID", conversationID, "err", err)
+			log.ZWarn(
+				ctx,
+				"DeleteConversationMsgsAndSetMinSeq error",
+				err,
+				"conversationID",
+				conversationID,
+				"err",
+				err,
+			)
 		}
 	}
 	return &msg.DeleteMsgPhysicalResp{}, nil
 }

-func (m *msgServer) clearConversation(ctx context.Context, conversationIDs []string, userID string, deleteSyncOpt *msg.DeleteSyncOpt) error {
+func (m *msgServer) clearConversation(
+	ctx context.Context,
+	conversationIDs []string,
+	userID string,
+	deleteSyncOpt *msg.DeleteSyncOpt,
+) error {
 	defer log.ZDebug(ctx, "clearConversation return line")
 	conversations, err := m.Conversation.GetConversationsByConversationID(ctx, conversationIDs)
 	if err != nil {
@@ -125,7 +157,14 @@ func (m *msgServer) clearConversation(ctx context.Context, conversationIDs []str
 		// notification 2 self
 		if isSyncSelf {
 			tips := &sdkws.ClearConversationTips{UserID: userID, ConversationIDs: existConversationIDs}
-			m.notificationSender.NotificationWithSesstionType(ctx, userID, userID, constant.ClearConversationNotification, constant.SingleChatType, tips)
+			m.notificationSender.NotificationWithSesstionType(
+				ctx,
+				userID,
+				userID,
+				constant.ClearConversationNotification,
+				constant.SingleChatType,
+				tips,
+			)
 		}
 	} else {
 		if err := m.MsgDatabase.SetMinSeqs(ctx, m.getMinSeqs(maxSeqs)); err != nil {
@@ -7,7 +7,10 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 )

-func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.SetMessageReactionExtensionsReq) (resp *msg.SetMessageReactionExtensionsResp, err error) {
+func (m *msgServer) SetMessageReactionExtensions(
+	ctx context.Context,
+	req *msg.SetMessageReactionExtensionsReq,
+) (resp *msg.SetMessageReactionExtensionsResp, err error) {
 	//resp = &msg.SetMessageReactionExtensionsResp{}
 	////resp.ClientMsgID = req.ClientMsgID
 	////resp.MsgFirstModifyTime = req.MsgFirstModifyTime
@@ -18,7 +21,8 @@ func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	////if ExternalExtension
 	//if req.IsExternalExtensions {
 	//	resp.MsgFirstModifyTime = req.MsgFirstModifyTime
-	//	notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &resp, !req.IsReact, false)
+	// 	notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID,
+	// req.SessionType, req, &resp, !req.IsReact, false)
 	//	return resp, nil
 	//}
 	//isExists, err := m.MsgDatabase.JudgeMessageReactionExist(ctx, req.ClientMsgID, req.SessionType)
@@ -35,12 +39,14 @@ func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	//				return nil, err
 	//			}
 	//			v.LatestUpdateTime = utils.GetCurrentTimestampByMill()
-	//			if err := m.MsgDatabase.SetMessageTypeKeyValue(ctx, req.ClientMsgID, req.SessionType, k, utils.StructToJsonString(v)); err != nil {
+	// 			if err := m.MsgDatabase.SetMessageTypeKeyValue(ctx, req.ClientMsgID, req.SessionType, k,
+	// utils.StructToJsonString(v)); err != nil {
 	//				return nil, err
 	//			}
 	//		}
 	//		resp.IsReact = true
-	//		_, err := m.MsgDatabase.SetMessageReactionExpire(ctx, req.ClientMsgID, req.SessionType, time.Duration(24*3)*time.Hour)
+	// 		_, err := m.MsgDatabase.SetMessageReactionExpire(ctx, req.ClientMsgID, req.SessionType,
+	// time.Duration(24*3)*time.Hour)
 	//		if err != nil {
 	//			return nil, err
 	//		}
@@ -49,7 +55,8 @@ func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	//		if err != nil {
 	//			return nil, err
 	//		}
-	//		mongoValue, err := m.MsgDatabase.GetExtendMsg(ctx, req.conversationID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime)
+	// 		mongoValue, err := m.MsgDatabase.GetExtendMsg(ctx, req.conversationID, req.SessionType, req.ClientMsgID,
+	// req.MsgFirstModifyTime)
 	//		if err != nil {
 	//			return nil, err
 	//		}
@@ -69,7 +76,8 @@ func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	//			temp.LatestUpdateTime = utils.GetCurrentTimestampByMill()
 	//			setValue[k] = temp
 	//		}
-	//		err = db.DB.InsertOrUpdateReactionExtendMsgSet(req.conversationID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime, setValue)
+	// 		err = db.DB.InsertOrUpdateReactionExtendMsgSet(req.conversationID, req.SessionType, req.ClientMsgID,
+	// req.MsgFirstModifyTime, setValue)
 	//		if err != nil {
 	//			for _, value := range setValue {
 	//				temp := new(msg.KeyValueResp)
@@ -112,7 +120,7 @@ func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	//			continue
 	//		} else {
 	//			v.LatestUpdateTime = utils.GetCurrentTimestampByMill()
-	//			newerr := db.DB.SetMessageTypeKeyValue(req.ClientMsgID, req.SessionType, k, utils.StructToJsonString(v))
+	// 			newerr := db.DB.SetMessageTypeKeyValue(req.ClientMsgID, req.SessionType, k, utils.StructToJsonString(v))
 	//			if newerr != nil {
 	//				setKeyResultInfo(&resp, 201, newerr.Error(), req.ClientMsgID, k, temp)
 	//				continue
@@ -124,26 +132,28 @@ func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	//}
 	//if !isExists {
 	//	if !req.IsReact {
-	//		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &resp, true, true)
+	// 		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID,
+	// req.SessionType, req, &resp, true, true)
 	//	} else {
-	//		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &resp, false, false)
+	// 		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID,
+	// req.SessionType, req, &resp, false, false)
 	//	}
 	//} else {
-	//	notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &resp, false, true)
+	// 	notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID,
+	// req.SessionType, req, &resp, false, true)
 	//}
 	//log.Debug(req.OperationID, utils.GetSelfFuncName(), "m return is:", resp.String())
 	return resp, nil

 }
-func (m *msgServer) setKeyResultInfo(ctx context.Context, r *msg.SetMessageReactionExtensionsResp, errCode int32, errMsg, clientMsgID, typeKey string, keyValue *sdkws.KeyValue) {
-	temp := new(msg.KeyValueResp)
-	temp.KeyValue = keyValue
-	temp.ErrCode = errCode
-	temp.ErrMsg = errMsg
-	r.Result = append(r.Result, temp)
-	_ = m.MessageLocker.UnLockMessageTypeKey(ctx, clientMsgID, typeKey)
-}
-func (m *msgServer) setDeleteKeyResultInfo(ctx context.Context, r *msg.DeleteMessagesReactionExtensionsResp, errCode int32, errMsg, clientMsgID, typeKey string, keyValue *sdkws.KeyValue) {
+
+func (m *msgServer) setKeyResultInfo(
+	ctx context.Context,
+	r *msg.SetMessageReactionExtensionsResp,
+	errCode int32,
+	errMsg, clientMsgID, typeKey string,
+	keyValue *sdkws.KeyValue,
+) {
 	temp := new(msg.KeyValueResp)
 	temp.KeyValue = keyValue
 	temp.ErrCode = errCode
@@ -152,7 +162,25 @@ func (m *msgServer) setDeleteKeyResultInfo(ctx context.Context, r *msg.DeleteMes
 	_ = m.MessageLocker.UnLockMessageTypeKey(ctx, clientMsgID, typeKey)
 }

-func (m *msgServer) GetMessagesReactionExtensions(ctx context.Context, req *msg.GetMessagesReactionExtensionsReq) (resp *msg.GetMessagesReactionExtensionsResp, err error) {
+func (m *msgServer) setDeleteKeyResultInfo(
+	ctx context.Context,
+	r *msg.DeleteMessagesReactionExtensionsResp,
+	errCode int32,
+	errMsg, clientMsgID, typeKey string,
+	keyValue *sdkws.KeyValue,
+) {
+	temp := new(msg.KeyValueResp)
+	temp.KeyValue = keyValue
+	temp.ErrCode = errCode
+	temp.ErrMsg = errMsg
+	r.Result = append(r.Result, temp)
+	_ = m.MessageLocker.UnLockMessageTypeKey(ctx, clientMsgID, typeKey)
+}
+
+func (m *msgServer) GetMessagesReactionExtensions(
+	ctx context.Context,
+	req *msg.GetMessagesReactionExtensionsReq,
+) (resp *msg.GetMessagesReactionExtensionsResp, err error) {
 	//log.Debug(req.OperationID, utils.GetSelfFuncName(), "m args is:", req.String())
 	//var rResp msg.GetMessageListReactionExtensionsResp
 	//for _, messageValue := range req.MessageReactionKeyList {
@@ -183,7 +211,8 @@ func (m *msgServer) GetMessagesReactionExtensions(ctx context.Context, req *msg.
 	//		oneMessage.Pb2Model = keyMap
 	//
 	//	} else {
-	//		mongoValue, err := db.DB.GetExtendMsg(req.conversationID, req.SessionType, messageValue.ClientMsgID, messageValue.MsgFirstModifyTime)
+	// 		mongoValue, err := db.DB.GetExtendMsg(req.conversationID, req.SessionType, messageValue.ClientMsgID,
+	// messageValue.MsgFirstModifyTime)
 	//		if err != nil {
 	//			oneMessage.ErrCode = 100
 	//			oneMessage.ErrMsg = err.Error()
@@ -208,11 +237,17 @@ func (m *msgServer) GetMessagesReactionExtensions(ctx context.Context, req *msg.

 }

-func (m *msgServer) AddMessageReactionExtensions(ctx context.Context, req *msg.ModifyMessageReactionExtensionsReq) (resp *msg.ModifyMessageReactionExtensionsResp, err error) {
+func (m *msgServer) AddMessageReactionExtensions(
+	ctx context.Context,
+	req *msg.ModifyMessageReactionExtensionsReq,
+) (resp *msg.ModifyMessageReactionExtensionsResp, err error) {
 	return
 }

-func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *msg.DeleteMessagesReactionExtensionsReq) (resp *msg.DeleteMessagesReactionExtensionsResp, err error) {
+func (m *msgServer) DeleteMessageReactionExtensions(
+	ctx context.Context,
+	req *msg.DeleteMessagesReactionExtensionsReq,
+) (resp *msg.DeleteMessagesReactionExtensionsResp, err error) {
 	//log.Debug(req.OperationID, utils.GetSelfFuncName(), "m args is:", req.String())
 	//var rResp msg.DeleteMessagesReactionExtensionsResp
 	//callbackResp := notification.callbackDeleteMessageReactionExtensions(req)
@@ -231,7 +266,8 @@ func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	////if ExternalExtension
 	//if req.IsExternalExtensions {
 	//	rResp.Result = callbackResp.ResultReactionExtensionList
-	//	notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &rResp, false, false)
+	// 	notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType,
+	// req, &rResp, false, false)
 	//	return &rResp, nil
 	//
 	//}
@@ -303,7 +339,8 @@ func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	//		}
 	//		return &rResp, nil
 	//	}
-	//	mongoValue, err := db.DB.GetExtendMsg(req.conversationID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime)
+	// 	mongoValue, err := db.DB.GetExtendMsg(req.conversationID, req.SessionType, req.ClientMsgID,
+	// req.MsgFirstModifyTime)
 	//	if err != nil {
 	//		rResp.ErrCode = 200
 	//		rResp.ErrMsg = err.Error()
@@ -333,7 +370,8 @@ func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	//		temp.TypeKey = v.TypeKey
 	//		setValue[v.TypeKey] = temp
 	//	}
-	//	err = db.DB.DeleteReactionExtendMsgSet(req.conversationID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime, setValue)
+	// 	err = db.DB.DeleteReactionExtendMsgSet(req.conversationID, req.SessionType, req.ClientMsgID,
+	// req.MsgFirstModifyTime, setValue)
 	//	if err != nil {
 	//		for _, value := range setValue {
 	//			temp := new(msg.KeyValueResp)
@@ -355,7 +393,8 @@ func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	//	}
 	//
 	//}
-	//notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &rResp, false, isExists)
+	// notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType,
+	// req, &rResp, false, isExists)
 	//log.Debug(req.OperationID, utils.GetSelfFuncName(), "m return is:", rResp.String())
 	return resp, nil
 }
@@ -35,7 +35,10 @@ func callbackSetMessageReactionExtensions(ctx context.Context, setReq *msg.SetMe
 	return nil
 }

-func callbackDeleteMessageReactionExtensions(ctx context.Context, setReq *msg.DeleteMessagesReactionExtensionsReq) error {
+func callbackDeleteMessageReactionExtensions(
+	ctx context.Context,
+	setReq *msg.DeleteMessagesReactionExtensionsReq,
+) error {
 	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
 		return nil
 	}
@@ -8,7 +8,10 @@ import (
 	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 )

-func (m *msgServer) SetSendMsgStatus(ctx context.Context, req *pbMsg.SetSendMsgStatusReq) (*pbMsg.SetSendMsgStatusResp, error) {
+func (m *msgServer) SetSendMsgStatus(
+	ctx context.Context,
+	req *pbMsg.SetSendMsgStatusReq,
+) (*pbMsg.SetSendMsgStatusResp, error) {
 	resp := &pbMsg.SetSendMsgStatusResp{}
 	if err := m.MsgDatabase.SetSendMsgStatus(ctx, mcontext.GetOperationID(ctx), req.Status); err != nil {
 		return nil, err
@@ -16,7 +19,10 @@ func (m *msgServer) SetSendMsgStatus(ctx context.Context, req *pbMsg.SetSendMsgS
 	return resp, nil
 }

-func (m *msgServer) GetSendMsgStatus(ctx context.Context, req *pbMsg.GetSendMsgStatusReq) (*pbMsg.GetSendMsgStatusResp, error) {
+func (m *msgServer) GetSendMsgStatus(
+	ctx context.Context,
+	req *pbMsg.GetSendMsgStatusReq,
+) (*pbMsg.GetSendMsgStatusResp, error) {
 	resp := &pbMsg.GetSendMsgStatusResp{}
 	status, err := m.MsgDatabase.GetSendMsgStatus(ctx, mcontext.GetOperationID(ctx))
 	if IsNotFound(err) {
@@ -56,7 +56,12 @@ func (m *msgServer) RevokeMsg(ctx context.Context, req *msg.RevokeMsgReq) (*msg.
 			}
 			role = user.AppMangerLevel
 		case constant.SuperGroupChatType:
-			members, err := m.Group.GetGroupMemberInfoMap(ctx, msgs[0].GroupID, utils.Distinct([]string{req.UserID, msgs[0].SendID}), true)
+			members, err := m.Group.GetGroupMemberInfoMap(
+				ctx,
+				msgs[0].GroupID,
+				utils.Distinct([]string{req.UserID, msgs[0].SendID}),
+				true,
+			)
 			if err != nil {
 				return nil, err
 			}
@@ -34,7 +34,10 @@ func (m *msgServer) SendMsg(ctx context.Context, req *pbMsg.SendMsgReq) (resp *p
 	}
 }

-func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *pbMsg.SendMsgReq) (resp *pbMsg.SendMsgResp, err error) {
+func (m *msgServer) sendMsgSuperGroupChat(
+	ctx context.Context,
+	req *pbMsg.SendMsgReq,
+) (resp *pbMsg.SendMsgResp, err error) {
 	promePkg.Inc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter)
 	if err = m.messageVerification(ctx, req); err != nil {
 		promePkg.Inc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
@@ -105,7 +108,10 @@ func (m *msgServer) setConversationAtInfo(nctx context.Context, msg *sdkws.MsgDa

 }

-func (m *msgServer) sendMsgNotification(ctx context.Context, req *pbMsg.SendMsgReq) (resp *pbMsg.SendMsgResp, err error) {
+func (m *msgServer) sendMsgNotification(
+	ctx context.Context,
+	req *pbMsg.SendMsgReq,
+) (resp *pbMsg.SendMsgResp, err error) {
 	promePkg.Inc(promePkg.SingleChatMsgRecvSuccessCounter)
 	if err := m.MsgDatabase.MsgToMQ(ctx, utils.GenConversationUniqueKeyForSingle(req.MsgData.SendID, req.MsgData.RecvID), req.MsgData); err != nil {
 		promePkg.Inc(promePkg.SingleChatMsgProcessFailedCounter)
@@ -127,7 +133,13 @@ func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *pbMsg.SendMsgReq
 	var isSend bool = true
 	isNotification := utils.IsNotificationByMsg(req.MsgData)
 	if !isNotification {
-		isSend, err = m.modifyMessageByUserMessageReceiveOpt(ctx, req.MsgData.RecvID, utils.GenConversationIDForSingle(req.MsgData.SendID, req.MsgData.RecvID), constant.SingleChatType, req)
+		isSend, err = m.modifyMessageByUserMessageReceiveOpt(
+			ctx,
+			req.MsgData.RecvID,
+			utils.GenConversationIDForSingle(req.MsgData.SendID, req.MsgData.RecvID),
+			constant.SingleChatType,
+			req,
+		)
 		if err != nil {
 			return nil, err
 		}
@@ -6,7 +6,10 @@ import (
 	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 )

-func (m *msgServer) GetConversationMaxSeq(ctx context.Context, req *pbMsg.GetConversationMaxSeqReq) (resp *pbMsg.GetConversationMaxSeqResp, err error) {
+func (m *msgServer) GetConversationMaxSeq(
+	ctx context.Context,
+	req *pbMsg.GetConversationMaxSeqReq,
+) (resp *pbMsg.GetConversationMaxSeqResp, err error) {
 	maxSeq, err := m.MsgDatabase.GetMaxSeq(ctx, req.ConversationID)
 	if err != nil {
 		return nil, err
@@ -3,6 +3,8 @@ package msg
 import (
 	"context"

+	"google.golang.org/grpc"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
@@ -14,7 +16,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
-	"google.golang.org/grpc"
 )

 type MessageInterceptorChain []MessageInterceptorFunc
@@ -64,7 +65,11 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	msgDocModel := unrelation.NewMsgMongoDriver(mongo.GetDatabase())
 	extendMsgModel := unrelation.NewExtendMsgSetMongoDriver(mongo.GetDatabase())
 	extendMsgCacheModel := cache.NewExtendMsgSetCacheRedis(rdb, extendMsgModel, cache.GetDefaultOpt())
-	extendMsgDatabase := controller.NewExtendMsgDatabase(extendMsgModel, extendMsgCacheModel, tx.NewMongo(mongo.GetClient()))
+	extendMsgDatabase := controller.NewExtendMsgDatabase(
+		extendMsgModel,
+		extendMsgCacheModel,
+		tx.NewMongo(mongo.GetClient()),
+	)
 	msgDatabase := controller.NewCommonMsgDatabase(msgDocModel, cacheModel)
 	conversationClient := rpcclient.NewConversationRpcClient(client)
 	userRpcClient := rpcclient.NewUserRpcClient(client)
@@ -106,7 +111,8 @@ func (m *msgServer) initPrometheus() {
 }

 func (m *msgServer) conversationAndGetRecvID(conversation *conversation.Conversation, userID string) (recvID string) {
-	if conversation.ConversationType == constant.SingleChatType || conversation.ConversationType == constant.NotificationChatType {
+	if conversation.ConversationType == constant.SingleChatType ||
+		conversation.ConversationType == constant.NotificationChatType {
 		if userID == conversation.OwnerUserID {
 			recvID = conversation.UserID
 		} else {
@@ -9,7 +9,10 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 )

-func (m *msgServer) PullMessageBySeqs(ctx context.Context, req *sdkws.PullMessageBySeqsReq) (*sdkws.PullMessageBySeqsResp, error) {
+func (m *msgServer) PullMessageBySeqs(
+	ctx context.Context,
+	req *sdkws.PullMessageBySeqsReq,
+) (*sdkws.PullMessageBySeqsResp, error) {
 	resp := &sdkws.PullMessageBySeqsResp{}
 	resp.Msgs = make(map[string]*sdkws.PullMsgs)
 	resp.NotificationMsgs = make(map[string]*sdkws.PullMsgs)
@@ -20,7 +23,15 @@ func (m *msgServer) PullMessageBySeqs(ctx context.Context, req *sdkws.PullMessag
 				log.ZError(ctx, "GetConversation error", err, "conversationID", seq.ConversationID)
 				continue
 			}
-			minSeq, maxSeq, msgs, err := m.MsgDatabase.GetMsgBySeqsRange(ctx, req.UserID, seq.ConversationID, seq.Begin, seq.End, seq.Num, conversation.MaxSeq)
+			minSeq, maxSeq, msgs, err := m.MsgDatabase.GetMsgBySeqsRange(
+				ctx,
+				req.UserID,
+				seq.ConversationID,
+				seq.Begin,
+				seq.End,
+				seq.Num,
+				conversation.MaxSeq,
+			)
 			if err != nil {
 				log.ZWarn(ctx, "GetMsgBySeqsRange error", err, "conversationID", seq.ConversationID, "seq", seq)
 				continue
@@ -1,12 +1,13 @@
 package msg

 import (
+	"github.com/redis/go-redis/v9"
+	"gorm.io/gorm"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"github.com/redis/go-redis/v9"
-	"gorm.io/gorm"
 )

 func isMessageHasReadEnabled(msgData *sdkws.MsgData) bool {
@@ -41,7 +41,8 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 		if utils.IsContain(data.MsgData.SendID, config.Config.Manager.UserID) {
 			return nil
 		}
-		if data.MsgData.ContentType <= constant.NotificationEnd && data.MsgData.ContentType >= constant.NotificationBegin {
+		if data.MsgData.ContentType <= constant.NotificationEnd &&
+			data.MsgData.ContentType >= constant.NotificationBegin {
 			return nil
 		}
 		black, err := m.friend.IsBlocked(ctx, data.MsgData.SendID, data.MsgData.RecvID)
@@ -67,7 +68,8 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 		if err != nil {
 			return err
 		}
-		if groupInfo.Status == constant.GroupStatusDismissed && data.MsgData.ContentType != constant.GroupDismissedNotification {
+		if groupInfo.Status == constant.GroupStatusDismissed &&
+			data.MsgData.ContentType != constant.GroupDismissedNotification {
 			return errs.ErrDismissedAlready.Wrap()
 		}
 		if groupInfo.GroupType == constant.SuperGroup {
@@ -76,7 +78,8 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 		if utils.IsContain(data.MsgData.SendID, config.Config.Manager.UserID) {
 			return nil
 		}
-		if data.MsgData.ContentType <= constant.NotificationEnd && data.MsgData.ContentType >= constant.NotificationBegin {
+		if data.MsgData.ContentType <= constant.NotificationEnd &&
+			data.MsgData.ContentType >= constant.NotificationBegin {
 			return nil
 		}
 		// memberIDs, err := m.GroupLocalCache.GetGroupMemberIDs(ctx, data.MsgData.GroupID)
@@ -161,7 +164,12 @@ func GetMsgID(sendID string) string {
 	return utils.Md5(t + "-" + sendID + "-" + strconv.Itoa(rand.Int()))
 }

-func (m *msgServer) modifyMessageByUserMessageReceiveOpt(ctx context.Context, userID, conversationID string, sessionType int, pb *msg.SendMsgReq) (bool, error) {
+func (m *msgServer) modifyMessageByUserMessageReceiveOpt(
+	ctx context.Context,
+	userID, conversationID string,
+	sessionType int,
+	pb *msg.SendMsgReq,
+) (bool, error) {
 	opt, err := m.User.GetUserGlobalMsgRecvOpt(ctx, userID)
 	if err != nil {
 		return false, err
@@ -4,6 +4,8 @@ import (
 	"context"
 	"net/url"

+	"google.golang.org/grpc"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
@@ -13,7 +15,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/third"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
-	"google.golang.org/grpc"
 )

 func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
@@ -39,7 +40,13 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	third.RegisterThirdServer(server, &thirdServer{
 		thirdDatabase: controller.NewThirdDatabase(cache.NewMsgCacheModel(rdb)),
 		userRpcClient: rpcclient.NewUserRpcClient(client),
-		s3dataBase:    controller.NewS3Database(o, relation.NewObjectHash(db), relation.NewObjectInfo(db), relation.NewObjectPut(db), u),
+		s3dataBase: controller.NewS3Database(
+			o,
+			relation.NewObjectHash(db),
+			relation.NewObjectInfo(db),
+			relation.NewObjectPut(db),
+			u,
+		),
 	})
 	return nil
 }
@@ -50,7 +57,10 @@ type thirdServer struct {
 	userRpcClient rpcclient.UserRpcClient
 }

-func (t *thirdServer) FcmUpdateToken(ctx context.Context, req *third.FcmUpdateTokenReq) (resp *third.FcmUpdateTokenResp, err error) {
+func (t *thirdServer) FcmUpdateToken(
+	ctx context.Context,
+	req *third.FcmUpdateTokenReq,
+) (resp *third.FcmUpdateTokenResp, err error) {
 	err = t.thirdDatabase.FcmUpdateToken(ctx, req.Account, int(req.PlatformID), req.FcmToken, req.ExpireTime)
 	if err != nil {
 		return nil, err
@@ -58,7 +68,10 @@ func (t *thirdServer) FcmUpdateToken(ctx context.Context, req *third.FcmUpdateTo
 	return &third.FcmUpdateTokenResp{}, nil
 }

-func (t *thirdServer) SetAppBadge(ctx context.Context, req *third.SetAppBadgeReq) (resp *third.SetAppBadgeResp, err error) {
+func (t *thirdServer) SetAppBadge(
+	ctx context.Context,
+	req *third.SetAppBadgeReq,
+) (resp *third.SetAppBadgeResp, err error) {
 	err = t.thirdDatabase.SetAppBadge(ctx, req.UserID, int(req.AppUnreadCount))
 	if err != nil {
 		return nil, err
@@ -8,7 +8,10 @@ import (
 	pbuser "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/user"
 )

-func (s *userServer) UserRegisterCount(ctx context.Context, req *pbuser.UserRegisterCountReq) (*pbuser.UserRegisterCountResp, error) {
+func (s *userServer) UserRegisterCount(
+	ctx context.Context,
+	req *pbuser.UserRegisterCountReq,
+) (*pbuser.UserRegisterCountResp, error) {
 	if req.Start > req.End {
 		return nil, errs.ErrArgs.Wrap("start > end")
 	}
@@ -23,8 +23,9 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"

-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"google.golang.org/grpc"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 )

 type userServer struct {
@@ -59,16 +60,22 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 	friendRpcClient := rpcclient.NewFriendRpcClient(client)
 	msgRpcClient := rpcclient.NewMessageRpcClient(client)
 	u := &userServer{
-		UserDatabase:       database,
-		RegisterCenter:     client,
-		friendRpcClient:    &friendRpcClient,
-		notificationSender: notification.NewFriendNotificationSender(&msgRpcClient, notification.WithDBFunc(database.FindWithError)),
+		UserDatabase:    database,
+		RegisterCenter:  client,
+		friendRpcClient: &friendRpcClient,
+		notificationSender: notification.NewFriendNotificationSender(
+			&msgRpcClient,
+			notification.WithDBFunc(database.FindWithError),
+		),
 	}
 	pbuser.RegisterUserServer(server, u)
 	return u.UserDatabase.InitOnce(context.Background(), users)
 }

-func (s *userServer) GetDesignateUsers(ctx context.Context, req *pbuser.GetDesignateUsersReq) (resp *pbuser.GetDesignateUsersResp, err error) {
+func (s *userServer) GetDesignateUsers(
+	ctx context.Context,
+	req *pbuser.GetDesignateUsersReq,
+) (resp *pbuser.GetDesignateUsersResp, err error) {
 	resp = &pbuser.GetDesignateUsersResp{}
 	users, err := s.FindWithError(ctx, req.UserIDs)
 	if err != nil {
@@ -81,7 +88,10 @@ func (s *userServer) GetDesignateUsers(ctx context.Context, req *pbuser.GetDesig
 	return resp, nil
 }

-func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserInfoReq) (resp *pbuser.UpdateUserInfoResp, err error) {
+func (s *userServer) UpdateUserInfo(
+	ctx context.Context,
+	req *pbuser.UpdateUserInfoReq,
+) (resp *pbuser.UpdateUserInfoResp, err error) {
 	resp = &pbuser.UpdateUserInfoResp{}
 	err = tokenverify.CheckAccessV3(ctx, req.UserInfo.UserID)
 	if err != nil {
@@ -106,7 +116,10 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserI
 	return resp, nil
 }

-func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.SetGlobalRecvMessageOptReq) (resp *pbuser.SetGlobalRecvMessageOptResp, err error) {
+func (s *userServer) SetGlobalRecvMessageOpt(
+	ctx context.Context,
+	req *pbuser.SetGlobalRecvMessageOptReq,
+) (resp *pbuser.SetGlobalRecvMessageOptResp, err error) {
 	resp = &pbuser.SetGlobalRecvMessageOptResp{}
 	if _, err := s.FindWithError(ctx, []string{req.UserID}); err != nil {
 		return nil, err
@@ -120,7 +133,10 @@ func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.Se
 	return resp, nil
 }

-func (s *userServer) AccountCheck(ctx context.Context, req *pbuser.AccountCheckReq) (resp *pbuser.AccountCheckResp, err error) {
+func (s *userServer) AccountCheck(
+	ctx context.Context,
+	req *pbuser.AccountCheckReq,
+) (resp *pbuser.AccountCheckResp, err error) {
 	resp = &pbuser.AccountCheckResp{}
 	if utils.Duplicate(req.CheckUserIDs) {
 		return nil, errs.ErrArgs.Wrap("userID repeated")
@@ -149,7 +165,10 @@ func (s *userServer) AccountCheck(ctx context.Context, req *pbuser.AccountCheckR
 	return resp, nil
 }

-func (s *userServer) GetPaginationUsers(ctx context.Context, req *pbuser.GetPaginationUsersReq) (resp *pbuser.GetPaginationUsersResp, err error) {
+func (s *userServer) GetPaginationUsers(
+	ctx context.Context,
+	req *pbuser.GetPaginationUsersReq,
+) (resp *pbuser.GetPaginationUsersResp, err error) {
 	var pageNumber, showNumber int32
 	if req.Pagination != nil {
 		pageNumber = req.Pagination.PageNumber
@@ -162,7 +181,10 @@ func (s *userServer) GetPaginationUsers(ctx context.Context, req *pbuser.GetPagi
 	return &pbuser.GetPaginationUsersResp{Total: int32(total), Users: convert.UsersDB2Pb(users)}, err
 }

-func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterReq) (resp *pbuser.UserRegisterResp, err error) {
+func (s *userServer) UserRegister(
+	ctx context.Context,
+	req *pbuser.UserRegisterReq,
+) (resp *pbuser.UserRegisterResp, err error) {
 	resp = &pbuser.UserRegisterResp{}
 	if len(req.Users) == 0 {
 		return nil, errs.ErrArgs.Wrap("users is empty")
@@ -210,7 +232,10 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
 	return resp, nil
 }

-func (s *userServer) GetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.GetGlobalRecvMessageOptReq) (resp *pbuser.GetGlobalRecvMessageOptResp, err error) {
+func (s *userServer) GetGlobalRecvMessageOpt(
+	ctx context.Context,
+	req *pbuser.GetGlobalRecvMessageOptReq,
+) (resp *pbuser.GetGlobalRecvMessageOptResp, err error) {
 	user, err := s.FindWithError(ctx, []string{req.UserID})
 	if err != nil {
 		return nil, err
@@ -218,7 +243,10 @@ func (s *userServer) GetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.Ge
 	return &pbuser.GetGlobalRecvMessageOptResp{GlobalRecvMsgOpt: user[0].GlobalRecvMsgOpt}, nil
 }

-func (s *userServer) GetAllUserID(ctx context.Context, req *pbuser.GetAllUserIDReq) (resp *pbuser.GetAllUserIDResp, err error) {
+func (s *userServer) GetAllUserID(
+	ctx context.Context,
+	req *pbuser.GetAllUserIDReq,
+) (resp *pbuser.GetAllUserIDResp, err error) {
 	userIDs, err := s.UserDatabase.GetAllUserID(ctx)
 	if err != nil {
 		return nil, err
@@ -5,9 +5,10 @@ import (
 	"fmt"
 	"sync"

+	"github.com/robfig/cron/v3"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/robfig/cron/v3"
 )

 func StartCronTask() error {
@@ -26,7 +26,12 @@ type MsgTool struct {

 var errSeq = errors.New("cache max seq and mongo max seq is diff > 10")

-func NewMsgTool(msgDatabase controller.CommonMsgDatabase, userDatabase controller.UserDatabase, groupDatabase controller.GroupDatabase, conversationDatabase controller.ConversationDatabase) *MsgTool {
+func NewMsgTool(
+	msgDatabase controller.CommonMsgDatabase,
+	userDatabase controller.UserDatabase,
+	groupDatabase controller.GroupDatabase,
+	conversationDatabase controller.ConversationDatabase,
+) *MsgTool {
 	return &MsgTool{
 		msgDatabase:          msgDatabase,
 		userDatabase:         userDatabase,
@@ -50,9 +55,17 @@ func InitMsgTool() (*MsgTool, error) {
 	}
 	userDB := relation.NewUserGorm(db)
 	msgDatabase := controller.InitCommonMsgDatabase(rdb, mongo.GetDatabase())
-	userDatabase := controller.NewUserDatabase(userDB, cache.NewUserCacheRedis(rdb, relation.NewUserGorm(db), cache.GetDefaultOpt()), tx.NewGorm(db))
+	userDatabase := controller.NewUserDatabase(
+		userDB,
+		cache.NewUserCacheRedis(rdb, relation.NewUserGorm(db), cache.GetDefaultOpt()),
+		tx.NewGorm(db),
+	)
 	groupDatabase := controller.InitGroupDatabase(db, rdb, mongo.GetDatabase())
-	conversationDatabase := controller.NewConversationDatabase(relation.NewConversationGorm(db), cache.NewConversationRedis(rdb, cache.GetDefaultOpt(), relation.NewConversationGorm(db)), tx.NewGorm(db))
+	conversationDatabase := controller.NewConversationDatabase(
+		relation.NewConversationGorm(db),
+		cache.NewConversationRedis(rdb, cache.GetDefaultOpt(), relation.NewConversationGorm(db)),
+		tx.NewGorm(db),
+	)
 	msgTool := NewMsgTool(msgDatabase, userDatabase, groupDatabase, conversationDatabase)
 	return msgTool, nil
 }
@@ -75,7 +88,15 @@ func (c *MsgTool) AllConversationClearMsgAndFixSeq() {
 func (c *MsgTool) ClearConversationsMsg(ctx context.Context, conversationIDs []string) {
 	for _, conversationID := range conversationIDs {
 		if err := c.msgDatabase.DeleteConversationMsgsAndSetMinSeq(ctx, conversationID, int64(config.Config.RetainChatRecords*24*60*60)); err != nil {
-			log.ZError(ctx, "DeleteUserSuperGroupMsgsAndSetMinSeq failed", err, "conversationID", conversationID, "DBRetainChatRecords", config.Config.RetainChatRecords)
+			log.ZError(
+				ctx,
+				"DeleteUserSuperGroupMsgsAndSetMinSeq failed",
+				err,
+				"conversationID",
+				conversationID,
+				"DBRetainChatRecords",
+				config.Config.RetainChatRecords,
+			)
 		}
 		if err := c.checkMaxSeq(ctx, conversationID); err != nil {
 			log.ZError(ctx, "fixSeq failed", err, "conversationID", conversationID)
@@ -4,11 +4,12 @@ import (
 	"context"
 	"strconv"

+	"go.mongodb.org/mongo-driver/bson"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"go.mongodb.org/mongo-driver/bson"

 	unRelationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"
@@ -89,7 +90,10 @@ func TestDeleteMongoMsgAndResetRedisSeq(t *testing.T) {
 		return
 	}
 	msgTools.ClearConversationsMsg(ctx, []string{conversationID})
-	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err := msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(ctx, conversationID)
+	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err := msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(
+		ctx,
+		conversationID,
+	)
 	if err != nil {
 		t.Error("GetSuperGroupMinMaxSeqInMongoAndCache failed")
 		return
@@ -132,7 +136,10 @@ func TestDeleteMongoMsgAndResetRedisSeq(t *testing.T) {
 	}

 	msgTools.ClearConversationsMsg(ctx, []string{conversationID})
-	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err = msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(ctx, conversationID)
+	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err = msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(
+		ctx,
+		conversationID,
+	)
 	if err != nil {
 		t.Error("GetSuperGroupMinMaxSeqInMongoAndCache failed")
 		return
@@ -164,7 +171,10 @@ func TestDeleteMongoMsgAndResetRedisSeq(t *testing.T) {
 	}

 	msgTools.ClearConversationsMsg(ctx, []string{conversationID})
-	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err = msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(ctx, conversationID)
+	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err = msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(
+		ctx,
+		conversationID,
+	)
 	if err != nil {
 		t.Error("GetSuperGroupMinMaxSeqInMongoAndCache failed")
 		return
@@ -214,7 +224,10 @@ func TestDeleteMongoMsgAndResetRedisSeq(t *testing.T) {
 		t.Error("GetSuperGroupMinMaxSeqInMongoAndCache failed")
 		return
 	}
-	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err = msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(ctx, conversationID)
+	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err = msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(
+		ctx,
+		conversationID,
+	)
 	if err != nil {
 		t.Error("GetSuperGroupMinMaxSeqInMongoAndCache failed")
 		return
@@ -255,7 +268,10 @@ func TestDeleteMongoMsgAndResetRedisSeq(t *testing.T) {
 		t.Error("GetSuperGroupMinMaxSeqInMongoAndCache failed")
 		return
 	}
-	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err = msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(ctx, conversationID)
+	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err = msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(
+		ctx,
+		conversationID,
+	)
 	if err != nil {
 		t.Error("GetSuperGroupMinMaxSeqInMongoAndCache failed")
 		return
@@ -305,7 +321,10 @@ func TestDeleteMongoMsgAndResetRedisSeq(t *testing.T) {
 	if _, err := mongoClient.InsertOne(ctx, msgDoc4); err != nil {
 		t.Error("InsertOne failed", testUID4)
 	}
-	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err = msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(ctx, conversationID)
+	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err = msgTools.msgDatabase.GetConversationMinMaxSeqInMongoAndCache(
+		ctx,
+		conversationID,
+	)
 	if err != nil {
 		t.Error("GetSuperGroupMinMaxSeqInMongoAndCache failed")
 		return