Merge remote-tracking branch 'upstream/main'

internal/api/auth.go

@@ -17,16 +17,15 @@ 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/OpenIMSDK/protocol/auth"
+	"github.com/OpenIMSDK/tools/a2r"
 )
 
 type AuthApi rpcclient.Auth
 
-func NewAuthApi(discov discoveryregistry.SvcDiscoveryRegistry) AuthApi {
-	return AuthApi(*rpcclient.NewAuth(discov))
+func NewAuthApi(client rpcclient.Auth) AuthApi {
+	return AuthApi(client)
 }
 
 func (o *AuthApi) UserToken(c *gin.Context) {

internal/api/conversation.go

@@ -17,16 +17,15 @@ 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/OpenIMSDK/protocol/conversation"
+	"github.com/OpenIMSDK/tools/a2r"
 )
 
 type ConversationApi rpcclient.Conversation
 
-func NewConversationApi(discov discoveryregistry.SvcDiscoveryRegistry) ConversationApi {
-	return ConversationApi(*rpcclient.NewConversation(discov))
+func NewConversationApi(client rpcclient.Conversation) ConversationApi {
+	return ConversationApi(client)
 }
 
 func (o *ConversationApi) GetAllConversations(c *gin.Context) {

internal/api/custom_validator.go

@@ -17,7 +17,7 @@ package api
 import (
 	"github.com/go-playground/validator/v10"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/tools/constant"
 )
 
 func RequiredIf(fl validator.FieldLevel) bool {

internal/api/friend.go

@@ -15,18 +15,17 @@
 package api
 
 import (
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+	"github.com/OpenIMSDK/protocol/friend"
+	"github.com/OpenIMSDK/tools/a2r"
 
 	"github.com/gin-gonic/gin"
 )
 
 type FriendApi rpcclient.Friend
 
-func NewFriendApi(discov discoveryregistry.SvcDiscoveryRegistry) FriendApi {
-	return FriendApi(*rpcclient.NewFriend(discov))
+func NewFriendApi(client rpcclient.Friend) FriendApi {
+	return FriendApi(client)
 }
 
 func (o *FriendApi) ApplyToAddFriend(c *gin.Context) {

internal/api/group.go

@@ -15,18 +15,17 @@
 package api
 
 import (
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+	"github.com/OpenIMSDK/protocol/group"
+	"github.com/OpenIMSDK/tools/a2r"
 
 	"github.com/gin-gonic/gin"
 )
 
 type GroupApi rpcclient.Group
 
-func NewGroupApi(discov discoveryregistry.SvcDiscoveryRegistry) GroupApi {
-	return GroupApi(*rpcclient.NewGroup(discov))
+func NewGroupApi(client rpcclient.Group) GroupApi {
+	return GroupApi(client)
 }
 
 func (o *GroupApi) CreateGroup(c *gin.Context) {
@@ -132,6 +131,7 @@ func (o *GroupApi) GetSuperGroupsInfo(c *gin.Context) {
 func (o *GroupApi) GroupCreateCount(c *gin.Context) {
 	a2r.Call(group.GroupClient.GroupCreateCount, o.Client, c)
 }
+
 func (o *GroupApi) GetGroups(c *gin.Context) {
 	a2r.Call(group.GroupClient.GetGroups, o.Client, c)
 }

internal/api/msg.go

@@ -20,27 +20,27 @@ import (
 	"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"
-	"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/tokenverify"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"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/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/a2r"
+	"github.com/OpenIMSDK/tools/apiresp"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/tokenverify"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type MessageApi struct {
-	rpcclient.Message
-	validate *validator.Validate
+	*rpcclient.Message
+	validate      *validator.Validate
+	userRpcClient *rpcclient.UserRpcClient
 }
 
-func NewMessageApi(discov discoveryregistry.SvcDiscoveryRegistry) MessageApi {
-	return MessageApi{Message: *rpcclient.NewMessage(discov), validate: validator.New()}
+func NewMessageApi(msgRpcClient *rpcclient.Message, userRpcClient *rpcclient.User) MessageApi {
+	return MessageApi{Message: msgRpcClient, validate: validator.New(), userRpcClient: rpcclient.NewUserRpcClientByUser(userRpcClient)}
 }
 
 func (MessageApi) SetOptions(options map[string]bool, value bool) {
@@ -50,9 +50,10 @@ func (MessageApi) SetOptions(options map[string]bool, value bool) {
 	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, value)
 }
 
-func (m MessageApi) newUserSendMsgReq(c *gin.Context, params *apistruct.ManagementSendMsgReq) *msg.SendMsgReq {
+func (m MessageApi) newUserSendMsgReq(c *gin.Context, params *apistruct.SendMsg) *msg.SendMsgReq {
 	var newContent string
 	var err error
+	options := make(map[string]bool, 5)
 	switch params.ContentType {
 	case constant.Text:
 		newContent = params.Content["text"].(string)
@@ -70,11 +71,9 @@ func (m MessageApi) newUserSendMsgReq(c *gin.Context, params *apistruct.Manageme
 		fallthrough
 	case constant.CustomOnlineOnly:
 		fallthrough
-	case constant.Revoke:
-		newContent = params.Content["revokeMsgClientID"].(string)
 	default:
+		newContent = utils.StructToJsonString(params.Content)
 	}
-	options := make(map[string]bool, 5)
 	if params.IsOnlineOnly {
 		m.SetOptions(options, false)
 	}
@@ -98,7 +97,6 @@ func (m MessageApi) newUserSendMsgReq(c *gin.Context, params *apistruct.Manageme
 			MsgFrom:          constant.SysMsgType,
 			ContentType:      params.ContentType,
 			Content:          []byte(newContent),
-			RecvID:           params.RecvID,
 			CreateTime:       utils.GetCurrentTimestampByMill(),
 			Options:          options,
 			OfflinePushInfo:  params.OfflinePushInfo,
@@ -163,19 +161,9 @@ func (m *MessageApi) DeleteMsgPhysical(c *gin.Context) {
 	a2r.Call(msg.MsgClient.DeleteMsgPhysical, m.Client, c)
 }
 
-func (m *MessageApi) SendMessage(c *gin.Context) {
-	params := apistruct.ManagementSendMsgReq{}
-	if err := c.BindJSON(&params); err != nil {
-		apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap())
-		return
-	}
-	if !tokenverify.IsAppManagerUid(c) {
-		apiresp.GinError(c, errs.ErrNoPermission.Wrap("only app manager can send message"))
-		return
-	}
-
+func (m *MessageApi) getSendMsgReq(c *gin.Context, req apistruct.SendMsg) (sendMsgReq *msg.SendMsgReq, err error) {
 	var data interface{}
-	switch params.ContentType {
+	switch req.ContentType {
 	case constant.Text:
 		data = apistruct.TextElem{}
 	case constant.Picture:
@@ -192,25 +180,45 @@ func (m *MessageApi) SendMessage(c *gin.Context) {
 		data = apistruct.RevokeElem{}
 	case constant.OANotification:
 		data = apistruct.OANotificationElem{}
-		params.SessionType = constant.NotificationChatType
+		req.SessionType = constant.NotificationChatType
 	case constant.CustomNotTriggerConversation:
 		data = apistruct.CustomElem{}
 	case constant.CustomOnlineOnly:
 		data = apistruct.CustomElem{}
 	default:
-		apiresp.GinError(c, errs.ErrArgs.WithDetail("not support err contentType").Wrap())
+		return nil, errs.ErrArgs.WithDetail("not support err contentType")
+	}
+	if err := mapstructure.WeakDecode(req.Content, &data); err != nil {
+		return nil, err
+	}
+	log.ZDebug(c, "getSendMsgReq", "data", data)
+	if err := m.validate.Struct(data); err != nil {
+		return nil, err
+	}
+	return m.newUserSendMsgReq(c, &req), nil
+}
+
+func (m *MessageApi) SendMessage(c *gin.Context) {
+	req := apistruct.SendMsgReq{}
+	if err := c.BindJSON(&req); err != nil {
+		apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap())
 		return
 	}
-	if err := mapstructure.WeakDecode(params.Content, &data); err != nil {
-		apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error()))
-		return
-	} else if err := m.validate.Struct(params); err != nil {
-		apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error()))
+	log.ZInfo(c, "SendMessage", "req", req)
+	if !tokenverify.IsAppManagerUid(c) {
+		apiresp.GinError(c, errs.ErrNoPermission.Wrap("only app manager can send message"))
 		return
 	}
-	pbReq := m.newUserSendMsgReq(c, &params)
+
+	sendMsgReq, err := m.getSendMsgReq(c, req.SendMsg)
+	if err != nil {
+		log.ZError(c, "decodeData failed", err)
+		apiresp.GinError(c, err)
+		return
+	}
+	sendMsgReq.MsgData.RecvID = req.RecvID
 	var status int
-	respPb, err := m.Client.SendMsg(c, pbReq)
+	respPb, err := m.Client.SendMsg(c, sendMsgReq)
 	if err != nil {
 		status = constant.MsgSendFailed
 		apiresp.GinError(c, err)
@@ -226,107 +234,64 @@ func (m *MessageApi) SendMessage(c *gin.Context) {
 	apiresp.GinSuccess(c, respPb)
 }
 
-func (m *MessageApi) ManagementBatchSendMsg(c *gin.Context) {
-	params := apistruct.ManagementBatchSendMsgReq{}
-	resp := apistruct.ManagementBatchSendMsgResp{}
-	var msgSendFailedFlag bool
-	if err := c.BindJSON(&params); err != nil {
+func (m *MessageApi) BatchSendMsg(c *gin.Context) {
+	var (
+		req  apistruct.BatchSendMsgReq
+		resp apistruct.BatchSendMsgResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.ZError(c, "BatchSendMsg BindJSON failed", err)
 		apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap())
 		return
 	}
-	if !tokenverify.IsAppManagerUid(c) {
+	log.ZInfo(c, "BatchSendMsg", "req", req)
+	if err := tokenverify.CheckAdmin(c); err != nil {
 		apiresp.GinError(c, errs.ErrNoPermission.Wrap("only app manager can send message"))
 		return
 	}
 
-	var data interface{}
-	switch params.ContentType {
-	case constant.Text:
-		data = apistruct.TextElem{}
-	case constant.Picture:
-		data = apistruct.PictureElem{}
-	case constant.Voice:
-		data = apistruct.SoundElem{}
-	case constant.Video:
-		data = apistruct.VideoElem{}
-	case constant.File:
-		data = apistruct.FileElem{}
-	case constant.Custom:
-		data = apistruct.CustomElem{}
-	case constant.Revoke:
-		data = apistruct.RevokeElem{}
-	case constant.OANotification:
-		data = apistruct.OANotificationElem{}
-		params.SessionType = constant.NotificationChatType
-	case constant.CustomNotTriggerConversation:
-		data = apistruct.CustomElem{}
-	case constant.CustomOnlineOnly:
-		data = apistruct.CustomElem{}
-	default:
-		apiresp.GinError(c, errs.ErrArgs.WithDetail("not support err contentType").Wrap())
-		return
-	}
-	if err := mapstructure.WeakDecode(params.Content, &data); err != nil {
-		apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error()))
-		return
-	} else if err := m.validate.Struct(params); err != nil {
-		apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error()))
-		return
-	}
-
-	t := &apistruct.ManagementSendMsgReq{
-		SendID:           params.SendID,
-		GroupID:          params.GroupID,
-		SenderNickname:   params.SenderNickname,
-		SenderFaceURL:    params.SenderFaceURL,
-		SenderPlatformID: params.SenderPlatformID,
-		Content:          params.Content,
-		ContentType:      params.ContentType,
-		SessionType:      params.SessionType,
-		IsOnlineOnly:     params.IsOnlineOnly,
-		NotOfflinePush:   params.NotOfflinePush,
-		OfflinePushInfo:  params.OfflinePushInfo,
-	}
-	pbReq := m.newUserSendMsgReq(c, t)
-	var recvList []string
-	if params.IsSendAll {
-		// req2 := &user.GetAllUserIDReq{}
-		// resp2, err := m.Message.GetAllUserID(c, req2)
-		// if err != nil {
-		// 	apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error()))
-		// 	return
-		// }
-		// recvList = resp2.UserIDs
+	var recvIDs []string
+	var err error
+	if req.IsSendAll {
+		pageNumber := 1
+		showNumber := 500
+		for {
+			recvIDsPart, err := m.userRpcClient.GetAllUserIDs(c, int32(pageNumber), int32(showNumber))
+			if err != nil {
+				log.ZError(c, "GetAllUserIDs failed", err)
+				apiresp.GinError(c, err)
+				return
+			}
+			if len(recvIDsPart) < showNumber {
+				recvIDs = append(recvIDs, recvIDsPart...)
+				break
+			}
+			pageNumber++
+		}
 	} else {
-		recvList = params.RecvIDList
+		recvIDs = req.RecvIDs
 	}
-
-	for _, recvID := range recvList {
-		pbReq.MsgData.RecvID = recvID
-		rpcResp, err := m.Client.SendMsg(c, pbReq)
+	log.ZDebug(c, "BatchSendMsg nums", "nums ", len(recvIDs))
+	sendMsgReq, err := m.getSendMsgReq(c, req.SendMsg)
+	if err != nil {
+		log.ZError(c, "decodeData failed", err)
+		apiresp.GinError(c, err)
+		return
+	}
+	for _, recvID := range recvIDs {
+		sendMsgReq.MsgData.RecvID = recvID
+		rpcResp, err := m.Client.SendMsg(c, sendMsgReq)
 		if err != nil {
-			resp.Data.FailedIDList = append(resp.Data.FailedIDList, recvID)
-			msgSendFailedFlag = true
+			resp.FailedIDs = append(resp.FailedIDs, recvID)
 			continue
 		}
-		resp.Data.ResultList = append(resp.Data.ResultList, &apistruct.SingleReturnResult{
+		resp.Results = append(resp.Results, &apistruct.SingleReturnResult{
 			ServerMsgID: rpcResp.ServerMsgID,
 			ClientMsgID: rpcResp.ClientMsgID,
 			SendTime:    rpcResp.SendTime,
 			RecvID:      recvID,
 		})
 	}
-	var status int32
-	if msgSendFailedFlag {
-		status = constant.MsgSendFailed
-	} else {
-		status = constant.MsgSendSuccessed
-	}
-	_, err := m.Client.SetSendMsgStatus(c, &msg.SetSendMsgStatusReq{Status: status})
-	if err != nil {
-		apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error()))
-		return
-	}
 	apiresp.GinSuccess(c, resp)
 }
 

internal/api/route.go

@@ -16,6 +16,13 @@ package api
 
 import (
 	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
+	"github.com/OpenIMSDK/tools/apiresp"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/tokenverify"
+	"net/http"
 
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
@@ -24,11 +31,12 @@ import (
 	"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"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/discoveryregistry"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mw"
 )
 
 func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.UniversalClient) *gin.Engine {
@@ -40,8 +48,17 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 	}
 	log.ZInfo(context.Background(), "load config", "config", config.Config)
 	r.Use(gin.Recovery(), mw.CorsHandler(), mw.GinParseOperationID())
-	u := NewUserApi(discov)
-	m := NewMessageApi(discov)
+	// init rpc client here
+	userRpc := rpcclient.NewUser(discov)
+	groupRpc := rpcclient.NewGroup(discov)
+	friendRpc := rpcclient.NewFriend(discov)
+	messageRpc := rpcclient.NewMessage(discov)
+	conversationRpc := rpcclient.NewConversation(discov)
+	authRpc := rpcclient.NewAuth(discov)
+	thirdRpc := rpcclient.NewThird(discov)
+
+	u := NewUserApi(*userRpc)
+	m := NewMessageApi(messageRpc, userRpc)
 	if config.Config.Prometheus.Enable {
 		prome.NewApiRequestCounter()
 		prome.NewApiRequestFailedCounter()
@@ -49,7 +66,7 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 		r.Use(prome.PrometheusMiddleware)
 		r.GET("/metrics", prome.PrometheusHandler())
 	}
-	ParseToken := mw.GinParseToken(rdb)
+	ParseToken := GinParseToken(rdb)
 	userRouterGroup := r.Group("/user")
 	{
 		userRouterGroup.POST("/user_register", u.UserRegister)
@@ -62,10 +79,10 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 		userRouterGroup.POST("/get_users_online_status", ParseToken, u.GetUsersOnlineStatus)
 		userRouterGroup.POST("/get_users_online_token_detail", ParseToken, u.GetUsersOnlineTokenDetail)
 	}
-	//friend routing group
+	// friend routing group
 	friendRouterGroup := r.Group("/friend", ParseToken)
 	{
-		f := NewFriendApi(discov)
+		f := NewFriendApi(*friendRpc)
 		friendRouterGroup.POST("/delete_friend", f.DeleteFriend)
 		friendRouterGroup.POST("/get_friend_apply_list", f.GetFriendApplyList)
 		friendRouterGroup.POST("/get_self_friend_apply_list", f.GetSelfApplyList)
@@ -79,7 +96,7 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 		friendRouterGroup.POST("/import_friend", f.ImportFriends)
 		friendRouterGroup.POST("/is_friend", f.IsFriend)
 	}
-	g := NewGroupApi(discov)
+	g := NewGroupApi(*groupRpc)
 	groupRouterGroup := r.Group("/group", ParseToken)
 	{
 		groupRouterGroup.POST("/create_group", g.CreateGroup)
@@ -110,18 +127,18 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 		superGroupRouterGroup.POST("/get_joined_group_list", g.GetJoinedSuperGroupList)
 		superGroupRouterGroup.POST("/get_groups_info", g.GetSuperGroupsInfo)
 	}
-	//certificate
+	// certificate
 	authRouterGroup := r.Group("/auth")
 	{
-		a := NewAuthApi(discov)
+		a := NewAuthApi(*authRpc)
 		authRouterGroup.POST("/user_token", a.UserToken)
 		authRouterGroup.POST("/parse_token", a.ParseToken)
 		authRouterGroup.POST("/force_logout", ParseToken, a.ForceLogout)
 	}
-	//Third service
+	// Third service
 	thirdGroup := r.Group("/third", ParseToken)
 	{
-		t := NewThirdApi(discov)
+		t := NewThirdApi(*thirdRpc)
 		thirdGroup.POST("/fcm_update_token", t.FcmUpdateToken)
 		thirdGroup.POST("/set_app_badge", t.SetAppBadge)
 
@@ -135,7 +152,7 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 		objectGroup.POST("/access_url", t.AccessURL)
 		objectGroup.GET("/*name", t.ObjectRedirect)
 	}
-	//Message
+	// Message
 	msgGroup := r.Group("/msg", ParseToken)
 	{
 		msgGroup.POST("/newest_seq", m.GetSeq)
@@ -154,13 +171,13 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 		msgGroup.POST("/delete_msg_phsical_by_seq", m.DeleteMsgPhysicalBySeq)
 		msgGroup.POST("/delete_msg_physical", m.DeleteMsgPhysical)
 
-		msgGroup.POST("/batch_send_msg", m.ManagementBatchSendMsg)
+		msgGroup.POST("/batch_send_msg", m.BatchSendMsg)
 		msgGroup.POST("/check_msg_is_send_success", m.CheckMsgIsSendSuccess)
 	}
-	//Conversation
+	// Conversation
 	conversationGroup := r.Group("/conversation", ParseToken)
 	{
-		c := NewConversationApi(discov)
+		c := NewConversationApi(*conversationRpc)
 		conversationGroup.POST("/get_all_conversations", c.GetAllConversations)
 		conversationGroup.POST("/get_conversation", c.GetConversation)
 		conversationGroup.POST("/get_conversations", c.GetConversations)
@@ -176,3 +193,65 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 	}
 	return r
 }
+
+func GinParseToken(rdb redis.UniversalClient) gin.HandlerFunc {
+	dataBase := controller.NewAuthDatabase(
+		cache.NewMsgCacheModel(rdb),
+		config.Config.Secret,
+		config.Config.TokenPolicy.Expire,
+	)
+	return func(c *gin.Context) {
+		switch c.Request.Method {
+		case http.MethodPost:
+			token := c.Request.Header.Get(constant.Token)
+			if token == "" {
+				log.ZWarn(c, "header get token error", errs.ErrArgs.Wrap("header must have token"))
+				apiresp.GinError(c, errs.ErrArgs.Wrap("header must have token"))
+				c.Abort()
+				return
+			}
+			claims, err := tokenverify.GetClaimFromToken(token)
+			if err != nil {
+				log.ZWarn(c, "jwt get token error", errs.ErrTokenUnknown.Wrap())
+				apiresp.GinError(c, errs.ErrTokenUnknown.Wrap())
+				c.Abort()
+				return
+			}
+			m, err := dataBase.GetTokensWithoutError(c, claims.UserID, claims.PlatformID)
+			if err != nil {
+				log.ZWarn(c, "cache get token error", errs.ErrTokenNotExist.Wrap())
+				apiresp.GinError(c, errs.ErrTokenNotExist.Wrap())
+				c.Abort()
+				return
+			}
+			if len(m) == 0 {
+				log.ZWarn(c, "cache do not exist token error", errs.ErrTokenNotExist.Wrap())
+				apiresp.GinError(c, errs.ErrTokenNotExist.Wrap())
+				c.Abort()
+				return
+			}
+			if v, ok := m[token]; ok {
+				switch v {
+				case constant.NormalToken:
+				case constant.KickedToken:
+					log.ZWarn(c, "cache kicked token error", errs.ErrTokenKicked.Wrap())
+					apiresp.GinError(c, errs.ErrTokenKicked.Wrap())
+					c.Abort()
+					return
+				default:
+					log.ZWarn(c, "cache unknown token error", errs.ErrTokenUnknown.Wrap())
+					apiresp.GinError(c, errs.ErrTokenUnknown.Wrap())
+					c.Abort()
+					return
+				}
+			} else {
+				apiresp.GinError(c, errs.ErrTokenNotExist.Wrap())
+				c.Abort()
+				return
+			}
+			c.Set(constant.OpUserPlatform, constant.PlatformIDToName(claims.PlatformID))
+			c.Set(constant.OpUserID, claims.UserID)
+			c.Next()
+		}
+	}
+}

internal/api/statistics.go

@@ -17,16 +17,15 @@ 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/OpenIMSDK/protocol/user"
+	"github.com/OpenIMSDK/tools/a2r"
 )
 
 type StatisticsApi rpcclient.User
 
-func NewStatisticsApi(discov discoveryregistry.SvcDiscoveryRegistry) StatisticsApi {
-	return StatisticsApi(*rpcclient.NewUser(discov))
+func NewStatisticsApi(client rpcclient.User) StatisticsApi {
+	return StatisticsApi(client)
 }
 
 func (s *StatisticsApi) UserRegister(c *gin.Context) {

internal/api/third.go

@@ -15,24 +15,22 @@
 package api
 
 import (
+	"github.com/gin-gonic/gin"
 	"math/rand"
 	"net/http"
 	"strconv"
 
-	"github.com/gin-gonic/gin"
-
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"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/OpenIMSDK/protocol/third"
+	"github.com/OpenIMSDK/tools/a2r"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/mcontext"
 )
 
 type ThirdApi rpcclient.Third
 
-func NewThirdApi(discov discoveryregistry.SvcDiscoveryRegistry) ThirdApi {
-	return ThirdApi(*rpcclient.NewThird(discov))
+func NewThirdApi(client rpcclient.Third) ThirdApi {
+	return ThirdApi(client)
 }
 
 func (o *ThirdApi) FcmUpdateToken(c *gin.Context) {
@@ -96,5 +94,5 @@ func (o *ThirdApi) ObjectRedirect(c *gin.Context) {
 		c.String(http.StatusInternalServerError, err.Error())
 		return
 	}
-	c.Redirect(http.StatusTemporaryRedirect, resp.Url)
+	c.Redirect(http.StatusFound, resp.Url)
 }

internal/api/user.go

@@ -17,22 +17,21 @@ 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/common/config"
-	"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/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msggateway"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/user"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+	"github.com/OpenIMSDK/protocol/msggateway"
+	"github.com/OpenIMSDK/protocol/user"
+	"github.com/OpenIMSDK/tools/a2r"
+	"github.com/OpenIMSDK/tools/apiresp"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
 )
 
 type UserApi rpcclient.User
 
-func NewUserApi(discov discoveryregistry.SvcDiscoveryRegistry) UserApi {
-	return UserApi(*rpcclient.NewUser(discov))
+func NewUserApi(client rpcclient.User) UserApi {
+	return UserApi(client)
 }
 
 func (u *UserApi) UserRegister(c *gin.Context) {
@@ -79,13 +78,19 @@ func (u *UserApi) GetUsersOnlineStatus(c *gin.Context) {
 	var respResult []*msggateway.GetUsersOnlineStatusResp_SuccessResult
 	flag := false
 
-	//Online push message
+	// Online push message
 	for _, v := range conns {
 		msgClient := msggateway.NewMsgGatewayClient(v)
 		reply, err := msgClient.GetUsersOnlineStatus(c, &req)
 		if err != nil {
-			log.ZWarn(c, "GetUsersOnlineStatus rpc  err", err)
-			continue
+			log.ZWarn(c, "GetUsersOnlineStatus rpc err", err)
+
+			parseError := apiresp.ParseError(err)
+			log.ZDebug(c, "errcode bantanger", "errcode", parseError.ErrCode)
+			if parseError.ErrCode == errs.NoPermissionError {
+				apiresp.GinError(c, err)
+				return
+			}
 		} else {
 			wsResult = append(wsResult, reply.SuccessResult...)
 		}
@@ -132,7 +137,7 @@ func (u *UserApi) GetUsersOnlineTokenDetail(c *gin.Context) {
 		apiresp.GinError(c, err)
 		return
 	}
-	//Online push message
+	// Online push message
 	for _, v := range conns {
 		msgClient := msggateway.NewMsgGatewayClient(v)
 		reply, err := msgClient.GetUsersOnlineStatus(c, &req)
@@ -161,7 +166,6 @@ func (u *UserApi) GetUsersOnlineTokenDetail(c *gin.Context) {
 					}
 				}
 			}
-
 		}
 		for p, tokens := range m {
 			t := new(msggateway.SinglePlatformToken)
@@ -177,5 +181,4 @@ func (u *UserApi) GetUsersOnlineTokenDetail(c *gin.Context) {
 	}
 
 	apiresp.GinSuccess(c, respResult)
-
 }

internal/msggateway/callback.go

@@ -19,10 +19,10 @@ import (
 	"time"
 
 	cbapi "github.com/OpenIMSDK/Open-IM-Server/pkg/callbackstruct"
-	"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/http"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/mcontext"
 )
 
 func url() string {

internal/msggateway/client.go

@@ -23,18 +23,20 @@ import (
 
 	"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"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/apiresp"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
-var ErrConnClosed = errors.New("conn has closed")
-var ErrNotSupportMessageProtocol = errors.New("not support message protocol")
-var ErrClientClosed = errors.New("client actively close the connection")
-var ErrPanic = errors.New("panic error")
+var (
+	ErrConnClosed                = errors.New("conn has closed")
+	ErrNotSupportMessageProtocol = errors.New("not support message protocol")
+	ErrClientClosed              = errors.New("client actively close the connection")
+	ErrPanic                     = errors.New("panic error")
+)
 
 const (
 	// MessageText is for UTF-8 encoded text messages like JSON.
@@ -102,10 +104,12 @@ func (c *Client) ResetClient(
 	c.closedErr = nil
 	c.token = token
 }
+
 func (c *Client) pongHandler(_ string) error {
 	c.conn.SetReadDeadline(pongWait)
 	return nil
 }
+
 func (c *Client) readMessage() {
 	defer func() {
 		if r := recover(); r != nil {
@@ -124,7 +128,7 @@ func (c *Client) readMessage() {
 			return
 		}
 		log.ZDebug(c.ctx, "readMessage", "messageType", messageType)
-		if c.closed == true { //连接刚置位已经关闭，但是协程还没退出的场景
+		if c.closed == true { // 连接刚置位已经关闭，但是协程还没退出的场景
 			c.closedErr = ErrConnClosed
 			return
 		}
@@ -148,8 +152,8 @@ func (c *Client) readMessage() {
 		default:
 		}
 	}
-
 }
+
 func (c *Client) handleMessage(message []byte) error {
 	if c.IsCompress {
 		var decompressErr error
@@ -198,26 +202,26 @@ func (c *Client) handleMessage(message []byte) error {
 	}
 	c.replyMessage(ctx, &binaryReq, messageErr, resp)
 	return nil
-
 }
+
 func (c *Client) setAppBackgroundStatus(ctx context.Context, req Req) ([]byte, error) {
 	resp, isBackground, messageErr := c.longConnServer.SetUserDeviceBackground(ctx, req)
 	if messageErr != nil {
 		return nil, messageErr
 	}
 	c.IsBackground = isBackground
-	//todo callback
+	// todo callback
 	return resp, nil
-
 }
+
 func (c *Client) close() {
 	c.w.Lock()
 	defer c.w.Unlock()
 	c.closed = true
 	c.conn.Close()
 	c.longConnServer.UnRegister(c)
-
 }
+
 func (c *Client) replyMessage(ctx context.Context, binaryReq *Req, err error, resp []byte) {
 	errResp := apiresp.ParseError(err)
 	mReply := Resp{
@@ -234,6 +238,7 @@ func (c *Client) replyMessage(ctx context.Context, binaryReq *Req, err error, re
 		log.ZWarn(ctx, "wireBinaryMsg replyMessage", err, "resp", mReply.String())
 	}
 }
+
 func (c *Client) PushMessage(ctx context.Context, msgData *sdkws.MsgData) error {
 	var msg sdkws.PushMessages
 	conversationID := utils.GetConversationIDByMsg(msgData)
@@ -296,5 +301,4 @@ func (c *Client) writePongMsg() error {
 	}
 	_ = c.conn.SetWriteDeadline(writeWait)
 	return c.conn.WriteMessage(PongMessage, nil)
-
 }

internal/msggateway/compressor.go

@@ -19,7 +19,7 @@ import (
 	"compress/gzip"
 	"io"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type Compressor interface {
@@ -33,6 +33,7 @@ type GzipCompressor struct {
 func NewGzipCompressor() *GzipCompressor {
 	return &GzipCompressor{compressProtocol: "gzip"}
 }
+
 func (g *GzipCompressor) Compress(rawData []byte) ([]byte, error) {
 	gzipBuffer := bytes.Buffer{}
 	gz := gzip.NewWriter(&gzipBuffer)

internal/msggateway/constant.go

@@ -27,11 +27,13 @@ const (
 	GzipCompressionProtocol = "gzip"
 	BackgroundStatus        = "isBackground"
 )
+
 const (
 	WebSocket = iota + 1
 )
+
 const (
-	//Websocket Protocol
+	// Websocket Protocol.
 	WSGetNewestSeq        = 1001
 	WSPullMsgBySeqList    = 1002
 	WSSendMsg             = 1003

internal/msggateway/context.go

@@ -19,8 +19,8 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type UserConnContext struct {
@@ -71,9 +71,11 @@ func newContext(respWriter http.ResponseWriter, req *http.Request) *UserConnCont
 		ConnID:     utils.Md5(req.RemoteAddr + "_" + strconv.Itoa(int(utils.GetCurrentTimestampByMill()))),
 	}
 }
+
 func (c *UserConnContext) GetRemoteAddr() string {
 	return c.RemoteAddr
 }
+
 func (c *UserConnContext) Query(key string) (string, bool) {
 	var value string
 	if value = c.Req.URL.Query().Get(key); value == "" {
@@ -81,6 +83,7 @@ func (c *UserConnContext) Query(key string) (string, bool) {
 	}
 	return value, true
 }
+
 func (c *UserConnContext) GetHeader(key string) (string, bool) {
 	var value string
 	if value = c.Req.Header.Get(key); value == "" {
@@ -88,27 +91,35 @@ func (c *UserConnContext) GetHeader(key string) (string, bool) {
 	}
 	return value, true
 }
+
 func (c *UserConnContext) SetHeader(key, value string) {
 	c.RespWriter.Header().Set(key, value)
 }
+
 func (c *UserConnContext) ErrReturn(error string, code int) {
 	http.Error(c.RespWriter, error, code)
 }
+
 func (c *UserConnContext) GetConnID() string {
 	return c.ConnID
 }
+
 func (c *UserConnContext) GetUserID() string {
 	return c.Req.URL.Query().Get(WsUserID)
 }
+
 func (c *UserConnContext) GetPlatformID() string {
 	return c.Req.URL.Query().Get(PlatformID)
 }
+
 func (c *UserConnContext) GetOperationID() string {
 	return c.Req.URL.Query().Get(OperationID)
 }
+
 func (c *UserConnContext) GetToken() string {
 	return c.Req.URL.Query().Get(Token)
 }
+
 func (c *UserConnContext) GetBackground() bool {
 	b, err := strconv.ParseBool(c.Req.URL.Query().Get(BackgroundStatus))
 	if err != nil {

internal/msggateway/encoder.go

@@ -18,7 +18,7 @@ import (
 	"bytes"
 	"encoding/gob"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type Encoder interface {
@@ -26,12 +26,12 @@ type Encoder interface {
 	Decode(encodeData []byte, decodeData interface{}) error
 }
 
-type GobEncoder struct {
-}
+type GobEncoder struct{}
 
 func NewGobEncoder() *GobEncoder {
 	return &GobEncoder{}
 }
+
 func (g *GobEncoder) Encode(data interface{}) ([]byte, error) {
 	buff := bytes.Buffer{}
 	enc := gob.NewEncoder(&buff)
@@ -41,6 +41,7 @@ func (g *GobEncoder) Encode(data interface{}) ([]byte, error) {
 	}
 	return buff.Bytes(), nil
 }
+
 func (g *GobEncoder) Decode(encodeData []byte, decodeData interface{}) error {
 	buff := bytes.NewBuffer(encodeData)
 	dec := gob.NewDecoder(buff)

internal/msggateway/http_error.go

@@ -14,7 +14,7 @@
 
 package msggateway
 
-import "github.com/OpenIMSDK/Open-IM-Server/pkg/apiresp"
+import "github.com/OpenIMSDK/tools/apiresp"
 
 func httpError(ctx *UserConnContext, err error) {
 	apiresp.HttpError(ctx.RespWriter, err)

internal/msggateway/hub_server.go

@@ -18,19 +18,19 @@ import (
 	"context"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/tokenverify"
 
 	"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"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	"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"
+	"github.com/OpenIMSDK/protocol/msggateway"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/discoveryregistry"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/startrpc"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func (s *Server) InitServer(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
@@ -181,13 +181,12 @@ func (s *Server) KickUserOffline(
 		if clients, _, ok := s.LongConnServer.GetUserPlatformCons(v, int(req.PlatformID)); ok {
 			for _, client := range clients {
 				log.ZDebug(ctx, "kick user offline", "userID", v, "platformID", req.PlatformID, "client", client)
-				err := client.KickOnlineMessage()
-				if err != nil {
-					return nil, err
+				if err := client.longConnServer.KickUserConn(client); err != nil {
+					log.ZWarn(ctx, "kick user offline failed", err, "userID", v, "platformID", req.PlatformID)
 				}
 			}
 		} else {
-			log.ZWarn(ctx, "conn not exist", nil, "userID", v, "platformID", req.PlatformID)
+			log.ZInfo(ctx, "conn not exist", "userID", v, "platformID", req.PlatformID)
 		}
 	}
 	return &msggateway.KickUserOfflineResp{}, nil
@@ -197,6 +196,6 @@ func (s *Server) MultiTerminalLoginCheck(
 	ctx context.Context,
 	req *msggateway.MultiTerminalLoginCheckReq,
 ) (*msggateway.MultiTerminalLoginCheckResp, error) {
-	//TODO implement me
+	// TODO implement me
 	panic("implement me")
 }

internal/msggateway/init.go

@@ -18,7 +18,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/tools/config"
 )
 
 func RunWsAndServer(rpcPort, wsPort, prometheusPort int) error {

internal/msggateway/long_conn.go

@@ -22,14 +22,14 @@ import (
 )
 
 type LongConn interface {
-	//Close this connection
+	// Close this connection
 	Close() error
 	// WriteMessage Write message to connection,messageType means data type,can be set binary(2) and text(1).
 	WriteMessage(messageType int, message []byte) error
 	// ReadMessage Read message from connection.
 	ReadMessage() (int, []byte, error)
 	// SetReadDeadline sets the read deadline on the underlying network connection,
-	//after a read has timed out, will return an error.
+	// after a read has timed out, will return an error.
 	SetReadDeadline(timeout time.Duration) error
 	// SetWriteDeadline sets to write deadline when send message,when read has timed out,will return error.
 	SetWriteDeadline(timeout time.Duration) error
@@ -58,6 +58,7 @@ func newGWebSocket(protocolType int, handshakeTimeout time.Duration) *GWebSocket
 func (d *GWebSocket) Close() error {
 	return d.conn.Close()
 }
+
 func (d *GWebSocket) GenerateLongConn(w http.ResponseWriter, r *http.Request) error {
 	upgrader := &websocket.Upgrader{
 		HandshakeTimeout: d.handshakeTimeout,
@@ -69,10 +70,10 @@ func (d *GWebSocket) GenerateLongConn(w http.ResponseWriter, r *http.Request) er
 	}
 	d.conn = conn
 	return nil
-
 }
+
 func (d *GWebSocket) WriteMessage(messageType int, message []byte) error {
-	//d.setSendConn(d.conn)
+	// d.setSendConn(d.conn)
 	return d.conn.WriteMessage(messageType, message)
 }
 
@@ -83,6 +84,7 @@ func (d *GWebSocket) WriteMessage(messageType int, message []byte) error {
 func (d *GWebSocket) ReadMessage() (int, []byte, error) {
 	return d.conn.ReadMessage()
 }
+
 func (d *GWebSocket) SetReadDeadline(timeout time.Duration) error {
 	return d.conn.SetReadDeadline(time.Now().Add(timeout))
 }
@@ -97,7 +99,6 @@ func (d *GWebSocket) Dial(urlStr string, requestHeader http.Header) (*http.Respo
 		d.conn = conn
 	}
 	return httpResp, err
-
 }
 
 func (d *GWebSocket) IsNil() bool {
@@ -110,9 +111,11 @@ func (d *GWebSocket) IsNil() bool {
 func (d *GWebSocket) SetConnNil() {
 	d.conn = nil
 }
+
 func (d *GWebSocket) SetReadLimit(limit int64) {
 	d.conn.SetReadLimit(limit)
 }
+
 func (d *GWebSocket) SetPongHandler(handler PongHandler) {
 	d.conn.SetPongHandler(handler)
 }

internal/msggateway/message_handler.go

@@ -17,16 +17,16 @@ package msggateway
 import (
 	"context"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/push"
+	"github.com/OpenIMSDK/protocol/push"
+	"github.com/OpenIMSDK/tools/discoveryregistry"
 
 	"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/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type Req struct {
@@ -75,8 +75,10 @@ type GrpcHandler struct {
 func NewGrpcHandler(validate *validator.Validate, client discoveryregistry.SvcDiscoveryRegistry) *GrpcHandler {
 	msgRpcClient := rpcclient.NewMessageRpcClient(client)
 	pushRpcClient := rpcclient.NewPushRpcClient(client)
-	return &GrpcHandler{msgRpcClient: &msgRpcClient,
-		pushClient: &pushRpcClient, validate: validate}
+	return &GrpcHandler{
+		msgRpcClient: &msgRpcClient,
+		pushClient:   &pushRpcClient, validate: validate,
+	}
 }
 
 func (g GrpcHandler) GetSeq(context context.Context, data Req) ([]byte, error) {
@@ -164,6 +166,7 @@ func (g GrpcHandler) UserLogout(context context.Context, data Req) ([]byte, erro
 	}
 	return c, nil
 }
+
 func (g GrpcHandler) SetUserDeviceBackground(_ context.Context, data Req) ([]byte, bool, error) {
 	req := sdkws.SetAppBackgroundStatusReq{}
 	if err := proto.Unmarshal(data.Data, &req); err != nil {

internal/msggateway/n_ws_server.go

@@ -23,20 +23,20 @@ import (
 	"sync/atomic"
 	"time"
 
-	"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/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
 
 	"github.com/redis/go-redis/v9"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/tools/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/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/tokenverify"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type LongConnServer interface {
@@ -47,6 +47,7 @@ type LongConnServer interface {
 	Validate(s interface{}) error
 	SetCacheHandler(cache cache.MsgModel)
 	SetDiscoveryRegistry(client discoveryregistry.SvcDiscoveryRegistry)
+	KickUserConn(client *Client) error
 	UnRegister(c *Client)
 	Compressor
 	Encoder
@@ -86,6 +87,7 @@ type kickHandler struct {
 func (ws *WsServer) SetDiscoveryRegistry(client discoveryregistry.SvcDiscoveryRegistry) {
 	ws.MessageHandler = NewGrpcHandler(ws.validate, client)
 }
+
 func (ws *WsServer) SetCacheHandler(cache cache.MsgModel) {
 	ws.cache = cache
 }
@@ -113,7 +115,6 @@ func NewWsServer(opts ...Option) (*WsServer, error) {
 	}
 	if config.port < 1024 {
 		return nil, errors.New("port not allow to listen")
-
 	}
 	v := validator.New()
 	return &WsServer{
@@ -134,6 +135,7 @@ func NewWsServer(opts ...Option) (*WsServer, error) {
 		Encoder:         NewGobEncoder(),
 	}, nil
 }
+
 func (ws *WsServer) Run() error {
 	var client *Client
 	go func() {
@@ -144,13 +146,13 @@ func (ws *WsServer) Run() error {
 			case client = <-ws.unregisterChan:
 				ws.unregisterClient(client)
 			case onlineInfo := <-ws.kickHandlerChan:
-				ws.multiTerminalLoginChecker(onlineInfo)
+				ws.multiTerminalLoginChecker(onlineInfo.clientOK, onlineInfo.oldClients, onlineInfo.newClient)
 			}
 		}
 	}()
 	http.HandleFunc("/", ws.wsHandler)
 	// http.HandleFunc("/metrics", func(w http.ResponseWriter, r *http.Request) {})
-	return http.ListenAndServe(":"+utils.IntToString(ws.port), nil) //Start listening
+	return http.ListenAndServe(":"+utils.IntToString(ws.port), nil) // Start listening
 }
 
 func (ws *WsServer) registerClient(client *Client) {
@@ -165,7 +167,6 @@ func (ws *WsServer) registerClient(client *Client) {
 		log.ZDebug(client.ctx, "user not exist", "userID", client.UserID, "platformID", client.PlatformID)
 		atomic.AddInt64(&ws.onlineUserNum, 1)
 		atomic.AddInt64(&ws.onlineUserConnNum, 1)
-
 	} else {
 		i := &kickHandler{
 			clientOK:   clientOK,
@@ -176,7 +177,7 @@ func (ws *WsServer) registerClient(client *Client) {
 		log.ZDebug(client.ctx, "user exist", "userID", client.UserID, "platformID", client.PlatformID)
 		if clientOK {
 			ws.clients.Set(client.UserID, client)
-			//已经有同平台的连接存在
+			// 已经有同平台的连接存在
 			log.ZInfo(client.ctx, "repeat login", "userID", client.UserID, "platformID", client.PlatformID, "old remote addr", getRemoteAdders(oldClients))
 			atomic.AddInt64(&ws.onlineUserConnNum, 1)
 		} else {
@@ -194,6 +195,7 @@ func (ws *WsServer) registerClient(client *Client) {
 		ws.onlineUserConnNum,
 	)
 }
+
 func getRemoteAdders(client []*Client) string {
 	var ret string
 	for i, c := range client {
@@ -206,86 +208,83 @@ func getRemoteAdders(client []*Client) string {
 	return ret
 }
 
-func (ws *WsServer) multiTerminalLoginChecker(info *kickHandler) {
+func (ws *WsServer) KickUserConn(client *Client) error {
+	ws.clients.deleteClients(client.UserID, []*Client{client})
+	return client.KickOnlineMessage()
+}
+
+func (ws *WsServer) multiTerminalLoginChecker(clientOK bool, oldClients []*Client, newClient *Client) {
 	switch config.Config.MultiLoginPolicy {
 	case constant.DefalutNotKick:
 	case constant.PCAndOther:
-		if constant.PlatformIDToClass(info.newClient.PlatformID) == constant.TerminalPC {
+		if constant.PlatformIDToClass(newClient.PlatformID) == constant.TerminalPC {
 			return
 		}
 		fallthrough
 	case constant.AllLoginButSameTermKick:
-		if info.clientOK {
-			ws.clients.deleteClients(info.newClient.UserID, info.oldClients)
-			for _, c := range info.oldClients {
+		if clientOK {
+			ws.clients.deleteClients(newClient.UserID, oldClients)
+			for _, c := range oldClients {
 				err := c.KickOnlineMessage()
 				if err != nil {
 					log.ZWarn(c.ctx, "KickOnlineMessage", err)
 				}
 			}
 			m, err := ws.cache.GetTokensWithoutError(
-				info.newClient.ctx,
-				info.newClient.UserID,
-				info.newClient.PlatformID,
+				newClient.ctx,
+				newClient.UserID,
+				newClient.PlatformID,
 			)
 			if err != nil && err != redis.Nil {
 				log.ZWarn(
-					info.newClient.ctx,
+					newClient.ctx,
 					"get token from redis err",
 					err,
 					"userID",
-					info.newClient.UserID,
+					newClient.UserID,
 					"platformID",
-					info.newClient.PlatformID,
+					newClient.PlatformID,
 				)
 				return
 			}
 			if m == nil {
 				log.ZWarn(
-					info.newClient.ctx,
+					newClient.ctx,
 					"m is nil",
 					errors.New("m is nil"),
 					"userID",
-					info.newClient.UserID,
+					newClient.UserID,
 					"platformID",
-					info.newClient.PlatformID,
+					newClient.PlatformID,
 				)
 				return
 			}
 			log.ZDebug(
-				info.newClient.ctx,
+				newClient.ctx,
 				"get token from redis",
 				"userID",
-				info.newClient.UserID,
+				newClient.UserID,
 				"platformID",
-				info.newClient.PlatformID,
+				newClient.PlatformID,
 				"tokenMap",
 				m,
 			)
 
 			for k := range m {
-				if k != info.newClient.ctx.GetToken() {
+				if k != newClient.ctx.GetToken() {
 					m[k] = constant.KickedToken
 				}
 			}
-			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)
+			log.ZDebug(newClient.ctx, "set token map is ", "token map", m, "userID", newClient.UserID)
+			err = ws.cache.SetTokenMapByUidPid(newClient.ctx, newClient.UserID, newClient.PlatformID, m)
 			if err != nil {
-				log.ZWarn(
-					info.newClient.ctx,
-					"SetTokenMapByUidPid err",
-					err,
-					"userID",
-					info.newClient.UserID,
-					"platformID",
-					info.newClient.PlatformID,
-				)
+				log.ZWarn(newClient.ctx, "SetTokenMapByUidPid err", err, "userID", newClient.UserID, "platformID", newClient.PlatformID)
 				return
 			}
 		}
 	}
-
 }
+
 func (ws *WsServer) unregisterClient(client *Client) {
 	defer ws.clientPool.Put(client)
 	isDeleteUser := ws.clients.delete(client.UserID, client.ctx.GetRemoteAddr())

internal/msggateway/options.go

@@ -16,33 +16,38 @@ package msggateway
 
 import "time"
 
-type Option func(opt *configs)
-type configs struct {
-	//长连接监听端口
-	port int
-	//长连接允许最大链接数
-	maxConnNum int64
-	//连接握手超时时间
-	handshakeTimeout time.Duration
-	//允许消息最大长度
-	messageMaxMsgLength int
-}
+type (
+	Option  func(opt *configs)
+	configs struct {
+		// 长连接监听端口
+		port int
+		// 长连接允许最大链接数
+		maxConnNum int64
+		// 连接握手超时时间
+		handshakeTimeout time.Duration
+		// 允许消息最大长度
+		messageMaxMsgLength int
+	}
+)
 
 func WithPort(port int) Option {
 	return func(opt *configs) {
 		opt.port = port
 	}
 }
+
 func WithMaxConnNum(num int64) Option {
 	return func(opt *configs) {
 		opt.maxConnNum = num
 	}
 }
+
 func WithHandshakeTimeout(t time.Duration) Option {
 	return func(opt *configs) {
 		opt.handshakeTimeout = t
 	}
 }
+
 func WithMessageMaxMsgLength(length int) Option {
 	return func(opt *configs) {
 		opt.messageMaxMsgLength = length

internal/msggateway/user_map.go

@@ -18,8 +18,8 @@ import (
 	"context"
 	"sync"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type UserMap struct {
@@ -29,6 +29,7 @@ type UserMap struct {
 func newUserMap() *UserMap {
 	return &UserMap{}
 }
+
 func (u *UserMap) GetAll(key string) ([]*Client, bool) {
 	allClients, ok := u.m.Load(key)
 	if ok {
@@ -36,6 +37,7 @@ func (u *UserMap) GetAll(key string) ([]*Client, bool) {
 	}
 	return nil, ok
 }
+
 func (u *UserMap) Get(key string, platformID int) ([]*Client, bool, bool) {
 	allClients, userExisted := u.m.Load(key)
 	if userExisted {
@@ -47,12 +49,12 @@ func (u *UserMap) Get(key string, platformID int) ([]*Client, bool, bool) {
 		}
 		if len(clients) > 0 {
 			return clients, userExisted, true
-
 		}
 		return clients, userExisted, false
 	}
 	return nil, userExisted, false
 }
+
 func (u *UserMap) Set(key string, v *Client) {
 	allClients, existed := u.m.Load(key)
 	if existed {
@@ -67,6 +69,7 @@ func (u *UserMap) Set(key string, v *Client) {
 		u.m.Store(key, clients)
 	}
 }
+
 func (u *UserMap) delete(key string, connRemoteAddr string) (isDeleteUser bool) {
 	allClients, existed := u.m.Load(key)
 	if existed {
@@ -87,6 +90,7 @@ func (u *UserMap) delete(key string, connRemoteAddr string) (isDeleteUser bool)
 	}
 	return existed
 }
+
 func (u *UserMap) deleteClients(key string, clients []*Client) (isDeleteUser bool) {
 	m := utils.SliceToMapAny(clients, func(c *Client) (string, struct{}) {
 		return c.ctx.GetRemoteAddr(), struct{}{}
@@ -110,6 +114,7 @@ func (u *UserMap) deleteClients(key string, clients []*Client) (isDeleteUser boo
 	}
 	return existed
 }
+
 func (u *UserMap) DeleteAll(key string) {
 	u.m.Delete(key)
 }

internal/msgtransfer/init.go

@@ -19,19 +19,20 @@ import (
 	"sync"
 	"time"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
 	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"
-	"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"
-	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"
+	"github.com/OpenIMSDK/tools/config"
+	openKeeper "github.com/OpenIMSDK/tools/discoveryregistry/zookeeper"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mw"
 )
 
 type MsgTransfer struct {
@@ -66,7 +67,7 @@ func StartTransfer(prometheusPort int) error {
 	if err != nil {
 		return err
 	}
-	if client.CreateRpcRootNodes(config.GetServiceNames()); err != nil {
+	if err := client.CreateRpcRootNodes(config.Config.GetServiceNames()); err != nil {
 		return err
 	}
 	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()))
@@ -74,7 +75,7 @@ func StartTransfer(prometheusPort int) error {
 	msgDocModel := unrelation.NewMsgMongoDriver(mongo.GetDatabase())
 	msgMysModel := relation.NewChatLogGorm(db)
 	chatLogDatabase := controller.NewChatLogDatabase(msgMysModel)
-	msgDatabase := controller.NewCommonMsgDatabase(msgDocModel, msgModel, msgMysModel)
+	msgDatabase := controller.NewCommonMsgDatabase(msgDocModel, msgModel)
 	conversationRpcClient := rpcclient.NewConversationRpcClient(client)
 	groupRpcClient := rpcclient.NewGroupRpcClient(client)
 	msgTransfer := NewMsgTransfer(chatLogDatabase, msgDatabase, &conversationRpcClient, &groupRpcClient)
@@ -84,9 +85,12 @@ func StartTransfer(prometheusPort int) error {
 
 func NewMsgTransfer(chatLogDatabase controller.ChatLogDatabase,
 	msgDatabase controller.CommonMsgDatabase,
-	conversationRpcClient *rpcclient.ConversationRpcClient, groupRpcClient *rpcclient.GroupRpcClient) *MsgTransfer {
-	return &MsgTransfer{persistentCH: NewPersistentConsumerHandler(chatLogDatabase), historyCH: NewOnlineHistoryRedisConsumerHandler(msgDatabase, conversationRpcClient, groupRpcClient),
-		historyMongoCH: NewOnlineHistoryMongoConsumerHandler(msgDatabase)}
+	conversationRpcClient *rpcclient.ConversationRpcClient, groupRpcClient *rpcclient.GroupRpcClient,
+) *MsgTransfer {
+	return &MsgTransfer{
+		persistentCH: NewPersistentConsumerHandler(chatLogDatabase), historyCH: NewOnlineHistoryRedisConsumerHandler(msgDatabase, conversationRpcClient, groupRpcClient),
+		historyMongoCH: NewOnlineHistoryMongoConsumerHandler(msgDatabase),
+	}
 }
 
 func (m *MsgTransfer) initPrometheus() {

internal/msgtransfer/online_history_msg_handler.go

@@ -21,27 +21,29 @@ import (
 	"sync"
 	"time"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/tools/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"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/kafka"
-	"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/rpcclient"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
-const ConsumerMsgs = 3
-const SourceMessages = 4
-const MongoMessages = 5
-const ChannelNum = 100
+const (
+	ConsumerMsgs   = 3
+	SourceMessages = 4
+	MongoMessages  = 5
+	ChannelNum     = 100
+)
 
 type MsgChannelValue struct {
 	uniqueKey  string
@@ -85,7 +87,7 @@ func NewOnlineHistoryRedisConsumerHandler(
 ) *OnlineHistoryRedisConsumerHandler {
 	var och OnlineHistoryRedisConsumerHandler
 	och.msgDatabase = database
-	och.msgDistributionCh = make(chan Cmd2Value) //no buffer channel
+	och.msgDistributionCh = make(chan Cmd2Value) // no buffer channel
 	go och.MessagesDistributionHandle()
 	for i := 0; i < ChannelNum; i++ {
 		och.chArrays[i] = make(chan Cmd2Value, 50)
@@ -93,8 +95,10 @@ func NewOnlineHistoryRedisConsumerHandler(
 	}
 	och.conversationRpcClient = conversationRpcClient
 	och.groupRpcClient = groupRpcClient
-	och.historyConsumerGroup = kafka.NewMConsumerGroup(&kafka.MConsumerGroupConfig{KafkaVersion: sarama.V2_0_0_0,
-		OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.LatestMsgToRedis.Topic},
+	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)
@@ -163,7 +167,7 @@ func (och *OnlineHistoryRedisConsumerHandler) Run(channelID int) {
 	}
 }
 
-// 获取消息/通知 存储的消息列表， 不存储并且推送的消息列表，
+// 获取消息/通知 存储的消息列表， 不存储并且推送的消息列表，.
 func (och *OnlineHistoryRedisConsumerHandler) getPushStorageMsgList(
 	totalMsgs []*ContextMsg,
 ) (storageMsgList, notStorageMsgList, storageNotificatoinList, notStorageNotificationList, modifyMsgList []*sdkws.MsgData) {
@@ -312,7 +316,7 @@ func (och *OnlineHistoryRedisConsumerHandler) MessagesDistributionHandle() {
 				triggerChannelValue := cmd.Value.(TriggerChannelValue)
 				ctx := triggerChannelValue.ctx
 				consumerMessages := triggerChannelValue.cMsgList
-				//Aggregation map[userid]message list
+				// Aggregation map[userid]message list
 				log.ZDebug(ctx, "batch messages come to distribution center", "length", len(consumerMessages))
 				for i := 0; i < len(consumerMessages); i++ {
 					ctxMsg := &ContextMsg{}
@@ -378,13 +382,13 @@ func (och *OnlineHistoryRedisConsumerHandler) MessagesDistributionHandle() {
 		}
 	}
 }
+
 func withAggregationCtx(ctx context.Context, values []*ContextMsg) context.Context {
 	var allMessageOperationID string
 	for i, v := range values {
 		if opid := mcontext.GetOperationID(v.ctx); opid != "" {
 			if i == 0 {
 				allMessageOperationID += opid
-
 			} else {
 				allMessageOperationID += "$" + opid
 			}
@@ -431,13 +435,15 @@ func (och *OnlineHistoryRedisConsumerHandler) ConsumeClaim(
 					ctx := mcontext.WithTriggerIDContext(context.Background(), utils.OperationIDGenerator())
 					log.ZDebug(ctx, "timer trigger msg consumer start", "length", len(ccMsg))
 					for i := 0; i < len(ccMsg)/split; i++ {
-						//log.Debug()
+						// log.Debug()
 						och.msgDistributionCh <- Cmd2Value{Cmd: ConsumerMsgs, Value: TriggerChannelValue{
-							ctx: ctx, cMsgList: ccMsg[i*split : (i+1)*split]}}
+							ctx: ctx, cMsgList: ccMsg[i*split : (i+1)*split],
+						}}
 					}
 					if (len(ccMsg) % split) > 0 {
 						och.msgDistributionCh <- Cmd2Value{Cmd: ConsumerMsgs, Value: TriggerChannelValue{
-							ctx: ctx, cMsgList: ccMsg[split*(len(ccMsg)/split):]}}
+							ctx: ctx, cMsgList: ccMsg[split*(len(ccMsg)/split):],
+						}}
 					}
 					log.ZDebug(ctx, "timer trigger msg consumer end", "length", len(ccMsg))
 				}

internal/msgtransfer/online_msg_to_mongo_handler.go

@@ -20,11 +20,11 @@ import (
 	"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"
+	pbMsg "github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/log"
 )
 
 type OnlineHistoryMongoConsumerHandler struct {
@@ -34,8 +34,10 @@ type OnlineHistoryMongoConsumerHandler struct {
 
 func NewOnlineHistoryMongoConsumerHandler(database controller.CommonMsgDatabase) *OnlineHistoryMongoConsumerHandler {
 	mc := &OnlineHistoryMongoConsumerHandler{
-		historyConsumerGroup: kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{KafkaVersion: sarama.V2_0_0_0,
-			OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.MsgToMongo.Topic},
+		historyConsumerGroup: kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{
+			KafkaVersion:   sarama.V2_0_0_0,
+			OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false,
+		}, []string{config.Config.Kafka.MsgToMongo.Topic},
 			config.Config.Kafka.Addr, config.Config.Kafka.ConsumerGroupID.MsgToMongo),
 		msgDatabase: database,
 	}

internal/msgtransfer/persistent_msg_handler.go

@@ -17,13 +17,13 @@ package msgtransfer
 import (
 	"context"
 
-	"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"
 	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/OpenIMSDK/Open-IM-Server/pkg/utils"
+	pbMsg "github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/utils"
 
 	"github.com/Shopify/sarama"
 	"google.golang.org/protobuf/proto"
@@ -36,8 +36,10 @@ type PersistentConsumerHandler struct {
 
 func NewPersistentConsumerHandler(database controller.ChatLogDatabase) *PersistentConsumerHandler {
 	return &PersistentConsumerHandler{
-		persistentConsumerGroup: kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{KafkaVersion: sarama.V2_0_0_0,
-			OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.LatestMsgToRedis.Topic},
+		persistentConsumerGroup: kfk.NewMConsumerGroup(&kfk.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.MsgToMySql),
 		chatLogDatabase: database,
 	}
@@ -59,9 +61,9 @@ func (pc *PersistentConsumerHandler) handleChatWs2Mysql(
 	}
 	return
 	log.ZDebug(ctx, "handleChatWs2Mysql", "msg", msgFromMQ.MsgData)
-	//Control whether to store history messages (mysql)
+	// Control whether to store history messages (mysql)
 	isPersist := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsPersistent)
-	//Only process receiver data
+	// Only process receiver data
 	if isPersist {
 		switch msgFromMQ.MsgData.SessionType {
 		case constant.SingleChatType, constant.NotificationChatType:

internal/push/callback.go

@@ -18,13 +18,13 @@ import (
 	"context"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/callbackstruct"
-	"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/http"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func url() string {
@@ -57,7 +57,7 @@ func callbackOfflinePush(
 		ContentType:     msg.ContentType,
 		SessionType:     msg.SessionType,
 		AtUserIDs:       msg.AtUserIDList,
-		Content:         utils.GetContent(msg),
+		Content:         GetContent(msg),
 	}
 	resp := &callbackstruct.CallbackBeforePushResp{}
 	if err := http.CallBackPostReturn(ctx, url(), req, resp, config.Config.Callback.CallbackOfflinePush); err != nil {
@@ -95,7 +95,7 @@ func callbackOnlinePush(ctx context.Context, userIDs []string, msg *sdkws.MsgDat
 		ContentType: msg.ContentType,
 		SessionType: msg.SessionType,
 		AtUserIDs:   msg.AtUserIDList,
-		Content:     utils.GetContent(msg),
+		Content:     GetContent(msg),
 	}
 	resp := &callbackstruct.CallbackBeforePushResp{}
 	return http.CallBackPostReturn(ctx, url(), req, resp, config.Config.Callback.CallbackOnlinePush)
@@ -123,7 +123,7 @@ func callbackBeforeSuperGroupOnlinePush(
 		ContentType: msg.ContentType,
 		SessionType: msg.SessionType,
 		AtUserIDs:   msg.AtUserIDList,
-		Content:     utils.GetContent(msg),
+		Content:     GetContent(msg),
 		Seq:         msg.Seq,
 	}
 	resp := &callbackstruct.CallbackBeforeSuperGroupOnlinePushResp{}

internal/push/offlinepush/fcm/push.go

@@ -16,6 +16,7 @@ package fcm
 
 import (
 	"context"
+	config2 "github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"path/filepath"
 
 	firebase "firebase.google.com/go"
@@ -24,9 +25,9 @@ import (
 	"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/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
 )
 
 const SinglePushCountLimit = 400
@@ -39,7 +40,7 @@ type Fcm struct {
 }
 
 func NewClient(cache cache.MsgModel) *Fcm {
-	opt := option.WithCredentialsFile(filepath.Join(config.Root, "config", config.Config.Push.Fcm.ServiceAccount))
+	opt := option.WithCredentialsFile(filepath.Join(config2.Root, "config", config.Config.Push.Fcm.ServiceAccount))
 	fcmApp, err := firebase.NewApp(context.Background(), nil, opt)
 	if err != nil {
 		return nil
@@ -95,7 +96,7 @@ func (f *Fcm) Push(ctx context.Context, userIDs []string, title, content string,
 			if err == nil {
 				apns.Payload.Aps.Badge = &unreadCountSum
 			} else {
-				//log.Error(operationID, "IncrUserBadgeUnreadCountSum redis err", err.Error(), uid)
+				// log.Error(operationID, "IncrUserBadgeUnreadCountSum redis err", err.Error(), uid)
 				Fail++
 				continue
 			}
@@ -107,7 +108,7 @@ func (f *Fcm) Push(ctx context.Context, userIDs []string, title, content string,
 				zero := 1
 				apns.Payload.Aps.Badge = &zero
 			} else {
-				//log.Error(operationID, "GetUserBadgeUnreadCountSum redis err", err.Error(), uid)
+				// log.Error(operationID, "GetUserBadgeUnreadCountSum redis err", err.Error(), uid)
 				Fail++
 				continue
 			}
@@ -127,7 +128,7 @@ func (f *Fcm) Push(ctx context.Context, userIDs []string, title, content string,
 		response, err := f.fcmMsgCli.SendAll(ctx, messages)
 		if err != nil {
 			Fail = Fail + messageCount
-			//log.Info(operationID, "some token push err", err.Error(), messageCount)
+			// log.Info(operationID, "some token push err", err.Error(), messageCount)
 		} else {
 			Success = Success + response.SuccessCount
 			Fail = Fail + response.FailureCount

internal/push/offlinepush/getui/body.go

@@ -17,7 +17,7 @@ package getui
 import (
 	"fmt"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/tools/config"
 )
 
 type Resp struct {
@@ -145,7 +145,7 @@ func newPushReq(title, content string) PushReq {
 }
 
 func newBatchPushReq(userIDs []string, taskID string) PushReq {
-	var IsAsync = true
+	IsAsync := true
 	return PushReq{Audience: &Audience{Alias: userIDs}, IsAsync: &IsAsync, TaskID: &taskID}
 }
 

internal/push/offlinepush/getui/push.go

@@ -15,27 +15,26 @@
 package getui
 
 import (
-	"sync"
-
-	"github.com/go-redis/redis"
-
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
 	"errors"
 	"strconv"
+	"sync"
 	"time"
 
+	"github.com/go-redis/redis"
+
 	"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/db/cache"
 	http2 "github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
-	"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/errs"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils/splitter"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils/splitter"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 var (
@@ -49,7 +48,7 @@ const (
 	taskURL      = "/push/list/message"
 	batchPushURL = "/push/list/alias"
 
-	// codes
+	// codes.
 	tokenExpireCode = 10001
 	tokenExpireTime = 60 * 60 * 23
 	taskIDTTL       = 1000 * 60 * 60 * 24
@@ -142,7 +141,7 @@ func (g *Client) GetTaskID(ctx context.Context, token string, pushReq PushReq) (
 	return respTask.TaskID, nil
 }
 
-// max num is 999
+// max num is 999.
 func (g *Client) batchPush(ctx context.Context, token string, userIDs []string, pushReq PushReq) error {
 	taskID, err := g.GetTaskID(ctx, token, pushReq)
 	if err != nil {

internal/push/offlinepush/jpush/body/notification.go

@@ -15,7 +15,7 @@
 package body
 
 import (
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/tools/config"
 )
 
 type Notification struct {

internal/push/offlinepush/jpush/body/platform.go

@@ -17,7 +17,7 @@ package body
 import (
 	"errors"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/tools/constant"
 )
 
 const (
@@ -66,6 +66,7 @@ func (p *Platform) Set(os string) error {
 
 	return nil
 }
+
 func (p *Platform) SetPlatform(platform string) error {
 	switch platform {
 	case constant.AndroidPlatformStr:
@@ -75,8 +76,8 @@ func (p *Platform) SetPlatform(platform string) error {
 	default:
 		return errors.New("platform err")
 	}
-
 }
+
 func (p *Platform) SetIOS() error {
 	return p.Set(IOS)
 }

internal/push/offlinepush/jpush/body/pushobj.go

@@ -37,6 +37,7 @@ func (p *PushObj) SetNotification(no *Notification) {
 func (p *PushObj) SetMessage(m *Message) {
 	p.Message = m
 }
+
 func (p *PushObj) SetOptions(o *Options) {
 	p.Options = o
 }

internal/push/offlinepush/jpush/push.go

@@ -21,8 +21,8 @@ import (
 
 	"github.com/OpenIMSDK/Open-IM-Server/internal/push/offlinepush"
 	"github.com/OpenIMSDK/Open-IM-Server/internal/push/offlinepush/jpush/body"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	http2 "github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
+	"github.com/OpenIMSDK/tools/config"
 )
 
 type JPush struct{}

internal/push/offlinepush/offlinepush_interface.go

@@ -18,10 +18,12 @@ import (
 	"context"
 )
 
+// OfflinePusher Offline Pusher.
 type OfflinePusher interface {
 	Push(ctx context.Context, userIDs []string, title, content string, opts *Opts) error
 }
 
+// Opts opts.
 type Opts struct {
 	Signal        *Signal
 	IOSPushSound  string
@@ -29,6 +31,7 @@ type Opts struct {
 	Ex            string
 }
 
+// Signal message id.
 type Signal struct {
 	ClientMsgID string
 }

internal/push/push_handler.go

@@ -20,13 +20,13 @@ import (
 	"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"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	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"
+	pbChat "github.com/OpenIMSDK/protocol/msg"
+	pbPush "github.com/OpenIMSDK/protocol/push"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type ConsumerHandler struct {
@@ -37,8 +37,10 @@ type ConsumerHandler struct {
 func NewConsumerHandler(pusher *Pusher) *ConsumerHandler {
 	var consumerHandler ConsumerHandler
 	consumerHandler.pusher = pusher
-	consumerHandler.pushConsumerGroup = kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{KafkaVersion: sarama.V2_0_0_0,
-		OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.MsgToPush.Topic}, config.Config.Kafka.Addr,
+	consumerHandler.pushConsumerGroup = kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{
+		KafkaVersion:   sarama.V2_0_0_0,
+		OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false,
+	}, []string{config.Config.Kafka.MsgToPush.Topic}, config.Config.Kafka.Addr,
 		config.Config.Kafka.ConsumerGroupID.MsgToPush)
 	return &consumerHandler
 }
@@ -63,7 +65,13 @@ func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
 	case constant.SuperGroupChatType:
 		err = c.pusher.Push2SuperGroup(ctx, pbData.MsgData.GroupID, pbData.MsgData)
 	default:
-		err = c.pusher.Push2User(ctx, []string{pbData.MsgData.SendID, pbData.MsgData.RecvID}, pbData.MsgData)
+		var pushUserIDs []string
+		if pbData.MsgData.SendID != pbData.MsgData.RecvID {
+			pushUserIDs = []string{pbData.MsgData.SendID, pbData.MsgData.RecvID}
+		} else {
+			pushUserIDs = []string{pbData.MsgData.SendID}
+		}
+		err = c.pusher.Push2User(ctx, pushUserIDs, pbData.MsgData)
 	}
 	if err != nil {
 		if err == errNoOfflinePusher {
@@ -76,7 +84,8 @@ func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
 func (ConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
 func (ConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
 func (c *ConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
-	claim sarama.ConsumerGroupClaim) error {
+	claim sarama.ConsumerGroupClaim,
+) error {
 	for msg := range claim.Messages() {
 		ctx := c.pushConsumerGroup.GetContextFromMsg(msg)
 		c.handleMs2PsChat(ctx, msg.Value)

internal/push/push_rpc_server.go

@@ -20,14 +20,14 @@ import (
 
 	"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"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/localcache"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"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"
+	pbPush "github.com/OpenIMSDK/protocol/push"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/discoveryregistry"
+	"github.com/OpenIMSDK/tools/log"
 )
 
 type pushServer struct {

internal/push/push_to_client.go

@@ -23,19 +23,19 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/internal/push/offlinepush/fcm"
 	"github.com/OpenIMSDK/Open-IM-Server/internal/push/offlinepush/getui"
 	"github.com/OpenIMSDK/Open-IM-Server/internal/push/offlinepush/jpush"
-	"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/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/localcache"
-	"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/common/prome"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msggateway"
-	"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/OpenIMSDK/protocol/msggateway"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/discoveryregistry"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type Pusher struct {
@@ -54,7 +54,8 @@ 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 {
+	conversationRpcClient *rpcclient.ConversationRpcClient, groupRpcClient *rpcclient.GroupRpcClient, msgRpcClient *rpcclient.MessageRpcClient,
+) *Pusher {
 	return &Pusher{
 		discov:                 discov,
 		database:               database,
@@ -223,7 +224,7 @@ func (p *Pusher) Push2SuperGroup(ctx context.Context, groupID string, msg *sdkws
 			}
 			needOfflinePushUserIDs = utils.DifferenceString(notNotificationUserIDs, needOfflinePushUserIDs)
 		}
-		//Use offline push messaging
+		// Use offline push messaging
 		if len(needOfflinePushUserIDs) > 0 {
 			var offlinePushUserIDs []string
 			err = callbackOfflinePush(ctx, needOfflinePushUserIDs, msg, &offlinePushUserIDs)
@@ -254,7 +255,7 @@ func (p *Pusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
 	if err != nil {
 		return nil, err
 	}
-	//Online push message
+	// Online push message
 	for _, v := range conns {
 		msgClient := msggateway.NewMsgGatewayClient(v)
 		reply, err := msgClient.SuperGroupOnlineBatchPushOneMsg(ctx, &msggateway.OnlineBatchPushOneMsgReq{MsgData: msg, PushToUserIDs: pushToUserIDs})
@@ -265,7 +266,6 @@ func (p *Pusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
 		if reply != nil && reply.SinglePushResult != nil {
 			wsResults = append(wsResults, reply.SinglePushResult...)
 		}
-
 	}
 	return wsResults, nil
 }

internal/push/tools.go

@@ -0,0 +1,18 @@
+package push
+
+import (
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/constant"
+	"google.golang.org/protobuf/proto"
+)
+
+func GetContent(msg *sdkws.MsgData) string {
+	if msg.ContentType >= constant.NotificationBegin && msg.ContentType <= constant.NotificationEnd {
+		var tips sdkws.TipsComm
+		_ = proto.Unmarshal(msg.Content, &tips)
+		content := tips.JsonDetail
+		return content
+	} else {
+		return string(msg.Content)
+	}
+}

internal/rpc/auth/auth.go

@@ -19,18 +19,19 @@ import (
 
 	"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"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	pbAuth "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/auth"
-	"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"
+	pbAuth "github.com/OpenIMSDK/protocol/auth"
+	"github.com/OpenIMSDK/protocol/msggateway"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/discoveryregistry"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/tokenverify"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type authServer struct {
@@ -129,11 +130,16 @@ func (s *authServer) forceKickOff(ctx context.Context, userID string, platformID
 	if err != nil {
 		return err
 	}
+	for _, v := range conns {
+		log.ZDebug(ctx, "forceKickOff", "conn", v.(*grpc.ClientConn).Target())
+	}
 	for _, v := range conns {
 		client := msggateway.NewMsgGatewayClient(v)
 		kickReq := &msggateway.KickUserOfflineReq{KickUserIDList: []string{userID}, PlatformID: platformID}
 		_, err := client.KickUserOffline(ctx, kickReq)
-		return utils.Wrap(err, "")
+		if err != nil {
+			log.ZError(ctx, "forceKickOff", err, "kickReq", kickReq)
+		}
 	}
 	return nil
 }

internal/rpc/conversation/conversaion.go

@@ -17,21 +17,22 @@ package conversation
 import (
 	"context"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"google.golang.org/grpc"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
 	tableRelation "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/tx"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	pbConversation "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
 	"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"
+	pbConversation "github.com/OpenIMSDK/protocol/conversation"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/discoveryregistry"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/tx"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type conversationServer struct {
@@ -184,7 +185,7 @@ func (c *conversationServer) SetConversations(ctx context.Context, req *pbConver
 	return &pbConversation.SetConversationsResp{}, nil
 }
 
-// 获取超级大群开启免打扰的用户ID
+// 获取超级大群开启免打扰的用户ID.
 func (c *conversationServer) GetRecvMsgNotNotifyUserIDs(ctx context.Context, req *pbConversation.GetRecvMsgNotNotifyUserIDsReq) (*pbConversation.GetRecvMsgNotNotifyUserIDsResp, error) {
 	userIDs, err := c.conversationDatabase.FindRecvMsgNotNotifyUserIDs(ctx, req.GroupID)
 	if err != nil {
@@ -193,7 +194,7 @@ func (c *conversationServer) GetRecvMsgNotNotifyUserIDs(ctx context.Context, req
 	return &pbConversation.GetRecvMsgNotNotifyUserIDsResp{UserIDs: userIDs}, nil
 }
 
-// create conversation without notification for msg redis transfer
+// create conversation without notification for msg redis transfer.
 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)
@@ -247,7 +248,10 @@ 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

internal/rpc/friend/black.go

@@ -20,9 +20,9 @@ import (
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-	pbFriend "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
+	pbFriend "github.com/OpenIMSDK/protocol/friend"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/tokenverify"
 )
 
 func (s *friendServer) GetPaginationBlacks(

internal/rpc/friend/callback.go

@@ -18,12 +18,12 @@ import (
 	"context"
 
 	cbapi "github.com/OpenIMSDK/Open-IM-Server/pkg/callbackstruct"
-	"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/http"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	pbfriend "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
+	pbfriend "github.com/OpenIMSDK/protocol/friend"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/mcontext"
 )
 
 func CallbackBeforeAddFriend(ctx context.Context, req *pbfriend.ApplyToAddFriendReq) error {

internal/rpc/friend/friend.go

@@ -18,23 +18,23 @@ import (
 	"context"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+	"github.com/OpenIMSDK/tools/log"
 
 	"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"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
 	tablerelation "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/tx"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-	registry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	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"
+	pbfriend "github.com/OpenIMSDK/protocol/friend"
+	"github.com/OpenIMSDK/tools/constant"
+	registry "github.com/OpenIMSDK/tools/discoveryregistry"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/tokenverify"
+	"github.com/OpenIMSDK/tools/tx"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type friendServer struct {
@@ -83,7 +83,12 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 	return nil
 }
 
-// ok
+func (s *friendServer) GetDesignatedFriendsApply(ctx context.Context, req *pbfriend.GetDesignatedFriendsApplyReq) (*pbfriend.GetDesignatedFriendsApplyResp, error) {
+	//TODO implement me
+	panic("implement me")
+}
+
+// ok.
 func (s *friendServer) ApplyToAddFriend(
 	ctx context.Context,
 	req *pbfriend.ApplyToAddFriendReq,
@@ -116,7 +121,7 @@ func (s *friendServer) ApplyToAddFriend(
 	return resp, nil
 }
 
-// ok
+// ok.
 func (s *friendServer) ImportFriends(
 	ctx context.Context,
 	req *pbfriend.ImportFriendReq,
@@ -142,7 +147,7 @@ func (s *friendServer) ImportFriends(
 	return &pbfriend.ImportFriendResp{}, nil
 }
 
-// ok
+// ok.
 func (s *friendServer) RespondFriendApply(
 	ctx context.Context,
 	req *pbfriend.RespondFriendApplyReq,
@@ -178,7 +183,7 @@ func (s *friendServer) RespondFriendApply(
 	return nil, errs.ErrArgs.Wrap("req.HandleResult != -1/1")
 }
 
-// ok
+// ok.
 func (s *friendServer) DeleteFriend(
 	ctx context.Context,
 	req *pbfriend.DeleteFriendReq,
@@ -199,7 +204,7 @@ func (s *friendServer) DeleteFriend(
 	return resp, nil
 }
 
-// ok
+// ok.
 func (s *friendServer) SetFriendRemark(
 	ctx context.Context,
 	req *pbfriend.SetFriendRemarkReq,
@@ -220,7 +225,7 @@ func (s *friendServer) SetFriendRemark(
 	return resp, nil
 }
 
-// ok
+// ok.
 func (s *friendServer) GetDesignatedFriends(
 	ctx context.Context,
 	req *pbfriend.GetDesignatedFriendsReq,
@@ -240,7 +245,7 @@ func (s *friendServer) GetDesignatedFriends(
 	return resp, nil
 }
 
-// ok 获取接收到的好友申请（即别人主动申请的）
+// ok 获取接收到的好友申请（即别人主动申请的）.
 func (s *friendServer) GetPaginationFriendsApplyTo(
 	ctx context.Context,
 	req *pbfriend.GetPaginationFriendsApplyToReq,
@@ -249,8 +254,7 @@ func (s *friendServer) GetPaginationFriendsApplyTo(
 	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
-	pageNumber, showNumber := utils.GetPage(req.Pagination)
-	friendRequests, total, err := s.friendDatabase.PageFriendRequestToMe(ctx, req.UserID, pageNumber, showNumber)
+	friendRequests, total, err := s.friendDatabase.PageFriendRequestToMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
@@ -263,7 +267,7 @@ func (s *friendServer) GetPaginationFriendsApplyTo(
 	return resp, nil
 }
 
-// ok 获取主动发出去的好友申请列表
+// ok 获取主动发出去的好友申请列表.
 func (s *friendServer) GetPaginationFriendsApplyFrom(
 	ctx context.Context,
 	req *pbfriend.GetPaginationFriendsApplyFromReq,
@@ -273,8 +277,7 @@ func (s *friendServer) GetPaginationFriendsApplyFrom(
 	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
-	pageNumber, showNumber := utils.GetPage(req.Pagination)
-	friendRequests, total, err := s.friendDatabase.PageFriendRequestFromMe(ctx, req.UserID, pageNumber, showNumber)
+	friendRequests, total, err := s.friendDatabase.PageFriendRequestFromMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
@@ -286,7 +289,7 @@ func (s *friendServer) GetPaginationFriendsApplyFrom(
 	return resp, nil
 }
 
-// ok
+// ok.
 func (s *friendServer) IsFriend(
 	ctx context.Context,
 	req *pbfriend.IsFriendReq,
@@ -300,7 +303,7 @@ func (s *friendServer) IsFriend(
 	return resp, nil
 }
 
-// ok
+// ok.
 func (s *friendServer) GetPaginationFriends(
 	ctx context.Context,
 	req *pbfriend.GetPaginationFriendsReq,
@@ -309,8 +312,7 @@ func (s *friendServer) GetPaginationFriends(
 	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
-	pageNumber, showNumber := utils.GetPage(req.Pagination)
-	friends, total, err := s.friendDatabase.PageOwnerFriends(ctx, req.UserID, pageNumber, showNumber)
+	friends, total, err := s.friendDatabase.PageOwnerFriends(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}

internal/rpc/group/cache.go

@@ -18,7 +18,7 @@ import (
 	"context"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
-	pbGroup "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
+	pbGroup "github.com/OpenIMSDK/protocol/group"
 )
 
 func (s *groupServer) GetGroupInfoCache(

internal/rpc/group/callback.go

@@ -20,15 +20,15 @@ import (
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/apistruct"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/callbackstruct"
-	"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/table/relation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/wrapperspb"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/protocol/group"
+	"github.com/OpenIMSDK/protocol/wrapperspb"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func CallbackBeforeCreateGroup(ctx context.Context, req *group.CreateGroupReq) (err error) {

internal/rpc/group/convert.go

@@ -16,7 +16,7 @@ package group
 
 import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"github.com/OpenIMSDK/protocol/sdkws"
 )
 
 func (s *groupServer) groupDB2PB(group *relation.GroupModel, ownerUserID string, memberCount uint32) *sdkws.GroupInfo {

internal/rpc/group/db_map.go

@@ -18,10 +18,10 @@ import (
 	"context"
 	"time"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
+	"github.com/OpenIMSDK/tools/mcontext"
 
-	pbGroup "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	pbGroup "github.com/OpenIMSDK/protocol/group"
+	"github.com/OpenIMSDK/protocol/sdkws"
 )
 
 func UpdateGroupInfoMap(ctx context.Context, group *sdkws.GroupInfoForSet) map[string]any {

internal/rpc/group/fill.go

@@ -18,7 +18,7 @@ import (
 	"context"
 
 	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func (s *groupServer) FindGroupMember(

internal/rpc/group/group.go

@@ -17,35 +17,37 @@ package group
 import (
 	"context"
 	"fmt"
-	pbConversation "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/wrapperspb"
 	"math/big"
 	"math/rand"
 	"strconv"
 	"strings"
 	"time"
 
+	pbConversation "github.com/OpenIMSDK/protocol/conversation"
+	"github.com/OpenIMSDK/protocol/wrapperspb"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mw/specialerror"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+	"github.com/OpenIMSDK/tools/mw/specialerror"
+
+	"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"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
 	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"
-	"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/common/tokenverify"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	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"
+	pbGroup "github.com/OpenIMSDK/protocol/group"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/discoveryregistry"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/tokenverify"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
@@ -92,6 +94,11 @@ type groupServer struct {
 	msgRpcClient          rpcclient.MessageRpcClient
 }
 
+func (s *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *pbGroup.GetGroupUsersReqApplicationListReq) (*pbGroup.GetGroupUsersReqApplicationListResp, error) {
+	//TODO implement me
+	panic("implement me")
+}
+
 func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error {
 	if !tokenverify.IsAppManagerUid(ctx) {
 		groupMember, err := s.GroupDatabase.TakeGroupMember(ctx, groupID, mcontext.GetOpUserID(ctx))
@@ -229,7 +236,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 			}
 		}()
 	} else {
-		//s.Notification.GroupCreatedNotification(ctx, group, groupMembers, userMap)
+		// s.Notification.GroupCreatedNotification(ctx, group, groupMembers, userMap)
 		tips := &sdkws.GroupCreatedTips{
 			Group:          resp.GroupInfo,
 			OperationTime:  group.CreateTime.UnixMilli(),
@@ -258,7 +265,7 @@ 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
@@ -515,7 +522,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 				Notification: group.Notification,
 				Introduction: group.Introduction,
 				FaceURL:      group.FaceURL,
-				//OwnerUserID:            owner[0].UserID,
+				// OwnerUserID:            owner[0].UserID,
 				CreateTime:             group.CreateTime.UnixMilli(),
 				MemberCount:            num,
 				Ex:                     group.Ex,
@@ -575,8 +582,6 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 }
 
 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)
 	if err != nil {
 		return nil, err
@@ -585,7 +590,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	if len(groupIDs) == 0 {
 		return resp, nil
 	}
-	total, groupRequests, err := s.GroupDatabase.PageGroupRequest(ctx, groupIDs, pageNumber, showNumber)
+	total, groupRequests, err := s.GroupDatabase.PageGroupRequest(ctx, groupIDs, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
@@ -900,7 +905,6 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		}()
 		num++
 		s.Notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser})
-
 	}
 	switch len(data) - num {
 	case 0:
@@ -1104,7 +1108,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 			if err != nil {
 				return nil, err
 			}
-			//s.Notification.GroupDismissedNotification(ctx, req)
+			// s.Notification.GroupDismissedNotification(ctx, req)
 			tips := &sdkws.GroupDismissedTips{
 				Group:  s.groupDB2PB(group, owner.UserID, num),
 				OpUser: &sdkws.GroupMemberFullInfo{},

internal/rpc/group/statistics.go

@@ -16,9 +16,10 @@ package group
 
 import (
 	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
 	"time"
+
+	"github.com/OpenIMSDK/protocol/group"
+	"github.com/OpenIMSDK/tools/errs"
 )
 
 func (s *groupServer) GroupCreateCount(ctx context.Context, req *group.GroupCreateCountReq) (*group.GroupCreateCountResp, error) {

internal/rpc/group/super_group.go

@@ -19,14 +19,14 @@ import (
 	"fmt"
 	"strings"
 
-	"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/table/relation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	pbGroup "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
-	sdkws "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	pbGroup "github.com/OpenIMSDK/protocol/group"
+	sdkws "github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func (s *groupServer) GetJoinedSuperGroupList(

internal/rpc/msg/as_read.go

@@ -19,11 +19,11 @@ import (
 
 	"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/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
 )
 
 func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *msg.GetConversationsHasReadAndMaxSeqReq) (*msg.GetConversationsHasReadAndMaxSeqResp, error) {
@@ -39,7 +39,7 @@ func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *m
 	if err != nil {
 		return nil, err
 	}
-	var conversationMaxSeqMap = make(map[string]int64)
+	conversationMaxSeqMap := make(map[string]int64)
 	for _, conversation := range conversations {
 		if conversation.MaxSeq != 0 {
 			conversationMaxSeqMap[conversation.ConversationID] = conversation.MaxSeq

internal/rpc/msg/callback.go

@@ -16,16 +16,18 @@ package msg
 
 import (
 	"context"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"google.golang.org/protobuf/proto"
 
 	cbapi "github.com/OpenIMSDK/Open-IM-Server/pkg/callbackstruct"
-	"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/http"
-	"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/errs"
-	pbChat "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	pbChat "github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func cbURL() string {
@@ -48,12 +50,23 @@ func toCommonCallback(ctx context.Context, msg *pbChat.SendMsgReq, command strin
 		CreateTime:       msg.MsgData.CreateTime,
 		AtUserIDList:     msg.MsgData.AtUserIDList,
 		SenderFaceURL:    msg.MsgData.SenderFaceURL,
-		Content:          utils.GetContent(msg.MsgData),
+		Content:          GetContent(msg.MsgData),
 		Seq:              uint32(msg.MsgData.Seq),
 		Ex:               msg.MsgData.Ex,
 	}
 }
 
+func GetContent(msg *sdkws.MsgData) string {
+	if msg.ContentType >= constant.NotificationBegin && msg.ContentType <= constant.NotificationEnd {
+		var tips sdkws.TipsComm
+		_ = proto.Unmarshal(msg.Content, &tips)
+		content := tips.JsonDetail
+		return content
+	} else {
+		return string(msg.Content)
+	}
+}
+
 func callbackBeforeSendSingleMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
 	if !config.Config.Callback.CallbackBeforeSendSingleMsg.Enable {
 		return nil

internal/rpc/msg/delete.go

@@ -17,13 +17,13 @@ package msg
 import (
 	"context"
 
-	"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/tokenverify"
-	"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/proto/sdkws"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/protocol/conversation"
+	"github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/tokenverify"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func (m *msgServer) getMinSeqs(maxSeqs map[string]int64) map[string]int64 {

internal/rpc/msg/lock.go

@@ -1,70 +0,0 @@
-// Copyright © 2023 OpenIM. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package msg
-
-import (
-	"context"
-	"time"
-
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
-)
-
-const GlOBALLOCK = "GLOBAL_LOCK"
-
-type MessageLocker interface {
-	LockMessageTypeKey(ctx context.Context, clientMsgID, typeKey string) (err error)
-	UnLockMessageTypeKey(ctx context.Context, clientMsgID string, typeKey string) error
-	LockGlobalMessage(ctx context.Context, clientMsgID string) (err error)
-	UnLockGlobalMessage(ctx context.Context, clientMsgID string) (err error)
-}
-type LockerMessage struct {
-	cache cache.MsgModel
-}
-
-func NewLockerMessage(cache cache.MsgModel) *LockerMessage {
-	return &LockerMessage{cache: cache}
-}
-func (l *LockerMessage) LockMessageTypeKey(ctx context.Context, clientMsgID, typeKey string) (err error) {
-	for i := 0; i < 3; i++ {
-		err = l.cache.LockMessageTypeKey(ctx, clientMsgID, typeKey)
-		if err != nil {
-			time.Sleep(time.Millisecond * 100)
-			continue
-		} else {
-			break
-		}
-	}
-	return err
-
-}
-func (l *LockerMessage) LockGlobalMessage(ctx context.Context, clientMsgID string) (err error) {
-	for i := 0; i < 3; i++ {
-		err = l.cache.LockMessageTypeKey(ctx, clientMsgID, GlOBALLOCK)
-		if err != nil {
-			time.Sleep(time.Millisecond * 100)
-			continue
-		} else {
-			break
-		}
-	}
-	return err
-
-}
-func (l *LockerMessage) UnLockMessageTypeKey(ctx context.Context, clientMsgID string, typeKey string) error {
-	return l.cache.UnLockMessageTypeKey(ctx, clientMsgID, typeKey)
-}
-func (l *LockerMessage) UnLockGlobalMessage(ctx context.Context, clientMsgID string) error {
-	return l.cache.UnLockMessageTypeKey(ctx, clientMsgID, GlOBALLOCK)
-}

internal/rpc/msg/message_interceptor.go

@@ -17,11 +17,11 @@ package msg
 import (
 	"context"
 
-	"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/errs"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
 )
 
 type MessageInterceptorFunc func(ctx context.Context, req *msg.SendMsgReq) (*sdkws.MsgData, error)

internal/rpc/msg/msg_status.go

@@ -17,9 +17,9 @@ package msg
 import (
 	"context"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
-	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
+	pbMsg "github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/mcontext"
 )
 
 func (m *msgServer) SetSendMsgStatus(

internal/rpc/msg/revoke.go

@@ -19,14 +19,14 @@ import (
 	"encoding/json"
 	"time"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	unRelationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
-	"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/proto/msg"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/tokenverify"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func (m *msgServer) RevokeMsg(ctx context.Context, req *msg.RevokeMsgReq) (*msg.RevokeMsgResp, error) {

internal/rpc/msg/send.go

@@ -17,16 +17,16 @@ package msg
 import (
 	"context"
 
-	"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"
 	promePkg "github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	pbConversation "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
-	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/proto/wrapperspb"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	pbConversation "github.com/OpenIMSDK/protocol/conversation"
+	pbMsg "github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/protocol/wrapperspb"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func (m *msgServer) SendMsg(ctx context.Context, req *pbMsg.SendMsgReq) (resp *pbMsg.SendMsgResp, error error) {
@@ -84,6 +84,7 @@ func (m *msgServer) sendMsgSuperGroupChat(
 	resp.ClientMsgID = req.MsgData.ClientMsgID
 	return resp, nil
 }
+
 func (m *msgServer) setConversationAtInfo(nctx context.Context, msg *sdkws.MsgData) {
 	log.ZDebug(nctx, "setConversationAtInfo", "msg", msg)
 	ctx := mcontext.NewCtx("@@@" + mcontext.GetOperationID(nctx))
@@ -101,7 +102,7 @@ func (m *msgServer) setConversationAtInfo(nctx context.Context, msg *sdkws.MsgDa
 			return
 		}
 		atUserID = utils.DifferenceString([]string{constant.AtAllString}, msg.AtUserIDList)
-		if len(atUserID) == 0 { //just @everyone
+		if len(atUserID) == 0 { // just @everyone
 			conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.AtAll}
 		} else { //@Everyone and @other people
 			conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.AtAllAtMe}
@@ -123,7 +124,6 @@ func (m *msgServer) setConversationAtInfo(nctx context.Context, msg *sdkws.MsgDa
 			log.ZWarn(ctx, "SetConversations", err, msg.AtUserIDList, conversation)
 		}
 	}
-
 }
 
 func (m *msgServer) sendMsgNotification(
@@ -189,3 +189,7 @@ func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *pbMsg.SendMsgReq
 		return resp, nil
 	}
 }
+
+func (m *msgServer) BatchSendMsg(ctx context.Context, in *pbMsg.BatchSendMessageReq) (*pbMsg.BatchSendMessageResp, error) {
+	return nil, nil
+}

internal/rpc/msg/seq.go

@@ -17,7 +17,7 @@ package msg
 import (
 	"context"
 
-	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
+	pbMsg "github.com/OpenIMSDK/protocol/msg"
 )
 
 func (m *msgServer) GetConversationMaxSeq(

internal/rpc/msg/server.go

@@ -16,36 +16,36 @@ package msg
 
 import (
 	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
 
 	"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"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/localcache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"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"
+	"github.com/OpenIMSDK/protocol/conversation"
+	"github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/discoveryregistry"
 )
 
-type MessageInterceptorChain []MessageInterceptorFunc
-type msgServer struct {
-	RegisterCenter         discoveryregistry.SvcDiscoveryRegistry
-	MsgDatabase            controller.CommonMsgDatabase
-	Group                  *rpcclient.GroupRpcClient
-	User                   *rpcclient.UserRpcClient
-	Conversation           *rpcclient.ConversationRpcClient
-	friend                 *rpcclient.FriendRpcClient
-	GroupLocalCache        *localcache.GroupLocalCache
-	ConversationLocalCache *localcache.ConversationLocalCache
-	MessageLocker          MessageLocker
-	Handlers               MessageInterceptorChain
-	notificationSender     *rpcclient.NotificationSender
-}
+type (
+	MessageInterceptorChain []MessageInterceptorFunc
+	msgServer               struct {
+		RegisterCenter         discoveryregistry.SvcDiscoveryRegistry
+		MsgDatabase            controller.CommonMsgDatabase
+		Group                  *rpcclient.GroupRpcClient
+		User                   *rpcclient.UserRpcClient
+		Conversation           *rpcclient.ConversationRpcClient
+		friend                 *rpcclient.FriendRpcClient
+		GroupLocalCache        *localcache.GroupLocalCache
+		ConversationLocalCache *localcache.ConversationLocalCache
+		Handlers               MessageInterceptorChain
+		notificationSender     *rpcclient.NotificationSender
+	}
+)
 
 func (m *msgServer) addInterceptorHandler(interceptorFunc ...MessageInterceptorFunc) {
 	m.Handlers = append(m.Handlers, interceptorFunc...)
@@ -80,12 +80,7 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	userRpcClient := rpcclient.NewUserRpcClient(client)
 	groupRpcClient := rpcclient.NewGroupRpcClient(client)
 	friendRpcClient := rpcclient.NewFriendRpcClient(client)
-	mysql, err := relation.NewGormDB()
-	if err != nil {
-		return err
-	}
-	msgMysModel := relation.NewChatLogGorm(mysql)
-	msgDatabase := controller.NewCommonMsgDatabase(msgDocModel, cacheModel, msgMysModel)
+	msgDatabase := controller.NewCommonMsgDatabase(msgDocModel, cacheModel)
 	s := &msgServer{
 		Conversation:           &conversationClient,
 		User:                   &userRpcClient,
@@ -95,7 +90,6 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 		GroupLocalCache:        localcache.NewGroupLocalCache(&groupRpcClient),
 		ConversationLocalCache: localcache.NewConversationLocalCache(&conversationClient),
 		friend:                 &friendRpcClient,
-		MessageLocker:          NewLockerMessage(cacheModel),
 	}
 	s.notificationSender = rpcclient.NewNotificationSender(rpcclient.WithLocalSendMsg(s.SendMsg))
 	s.addInterceptorHandler(MessageHasReadEnabled)

internal/rpc/msg/statistics.go

@@ -16,15 +16,24 @@ package msg
 
 import (
 	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
-	"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"
 	"time"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
+	"github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func (m *msgServer) GetActiveUser(ctx context.Context, req *msg.GetActiveUserReq) (*msg.GetActiveUserResp, error) {
-	msgCount, userCount, users, dateCount, err := m.MsgDatabase.RangeUserSendCount(ctx, time.UnixMilli(req.Start), time.UnixMilli(req.End), req.Group, req.Ase, req.Pagination.PageNumber, req.Pagination.ShowNumber)
+	msgCount, userCount, users, dateCount, err := m.MsgDatabase.RangeUserSendCount(
+		ctx,
+		time.UnixMilli(req.Start),
+		time.UnixMilli(req.End),
+		req.Group,
+		req.Ase,
+		req.Pagination.PageNumber,
+		req.Pagination.ShowNumber,
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -59,7 +68,14 @@ func (m *msgServer) GetActiveUser(ctx context.Context, req *msg.GetActiveUserReq
 }
 
 func (m *msgServer) GetActiveGroup(ctx context.Context, req *msg.GetActiveGroupReq) (*msg.GetActiveGroupResp, error) {
-	msgCount, groupCount, groups, dateCount, err := m.MsgDatabase.RangeGroupSendCount(ctx, time.UnixMilli(req.Start), time.UnixMilli(req.End), req.Ase, req.Pagination.PageNumber, req.Pagination.ShowNumber)
+	msgCount, groupCount, groups, dateCount, err := m.MsgDatabase.RangeGroupSendCount(
+		ctx,
+		time.UnixMilli(req.Start),
+		time.UnixMilli(req.End),
+		req.Ase,
+		req.Pagination.PageNumber,
+		req.Pagination.ShowNumber,
+	)
 	if err != nil {
 		return nil, err
 	}

internal/rpc/msg/sync_msg.go

@@ -16,13 +16,14 @@ package msg
 
 import (
 	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 
-	"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/proto/sdkws"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/tools/constant"
+
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/tokenverify"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func (m *msgServer) PullMessageBySeqs(
@@ -94,6 +95,7 @@ func (m *msgServer) GetMaxSeq(ctx context.Context, req *sdkws.GetMaxSeqReq) (*sd
 	for _, conversationID := range conversationIDs {
 		conversationIDs = append(conversationIDs, utils.GetNotificationConversationIDByConversationID(conversationID))
 	}
+	conversationIDs = append(conversationIDs, utils.GetSelfNotificationConversationID(req.UserID))
 	log.ZDebug(ctx, "GetMaxSeq", "conversationIDs", conversationIDs)
 	maxSeqs, err := m.MsgDatabase.GetMaxSeqs(ctx, conversationIDs)
 	if err != nil {
@@ -107,11 +109,11 @@ func (m *msgServer) GetMaxSeq(ctx context.Context, req *sdkws.GetMaxSeqReq) (*sd
 
 func (m *msgServer) SearchMessage(ctx context.Context, req *msg.SearchMessageReq) (resp *msg.SearchMessageResp, err error) {
 	var chatLogs []*sdkws.MsgData
+	var total int32
 	resp = &msg.SearchMessageResp{}
-	if chatLogs, err = m.MsgDatabase.SearchMessage(ctx, req); err != nil {
+	if total, chatLogs, err = m.MsgDatabase.SearchMessage(ctx, req); err != nil {
 		return nil, err
 	}
-	var num int
 	for _, chatLog := range chatLogs {
 		pbChatLog := &msg.ChatLog{}
 		utils.CopyStructFields(pbChatLog, chatLog)
@@ -130,7 +132,7 @@ func (m *msgServer) SearchMessage(ctx context.Context, req *msg.SearchMessageReq
 			if err != nil {
 				return nil, err
 			}
-			pbChatLog.SenderNickname = recvUser.Nickname
+			pbChatLog.RecvNickname = recvUser.Nickname
 
 		case constant.GroupChatType, constant.SuperGroupChatType:
 			group, err := m.Group.GetGroupInfo(ctx, chatLog.GroupID)
@@ -145,9 +147,8 @@ func (m *msgServer) SearchMessage(ctx context.Context, req *msg.SearchMessageReq
 			pbChatLog.GroupType = group.GroupType
 		}
 		resp.ChatLogs = append(resp.ChatLogs, pbChatLog)
-		num++
 	}
 
-	resp.ChatLogsNum = int32(num)
+	resp.ChatLogsNum = total
 	return resp, nil
 }

internal/rpc/msg/utils.go

@@ -18,10 +18,10 @@ 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/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func isMessageHasReadEnabled(msgData *sdkws.MsgData) bool {

internal/rpc/msg/verify.go

@@ -20,17 +20,15 @@ import (
 	"strconv"
 	"time"
 
-	"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/errs"
-	"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/OpenIMSDK/protocol/msg"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
-var (
-	ExcludeContentType = []int{constant.HasReadReceipt}
-)
+var ExcludeContentType = []int{constant.HasReadReceipt}
 
 type Validator interface {
 	validate(pb *msg.SendMsgReq) (bool, int32, string)
@@ -126,6 +124,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 		return nil
 	}
 }
+
 func (m *msgServer) encapsulateMsgData(msg *sdkws.MsgData) {
 	msg.ServerMsgID = GetMsgID(msg.SendID)
 	msg.SendTime = utils.GetCurrentTimestampByMill()

internal/rpc/third/s3.go

@@ -16,14 +16,15 @@ package third
 
 import (
 	"context"
+	"time"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/s3/cont"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
-	"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/errs"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/third"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"time"
+	"github.com/OpenIMSDK/protocol/third"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func (t *thirdServer) PartLimit(ctx context.Context, req *third.PartLimitReq) (*third.PartLimitResp, error) {

internal/rpc/third/third.go

@@ -17,22 +17,24 @@ package third
 import (
 	"context"
 	"fmt"
+	"net/url"
+	"time"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/s3"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/s3/cos"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/s3/minio"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/s3/oss"
-	"net/url"
-	"time"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"google.golang.org/grpc"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
 	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
-	"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"
+	"github.com/OpenIMSDK/protocol/third"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/discoveryregistry"
 )
 
 func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {

internal/rpc/third/tool.go

@@ -18,12 +18,13 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/third"
 	"strings"
 	"unicode/utf8"
+
+	"github.com/OpenIMSDK/protocol/third"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/tokenverify"
 )
 
 func toPbMapArray(m map[string][]string) []*third.KeyValues {

internal/rpc/user/statistics.go

@@ -18,8 +18,8 @@ import (
 	"context"
 	"time"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	pbuser "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/user"
+	pbuser "github.com/OpenIMSDK/protocol/user"
+	"github.com/OpenIMSDK/tools/errs"
 )
 
 func (s *userServer) UserRegisterCount(

internal/rpc/user/user.go

@@ -17,28 +17,30 @@ package user
 import (
 	"context"
 	"errors"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"strings"
 	"time"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/tools/log"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
 	tablerelation "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/tx"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-	registry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-	pbuser "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/user"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"
+	"github.com/OpenIMSDK/protocol/sdkws"
+	pbuser "github.com/OpenIMSDK/protocol/user"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/constant"
+	registry "github.com/OpenIMSDK/tools/discoveryregistry"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/tokenverify"
+	"github.com/OpenIMSDK/tools/tx"
 
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"google.golang.org/grpc"
+
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type userServer struct {
@@ -65,7 +67,7 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 		return errors.New("len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname)")
 	}
 	for k, v := range config.Config.Manager.UserID {
-		users = append(users, &tablerelation.UserModel{UserID: v, Nickname: config.Config.Manager.Nickname[k]})
+		users = append(users, &tablerelation.UserModel{UserID: v, Nickname: config.Config.Manager.Nickname[k], AppMangerLevel: constant.AppAdmin})
 	}
 	userDB := relation.NewUserGorm(db)
 	cache := cache.NewUserCacheRedis(rdb, userDB, cache.GetDefaultOpt())
@@ -233,7 +235,7 @@ func (s *userServer) GetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.Ge
 }
 
 func (s *userServer) GetAllUserID(ctx context.Context, req *pbuser.GetAllUserIDReq) (resp *pbuser.GetAllUserIDResp, err error) {
-	userIDs, err := s.UserDatabase.GetAllUserID(ctx)
+	userIDs, err := s.UserDatabase.GetAllUserID(ctx, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}

internal/tools/conversation.go

@@ -18,9 +18,9 @@ import (
 	"context"
 	"time"
 
-	"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/utils"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 func (c *MsgTool) ConversationsDestructMsgs() {
@@ -33,17 +33,30 @@ func (c *MsgTool) ConversationsDestructMsgs() {
 	}
 	log.ZDebug(context.Background(), "nums conversations need destruct", "nums", len(conversations))
 	for _, conversation := range conversations {
-		log.ZDebug(ctx, "UserMsgsDestruct", "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID, "msgDestructTime", conversation.MsgDestructTime, "lastMsgDestructTime", conversation.LatestMsgDestructTime)
+		ctx = mcontext.NewCtx(utils.GetSelfFuncName() + "-" + utils.OperationIDGenerator() + "-" + conversation.ConversationID + "-" + conversation.OwnerUserID)
+		log.ZDebug(
+			ctx,
+			"UserMsgsDestruct",
+			"conversationID",
+			conversation.ConversationID,
+			"ownerUserID",
+			conversation.OwnerUserID,
+			"msgDestructTime",
+			conversation.MsgDestructTime,
+			"lastMsgDestructTime",
+			conversation.LatestMsgDestructTime,
+		)
+		now := time.Now()
 		seqs, err := c.msgDatabase.UserMsgsDestruct(ctx, conversation.OwnerUserID, conversation.ConversationID, conversation.MsgDestructTime, conversation.LatestMsgDestructTime)
 		if err != nil {
 			log.ZError(ctx, "user msg destruct failed", err, "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID)
 			continue
 		}
-		if err := c.conversationDatabase.UpdateUsersConversationFiled(ctx, []string{conversation.OwnerUserID}, conversation.ConversationID, map[string]interface{}{"latest_msg_destruct_time": time.Now()}); err != nil {
-			log.ZError(ctx, "updateUsersConversationFiled failed", err, "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID)
-			continue
-		}
 		if len(seqs) > 0 {
+			if err := c.conversationDatabase.UpdateUsersConversationFiled(ctx, []string{conversation.OwnerUserID}, conversation.ConversationID, map[string]interface{}{"latest_msg_destruct_time": now}); err != nil {
+				log.ZError(ctx, "updateUsersConversationFiled failed", err, "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID)
+				continue
+			}
 			if err := c.msgNotificationSender.UserDeleteMsgsNotification(ctx, conversation.OwnerUserID, conversation.ConversationID, seqs); err != nil {
 				log.ZError(ctx, "userDeleteMsgsNotification failed", err, "conversationID", conversation.ConversationID, "ownerUserID", conversation.OwnerUserID)
 			}

internal/tools/cron_task.go

@@ -21,8 +21,8 @@ import (
 
 	"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/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/log"
 )
 
 func StartCronTask() error {

internal/tools/msg.go

@@ -20,23 +20,24 @@ import (
 	"math"
 	"time"
 
-	"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"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/tx"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"
-	"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/common/mw"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry/zookeeper"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	"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"
 	"github.com/redis/go-redis/v9"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"
+	"github.com/OpenIMSDK/tools/config"
+	"github.com/OpenIMSDK/tools/discoveryregistry/zookeeper"
+	"github.com/OpenIMSDK/tools/errs"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/mw"
+	"github.com/OpenIMSDK/tools/tx"
+	"github.com/OpenIMSDK/tools/utils"
 )
 
 type MsgTool struct {
@@ -48,7 +49,8 @@ type MsgTool struct {
 }
 
 func NewMsgTool(msgDatabase controller.CommonMsgDatabase, userDatabase controller.UserDatabase,
-	groupDatabase controller.GroupDatabase, conversationDatabase controller.ConversationDatabase, msgNotificationSender *notification.MsgNotificationSender) *MsgTool {
+	groupDatabase controller.GroupDatabase, conversationDatabase controller.ConversationDatabase, msgNotificationSender *notification.MsgNotificationSender,
+) *MsgTool {
 	return &MsgTool{
 		msgDatabase:           msgDatabase,
 		userDatabase:          userDatabase,
@@ -79,14 +81,18 @@ func InitMsgTool() (*MsgTool, error) {
 	}
 	discov.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()))
 	userDB := relation.NewUserGorm(db)
-	msgDatabase := controller.InitCommonMsgDatabase(rdb, mongo.GetDatabase(), db)
+	msgDatabase := controller.InitCommonMsgDatabase(rdb, mongo.GetDatabase())
 	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),
+	)
 	msgRpcClient := rpcclient.NewMessageRpcClient(discov)
 	msgNotificationSender := notification.NewMsgNotificationSender(rpcclient.WithRpcClient(&msgRpcClient))
 	msgTool := NewMsgTool(msgDatabase, userDatabase, groupDatabase, conversationDatabase, msgNotificationSender)

internal/tools/msg_test.go

@@ -20,10 +20,10 @@ import (
 
 	"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"
+	"github.com/OpenIMSDK/tools/constant"
+	"github.com/OpenIMSDK/tools/mcontext"
+	"github.com/OpenIMSDK/tools/utils"
 
 	unRelationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"