sourceID2conversationID

internal/msggateway/n_ws_server.go

@@ -110,7 +110,8 @@ func (ws *WsServer) Run() error {
 			}
 		}
 	}()
-	http.HandleFunc("/", ws.wsHandler)                              //Get request from client to handle by wsHandler
+	http.HandleFunc("/", ws.wsHandler)
+	// http.HandleFunc("/metrics", func(w http.ResponseWriter, r *http.Request) {})
 	return http.ListenAndServe(":"+utils.IntToString(ws.port), nil) //Start listening
 }
 

internal/msgtransfer/modify_msg_handler.go

@@ -93,12 +93,12 @@ func (mmc *ModifyMsgConsumerHandler) ModifyMsg(ctx context.Context, cMsg *sarama
 					}
 				}
 
-				if err := mmc.extendMsgDatabase.InsertExtendMsg(ctx, notification.SourceID, notification.SessionType, &extendMsg); err != nil {
-					log.NewError(operationID, "MsgFirstModify InsertExtendMsg failed", notification.SourceID, notification.SessionType, extendMsg, err.Error())
+				if err := mmc.extendMsgDatabase.InsertExtendMsg(ctx, notification.ConversationID, notification.SessionType, &extendMsg); err != nil {
+					log.NewError(operationID, "MsgFirstModify InsertExtendMsg failed", notification.ConversationID, notification.SessionType, extendMsg, err.Error())
 					continue
 				}
 			} else {
-				if err := mmc.extendMsgDatabase.InsertOrUpdateReactionExtendMsgSet(ctx, notification.SourceID, notification.SessionType, notification.ClientMsgID, notification.MsgFirstModifyTime, mmc.extendSetMsgModel.Pb2Model(notification.SuccessReactionExtensions)); err != nil {
+				if err := mmc.extendMsgDatabase.InsertOrUpdateReactionExtendMsgSet(ctx, notification.ConversationID, notification.SessionType, notification.ClientMsgID, notification.MsgFirstModifyTime, mmc.extendSetMsgModel.Pb2Model(notification.SuccessReactionExtensions)); err != nil {
 					log.NewError(operationID, "InsertOrUpdateReactionExtendMsgSet failed")
 				}
 			}
@@ -107,7 +107,7 @@ func (mmc *ModifyMsgConsumerHandler) ModifyMsg(ctx context.Context, cMsg *sarama
 			if err := json.Unmarshal(msgDataToMQ.MsgData.Content, notification); err != nil {
 				continue
 			}
-			if err := mmc.extendMsgDatabase.DeleteReactionExtendMsgSet(ctx, notification.SourceID, notification.SessionType, notification.ClientMsgID, notification.MsgFirstModifyTime, mmc.extendSetMsgModel.Pb2Model(notification.SuccessReactionExtensions)); err != nil {
+			if err := mmc.extendMsgDatabase.DeleteReactionExtendMsgSet(ctx, notification.ConversationID, notification.SessionType, notification.ClientMsgID, notification.MsgFirstModifyTime, mmc.extendSetMsgModel.Pb2Model(notification.SuccessReactionExtensions)); err != nil {
 				log.NewError(operationID, "InsertOrUpdateReactionExtendMsgSet failed")
 			}
 		}

internal/msgtransfer/online_history_msg_handler.go

@@ -28,9 +28,9 @@ const MongoMessages = 5
 const ChannelNum = 100
 
 type MsgChannelValue struct {
-	sourceID   string //maybe userID or super groupID
-	ctx        context.Context
-	ctxMsgList []*ContextMsg
+	conversationID string //maybe userID or super groupID
+	ctx            context.Context
+	ctxMsgList     []*ContextMsg
 }
 
 type TriggerChannelValue struct {
@@ -88,12 +88,12 @@ func (och *OnlineHistoryRedisConsumerHandler) Run(channelID int) {
 				msgChannelValue := cmd.Value.(MsgChannelValue)
 				ctxMsgList := msgChannelValue.ctxMsgList
 				ctx := msgChannelValue.ctx
-				log.ZDebug(ctx, "msg arrived channel", "channel id", channelID, "msgList length", len(ctxMsgList), "sourceID", msgChannelValue.sourceID)
-				storageMsgList, notStorageMsgList, storageNotificationList, notStorageNotificationList, modifyMsgList := och.getPushStorageMsgList(msgChannelValue.sourceID, ctxMsgList)
-				och.handleMsg(ctx, msgChannelValue.sourceID, storageMsgList, notStorageMsgList)
-				och.handleNotification(ctx, msgChannelValue.sourceID, storageNotificationList, notStorageNotificationList)
-				if err := och.msgDatabase.MsgToModifyMQ(ctx, msgChannelValue.sourceID, modifyMsgList); err != nil {
-					log.ZError(ctx, "msg to modify mq error", err, "sourceID", msgChannelValue.sourceID, "modifyMsgList", modifyMsgList)
+				log.ZDebug(ctx, "msg arrived channel", "channel id", channelID, "msgList length", len(ctxMsgList), "conversationID", msgChannelValue.conversationID)
+				storageMsgList, notStorageMsgList, storageNotificationList, notStorageNotificationList, modifyMsgList := och.getPushStorageMsgList(msgChannelValue.conversationID, ctxMsgList)
+				och.handleMsg(ctx, msgChannelValue.conversationID, storageMsgList, notStorageMsgList)
+				och.handleNotification(ctx, msgChannelValue.conversationID, storageNotificationList, notStorageNotificationList)
+				if err := och.msgDatabase.MsgToModifyMQ(ctx, msgChannelValue.conversationID, modifyMsgList); err != nil {
+					log.ZError(ctx, "msg to modify mq error", err, "conversationID", msgChannelValue.conversationID, "modifyMsgList", modifyMsgList)
 				}
 			}
 		}
@@ -101,15 +101,16 @@ func (och *OnlineHistoryRedisConsumerHandler) Run(channelID int) {
 }
 
 // 获取消息/通知 存储的消息列表， 不存储并且推送的消息列表，
-func (och *OnlineHistoryRedisConsumerHandler) getPushStorageMsgList(sourceID string, totalMsgs []*ContextMsg) (storageMsgList, notStorageMsgList, storageNotificatoinList, notStorageNotificationList, modifyMsgList []*pbMsg.MsgDataToMQ) {
+func (och *OnlineHistoryRedisConsumerHandler) getPushStorageMsgList(conversationID string, totalMsgs []*ContextMsg) (storageMsgList, notStorageMsgList, storageNotificatoinList, notStorageNotificationList, modifyMsgList []*pbMsg.MsgDataToMQ) {
 	isStorage := func(msg *pbMsg.MsgDataToMQ) bool {
 		options2 := utils.Options(msg.MsgData.Options)
 		if options2.IsHistory() {
 			return true
 		} else {
-			if !(!options2.IsSenderSync() && sourceID == msg.MsgData.SendID) {
-				return false
-			}
+			// if !(!options2.IsSenderSync() && conversationID == msg.MsgData.SendID) {
+			// 	return false
+			// }
+			return false
 		}
 		return false
 	}
@@ -142,52 +143,55 @@ func (och *OnlineHistoryRedisConsumerHandler) getPushStorageMsgList(sourceID str
 	return
 }
 
-func (och *OnlineHistoryRedisConsumerHandler) handleNotification(ctx context.Context, sourceID string, storageList, notStorageList []*pbMsg.MsgDataToMQ) {
-	och.toPushTopic(ctx, sourceID, notStorageList)
+func (och *OnlineHistoryRedisConsumerHandler) handleNotification(ctx context.Context, conversationID string, storageList, notStorageList []*pbMsg.MsgDataToMQ) {
+	och.toPushTopic(ctx, conversationID, notStorageList)
 	if len(storageList) > 0 {
-		lastSeq, err := och.msgDatabase.NotificationBatchInsertChat2Cache(ctx, sourceID, storageList)
+		lastSeq, err := och.msgDatabase.NotificationBatchInsertChat2Cache(ctx, conversationID, storageList)
 		if err != nil {
-			log.ZError(ctx, "notification batch insert to redis error", err, "sourceID", sourceID, "storageList", storageList)
+			log.ZError(ctx, "notification batch insert to redis error", err, "conversationID", conversationID, "storageList", storageList)
 			return
 		}
-		och.msgDatabase.MsgToMongoMQ(ctx, sourceID, storageList, lastSeq)
-		och.toPushTopic(ctx, sourceID, storageList)
+		log.ZDebug(ctx, "success to next topic")
+		och.msgDatabase.MsgToMongoMQ(ctx, conversationID, storageList, lastSeq)
+		och.toPushTopic(ctx, conversationID, storageList)
 	}
 }
 
-func (och *OnlineHistoryRedisConsumerHandler) toPushTopic(ctx context.Context, sourceID string, msgs []*pbMsg.MsgDataToMQ) {
+func (och *OnlineHistoryRedisConsumerHandler) toPushTopic(ctx context.Context, conversationID string, msgs []*pbMsg.MsgDataToMQ) {
 	for _, v := range msgs {
-		och.msgDatabase.MsgToPushMQ(ctx, sourceID, v)
+		och.msgDatabase.MsgToPushMQ(ctx, conversationID, v)
 	}
 }
 
-func (och *OnlineHistoryRedisConsumerHandler) handleMsg(ctx context.Context, sourceID string, storageList, notStorageList []*pbMsg.MsgDataToMQ) {
-	och.toPushTopic(ctx, sourceID, notStorageList)
+func (och *OnlineHistoryRedisConsumerHandler) handleMsg(ctx context.Context, conversationID string, storageList, notStorageList []*pbMsg.MsgDataToMQ) {
+	och.toPushTopic(ctx, conversationID, notStorageList)
 	if len(storageList) > 0 {
 		var currentMaxSeq int64
 		var err error
 		if storageList[0].MsgData.SessionType == constant.SuperGroupChatType {
-			currentMaxSeq, err = och.msgDatabase.GetGroupMaxSeq(ctx, sourceID)
+			currentMaxSeq, err = och.msgDatabase.GetGroupMaxSeq(ctx, conversationID)
 			if err == redis.Nil {
+				log.ZInfo(ctx, "group chat first create conversation", "conversationID", conversationID)
 				if err := och.GroupChatFirstCreateConversation(ctx, storageList[0].MsgData); err != nil {
-					log.ZError(ctx, "single chat first create conversation error", err, "sourceID", sourceID)
+					log.ZError(ctx, "single chat first create conversation error", err, "conversationID", conversationID)
 				}
 			}
 		} else {
-			currentMaxSeq, err = och.msgDatabase.GetUserMaxSeq(ctx, sourceID)
+			currentMaxSeq, err = och.msgDatabase.GetUserMaxSeq(ctx, conversationID)
 			if err == redis.Nil {
+				log.ZInfo(ctx, "single chat first create conversation", "conversationID", conversationID)
 				if err := och.SingleChatFirstCreateConversation(ctx, storageList[0].MsgData); err != nil {
-					log.ZError(ctx, "single chat first create conversation error", err, "sourceID", sourceID)
+					log.ZError(ctx, "single chat first create conversation error", err, "conversationID", conversationID)
 				}
 			}
 		}
 		if err != nil && err != redis.Nil {
 			prome.Inc(prome.SeqGetFailedCounter)
-			log.ZError(ctx, "get max seq err", err, "sourceID", sourceID)
+			log.ZError(ctx, "get max seq err", err, "conversationID", conversationID)
 			return
 		}
 		prome.Inc(prome.SeqGetSuccessCounter)
-		lastSeq, err := och.msgDatabase.BatchInsertChat2Cache(ctx, sourceID, storageList, currentMaxSeq)
+		lastSeq, err := och.msgDatabase.BatchInsertChat2Cache(ctx, conversationID, storageList, currentMaxSeq)
 		if err != nil && err != redis.Nil {
 			log.ZError(ctx, "batch data insert to redis err", err, "storageMsgList", storageList)
 			och.singleMsgFailedCountMutex.Lock()
@@ -195,24 +199,26 @@ func (och *OnlineHistoryRedisConsumerHandler) handleMsg(ctx context.Context, sou
 			och.singleMsgFailedCountMutex.Unlock()
 			return
 		}
+		log.ZDebug(ctx, "success to next topic")
 		och.singleMsgSuccessCountMutex.Lock()
 		och.singleMsgSuccessCount += uint64(len(storageList))
 		och.singleMsgSuccessCountMutex.Unlock()
-		och.msgDatabase.MsgToMongoMQ(ctx, sourceID, storageList, lastSeq)
-		och.toPushTopic(ctx, sourceID, storageList)
+		och.msgDatabase.MsgToMongoMQ(ctx, conversationID, storageList, lastSeq)
+		och.toPushTopic(ctx, conversationID, storageList)
 	}
 }
 
 func (och *OnlineHistoryRedisConsumerHandler) SingleChatFirstCreateConversation(ctx context.Context, msg *sdkws.MsgData) error {
 	conversation := new(pbConversation.Conversation)
+	conversationID := utils.GetConversationIDBySessionType(constant.SingleChatType, msg.RecvID, msg.SendID)
 	conversation.ConversationType = constant.SingleChatType
 	conversation2 := proto.Clone(conversation).(*pbConversation.Conversation)
 	conversation.OwnerUserID = msg.SendID
 	conversation.UserID = msg.RecvID
-	conversation.ConversationID = utils.GetConversationIDBySessionType(msg.RecvID, constant.SingleChatType)
+	conversation.ConversationID = conversationID
 	conversation2.OwnerUserID = msg.RecvID
 	conversation2.UserID = msg.SendID
-	conversation2.ConversationID = utils.GetConversationIDBySessionType(msg.SendID, constant.SingleChatType)
+	conversation2.ConversationID = conversationID
 	log.ZDebug(ctx, "create single conversation", "conversation", conversation, "conversation2", conversation2)
 	return och.conversationRpcClient.CreateConversationsWithoutNotification(ctx, []*pbConversation.Conversation{conversation, conversation2})
 }
@@ -224,7 +230,7 @@ func (och *OnlineHistoryRedisConsumerHandler) GroupChatFirstCreateConversation(c
 	}
 	var conversations []*pbConversation.Conversation
 	for _, v := range userIDs {
-		conversation := pbConversation.Conversation{ConversationType: constant.SuperGroupChatType, GroupID: msg.GroupID, OwnerUserID: v, ConversationID: utils.GetConversationIDBySessionType(v, constant.SuperGroupChatType)}
+		conversation := pbConversation.Conversation{ConversationType: constant.SuperGroupChatType, GroupID: msg.GroupID, OwnerUserID: v, ConversationID: utils.GetConversationIDBySessionType(constant.SuperGroupChatType, msg.GroupID)}
 		conversations = append(conversations, &conversation)
 	}
 	log.ZDebug(ctx, "create group conversation", "conversations", conversations)
@@ -265,12 +271,12 @@ func (och *OnlineHistoryRedisConsumerHandler) MessagesDistributionHandle() {
 					}
 				}
 				log.ZDebug(ctx, "generate map list users len", "length", len(aggregationMsgs))
-				for sourceID, v := range aggregationMsgs {
+				for conversationID, v := range aggregationMsgs {
 					if len(v) >= 0 {
-						hashCode := utils.GetHashCode(sourceID)
+						hashCode := utils.GetHashCode(conversationID)
 						channelID := hashCode % ChannelNum
-						log.ZDebug(ctx, "generate channelID", "hashCode", hashCode, "channelID", channelID, "sourceID", sourceID)
-						och.chArrays[channelID] <- Cmd2Value{Cmd: AggregationMessages, Value: MsgChannelValue{sourceID: sourceID, ctxMsgList: v, ctx: ctx}}
+						log.ZDebug(ctx, "generate channelID", "hashCode", hashCode, "channelID", channelID, "conversationID", conversationID)
+						och.chArrays[channelID] <- Cmd2Value{Cmd: SourceMessages, Value: MsgChannelValue{conversationID: conversationID, ctxMsgList: v, ctx: ctx}}
 					}
 				}
 			}

internal/msgtransfer/online_msg_to_mongo_handler.go

@@ -40,14 +40,14 @@ func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(ctx context.Cont
 		log.Error("msg_transfer Unmarshal msg err", "", "msg", string(msg), "err", err.Error())
 		return
 	}
-	log.Info(operationID, "BatchInsertChat2DB userID: ", msgFromMQ.SourceID, "msgFromMQ.LastSeq: ", msgFromMQ.LastSeq)
-	err = mc.msgDatabase.BatchInsertChat2DB(ctx, msgFromMQ.SourceID, msgFromMQ.Messages, msgFromMQ.LastSeq)
+	log.Info(operationID, "BatchInsertChat2DB userID: ", msgFromMQ.ConversationID, "msgFromMQ.LastSeq: ", msgFromMQ.LastSeq)
+	err = mc.msgDatabase.BatchInsertChat2DB(ctx, msgFromMQ.ConversationID, msgFromMQ.Messages, msgFromMQ.LastSeq)
 	if err != nil {
-		log.NewError(operationID, "single data insert to mongo err", err.Error(), msgFromMQ.Messages, msgFromMQ.SourceID, msgFromMQ.TriggerID)
+		log.NewError(operationID, "single data insert to mongo err", err.Error(), msgFromMQ.Messages, msgFromMQ.ConversationID, msgFromMQ.TriggerID)
 	}
-	err = mc.msgDatabase.DeleteMessageFromCache(ctx, msgFromMQ.SourceID, msgFromMQ.Messages)
+	err = mc.msgDatabase.DeleteMessageFromCache(ctx, msgFromMQ.ConversationID, msgFromMQ.Messages)
 	if err != nil {
-		log.NewError(operationID, "remove cache msg from redis err", err.Error(), msgFromMQ.Messages, msgFromMQ.SourceID, msgFromMQ.TriggerID)
+		log.NewError(operationID, "remove cache msg from redis err", err.Error(), msgFromMQ.Messages, msgFromMQ.ConversationID, msgFromMQ.TriggerID)
 	}
 	for _, v := range msgFromMQ.Messages {
 		if v.MsgData.ContentType == constant.DeleteMessageNotification {

internal/push/push_handler.go

@@ -35,8 +35,8 @@ func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
 		return
 	}
 	pbData := &pbPush.PushMsgReq{
-		MsgData:  msgFromMQ.MsgData,
-		SourceID: msgFromMQ.SourceID,
+		MsgData:        msgFromMQ.MsgData,
+		ConversationID: msgFromMQ.ConversationID,
 	}
 	sec := msgFromMQ.MsgData.SendTime / 1000
 	nowSec := utils.GetCurrentTimestampBySecond()
@@ -46,9 +46,9 @@ func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
 	var err error
 	switch msgFromMQ.MsgData.SessionType {
 	case constant.SuperGroupChatType:
-		err = c.pusher.MsgToSuperGroupUser(ctx, pbData.SourceID, pbData.MsgData)
+		err = c.pusher.MsgToSuperGroupUser(ctx, pbData.ConversationID, pbData.MsgData)
 	default:
-		err = c.pusher.MsgToUser(ctx, pbData.SourceID, pbData.MsgData)
+		err = c.pusher.MsgToUser(ctx, pbData.ConversationID, pbData.MsgData)
 	}
 	if err != nil {
 		log.ZError(ctx, "push failed", err, "msg", pbData.String())

internal/push/push_rpc_server.go

@@ -2,6 +2,8 @@ package push
 
 import (
 	"context"
+	"sync"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
@@ -9,7 +11,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	pbPush "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/push"
 	"google.golang.org/grpc"
-	"sync"
 )
 
 type pushServer struct {
@@ -46,9 +47,9 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 func (r *pushServer) PushMsg(ctx context.Context, pbData *pbPush.PushMsgReq) (resp *pbPush.PushMsgResp, err error) {
 	switch pbData.MsgData.SessionType {
 	case constant.SuperGroupChatType:
-		err = r.pusher.MsgToSuperGroupUser(ctx, pbData.SourceID, pbData.MsgData)
+		err = r.pusher.MsgToSuperGroupUser(ctx, pbData.ConversationID, pbData.MsgData)
 	default:
-		err = r.pusher.MsgToUser(ctx, pbData.SourceID, pbData.MsgData)
+		err = r.pusher.MsgToUser(ctx, pbData.ConversationID, pbData.MsgData)
 	}
 	if err != nil {
 		return nil, err

internal/push/push_to_client.go

@@ -196,8 +196,8 @@ func (p *Pusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
 	return wsResults, nil
 }
 
-func (p *Pusher) offlinePushMsg(ctx context.Context, sourceID string, msg *sdkws.MsgData, offlinePushUserIDs []string) error {
-	title, content, opts, err := p.getOfflinePushInfos(sourceID, msg)
+func (p *Pusher) offlinePushMsg(ctx context.Context, conversationID string, msg *sdkws.MsgData, offlinePushUserIDs []string) error {
+	title, content, opts, err := p.getOfflinePushInfos(conversationID, msg)
 	if err != nil {
 		return err
 	}
@@ -230,7 +230,7 @@ func (p *Pusher) GetOfflinePushOpts(msg *sdkws.MsgData) (opts *offlinepush.Opts,
 	return opts, nil
 }
 
-func (p *Pusher) getOfflinePushInfos(sourceID string, msg *sdkws.MsgData) (title, content string, opts *offlinepush.Opts, err error) {
+func (p *Pusher) getOfflinePushInfos(conversationID string, msg *sdkws.MsgData) (title, content string, opts *offlinepush.Opts, err error) {
 	if p.offlinePusher == nil {
 		err = errors.New("no offlinePusher is configured")
 		return
@@ -263,7 +263,7 @@ func (p *Pusher) getOfflinePushInfos(sourceID string, msg *sdkws.MsgData) (title
 		case constant.AtText:
 			a := AtContent{}
 			_ = utils.JsonStringToStruct(string(msg.Content), &a)
-			if utils.IsContain(sourceID, a.AtUserList) {
+			if utils.IsContain(conversationID, a.AtUserList) {
 				title = constant.ContentType2PushContent[constant.AtText] + constant.ContentType2PushContent[constant.Common]
 			} else {
 				title = constant.ContentType2PushContent[constant.GroupMsg]

internal/rpc/group/group.go

@@ -758,7 +758,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		args := &pbConversation.ModifyConversationFieldReq{
 			Conversation: &pbConversation.Conversation{
 				OwnerUserID:      mcontext.GetOpUserID(ctx),
-				ConversationID:   utils.GetConversationIDBySessionType(group.GroupID, constant.GroupChatType),
+				ConversationID:   utils.GetConversationIDBySessionType(constant.GroupChatType, group.GroupID),
 				ConversationType: constant.SuperGroupChatType,
 				GroupID:          group.GroupID,
 			},

internal/rpc/msg/extend_msg.go

@@ -2,6 +2,7 @@ package msg
 
 import (
 	"context"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 )
@@ -17,7 +18,7 @@ func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	////if ExternalExtension
 	//if req.IsExternalExtensions {
 	//	resp.MsgFirstModifyTime = req.MsgFirstModifyTime
-	//	notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &resp, !req.IsReact, false)
+	//	notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &resp, !req.IsReact, false)
 	//	return resp, nil
 	//}
 	//isExists, err := m.MsgDatabase.JudgeMessageReactionExist(ctx, req.ClientMsgID, req.SessionType)
@@ -48,7 +49,7 @@ func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	//		if err != nil {
 	//			return nil, err
 	//		}
-	//		mongoValue, err := m.MsgDatabase.GetExtendMsg(ctx, req.SourceID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime)
+	//		mongoValue, err := m.MsgDatabase.GetExtendMsg(ctx, req.conversationID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime)
 	//		if err != nil {
 	//			return nil, err
 	//		}
@@ -68,7 +69,7 @@ func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	//			temp.LatestUpdateTime = utils.GetCurrentTimestampByMill()
 	//			setValue[k] = temp
 	//		}
-	//		err = db.DB.InsertOrUpdateReactionExtendMsgSet(req.SourceID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime, setValue)
+	//		err = db.DB.InsertOrUpdateReactionExtendMsgSet(req.conversationID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime, setValue)
 	//		if err != nil {
 	//			for _, value := range setValue {
 	//				temp := new(msg.KeyValueResp)
@@ -123,12 +124,12 @@ func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	//}
 	//if !isExists {
 	//	if !req.IsReact {
-	//		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &resp, true, true)
+	//		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &resp, true, true)
 	//	} else {
-	//		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &resp, false, false)
+	//		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &resp, false, false)
 	//	}
 	//} else {
-	//	notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &resp, false, true)
+	//	notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &resp, false, true)
 	//}
 	//log.Debug(req.OperationID, utils.GetSelfFuncName(), "m return is:", resp.String())
 	return resp, nil
@@ -182,7 +183,7 @@ func (m *msgServer) GetMessagesReactionExtensions(ctx context.Context, req *msg.
 	//		oneMessage.Pb2Model = keyMap
 	//
 	//	} else {
-	//		mongoValue, err := db.DB.GetExtendMsg(req.SourceID, req.SessionType, messageValue.ClientMsgID, messageValue.MsgFirstModifyTime)
+	//		mongoValue, err := db.DB.GetExtendMsg(req.conversationID, req.SessionType, messageValue.ClientMsgID, messageValue.MsgFirstModifyTime)
 	//		if err != nil {
 	//			oneMessage.ErrCode = 100
 	//			oneMessage.ErrMsg = err.Error()
@@ -230,7 +231,7 @@ func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	////if ExternalExtension
 	//if req.IsExternalExtensions {
 	//	rResp.Result = callbackResp.ResultReactionExtensionList
-	//	notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, false)
+	//	notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &rResp, false, false)
 	//	return &rResp, nil
 	//
 	//}
@@ -302,7 +303,7 @@ func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	//		}
 	//		return &rResp, nil
 	//	}
-	//	mongoValue, err := db.DB.GetExtendMsg(req.SourceID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime)
+	//	mongoValue, err := db.DB.GetExtendMsg(req.conversationID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime)
 	//	if err != nil {
 	//		rResp.ErrCode = 200
 	//		rResp.ErrMsg = err.Error()
@@ -332,7 +333,7 @@ func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	//		temp.TypeKey = v.TypeKey
 	//		setValue[v.TypeKey] = temp
 	//	}
-	//	err = db.DB.DeleteReactionExtendMsgSet(req.SourceID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime, setValue)
+	//	err = db.DB.DeleteReactionExtendMsgSet(req.conversationID, req.SessionType, req.ClientMsgID, req.MsgFirstModifyTime, setValue)
 	//	if err != nil {
 	//		for _, value := range setValue {
 	//			temp := new(msg.KeyValueResp)
@@ -354,7 +355,7 @@ func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	//	}
 	//
 	//}
-	//notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, isExists)
+	//notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.conversationID, req.SessionType, req, &rResp, false, isExists)
 	//log.Debug(req.OperationID, utils.GetSelfFuncName(), "m return is:", rResp.String())
 	return resp, nil
 }

internal/rpc/msg/extend_msg_callback.go

@@ -2,6 +2,7 @@ package msg
 
 import (
 	"context"
+
 	cbapi "github.com/OpenIMSDK/Open-IM-Server/pkg/callbackstruct"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
@@ -17,7 +18,7 @@ func CallbackSetMessageReactionExtensions(ctx context.Context, setReq *msg.SetMe
 	req := &cbapi.CallbackBeforeSetMessageReactionExtReq{
 		OperationID:           mcontext.GetOperationID(ctx),
 		CallbackCommand:       constant.CallbackBeforeSetMessageReactionExtensionCommand,
-		SourceID:              setReq.SourceID,
+		ConversationID:        setReq.ConversationID,
 		OpUserID:              mcontext.GetOpUserID(ctx),
 		SessionType:           setReq.SessionType,
 		ReactionExtensionList: setReq.ReactionExtensions,
@@ -41,7 +42,7 @@ func CallbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessagesReactionE
 	req := &cbapi.CallbackDeleteMessageReactionExtReq{
 		OperationID:           setReq.OperationID,
 		CallbackCommand:       constant.CallbackBeforeDeleteMessageReactionExtensionsCommand,
-		SourceID:              setReq.SourceID,
+		ConversationID:        setReq.ConversationID,
 		OpUserID:              setReq.OpUserID,
 		SessionType:           setReq.SessionType,
 		ReactionExtensionList: setReq.ReactionExtensions,
@@ -60,7 +61,7 @@ func CallbackGetMessageListReactionExtensions(ctx context.Context, getReq *msg.G
 	req := &cbapi.CallbackGetMessageListReactionExtReq{
 		OperationID:     mcontext.GetOperationID(ctx),
 		CallbackCommand: constant.CallbackGetMessageListReactionExtensionsCommand,
-		SourceID:        getReq.SourceID,
+		ConversationID:  getReq.ConversationID,
 		OpUserID:        mcontext.GetOperationID(ctx),
 		SessionType:     getReq.SessionType,
 		TypeKeyList:     getReq.TypeKeys,
@@ -73,7 +74,7 @@ func CallbackAddMessageReactionExtensions(ctx context.Context, setReq *msg.Modif
 	req := &cbapi.CallbackAddMessageReactionExtReq{
 		OperationID:           mcontext.GetOperationID(ctx),
 		CallbackCommand:       constant.CallbackAddMessageListReactionExtensionsCommand,
-		SourceID:              setReq.SourceID,
+		ConversationID:        setReq.ConversationID,
 		OpUserID:              mcontext.GetOperationID(ctx),
 		SessionType:           setReq.SessionType,
 		ReactionExtensionList: setReq.ReactionExtensions,

internal/rpc/msg/send_msg.go

@@ -2,16 +2,17 @@ package msg
 
 import (
 	"context"
+	"math/rand"
+	"strconv"
+	"sync"
+	"time"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"math/rand"
-	"strconv"
-	"sync"
-	"time"
 )
 
 var (
@@ -252,7 +253,7 @@ func GetMsgID(sendID string) string {
 	return utils.Md5(t + "-" + sendID + "-" + strconv.Itoa(rand.Int()))
 }
 
-func (m *msgServer) modifyMessageByUserMessageReceiveOpt(ctx context.Context, userID, sourceID string, sessionType int, pb *msg.SendMsgReq) (bool, error) {
+func (m *msgServer) modifyMessageByUserMessageReceiveOpt(ctx context.Context, userID, conversationID string, sessionType int, pb *msg.SendMsgReq) (bool, error) {
 	opt, err := m.User.GetUserGlobalMsgRecvOpt(ctx, userID)
 	if err != nil {
 		return false, err
@@ -268,11 +269,11 @@ func (m *msgServer) modifyMessageByUserMessageReceiveOpt(ctx context.Context, us
 		utils.SetSwitchFromOptions(pb.MsgData.Options, constant.IsOfflinePush, false)
 		return true, nil
 	}
-	conversationID := utils.GetConversationIDBySessionType(sourceID, sessionType)
+	// conversationID := utils.GetConversationIDBySessionType(conversationID, sessionType)
 	singleOpt, err := m.Conversation.GetSingleConversationRecvMsgOpt(ctx, userID, conversationID)
-	//if err != nil {
-	//	return false, err
-	//}
+	if err != nil {
+		return false, err
+	}
 	return true, nil
 	switch singleOpt {
 	case constant.ReceiveMessage:
@@ -323,7 +324,8 @@ func (m *msgServer) sendMsgToGroupOptimization(ctx context.Context, list []strin
 			options[k] = v
 		}
 		groupPB.MsgData.Options = options
-		isSend, err := m.modifyMessageByUserMessageReceiveOpt(ctx, v, groupPB.MsgData.GroupID, constant.GroupChatType, groupPB)
+		conversationID := utils.GetConversationIDBySessionType(constant.GroupChatType, groupPB.MsgData.GroupID)
+		isSend, err := m.modifyMessageByUserMessageReceiveOpt(ctx, v, conversationID, constant.GroupChatType, groupPB)
 		if err != nil {
 			wg.Done()
 			return err

internal/rpc/msg/send_pull.go

@@ -175,7 +175,7 @@ func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (
 			var atUserID []string
 			conversation := pbConversation.Conversation{
 				OwnerUserID:      req.MsgData.SendID,
-				ConversationID:   utils.GetConversationIDBySessionType(req.MsgData.GroupID, constant.GroupChatType),
+				ConversationID:   utils.GetConversationIDBySessionType(constant.GroupChatType, req.MsgData.GroupID),
 				ConversationType: constant.GroupChatType,
 				GroupID:          req.MsgData.GroupID,
 			}

internal/rpc/msg/server.go

@@ -159,20 +159,16 @@ func (m *msgServer) GetMaxAndMinSeq(ctx context.Context, req *sdkws.GetMaxAndMin
 }
 
 func (m *msgServer) PullMessageBySeqs(ctx context.Context, req *sdkws.PullMessageBySeqsReq) (*sdkws.PullMessageBySeqsResp, error) {
-	resp := &sdkws.PullMessageBySeqsResp{GroupMsgDataList: make(map[string]*sdkws.MsgDataList)}
-	msgs, err := m.MsgDatabase.GetMsgBySeqs(ctx, req.UserID, req.Seqs)
-	if err != nil {
-		return nil, err
-	}
-	resp.List = msgs
-	for groupID, list := range req.GroupSeqs {
-		msgs, err := m.MsgDatabase.GetSuperGroupMsgBySeqs(ctx, groupID, list.Seqs)
+	resp := &sdkws.PullMessageBySeqsResp{}
+	for _, seq := range req.SeqRanges {
+		msgs, err := m.MsgDatabase.GetMsgBySeqsRange(ctx, seq.ConversationID, seq.Begin, seq.End, seq.Num)
 		if err != nil {
 			return nil, err
 		}
-		resp.GroupMsgDataList[groupID] = &sdkws.MsgDataList{
-			MsgDataList: msgs,
-		}
+		resp.Msgs = append(resp.Msgs, &sdkws.PullMsgs{
+			ConversationID: seq.ConversationID,
+			Msgs:           msgs,
+		})
 	}
 	return resp, nil
 }

internal/tools/msg.go

@@ -167,7 +167,7 @@ func (c *MsgTool) GetAndFixGroupUserSeq(ctx context.Context, userID string, grou
 	return minSeqCache, nil
 }
 
-func (c *MsgTool) CheckMaxSeqWithMongo(ctx context.Context, sourceID string, maxSeqCache, maxSeqMongo int64, diffusionType int) error {
+func (c *MsgTool) CheckMaxSeqWithMongo(ctx context.Context, conversationID string, maxSeqCache, maxSeqMongo int64, diffusionType int) error {
 	if math.Abs(float64(maxSeqMongo-maxSeqCache)) > 10 {
 		return errSeq
 	}