Error code standardization

2026-05-19 00:09:02 +08:00 · 2023-02-10 22:10:37 +08:00
parent adc84b68e7
commit 452d9840bf
21 changed files with 1307 additions and 2909 deletions
@@ -0,0 +1,289 @@
+package notification
+
+import (
+	"Open_IM/pkg/common/constant"
+	pbChat "Open_IM/pkg/proto/msg"
+	"strings"
+)
+
+type NotificationMsg struct {
+	SendID         string
+	RecvID         string
+	Content        []byte //  sdkws.TipsComm
+	MsgFrom        int32
+	ContentType    int32
+	SessionType    int32
+	OperationID    string
+	SenderNickname string
+	SenderFaceURL  string
+}
+
+func Notification(n *NotificationMsg) {
+	var req pbChat.SendMsgReq
+	var msg sdkws.MsgData
+	var offlineInfo sdkws.OfflinePushInfo
+	var title, desc, ex string
+	var pushSwitch, unReadCount bool
+	var reliabilityLevel int
+	req.OperationID = n.OperationID
+	msg.SendID = n.SendID
+	msg.RecvID = n.RecvID
+	msg.Content = n.Content
+	msg.MsgFrom = n.MsgFrom
+	msg.ContentType = n.ContentType
+	msg.SessionType = n.SessionType
+	msg.CreateTime = utils.GetCurrentTimestampByMill()
+	msg.ClientMsgID = utils.GetMsgID(n.SendID)
+	msg.Options = make(map[string]bool, 7)
+	msg.SenderNickname = n.SenderNickname
+	msg.SenderFaceURL = n.SenderFaceURL
+	switch n.SessionType {
+	case constant.GroupChatType, constant.SuperGroupChatType:
+		msg.RecvID = ""
+		msg.GroupID = n.RecvID
+	}
+	offlineInfo.IOSBadgeCount = config.Config.IOSPush.BadgeCount
+	offlineInfo.IOSPushSound = config.Config.IOSPush.PushSound
+	switch msg.ContentType {
+	case constant.GroupCreatedNotification:
+		pushSwitch = config.Config.Notification.GroupCreated.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupCreated.OfflinePush.Title
+		desc = config.Config.Notification.GroupCreated.OfflinePush.Desc
+		ex = config.Config.Notification.GroupCreated.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupCreated.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupCreated.Conversation.UnreadCount
+	case constant.GroupInfoSetNotification:
+		pushSwitch = config.Config.Notification.GroupInfoSet.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupInfoSet.OfflinePush.Title
+		desc = config.Config.Notification.GroupInfoSet.OfflinePush.Desc
+		ex = config.Config.Notification.GroupInfoSet.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupInfoSet.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupInfoSet.Conversation.UnreadCount
+	case constant.JoinGroupApplicationNotification:
+		pushSwitch = config.Config.Notification.JoinGroupApplication.OfflinePush.PushSwitch
+		title = config.Config.Notification.JoinGroupApplication.OfflinePush.Title
+		desc = config.Config.Notification.JoinGroupApplication.OfflinePush.Desc
+		ex = config.Config.Notification.JoinGroupApplication.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.JoinGroupApplication.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.JoinGroupApplication.Conversation.UnreadCount
+	case constant.MemberQuitNotification:
+		pushSwitch = config.Config.Notification.MemberQuit.OfflinePush.PushSwitch
+		title = config.Config.Notification.MemberQuit.OfflinePush.Title
+		desc = config.Config.Notification.MemberQuit.OfflinePush.Desc
+		ex = config.Config.Notification.MemberQuit.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.MemberQuit.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.MemberQuit.Conversation.UnreadCount
+	case constant.GroupApplicationAcceptedNotification:
+		pushSwitch = config.Config.Notification.GroupApplicationAccepted.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Title
+		desc = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Desc
+		ex = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupApplicationAccepted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupApplicationAccepted.Conversation.UnreadCount
+	case constant.GroupApplicationRejectedNotification:
+		pushSwitch = config.Config.Notification.GroupApplicationRejected.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupApplicationRejected.OfflinePush.Title
+		desc = config.Config.Notification.GroupApplicationRejected.OfflinePush.Desc
+		ex = config.Config.Notification.GroupApplicationRejected.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupApplicationRejected.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupApplicationRejected.Conversation.UnreadCount
+	case constant.GroupOwnerTransferredNotification:
+		pushSwitch = config.Config.Notification.GroupOwnerTransferred.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Title
+		desc = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Desc
+		ex = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupOwnerTransferred.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupOwnerTransferred.Conversation.UnreadCount
+	case constant.MemberKickedNotification:
+		pushSwitch = config.Config.Notification.MemberKicked.OfflinePush.PushSwitch
+		title = config.Config.Notification.MemberKicked.OfflinePush.Title
+		desc = config.Config.Notification.MemberKicked.OfflinePush.Desc
+		ex = config.Config.Notification.MemberKicked.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.MemberKicked.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.MemberKicked.Conversation.UnreadCount
+	case constant.MemberInvitedNotification:
+		pushSwitch = config.Config.Notification.MemberInvited.OfflinePush.PushSwitch
+		title = config.Config.Notification.MemberInvited.OfflinePush.Title
+		desc = config.Config.Notification.MemberInvited.OfflinePush.Desc
+		ex = config.Config.Notification.MemberInvited.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.MemberInvited.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.MemberInvited.Conversation.UnreadCount
+	case constant.MemberEnterNotification:
+		pushSwitch = config.Config.Notification.MemberEnter.OfflinePush.PushSwitch
+		title = config.Config.Notification.MemberEnter.OfflinePush.Title
+		desc = config.Config.Notification.MemberEnter.OfflinePush.Desc
+		ex = config.Config.Notification.MemberEnter.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.MemberEnter.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.MemberEnter.Conversation.UnreadCount
+	case constant.UserInfoUpdatedNotification:
+		pushSwitch = config.Config.Notification.UserInfoUpdated.OfflinePush.PushSwitch
+		title = config.Config.Notification.UserInfoUpdated.OfflinePush.Title
+		desc = config.Config.Notification.UserInfoUpdated.OfflinePush.Desc
+		ex = config.Config.Notification.UserInfoUpdated.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.UserInfoUpdated.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.UserInfoUpdated.Conversation.UnreadCount
+	case constant.FriendApplicationNotification:
+		pushSwitch = config.Config.Notification.FriendApplication.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendApplication.OfflinePush.Title
+		desc = config.Config.Notification.FriendApplication.OfflinePush.Desc
+		ex = config.Config.Notification.FriendApplication.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendApplication.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendApplication.Conversation.UnreadCount
+	case constant.FriendApplicationApprovedNotification:
+		pushSwitch = config.Config.Notification.FriendApplicationApproved.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendApplicationApproved.OfflinePush.Title
+		desc = config.Config.Notification.FriendApplicationApproved.OfflinePush.Desc
+		ex = config.Config.Notification.FriendApplicationApproved.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendApplicationApproved.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendApplicationApproved.Conversation.UnreadCount
+	case constant.FriendApplicationRejectedNotification:
+		pushSwitch = config.Config.Notification.FriendApplicationRejected.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendApplicationRejected.OfflinePush.Title
+		desc = config.Config.Notification.FriendApplicationRejected.OfflinePush.Desc
+		ex = config.Config.Notification.FriendApplicationRejected.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendApplicationRejected.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendApplicationRejected.Conversation.UnreadCount
+	case constant.FriendAddedNotification:
+		pushSwitch = config.Config.Notification.FriendAdded.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendAdded.OfflinePush.Title
+		desc = config.Config.Notification.FriendAdded.OfflinePush.Desc
+		ex = config.Config.Notification.FriendAdded.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendAdded.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendAdded.Conversation.UnreadCount
+	case constant.FriendDeletedNotification:
+		pushSwitch = config.Config.Notification.FriendDeleted.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendDeleted.OfflinePush.Title
+		desc = config.Config.Notification.FriendDeleted.OfflinePush.Desc
+		ex = config.Config.Notification.FriendDeleted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendDeleted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendDeleted.Conversation.UnreadCount
+	case constant.FriendRemarkSetNotification:
+		pushSwitch = config.Config.Notification.FriendRemarkSet.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendRemarkSet.OfflinePush.Title
+		desc = config.Config.Notification.FriendRemarkSet.OfflinePush.Desc
+		ex = config.Config.Notification.FriendRemarkSet.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendRemarkSet.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendRemarkSet.Conversation.UnreadCount
+	case constant.BlackAddedNotification:
+		pushSwitch = config.Config.Notification.BlackAdded.OfflinePush.PushSwitch
+		title = config.Config.Notification.BlackAdded.OfflinePush.Title
+		desc = config.Config.Notification.BlackAdded.OfflinePush.Desc
+		ex = config.Config.Notification.BlackAdded.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.BlackAdded.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.BlackAdded.Conversation.UnreadCount
+	case constant.BlackDeletedNotification:
+		pushSwitch = config.Config.Notification.BlackDeleted.OfflinePush.PushSwitch
+		title = config.Config.Notification.BlackDeleted.OfflinePush.Title
+		desc = config.Config.Notification.BlackDeleted.OfflinePush.Desc
+		ex = config.Config.Notification.BlackDeleted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.BlackDeleted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.BlackDeleted.Conversation.UnreadCount
+	case constant.ConversationOptChangeNotification:
+		pushSwitch = config.Config.Notification.ConversationOptUpdate.OfflinePush.PushSwitch
+		title = config.Config.Notification.ConversationOptUpdate.OfflinePush.Title
+		desc = config.Config.Notification.ConversationOptUpdate.OfflinePush.Desc
+		ex = config.Config.Notification.ConversationOptUpdate.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.ConversationOptUpdate.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.ConversationOptUpdate.Conversation.UnreadCount
+
+	case constant.GroupDismissedNotification:
+		pushSwitch = config.Config.Notification.GroupDismissed.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupDismissed.OfflinePush.Title
+		desc = config.Config.Notification.GroupDismissed.OfflinePush.Desc
+		ex = config.Config.Notification.GroupDismissed.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupDismissed.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupDismissed.Conversation.UnreadCount
+
+	case constant.GroupMutedNotification:
+		pushSwitch = config.Config.Notification.GroupMuted.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupMuted.OfflinePush.Title
+		desc = config.Config.Notification.GroupMuted.OfflinePush.Desc
+		ex = config.Config.Notification.GroupMuted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupMuted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupMuted.Conversation.UnreadCount
+
+	case constant.GroupCancelMutedNotification:
+		pushSwitch = config.Config.Notification.GroupCancelMuted.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupCancelMuted.OfflinePush.Title
+		desc = config.Config.Notification.GroupCancelMuted.OfflinePush.Desc
+		ex = config.Config.Notification.GroupCancelMuted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupCancelMuted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupCancelMuted.Conversation.UnreadCount
+
+	case constant.GroupMemberMutedNotification:
+		pushSwitch = config.Config.Notification.GroupMemberMuted.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupMemberMuted.OfflinePush.Title
+		desc = config.Config.Notification.GroupMemberMuted.OfflinePush.Desc
+		ex = config.Config.Notification.GroupMemberMuted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupMemberMuted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupMemberMuted.Conversation.UnreadCount
+
+	case constant.GroupMemberCancelMutedNotification:
+		pushSwitch = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Title
+		desc = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Desc
+		ex = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupMemberCancelMuted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupMemberCancelMuted.Conversation.UnreadCount
+
+	case constant.GroupMemberInfoSetNotification:
+		pushSwitch = config.Config.Notification.GroupMemberInfoSet.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Title
+		desc = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Desc
+		ex = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupMemberInfoSet.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupMemberInfoSet.Conversation.UnreadCount
+
+	case constant.ConversationPrivateChatNotification:
+		pushSwitch = config.Config.Notification.ConversationSetPrivate.OfflinePush.PushSwitch
+		title = config.Config.Notification.ConversationSetPrivate.OfflinePush.Title
+		desc = config.Config.Notification.ConversationSetPrivate.OfflinePush.Desc
+		ex = config.Config.Notification.ConversationSetPrivate.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.ConversationSetPrivate.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.ConversationSetPrivate.Conversation.UnreadCount
+	case constant.FriendInfoUpdatedNotification:
+		pushSwitch = config.Config.Notification.FriendInfoUpdated.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendInfoUpdated.OfflinePush.Title
+		desc = config.Config.Notification.FriendInfoUpdated.OfflinePush.Desc
+		ex = config.Config.Notification.FriendInfoUpdated.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendInfoUpdated.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendInfoUpdated.Conversation.UnreadCount
+	case constant.DeleteMessageNotification:
+		reliabilityLevel = constant.ReliableNotificationNoMsg
+	case constant.ConversationUnreadNotification, constant.SuperGroupUpdateNotification:
+		reliabilityLevel = constant.UnreliableNotification
+	}
+	switch reliabilityLevel {
+	case constant.UnreliableNotification:
+		utils.SetSwitchFromOptions(msg.Options, constant.IsHistory, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsPersistent, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
+	case constant.ReliableNotificationNoMsg:
+		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
+	case constant.ReliableNotificationMsg:
+
+	}
+	utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, unReadCount)
+	utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, pushSwitch)
+	offlineInfo.Title = title
+	offlineInfo.Desc = desc
+	offlineInfo.Ex = ex
+	msg.OfflinePushInfo = &offlineInfo
+	req.MsgData = &msg
+	etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		return
+	}
+
+	client := pbChat.NewMsgClient(etcdConn)
+	reply, err := client.SendMsg(context.Background(), &req)
+	if err != nil {
+		log.NewError(req.OperationID, "SendMsg rpc failed, ", req.String(), err.Error())
+	} else if reply.ErrCode != 0 {
+		log.NewError(req.OperationID, "SendMsg rpc failed, ", req.String(), reply.ErrCode, reply.ErrMsg)
+	}
+}
@@ -1,100 +0,0 @@
-package notification
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/proto/msg"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-)
-
-func ExtendMessageUpdatedNotification(operationID, sendID string, sourceID string, sessionType int32,
-	req *msg.SetMessageReactionExtensionsReq, resp *msg.SetMessageReactionExtensionsResp, isHistory bool, isReactionFromCache bool) {
-	var m apistruct.ReactionMessageModifierNotification
-	m.SourceID = req.SourceID
-	m.OpUserID = req.OpUserID
-	m.SessionType = req.SessionType
-	keyMap := make(map[string]*sdkws.KeyValue)
-	for _, valueResp := range resp.Result {
-		if valueResp.ErrCode == 0 {
-			keyMap[valueResp.KeyValue.TypeKey] = valueResp.KeyValue
-		}
-	}
-	if len(keyMap) == 0 {
-		log.NewWarn(operationID, "all key set failed can not send notification", *req)
-		return
-	}
-	m.SuccessReactionExtensionList = keyMap
-	m.ClientMsgID = req.ClientMsgID
-	m.IsReact = resp.IsReact
-	m.IsExternalExtensions = req.IsExternalExtensions
-	m.MsgFirstModifyTime = resp.MsgFirstModifyTime
-	messageReactionSender(operationID, sendID, sourceID, sessionType, constant.ReactionMessageModifier, utils.StructToJsonString(m), isHistory, isReactionFromCache)
-}
-func ExtendMessageDeleteNotification(operationID, sendID string, sourceID string, sessionType int32,
-	req *msg.DeleteMessageListReactionExtensionsReq, resp *msg.DeleteMessageListReactionExtensionsResp, isHistory bool, isReactionFromCache bool) {
-	var m apistruct.ReactionMessageDeleteNotification
-	m.SourceID = req.SourceID
-	m.OpUserID = req.OpUserID
-	m.SessionType = req.SessionType
-	keyMap := make(map[string]*sdkws.KeyValue)
-	for _, valueResp := range resp.Result {
-		if valueResp.ErrCode == 0 {
-			keyMap[valueResp.KeyValue.TypeKey] = valueResp.KeyValue
-		}
-	}
-	if len(keyMap) == 0 {
-		log.NewWarn(operationID, "all key set failed can not send notification", *req)
-		return
-	}
-	m.SuccessReactionExtensionList = keyMap
-	m.ClientMsgID = req.ClientMsgID
-	m.MsgFirstModifyTime = req.MsgFirstModifyTime
-
-	messageReactionSender(operationID, sendID, sourceID, sessionType, constant.ReactionMessageDeleter, utils.StructToJsonString(m), isHistory, isReactionFromCache)
-}
-func messageReactionSender(operationID, sendID string, sourceID string, sessionType, contentType int32, content string, isHistory bool, isReactionFromCache bool) {
-	options := make(map[string]bool, 5)
-	utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false)
-	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, false)
-	utils.SetSwitchFromOptions(options, constant.IsSenderConversationUpdate, false)
-	utils.SetSwitchFromOptions(options, constant.IsUnreadCount, false)
-	utils.SetSwitchFromOptions(options, constant.IsReactionFromCache, isReactionFromCache)
-	if !isHistory {
-		utils.SetSwitchFromOptions(options, constant.IsHistory, false)
-		utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
-	}
-	pbData := msg.SendMsgReq{
-		OperationID: operationID,
-		MsgData: &sdkws.MsgData{
-			SendID:      sendID,
-			ClientMsgID: utils.GetMsgID(sendID),
-			SessionType: sessionType,
-			MsgFrom:     constant.SysMsgType,
-			ContentType: contentType,
-			Content:     []byte(content),
-			//	ForceList:        params.ForceList,
-			CreateTime: utils.GetCurrentTimestampByMill(),
-			Options:    options,
-		},
-	}
-	switch sessionType {
-	case constant.SingleChatType, constant.NotificationChatType:
-		pbData.MsgData.RecvID = sourceID
-	case constant.GroupChatType, constant.SuperGroupChatType:
-		pbData.MsgData.GroupID = sourceID
-	}
-	etcdConn, err := rpc.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImMsgName)
-	if err != nil {
-		return
-	}
-	client := msg.NewMsgClient(etcdConn)
-	reply, err := client.SendMsg(context.Background(), &pbData)
-	if err != nil {
-		log.NewError(operationID, "SendMsg rpc failed, ", pbData.String(), err.Error())
-	} else if reply.ErrCode != 0 {
-		log.NewError(operationID, "SendMsg rpc failed, ", pbData.String(), reply.ErrCode, reply.ErrMsg)
-	}
-}
@@ -1,62 +0,0 @@
-package notification
-
-import (
-	cbApi "Open_IM/pkg/callback_struct"
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/http"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	http2 "net/http"
-)
-
-func callbackSetMessageReactionExtensions(setReq *msg.SetMessageReactionExtensionsReq) *cbApi.CallbackBeforeSetMessageReactionExtResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: setReq.OperationID}
-	log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String())
-	req := cbApi.CallbackBeforeSetMessageReactionExtReq{
-		OperationID:           setReq.OperationID,
-		CallbackCommand:       constant.CallbackBeforeSetMessageReactionExtensionCommand,
-		SourceID:              setReq.SourceID,
-		OpUserID:              setReq.OpUserID,
-		SessionType:           setReq.SessionType,
-		ReactionExtensionList: setReq.ReactionExtensionList,
-		ClientMsgID:           setReq.ClientMsgID,
-		IsReact:               setReq.IsReact,
-		IsExternalExtensions:  setReq.IsExternalExtensions,
-		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
-	}
-	resp := &cbApi.CallbackBeforeSetMessageReactionExtResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSetMessageReactionExtensionCommand,
-		req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-	}
-	return resp
-
-}
-
-func callbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessageListReactionExtensionsReq) *cbApi.CallbackDeleteMessageReactionExtResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: setReq.OperationID}
-	log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String())
-	req := cbApi.CallbackDeleteMessageReactionExtReq{
-		OperationID:           setReq.OperationID,
-		CallbackCommand:       constant.CallbackBeforeDeleteMessageReactionExtensionsCommand,
-		SourceID:              setReq.SourceID,
-		OpUserID:              setReq.OpUserID,
-		SessionType:           setReq.SessionType,
-		ReactionExtensionList: setReq.ReactionExtensionList,
-		ClientMsgID:           setReq.ClientMsgID,
-		IsExternalExtensions:  setReq.IsExternalExtensions,
-		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
-	}
-	resp := &cbApi.CallbackDeleteMessageReactionExtResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeDeleteMessageReactionExtensionsCommand,
-		req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-	}
-	return resp
-}
@@ -1,174 +0,0 @@
-package notification
-
-import (
-	"Open_IM/internal/common/check"
-	"Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tracelog"
-	pbFriend "Open_IM/pkg/proto/friend"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-)
-
-func getFromToUserNickname(fromUserID, toUserID string) (string, string, error) {
-	users, err := check.GetUsersInfo(context.Background(), fromUserID, toUserID)
-	if err != nil {
-		return "", "", nil
-	}
-	if users[0].UserID == fromUserID {
-		return users[0].Nickname, users[1].Nickname, nil
-	}
-	return users[1].Nickname, users[0].Nickname, nil
-
-}
-
-func friendNotification(operationID, fromUserID, toUserID string, contentType int32, m proto.Message) {
-	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType)
-	var err error
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
-		return
-	}
-
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-
-	fromUserNickname, toUserNickname, err := getFromToUserNickname(fromUserID, toUserID)
-	if err != nil {
-		log.Error(operationID, "getFromToUserNickname failed ", err.Error(), fromUserID, toUserID)
-		return
-	}
-	cn := config.Config.Notification
-	switch contentType {
-	case constant.FriendApplicationNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendApplication.DefaultTips.Tips
-	case constant.FriendApplicationApprovedNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendApplicationApproved.DefaultTips.Tips
-	case constant.FriendApplicationRejectedNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendApplicationRejected.DefaultTips.Tips
-	case constant.FriendAddedNotification:
-		tips.DefaultTips = cn.FriendAdded.DefaultTips.Tips
-	case constant.FriendDeletedNotification:
-		tips.DefaultTips = cn.FriendDeleted.DefaultTips.Tips + toUserNickname
-	case constant.FriendRemarkSetNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendRemarkSet.DefaultTips.Tips
-	case constant.BlackAddedNotification:
-		tips.DefaultTips = cn.BlackAdded.DefaultTips.Tips
-	case constant.BlackDeletedNotification:
-		tips.DefaultTips = cn.BlackDeleted.DefaultTips.Tips + toUserNickname
-	case constant.UserInfoUpdatedNotification:
-		tips.DefaultTips = cn.UserInfoUpdated.DefaultTips.Tips
-	case constant.FriendInfoUpdatedNotification:
-		tips.DefaultTips = cn.FriendInfoUpdated.DefaultTips.Tips + toUserNickname
-	default:
-		log.Error(operationID, "contentType failed ", contentType)
-		return
-	}
-
-	var n msg.NotificationMsg
-	n.SendID = fromUserID
-	n.RecvID = toUserID
-	n.ContentType = contentType
-	n.SessionType = constant.SingleChatType
-	n.MsgFrom = constant.SysMsgType
-	n.OperationID = operationID
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
-		return
-	}
-	msg.Notification(&n)
-}
-
-func FriendApplicationAddNotification(ctx context.Context, req *pbFriend.AddFriendReq) {
-	FriendApplicationTips := sdkws.FriendApplicationTips{FromToUserID: &sdkws.FromToUserID{}}
-	FriendApplicationTips.FromToUserID.FromUserID = req.FromUserID
-	FriendApplicationTips.FromToUserID.ToUserID = req.ToUserID
-	friendNotification(tracelog.GetOperationID(ctx), req.FromUserID, req.ToUserID, constant.FriendApplicationNotification, &FriendApplicationTips)
-}
-
-func FriendApplicationAgreedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
-	FriendApplicationApprovedTips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{}}
-	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID
-	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID
-	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
-	friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
-}
-
-func FriendApplicationRefusedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
-	FriendApplicationApprovedTips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{}}
-	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID
-	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID
-	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
-	friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
-}
-
-func FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) {
-	friendAddedTips := sdkws.FriendAddedTips{Friend: &sdkws.FriendInfo{}, OpUser: &sdkws.PublicUserInfo{}}
-	user, err := check.GetUsersInfo(context.Background(), opUserID)
-	if err != nil {
-		return
-	}
-	friendAddedTips.OpUser.UserID = user[0].UserID
-	friendAddedTips.OpUser.Ex = user[0].Ex
-	friendAddedTips.OpUser.Nickname = user[0].Nickname
-	friendAddedTips.OpUser.FaceURL = user[0].FaceURL
-
-	friend, err := check.GetFriendsInfo(ctx, fromUserID, toUserID)
-	if err != nil {
-		return
-	}
-	friendAddedTips.Friend = friend
-	friendNotification(operationID, fromUserID, toUserID, constant.FriendAddedNotification, &friendAddedTips)
-}
-
-func FriendDeletedNotification(ctx context.Context, req *pbFriend.DeleteFriendReq) {
-	friendDeletedTips := sdkws.FriendDeletedTips{FromToUserID: &sdkws.FromToUserID{}}
-	friendDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
-	friendDeletedTips.FromToUserID.ToUserID = req.FriendUserID
-	friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.FriendUserID, constant.FriendDeletedNotification, &friendDeletedTips)
-}
-
-func FriendRemarkSetNotification(ctx context.Context, fromUserID, toUserID string) {
-	friendInfoChangedTips := sdkws.FriendInfoChangedTips{FromToUserID: &sdkws.FromToUserID{}}
-	friendInfoChangedTips.FromToUserID.FromUserID = fromUserID
-	friendInfoChangedTips.FromToUserID.ToUserID = toUserID
-	friendNotification(tracelog.GetOperationID(ctx), fromUserID, toUserID, constant.FriendRemarkSetNotification, &friendInfoChangedTips)
-}
-
-func BlackAddedNotification(ctx context.Context, req *pbFriend.AddBlackReq) {
-	blackAddedTips := sdkws.BlackAddedTips{FromToUserID: &sdkws.FromToUserID{}}
-	blackAddedTips.FromToUserID.FromUserID = req.OwnerUserID
-	blackAddedTips.FromToUserID.ToUserID = req.BlackUserID
-	friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackAddedNotification, &blackAddedTips)
-}
-
-func BlackDeletedNotification(ctx context.Context, req *pbFriend.RemoveBlackReq) {
-	blackDeletedTips := sdkws.BlackDeletedTips{FromToUserID: &sdkws.FromToUserID{}}
-	blackDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
-	blackDeletedTips.FromToUserID.ToUserID = req.BlackUserID
-	friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackDeletedNotification, &blackDeletedTips)
-}
-
-// send to myself
-func UserInfoUpdatedNotification(ctx context.Context, opUserID string, changedUserID string) {
-	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
-	friendNotification(tracelog.GetOperationID(ctx), opUserID, changedUserID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
-}
-
-func FriendInfoUpdatedNotification(ctx context.Context, changedUserID string, needNotifiedUserID string, opUserID string) {
-	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
-	friendNotification(tracelog.GetOperationID(ctx), opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
-}
@@ -1,622 +0,0 @@
-package notification
-
-import (
-	"Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tokenverify"
-	utils2 "Open_IM/pkg/common/utils"
-	pbGroup "Open_IM/pkg/proto/group"
-	"Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-	"google.golang.org/protobuf/types/known/wrapperspb"
-)
-
-//message GroupCreatedTips{
-//  GroupInfo Group = 1;
-//  GroupMemberFullInfo Creator = 2;
-//  repeated GroupMemberFullInfo MemberList = 3;
-//  uint64 OperationTime = 4;
-//} creator->group
-
-func setOpUserInfo(opUserID, groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	if tokenverify.IsManagerUserID(opUserID) {
-		u, err := imdb.GetUserByUserID(opUserID)
-		if err != nil {
-			return utils.Wrap(err, "GetUserByUserID failed")
-		}
-		utils.CopyStructFields(groupMemberInfo, u)
-		groupMemberInfo.GroupID = groupID
-	} else {
-		u, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, opUserID)
-		if err == nil {
-			if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, u); err != nil {
-				return utils.Wrap(err, "")
-			}
-		}
-		user, err := imdb.GetUserByUserID(opUserID)
-		if err != nil {
-			return utils.Wrap(err, "")
-		}
-		groupMemberInfo.GroupID = groupID
-		groupMemberInfo.UserID = user.UserID
-		groupMemberInfo.Nickname = user.Nickname
-		groupMemberInfo.AppMangerLevel = user.AppMangerLevel
-		groupMemberInfo.FaceURL = user.FaceURL
-	}
-	return nil
-}
-
-func setGroupInfo(groupID string, groupInfo *sdkws.GroupInfo) error {
-	group, err := imdb.GetGroupInfoByGroupID(groupID)
-	if err != nil {
-		return utils.Wrap(err, "GetGroupInfoByGroupID failed")
-	}
-	err = utils2.GroupDBCopyOpenIM(groupInfo, group)
-	if err != nil {
-		log.NewWarn("", "GroupDBCopyOpenIM failed ", groupID, err.Error())
-		return nil
-	}
-	return nil
-}
-
-func setGroupMemberInfo(groupID, userID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	groupMember, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
-	if err == nil {
-		return utils.Wrap(utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember), "")
-	}
-
-	user, err := imdb.GetUserByUserID(userID)
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-	groupMemberInfo.GroupID = groupID
-	groupMemberInfo.UserID = user.UserID
-	groupMemberInfo.Nickname = user.Nickname
-	groupMemberInfo.AppMangerLevel = user.AppMangerLevel
-	groupMemberInfo.FaceURL = user.FaceURL
-	return nil
-}
-
-func setGroupOwnerInfo(groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	groupMember, err := imdb.GetGroupOwnerInfoByGroupID(groupID)
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-	if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember); err != nil {
-		return utils.Wrap(err, "")
-	}
-	return nil
-}
-
-func setPublicUserInfo(userID string, publicUserInfo *sdkws.PublicUserInfo) error {
-	user, err := imdb.GetUserByUserID(userID)
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-	utils2.UserDBCopyOpenIMPublicUser(publicUserInfo, user)
-	return nil
-}
-
-func groupNotification(contentType int32, m proto.Message, sendID, groupID, recvUserID, operationID string) {
-	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType, sendID, groupID, recvUserID)
-
-	var err error
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
-		return
-	}
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-	var nickname string
-
-	from, err := imdb.GetUserByUserID(sendID)
-	if err != nil {
-		log.Error(operationID, "GetUserByUserID failed ", err.Error(), sendID)
-	}
-	if from != nil {
-		nickname = from.Nickname
-	}
-
-	to, err := imdb.GetUserByUserID(recvUserID)
-	if err != nil {
-		log.NewWarn(operationID, "GetUserByUserID failed ", err.Error(), recvUserID)
-	}
-	toNickname := ""
-	if to != nil {
-		toNickname = to.Nickname
-	}
-
-	cn := config.Config.Notification
-	switch contentType {
-	case constant.GroupCreatedNotification:
-		tips.DefaultTips = nickname + " " + cn.GroupCreated.DefaultTips.Tips
-	case constant.GroupInfoSetNotification:
-		tips.DefaultTips = nickname + " " + cn.GroupInfoSet.DefaultTips.Tips
-	case constant.JoinGroupApplicationNotification:
-		tips.DefaultTips = nickname + " " + cn.JoinGroupApplication.DefaultTips.Tips
-	case constant.MemberQuitNotification:
-		tips.DefaultTips = nickname + " " + cn.MemberQuit.DefaultTips.Tips
-	case constant.GroupApplicationAcceptedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.GroupApplicationAccepted.DefaultTips.Tips
-	case constant.GroupApplicationRejectedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.GroupApplicationRejected.DefaultTips.Tips
-	case constant.GroupOwnerTransferredNotification: //
-		tips.DefaultTips = toNickname + " " + cn.GroupOwnerTransferred.DefaultTips.Tips
-	case constant.MemberKickedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.MemberKicked.DefaultTips.Tips
-	case constant.MemberInvitedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.MemberInvited.DefaultTips.Tips
-	case constant.MemberEnterNotification:
-		tips.DefaultTips = toNickname + " " + cn.MemberEnter.DefaultTips.Tips
-	case constant.GroupDismissedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupDismissed.DefaultTips.Tips
-	case constant.GroupMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMuted.DefaultTips.Tips
-	case constant.GroupCancelMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupCancelMuted.DefaultTips.Tips
-	case constant.GroupMemberMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberMuted.DefaultTips.Tips
-	case constant.GroupMemberCancelMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberCancelMuted.DefaultTips.Tips
-	case constant.GroupMemberInfoSetNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberInfoSet.DefaultTips.Tips
-	case constant.GroupMemberSetToAdminNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToAdmin.DefaultTips.Tips
-	case constant.GroupMemberSetToOrdinaryUserNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToOrdinary.DefaultTips.Tips
-	default:
-		log.Error(operationID, "contentType failed ", contentType)
-		return
-	}
-
-	var n msg.NotificationMsg
-	n.SendID = sendID
-	if groupID != "" {
-		n.RecvID = groupID
-		group, err := imdb.GetGroupInfoByGroupID(groupID)
-		if err != nil {
-			log.NewError(operationID, "GetGroupInfoByGroupID failed ", err.Error(), groupID)
-		}
-		switch group.GroupType {
-		case constant.NormalGroup:
-			n.SessionType = constant.GroupChatType
-		default:
-			n.SessionType = constant.SuperGroupChatType
-		}
-	} else {
-		n.RecvID = recvUserID
-		n.SessionType = constant.SingleChatType
-	}
-	n.ContentType = contentType
-	n.OperationID = operationID
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
-		return
-	}
-	msg.Notification(&n)
-}
-
-// 创建群后调用
-func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberList []string) {
-	GroupCreatedTips := sdkws.GroupCreatedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, GroupOwnerUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setOpUserInfo(opUserID, groupID, GroupCreatedTips.OpUser); err != nil {
-		log.NewError(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, GroupCreatedTips.OpUser)
-		return
-	}
-	err := setGroupInfo(groupID, GroupCreatedTips.Group)
-	if err != nil {
-		log.Error(operationID, "setGroupInfo failed ", groupID, GroupCreatedTips.Group)
-		return
-	}
-	imdb.GetGroupOwnerInfoByGroupID(groupID)
-	if err := setGroupOwnerInfo(groupID, GroupCreatedTips.GroupOwnerUser); err != nil {
-		log.Error(operationID, "setGroupOwnerInfo failed", err.Error(), groupID)
-		return
-	}
-	for _, v := range initMemberList {
-		var groupMemberInfo sdkws.GroupMemberFullInfo
-		if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
-			log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, v)
-			continue
-		}
-		GroupCreatedTips.MemberList = append(GroupCreatedTips.MemberList, &groupMemberInfo)
-		if len(GroupCreatedTips.MemberList) == constant.MaxNotificationNum {
-			break
-		}
-	}
-	groupNotification(constant.GroupCreatedNotification, &GroupCreatedTips, opUserID, groupID, "", operationID)
-}
-
-// 群信息改变后掉用
-// groupName := ""
-//
-//	notification := ""
-//	introduction := ""
-//	faceURL := ""
-func GroupInfoSetNotification(operationID, opUserID, groupID string, groupName, notification, introduction, faceURL string, needVerification *wrapperspb.Int32Value) {
-	GroupInfoChangedTips := sdkws.GroupInfoSetTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, GroupInfoChangedTips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	GroupInfoChangedTips.Group.GroupName = groupName
-	GroupInfoChangedTips.Group.Notification = notification
-	GroupInfoChangedTips.Group.Introduction = introduction
-	GroupInfoChangedTips.Group.FaceURL = faceURL
-	if needVerification != nil {
-		GroupInfoChangedTips.Group.NeedVerification = needVerification.Value
-	}
-
-	if err := setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	groupNotification(constant.GroupInfoSetNotification, &GroupInfoChangedTips, opUserID, groupID, "", operationID)
-}
-
-func GroupMutedNotification(operationID, opUserID, groupID string) {
-	tips := sdkws.GroupMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	groupNotification(constant.GroupMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupCancelMutedNotification(operationID, opUserID, groupID string) {
-	tips := sdkws.GroupCancelMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	groupNotification(constant.GroupCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberMutedNotification(operationID, opUserID, groupID, groupMemberUserID string, mutedSeconds uint32) {
-	tips := sdkws.GroupMemberMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, MutedUser: &sdkws.GroupMemberFullInfo{}}
-	tips.MutedSeconds = mutedSeconds
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(constant.GroupMemberMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberInfoSetNotification(operationID, opUserID, groupID, groupMemberUserID string) {
-	tips := sdkws.GroupMemberInfoSetTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, ChangedUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(constant.GroupMemberInfoSetNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberRoleLevelChangeNotification(operationID, opUserID, groupID, groupMemberUserID string, notificationType int32) {
-	if notificationType != constant.GroupMemberSetToAdminNotification && notificationType != constant.GroupMemberSetToOrdinaryUserNotification {
-		log.NewError(operationID, utils.GetSelfFuncName(), "invalid notificationType: ", notificationType)
-		return
-	}
-	tips := sdkws.GroupMemberInfoSetTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, ChangedUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(notificationType, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMemberUserID string) {
-	tips := sdkws.GroupMemberCancelMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, MutedUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(constant.GroupMemberCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-//	message ReceiveJoinApplicationTips{
-//	 GroupInfo Group = 1;
-//	 PublicUserInfo Applicant  = 2;
-//	 string 	Reason = 3;
-//	}  apply->all managers GroupID              string   `protobuf:"bytes,1,opt,name=GroupID" json:"GroupID,omitempty"`
-//
-//	ReqMessage           string   `protobuf:"bytes,2,opt,name=ReqMessage" json:"ReqMessage,omitempty"`
-//	OpUserID             string   `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"`
-//	OperationID          string   `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"`
-//
-// 申请进群后调用
-func JoinGroupApplicationNotification(ctx context.Context, req *pbGroup.JoinGroupReq) {
-	JoinGroupApplicationTips := sdkws.JoinGroupApplicationTips{Group: &sdkws.GroupInfo{}, Applicant: &sdkws.PublicUserInfo{}}
-	err := setGroupInfo(req.GroupID, JoinGroupApplicationTips.Group)
-	if err != nil {
-		log.Error(utils.OperationID(ctx), "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err = setPublicUserInfo(utils.OpUserID(ctx), JoinGroupApplicationTips.Applicant); err != nil {
-		log.Error(utils.OperationID(ctx), "setPublicUserInfo failed ", err.Error(), utils.OpUserID(ctx))
-		return
-	}
-	JoinGroupApplicationTips.ReqMsg = req.ReqMessage
-
-	managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
-	if err != nil {
-		log.NewError(utils.OperationID(ctx), "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID)
-		return
-	}
-	for _, v := range managerList {
-		groupNotification(constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, utils.OpUserID(ctx), "", v.UserID, utils.OperationID(ctx))
-		log.NewInfo(utils.OperationID(ctx), "Notification ", v)
-	}
-}
-
-func MemberQuitNotification(req *pbGroup.QuitGroupReq) {
-	MemberQuitTips := sdkws.MemberQuitTips{Group: &sdkws.GroupInfo{}, QuitUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberQuitTips.Group); err != nil {
-		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberQuitTips.QuitUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID)
-		return
-	}
-
-	groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-//	message ApplicationProcessedTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo OpUser = 2;
-//	 int32 Result = 3;
-//	 string 	Reason = 4;
-//	}
-//
-// 处理进群请求后调用
-func GroupApplicationAcceptedNotification(req *pbGroup.GroupApplicationResponseReq) {
-	GroupApplicationAcceptedTips := sdkws.GroupApplicationAcceptedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
-	if err := setGroupInfo(req.GroupID, GroupApplicationAcceptedTips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationAcceptedTips.Group)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser)
-		return
-	}
-
-	groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
-	adminList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
-	if err != nil {
-		log.Error(req.OperationID, "GetOwnerManagerByGroupID failed", req.GroupID)
-		return
-	}
-	for _, v := range adminList {
-		if v.UserID == req.OpUserID {
-			continue
-		}
-		GroupApplicationAcceptedTips.ReceiverAs = 1
-		groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", v.UserID, req.OperationID)
-	}
-}
-
-func GroupApplicationRejectedNotification(req *pbGroup.GroupApplicationResponseReq) {
-	GroupApplicationRejectedTips := sdkws.GroupApplicationRejectedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
-	if err := setGroupInfo(req.GroupID, GroupApplicationRejectedTips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationRejectedTips.Group)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser)
-		return
-	}
-	groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
-	adminList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
-	if err != nil {
-		log.Error(req.OperationID, "GetOwnerManagerByGroupID failed", req.GroupID)
-		return
-	}
-	for _, v := range adminList {
-		if v.UserID == req.OpUserID {
-			continue
-		}
-		GroupApplicationRejectedTips.ReceiverAs = 1
-		groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", v.UserID, req.OperationID)
-	}
-}
-
-func GroupOwnerTransferredNotification(req *pbGroup.TransferGroupOwnerReq) {
-	GroupOwnerTransferredTips := sdkws.GroupOwnerTransferredTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, NewGroupOwner: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, GroupOwnerTransferredTips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupOwnerTransferredTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID)
-		return
-	}
-	if err := setGroupMemberInfo(req.GroupID, req.NewOwnerUserID, GroupOwnerTransferredTips.NewGroupOwner); err != nil {
-		log.Error(req.OperationID, "setGroupMemberInfo failed", req.GroupID, req.NewOwnerUserID)
-		return
-	}
-	groupNotification(constant.GroupOwnerTransferredNotification, &GroupOwnerTransferredTips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-func GroupDismissedNotification(req *pbGroup.DismissGroupReq) {
-	tips := sdkws.GroupDismissedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, tips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, tips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID)
-		return
-	}
-	groupNotification(constant.GroupDismissedNotification, &tips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-//	message MemberKickedTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo OpUser = 2;
-//	 GroupMemberFullInfo KickedUser = 3;
-//	 uint64 OperationTime = 4;
-//	}
-//
-// 被踢后调用
-func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
-	MemberKickedTips := sdkws.MemberKickedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberKickedTips.Group); err != nil {
-		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberKickedTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID)
-		return
-	}
-	for _, v := range kickedUserIDList {
-		var groupMemberInfo sdkws.GroupMemberFullInfo
-		if err := setGroupMemberInfo(req.GroupID, v, &groupMemberInfo); err != nil {
-			log.Error(req.OperationID, "setGroupMemberInfo failed ", err.Error(), req.GroupID, v)
-			continue
-		}
-		MemberKickedTips.KickedUserList = append(MemberKickedTips.KickedUserList, &groupMemberInfo)
-	}
-	groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, req.GroupID, "", req.OperationID)
-	//
-	//for _, v := range kickedUserIDList {
-	//	groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, "", v, req.OperationID)
-	//}
-}
-
-//	message MemberInvitedTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo OpUser = 2;
-//	 GroupMemberFullInfo InvitedUser = 3;
-//	 uint64 OperationTime = 4;
-//	}
-//
-// 被邀请进群后调用
-func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) {
-	MemberInvitedTips := sdkws.MemberInvitedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, MemberInvitedTips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, MemberInvitedTips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	for _, v := range invitedUserIDList {
-		var groupMemberInfo sdkws.GroupMemberFullInfo
-		if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
-			log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID)
-			continue
-		}
-		MemberInvitedTips.InvitedUserList = append(MemberInvitedTips.InvitedUserList, &groupMemberInfo)
-	}
-	groupNotification(constant.MemberInvitedNotification, &MemberInvitedTips, opUserID, groupID, "", operationID)
-}
-
-//message GroupInfoChangedTips{
-//  int32 ChangedType = 1; //bitwise operators: 1:groupName; 10:Notification  100:Introduction; 1000:FaceUrl
-//  GroupInfo Group = 2;
-//  GroupMemberFullInfo OpUser = 3;
-//}
-
-//message MemberLeaveTips{
-//  GroupInfo Group = 1;
-//  GroupMemberFullInfo LeaverUser = 2;
-//  uint64 OperationTime = 3;
-//}
-
-//群成员退群后调用
-
-//	message MemberEnterTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo EntrantUser = 2;
-//	 uint64 OperationTime = 3;
-//	}
-//
-// 群成员主动申请进群，管理员同意后调用，
-func MemberEnterNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) {
-	MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberEnterTips.Group); err != nil {
-		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, MemberEnterTips.Group)
-		return
-	}
-	if err := setGroupMemberInfo(req.GroupID, req.FromUserID, MemberEnterTips.EntrantUser); err != nil {
-		log.Error(req.OperationID, "setGroupMemberInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberEnterTips.EntrantUser)
-		return
-	}
-	groupNotification(constant.MemberEnterNotification, &MemberEnterTips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-func MemberEnterDirectlyNotification(groupID string, entrantUserID string, operationID string) {
-	MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, MemberEnterTips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID, MemberEnterTips.Group)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, entrantUserID, MemberEnterTips.EntrantUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, entrantUserID, MemberEnterTips.EntrantUser)
-		return
-	}
-	groupNotification(constant.MemberEnterNotification, &MemberEnterTips, entrantUserID, groupID, "", operationID)
-}
@@ -1,48 +0,0 @@
-package notification
-
-import (
-	"Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-)
-
-func DeleteMessageNotification(opUserID, userID string, seqList []uint32, operationID string) {
-	DeleteMessageTips := sdkws.DeleteMessageTips{OpUserID: opUserID, UserID: userID, SeqList: seqList}
-	MessageNotification(operationID, userID, userID, constant.DeleteMessageNotification, &DeleteMessageTips)
-}
-
-func MessageNotification(operationID, sendID, recvID string, contentType int32, m proto.Message) {
-	log.Debug(operationID, utils.GetSelfFuncName(), "args: ", m.String(), contentType)
-	var err error
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
-		return
-	}
-
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-	var n msg.NotificationMsg
-	n.SendID = sendID
-	n.RecvID = recvID
-	n.ContentType = contentType
-	n.SessionType = constant.SingleChatType
-	n.MsgFrom = constant.SysMsgType
-	n.OperationID = operationID
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
-		return
-	}
-	msg.Notification(&n)
-}
@@ -1,24 +0,0 @@
-package notification
-
-import (
-	"Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	//sdk "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	//"github.com/golang/protobuf/jsonpb"
-	//"github.com/golang/protobuf/proto"
-)
-
-func SuperGroupNotification(operationID, sendID, recvID string) {
-	n := &msg.NotificationMsg{
-		SendID:      sendID,
-		RecvID:      recvID,
-		MsgFrom:     constant.SysMsgType,
-		ContentType: constant.SuperGroupUpdateNotification,
-		SessionType: constant.SingleChatType,
-		OperationID: operationID,
-	}
-	log.NewInfo(operationID, utils.GetSelfFuncName(), string(n.Content))
-	msg.Notification(n)
-}
@@ -24,7 +24,6 @@ import (

 type friendServer struct {
 	*rpcserver.RpcServer
-
 	controller.FriendInterface
 	controller.BlackInterface
 }
@@ -1,63 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tokenverify"
-	pbChat "Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	"context"
-)
-
-func (rpc *rpcChat) ClearMsg(_ context.Context, req *pbChat.ClearMsgReq) (*pbChat.ClearMsgResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc req: ", req.String())
-	if req.OpUserID != req.UserID && !tokenverify.IsManagerUserID(req.UserID) {
-		errMsg := "No permission" + req.OpUserID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.ClearMsgResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: errMsg}, nil
-	}
-	log.Debug(req.OperationID, "CleanUpOneUserAllMsgFromRedis args", req.UserID)
-	err := db.DB.CleanUpOneUserAllMsgFromRedis(req.UserID, req.OperationID)
-	if err != nil {
-		errMsg := "CleanUpOneUserAllMsgFromRedis failed " + err.Error() + req.OperationID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-	}
-	log.Debug(req.OperationID, "CleanUpUserMsgFromMongo args", req.UserID)
-	err = db.DB.CleanUpUserMsgFromMongo(req.UserID, req.OperationID)
-	if err != nil {
-		errMsg := "CleanUpUserMsgFromMongo failed " + err.Error() + req.OperationID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-	}
-
-	resp := pbChat.ClearMsgResp{ErrCode: 0}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return &resp, nil
-}
-
-func (rpc *rpcChat) SetMsgMinSeq(_ context.Context, req *pbChat.SetMsgMinSeqReq) (*pbChat.SetMsgMinSeqResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc req: ", req.String())
-	if req.OpUserID != req.UserID && !tokenverify.IsManagerUserID(req.UserID) {
-		errMsg := "No permission" + req.OpUserID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: errMsg}, nil
-	}
-	if req.GroupID == "" {
-		err := db.DB.SetUserMinSeq(req.UserID, req.MinSeq)
-		if err != nil {
-			errMsg := "SetUserMinSeq failed " + err.Error() + req.OperationID + req.UserID + utils.Uint32ToString(req.MinSeq)
-			log.Error(req.OperationID, errMsg)
-			return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-		}
-		return &pbChat.SetMsgMinSeqResp{}, nil
-	}
-	err := db.DB.SetGroupUserMinSeq(req.GroupID, req.UserID, uint64(req.MinSeq))
-	if err != nil {
-		errMsg := "SetGroupUserMinSeq failed " + err.Error() + req.OperationID + req.GroupID + req.UserID + utils.Uint32ToString(req.MinSeq)
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-	}
-	return &pbChat.SetMsgMinSeqResp{}, nil
-}
@@ -54,3 +54,30 @@ func (rpc *rpcChat) DelSuperGroupMsg(ctx context.Context, req *msg.DelSuperGroup
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
 }
+
+func (rpc *rpcChat) ClearMsg(_ context.Context, req *pbChat.ClearMsgReq) (*pbChat.ClearMsgResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc req: ", req.String())
+	if req.OpUserID != req.UserID && !tokenverify.IsManagerUserID(req.UserID) {
+		errMsg := "No permission" + req.OpUserID + req.UserID
+		log.Error(req.OperationID, errMsg)
+		return &pbChat.ClearMsgResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "CleanUpOneUserAllMsgFromRedis args", req.UserID)
+	err := db.DB.CleanUpOneUserAllMsgFromRedis(req.UserID, req.OperationID)
+	if err != nil {
+		errMsg := "CleanUpOneUserAllMsgFromRedis failed " + err.Error() + req.OperationID + req.UserID
+		log.Error(req.OperationID, errMsg)
+		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "CleanUpUserMsgFromMongo args", req.UserID)
+	err = db.DB.CleanUpUserMsgFromMongo(req.UserID, req.OperationID)
+	if err != nil {
+		errMsg := "CleanUpUserMsgFromMongo failed " + err.Error() + req.OperationID + req.UserID
+		log.Error(req.OperationID, errMsg)
+		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	resp := pbChat.ClearMsgResp{ErrCode: 0}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return &resp, nil
+}
@@ -1,126 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/utils"
-	"context"
-	go_redis "github.com/go-redis/redis/v8"
-
-	commonDB "Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	sdkws "Open_IM/pkg/proto/sdkws"
-
-	promePkg "Open_IM/pkg/common/prometheus"
-)
-
-func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *sdkws.GetMaxAndMinSeqReq) (*sdkws.GetMaxAndMinSeqResp, error) {
-	log.NewInfo(in.OperationID, "rpc getMaxAndMinSeq is arriving", in.String())
-	resp := new(sdkws.GetMaxAndMinSeqResp)
-	m := make(map[string]*sdkws.MaxAndMinSeq)
-	var maxSeq, minSeq uint64
-	var err1, err2 error
-	maxSeq, err1 = commonDB.DB.GetUserMaxSeq(in.UserID)
-	minSeq, err2 = commonDB.DB.GetUserMinSeq(in.UserID)
-	if (err1 != nil && err1 != go_redis.Nil) || (err2 != nil && err2 != go_redis.Nil) {
-		log.NewError(in.OperationID, "getMaxSeq from redis error", in.String())
-		if err1 != nil {
-			log.NewError(in.OperationID, utils.GetSelfFuncName(), err1.Error())
-		}
-		if err2 != nil {
-			log.NewError(in.OperationID, utils.GetSelfFuncName(), err2.Error())
-		}
-		resp.ErrCode = 200
-		resp.ErrMsg = "redis get err"
-		return resp, nil
-	}
-	resp.MaxSeq = uint32(maxSeq)
-	resp.MinSeq = uint32(minSeq)
-	for _, groupID := range in.GroupIDList {
-		x := new(sdkws.MaxAndMinSeq)
-		maxSeq, _ := commonDB.DB.GetGroupMaxSeq(groupID)
-		minSeq, _ := commonDB.DB.GetGroupUserMinSeq(groupID, in.UserID)
-		x.MaxSeq = uint32(maxSeq)
-		x.MinSeq = uint32(minSeq)
-		m[groupID] = x
-	}
-	resp.GroupMaxAndMinSeq = m
-	return resp, nil
-}
-
-func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *sdkws.PullMessageBySeqListReq) (*sdkws.PullMessageBySeqListResp, error) {
-	log.NewInfo(in.OperationID, "rpc PullMessageBySeqList is arriving", in.String())
-	resp := new(sdkws.PullMessageBySeqListResp)
-	m := make(map[string]*sdkws.MsgDataList)
-	redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(in.UserID, in.SeqList, in.OperationID)
-	if err != nil {
-		if err != go_redis.Nil {
-			promePkg.PromeAdd(promePkg.MsgPullFromRedisFailedCounter, len(failedSeqList))
-			log.Error(in.OperationID, "get message from redis exception", err.Error(), failedSeqList)
-		} else {
-			log.Debug(in.OperationID, "get message from redis is nil", failedSeqList)
-		}
-		msgList, err1 := commonDB.DB.GetMsgBySeqListMongo2(in.UserID, failedSeqList, in.OperationID)
-		if err1 != nil {
-			promePkg.PromeAdd(promePkg.MsgPullFromMongoFailedCounter, len(failedSeqList))
-			log.Error(in.OperationID, "PullMessageBySeqList data error", in.String(), err1.Error())
-			resp.ErrCode = 201
-			resp.ErrMsg = err1.Error()
-			return resp, nil
-		} else {
-			promePkg.PromeAdd(promePkg.MsgPullFromMongoSuccessCounter, len(msgList))
-			redisMsgList = append(redisMsgList, msgList...)
-			resp.List = redisMsgList
-		}
-	} else {
-		promePkg.PromeAdd(promePkg.MsgPullFromRedisSuccessCounter, len(redisMsgList))
-		resp.List = redisMsgList
-	}
-
-	for k, v := range in.GroupSeqList {
-		x := new(sdkws.MsgDataList)
-		redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(k, v.SeqList, in.OperationID)
-		if err != nil {
-			if err != go_redis.Nil {
-				promePkg.PromeAdd(promePkg.MsgPullFromRedisFailedCounter, len(failedSeqList))
-				log.Error(in.OperationID, "get message from redis exception", err.Error(), failedSeqList)
-			} else {
-				log.Debug(in.OperationID, "get message from redis is nil", failedSeqList)
-			}
-			msgList, err1 := commonDB.DB.GetSuperGroupMsgBySeqListMongo(k, failedSeqList, in.OperationID)
-			if err1 != nil {
-				promePkg.PromeAdd(promePkg.MsgPullFromMongoFailedCounter, len(failedSeqList))
-				log.Error(in.OperationID, "PullMessageBySeqList data error", in.String(), err1.Error())
-				resp.ErrCode = 201
-				resp.ErrMsg = err1.Error()
-				return resp, nil
-			} else {
-				promePkg.PromeAdd(promePkg.MsgPullFromMongoSuccessCounter, len(msgList))
-				redisMsgList = append(redisMsgList, msgList...)
-				x.MsgDataList = redisMsgList
-				m[k] = x
-			}
-		} else {
-			promePkg.PromeAdd(promePkg.MsgPullFromRedisSuccessCounter, len(redisMsgList))
-			x.MsgDataList = redisMsgList
-			m[k] = x
-		}
-	}
-	resp.GroupMsgDataList = m
-	return resp, nil
-}
-
-type MsgFormats []*sdkws.MsgData
-
-// Implement the sort.Interface interface to get the number of elements method
-func (s MsgFormats) Len() int {
-	return len(s)
-}
-
-//Implement the sort.Interface interface comparison element method
-func (s MsgFormats) Less(i, j int) bool {
-	return s[i].SendTime < s[j].SendTime
-}
-
-//Implement the sort.Interface interface exchange element method
-func (s MsgFormats) Swap(i, j int) {
-	s[i], s[j] = s[j], s[i]
-}
@@ -45,7 +45,3 @@ func (rpc *rpcChat) GetSuperGroupMsg(context context.Context, req *msg.GetSuperG
 	log.Debug(req.OperationID, utils.GetSelfFuncName(), resp.String())
 	return resp, nil
 }
-
-func (rpc *rpcChat) GetWriteDiffMsg(context context.Context, req *msg.GetWriteDiffMsgReq) (*msg.GetWriteDiffMsgResp, error) {
-	panic("implement me")
-}
@@ -7,10 +7,8 @@ import (
 	rocksCache "Open_IM/pkg/common/db/rocks_cache"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/tokenverify"
-	"Open_IM/pkg/getcdv3"
 	cacheRpc "Open_IM/pkg/proto/cache"
-	pbConversation "Open_IM/pkg/proto/conversation"
-	pbChat "Open_IM/pkg/proto/msg"
+	"Open_IM/pkg/proto/msg"
 	pbPush "Open_IM/pkg/proto/push"
 	pbRelay "Open_IM/pkg/proto/relay"
 	sdkws "Open_IM/pkg/proto/sdkws"
@@ -23,26 +21,17 @@ import (
 	"sync"
 	"time"

-	promePkg "Open_IM/pkg/common/prometheus"
 	go_redis "github.com/go-redis/redis/v8"
-	"github.com/golang/protobuf/proto"
 )

-//When the number of group members is greater than this value，Online users will be sent first，Guaranteed service availability
-const GroupMemberNum = 500
-
 var (
 	ExcludeContentType = []int{constant.HasReadReceipt, constant.GroupHasReadReceipt}
 )

 type Validator interface {
-	validate(pb *pbChat.SendMsgReq) (bool, int32, string)
+	validate(pb *msg.SendMsgReq) (bool, int32, string)
 }

-//type MessageValidator struct {
-//
-//}
-
 type MessageRevoked struct {
 	RevokerID                   string `json:"revokerID"`
 	RevokerRole                 int32  `json:"revokerRole"`
@@ -77,7 +66,7 @@ type MsgCallBackResp struct {
 	}
 }

-func isMessageHasReadEnabled(pb *pbChat.SendMsgReq) (bool, int32, string) {
+func isMessageHasReadEnabled(pb *msg.SendMsgReq) (bool, int32, string) {
 	switch pb.MsgData.ContentType {
 	case constant.HasReadReceipt:
 		if config.Config.SingleMessageHasReadReceiptEnable {
@@ -341,298 +330,6 @@ func (rpc *rpcChat) encapsulateMsgData(msg *sdkws.MsgData) {
 		utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false)
 	}
 }
-func (rpc *rpcChat) SendMsg(ctx context.Context, pb *pbChat.SendMsgReq) (*pbChat.SendMsgResp, error) {
-	replay := pbChat.SendMsgResp{}
-	log.Info(pb.OperationID, "rpc sendMsg come here ", pb.String())
-	flag, errCode, errMsg := isMessageHasReadEnabled(pb)
-	if !flag {
-		return returnMsg(&replay, pb, errCode, errMsg, "", 0)
-	}
-	t1 := time.Now()
-	rpc.encapsulateMsgData(pb.MsgData)
-	log.Debug(pb.OperationID, "encapsulateMsgData ", " cost time: ", time.Since(t1))
-	msgToMQSingle := pbChat.MsgDataToMQ{Token: pb.Token, OperationID: pb.OperationID, MsgData: pb.MsgData}
-	// callback
-	t1 = time.Now()
-	callbackResp := callbackMsgModify(pb)
-	log.Debug(pb.OperationID, "callbackMsgModify ", callbackResp, "cost time: ", time.Since(t1))
-	if callbackResp.ErrCode != 0 {
-		log.Error(pb.OperationID, utils.GetSelfFuncName(), "callbackMsgModify resp: ", callbackResp)
-	}
-	log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackResp: ", callbackResp)
-	if callbackResp.ActionCode != constant.ActionAllow {
-		if callbackResp.ErrCode == 0 {
-			callbackResp.ErrCode = 201
-		}
-		log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackMsgModify result", "end rpc and return", pb.MsgData)
-		return returnMsg(&replay, pb, int32(callbackResp.ErrCode), callbackResp.ErrMsg, "", 0)
-	}
-	switch pb.MsgData.SessionType {
-	case constant.SingleChatType:
-		promePkg.PromeInc(promePkg.SingleChatMsgRecvSuccessCounter)
-		// callback
-		t1 = time.Now()
-		callbackResp := callbackBeforeSendSingleMsg(pb)
-		log.Debug(pb.OperationID, "callbackBeforeSendSingleMsg ", " cost time: ", time.Since(t1))
-		if callbackResp.ErrCode != 0 {
-			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg resp: ", callbackResp)
-		}
-		if callbackResp.ActionCode != constant.ActionAllow {
-			if callbackResp.ErrCode == 0 {
-				callbackResp.ErrCode = 201
-			}
-			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
-			promePkg.PromeInc(promePkg.SingleChatMsgProcessFailedCounter)
-			return returnMsg(&replay, pb, int32(callbackResp.ErrCode), callbackResp.ErrMsg, "", 0)
-		}
-		t1 = time.Now()
-		flag, errCode, errMsg, _ = rpc.messageVerification(ctx, pb)
-		log.Debug(pb.OperationID, "messageVerification ", flag, " cost time: ", time.Since(t1))
-		if !flag {
-			return returnMsg(&replay, pb, errCode, errMsg, "", 0)
-		}
-		t1 = time.Now()
-		isSend := modifyMessageByUserMessageReceiveOpt(pb.MsgData.RecvID, pb.MsgData.SendID, constant.SingleChatType, pb)
-		log.Info(pb.OperationID, "modifyMessageByUserMessageReceiveOpt ", " cost time: ", time.Since(t1))
-		if isSend {
-			msgToMQSingle.MsgData = pb.MsgData
-			log.NewInfo(msgToMQSingle.OperationID, msgToMQSingle)
-			t1 = time.Now()
-			err1 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.RecvID, constant.OnlineStatus)
-			log.Info(pb.OperationID, "sendMsgToWriter ", " cost time: ", time.Since(t1))
-			if err1 != nil {
-				log.NewError(msgToMQSingle.OperationID, "kafka send msg err :RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String(), err1.Error())
-				promePkg.PromeInc(promePkg.SingleChatMsgProcessFailedCounter)
-				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
-			}
-		}
-		if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
-			t1 = time.Now()
-			err2 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.SendID, constant.OnlineStatus)
-			log.Info(pb.OperationID, "sendMsgToWriter ", " cost time: ", time.Since(t1))
-			if err2 != nil {
-				log.NewError(msgToMQSingle.OperationID, "kafka send msg err:SendID", msgToMQSingle.MsgData.SendID, msgToMQSingle.String())
-				promePkg.PromeInc(promePkg.SingleChatMsgProcessFailedCounter)
-				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
-			}
-		}
-		// callback
-		t1 = time.Now()
-		callbackResp = callbackAfterSendSingleMsg(pb)
-		log.Info(pb.OperationID, "callbackAfterSendSingleMsg ", " cost time: ", time.Since(t1))
-		if callbackResp.ErrCode != 0 {
-			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendSingleMsg resp: ", callbackResp)
-		}
-		promePkg.PromeInc(promePkg.SingleChatMsgProcessSuccessCounter)
-		return returnMsg(&replay, pb, 0, "", msgToMQSingle.MsgData.ServerMsgID, msgToMQSingle.MsgData.SendTime)
-	case constant.GroupChatType:
-		// callback
-		promePkg.PromeInc(promePkg.GroupChatMsgRecvSuccessCounter)
-		callbackResp := callbackBeforeSendGroupMsg(pb)
-		if callbackResp.ErrCode != 0 {
-			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendGroupMsg resp:", callbackResp)
-		}
-		if callbackResp.ActionCode != constant.ActionAllow {
-			if callbackResp.ErrCode == 0 {
-				callbackResp.ErrCode = 201
-			}
-			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
-			promePkg.PromeInc(promePkg.GroupChatMsgProcessFailedCounter)
-			return returnMsg(&replay, pb, int32(callbackResp.ErrCode), callbackResp.ErrMsg, "", 0)
-		}
-		var memberUserIDList []string
-		if flag, errCode, errMsg, memberUserIDList = rpc.messageVerification(ctx, pb); !flag {
-			promePkg.PromeInc(promePkg.GroupChatMsgProcessFailedCounter)
-			return returnMsg(&replay, pb, errCode, errMsg, "", 0)
-		}
-		log.Debug(pb.OperationID, "GetGroupAllMember userID list", memberUserIDList, "len: ", len(memberUserIDList))
-		var addUidList []string
-		switch pb.MsgData.ContentType {
-		case constant.MemberKickedNotification:
-			var tips sdkws.TipsComm
-			var memberKickedTips sdkws.MemberKickedTips
-			err := proto.Unmarshal(pb.MsgData.Content, &tips)
-			if err != nil {
-				log.Error(pb.OperationID, "Unmarshal err", err.Error())
-			}
-			err = proto.Unmarshal(tips.Detail, &memberKickedTips)
-			if err != nil {
-				log.Error(pb.OperationID, "Unmarshal err", err.Error())
-			}
-			log.Info(pb.OperationID, "data is ", memberKickedTips)
-			for _, v := range memberKickedTips.KickedUserList {
-				addUidList = append(addUidList, v.UserID)
-			}
-		case constant.MemberQuitNotification:
-			addUidList = append(addUidList, pb.MsgData.SendID)
-
-		default:
-		}
-		if len(addUidList) > 0 {
-			memberUserIDList = append(memberUserIDList, addUidList...)
-		}
-		m := make(map[string][]string, 2)
-		m[constant.OnlineStatus] = memberUserIDList
-		t1 = time.Now()
-
-		//split  parallel send
-		var wg sync.WaitGroup
-		var sendTag bool
-		var split = 20
-		for k, v := range m {
-			remain := len(v) % split
-			for i := 0; i < len(v)/split; i++ {
-				wg.Add(1)
-				tmp := valueCopy(pb)
-				//	go rpc.sendMsgToGroup(v[i*split:(i+1)*split], *pb, k, &sendTag, &wg)
-				go rpc.sendMsgToGroupOptimization(ctx, v[i*split:(i+1)*split], tmp, k, &sendTag, &wg)
-			}
-			if remain > 0 {
-				wg.Add(1)
-				tmp := valueCopy(pb)
-				//	go rpc.sendMsgToGroup(v[split*(len(v)/split):], *pb, k, &sendTag, &wg)
-				go rpc.sendMsgToGroupOptimization(ctx, v[split*(len(v)/split):], tmp, k, &sendTag, &wg)
-			}
-		}
-		log.Debug(pb.OperationID, "send msg cost time22 ", time.Since(t1), pb.MsgData.ClientMsgID, "uidList : ", len(addUidList))
-		//wg.Add(1)
-		//go rpc.sendMsgToGroup(addUidList, *pb, constant.OnlineStatus, &sendTag, &wg)
-		wg.Wait()
-		t1 = time.Now()
-		// callback
-		callbackResp = callbackAfterSendGroupMsg(pb)
-		if callbackResp.ErrCode != 0 {
-			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendGroupMsg resp: ", callbackResp)
-		}
-		if !sendTag {
-			log.NewWarn(pb.OperationID, "send tag is ", sendTag)
-			promePkg.PromeInc(promePkg.GroupChatMsgProcessFailedCounter)
-			return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
-		} else {
-			if pb.MsgData.ContentType == constant.AtText {
-				go func() {
-					var conversationReq pbConversation.ModifyConversationFieldReq
-					var tag bool
-					var atUserID []string
-					conversation := pbConversation.Conversation{
-						OwnerUserID:      pb.MsgData.SendID,
-						ConversationID:   utils.GetConversationIDBySessionType(pb.MsgData.GroupID, constant.GroupChatType),
-						ConversationType: constant.GroupChatType,
-						GroupID:          pb.MsgData.GroupID,
-					}
-					conversationReq.Conversation = &conversation
-					conversationReq.OperationID = pb.OperationID
-					conversationReq.FieldType = constant.FieldGroupAtType
-					tagAll := utils.IsContain(constant.AtAllString, pb.MsgData.AtUserIDList)
-					if tagAll {
-						atUserID = utils.DifferenceString([]string{constant.AtAllString}, pb.MsgData.AtUserIDList)
-						if len(atUserID) == 0 { //just @everyone
-							conversationReq.UserIDList = memberUserIDList
-							conversation.GroupAtType = constant.AtAll
-						} else { //@Everyone and @other people
-							conversationReq.UserIDList = atUserID
-							conversation.GroupAtType = constant.AtAllAtMe
-							tag = true
-						}
-					} else {
-						conversationReq.UserIDList = pb.MsgData.AtUserIDList
-						conversation.GroupAtType = constant.AtMe
-					}
-					etcdConn, err := rpc.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName)
-					if err != nil {
-						errMsg := pb.OperationID + "getcdv3.GetDefaultConn == nil"
-						log.NewError(pb.OperationID, errMsg)
-						return
-					}
-					client := pbConversation.NewConversationClient(etcdConn)
-					conversationReply, err := client.ModifyConversationField(context.Background(), &conversationReq)
-					if err != nil {
-						log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), err.Error())
-					} else if conversationReply.CommonResp.ErrCode != 0 {
-						log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), conversationReply.String())
-					}
-					if tag {
-						conversationReq.UserIDList = utils.DifferenceString(atUserID, memberUserIDList)
-						conversation.GroupAtType = constant.AtAll
-						etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName, pb.OperationID)
-						if etcdConn == nil {
-							errMsg := pb.OperationID + "getcdv3.GetDefaultConn == nil"
-							log.NewError(pb.OperationID, errMsg)
-							return
-						}
-						client := pbConversation.NewConversationClient(etcdConn)
-						conversationReply, err := client.ModifyConversationField(context.Background(), &conversationReq)
-						if err != nil {
-							log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), err.Error())
-						} else if conversationReply.CommonResp.ErrCode != 0 {
-							log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), conversationReply.String())
-						}
-					}
-				}()
-			}
-			log.Debug(pb.OperationID, "send msg cost time3 ", time.Since(t1), pb.MsgData.ClientMsgID)
-			promePkg.PromeInc(promePkg.GroupChatMsgProcessSuccessCounter)
-			return returnMsg(&replay, pb, 0, "", msgToMQSingle.MsgData.ServerMsgID, msgToMQSingle.MsgData.SendTime)
-		}
-	case constant.NotificationChatType:
-		t1 = time.Now()
-		msgToMQSingle.MsgData = pb.MsgData
-		log.NewInfo(msgToMQSingle.OperationID, msgToMQSingle)
-		err1 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.RecvID, constant.OnlineStatus)
-		if err1 != nil {
-			log.NewError(msgToMQSingle.OperationID, "kafka send msg err:RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String())
-			return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
-		}
-
-		if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
-			err2 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.SendID, constant.OnlineStatus)
-			if err2 != nil {
-				log.NewError(msgToMQSingle.OperationID, "kafka send msg err:SendID", msgToMQSingle.MsgData.SendID, msgToMQSingle.String())
-				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
-			}
-		}
-
-		log.Debug(pb.OperationID, "send msg cost time ", time.Since(t1), pb.MsgData.ClientMsgID)
-		return returnMsg(&replay, pb, 0, "", msgToMQSingle.MsgData.ServerMsgID, msgToMQSingle.MsgData.SendTime)
-	case constant.SuperGroupChatType:
-		promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter)
-		// callback
-		callbackResp := callbackBeforeSendGroupMsg(pb)
-		if callbackResp.ErrCode != 0 {
-			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSuperGroupMsg resp: ", callbackResp)
-		}
-		if callbackResp.ActionCode != constant.ActionAllow {
-			if callbackResp.ErrCode == 0 {
-				callbackResp.ErrCode = 201
-			}
-			promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
-			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSuperGroupMsg result", "end rpc and return", callbackResp)
-			return returnMsg(&replay, pb, int32(callbackResp.ErrCode), callbackResp.ErrMsg, "", 0)
-		}
-		if flag, errCode, errMsg, _ = rpc.messageVerification(ctx, pb); !flag {
-			promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
-			return returnMsg(&replay, pb, errCode, errMsg, "", 0)
-		}
-		msgToMQSingle.MsgData = pb.MsgData
-		log.NewInfo(msgToMQSingle.OperationID, msgToMQSingle)
-		err1 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.GroupID, constant.OnlineStatus)
-		if err1 != nil {
-			log.NewError(msgToMQSingle.OperationID, "kafka send msg err:RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String())
-			promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
-			return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
-		}
-		// callback
-		callbackResp = callbackAfterSendGroupMsg(pb)
-		if callbackResp.ErrCode != 0 {
-			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendSuperGroupMsg resp: ", callbackResp)
-		}
-		promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessSuccessCounter)
-		return returnMsg(&replay, pb, 0, "", msgToMQSingle.MsgData.ServerMsgID, msgToMQSingle.MsgData.SendTime)
-
-	default:
-		return returnMsg(&replay, pb, 203, "unknown sessionType", "", 0)
-	}
-}

 func (rpc *rpcChat) sendMsgToWriter(ctx context.Context, m *pbChat.MsgDataToMQ, key string, status string) error {
 	switch status {
@@ -747,288 +444,6 @@ func modifyMessageByUserMessageReceiveOptoptimization(userID, sourceID string, s
 	return true
 }

-type NotificationMsg struct {
-	SendID         string
-	RecvID         string
-	Content        []byte //  sdkws.TipsComm
-	MsgFrom        int32
-	ContentType    int32
-	SessionType    int32
-	OperationID    string
-	SenderNickname string
-	SenderFaceURL  string
-}
-
-func Notification(n *NotificationMsg) {
-	var req pbChat.SendMsgReq
-	var msg sdkws.MsgData
-	var offlineInfo sdkws.OfflinePushInfo
-	var title, desc, ex string
-	var pushSwitch, unReadCount bool
-	var reliabilityLevel int
-	req.OperationID = n.OperationID
-	msg.SendID = n.SendID
-	msg.RecvID = n.RecvID
-	msg.Content = n.Content
-	msg.MsgFrom = n.MsgFrom
-	msg.ContentType = n.ContentType
-	msg.SessionType = n.SessionType
-	msg.CreateTime = utils.GetCurrentTimestampByMill()
-	msg.ClientMsgID = utils.GetMsgID(n.SendID)
-	msg.Options = make(map[string]bool, 7)
-	msg.SenderNickname = n.SenderNickname
-	msg.SenderFaceURL = n.SenderFaceURL
-	switch n.SessionType {
-	case constant.GroupChatType, constant.SuperGroupChatType:
-		msg.RecvID = ""
-		msg.GroupID = n.RecvID
-	}
-	offlineInfo.IOSBadgeCount = config.Config.IOSPush.BadgeCount
-	offlineInfo.IOSPushSound = config.Config.IOSPush.PushSound
-	switch msg.ContentType {
-	case constant.GroupCreatedNotification:
-		pushSwitch = config.Config.Notification.GroupCreated.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupCreated.OfflinePush.Title
-		desc = config.Config.Notification.GroupCreated.OfflinePush.Desc
-		ex = config.Config.Notification.GroupCreated.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupCreated.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupCreated.Conversation.UnreadCount
-	case constant.GroupInfoSetNotification:
-		pushSwitch = config.Config.Notification.GroupInfoSet.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupInfoSet.OfflinePush.Title
-		desc = config.Config.Notification.GroupInfoSet.OfflinePush.Desc
-		ex = config.Config.Notification.GroupInfoSet.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupInfoSet.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupInfoSet.Conversation.UnreadCount
-	case constant.JoinGroupApplicationNotification:
-		pushSwitch = config.Config.Notification.JoinGroupApplication.OfflinePush.PushSwitch
-		title = config.Config.Notification.JoinGroupApplication.OfflinePush.Title
-		desc = config.Config.Notification.JoinGroupApplication.OfflinePush.Desc
-		ex = config.Config.Notification.JoinGroupApplication.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.JoinGroupApplication.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.JoinGroupApplication.Conversation.UnreadCount
-	case constant.MemberQuitNotification:
-		pushSwitch = config.Config.Notification.MemberQuit.OfflinePush.PushSwitch
-		title = config.Config.Notification.MemberQuit.OfflinePush.Title
-		desc = config.Config.Notification.MemberQuit.OfflinePush.Desc
-		ex = config.Config.Notification.MemberQuit.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.MemberQuit.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.MemberQuit.Conversation.UnreadCount
-	case constant.GroupApplicationAcceptedNotification:
-		pushSwitch = config.Config.Notification.GroupApplicationAccepted.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Title
-		desc = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Desc
-		ex = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupApplicationAccepted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupApplicationAccepted.Conversation.UnreadCount
-	case constant.GroupApplicationRejectedNotification:
-		pushSwitch = config.Config.Notification.GroupApplicationRejected.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupApplicationRejected.OfflinePush.Title
-		desc = config.Config.Notification.GroupApplicationRejected.OfflinePush.Desc
-		ex = config.Config.Notification.GroupApplicationRejected.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupApplicationRejected.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupApplicationRejected.Conversation.UnreadCount
-	case constant.GroupOwnerTransferredNotification:
-		pushSwitch = config.Config.Notification.GroupOwnerTransferred.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Title
-		desc = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Desc
-		ex = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupOwnerTransferred.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupOwnerTransferred.Conversation.UnreadCount
-	case constant.MemberKickedNotification:
-		pushSwitch = config.Config.Notification.MemberKicked.OfflinePush.PushSwitch
-		title = config.Config.Notification.MemberKicked.OfflinePush.Title
-		desc = config.Config.Notification.MemberKicked.OfflinePush.Desc
-		ex = config.Config.Notification.MemberKicked.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.MemberKicked.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.MemberKicked.Conversation.UnreadCount
-	case constant.MemberInvitedNotification:
-		pushSwitch = config.Config.Notification.MemberInvited.OfflinePush.PushSwitch
-		title = config.Config.Notification.MemberInvited.OfflinePush.Title
-		desc = config.Config.Notification.MemberInvited.OfflinePush.Desc
-		ex = config.Config.Notification.MemberInvited.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.MemberInvited.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.MemberInvited.Conversation.UnreadCount
-	case constant.MemberEnterNotification:
-		pushSwitch = config.Config.Notification.MemberEnter.OfflinePush.PushSwitch
-		title = config.Config.Notification.MemberEnter.OfflinePush.Title
-		desc = config.Config.Notification.MemberEnter.OfflinePush.Desc
-		ex = config.Config.Notification.MemberEnter.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.MemberEnter.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.MemberEnter.Conversation.UnreadCount
-	case constant.UserInfoUpdatedNotification:
-		pushSwitch = config.Config.Notification.UserInfoUpdated.OfflinePush.PushSwitch
-		title = config.Config.Notification.UserInfoUpdated.OfflinePush.Title
-		desc = config.Config.Notification.UserInfoUpdated.OfflinePush.Desc
-		ex = config.Config.Notification.UserInfoUpdated.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.UserInfoUpdated.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.UserInfoUpdated.Conversation.UnreadCount
-	case constant.FriendApplicationNotification:
-		pushSwitch = config.Config.Notification.FriendApplication.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendApplication.OfflinePush.Title
-		desc = config.Config.Notification.FriendApplication.OfflinePush.Desc
-		ex = config.Config.Notification.FriendApplication.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendApplication.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendApplication.Conversation.UnreadCount
-	case constant.FriendApplicationApprovedNotification:
-		pushSwitch = config.Config.Notification.FriendApplicationApproved.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendApplicationApproved.OfflinePush.Title
-		desc = config.Config.Notification.FriendApplicationApproved.OfflinePush.Desc
-		ex = config.Config.Notification.FriendApplicationApproved.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendApplicationApproved.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendApplicationApproved.Conversation.UnreadCount
-	case constant.FriendApplicationRejectedNotification:
-		pushSwitch = config.Config.Notification.FriendApplicationRejected.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendApplicationRejected.OfflinePush.Title
-		desc = config.Config.Notification.FriendApplicationRejected.OfflinePush.Desc
-		ex = config.Config.Notification.FriendApplicationRejected.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendApplicationRejected.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendApplicationRejected.Conversation.UnreadCount
-	case constant.FriendAddedNotification:
-		pushSwitch = config.Config.Notification.FriendAdded.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendAdded.OfflinePush.Title
-		desc = config.Config.Notification.FriendAdded.OfflinePush.Desc
-		ex = config.Config.Notification.FriendAdded.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendAdded.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendAdded.Conversation.UnreadCount
-	case constant.FriendDeletedNotification:
-		pushSwitch = config.Config.Notification.FriendDeleted.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendDeleted.OfflinePush.Title
-		desc = config.Config.Notification.FriendDeleted.OfflinePush.Desc
-		ex = config.Config.Notification.FriendDeleted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendDeleted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendDeleted.Conversation.UnreadCount
-	case constant.FriendRemarkSetNotification:
-		pushSwitch = config.Config.Notification.FriendRemarkSet.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendRemarkSet.OfflinePush.Title
-		desc = config.Config.Notification.FriendRemarkSet.OfflinePush.Desc
-		ex = config.Config.Notification.FriendRemarkSet.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendRemarkSet.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendRemarkSet.Conversation.UnreadCount
-	case constant.BlackAddedNotification:
-		pushSwitch = config.Config.Notification.BlackAdded.OfflinePush.PushSwitch
-		title = config.Config.Notification.BlackAdded.OfflinePush.Title
-		desc = config.Config.Notification.BlackAdded.OfflinePush.Desc
-		ex = config.Config.Notification.BlackAdded.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.BlackAdded.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.BlackAdded.Conversation.UnreadCount
-	case constant.BlackDeletedNotification:
-		pushSwitch = config.Config.Notification.BlackDeleted.OfflinePush.PushSwitch
-		title = config.Config.Notification.BlackDeleted.OfflinePush.Title
-		desc = config.Config.Notification.BlackDeleted.OfflinePush.Desc
-		ex = config.Config.Notification.BlackDeleted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.BlackDeleted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.BlackDeleted.Conversation.UnreadCount
-	case constant.ConversationOptChangeNotification:
-		pushSwitch = config.Config.Notification.ConversationOptUpdate.OfflinePush.PushSwitch
-		title = config.Config.Notification.ConversationOptUpdate.OfflinePush.Title
-		desc = config.Config.Notification.ConversationOptUpdate.OfflinePush.Desc
-		ex = config.Config.Notification.ConversationOptUpdate.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.ConversationOptUpdate.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.ConversationOptUpdate.Conversation.UnreadCount
-
-	case constant.GroupDismissedNotification:
-		pushSwitch = config.Config.Notification.GroupDismissed.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupDismissed.OfflinePush.Title
-		desc = config.Config.Notification.GroupDismissed.OfflinePush.Desc
-		ex = config.Config.Notification.GroupDismissed.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupDismissed.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupDismissed.Conversation.UnreadCount
-
-	case constant.GroupMutedNotification:
-		pushSwitch = config.Config.Notification.GroupMuted.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupMuted.OfflinePush.Title
-		desc = config.Config.Notification.GroupMuted.OfflinePush.Desc
-		ex = config.Config.Notification.GroupMuted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupMuted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupMuted.Conversation.UnreadCount
-
-	case constant.GroupCancelMutedNotification:
-		pushSwitch = config.Config.Notification.GroupCancelMuted.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupCancelMuted.OfflinePush.Title
-		desc = config.Config.Notification.GroupCancelMuted.OfflinePush.Desc
-		ex = config.Config.Notification.GroupCancelMuted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupCancelMuted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupCancelMuted.Conversation.UnreadCount
-
-	case constant.GroupMemberMutedNotification:
-		pushSwitch = config.Config.Notification.GroupMemberMuted.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupMemberMuted.OfflinePush.Title
-		desc = config.Config.Notification.GroupMemberMuted.OfflinePush.Desc
-		ex = config.Config.Notification.GroupMemberMuted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupMemberMuted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupMemberMuted.Conversation.UnreadCount
-
-	case constant.GroupMemberCancelMutedNotification:
-		pushSwitch = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Title
-		desc = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Desc
-		ex = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupMemberCancelMuted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupMemberCancelMuted.Conversation.UnreadCount
-
-	case constant.GroupMemberInfoSetNotification:
-		pushSwitch = config.Config.Notification.GroupMemberInfoSet.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Title
-		desc = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Desc
-		ex = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupMemberInfoSet.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupMemberInfoSet.Conversation.UnreadCount
-
-	case constant.ConversationPrivateChatNotification:
-		pushSwitch = config.Config.Notification.ConversationSetPrivate.OfflinePush.PushSwitch
-		title = config.Config.Notification.ConversationSetPrivate.OfflinePush.Title
-		desc = config.Config.Notification.ConversationSetPrivate.OfflinePush.Desc
-		ex = config.Config.Notification.ConversationSetPrivate.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.ConversationSetPrivate.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.ConversationSetPrivate.Conversation.UnreadCount
-	case constant.FriendInfoUpdatedNotification:
-		pushSwitch = config.Config.Notification.FriendInfoUpdated.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendInfoUpdated.OfflinePush.Title
-		desc = config.Config.Notification.FriendInfoUpdated.OfflinePush.Desc
-		ex = config.Config.Notification.FriendInfoUpdated.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendInfoUpdated.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendInfoUpdated.Conversation.UnreadCount
-	case constant.DeleteMessageNotification:
-		reliabilityLevel = constant.ReliableNotificationNoMsg
-	case constant.ConversationUnreadNotification, constant.SuperGroupUpdateNotification:
-		reliabilityLevel = constant.UnreliableNotification
-	}
-	switch reliabilityLevel {
-	case constant.UnreliableNotification:
-		utils.SetSwitchFromOptions(msg.Options, constant.IsHistory, false)
-		utils.SetSwitchFromOptions(msg.Options, constant.IsPersistent, false)
-		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
-		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
-	case constant.ReliableNotificationNoMsg:
-		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
-		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
-	case constant.ReliableNotificationMsg:
-
-	}
-	utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, unReadCount)
-	utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, pushSwitch)
-	offlineInfo.Title = title
-	offlineInfo.Desc = desc
-	offlineInfo.Ex = ex
-	msg.OfflinePushInfo = &offlineInfo
-	req.MsgData = &msg
-	etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		return
-	}
-
-	client := pbChat.NewMsgClient(etcdConn)
-	reply, err := client.SendMsg(context.Background(), &req)
-	if err != nil {
-		log.NewError(req.OperationID, "SendMsg rpc failed, ", req.String(), err.Error())
-	} else if reply.ErrCode != 0 {
-		log.NewError(req.OperationID, "SendMsg rpc failed, ", req.String(), reply.ErrCode, reply.ErrMsg)
-	}
-}
-
 func getOnlineAndOfflineUserIDList(memberList []string, m map[string][]string, operationID string) {
 	var onllUserIDList, offlUserIDList []string
 	var wsResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
@@ -0,0 +1,403 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/constant"
+	promePkg "Open_IM/pkg/common/prometheus"
+	pbConversation "Open_IM/pkg/proto/conversation"
+	pbChat "Open_IM/pkg/proto/msg"
+	"Open_IM/pkg/proto/sdkws"
+	"context"
+	go_redis "github.com/go-redis/redis/v8"
+	"strings"
+	"sync"
+	"time"
+)
+
+func (m *msgServer) SendMsg(ctx context.Context, pb *pbChat.SendMsgReq) (*pbChat.SendMsgResp, error) {
+	replay := pbChat.SendMsgResp{}
+
+	flag, errCode, errMsg := isMessageHasReadEnabled(pb)
+	if !flag {
+		return returnMsg(&replay, pb, errCode, errMsg, "", 0)
+	}
+	t1 := time.Now()
+	rpc.encapsulateMsgData(pb.MsgData)
+	log.Debug(pb.OperationID, "encapsulateMsgData ", " cost time: ", time.Since(t1))
+	msgToMQSingle := pbChat.MsgDataToMQ{Token: pb.Token, OperationID: pb.OperationID, MsgData: pb.MsgData}
+	// callback
+	t1 = time.Now()
+	callbackResp := callbackMsgModify(pb)
+	log.Debug(pb.OperationID, "callbackMsgModify ", callbackResp, "cost time: ", time.Since(t1))
+	if callbackResp.ErrCode != 0 {
+		log.Error(pb.OperationID, utils.GetSelfFuncName(), "callbackMsgModify resp: ", callbackResp)
+	}
+	log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackResp: ", callbackResp)
+	if callbackResp.ActionCode != constant.ActionAllow {
+		if callbackResp.ErrCode == 0 {
+			callbackResp.ErrCode = 201
+		}
+		log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackMsgModify result", "end rpc and return", pb.MsgData)
+		return returnMsg(&replay, pb, int32(callbackResp.ErrCode), callbackResp.ErrMsg, "", 0)
+	}
+	switch pb.MsgData.SessionType {
+	case constant.SingleChatType:
+		promePkg.PromeInc(promePkg.SingleChatMsgRecvSuccessCounter)
+		// callback
+		t1 = time.Now()
+		callbackResp := callbackBeforeSendSingleMsg(pb)
+		log.Debug(pb.OperationID, "callbackBeforeSendSingleMsg ", " cost time: ", time.Since(t1))
+		if callbackResp.ErrCode != 0 {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg resp: ", callbackResp)
+		}
+		if callbackResp.ActionCode != constant.ActionAllow {
+			if callbackResp.ErrCode == 0 {
+				callbackResp.ErrCode = 201
+			}
+			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
+			promePkg.PromeInc(promePkg.SingleChatMsgProcessFailedCounter)
+			return returnMsg(&replay, pb, int32(callbackResp.ErrCode), callbackResp.ErrMsg, "", 0)
+		}
+		t1 = time.Now()
+		flag, errCode, errMsg, _ = rpc.messageVerification(ctx, pb)
+		log.Debug(pb.OperationID, "messageVerification ", flag, " cost time: ", time.Since(t1))
+		if !flag {
+			return returnMsg(&replay, pb, errCode, errMsg, "", 0)
+		}
+		t1 = time.Now()
+		isSend := modifyMessageByUserMessageReceiveOpt(pb.MsgData.RecvID, pb.MsgData.SendID, constant.SingleChatType, pb)
+		log.Info(pb.OperationID, "modifyMessageByUserMessageReceiveOpt ", " cost time: ", time.Since(t1))
+		if isSend {
+			msgToMQSingle.MsgData = pb.MsgData
+			log.NewInfo(msgToMQSingle.OperationID, msgToMQSingle)
+			t1 = time.Now()
+			err1 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.RecvID, constant.OnlineStatus)
+			log.Info(pb.OperationID, "sendMsgToWriter ", " cost time: ", time.Since(t1))
+			if err1 != nil {
+				log.NewError(msgToMQSingle.OperationID, "kafka send msg err :RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String(), err1.Error())
+				promePkg.PromeInc(promePkg.SingleChatMsgProcessFailedCounter)
+				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+			}
+		}
+		if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
+			t1 = time.Now()
+			err2 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.SendID, constant.OnlineStatus)
+			log.Info(pb.OperationID, "sendMsgToWriter ", " cost time: ", time.Since(t1))
+			if err2 != nil {
+				log.NewError(msgToMQSingle.OperationID, "kafka send msg err:SendID", msgToMQSingle.MsgData.SendID, msgToMQSingle.String())
+				promePkg.PromeInc(promePkg.SingleChatMsgProcessFailedCounter)
+				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+			}
+		}
+		// callback
+		t1 = time.Now()
+		callbackResp = callbackAfterSendSingleMsg(pb)
+		log.Info(pb.OperationID, "callbackAfterSendSingleMsg ", " cost time: ", time.Since(t1))
+		if callbackResp.ErrCode != 0 {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendSingleMsg resp: ", callbackResp)
+		}
+		promePkg.PromeInc(promePkg.SingleChatMsgProcessSuccessCounter)
+		return returnMsg(&replay, pb, 0, "", msgToMQSingle.MsgData.ServerMsgID, msgToMQSingle.MsgData.SendTime)
+	case constant.GroupChatType:
+		// callback
+		promePkg.PromeInc(promePkg.GroupChatMsgRecvSuccessCounter)
+		callbackResp := callbackBeforeSendGroupMsg(pb)
+		if callbackResp.ErrCode != 0 {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendGroupMsg resp:", callbackResp)
+		}
+		if callbackResp.ActionCode != constant.ActionAllow {
+			if callbackResp.ErrCode == 0 {
+				callbackResp.ErrCode = 201
+			}
+			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
+			promePkg.PromeInc(promePkg.GroupChatMsgProcessFailedCounter)
+			return returnMsg(&replay, pb, int32(callbackResp.ErrCode), callbackResp.ErrMsg, "", 0)
+		}
+		var memberUserIDList []string
+		if flag, errCode, errMsg, memberUserIDList = rpc.messageVerification(ctx, pb); !flag {
+			promePkg.PromeInc(promePkg.GroupChatMsgProcessFailedCounter)
+			return returnMsg(&replay, pb, errCode, errMsg, "", 0)
+		}
+		log.Debug(pb.OperationID, "GetGroupAllMember userID list", memberUserIDList, "len: ", len(memberUserIDList))
+		var addUidList []string
+		switch pb.MsgData.ContentType {
+		case constant.MemberKickedNotification:
+			var tips sdkws.TipsComm
+			var memberKickedTips sdkws.MemberKickedTips
+			err := proto.Unmarshal(pb.MsgData.Content, &tips)
+			if err != nil {
+				log.Error(pb.OperationID, "Unmarshal err", err.Error())
+			}
+			err = proto.Unmarshal(tips.Detail, &memberKickedTips)
+			if err != nil {
+				log.Error(pb.OperationID, "Unmarshal err", err.Error())
+			}
+			log.Info(pb.OperationID, "data is ", memberKickedTips)
+			for _, v := range memberKickedTips.KickedUserList {
+				addUidList = append(addUidList, v.UserID)
+			}
+		case constant.MemberQuitNotification:
+			addUidList = append(addUidList, pb.MsgData.SendID)
+
+		default:
+		}
+		if len(addUidList) > 0 {
+			memberUserIDList = append(memberUserIDList, addUidList...)
+		}
+		m := make(map[string][]string, 2)
+		m[constant.OnlineStatus] = memberUserIDList
+		t1 = time.Now()
+
+		//split  parallel send
+		var wg sync.WaitGroup
+		var sendTag bool
+		var split = 20
+		for k, v := range m {
+			remain := len(v) % split
+			for i := 0; i < len(v)/split; i++ {
+				wg.Add(1)
+				tmp := valueCopy(pb)
+				//	go rpc.sendMsgToGroup(v[i*split:(i+1)*split], *pb, k, &sendTag, &wg)
+				go rpc.sendMsgToGroupOptimization(ctx, v[i*split:(i+1)*split], tmp, k, &sendTag, &wg)
+			}
+			if remain > 0 {
+				wg.Add(1)
+				tmp := valueCopy(pb)
+				//	go rpc.sendMsgToGroup(v[split*(len(v)/split):], *pb, k, &sendTag, &wg)
+				go rpc.sendMsgToGroupOptimization(ctx, v[split*(len(v)/split):], tmp, k, &sendTag, &wg)
+			}
+		}
+		log.Debug(pb.OperationID, "send msg cost time22 ", time.Since(t1), pb.MsgData.ClientMsgID, "uidList : ", len(addUidList))
+		//wg.Add(1)
+		//go rpc.sendMsgToGroup(addUidList, *pb, constant.OnlineStatus, &sendTag, &wg)
+		wg.Wait()
+		t1 = time.Now()
+		// callback
+		callbackResp = callbackAfterSendGroupMsg(pb)
+		if callbackResp.ErrCode != 0 {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendGroupMsg resp: ", callbackResp)
+		}
+		if !sendTag {
+			log.NewWarn(pb.OperationID, "send tag is ", sendTag)
+			promePkg.PromeInc(promePkg.GroupChatMsgProcessFailedCounter)
+			return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+		} else {
+			if pb.MsgData.ContentType == constant.AtText {
+				go func() {
+					var conversationReq pbConversation.ModifyConversationFieldReq
+					var tag bool
+					var atUserID []string
+					conversation := pbConversation.Conversation{
+						OwnerUserID:      pb.MsgData.SendID,
+						ConversationID:   utils.GetConversationIDBySessionType(pb.MsgData.GroupID, constant.GroupChatType),
+						ConversationType: constant.GroupChatType,
+						GroupID:          pb.MsgData.GroupID,
+					}
+					conversationReq.Conversation = &conversation
+					conversationReq.OperationID = pb.OperationID
+					conversationReq.FieldType = constant.FieldGroupAtType
+					tagAll := utils.IsContain(constant.AtAllString, pb.MsgData.AtUserIDList)
+					if tagAll {
+						atUserID = utils.DifferenceString([]string{constant.AtAllString}, pb.MsgData.AtUserIDList)
+						if len(atUserID) == 0 { //just @everyone
+							conversationReq.UserIDList = memberUserIDList
+							conversation.GroupAtType = constant.AtAll
+						} else { //@Everyone and @other people
+							conversationReq.UserIDList = atUserID
+							conversation.GroupAtType = constant.AtAllAtMe
+							tag = true
+						}
+					} else {
+						conversationReq.UserIDList = pb.MsgData.AtUserIDList
+						conversation.GroupAtType = constant.AtMe
+					}
+					etcdConn, err := rpc.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName)
+					if err != nil {
+						errMsg := pb.OperationID + "getcdv3.GetDefaultConn == nil"
+						log.NewError(pb.OperationID, errMsg)
+						return
+					}
+					client := pbConversation.NewConversationClient(etcdConn)
+					conversationReply, err := client.ModifyConversationField(context.Background(), &conversationReq)
+					if err != nil {
+						log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), err.Error())
+					} else if conversationReply.CommonResp.ErrCode != 0 {
+						log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), conversationReply.String())
+					}
+					if tag {
+						conversationReq.UserIDList = utils.DifferenceString(atUserID, memberUserIDList)
+						conversation.GroupAtType = constant.AtAll
+						etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName, pb.OperationID)
+						if etcdConn == nil {
+							errMsg := pb.OperationID + "getcdv3.GetDefaultConn == nil"
+							log.NewError(pb.OperationID, errMsg)
+							return
+						}
+						client := pbConversation.NewConversationClient(etcdConn)
+						conversationReply, err := client.ModifyConversationField(context.Background(), &conversationReq)
+						if err != nil {
+							log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), err.Error())
+						} else if conversationReply.CommonResp.ErrCode != 0 {
+							log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), conversationReply.String())
+						}
+					}
+				}()
+			}
+			log.Debug(pb.OperationID, "send msg cost time3 ", time.Since(t1), pb.MsgData.ClientMsgID)
+			promePkg.PromeInc(promePkg.GroupChatMsgProcessSuccessCounter)
+			return returnMsg(&replay, pb, 0, "", msgToMQSingle.MsgData.ServerMsgID, msgToMQSingle.MsgData.SendTime)
+		}
+	case constant.NotificationChatType:
+		t1 = time.Now()
+		msgToMQSingle.MsgData = pb.MsgData
+		log.NewInfo(msgToMQSingle.OperationID, msgToMQSingle)
+		err1 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.RecvID, constant.OnlineStatus)
+		if err1 != nil {
+			log.NewError(msgToMQSingle.OperationID, "kafka send msg err:RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String())
+			return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+		}
+
+		if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
+			err2 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.SendID, constant.OnlineStatus)
+			if err2 != nil {
+				log.NewError(msgToMQSingle.OperationID, "kafka send msg err:SendID", msgToMQSingle.MsgData.SendID, msgToMQSingle.String())
+				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+			}
+		}
+
+		log.Debug(pb.OperationID, "send msg cost time ", time.Since(t1), pb.MsgData.ClientMsgID)
+		return returnMsg(&replay, pb, 0, "", msgToMQSingle.MsgData.ServerMsgID, msgToMQSingle.MsgData.SendTime)
+	case constant.SuperGroupChatType:
+		promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter)
+		// callback
+		callbackResp := callbackBeforeSendGroupMsg(pb)
+		if callbackResp.ErrCode != 0 {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSuperGroupMsg resp: ", callbackResp)
+		}
+		if callbackResp.ActionCode != constant.ActionAllow {
+			if callbackResp.ErrCode == 0 {
+				callbackResp.ErrCode = 201
+			}
+			promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
+			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSuperGroupMsg result", "end rpc and return", callbackResp)
+			return returnMsg(&replay, pb, int32(callbackResp.ErrCode), callbackResp.ErrMsg, "", 0)
+		}
+		if flag, errCode, errMsg, _ = rpc.messageVerification(ctx, pb); !flag {
+			promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
+			return returnMsg(&replay, pb, errCode, errMsg, "", 0)
+		}
+		msgToMQSingle.MsgData = pb.MsgData
+		log.NewInfo(msgToMQSingle.OperationID, msgToMQSingle)
+		err1 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.GroupID, constant.OnlineStatus)
+		if err1 != nil {
+			log.NewError(msgToMQSingle.OperationID, "kafka send msg err:RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String())
+			promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
+			return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+		}
+		// callback
+		callbackResp = callbackAfterSendGroupMsg(pb)
+		if callbackResp.ErrCode != 0 {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendSuperGroupMsg resp: ", callbackResp)
+		}
+		promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessSuccessCounter)
+		return returnMsg(&replay, pb, 0, "", msgToMQSingle.MsgData.ServerMsgID, msgToMQSingle.MsgData.SendTime)
+
+	default:
+		return returnMsg(&replay, pb, 203, "unknown sessionType", "", 0)
+	}
+}
+
+func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *sdkws.GetMaxAndMinSeqReq) (*sdkws.GetMaxAndMinSeqResp, error) {
+	log.NewInfo(in.OperationID, "rpc getMaxAndMinSeq is arriving", in.String())
+	resp := new(sdkws.GetMaxAndMinSeqResp)
+	m := make(map[string]*sdkws.MaxAndMinSeq)
+	var maxSeq, minSeq uint64
+	var err1, err2 error
+	maxSeq, err1 = commonDB.DB.GetUserMaxSeq(in.UserID)
+	minSeq, err2 = commonDB.DB.GetUserMinSeq(in.UserID)
+	if (err1 != nil && err1 != go_redis.Nil) || (err2 != nil && err2 != go_redis.Nil) {
+		log.NewError(in.OperationID, "getMaxSeq from redis error", in.String())
+		if err1 != nil {
+			log.NewError(in.OperationID, utils.GetSelfFuncName(), err1.Error())
+		}
+		if err2 != nil {
+			log.NewError(in.OperationID, utils.GetSelfFuncName(), err2.Error())
+		}
+		resp.ErrCode = 200
+		resp.ErrMsg = "redis get err"
+		return resp, nil
+	}
+	resp.MaxSeq = uint32(maxSeq)
+	resp.MinSeq = uint32(minSeq)
+	for _, groupID := range in.GroupIDList {
+		x := new(sdkws.MaxAndMinSeq)
+		maxSeq, _ := commonDB.DB.GetGroupMaxSeq(groupID)
+		minSeq, _ := commonDB.DB.GetGroupUserMinSeq(groupID, in.UserID)
+		x.MaxSeq = uint32(maxSeq)
+		x.MinSeq = uint32(minSeq)
+		m[groupID] = x
+	}
+	resp.GroupMaxAndMinSeq = m
+	return resp, nil
+}
+
+func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *sdkws.PullMessageBySeqListReq) (*sdkws.PullMessageBySeqListResp, error) {
+	log.NewInfo(in.OperationID, "rpc PullMessageBySeqList is arriving", in.String())
+	resp := new(sdkws.PullMessageBySeqListResp)
+	m := make(map[string]*sdkws.MsgDataList)
+	redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(in.UserID, in.SeqList, in.OperationID)
+	if err != nil {
+		if err != go_redis.Nil {
+			promePkg.PromeAdd(promePkg.MsgPullFromRedisFailedCounter, len(failedSeqList))
+			log.Error(in.OperationID, "get message from redis exception", err.Error(), failedSeqList)
+		} else {
+			log.Debug(in.OperationID, "get message from redis is nil", failedSeqList)
+		}
+		msgList, err1 := commonDB.DB.GetMsgBySeqListMongo2(in.UserID, failedSeqList, in.OperationID)
+		if err1 != nil {
+			promePkg.PromeAdd(promePkg.MsgPullFromMongoFailedCounter, len(failedSeqList))
+			log.Error(in.OperationID, "PullMessageBySeqList data error", in.String(), err1.Error())
+			resp.ErrCode = 201
+			resp.ErrMsg = err1.Error()
+			return resp, nil
+		} else {
+			promePkg.PromeAdd(promePkg.MsgPullFromMongoSuccessCounter, len(msgList))
+			redisMsgList = append(redisMsgList, msgList...)
+			resp.List = redisMsgList
+		}
+	} else {
+		promePkg.PromeAdd(promePkg.MsgPullFromRedisSuccessCounter, len(redisMsgList))
+		resp.List = redisMsgList
+	}
+
+	for k, v := range in.GroupSeqList {
+		x := new(sdkws.MsgDataList)
+		redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(k, v.SeqList, in.OperationID)
+		if err != nil {
+			if err != go_redis.Nil {
+				promePkg.PromeAdd(promePkg.MsgPullFromRedisFailedCounter, len(failedSeqList))
+				log.Error(in.OperationID, "get message from redis exception", err.Error(), failedSeqList)
+			} else {
+				log.Debug(in.OperationID, "get message from redis is nil", failedSeqList)
+			}
+			msgList, err1 := commonDB.DB.GetSuperGroupMsgBySeqListMongo(k, failedSeqList, in.OperationID)
+			if err1 != nil {
+				promePkg.PromeAdd(promePkg.MsgPullFromMongoFailedCounter, len(failedSeqList))
+				log.Error(in.OperationID, "PullMessageBySeqList data error", in.String(), err1.Error())
+				resp.ErrCode = 201
+				resp.ErrMsg = err1.Error()
+				return resp, nil
+			} else {
+				promePkg.PromeAdd(promePkg.MsgPullFromMongoSuccessCounter, len(msgList))
+				redisMsgList = append(redisMsgList, msgList...)
+				x.MsgDataList = redisMsgList
+				m[k] = x
+			}
+		} else {
+			promePkg.PromeAdd(promePkg.MsgPullFromRedisSuccessCounter, len(redisMsgList))
+			x.MsgDataList = redisMsgList
+			m[k] = x
+		}
+	}
+	resp.GroupMsgDataList = m
+	return resp, nil
+}
@@ -2,9 +2,10 @@ package msg

 import (
 	"Open_IM/internal/common/notification"
+	"Open_IM/internal/common/rpcserver"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
+
 	"Open_IM/pkg/common/kafka"
 	"Open_IM/pkg/common/log"
 	promePkg "Open_IM/pkg/common/prometheus"
@@ -15,25 +16,13 @@ import (
 	"strconv"
 	"strings"

-	"github.com/golang/protobuf/proto"
-
 	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"

 	"google.golang.org/grpc"
 )

-type MessageWriter interface {
-	SendMessage(m proto.Message, key string, operationID string) (int32, int64, error)
-}
-type rpcChat struct {
-	rpcPort         int
-	rpcRegisterName string
-	etcdSchema      string
-	etcdAddr        []string
-	messageWriter   MessageWriter
-	//offlineProducer *kafka.Producer
-	delMsgCh       chan deleteMsg
-	dMessageLocker MessageLocker
+type msgServer struct {
+	*rpcserver.RpcServer
 }

 type deleteMsg struct {