errcode

pkg/common/db/cache/conversation.go

@@ -21,7 +21,7 @@ const (
 	conversationExpireTime               = time.Second * 60 * 60 * 12
 )
 
-// args fn will exec when no data in cache
+// arg fn will exec when no data in cache
 type ConversationCache interface {
 	// get user's conversationIDs from cache
 	GetUserConversationIDs(ctx context.Context, userID string, fn func(ctx context.Context, userID string) ([]string, error)) ([]string, error)
@@ -96,7 +96,7 @@ func (c *ConversationRedis) GetUserConversationIDs(ctx context.Context, ownerUse
 	//	return nil, utils.Wrap(err, "")
 	//}
 	//return conversationIDs, nil
-	return GetCache(ctx, c.rcClient, c.getConversationIDsKey(ownerUserID), time.Second*30*60, func(ctx context.Context) ([]string, error) {
+	return GetCache(ctx, c.rcClient, c.getConversationIDsKey(ownerUserID), conversationExpireTime, func(ctx context.Context) ([]string, error) {
 		return f(ownerUserID)
 	})
 }
@@ -122,7 +122,7 @@ func (c *ConversationRedis) GetUserConversationIDs1(ctx context.Context, ownerUs
 	//	return nil, utils.Wrap(err, "")
 	//}
 	//return conversationIDs, nil
-	return GetCache1[[]string](c.rcClient, c.getConversationIDsKey(ownerUserID), time.Second*30*60, fn)
+	return GetCache1[[]string](c.rcClient, c.getConversationIDsKey(ownerUserID), conversationExpireTime, fn)
 }
 
 //func GetCache1[T any](rcClient *rockscache.Client, key string, expire time.Duration, fn func() (any, error)) (T, error) {

pkg/common/db/cache/redis.go

@@ -3,10 +3,9 @@ package cache
 import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
-	log2 "Open_IM/pkg/common/log"
 	pbChat "Open_IM/pkg/proto/msg"
 	pbRtc "Open_IM/pkg/proto/rtc"
-	pbCommon "Open_IM/pkg/proto/sdkws"
+	"Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
 	"errors"
@@ -39,13 +38,52 @@ const (
 )
 
 type Cache interface {
-	IncrUserSeq(uid string) (uint64, error)
-	GetUserMaxSeq(uid string) (uint64, error)
-	SetUserMaxSeq(uid string, maxSeq uint64) error
-	SetUserMinSeq(uid string, minSeq uint32) (err error)
-	GetUserMinSeq(uid string) (uint64, error)
-	SetGroupUserMinSeq(groupID, userID string, minSeq uint64) (err error)
-	GetGroupUserMinSeq(groupID, userID string) (uint64, error)
+	IncrUserSeq(ctx context.Context, userID string) (uint64, error)
+	GetUserMaxSeq(ctx context.Context, userID string) (uint64, error)
+	SetUserMaxSeq(ctx context.Context, userID string, maxSeq uint64) error
+	SetUserMinSeq(ctx context.Context, userID string, minSeq uint64) (err error)
+	GetUserMinSeq(ctx context.Context, userID string) (uint64, error)
+	SetGroupUserMinSeq(ctx context.Context, groupID, userID string, minSeq uint64) (err error)
+	GetGroupUserMinSeq(ctx context.Context, groupID, userID string) (uint64, error)
+	GetGroupMaxSeq(ctx context.Context, groupID string) (uint64, error)
+	IncrGroupMaxSeq(ctx context.Context, groupID string) (uint64, error)
+	SetGroupMaxSeq(ctx context.Context, groupID string, maxSeq uint64) error
+	SetGroupMinSeq(ctx context.Context, groupID string, minSeq uint32) error
+	AddTokenFlag(ctx context.Context, userID string, platformID int, token string, flag int) error
+	GetTokenMapByUidPid(ctx context.Context, userID, platformID string) (map[string]int, error)
+	SetTokenMapByUidPid(ctx context.Context, userID string, platformID int, m map[string]int) error
+	DeleteTokenByUidPid(ctx context.Context, userID string, platformID int, fields []string) error
+	GetMessageListBySeq(ctx context.Context, userID string, seqList []uint32) (seqMsg []*sdkws.MsgData, failedSeqList []uint32, err error)
+	SetMessageToCache(ctx context.Context, userID string, msgList []*pbChat.MsgDataToMQ) (int, error)
+	DeleteMessageFromCache(ctx context.Context, userID string, msgList []*pbChat.MsgDataToMQ) error
+	CleanUpOneUserAllMsgFromRedis(ctx context.Context, userID string) error
+	HandleSignalInfo(ctx context.Context, msg *sdkws.MsgData, pushToUserID string) (isSend bool, err error)
+	GetSignalInfoFromCacheByClientMsgID(ctx context.Context, clientMsgID string) (invitationInfo *pbRtc.SignalInviteReq, err error)
+	GetAvailableSignalInvitationInfo(ctx context.Context, userID string) (invitationInfo *pbRtc.SignalInviteReq, err error)
+	DelUserSignalList(ctx context.Context, userID string) error
+	DelMsgFromCache(ctx context.Context, userID string, seqList []uint32) error
+
+	SetGetuiToken(ctx context.Context, token string, expireTime int64) error
+	GetGetuiToken(ctx context.Context) (string, error)
+	SetGetuiTaskID(ctx context.Context, taskID string, expireTime int64) error
+	GetGetuiTaskID(ctx context.Context) (string, error)
+
+	SetSendMsgStatus(ctx context.Context, status int32) error
+	GetSendMsgStatus(ctx context.Context) (int, error)
+	SetFcmToken(ctx context.Context, account string, platformID int, fcmToken string, expireTime int64) (err error)
+	GetFcmToken(ctx context.Context, account string, platformID int) (string, error)
+	DelFcmToken(ctx context.Context, account string, platformID int) error
+	IncrUserBadgeUnreadCountSum(ctx context.Context, userID string) (int, error)
+	SetUserBadgeUnreadCountSum(ctx context.Context, userID string, value int) error
+	GetUserBadgeUnreadCountSum(ctx context.Context, userID string) (int, error)
+	JudgeMessageReactionEXISTS(ctx context.Context, clientMsgID string, sessionType int32) (bool, error)
+	GetOneMessageAllReactionList(ctx context.Context, clientMsgID string, sessionType int32) (map[string]string, error)
+	DeleteOneMessageKey(ctx context.Context, clientMsgID string, sessionType int32, subKey string) error
+	SetMessageReactionExpire(ctx context.Context, clientMsgID string, sessionType int32, expiration time.Duration) (bool, error)
+	GetMessageTypeKeyValue(ctx context.Context, clientMsgID string, sessionType int32, typeKey string) (string, error)
+	SetMessageTypeKeyValue(ctx context.Context, clientMsgID string, sessionType int32, typeKey, value string) error
+	LockMessageTypeKey(ctx context.Context, clientMsgID string, TypeKey string) error
+	UnLockMessageTypeKey(ctx context.Context, clientMsgID string, TypeKey string) error
 }
 
 // native redis operate
@@ -54,7 +92,7 @@ type RedisClient struct {
 	rdb redis.UniversalClient
 }
 
-func (r *RedisClient) InitRedis() {
+func (r *RedisClient) InitRedis() error {
 	var rdb redis.UniversalClient
 	var err error
 	ctx := context.Background()
@@ -67,8 +105,8 @@ func (r *RedisClient) InitRedis() {
 		})
 		_, err = rdb.Ping(ctx).Result()
 		if err != nil {
-			fmt.Println("redis cluster failed address ", config.Config.Redis.DBAddress)
-			panic(err.Error() + " redis cluster " + config.Config.Redis.DBUserName + config.Config.Redis.DBPassWord)
+			fmt.Println("redis cluster failed address ", config.Config.Redis.DBAddress, config.Config.Redis.DBUserName, config.Config.Redis.DBPassWord)
+			return err
 		}
 	} else {
 		rdb = redis.NewClient(&redis.Options{
@@ -80,10 +118,12 @@ func (r *RedisClient) InitRedis() {
 		})
 		_, err = rdb.Ping(ctx).Result()
 		if err != nil {
-			panic(err.Error() + " redis " + config.Config.Redis.DBAddress[0] + config.Config.Redis.DBUserName + config.Config.Redis.DBPassWord)
+			fmt.Println(" redis " + config.Config.Redis.DBAddress[0] + config.Config.Redis.DBUserName + config.Config.Redis.DBPassWord)
+			return err
 		}
 	}
 	r.rdb = rdb
+	return nil
 }
 
 func (r *RedisClient) GetClient() redis.UniversalClient {
@@ -95,80 +135,78 @@ func NewRedisClient(rdb redis.UniversalClient) *RedisClient {
 }
 
 // Perform seq auto-increment operation of user messages
-func (r *RedisClient) IncrUserSeq(uid string) (uint64, error) {
+func (r *RedisClient) IncrUserSeq(ctx context.Context, uid string) (uint64, error) {
 	key := userIncrSeq + uid
 	seq, err := r.rdb.Incr(context.Background(), key).Result()
 	return uint64(seq), err
 }
 
 // Get the largest Seq
-func (r *RedisClient) GetUserMaxSeq(uid string) (uint64, error) {
+func (r *RedisClient) GetUserMaxSeq(ctx context.Context, uid string) (uint64, error) {
 	key := userIncrSeq + uid
 	seq, err := r.rdb.Get(context.Background(), key).Result()
 	return uint64(utils.StringToInt(seq)), err
 }
 
 // set the largest Seq
-func (r *RedisClient) SetUserMaxSeq(uid string, maxSeq uint64) error {
+func (r *RedisClient) SetUserMaxSeq(ctx context.Context, uid string, maxSeq uint64) error {
 	key := userIncrSeq + uid
 	return r.rdb.Set(context.Background(), key, maxSeq, 0).Err()
 }
 
 // Set the user's minimum seq
-func (r *RedisClient) SetUserMinSeq(uid string, minSeq uint32) (err error) {
+func (r *RedisClient) SetUserMinSeq(ctx context.Context, uid string, minSeq uint64) (err error) {
 	key := userMinSeq + uid
 	return r.rdb.Set(context.Background(), key, minSeq, 0).Err()
 }
 
 // Get the smallest Seq
-func (r *RedisClient) GetUserMinSeq(uid string) (uint64, error) {
+func (r *RedisClient) GetUserMinSeq(ctx context.Context, uid string) (uint64, error) {
 	key := userMinSeq + uid
 	seq, err := r.rdb.Get(context.Background(), key).Result()
 	return uint64(utils.StringToInt(seq)), err
 }
 
-func (r *RedisClient) SetGroupUserMinSeq(groupID, userID string, minSeq uint64) (err error) {
+func (r *RedisClient) SetGroupUserMinSeq(ctx context.Context, groupID, userID string, minSeq uint64) (err error) {
 	key := groupUserMinSeq + "g:" + groupID + "u:" + userID
 	return r.rdb.Set(context.Background(), key, minSeq, 0).Err()
 }
-func (r *RedisClient) GetGroupUserMinSeq(groupID, userID string) (uint64, error) {
+func (r *RedisClient) GetGroupUserMinSeq(ctx context.Context, groupID, userID string) (uint64, error) {
 	key := groupUserMinSeq + "g:" + groupID + "u:" + userID
 	seq, err := r.rdb.Get(context.Background(), key).Result()
 	return uint64(utils.StringToInt(seq)), err
 }
 
-func (r *RedisClient) GetGroupMaxSeq(groupID string) (uint64, error) {
+func (r *RedisClient) GetGroupMaxSeq(ctx context.Context, groupID string) (uint64, error) {
 	key := groupMaxSeq + groupID
 	seq, err := r.rdb.Get(context.Background(), key).Result()
 	return uint64(utils.StringToInt(seq)), err
 }
 
-func (r *RedisClient) IncrGroupMaxSeq(groupID string) (uint64, error) {
+func (r *RedisClient) IncrGroupMaxSeq(ctx context.Context, groupID string) (uint64, error) {
 	key := groupMaxSeq + groupID
 	seq, err := r.rdb.Incr(context.Background(), key).Result()
 	return uint64(seq), err
 }
 
-func (r *RedisClient) SetGroupMaxSeq(groupID string, maxSeq uint64) error {
+func (r *RedisClient) SetGroupMaxSeq(ctx context.Context, groupID string, maxSeq uint64) error {
 	key := groupMaxSeq + groupID
 	return r.rdb.Set(context.Background(), key, maxSeq, 0).Err()
 }
 
-func (r *RedisClient) SetGroupMinSeq(groupID string, minSeq uint32) error {
+func (r *RedisClient) SetGroupMinSeq(ctx context.Context, groupID string, minSeq uint32) error {
 	key := groupMinSeq + groupID
 	return r.rdb.Set(context.Background(), key, minSeq, 0).Err()
 }
 
 // Store userid and platform class to redis
-func (r *RedisClient) AddTokenFlag(userID string, platformID int, token string, flag int) error {
+func (r *RedisClient) AddTokenFlag(ctx context.Context, userID string, platformID int, token string, flag int) error {
 	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)
-	log2.NewDebug("", "add token key is ", key)
 	return r.rdb.HSet(context.Background(), key, token, flag).Err()
 }
 
-func (r *RedisClient) GetTokenMapByUidPid(userID, platformID string) (map[string]int, error) {
+func (r *RedisClient) GetTokenMapByUidPid(ctx context.Context, userID, platformID string) (map[string]int, error) {
 	key := uidPidToken + userID + ":" + platformID
-	log2.NewDebug("", "get token key is ", key)
 	m, err := r.rdb.HGetAll(context.Background(), key).Result()
 	mm := make(map[string]int)
 	for k, v := range m {
@@ -176,7 +214,7 @@ func (r *RedisClient) GetTokenMapByUidPid(userID, platformID string) (map[string
 	}
 	return mm, err
 }
-func (r *RedisClient) SetTokenMapByUidPid(userID string, platformID int, m map[string]int) error {
+func (r *RedisClient) SetTokenMapByUidPid(ctx context.Context, userID string, platformID int, m map[string]int) error {
 	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)
 	mm := make(map[string]interface{})
 	for k, v := range m {
@@ -185,12 +223,12 @@ func (r *RedisClient) SetTokenMapByUidPid(userID string, platformID int, m map[s
 	return r.rdb.HSet(context.Background(), key, mm).Err()
 }
 
-func (r *RedisClient) DeleteTokenByUidPid(userID string, platformID int, fields []string) error {
+func (r *RedisClient) DeleteTokenByUidPid(ctx context.Context, userID string, platformID int, fields []string) error {
 	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)
 	return r.rdb.HDel(context.Background(), key, fields...).Err()
 }
 
-func (r *RedisClient) GetMessageListBySeq(userID string, seqList []uint32, operationID string) (seqMsg []*pbCommon.MsgData, failedSeqList []uint32, errResult error) {
+func (r *RedisClient) GetMessageListBySeq(ctx context.Context, userID string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, failedSeqList []uint32, errResult error) {
 	for _, v := range seqList {
 		//MESSAGE_CACHE:169.254.225.224_reliability1653387820_0_1
 		key := messageCache + userID + "_" + strconv.Itoa(int(v))
@@ -198,16 +236,13 @@ func (r *RedisClient) GetMessageListBySeq(userID string, seqList []uint32, opera
 		if err != nil {
 			errResult = err
 			failedSeqList = append(failedSeqList, v)
-			log2.Debug(operationID, "redis get message error: ", err.Error(), v)
 		} else {
-			msg := pbCommon.MsgData{}
+			msg := sdkws.MsgData{}
 			err = jsonpb.UnmarshalString(result, &msg)
 			if err != nil {
 				errResult = err
 				failedSeqList = append(failedSeqList, v)
-				log2.NewWarn(operationID, "Unmarshal err ", result, err.Error())
 			} else {
-				log2.NewDebug(operationID, "redis get msg is ", msg.String())
 				seqMsg = append(seqMsg, &msg)
 			}
 
@@ -216,48 +251,40 @@ func (r *RedisClient) GetMessageListBySeq(userID string, seqList []uint32, opera
 	return seqMsg, failedSeqList, errResult
 }
 
-func (r *RedisClient) SetMessageToCache(msgList []*pbChat.MsgDataToMQ, uid string, operationID string) (error, int) {
-	ctx := context.Background()
+func (r *RedisClient) SetMessageToCache(ctx context.Context, userID string, msgList []*pbChat.MsgDataToMQ, uid string) (int, error) {
 	pipe := r.rdb.Pipeline()
 	var failedList []pbChat.MsgDataToMQ
 	for _, msg := range msgList {
 		key := messageCache + uid + "_" + strconv.Itoa(int(msg.MsgData.Seq))
 		s, err := utils.Pb2String(msg.MsgData)
 		if err != nil {
-			log2.NewWarn(operationID, utils.GetSelfFuncName(), "Pb2String failed", msg.MsgData.String(), uid, err.Error())
 			continue
 		}
-		log2.NewDebug(operationID, "convert string is ", s)
 		err = pipe.Set(ctx, key, s, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err()
 		//err = r.rdb.HMSet(context.Background(), "12", map[string]interface{}{"1": 2, "343": false}).Err()
 		if err != nil {
-			log2.NewWarn(operationID, utils.GetSelfFuncName(), "redis failed", "args:", key, *msg, uid, s, err.Error())
 			failedList = append(failedList, *msg)
 		}
 	}
 	if len(failedList) != 0 {
-		return errors.New(fmt.Sprintf("set msg to cache failed, failed lists: %q,%s", failedList, operationID)), len(failedList)
+		return len(failedList), errors.New(fmt.Sprintf("set msg to cache failed, failed lists: %q,%s", failedList))
 	}
 	_, err := pipe.Exec(ctx)
-	return err, 0
+	return 0, err
 }
-func (r *RedisClient) DeleteMessageFromCache(msgList []*pbChat.MsgDataToMQ, uid string, operationID string) error {
-	ctx := context.Background()
+func (r *RedisClient) DeleteMessageFromCache(ctx context.Context, userID string, msgList []*pbChat.MsgDataToMQ) error {
 	for _, msg := range msgList {
-		key := messageCache + uid + "_" + strconv.Itoa(int(msg.MsgData.Seq))
+		key := messageCache + userID + "_" + strconv.Itoa(int(msg.MsgData.Seq))
 		err := r.rdb.Del(ctx, key).Err()
 		if err != nil {
-			log2.NewWarn(operationID, utils.GetSelfFuncName(), "redis failed", "args:", key, uid, err.Error(), msgList)
 		}
 	}
 	return nil
 }
 
-func (r *RedisClient) CleanUpOneUserAllMsgFromRedis(userID string, operationID string) error {
-	ctx := context.Background()
+func (r *RedisClient) CleanUpOneUserAllMsgFromRedis(ctx context.Context, userID string) error {
 	key := messageCache + userID + "_" + "*"
 	vals, err := r.rdb.Keys(ctx, key).Result()
-	log2.Debug(operationID, "vals: ", vals)
 	if err == redis.Nil {
 		return nil
 	}
@@ -270,7 +297,7 @@ func (r *RedisClient) CleanUpOneUserAllMsgFromRedis(userID string, operationID s
 	return nil
 }
 
-func (r *RedisClient) HandleSignalInfo(operationID string, msg *pbCommon.MsgData, pushToUserID string) (isSend bool, err error) {
+func (r *RedisClient) HandleSignalInfo(ctx context.Context, operationID string, msg *sdkws.MsgData, pushToUserID string) (isSend bool, err error) {
 	req := &pbRtc.SignalReq{}
 	if err := proto.Unmarshal(msg.Content, req); err != nil {
 		return false, err
@@ -294,9 +321,7 @@ func (r *RedisClient) HandleSignalInfo(operationID string, msg *pbCommon.MsgData
 		return false, nil
 	}
 	if isInviteSignal {
-		log2.NewDebug(operationID, utils.GetSelfFuncName(), "invite userID list:", inviteeUserIDList)
 		for _, userID := range inviteeUserIDList {
-			log2.NewInfo(operationID, utils.GetSelfFuncName(), "invite userID:", userID)
 			timeout, err := strconv.Atoi(config.Config.Rtc.SignalTimeout)
 			if err != nil {
 				return false, err
@@ -320,7 +345,7 @@ func (r *RedisClient) HandleSignalInfo(operationID string, msg *pbCommon.MsgData
 	return true, nil
 }
 
-func (r *RedisClient) GetSignalInfoFromCacheByClientMsgID(clientMsgID string) (invitationInfo *pbRtc.SignalInviteReq, err error) {
+func (r *RedisClient) GetSignalInfoFromCacheByClientMsgID(ctx context.Context, clientMsgID string) (invitationInfo *pbRtc.SignalInviteReq, err error) {
 	key := signalCache + clientMsgID
 	invitationInfo = &pbRtc.SignalInviteReq{}
 	bytes, err := r.rdb.Get(context.Background(), key).Bytes()
@@ -342,7 +367,7 @@ func (r *RedisClient) GetSignalInfoFromCacheByClientMsgID(clientMsgID string) (i
 	return invitationInfo, err
 }
 
-func (r *RedisClient) GetAvailableSignalInvitationInfo(userID string) (invitationInfo *pbRtc.SignalInviteReq, err error) {
+func (r *RedisClient) GetAvailableSignalInvitationInfo(ctx context.Context, userID string) (invitationInfo *pbRtc.SignalInviteReq, err error) {
 	keyList := signalListCache + userID
 	result := r.rdb.LPop(context.Background(), keyList)
 	if err = result.Err(); err != nil {
@@ -352,76 +377,70 @@ func (r *RedisClient) GetAvailableSignalInvitationInfo(userID string) (invitatio
 	if err != nil {
 		return nil, utils.Wrap(err, "GetAvailableSignalInvitationInfo failed")
 	}
-	log2.NewDebug("", utils.GetSelfFuncName(), result, result.String())
-	invitationInfo, err = r.GetSignalInfoFromCacheByClientMsgID(key)
+	invitationInfo, err = r.GetSignalInfoFromCacheByClientMsgID(ctx, key)
 	if err != nil {
 		return nil, utils.Wrap(err, "GetSignalInfoFromCacheByClientMsgID")
 	}
-	err = r.DelUserSignalList(userID)
+	err = r.DelUserSignalList(ctx, userID)
 	if err != nil {
 		return nil, utils.Wrap(err, "GetSignalInfoFromCacheByClientMsgID")
 	}
 	return invitationInfo, nil
 }
 
-func (r *RedisClient) DelUserSignalList(userID string) error {
+func (r *RedisClient) DelUserSignalList(ctx context.Context, userID string) error {
 	keyList := signalListCache + userID
 	err := r.rdb.Del(context.Background(), keyList).Err()
 	return err
 }
 
-func (r *RedisClient) DelMsgFromCache(uid string, seqList []uint32, operationID string) {
+func (r *RedisClient) DelMsgFromCache(ctx context.Context, uid string, seqList []uint32, operationID string) {
 	for _, seq := range seqList {
 		key := messageCache + uid + "_" + strconv.Itoa(int(seq))
 		result, err := r.rdb.Get(context.Background(), key).Result()
 		if err != nil {
 			if err == redis.Nil {
-				log2.NewDebug(operationID, utils.GetSelfFuncName(), err.Error(), "redis nil")
 			} else {
-				log2.NewError(operationID, utils.GetSelfFuncName(), err.Error(), key)
 			}
 			continue
 		}
-		var msg pbCommon.MsgData
+		var msg sdkws.MsgData
 		if err := utils.String2Pb(result, &msg); err != nil {
-			log2.Error(operationID, utils.GetSelfFuncName(), "String2Pb failed", msg, result, key, err.Error())
 			continue
 		}
 		msg.Status = constant.MsgDeleted
 		s, err := utils.Pb2String(&msg)
 		if err != nil {
-			log2.Error(operationID, utils.GetSelfFuncName(), "Pb2String failed", msg, err.Error())
 			continue
 		}
 		if err := r.rdb.Set(context.Background(), key, s, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err(); err != nil {
-			log2.Error(operationID, utils.GetSelfFuncName(), "Set failed", err.Error())
 		}
 	}
 }
 
-func (r *RedisClient) SetGetuiToken(token string, expireTime int64) error {
+func (r *RedisClient) SetGetuiToken(ctx context.Context, token string, expireTime int64) error {
 	return r.rdb.Set(context.Background(), getuiToken, token, time.Duration(expireTime)*time.Second).Err()
 }
 
-func (r *RedisClient) GetGetuiToken() (string, error) {
+func (r *RedisClient) GetGetuiToken(ctx context.Context) (string, error) {
 	result, err := r.rdb.Get(context.Background(), getuiToken).Result()
 	return result, err
 }
 
-func (r *RedisClient) SetGetuiTaskID(taskID string, expireTime int64) error {
+func (r *RedisClient) SetGetuiTaskID(ctx context.Context, taskID string, expireTime int64) error {
 	return r.rdb.Set(context.Background(), getuiTaskID, taskID, time.Duration(expireTime)*time.Second).Err()
 }
 
-func (r *RedisClient) GetGetuiTaskID() (string, error) {
+func (r *RedisClient) GetGetuiTaskID(ctx context.Context) (string, error) {
 	result, err := r.rdb.Get(context.Background(), getuiTaskID).Result()
 	return result, err
 }
 
-func (r *RedisClient) SetSendMsgStatus(status int32, operationID string) error {
+func (r *RedisClient) SetSendMsgStatus(ctx context.Context, status int32, operationID string) error {
 	return r.rdb.Set(context.Background(), sendMsgFailedFlag+operationID, status, time.Hour*24).Err()
 }
 
-func (r *RedisClient) GetSendMsgStatus(operationID string) (int, error) {
+func (r *RedisClient) GetSendMsgStatus(ctx context.Context, operationID string) (int, error) {
 	result, err := r.rdb.Get(context.Background(), sendMsgFailedFlag+operationID).Result()
 	if err != nil {
 		return 0, err
@@ -430,75 +449,71 @@ func (r *RedisClient) GetSendMsgStatus(operationID string) (int, error) {
 	return status, err
 }
 
-func (r *RedisClient) SetFcmToken(account string, platformID int, fcmToken string, expireTime int64) (err error) {
+func (r *RedisClient) SetFcmToken(ctx context.Context, account string, platformID int, fcmToken string, expireTime int64) (err error) {
 	key := FcmToken + account + ":" + strconv.Itoa(platformID)
 	return r.rdb.Set(context.Background(), key, fcmToken, time.Duration(expireTime)*time.Second).Err()
 }
 
-func (r *RedisClient) GetFcmToken(account string, platformID int) (string, error) {
+func (r *RedisClient) GetFcmToken(ctx context.Context, account string, platformID int) (string, error) {
 	key := FcmToken + account + ":" + strconv.Itoa(platformID)
 	return r.rdb.Get(context.Background(), key).Result()
 }
-func (r *RedisClient) DelFcmToken(account string, platformID int) error {
+func (r *RedisClient) DelFcmToken(ctx context.Context, account string, platformID int) error {
 	key := FcmToken + account + ":" + strconv.Itoa(platformID)
 	return r.rdb.Del(context.Background(), key).Err()
 }
-func (r *RedisClient) IncrUserBadgeUnreadCountSum(uid string) (int, error) {
+func (r *RedisClient) IncrUserBadgeUnreadCountSum(ctx context.Context, uid string) (int, error) {
 	key := userBadgeUnreadCountSum + uid
 	seq, err := r.rdb.Incr(context.Background(), key).Result()
 	return int(seq), err
 }
-func (r *RedisClient) SetUserBadgeUnreadCountSum(uid string, value int) error {
+func (r *RedisClient) SetUserBadgeUnreadCountSum(ctx context.Context, uid string, value int) error {
 	key := userBadgeUnreadCountSum + uid
 	return r.rdb.Set(context.Background(), key, value, 0).Err()
 }
-func (r *RedisClient) GetUserBadgeUnreadCountSum(uid string) (int, error) {
+func (r *RedisClient) GetUserBadgeUnreadCountSum(ctx context.Context, uid string) (int, error) {
 	key := userBadgeUnreadCountSum + uid
 	seq, err := r.rdb.Get(context.Background(), key).Result()
 	return utils.StringToInt(seq), err
 }
-func (r *RedisClient) JudgeMessageReactionEXISTS(clientMsgID string, sessionType int32) (bool, error) {
-	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+func (r *RedisClient) JudgeMessageReactionEXISTS(ctx context.Context, clientMsgID string, sessionType int32) (bool, error) {
+	key := r.getMessageReactionExPrefix(clientMsgID, sessionType)
 	n, err := r.rdb.Exists(context.Background(), key).Result()
-	if n > 0 {
-		return true, err
-	} else {
-		return false, err
-	}
+	return n > 0, err
 }
 
-func (r *RedisClient) GetOneMessageAllReactionList(clientMsgID string, sessionType int32) (map[string]string, error) {
-	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+func (r *RedisClient) GetOneMessageAllReactionList(ctx context.Context, clientMsgID string, sessionType int32) (map[string]string, error) {
+	key := r.getMessageReactionExPrefix(clientMsgID, sessionType)
 	return r.rdb.HGetAll(context.Background(), key).Result()
 
 }
-func (r *RedisClient) DeleteOneMessageKey(clientMsgID string, sessionType int32, subKey string) error {
-	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+func (r *RedisClient) DeleteOneMessageKey(ctx context.Context, clientMsgID string, sessionType int32, subKey string) error {
+	key := r.getMessageReactionExPrefix(clientMsgID, sessionType)
 	return r.rdb.HDel(context.Background(), key, subKey).Err()
 
 }
-func (r *RedisClient) SetMessageReactionExpire(clientMsgID string, sessionType int32, expiration time.Duration) (bool, error) {
-	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+func (r *RedisClient) SetMessageReactionExpire(ctx context.Context, clientMsgID string, sessionType int32, expiration time.Duration) (bool, error) {
+	key := r.getMessageReactionExPrefix(clientMsgID, sessionType)
 	return r.rdb.Expire(context.Background(), key, expiration).Result()
 }
 
-func (r *RedisClient) GetMessageTypeKeyValue(clientMsgID string, sessionType int32, typeKey string) (string, error) {
-	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+func (r *RedisClient) GetMessageTypeKeyValue(ctx context.Context, clientMsgID string, sessionType int32, typeKey string) (string, error) {
+	key := r.getMessageReactionExPrefix(clientMsgID, sessionType)
 	result, err := r.rdb.HGet(context.Background(), key, typeKey).Result()
 	return result, err
 }
 
-func (r *RedisClient) SetMessageTypeKeyValue(clientMsgID string, sessionType int32, typeKey, value string) error {
-	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+func (r *RedisClient) SetMessageTypeKeyValue(ctx context.Context, clientMsgID string, sessionType int32, typeKey, value string) error {
+	key := r.getMessageReactionExPrefix(clientMsgID, sessionType)
 	return r.rdb.HSet(context.Background(), key, typeKey, value).Err()
 
 }
 
-func (r *RedisClient) LockMessageTypeKey(clientMsgID string, TypeKey string) error {
+func (r *RedisClient) LockMessageTypeKey(ctx context.Context, clientMsgID string, TypeKey string) error {
 	key := exTypeKeyLocker + clientMsgID + "_" + TypeKey
 	return r.rdb.SetNX(context.Background(), key, 1, time.Minute).Err()
 }
-func (r *RedisClient) UnLockMessageTypeKey(clientMsgID string, TypeKey string) error {
+func (r *RedisClient) UnLockMessageTypeKey(ctx context.Context, clientMsgID string, TypeKey string) error {
 	key := exTypeKeyLocker + clientMsgID + "_" + TypeKey
 	return r.rdb.Del(context.Background(), key).Err()
 

pkg/common/db/cache/token.go

@@ -5,7 +5,7 @@ import (
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/utils"
 	"context"
-	go_redis "github.com/go-redis/redis/v8"
+	"github.com/go-redis/redis/v8"
 	"github.com/golang-jwt/jwt/v4"
 )
 
@@ -34,7 +34,7 @@ func NewTokenRedis(redisClient *RedisClient, accessSecret string, accessExpire i
 func (t *TokenRedis) GetTokensWithoutError(ctx context.Context, userID, platform string) (map[string]int, error) {
 	key := uidPidToken + userID + ":" + platform
 	m, err := t.RedisClient.GetClient().HGetAll(context.Background(), key).Result()
-	if err != nil && err == go_redis.Nil {
+	if err != nil && err == redis.Nil {
 		return nil, nil
 	}
 	mm := make(map[string]int)

pkg/common/db/controller/extend_msg.go

@@ -0,0 +1,99 @@
+package controller
+
+import (
+	unRelationTb "Open_IM/pkg/common/db/table/unrelation"
+	"Open_IM/pkg/proto/sdkws"
+	"context"
+	"github.com/go-redis/redis/v8"
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+type ExtendMsgInterface interface {
+	CreateExtendMsgSet(ctx context.Context, set *unRelationTb.ExtendMsgSetModel) error
+	GetAllExtendMsgSet(ctx context.Context, ID string, opts *unRelationTb.GetAllExtendMsgSetOpts) (sets []*unRelationTb.ExtendMsgSetModel, err error)
+	GetExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, maxMsgUpdateTime int64) (*unRelationTb.ExtendMsgSetModel, error)
+	InsertExtendMsg(ctx context.Context, sourceID string, sessionType int32, msg *unRelationTb.ExtendMsgModel) error
+	InsertOrUpdateReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*sdkws.KeyValue) error
+	DeleteReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*sdkws.KeyValue) error
+	GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, maxMsgUpdateTime int64) (extendMsg *unRelationTb.ExtendMsgModel, err error)
+}
+
+type ExtendMsgController struct {
+	database ExtendMsgDatabase
+}
+
+func NewExtendMsgController(mgo *mongo.Client, rdb redis.UniversalClient) *ExtendMsgController {
+	return &ExtendMsgController{}
+}
+
+func (e *ExtendMsgController) CreateExtendMsgSet(ctx context.Context, set *unRelationTb.ExtendMsgSetModel) error {
+	return e.database.CreateExtendMsgSet(ctx, set)
+}
+
+func (e *ExtendMsgController) GetAllExtendMsgSet(ctx context.Context, ID string, opts *unRelationTb.GetAllExtendMsgSetOpts) (sets []*unRelationTb.ExtendMsgSetModel, err error) {
+	return e.GetAllExtendMsgSet(ctx, ID, opts)
+}
+
+func (e *ExtendMsgController) GetExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, maxMsgUpdateTime int64) (*unRelationTb.ExtendMsgSetModel, error) {
+	return e.GetExtendMsgSet(ctx, sourceID, sessionType, maxMsgUpdateTime)
+}
+
+func (e *ExtendMsgController) InsertExtendMsg(ctx context.Context, sourceID string, sessionType int32, msg *unRelationTb.ExtendMsgModel) error {
+	return e.InsertExtendMsg(ctx, sourceID, sessionType, msg)
+}
+
+func (e *ExtendMsgController) InsertOrUpdateReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*sdkws.KeyValue) error {
+	return e.InsertOrUpdateReactionExtendMsgSet(ctx, sourceID, sessionType, clientMsgID, msgFirstModifyTime, reactionExtensionList)
+}
+func (e *ExtendMsgController) DeleteReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*sdkws.KeyValue) error {
+	return e.DeleteReactionExtendMsgSet(ctx, sourceID, sessionType, clientMsgID, msgFirstModifyTime, reactionExtensionList)
+}
+
+func (e *ExtendMsgController) GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, maxMsgUpdateTime int64) (extendMsg *unRelationTb.ExtendMsgModel, err error) {
+	return e.GetExtendMsg(ctx, sourceID, sessionType, clientMsgID, maxMsgUpdateTime)
+}
+
+type ExtendMsgDatabaseInterface interface {
+	CreateExtendMsgSet(ctx context.Context, set *unRelationTb.ExtendMsgSetModel) error
+	GetAllExtendMsgSet(ctx context.Context, ID string, opts *unRelationTb.GetAllExtendMsgSetOpts) (sets []*unRelationTb.ExtendMsgSetModel, err error)
+	GetExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, maxMsgUpdateTime int64) (*unRelationTb.ExtendMsgSetModel, error)
+	InsertExtendMsg(ctx context.Context, sourceID string, sessionType int32, msg *unRelationTb.ExtendMsgModel) error
+	InsertOrUpdateReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*sdkws.KeyValue) error
+	DeleteReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*sdkws.KeyValue) error
+	GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, maxMsgUpdateTime int64) (extendMsg *unRelationTb.ExtendMsgModel, err error)
+}
+
+type ExtendMsgDatabase struct {
+	model unRelationTb.ExtendMsgSetModelInterface
+}
+
+func NewExtendMsgDatabase() ExtendMsgDatabaseInterface {
+	return &ExtendMsgDatabase{}
+}
+
+func (e *ExtendMsgDatabase) CreateExtendMsgSet(ctx context.Context, set *unRelationTb.ExtendMsgSetModel) error {
+	return e.model.CreateExtendMsgSet(ctx, set)
+}
+
+func (e *ExtendMsgDatabase) GetAllExtendMsgSet(ctx context.Context, sourceID string, opts *unRelationTb.GetAllExtendMsgSetOpts) (sets []*unRelationTb.ExtendMsgSetModel, err error) {
+	return e.model.GetAllExtendMsgSet(ctx, sourceID, opts)
+}
+
+func (e *ExtendMsgDatabase) GetExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, maxMsgUpdateTime int64) (*unRelationTb.ExtendMsgSetModel, error) {
+	return e.model.GetExtendMsgSet(ctx, sourceID, sessionType, maxMsgUpdateTime)
+}
+
+func (e *ExtendMsgDatabase) InsertExtendMsg(ctx context.Context, sourceID string, sessionType int32, msg *unRelationTb.ExtendMsgModel) error {
+	return e.model.InsertExtendMsg(ctx, sourceID, sessionType, msg)
+}
+
+func (e *ExtendMsgDatabase) InsertOrUpdateReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*sdkws.KeyValue) error {
+	return e.InsertOrUpdateReactionExtendMsgSet(ctx, sourceID, sessionType, clientMsgID, msgFirstModifyTime, reactionExtensionList)
+}
+func (e *ExtendMsgDatabase) DeleteReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*sdkws.KeyValue) error {
+	return e.DeleteReactionExtendMsgSet(ctx, sourceID, sessionType, clientMsgID, msgFirstModifyTime, reactionExtensionList)
+}
+
+func (e *ExtendMsgDatabase) GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, maxMsgUpdateTime int64) (extendMsg *unRelationTb.ExtendMsgModel, err error) {
+	return e.GetExtendMsg(ctx, sourceID, sessionType, clientMsgID, maxMsgUpdateTime)
+}

pkg/common/db/controller/group.go

@@ -5,7 +5,7 @@ import (
 	"Open_IM/pkg/common/db/cache"
 	"Open_IM/pkg/common/db/relation"
 	relationTb "Open_IM/pkg/common/db/table/relation"
-	unrelationTb "Open_IM/pkg/common/db/table/unrelation"
+	unRelationTb "Open_IM/pkg/common/db/table/unrelation"
 	"Open_IM/pkg/common/db/unrelation"
 	"Open_IM/pkg/utils"
 	"context"
@@ -47,8 +47,8 @@ type GroupInterface interface {
 	TakeGroupRequest(ctx context.Context, groupID string, userID string) (*relationTb.GroupRequestModel, error)
 	PageGroupRequestUser(ctx context.Context, userID string, pageNumber, showNumber int32) (uint32, []*relationTb.GroupRequestModel, error)
 	// SuperGroup
-	FindSuperGroup(ctx context.Context, groupIDs []string) ([]*unrelationTb.SuperGroupModel, error)
-	FindJoinSuperGroup(ctx context.Context, userID string) (superGroup *unrelationTb.UserToSuperGroupModel, err error)
+	FindSuperGroup(ctx context.Context, groupIDs []string) ([]*unRelationTb.SuperGroupModel, error)
+	FindJoinSuperGroup(ctx context.Context, userID string) (superGroup *unRelationTb.UserToSuperGroupModel, err error)
 	CreateSuperGroup(ctx context.Context, groupID string, initMemberIDList []string) error
 	DeleteSuperGroup(ctx context.Context, groupID string) error
 	DeleteSuperGroupMember(ctx context.Context, groupID string, userIDs []string) error
@@ -153,11 +153,11 @@ func (g *GroupController) PageGroupRequestUser(ctx context.Context, userID strin
 	return g.database.PageGroupRequestUser(ctx, userID, pageNumber, showNumber)
 }
 
-func (g *GroupController) FindSuperGroup(ctx context.Context, groupIDs []string) ([]*unrelationTb.SuperGroupModel, error) {
+func (g *GroupController) FindSuperGroup(ctx context.Context, groupIDs []string) ([]*unRelationTb.SuperGroupModel, error) {
 	return g.database.FindSuperGroup(ctx, groupIDs)
 }
 
-func (g *GroupController) FindJoinSuperGroup(ctx context.Context, userID string) (*unrelationTb.UserToSuperGroupModel, error) {
+func (g *GroupController) FindJoinSuperGroup(ctx context.Context, userID string) (*unRelationTb.UserToSuperGroupModel, error) {
 	return g.database.FindJoinSuperGroup(ctx, userID)
 }
 
@@ -203,8 +203,8 @@ type GroupDataBaseInterface interface {
 	TakeGroupRequest(ctx context.Context, groupID string, userID string) (*relationTb.GroupRequestModel, error)
 	PageGroupRequestUser(ctx context.Context, userID string, pageNumber, showNumber int32) (uint32, []*relationTb.GroupRequestModel, error)
 	// SuperGroup
-	FindSuperGroup(ctx context.Context, groupIDs []string) ([]*unrelationTb.SuperGroupModel, error)
-	FindJoinSuperGroup(ctx context.Context, userID string) (*unrelationTb.UserToSuperGroupModel, error)
+	FindSuperGroup(ctx context.Context, groupIDs []string) ([]*unRelationTb.SuperGroupModel, error)
+	FindJoinSuperGroup(ctx context.Context, userID string) (*unRelationTb.UserToSuperGroupModel, error)
 	CreateSuperGroup(ctx context.Context, groupID string, initMemberIDList []string) error
 	DeleteSuperGroup(ctx context.Context, groupID string) error
 	DeleteSuperGroupMember(ctx context.Context, groupID string, userIDs []string) error
@@ -467,11 +467,11 @@ func (g *GroupDataBase) PageGroupRequestUser(ctx context.Context, userID string,
 	return g.groupRequestDB.Page(ctx, userID, pageNumber, showNumber)
 }
 
-func (g *GroupDataBase) FindSuperGroup(ctx context.Context, groupIDs []string) ([]*unrelationTb.SuperGroupModel, error) {
+func (g *GroupDataBase) FindSuperGroup(ctx context.Context, groupIDs []string) ([]*table.SuperGroupModel, error) {
 	return g.mongoDB.FindSuperGroup(ctx, groupIDs)
 }
 
-func (g *GroupDataBase) FindJoinSuperGroup(ctx context.Context, userID string) (*unrelationTb.UserToSuperGroupModel, error) {
+func (g *GroupDataBase) FindJoinSuperGroup(ctx context.Context, userID string) (*table.UserToSuperGroupModel, error) {
 	return g.mongoDB.GetSuperGroupByUserID(ctx, userID)
 }
 

pkg/common/db/controller/msg.go

@@ -1,76 +1,554 @@
 package controller
 
 import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db/cache"
+	unRelationTb "Open_IM/pkg/common/db/table/unrelation"
+	"Open_IM/pkg/common/db/unrelation"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/prome"
+	"Open_IM/pkg/common/tracelog"
+	"github.com/gogo/protobuf/sortkeys"
+	"sync"
+
+	//"Open_IM/pkg/common/log"
 	pbMsg "Open_IM/pkg/proto/msg"
 	"Open_IM/pkg/proto/sdkws"
+	"Open_IM/pkg/utils"
 	"context"
-	"encoding/json"
+	"errors"
+	"github.com/go-redis/redis/v8"
+	"go.mongodb.org/mongo-driver/mongo"
+
+	"github.com/golang/protobuf/proto"
 )
 
 type MsgInterface interface {
-	BatchInsertChat2DB(ctx context.Context, userID string, msgList []*pbMsg.MsgDataToMQ, currentMaxSeq uint64) error
-	BatchInsertChat2Cache(ctx context.Context, insertID string, msgList []*pbMsg.MsgDataToMQ) (error, uint64)
-
-	DelMsgBySeqList(ctx context.Context, userID string, seqList []uint32) (totalUnExistSeqList []uint32, err error)
-	// logic delete
-	DelMsgLogic(ctx context.Context, userID string, seqList []uint32) error
-	DelMsgBySeqListInOneDoc(ctx context.Context, docID string, seqList []uint32) (unExistSeqList []uint32, err error)
-	ReplaceMsgToBlankByIndex(docID string, index int) (replaceMaxSeq uint32, err error)
-	ReplaceMsgByIndex(ctx context.Context, suffixUserID string, msg *sdkws.MsgData, seqIndex int) error
-	// 获取群ID或者UserID最新一条在mongo里面的消息
-	GetNewestMsg(ID string) (msg *sdkws.MsgData, err error)
-	// 获取群ID或者UserID最老一条在mongo里面的消息
-	GetOldestMsg(ID string) (msg *sdkws.MsgData, err error)
-
-	GetMsgBySeqListMongo2(uid string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, err error)
-	GetSuperGroupMsgBySeqListMongo(groupID string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, err error)
-	GetMsgAndIndexBySeqListInOneMongo2(suffixUserID string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, indexList []int, unExistSeqList []uint32, err error)
-	SaveUserChatMongo2(uid string, sendTime int64, m *pbMsg.MsgDataToDB) error
-
-	CleanUpUserMsgFromMongo(userID string, operationID string) error
+	// 批量插入消息到db
+	BatchInsertChat2DB(ctx context.Context, ID string, msgList []*pbMsg.MsgDataToMQ, currentMaxSeq uint64) error
+	// 刪除redis中消息缓存
+	DeleteMessageFromCache(ctx context.Context, userID string, msgList []*pbMsg.MsgDataToMQ) error
+	// incrSeq然后批量插入缓存
+	BatchInsertChat2Cache(ctx context.Context, sourceID string, msgList []*pbMsg.MsgDataToMQ) (uint64, error)
+	// 删除消息 返回不存在的seqList
+	DelMsgBySeqs(ctx context.Context, userID string, seqs []uint32) (totalUnExistSeqs []uint32, err error)
+	// 获取群ID或者UserID最新一条在db里面的消息
+	GetNewestMsg(ctx context.Context, sourceID string) (msg *sdkws.MsgData, err error)
+	// 获取群ID或者UserID最老一条在db里面的消息
+	GetOldestMsg(ctx context.Context, sourceID string) (msg *sdkws.MsgData, err error)
+	//  通过seqList获取db中写扩散消息
+	GetMsgBySeqs(ctx context.Context, userID string, seqs []uint32) (seqMsg []*sdkws.MsgData, err error)
+	// 通过seqList获取大群在db里面的消息
+	GetSuperGroupMsgBySeqs(ctx context.Context, groupID string, seqs []uint32) (seqMsg []*sdkws.MsgData, err error)
+	// 删除用户所有消息/cache/db然后重置seq
+	CleanUpUserMsgFromMongo(ctx context.Context, userID string) error
+	// 删除大群消息重置群成员最小群seq, remainTime为消息保留的时间单位秒,超时消息删除， 传0删除所有消息(此方法不删除 redis cache)
+	DeleteUserSuperGroupMsgsAndSetMinSeq(ctx context.Context, groupID string, userID string, remainTime int64) error
+	// 删除用户消息重置最小seq， remainTime为消息保留的时间单位秒,超时消息删除， 传0删除所有消息(此方法不删除redis cache)
+	DeleteUserMsgsAndSetMinSeq(ctx context.Context, userID string, remainTime int64) error
 }
 
-func NewMsgController() MsgDatabaseInterface {
-	return MsgController
+func NewMsgController(mgo *mongo.Client, rdb redis.UniversalClient) MsgInterface {
+	return &MsgController{}
 }
 
 type MsgController struct {
+	database MsgDatabase
+}
+
+func (m *MsgController) BatchInsertChat2DB(ctx context.Context, ID string, msgList []*pbMsg.MsgDataToMQ, currentMaxSeq uint64) error {
+	return m.database.BatchInsertChat2DB(ctx, ID, msgList, currentMaxSeq)
+}
+
+func (m *MsgController) DeleteMessageFromCache(ctx context.Context, userID string, msgList []*pbMsg.MsgDataToMQ) error {
+	return m.database.DeleteMessageFromCache(ctx, userID, msgList)
+}
+
+func (m *MsgController) BatchInsertChat2Cache(ctx context.Context, sourceID string, msgList []*pbMsg.MsgDataToMQ) (uint64, error) {
+	return m.database.BatchInsertChat2Cache(ctx, sourceID, msgList)
+}
+
+func (m *MsgController) DelMsgBySeqs(ctx context.Context, userID string, seqs []uint32) (totalUnExistSeqs []uint32, err error) {
+	return m.database.DelMsgBySeqs(ctx, userID, seqs)
+}
+
+func (m *MsgController) GetNewestMsg(ctx context.Context, ID string) (msg *sdkws.MsgData, err error) {
+	return m.database.GetNewestMsg(ctx, ID)
+}
+
+func (m *MsgController) GetOldestMsg(ctx context.Context, ID string) (msg *sdkws.MsgData, err error) {
+	return m.database.GetOldestMsg(ctx, ID)
+}
+
+func (m *MsgController) GetMsgBySeqs(ctx context.Context, userID string, seqs []uint32) (seqMsg []*sdkws.MsgData, err error) {
+	return m.database.GetMsgBySeqs(ctx, userID, seqs)
+}
+
+func (m *MsgController) GetSuperGroupMsgBySeqs(ctx context.Context, groupID string, seqs []uint32) (seqMsg []*sdkws.MsgData, err error) {
+	return m.database.GetSuperGroupMsgBySeqs(ctx, groupID, seqs)
+}
+
+func (m *MsgController) CleanUpUserMsgFromMongo(ctx context.Context, userID string) error {
+	return m.database.CleanUpUserMsgFromMongo(ctx, userID)
+}
+
+func (m *MsgController) DeleteUserSuperGroupMsgsAndSetMinSeq(ctx context.Context, groupID string, userID string, remainTime int64) error {
+	return m.database.DeleteUserMsgsAndSetMinSeq(ctx, userID, remainTime)
+}
+
+func (m *MsgController) DeleteUserMsgsAndSetMinSeq(ctx context.Context, userID string, remainTime int64) error {
+	return m.database.DeleteUserMsgsAndSetMinSeq(ctx, userID, remainTime)
 }
 
 type MsgDatabaseInterface interface {
-	BatchInsertChat2DB(ctx context.Context, userID string, msgList []*pbMsg.MsgDataToMQ, currentMaxSeq uint64) error
-	BatchInsertChat2Cache(ctx context.Context, insertID string, msgList []*pbMsg.MsgDataToMQ) (error, uint64)
-
-	DelMsgBySeqList(ctx context.Context, userID string, seqList []uint32) (totalUnExistSeqList []uint32, err error)
-	// logic delete
-	DelMsgLogic(ctx context.Context, userID string, seqList []uint32) error
-	DelMsgBySeqListInOneDoc(ctx context.Context, docID string, seqList []uint32) (unExistSeqList []uint32, err error)
-	ReplaceMsgToBlankByIndex(docID string, index int) (replaceMaxSeq uint32, err error)
-	ReplaceMsgByIndex(ctx context.Context, suffixUserID string, msg *sdkws.MsgData, seqIndex int) error
+	// 批量插入消息
+	BatchInsertChat2DB(ctx context.Context, ID string, msgList []*pbMsg.MsgDataToMQ, currentMaxSeq uint64) error
+	// 刪除redis中消息缓存
+	DeleteMessageFromCache(ctx context.Context, userID string, msgList []*pbMsg.MsgDataToMQ) error
+	// incrSeq然后批量插入缓存
+	BatchInsertChat2Cache(ctx context.Context, sourceID string, msgList []*pbMsg.MsgDataToMQ) (uint64, error)
+	// 删除消息 返回不存在的seqList
+	DelMsgBySeqs(ctx context.Context, userID string, seqs []uint32) (totalUnExistSeqs []uint32, err error)
 	// 获取群ID或者UserID最新一条在mongo里面的消息
-	GetNewestMsg(ID string) (msg *sdkws.MsgData, err error)
+	GetNewestMsg(ctx context.Context, sourceID string) (msg *sdkws.MsgData, err error)
 	// 获取群ID或者UserID最老一条在mongo里面的消息
-	GetOldestMsg(ID string) (msg *sdkws.MsgData, err error)
-
-	GetMsgBySeqListMongo2(uid string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, err error)
-	GetSuperGroupMsgBySeqListMongo(groupID string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, err error)
-	GetMsgAndIndexBySeqListInOneMongo2(suffixUserID string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, indexList []int, unExistSeqList []uint32, err error)
-	SaveUserChatMongo2(uid string, sendTime int64, m *pbMsg.MsgDataToDB) error
+	GetOldestMsg(ctx context.Context, sourceID string) (msg *sdkws.MsgData, err error)
+	//  通过seqList获取mongo中写扩散消息
+	GetMsgBySeqs(ctx context.Context, userID string, seqs []uint32) (seqMsg []*sdkws.MsgData, err error)
+	// 通过seqList获取大群在 mongo里面的消息
+	GetSuperGroupMsgBySeqs(ctx context.Context, groupID string, seqs []uint32) (seqMsg []*sdkws.MsgData, err error)
 	// 删除用户所有消息/redis/mongo然后重置seq
-	CleanUpUserMsgFromMongo(userID string, operationID string) error
-}
-
-func NewMsgDatabase() MsgDatabaseInterface {
-	return MsgDatabase
+	CleanUpUserMsgFromMongo(ctx context.Context, userID string) error
+	// 删除大群消息重置群成员最小群seq, remainTime为消息保留的时间单位秒,超时消息删除， 传0删除所有消息(此方法不删除 redis cache)
+	DeleteUserSuperGroupMsgsAndSetMinSeq(ctx context.Context, groupID string, userID string, remainTime int64) error
+	// 删除用户消息重置最小seq， remainTime为消息保留的时间单位秒,超时消息删除， 传0删除所有消息(此方法不删除redis cache)
+	DeleteUserMsgsAndSetMinSeq(ctx context.Context, userID string, remainTime int64) error
 }
 
 type MsgDatabase struct {
+	msgModel unRelationTb.MsgDocModelInterface
+	msgCache cache.Cache
+	msg      unRelationTb.MsgDocModel
 }
 
-func (m *MsgDatabase) BatchInsertChat2DB(ctx context.Context, userID string, msgList []*pbMsg.MsgDataToMQ, currentMaxSeq uint64) error {
-
+func NewMsgDatabase(mgo *mongo.Client, rdb redis.UniversalClient) MsgDatabaseInterface {
+	return &MsgDatabase{}
 }
 
-func (m *MsgDatabase) CleanUpUserMsgFromMongo(userID string, operationID string) error {
+func (db *MsgDatabase) BatchInsertChat2DB(ctx context.Context, sourceID string, msgList []*pbMsg.MsgDataToMQ, currentMaxSeq uint64) error {
+	//newTime := utils.GetCurrentTimestampByMill()
+	if len(msgList) > db.msg.GetSingleGocMsgNum() {
+		return errors.New("too large")
+	}
+	var remain uint64
+	blk0 := uint64(db.msg.GetSingleGocMsgNum() - 1)
+	//currentMaxSeq 4998
+	if currentMaxSeq < uint64(db.msg.GetSingleGocMsgNum()) {
+		remain = blk0 - currentMaxSeq //1
+	} else {
+		excludeBlk0 := currentMaxSeq - blk0 //=1
+		//(5000-1)%5000 == 4999
+		remain = (uint64(db.msg.GetSingleGocMsgNum()) - (excludeBlk0 % uint64(db.msg.GetSingleGocMsgNum()))) % uint64(db.msg.GetSingleGocMsgNum())
+	}
+	//remain=1
+	insertCounter := uint64(0)
+	msgsToMongo := make([]unRelationTb.MsgInfoModel, 0)
+	msgsToMongoNext := make([]unRelationTb.MsgInfoModel, 0)
+	docID := ""
+	docIDNext := ""
+	var err error
+	for _, m := range msgList {
+		//log.Debug(operationID, "msg node ", m.String(), m.MsgData.ClientMsgID)
+		currentMaxSeq++
+		sMsg := unRelationTb.MsgInfoModel{}
+		sMsg.SendTime = m.MsgData.SendTime
+		m.MsgData.Seq = uint32(currentMaxSeq)
+		if sMsg.Msg, err = proto.Marshal(m.MsgData); err != nil {
+			return utils.Wrap(err, "")
+		}
+		if insertCounter < remain {
+			msgsToMongo = append(msgsToMongo, sMsg)
+			insertCounter++
+			docID = db.msg.GetDocID(sourceID, uint32(currentMaxSeq))
+			//log.Debug(operationID, "msgListToMongo ", seqUid, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain, "userID: ", userID)
+		} else {
+			msgsToMongoNext = append(msgsToMongoNext, sMsg)
+			docIDNext = db.msg.GetDocID(sourceID, uint32(currentMaxSeq))
+			//log.Debug(operationID, "msgListToMongoNext ", seqUidNext, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain, "userID: ", userID)
+		}
+	}
 
+	if docID != "" {
+		//filter := bson.M{"uid": seqUid}
+		//log.NewDebug(operationID, "filter ", seqUid, "list ", msgListToMongo, "userID: ", userID)
+		//err := c.FindOneAndUpdate(ctx, filter, bson.M{"$push": bson.M{"msg": bson.M{"$each": msgsToMongo}}}).Err()
+		err = db.msgModel.PushMsgsToDoc(ctx, docID, msgsToMongo)
+		if err != nil {
+			if err == mongo.ErrNoDocuments {
+				doc := &unRelationTb.MsgDocModel{}
+				doc.DocID = docID
+				doc.Msg = msgsToMongo
+				if err = db.msgModel.Create(ctx, doc); err != nil {
+					prome.PromeInc(prome.MsgInsertMongoFailedCounter)
+					//log.NewError(operationID, "InsertOne failed", filter, err.Error(), sChat)
+					return utils.Wrap(err, "")
+				}
+				prome.PromeInc(prome.MsgInsertMongoSuccessCounter)
+			} else {
+				prome.PromeInc(prome.MsgInsertMongoFailedCounter)
+				//log.Error(operationID, "FindOneAndUpdate failed ", err.Error(), filter)
+				return utils.Wrap(err, "")
+			}
+		} else {
+			prome.PromeInc(prome.MsgInsertMongoSuccessCounter)
+		}
+	}
+	if docIDNext != "" {
+		nextDoc := &unRelationTb.MsgDocModel{}
+		nextDoc.DocID = docIDNext
+		nextDoc.Msg = msgsToMongoNext
+		//log.NewDebug(operationID, "filter ", seqUidNext, "list ", msgListToMongoNext, "userID: ", userID)
+		if err = db.msgModel.Create(ctx, nextDoc); err != nil {
+			prome.PromeInc(prome.MsgInsertMongoFailedCounter)
+			//log.NewError(operationID, "InsertOne failed", filter, err.Error(), sChat)
+			return utils.Wrap(err, "")
+		}
+		prome.PromeInc(prome.MsgInsertMongoSuccessCounter)
+	}
+	//log.Debug(operationID, "batch mgo  cost time ", mongo2.getCurrentTimestampByMill()-newTime, userID, len(msgList))
+	return nil
+}
+
+func (db *MsgDatabase) DeleteMessageFromCache(ctx context.Context, userID string, msgs []*pbMsg.MsgDataToMQ) error {
+	return db.msgCache.DeleteMessageFromCache(ctx, userID, msgs)
+}
+
+func (db *MsgDatabase) BatchInsertChat2Cache(ctx context.Context, sourceID string, msgList []*pbMsg.MsgDataToMQ) (uint64, error) {
+	//newTime := utils.GetCurrentTimestampByMill()
+	lenList := len(msgList)
+	if lenList > db.msg.GetSingleGocMsgNum() {
+		return 0, errors.New("too large")
+	}
+	if lenList < 1 {
+		return 0, errors.New("too short as 0")
+	}
+	// judge sessionType to get seq
+	var currentMaxSeq uint64
+	var err error
+	if msgList[0].MsgData.SessionType == constant.SuperGroupChatType {
+		currentMaxSeq, err = db.msgCache.GetGroupMaxSeq(ctx, sourceID)
+		//log.Debug(operationID, "constant.SuperGroupChatType  lastMaxSeq before add ", currentMaxSeq, "userID ", sourceID, err)
+	} else {
+		currentMaxSeq, err = db.msgCache.GetUserMaxSeq(ctx, sourceID)
+		//log.Debug(operationID, "constant.SingleChatType  lastMaxSeq before add ", currentMaxSeq, "userID ", sourceID, err)
+	}
+	if err != nil && err != redis.Nil {
+		prome.PromeInc(prome.SeqGetFailedCounter)
+		return 0, utils.Wrap(err, "")
+	}
+	prome.PromeInc(prome.SeqGetSuccessCounter)
+	lastMaxSeq := currentMaxSeq
+	for _, m := range msgList {
+		currentMaxSeq++
+		m.MsgData.Seq = uint32(currentMaxSeq)
+		//log.Debug(operationID, "cache msg node ", m.String(), m.MsgData.ClientMsgID, "userID: ", sourceID, "seq: ", currentMaxSeq)
+	}
+	//log.Debug(operationID, "SetMessageToCache ", sourceID, len(msgList))
+	failedNum, err := db.msgCache.SetMessageToCache(ctx, sourceID, msgList)
+	if err != nil {
+		prome.PromeAdd(prome.MsgInsertRedisFailedCounter, failedNum)
+		//log.Error(operationID, "setMessageToCache failed, continue ", err.Error(), len(msgList), sourceID)
+	} else {
+		prome.PromeInc(prome.MsgInsertRedisSuccessCounter)
+	}
+	//log.Debug(operationID, "batch to redis  cost time ", mongo2.getCurrentTimestampByMill()-newTime, sourceID, len(msgList))
+	if msgList[0].MsgData.SessionType == constant.SuperGroupChatType {
+		err = db.msgCache.SetGroupMaxSeq(ctx, sourceID, currentMaxSeq)
+	} else {
+		err = db.msgCache.SetUserMaxSeq(ctx, sourceID, currentMaxSeq)
+	}
+	if err != nil {
+		prome.PromeInc(prome.SeqSetFailedCounter)
+	} else {
+		prome.PromeInc(prome.SeqSetSuccessCounter)
+	}
+	return lastMaxSeq, utils.Wrap(err, "")
+}
+
+func (db *MsgDatabase) DelMsgBySeqs(ctx context.Context, userID string, seqs []uint32) (totalUnExistSeqs []uint32, err error) {
+	sortkeys.Uint32s(seqs)
+	docIDSeqsMap := db.msg.GetDocIDSeqsMap(userID, seqs)
+	lock := sync.Mutex{}
+	var wg sync.WaitGroup
+	wg.Add(len(docIDSeqsMap))
+	for k, v := range docIDSeqsMap {
+		go func(docID string, seqs []uint32) {
+			defer wg.Done()
+			unExistSeqList, err := db.DelMsgBySeqsInOneDoc(ctx, docID, seqs)
+			if err != nil {
+				return
+			}
+			lock.Lock()
+			totalUnExistSeqs = append(totalUnExistSeqs, unExistSeqList...)
+			lock.Unlock()
+		}(k, v)
+	}
+	return totalUnExistSeqs, nil
+}
+
+func (db *MsgDatabase) DelMsgBySeqsInOneDoc(ctx context.Context, docID string, seqs []uint32) (unExistSeqs []uint32, err error) {
+	seqMsgs, indexes, unExistSeqs, err := db.GetMsgAndIndexBySeqsInOneDoc(ctx, docID, seqs)
+	if err != nil {
+		return nil, err
+	}
+	for i, v := range seqMsgs {
+		if err = db.msgModel.UpdateMsgStatusByIndexInOneDoc(ctx, docID, v, indexes[i], constant.MsgDeleted); err != nil {
+			return nil, err
+		}
+	}
+	return unExistSeqs, nil
+}
+
+func (db *MsgDatabase) GetMsgAndIndexBySeqsInOneDoc(ctx context.Context, docID string, seqs []uint32) (seqMsgs []*sdkws.MsgData, indexes []int, unExistSeqs []uint32, err error) {
+	doc, err := db.msgModel.FindOneByDocID(ctx, docID)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	singleCount := 0
+	var hasSeqList []uint32
+	for i := 0; i < len(doc.Msg); i++ {
+		msgPb, err := db.unmarshalMsg(&doc.Msg[i])
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		if utils.Contain(msgPb.Seq, seqs) {
+			indexes = append(indexes, i)
+			seqMsgs = append(seqMsgs, msgPb)
+			hasSeqList = append(hasSeqList, msgPb.Seq)
+			singleCount++
+			if singleCount == len(seqs) {
+				break
+			}
+		}
+	}
+	for _, i := range seqs {
+		if utils.Contain(i, hasSeqList) {
+			continue
+		}
+		unExistSeqs = append(unExistSeqs, i)
+	}
+	return seqMsgs, indexes, unExistSeqs, nil
+}
+
+func (db *MsgDatabase) GetNewestMsg(ctx context.Context, sourceID string) (msgPb *sdkws.MsgData, err error) {
+	msgInfo, err := db.msgModel.GetNewestMsg(ctx, sourceID)
+	if err != nil {
+		return nil, err
+	}
+	return db.unmarshalMsg(msgInfo)
+}
+
+func (db *MsgDatabase) GetOldestMsg(ctx context.Context, sourceID string) (msgPb *sdkws.MsgData, err error) {
+	msgInfo, err := db.msgModel.GetOldestMsg(ctx, sourceID)
+	if err != nil {
+		return nil, err
+	}
+	return db.unmarshalMsg(msgInfo)
+}
+
+func (db *MsgDatabase) unmarshalMsg(msgInfo *unRelationTb.MsgInfoModel) (msgPb *sdkws.MsgData, err error) {
+	msgPb = &sdkws.MsgData{}
+	err = proto.Unmarshal(msgInfo.Msg, msgPb)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	return msgPb, nil
+}
+
+func (db *MsgDatabase) getMsgBySeqs(ctx context.Context, sourceID string, seqs []uint32, diffusionType int) (seqMsg []*sdkws.MsgData, err error) {
+	var hasSeqs []uint32
+	singleCount := 0
+	m := db.msg.GetDocIDSeqsMap(sourceID, seqs)
+	for docID, value := range m {
+		doc, err := db.msgModel.FindOneByDocID(ctx, docID)
+		if err != nil {
+			//log.NewError(operationID, "not find seqUid", seqUid, value, uid, seqList, err.Error())
+			continue
+		}
+		singleCount = 0
+		for i := 0; i < len(doc.Msg); i++ {
+			msgPb, err := db.unmarshalMsg(&doc.Msg[i])
+			if err != nil {
+				//log.NewError(operationID, "Unmarshal err", seqUid, value, uid, seqList, err.Error())
+				return nil, err
+			}
+			if utils.Contain(msgPb.Seq, value) {
+				seqMsg = append(seqMsg, msgPb)
+				hasSeqs = append(hasSeqs, msgPb.Seq)
+				singleCount++
+				if singleCount == len(value) {
+					break
+				}
+			}
+		}
+	}
+	if len(hasSeqs) != len(seqs) {
+		var diff []uint32
+		var exceptionMsg []*sdkws.MsgData
+		diff = utils.Difference(hasSeqs, seqs)
+		if diffusionType == constant.WriteDiffusion {
+			exceptionMsg = db.msg.GenExceptionMessageBySeqs(diff)
+		} else if diffusionType == constant.ReadDiffusion {
+			exceptionMsg = db.msg.GenExceptionSuperGroupMessageBySeqs(diff, sourceID)
+		}
+		seqMsg = append(seqMsg, exceptionMsg...)
+	}
+	return seqMsg, nil
+}
+
+func (db *MsgDatabase) GetMsgBySeqs(ctx context.Context, userID string, seqs []uint32) (seqMsg []*sdkws.MsgData, err error) {
+	return db.getMsgBySeqs(ctx, userID, seqs, constant.WriteDiffusion)
+}
+
+func (db *MsgDatabase) GetSuperGroupMsgBySeqs(ctx context.Context, groupID string, seqs []uint32) (seqMsg []*sdkws.MsgData, err error) {
+	return db.getMsgBySeqs(ctx, groupID, seqs, constant.ReadDiffusion)
+}
+
+func (db *MsgDatabase) CleanUpUserMsgFromMongo(ctx context.Context, userID string) error {
+	maxSeq, err := db.msgCache.GetUserMaxSeq(ctx, userID)
+	if err == redis.Nil {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	docIDs := db.msg.GetSeqDocIDList(userID, uint32(maxSeq))
+	err = db.msgModel.Delete(ctx, docIDs)
+	if err == mongo.ErrNoDocuments {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	err = db.msgCache.SetUserMinSeq(ctx, userID, maxSeq)
+	return utils.Wrap(err, "")
+}
+
+func (db *MsgDatabase) DeleteUserSuperGroupMsgsAndSetMinSeq(ctx context.Context, groupID string, userIDs []string, remainTime int64) error {
+	var delStruct delMsgRecursionStruct
+	minSeq, err := db.deleteMsgRecursion(ctx, groupID, unRelationTb.OldestList, &delStruct, remainTime)
+	if err != nil {
+		//log.NewError(operationID, utils.GetSelfFuncName(), groupID, "deleteMsg failed")
+	}
+	if minSeq == 0 {
+		return nil
+	}
+	//log.NewDebug(operationID, utils.GetSelfFuncName(), "delMsgIDList:", delStruct, "minSeq", minSeq)
+	for _, userID := range userIDs {
+		userMinSeq, err := db.msgCache.GetGroupUserMinSeq(ctx, groupID, userID)
+		if err != nil && err != redis.Nil {
+			//log.NewError(operationID, utils.GetSelfFuncName(), "GetGroupUserMinSeq failed", groupID, userID, err.Error())
+			continue
+		}
+		if userMinSeq > uint64(minSeq) {
+			err = db.msgCache.SetGroupUserMinSeq(ctx, groupID, userID, userMinSeq)
+		} else {
+			err = db.msgCache.SetGroupUserMinSeq(ctx, groupID, userID, uint64(minSeq))
+		}
+		if err != nil {
+			//log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), groupID, userID, userMinSeq, minSeq)
+		}
+	}
+	return nil
+}
+
+func (db *MsgDatabase) DeleteUserMsgsAndSetMinSeq(ctx context.Context, userID string, remainTime int64) error {
+	var delStruct delMsgRecursionStruct
+	minSeq, err := db.deleteMsgRecursion(ctx, userID, unRelationTb.OldestList, &delStruct, remainTime)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	if minSeq == 0 {
+		return nil
+	}
+	return db.msgCache.SetUserMinSeq(ctx, userID, uint64(minSeq))
+}
+
+// this is struct for recursion
+type delMsgRecursionStruct struct {
+	minSeq       uint32
+	delDocIDList []string
+}
+
+func (d *delMsgRecursionStruct) getSetMinSeq() uint32 {
+	return d.minSeq
+}
+
+// index 0....19(del) 20...69
+// seq 70
+// set minSeq 21
+// recursion 删除list并且返回设置的最小seq
+func (db *MsgDatabase) deleteMsgRecursion(ctx context.Context, sourceID string, index int64, delStruct *delMsgRecursionStruct, remainTime int64) (uint32, error) {
+	// find from oldest list
+	msgs, err := db.msgModel.GetMsgsByIndex(ctx, sourceID, index)
+	if err != nil || msgs.DocID == "" {
+		if err != nil {
+			if err == unrelation.ErrMsgListNotExist {
+				//log.NewInfo(operationID, utils.GetSelfFuncName(), "ID:", sourceID, "index:", index, err.Error())
+			} else {
+				//log.NewError(operationID, utils.GetSelfFuncName(), "GetUserMsgListByIndex failed", err.Error(), index, ID)
+			}
+		}
+		// 获取报错，或者获取不到了，物理删除并且返回seq delMongoMsgsPhysical(delStruct.delDocIDList)
+		err = db.msgModel.Delete(ctx, delStruct.delDocIDList)
+		if err != nil {
+			return 0, err
+		}
+		return delStruct.getSetMinSeq() + 1, nil
+	}
+	//log.NewDebug(operationID, "ID:", sourceID, "index:", index, "uid:", msgs.UID, "len:", len(msgs.Msg))
+	if len(msgs.Msg) > db.msg.GetSingleGocMsgNum() {
+		log.NewWarn(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "msgs too large:", len(msgs.Msg), "docID:", msgs.DocID)
+	}
+	if msgs.Msg[len(msgs.Msg)-1].SendTime+(remainTime*1000) < utils.GetCurrentTimestampByMill() && msgs.IsFull() {
+		delStruct.delDocIDList = append(delStruct.delDocIDList, msgs.DocID)
+		lastMsgPb := &sdkws.MsgData{}
+		err = proto.Unmarshal(msgs.Msg[len(msgs.Msg)-1].Msg, lastMsgPb)
+		if err != nil {
+			//log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), len(msgs.Msg)-1, msgs.UID)
+			return 0, utils.Wrap(err, "proto.Unmarshal failed")
+		}
+		delStruct.minSeq = lastMsgPb.Seq
+	} else {
+		var hasMarkDelFlag bool
+		for _, msg := range msgs.Msg {
+			msgPb := &sdkws.MsgData{}
+			err = proto.Unmarshal(msg.Msg, msgPb)
+			if err != nil {
+				//log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), len(msgs.Msg)-1, msgs.UID)
+				return 0, utils.Wrap(err, "proto.Unmarshal failed")
+			}
+			if utils.GetCurrentTimestampByMill() > msg.SendTime+(remainTime*1000) {
+				msgPb.Status = constant.MsgDeleted
+				bytes, _ := proto.Marshal(msgPb)
+				msg.Msg = bytes
+				msg.SendTime = 0
+				hasMarkDelFlag = true
+			} else {
+				if err := db.msgModel.Delete(ctx, delStruct.delDocIDList); err != nil {
+					return 0, err
+				}
+				if hasMarkDelFlag {
+					if err := db.msgModel.UpdateOneDoc(ctx, msgs); err != nil {
+						return delStruct.getSetMinSeq(), utils.Wrap(err, "")
+					}
+				}
+				return msgPb.Seq + 1, nil
+			}
+		}
+	}
+	//log.NewDebug(operationID, sourceID, "continue to", delStruct)
+	//  继续递归 index+1
+	seq, err := db.deleteMsgRecursion(ctx, sourceID, index+1, delStruct, remainTime)
+	return seq, utils.Wrap(err, "deleteMsg failed")
 }

pkg/common/db/controller/user.go

@@ -23,6 +23,8 @@ type UserInterface interface {
 	Page(ctx context.Context, pageNumber, showNumber int32) (users []*relationTb.UserModel, count int64, err error)
 	//只要有一个存在就为true
 	IsExist(ctx context.Context, userIDs []string) (exist bool, err error)
+	//获取所有用户ID
+	GetAllUserID(ctx context.Context) ([]string, error)
 }
 
 type UserController struct {
@@ -55,6 +57,11 @@ func (u *UserController) Page(ctx context.Context, pageNumber, showNumber int32)
 func (u *UserController) IsExist(ctx context.Context, userIDs []string) (exist bool, err error) {
 	return u.database.IsExist(ctx, userIDs)
 }
+
+func (u *UserController) GetAllUserID(ctx context.Context) ([]string, error) {
+	return u.database.GetAllUserID(ctx)
+}
+
 func NewUserController(db *gorm.DB) *UserController {
 	controller := &UserController{database: newUserDatabase(db)}
 	return controller
@@ -75,6 +82,8 @@ type UserDatabaseInterface interface {
 	Page(ctx context.Context, pageNumber, showNumber int32) (users []*relationTb.UserModel, count int64, err error)
 	//只要有一个存在就为true
 	IsExist(ctx context.Context, userIDs []string) (exist bool, err error)
+	//获取所有用户ID
+	GetAllUserID(ctx context.Context) ([]string, error)
 }
 
 type UserDatabase struct {
@@ -138,3 +147,7 @@ func (u *UserDatabase) IsExist(ctx context.Context, userIDs []string) (exist boo
 	}
 	return false, nil
 }
+
+func (u *UserDatabase) GetAllUserID(ctx context.Context) ([]string, error) {
+	return u.user.GetAllUserID(ctx)
+}

pkg/common/db/relation/user_model_k.go

@@ -100,3 +100,10 @@ func (u *UserGorm) Page(ctx context.Context, pageNumber, showNumber int32, tx ..
 	err = utils.Wrap(getDBConn(u.DB, tx).Limit(int(showNumber)).Offset(int(pageNumber*showNumber)).Find(&users).Error, "")
 	return
 }
+
+// 获取所有用户ID
+func (u *UserGorm) GetAllUserID(ctx context.Context) ([]string, error) {
+	var userIDs []string
+	err := u.DB.Pluck("user_id", &userIDs).Error
+	return userIDs, err
+}

pkg/common/db/table/unrelation/extend_msg_set.go

@@ -1,7 +1,7 @@
 package unrelation
 
 import (
-	common "Open_IM/pkg/proto/sdkws"
+	"Open_IM/pkg/proto/sdkws"
 	"context"
 	"strconv"
 	"strings"
@@ -14,12 +14,12 @@ const (
 )
 
 type ExtendMsgSetModel struct {
-	SourceID         string               `bson:"source_id" json:"sourceID"`
-	SessionType      int32                `bson:"session_type" json:"sessionType"`
-	ExtendMsgs       map[string]ExtendMsg `bson:"extend_msgs" json:"extendMsgs"`
-	ExtendMsgNum     int32                `bson:"extend_msg_num" json:"extendMsgNum"`
-	CreateTime       int64                `bson:"create_time" json:"createTime"`               // this block's create time
-	MaxMsgUpdateTime int64                `bson:"max_msg_update_time" json:"maxMsgUpdateTime"` // index find msg
+	SourceID         string                    `bson:"source_id" json:"sourceID"`
+	SessionType      int32                     `bson:"session_type" json:"sessionType"`
+	ExtendMsgs       map[string]ExtendMsgModel `bson:"extend_msgs" json:"extendMsgs"`
+	ExtendMsgNum     int32                     `bson:"extend_msg_num" json:"extendMsgNum"`
+	CreateTime       int64                     `bson:"create_time" json:"createTime"`               // this block's create time
+	MaxMsgUpdateTime int64                     `bson:"max_msg_update_time" json:"maxMsgUpdateTime"` // index find msg
 }
 
 type KeyValueModel struct {
@@ -28,7 +28,7 @@ type KeyValueModel struct {
 	LatestUpdateTime int64  `bson:"latest_update_time" json:"latestUpdateTime"`
 }
 
-type ExtendMsg struct {
+type ExtendMsgModel struct {
 	ReactionExtensionList map[string]KeyValueModel `bson:"reaction_extension_list" json:"reactionExtensionList"`
 	ClientMsgID           string                   `bson:"client_msg_id" json:"clientMsgID"`
 	MsgFirstModifyTime    int64                    `bson:"msg_first_modify_time" json:"msgFirstModifyTime"` // this extendMsg create time
@@ -36,6 +36,16 @@ type ExtendMsg struct {
 	Ex                    string                   `bson:"ex" json:"ex"`
 }
 
+type ExtendMsgSetModelInterface interface {
+	CreateExtendMsgSet(ctx context.Context, set *ExtendMsgSetModel) error
+	GetAllExtendMsgSet(ctx context.Context, sourceID string, opts *GetAllExtendMsgSetOpts) (sets []*ExtendMsgSetModel, err error)
+	GetExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, maxMsgUpdateTime int64) (*ExtendMsgSetModel, error)
+	InsertExtendMsg(ctx context.Context, sourceID string, sessionType int32, msg *ExtendMsgModel) error
+	InsertOrUpdateReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*sdkws.KeyValue) error
+	DeleteReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*sdkws.KeyValue) error
+	TakeExtendMsg(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, maxMsgUpdateTime int64) (extendMsg *ExtendMsgModel, err error)
+}
+
 func (ExtendMsgSetModel) TableName() string {
 	return CExtendMsgSet
 }
@@ -57,13 +67,3 @@ func (e *ExtendMsgSetModel) SplitSourceIDAndGetIndex() int32 {
 type GetAllExtendMsgSetOpts struct {
 	ExcludeExtendMsgs bool
 }
-
-type ExtendMsgSetInterface interface {
-	CreateExtendMsgSet(ctx context.Context, set *ExtendMsgSetModel) error
-	GetAllExtendMsgSet(ctx context.Context, ID string, opts *GetAllExtendMsgSetOpts) (sets []*ExtendMsgSetModel, err error)
-	GetExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, maxMsgUpdateTime int64) (*ExtendMsgSetModel, error)
-	InsertExtendMsg(ctx context.Context, sourceID string, sessionType int32, msg *ExtendMsg) error
-	InsertOrUpdateReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*common.KeyValue) error
-	DeleteReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*common.KeyValue) error
-	GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, maxMsgUpdateTime int64) (extendMsg *ExtendMsg, err error)
-}

pkg/common/db/table/unrelation/msg.go

@@ -3,15 +3,19 @@ package unrelation
 import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/proto/sdkws"
+	"context"
 	"strconv"
+	"strings"
 )
 
 const (
 	singleGocMsgNum = 5000
 	CChat           = "msg"
+	OldestList      = 0
+	NewestList      = -1
 )
 
-type UserMsgDocModel struct {
+type MsgDocModel struct {
 	DocID string         `bson:"uid"`
 	Msg   []MsgInfoModel `bson:"msg"`
 }
@@ -21,53 +25,79 @@ type MsgInfoModel struct {
 	Msg      []byte `bson:"msg"`
 }
 
-func (UserMsgDocModel) TableName() string {
+type MsgDocModelInterface interface {
+	PushMsgsToDoc(ctx context.Context, docID string, msgsToMongo []MsgInfoModel) error
+	Create(ctx context.Context, model *MsgDocModel) error
+	UpdateMsgStatusByIndexInOneDoc(ctx context.Context, docID string, msg *sdkws.MsgData, seqIndex int, status int32) error
+	FindOneByDocID(ctx context.Context, docID string) (*MsgDocModel, error)
+	GetNewestMsg(ctx context.Context, sourceID string) (*MsgInfoModel, error)
+	GetOldestMsg(ctx context.Context, sourceID string) (*MsgInfoModel, error)
+	Delete(ctx context.Context, docIDs []string) error
+	GetMsgsByIndex(ctx context.Context, sourceID string, index int64) (*MsgDocModel, error)
+	UpdateOneDoc(ctx context.Context, msg *MsgDocModel) error
+}
+
+func (MsgDocModel) TableName() string {
 	return CChat
 }
 
-func (UserMsgDocModel) GetSingleDocMsgNum() int {
+func (MsgDocModel) GetSingleGocMsgNum() int {
 	return singleGocMsgNum
 }
 
-func (u UserMsgDocModel) getSeqUid(uid string, seq uint32) string {
-	seqSuffix := seq / singleGocMsgNum
-	return u.indexGen(uid, seqSuffix)
-}
-
-func (u UserMsgDocModel) getSeqUserIDList(userID string, maxSeq uint32) []string {
-	seqMaxSuffix := maxSeq / singleGocMsgNum
-	var seqUserIDList []string
-	for i := 0; i <= int(seqMaxSuffix); i++ {
-		seqUserID := u.indexGen(userID, uint32(i))
-		seqUserIDList = append(seqUserIDList, seqUserID)
+func (m *MsgDocModel) IsFull() bool {
+	index, _ := strconv.Atoi(strings.Split(m.DocID, ":")[1])
+	if index == 0 {
+		if len(m.Msg) >= singleGocMsgNum-1 {
+			return true
+		}
 	}
-	return seqUserIDList
+	if len(m.Msg) >= singleGocMsgNum {
+		return true
+	}
+
+	return false
 }
 
-func (UserMsgDocModel) getSeqSuperGroupID(groupID string, seq uint32) string {
+func (m MsgDocModel) GetDocID(sourceID string, seq uint32) string {
 	seqSuffix := seq / singleGocMsgNum
-	return superGroupIndexGen(groupID, seqSuffix)
+	return m.indexGen(sourceID, seqSuffix)
 }
 
-func (u UserMsgDocModel) GetSeqUid(uid string, seq uint32) string {
-	return u.getSeqUid(uid, seq)
+func (m MsgDocModel) GetSeqDocIDList(userID string, maxSeq uint32) []string {
+	seqMaxSuffix := maxSeq / singleGocMsgNum
+	var seqUserIDs []string
+	for i := 0; i <= int(seqMaxSuffix); i++ {
+		seqUserID := m.indexGen(userID, uint32(i))
+		seqUserIDs = append(seqUserIDs, seqUserID)
+	}
+	return seqUserIDs
 }
 
-func (u UserMsgDocModel) GetDocIDSeqsMap(uid string, seqs []uint32) map[string][]uint32 {
+func (m MsgDocModel) getSeqSuperGroupID(groupID string, seq uint32) string {
+	seqSuffix := seq / singleGocMsgNum
+	return m.superGroupIndexGen(groupID, seqSuffix)
+}
+
+func (m MsgDocModel) superGroupIndexGen(groupID string, seqSuffix uint32) string {
+	return "super_group_" + groupID + ":" + strconv.FormatInt(int64(seqSuffix), 10)
+}
+
+func (m MsgDocModel) GetDocIDSeqsMap(sourceID string, seqs []uint32) map[string][]uint32 {
 	t := make(map[string][]uint32)
 	for i := 0; i < len(seqs); i++ {
-		seqUid := u.getSeqUid(uid, seqs[i])
-		if value, ok := t[seqUid]; !ok {
+		docID := m.GetDocID(sourceID, seqs[i])
+		if value, ok := t[docID]; !ok {
 			var temp []uint32
-			t[seqUid] = append(temp, seqs[i])
+			t[docID] = append(temp, seqs[i])
 		} else {
-			t[seqUid] = append(value, seqs[i])
+			t[docID] = append(value, seqs[i])
 		}
 	}
 	return t
 }
 
-func (UserMsgDocModel) getMsgIndex(seq uint32) int {
+func (m MsgDocModel) getMsgIndex(seq uint32) int {
 	seqSuffix := seq / singleGocMsgNum
 	var index uint32
 	if seqSuffix == 0 {
@@ -78,12 +108,12 @@ func (UserMsgDocModel) getMsgIndex(seq uint32) int {
 	return int(index)
 }
 
-func (UserMsgDocModel) indexGen(uid string, seqSuffix uint32) string {
-	return uid + ":" + strconv.FormatInt(int64(seqSuffix), 10)
+func (m MsgDocModel) indexGen(sourceID string, seqSuffix uint32) string {
+	return sourceID + ":" + strconv.FormatInt(int64(seqSuffix), 10)
 }
 
-func (UserMsgDocModel) genExceptionMessageBySeqList(seqList []uint32) (exceptionMsg []*sdkws.MsgData) {
-	for _, v := range seqList {
+func (MsgDocModel) GenExceptionMessageBySeqs(seqs []uint32) (exceptionMsg []*sdkws.MsgData) {
+	for _, v := range seqs {
 		msg := new(sdkws.MsgData)
 		msg.Seq = v
 		exceptionMsg = append(exceptionMsg, msg)
@@ -91,8 +121,8 @@ func (UserMsgDocModel) genExceptionMessageBySeqList(seqList []uint32) (exception
 	return exceptionMsg
 }
 
-func (UserMsgDocModel) genExceptionSuperGroupMessageBySeqList(seqList []uint32, groupID string) (exceptionMsg []*sdkws.MsgData) {
-	for _, v := range seqList {
+func (MsgDocModel) GenExceptionSuperGroupMessageBySeqs(seqs []uint32, groupID string) (exceptionMsg []*sdkws.MsgData) {
+	for _, v := range seqs {
 		msg := new(sdkws.MsgData)
 		msg.Seq = v
 		msg.GroupID = groupID

pkg/common/db/table/unrelation/super_group.go

@@ -37,7 +37,3 @@ type SuperGroupModelInterface interface {
 	DeleteSuperGroup(ctx context.Context, groupID string, tx ...any) error
 	RemoveGroupFromUser(ctx context.Context, groupID string, userIDs []string, tx ...any) error
 }
-
-func superGroupIndexGen(groupID string, seqSuffix uint32) string {
-	return "super_group_" + groupID + ":" + strconv.FormatInt(int64(seqSuffix), 10)
-}

pkg/common/db/unrelation/batch_insert_chat.go

@@ -1,171 +0,0 @@
-package unrelation
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	promePkg "Open_IM/pkg/common/prometheus"
-	pbMsg "Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	"context"
-	"errors"
-	go_redis "github.com/go-redis/redis/v8"
-	"github.com/golang/protobuf/proto"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
-)
-
-func (d *db.DataBases) BatchInsertChat2DB(userID string, msgList []*pbMsg.MsgDataToMQ, operationID string, currentMaxSeq uint64) error {
-	newTime := getCurrentTimestampByMill()
-	if len(msgList) > GetSingleGocMsgNum() {
-		return errors.New("too large")
-	}
-	isInit := false
-	var remain uint64
-	blk0 := uint64(GetSingleGocMsgNum() - 1)
-	//currentMaxSeq 4998
-	if currentMaxSeq < uint64(mongo2.GetSingleGocMsgNum()) {
-		remain = blk0 - currentMaxSeq //1
-	} else {
-		excludeBlk0 := currentMaxSeq - blk0 //=1
-		//(5000-1)%5000 == 4999
-		remain = (uint64(mongo2.GetSingleGocMsgNum()) - (excludeBlk0 % uint64(mongo2.GetSingleGocMsgNum()))) % uint64(mongo2.GetSingleGocMsgNum())
-	}
-	//remain=1
-	insertCounter := uint64(0)
-	msgListToMongo := make([]mongo2.MsgInfo, 0)
-	msgListToMongoNext := make([]mongo2.MsgInfo, 0)
-	seqUid := ""
-	seqUidNext := ""
-	log.Debug(operationID, "remain ", remain, "insertCounter ", insertCounter, "currentMaxSeq ", currentMaxSeq, userID, len(msgList))
-	var err error
-	for _, m := range msgList {
-		log.Debug(operationID, "msg node ", m.String(), m.MsgData.ClientMsgID)
-		currentMaxSeq++
-		sMsg := mongo2.MsgInfo{}
-		sMsg.SendTime = m.MsgData.SendTime
-		m.MsgData.Seq = uint32(currentMaxSeq)
-		log.Debug(operationID, "mongo msg node ", m.String(), m.MsgData.ClientMsgID, "userID: ", userID, "seq: ", currentMaxSeq)
-		if sMsg.Msg, err = proto.Marshal(m.MsgData); err != nil {
-			return utils.Wrap(err, "")
-		}
-		if isInit {
-			msgListToMongoNext = append(msgListToMongoNext, sMsg)
-			seqUidNext = mongo2.getSeqUid(userID, uint32(currentMaxSeq))
-			log.Debug(operationID, "msgListToMongoNext ", seqUidNext, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain)
-			continue
-		}
-		if insertCounter < remain {
-			msgListToMongo = append(msgListToMongo, sMsg)
-			insertCounter++
-			seqUid = mongo2.getSeqUid(userID, uint32(currentMaxSeq))
-			log.Debug(operationID, "msgListToMongo ", seqUid, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain, "userID: ", userID)
-		} else {
-			msgListToMongoNext = append(msgListToMongoNext, sMsg)
-			seqUidNext = mongo2.getSeqUid(userID, uint32(currentMaxSeq))
-			log.Debug(operationID, "msgListToMongoNext ", seqUidNext, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain, "userID: ", userID)
-		}
-	}
-
-	ctx := context.Background()
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(mongo2.cChat)
-
-	if seqUid != "" {
-		filter := bson.M{"uid": seqUid}
-		log.NewDebug(operationID, "filter ", seqUid, "list ", msgListToMongo, "userID: ", userID)
-		err := c.FindOneAndUpdate(ctx, filter, bson.M{"$push": bson.M{"msg": bson.M{"$each": msgListToMongo}}}).Err()
-		if err != nil {
-			if err == mongo.ErrNoDocuments {
-				filter := bson.M{"uid": seqUid}
-				sChat := mongo2.UserChat{}
-				sChat.UID = seqUid
-				sChat.Msg = msgListToMongo
-				log.NewDebug(operationID, "filter ", seqUid, "list ", msgListToMongo)
-				if _, err = c.InsertOne(ctx, &sChat); err != nil {
-					promePkg.PromeInc(promePkg.MsgInsertMongoFailedCounter)
-					log.NewError(operationID, "InsertOne failed", filter, err.Error(), sChat)
-					return utils.Wrap(err, "")
-				}
-				promePkg.PromeInc(promePkg.MsgInsertMongoSuccessCounter)
-			} else {
-				promePkg.PromeInc(promePkg.MsgInsertMongoFailedCounter)
-				log.Error(operationID, "FindOneAndUpdate failed ", err.Error(), filter)
-				return utils.Wrap(err, "")
-			}
-		} else {
-			promePkg.PromeInc(promePkg.MsgInsertMongoSuccessCounter)
-		}
-	}
-	if seqUidNext != "" {
-		filter := bson.M{"uid": seqUidNext}
-		sChat := mongo2.UserChat{}
-		sChat.UID = seqUidNext
-		sChat.Msg = msgListToMongoNext
-		log.NewDebug(operationID, "filter ", seqUidNext, "list ", msgListToMongoNext, "userID: ", userID)
-		if _, err = c.InsertOne(ctx, &sChat); err != nil {
-			promePkg.PromeInc(promePkg.MsgInsertMongoFailedCounter)
-			log.NewError(operationID, "InsertOne failed", filter, err.Error(), sChat)
-			return utils.Wrap(err, "")
-		}
-		promePkg.PromeInc(promePkg.MsgInsertMongoSuccessCounter)
-	}
-	log.Debug(operationID, "batch mgo  cost time ", mongo2.getCurrentTimestampByMill()-newTime, userID, len(msgList))
-	return nil
-}
-
-func (d *db.DataBases) BatchInsertChat2Cache(insertID string, msgList []*pbMsg.MsgDataToMQ, operationID string) (error, uint64) {
-	newTime := mongo2.getCurrentTimestampByMill()
-	lenList := len(msgList)
-	if lenList > mongo2.GetSingleGocMsgNum() {
-		return errors.New("too large"), 0
-	}
-	if lenList < 1 {
-		return errors.New("too short as 0"), 0
-	}
-	// judge sessionType to get seq
-	var currentMaxSeq uint64
-	var err error
-	if msgList[0].MsgData.SessionType == constant.SuperGroupChatType {
-		currentMaxSeq, err = d.GetGroupMaxSeq(insertID)
-		log.Debug(operationID, "constant.SuperGroupChatType  lastMaxSeq before add ", currentMaxSeq, "userID ", insertID, err)
-	} else {
-		currentMaxSeq, err = d.GetUserMaxSeq(insertID)
-		log.Debug(operationID, "constant.SingleChatType  lastMaxSeq before add ", currentMaxSeq, "userID ", insertID, err)
-	}
-	if err != nil && err != go_redis.Nil {
-		promePkg.PromeInc(promePkg.SeqGetFailedCounter)
-		return utils.Wrap(err, ""), 0
-	}
-	promePkg.PromeInc(promePkg.SeqGetSuccessCounter)
-
-	lastMaxSeq := currentMaxSeq
-	for _, m := range msgList {
-
-		currentMaxSeq++
-		sMsg := mongo2.MsgInfo{}
-		sMsg.SendTime = m.MsgData.SendTime
-		m.MsgData.Seq = uint32(currentMaxSeq)
-		log.Debug(operationID, "cache msg node ", m.String(), m.MsgData.ClientMsgID, "userID: ", insertID, "seq: ", currentMaxSeq)
-	}
-	log.Debug(operationID, "SetMessageToCache ", insertID, len(msgList))
-	err, failedNum := d.SetMessageToCache(msgList, insertID, operationID)
-	if err != nil {
-		promePkg.PromeAdd(promePkg.MsgInsertRedisFailedCounter, failedNum)
-		log.Error(operationID, "setMessageToCache failed, continue ", err.Error(), len(msgList), insertID)
-	} else {
-		promePkg.PromeInc(promePkg.MsgInsertRedisSuccessCounter)
-	}
-	log.Debug(operationID, "batch to redis  cost time ", mongo2.getCurrentTimestampByMill()-newTime, insertID, len(msgList))
-	if msgList[0].MsgData.SessionType == constant.SuperGroupChatType {
-		err = d.SetGroupMaxSeq(insertID, currentMaxSeq)
-	} else {
-		err = d.SetUserMaxSeq(insertID, currentMaxSeq)
-	}
-	if err != nil {
-		promePkg.PromeInc(promePkg.SeqSetFailedCounter)
-	} else {
-		promePkg.PromeInc(promePkg.SeqSetSuccessCounter)
-	}
-	return utils.Wrap(err, ""), lastMaxSeq
-}

pkg/common/db/unrelation/extend_msg.go

@@ -1,7 +1,7 @@
 package unrelation
 
 import (
-	"Open_IM/pkg/common/db/table/unrelation"
+	unRelationTb "Open_IM/pkg/common/db/table/unrelation"
 	"Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
@@ -19,19 +19,15 @@ type ExtendMsgSetMongoDriver struct {
 }
 
 func NewExtendMsgSetMongoDriver(mgoDB *mongo.Database) *ExtendMsgSetMongoDriver {
-	return &ExtendMsgSetMongoDriver{mgoDB: mgoDB, ExtendMsgSetCollection: mgoDB.Collection(unrelation.CExtendMsgSet)}
+	return &ExtendMsgSetMongoDriver{mgoDB: mgoDB, ExtendMsgSetCollection: mgoDB.Collection(unRelationTb.CExtendMsgSet)}
 }
 
-func (e *ExtendMsgSetMongoDriver) CreateExtendMsgSet(ctx context.Context, set *unrelation.ExtendMsgSet) error {
+func (e *ExtendMsgSetMongoDriver) CreateExtendMsgSet(ctx context.Context, set *unRelationTb.ExtendMsgSetModel) error {
 	_, err := e.ExtendMsgSetCollection.InsertOne(ctx, set)
 	return err
 }
 
-type GetAllExtendMsgSetOpts struct {
-	ExcludeExtendMsgs bool
-}
-
-func (e *ExtendMsgSetMongoDriver) GetAllExtendMsgSet(ctx context.Context, ID string, opts *GetAllExtendMsgSetOpts) (sets []*unrelation.ExtendMsgSet, err error) {
+func (e *ExtendMsgSetMongoDriver) GetAllExtendMsgSet(ctx context.Context, ID string, opts *unRelationTb.GetAllExtendMsgSetOpts) (sets []*unRelationTb.ExtendMsgSetModel, err error) {
 	regex := fmt.Sprintf("^%s", ID)
 	var findOpts *options.FindOptions
 	if opts != nil {
@@ -51,7 +47,7 @@ func (e *ExtendMsgSetMongoDriver) GetAllExtendMsgSet(ctx context.Context, ID str
 	return sets, nil
 }
 
-func (e *ExtendMsgSetMongoDriver) GetExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, maxMsgUpdateTime int64) (*unrelation.ExtendMsgSet, error) {
+func (e *ExtendMsgSetMongoDriver) GetExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, maxMsgUpdateTime int64) (*unRelationTb.ExtendMsgSetModel, error) {
 	var err error
 	findOpts := options.Find().SetLimit(1).SetSkip(0).SetSort(bson.M{"source_id": -1}).SetProjection(bson.M{"extend_msgs": 0})
 	// update newest
@@ -63,7 +59,7 @@ func (e *ExtendMsgSetMongoDriver) GetExtendMsgSet(ctx context.Context, sourceID
 	if err != nil {
 		return nil, utils.Wrap(err, "")
 	}
-	var setList []unrelation.ExtendMsgSet
+	var setList []unRelationTb.ExtendMsgSetModel
 	if err := result.All(ctx, &setList); err != nil {
 		return nil, utils.Wrap(err, "")
 	}
@@ -74,7 +70,7 @@ func (e *ExtendMsgSetMongoDriver) GetExtendMsgSet(ctx context.Context, sourceID
 }
 
 // first modify msg
-func (e *ExtendMsgSetMongoDriver) InsertExtendMsg(ctx context.Context, sourceID string, sessionType int32, msg *unrelation.ExtendMsg) error {
+func (e *ExtendMsgSetMongoDriver) InsertExtendMsg(ctx context.Context, sourceID string, sessionType int32, msg *unRelationTb.ExtendMsgModel) error {
 	set, err := e.GetExtendMsgSet(ctx, sourceID, sessionType, 0)
 	if err != nil {
 		return utils.Wrap(err, "")
@@ -84,10 +80,10 @@ func (e *ExtendMsgSetMongoDriver) InsertExtendMsg(ctx context.Context, sourceID
 		if set != nil {
 			index = set.SplitSourceIDAndGetIndex()
 		}
-		err = e.CreateExtendMsgSet(ctx, &unrelation.ExtendMsgSet{
+		err = e.CreateExtendMsgSet(ctx, &unRelationTb.ExtendMsgSetModel{
 			SourceID:         set.GetSourceID(sourceID, index),
 			SessionType:      sessionType,
-			ExtendMsgs:       map[string]unrelation.ExtendMsg{msg.ClientMsgID: *msg},
+			ExtendMsgs:       map[string]unRelationTb.ExtendMsgModel{msg.ClientMsgID: *msg},
 			ExtendMsgNum:     1,
 			CreateTime:       msg.MsgFirstModifyTime,
 			MaxMsgUpdateTime: msg.MsgFirstModifyTime,
@@ -136,14 +132,14 @@ func (e *ExtendMsgSetMongoDriver) DeleteReactionExtendMsgSet(ctx context.Context
 	return err
 }
 
-func (e *ExtendMsgSetMongoDriver) GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, maxMsgUpdateTime int64) (extendMsg *unrelation.ExtendMsg, err error) {
+func (e *ExtendMsgSetMongoDriver) GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, maxMsgUpdateTime int64) (extendMsg *unRelationTb.ExtendMsgModel, err error) {
 	findOpts := options.Find().SetLimit(1).SetSkip(0).SetSort(bson.M{"source_id": -1}).SetProjection(bson.M{fmt.Sprintf("extend_msgs.%s", clientMsgID): 1})
 	regex := fmt.Sprintf("^%s", sourceID)
 	result, err := e.ExtendMsgSetCollection.Find(ctx, bson.M{"source_id": primitive.Regex{Pattern: regex}, "session_type": sessionType, "max_msg_update_time": bson.M{"$lte": maxMsgUpdateTime}}, findOpts)
 	if err != nil {
 		return nil, utils.Wrap(err, "")
 	}
-	var setList []unrelation.ExtendMsgSet
+	var setList []unRelationTb.ExtendMsgSetModel
 	if err := result.All(ctx, &setList); err != nil {
 		return nil, utils.Wrap(err, "")
 	}

pkg/common/db/unrelation/mongo.go

@@ -62,17 +62,17 @@ func (m *Mongo) GetClient() *mongo.Client {
 }
 
 func (m *Mongo) CreateMsgIndex() {
-	if err := m.createMongoIndex(unrelation, false, "uid"); err != nil {
+	if err := m.createMongoIndex(unrelation.CChat, false, "uid"); err != nil {
 		fmt.Println(err.Error() + " index create failed " + unrelation.CChat + " uid, please create index by yourself in field uid")
 	}
 }
 
 func (m *Mongo) CreateSuperGroupIndex() {
 	if err := m.createMongoIndex(unrelation.CSuperGroup, true, "group_id"); err != nil {
-		panic(err.Error() + "index create failed " + unrelation.CTag + " group_id")
+		panic(err.Error() + "index create failed " + unrelation.CSuperGroup + " group_id")
 	}
 	if err := m.createMongoIndex(unrelation.CUserToSuperGroup, true, "user_id"); err != nil {
-		panic(err.Error() + "index create failed " + unrelation.CTag + "user_id")
+		panic(err.Error() + "index create failed " + unrelation.CUserToSuperGroup + "user_id")
 	}
 }
 

pkg/common/db/unrelation/mongo_model.go

@@ -1,670 +0,0 @@
-package unrelation
-
-
-// deleteMsgByLogic
-//func (d *db.DataBases) DelMsgBySeqList(userID string, seqList []uint32, operationID string) (totalUnexistSeqList []uint32, err error) {
-//	log.Debug(operationID, utils.GetSelfFuncName(), "args ", userID, seqList)
-//	sortkeys.Uint32s(seqList)
-//	suffixUserID2SubSeqList := func(uid string, seqList []uint32) map[string][]uint32 {
-//		t := make(map[string][]uint32)
-//		for i := 0; i < len(seqList); i++ {
-//			seqUid := getSeqUid(uid, seqList[i])
-//			if value, ok := t[seqUid]; !ok {
-//				var temp []uint32
-//				t[seqUid] = append(temp, seqList[i])
-//			} else {
-//				t[seqUid] = append(value, seqList[i])
-//			}
-//		}
-//		return t
-//	}(userID, seqList)
-//
-//	lock := sync.Mutex{}
-//	var wg sync.WaitGroup
-//	wg.Add(len(suffixUserID2SubSeqList))
-//	for k, v := range suffixUserID2SubSeqList {
-//		go func(suffixUserID string, subSeqList []uint32, operationID string) {
-//			defer wg.Done()
-//			unexistSeqList, err := d.DelMsgBySeqListInOneDoc(suffixUserID, subSeqList, operationID)
-//			if err != nil {
-//				log.Error(operationID, "DelMsgBySeqListInOneDoc failed ", err.Error(), suffixUserID, subSeqList)
-//				return
-//			}
-//			lock.Lock()
-//			totalUnexistSeqList = append(totalUnexistSeqList, unexistSeqList...)
-//			lock.Unlock()
-//		}(k, v, operationID)
-//	}
-//	return totalUnexistSeqList, err
-//}
-//
-//func (d *db.DataBases) DelMsgBySeqListInOneDoc(suffixUserID string, seqList []uint32, operationID string) ([]uint32, error) {
-//	log.Debug(operationID, utils.GetSelfFuncName(), "args ", suffixUserID, seqList)
-//	seqMsgList, indexList, unexistSeqList, err := d.GetMsgAndIndexBySeqListInOneMongo2(suffixUserID, seqList, operationID)
-//	if err != nil {
-//		return nil, utils.Wrap(err, "")
-//	}
-//	for i, v := range seqMsgList {
-//		if err := d.ReplaceMsgByIndex(suffixUserID, v, operationID, indexList[i]); err != nil {
-//			return nil, utils.Wrap(err, "")
-//		}
-//	}
-//	return unexistSeqList, nil
-//}
-
-// deleteMsgByLogic
-//func (d *db.DataBases) DelMsgLogic(uid string, seqList []uint32, operationID string) error {
-//	sortkeys.Uint32s(seqList)
-//	seqMsgs, err := d.GetMsgBySeqListMongo2(uid, seqList, operationID)
-//	if err != nil {
-//		return utils.Wrap(err, "")
-//	}
-//	for _, seqMsg := range seqMsgs {
-//		log.NewDebug(operationID, utils.GetSelfFuncName(), *seqMsg)
-//		seqMsg.Status = constant.MsgDeleted
-//		if err = d.ReplaceMsgBySeq(uid, seqMsg, operationID); err != nil {
-//			log.NewError(operationID, utils.GetSelfFuncName(), "ReplaceMsgListBySeq error", err.Error())
-//		}
-//	}
-//	return nil
-//}
-
-//func (d *db.DataBases) ReplaceMsgByIndex(suffixUserID string, msg *sdkws.MsgData, operationID string, seqIndex int) error {
-//	log.NewInfo(operationID, utils.GetSelfFuncName(), suffixUserID, *msg)
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	s := fmt.Sprintf("msg.%d.msg", seqIndex)
-//	log.NewDebug(operationID, utils.GetSelfFuncName(), seqIndex, s)
-//	msg.Status = constant.MsgDeleted
-//	bytes, err := proto.Marshal(msg)
-//	if err != nil {
-//		log.NewError(operationID, utils.GetSelfFuncName(), "proto marshal failed ", err.Error(), msg.String())
-//		return utils.Wrap(err, "")
-//	}
-//	updateResult, err := c.UpdateOne(ctx, bson.M{"uid": suffixUserID}, bson.M{"$set": bson.M{s: bytes}})
-//	log.NewInfo(operationID, utils.GetSelfFuncName(), updateResult)
-//	if err != nil {
-//		log.NewError(operationID, utils.GetSelfFuncName(), "UpdateOne", err.Error())
-//		return utils.Wrap(err, "")
-//	}
-//	return nil
-//}
-
-//func (d *db.DataBases) ReplaceMsgBySeq(uid string, msg *sdkws.MsgData, operationID string) error {
-//	log.NewInfo(operationID, utils.GetSelfFuncName(), uid, *msg)
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	uid = getSeqUid(uid, msg.Seq)
-//	seqIndex := getMsgIndex(msg.Seq)
-//	s := fmt.Sprintf("msg.%d.msg", seqIndex)
-//	log.NewDebug(operationID, utils.GetSelfFuncName(), seqIndex, s)
-//	bytes, err := proto.Marshal(msg)
-//	if err != nil {
-//		log.NewError(operationID, utils.GetSelfFuncName(), "proto marshal", err.Error())
-//		return utils.Wrap(err, "")
-//	}
-//
-//	updateResult, err := c.UpdateOne(
-//		ctx, bson.M{"uid": uid},
-//		bson.M{"$set": bson.M{s: bytes}})
-//	log.NewInfo(operationID, utils.GetSelfFuncName(), updateResult)
-//	if err != nil {
-//		log.NewError(operationID, utils.GetSelfFuncName(), "UpdateOne", err.Error())
-//		return utils.Wrap(err, "")
-//	}
-//	return nil
-//}
-//
-//func (d *db.DataBases) UpdateOneMsgList(msg *UserChat) error {
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	_, err := c.UpdateOne(ctx, bson.M{"uid": msg.UID}, bson.M{"$set": bson.M{"msg": msg.Msg}})
-//	return err
-//}
-//
-//func (d *db.DataBases) GetMsgBySeqList(uid string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, err error) {
-//	log.NewInfo(operationID, utils.GetSelfFuncName(), uid, seqList)
-//	var hasSeqList []uint32
-//	singleCount := 0
-//	session := d.mgoSession.Clone()
-//	if session == nil {
-//		return nil, errors.New("session == nil")
-//	}
-//	defer session.Close()
-//	c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
-//	m := func(uid string, seqList []uint32) map[string][]uint32 {
-//		t := make(map[string][]uint32)
-//		for i := 0; i < len(seqList); i++ {
-//			seqUid := getSeqUid(uid, seqList[i])
-//			if value, ok := t[seqUid]; !ok {
-//				var temp []uint32
-//				t[seqUid] = append(temp, seqList[i])
-//			} else {
-//				t[seqUid] = append(value, seqList[i])
-//			}
-//		}
-//		return t
-//	}(uid, seqList)
-//	sChat := UserChat{}
-//	for seqUid, value := range m {
-//		if err = c.Find(bson.M{"uid": seqUid}).One(&sChat); err != nil {
-//			log.NewError(operationID, "not find seqUid", seqUid, value, uid, seqList, err.Error())
-//			continue
-//		}
-//		singleCount = 0
-//		for i := 0; i < len(sChat.Msg); i++ {
-//			msg := new(sdkws.MsgData)
-//			if err = proto.Unmarshal(sChat.Msg[i].Msg, msg); err != nil {
-//				log.NewError(operationID, "Unmarshal err", seqUid, value, uid, seqList, err.Error())
-//				return nil, err
-//			}
-//			if isContainInt32(msg.Seq, value) {
-//				seqMsg = append(seqMsg, msg)
-//				hasSeqList = append(hasSeqList, msg.Seq)
-//				singleCount++
-//				if singleCount == len(value) {
-//					break
-//				}
-//			}
-//		}
-//	}
-//	if len(hasSeqList) != len(seqList) {
-//		var diff []uint32
-//		diff = utils.Difference(hasSeqList, seqList)
-//		exceptionMSg := genExceptionMessageBySeqList(diff)
-//		seqMsg = append(seqMsg, exceptionMSg...)
-//
-//	}
-//	return seqMsg, nil
-//}
-//
-//func (d *db.DataBases) GetUserMsgListByIndex(ID string, index int64) (*UserChat, error) {
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	regex := fmt.Sprintf("^%s", ID)
-//	findOpts := options.Find().SetLimit(1).SetSkip(index).SetSort(bson.M{"uid": 1})
-//	var msgs []UserChat
-//	//primitive.Regex{Pattern: regex}
-//	cursor, err := c.Find(ctx, bson.M{"uid": primitive.Regex{Pattern: regex}}, findOpts)
-//	if err != nil {
-//		return nil, utils.Wrap(err, "")
-//	}
-//	err = cursor.All(context.Background(), &msgs)
-//	if err != nil {
-//		return nil, utils.Wrap(err, fmt.Sprintf("cursor is %s", cursor.Current.String()))
-//	}
-//	if len(msgs) > 0 {
-//		return &msgs[0], nil
-//	} else {
-//		return nil, ErrMsgListNotExist
-//	}
-//}
-//
-//func (d *db.DataBases) DelMongoMsgs(IDList []string) error {
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	_, err := c.DeleteMany(ctx, bson.M{"uid": bson.M{"$in": IDList}})
-//	return err
-//}
-//
-//func (d *db.DataBases) ReplaceMsgToBlankByIndex(suffixID string, index int) (replaceMaxSeq uint32, err error) {
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	userChat := &UserChat{}
-//	err = c.FindOne(ctx, bson.M{"uid": suffixID}).Decode(&userChat)
-//	if err != nil {
-//		return 0, err
-//	}
-//	for i, msg := range userChat.Msg {
-//		if i <= index {
-//			msgPb := &sdkws.MsgData{}
-//			if err = proto.Unmarshal(msg.Msg, msgPb); err != nil {
-//				continue
-//			}
-//			newMsgPb := &sdkws.MsgData{Seq: msgPb.Seq}
-//			bytes, err := proto.Marshal(newMsgPb)
-//			if err != nil {
-//				continue
-//			}
-//			msg.Msg = bytes
-//			msg.SendTime = 0
-//			replaceMaxSeq = msgPb.Seq
-//		}
-//	}
-//	_, err = c.UpdateOne(ctx, bson.M{"uid": suffixID}, bson.M{"$set": bson.M{"msg": userChat.Msg}})
-//	return replaceMaxSeq, err
-//}
-//
-//func (d *db.DataBases) GetNewestMsg(ID string) (msg *sdkws.MsgData, err error) {
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	regex := fmt.Sprintf("^%s", ID)
-//	findOpts := options.Find().SetLimit(1).SetSort(bson.M{"uid": -1})
-//	var userChats []UserChat
-//	cursor, err := c.Find(ctx, bson.M{"uid": bson.M{"$regex": regex}}, findOpts)
-//	if err != nil {
-//		return nil, err
-//	}
-//	err = cursor.All(ctx, &userChats)
-//	if err != nil {
-//		return nil, utils.Wrap(err, "")
-//	}
-//	if len(userChats) > 0 {
-//		if len(userChats[0].Msg) > 0 {
-//			msgPb := &sdkws.MsgData{}
-//			err = proto.Unmarshal(userChats[0].Msg[len(userChats[0].Msg)-1].Msg, msgPb)
-//			if err != nil {
-//				return nil, utils.Wrap(err, "")
-//			}
-//			return msgPb, nil
-//		}
-//		return nil, errors.New("len(userChats[0].Msg) < 0")
-//	}
-//	return nil, nil
-//}
-//
-//func (d *db.DataBases) GetOldestMsg(ID string) (msg *sdkws.MsgData, err error) {
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	regex := fmt.Sprintf("^%s", ID)
-//	findOpts := options.Find().SetLimit(1).SetSort(bson.M{"uid": 1})
-//	var userChats []UserChat
-//	cursor, err := c.Find(ctx, bson.M{"uid": bson.M{"$regex": regex}}, findOpts)
-//	if err != nil {
-//		return nil, err
-//	}
-//	err = cursor.All(ctx, &userChats)
-//	if err != nil {
-//		return nil, utils.Wrap(err, "")
-//	}
-//	var oldestMsg []byte
-//	if len(userChats) > 0 {
-//		for _, v := range userChats[0].Msg {
-//			if v.SendTime != 0 {
-//				oldestMsg = v.Msg
-//				break
-//			}
-//		}
-//		if len(oldestMsg) == 0 {
-//			oldestMsg = userChats[0].Msg[len(userChats[0].Msg)-1].Msg
-//		}
-//		msgPb := &sdkws.MsgData{}
-//		err = proto.Unmarshal(oldestMsg, msgPb)
-//		if err != nil {
-//			return nil, utils.Wrap(err, "")
-//		}
-//		return msgPb, nil
-//	}
-//	return nil, nil
-//}
-//
-//func (d *db.DataBases) GetMsgBySeqListMongo2(uid string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, err error) {
-//	var hasSeqList []uint32
-//	singleCount := 0
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//
-//	m := func(uid string, seqList []uint32) map[string][]uint32 {
-//		t := make(map[string][]uint32)
-//		for i := 0; i < len(seqList); i++ {
-//			seqUid := getSeqUid(uid, seqList[i])
-//			if value, ok := t[seqUid]; !ok {
-//				var temp []uint32
-//				t[seqUid] = append(temp, seqList[i])
-//			} else {
-//				t[seqUid] = append(value, seqList[i])
-//			}
-//		}
-//		return t
-//	}(uid, seqList)
-//	sChat := UserChat{}
-//	for seqUid, value := range m {
-//		if err = c.FindOne(ctx, bson.M{"uid": seqUid}).Decode(&sChat); err != nil {
-//			log.NewError(operationID, "not find seqUid", seqUid, value, uid, seqList, err.Error())
-//			continue
-//		}
-//		singleCount = 0
-//		for i := 0; i < len(sChat.Msg); i++ {
-//			msg := new(sdkws.MsgData)
-//			if err = proto.Unmarshal(sChat.Msg[i].Msg, msg); err != nil {
-//				log.NewError(operationID, "Unmarshal err", seqUid, value, uid, seqList, err.Error())
-//				return nil, err
-//			}
-//			if isContainInt32(msg.Seq, value) {
-//				seqMsg = append(seqMsg, msg)
-//				hasSeqList = append(hasSeqList, msg.Seq)
-//				singleCount++
-//				if singleCount == len(value) {
-//					break
-//				}
-//			}
-//		}
-//	}
-//	if len(hasSeqList) != len(seqList) {
-//		var diff []uint32
-//		diff = utils.Difference(hasSeqList, seqList)
-//		exceptionMSg := genExceptionMessageBySeqList(diff)
-//		seqMsg = append(seqMsg, exceptionMSg...)
-//
-//	}
-//	return seqMsg, nil
-//}
-//func (d *db.DataBases) GetSuperGroupMsgBySeqListMongo(groupID string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, err error) {
-//	var hasSeqList []uint32
-//	singleCount := 0
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//
-//	m := func(uid string, seqList []uint32) map[string][]uint32 {
-//		t := make(map[string][]uint32)
-//		for i := 0; i < len(seqList); i++ {
-//			seqUid := getSeqUid(uid, seqList[i])
-//			if value, ok := t[seqUid]; !ok {
-//				var temp []uint32
-//				t[seqUid] = append(temp, seqList[i])
-//			} else {
-//				t[seqUid] = append(value, seqList[i])
-//			}
-//		}
-//		return t
-//	}(groupID, seqList)
-//	sChat := UserChat{}
-//	for seqUid, value := range m {
-//		if err = c.FindOne(ctx, bson.M{"uid": seqUid}).Decode(&sChat); err != nil {
-//			log.NewError(operationID, "not find seqGroupID", seqUid, value, groupID, seqList, err.Error())
-//			continue
-//		}
-//		singleCount = 0
-//		for i := 0; i < len(sChat.Msg); i++ {
-//			msg := new(sdkws.MsgData)
-//			if err = proto.Unmarshal(sChat.Msg[i].Msg, msg); err != nil {
-//				log.NewError(operationID, "Unmarshal err", seqUid, value, groupID, seqList, err.Error())
-//				return nil, err
-//			}
-//			if isContainInt32(msg.Seq, value) {
-//				seqMsg = append(seqMsg, msg)
-//				hasSeqList = append(hasSeqList, msg.Seq)
-//				singleCount++
-//				if singleCount == len(value) {
-//					break
-//				}
-//			}
-//		}
-//	}
-//	if len(hasSeqList) != len(seqList) {
-//		var diff []uint32
-//		diff = utils.Difference(hasSeqList, seqList)
-//		exceptionMSg := genExceptionSuperGroupMessageBySeqList(diff, groupID)
-//		seqMsg = append(seqMsg, exceptionMSg...)
-//
-//	}
-//	return seqMsg, nil
-//}
-//
-//func (d *db.DataBases) GetMsgAndIndexBySeqListInOneMongo2(suffixUserID string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, indexList []int, unexistSeqList []uint32, err error) {
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	sChat := UserChat{}
-//	if err = c.FindOne(ctx, bson.M{"uid": suffixUserID}).Decode(&sChat); err != nil {
-//		log.NewError(operationID, "not find seqUid", suffixUserID, err.Error())
-//		return nil, nil, nil, utils.Wrap(err, "")
-//	}
-//	singleCount := 0
-//	var hasSeqList []uint32
-//	for i := 0; i < len(sChat.Msg); i++ {
-//		msg := new(sdkws.MsgData)
-//		if err = proto.Unmarshal(sChat.Msg[i].Msg, msg); err != nil {
-//			log.NewError(operationID, "Unmarshal err", msg.String(), err.Error())
-//			return nil, nil, nil, err
-//		}
-//		if isContainInt32(msg.Seq, seqList) {
-//			indexList = append(indexList, i)
-//			seqMsg = append(seqMsg, msg)
-//			hasSeqList = append(hasSeqList, msg.Seq)
-//			singleCount++
-//			if singleCount == len(seqList) {
-//				break
-//			}
-//		}
-//	}
-//	for _, i := range seqList {
-//		if isContainInt32(i, hasSeqList) {
-//			continue
-//		}
-//		unexistSeqList = append(unexistSeqList, i)
-//	}
-//	return seqMsg, indexList, unexistSeqList, nil
-//}
-//
-//func genExceptionMessageBySeqList(seqList []uint32) (exceptionMsg []*sdkws.MsgData) {
-//	for _, v := range seqList {
-//		msg := new(sdkws.MsgData)
-//		msg.Seq = v
-//		exceptionMsg = append(exceptionMsg, msg)
-//	}
-//	return exceptionMsg
-//}
-//
-//func genExceptionSuperGroupMessageBySeqList(seqList []uint32, groupID string) (exceptionMsg []*sdkws.MsgData) {
-//	for _, v := range seqList {
-//		msg := new(sdkws.MsgData)
-//		msg.Seq = v
-//		msg.GroupID = groupID
-//		msg.SessionType = constant.SuperGroupChatType
-//		exceptionMsg = append(exceptionMsg, msg)
-//	}
-//	return exceptionMsg
-//}
-//
-//func (d *db.DataBases) SaveUserChatMongo2(uid string, sendTime int64, m *pbMsg.MsgDataToDB) error {
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	newTime := getCurrentTimestampByMill()
-//	operationID := ""
-//	seqUid := getSeqUid(uid, m.MsgData.Seq)
-//	filter := bson.M{"uid": seqUid}
-//	var err error
-//	sMsg := MsgInfo{}
-//	sMsg.SendTime = sendTime
-//	if sMsg.Msg, err = proto.Marshal(m.MsgData); err != nil {
-//		return utils.Wrap(err, "")
-//	}
-//	err = c.FindOneAndUpdate(ctx, filter, bson.M{"$push": bson.M{"msg": sMsg}}).Err()
-//	log.NewWarn(operationID, "get mgoSession cost time", getCurrentTimestampByMill()-newTime)
-//	if err != nil {
-//		sChat := UserChat{}
-//		sChat.UID = seqUid
-//		sChat.Msg = append(sChat.Msg, sMsg)
-//		if _, err = c.InsertOne(ctx, &sChat); err != nil {
-//			log.NewDebug(operationID, "InsertOne failed", filter)
-//			return utils.Wrap(err, "")
-//		}
-//	} else {
-//		log.NewDebug(operationID, "FindOneAndUpdate ok", filter)
-//	}
-//
-//	log.NewDebug(operationID, "find mgo uid cost time", getCurrentTimestampByMill()-newTime)
-//	return nil
-//}
-
-//
-//func (d *DataBases) SaveUserChatListMongo2(uid string, sendTime int64, msgList []*pbMsg.MsgDataToDB) error {
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	newTime := getCurrentTimestampByMill()
-//	operationID := ""
-//	seqUid := ""
-//	msgListToMongo := make([]MsgInfo, 0)
-//
-//	for _, m := range msgList {
-//		seqUid = getSeqUid(uid, m.MsgData.Seq)
-//		var err error
-//		sMsg := MsgInfo{}
-//		sMsg.SendTime = sendTime
-//		if sMsg.Msg, err = proto.Marshal(m.MsgData); err != nil {
-//			return utils.Wrap(err, "")
-//		}
-//		msgListToMongo = append(msgListToMongo, sMsg)
-//	}
-//
-//	filter := bson.M{"uid": seqUid}
-//	log.NewDebug(operationID, "filter ", seqUid)
-//	err := c.FindOneAndUpdate(ctx, filter, bson.M{"$push": bson.M{"msg": bson.M{"$each": msgListToMongo}}}).Err()
-//	log.NewWarn(operationID, "get mgoSession cost time", getCurrentTimestampByMill()-newTime)
-//	if err != nil {
-//		sChat := UserChat{}
-//		sChat.UID = seqUid
-//		sChat.Msg = msgListToMongo
-//
-//		if _, err = c.InsertOne(ctx, &sChat); err != nil {
-//			log.NewError(operationID, "InsertOne failed", filter, err.Error(), sChat)
-//			return utils.Wrap(err, "")
-//		}
-//	} else {
-//		log.NewDebug(operationID, "FindOneAndUpdate ok", filter)
-//	}
-//
-//	log.NewDebug(operationID, "find mgo uid cost time", getCurrentTimestampByMill()-newTime)
-//	return nil
-//}
-
-//func (d *db.DataBases) SaveUserChat(uid string, sendTime int64, m *pbMsg.MsgDataToDB) error {
-//	var seqUid string
-//	newTime := getCurrentTimestampByMill()
-//	session := d.mgoSession.Clone()
-//	if session == nil {
-//		return errors.New("session == nil")
-//	}
-//	defer session.Close()
-//	log.NewDebug("", "get mgoSession cost time", getCurrentTimestampByMill()-newTime)
-//	c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
-//	seqUid = getSeqUid(uid, m.MsgData.Seq)
-//	n, err := c.Find(bson.M{"uid": seqUid}).Count()
-//	if err != nil {
-//		return err
-//	}
-//	log.NewDebug("", "find mgo uid cost time", getCurrentTimestampByMill()-newTime)
-//	sMsg := MsgInfo{}
-//	sMsg.SendTime = sendTime
-//	if sMsg.Msg, err = proto.Marshal(m.MsgData); err != nil {
-//		return err
-//	}
-//	if n == 0 {
-//		sChat := UserChat{}
-//		sChat.UID = seqUid
-//		sChat.Msg = append(sChat.Msg, sMsg)
-//		err = c.Insert(&sChat)
-//		if err != nil {
-//			return err
-//		}
-//	} else {
-//		err = c.Update(bson.M{"uid": seqUid}, bson.M{"$push": bson.M{"msg": sMsg}})
-//		if err != nil {
-//			return err
-//		}
-//	}
-//	log.NewDebug("", "insert mgo data cost time", getCurrentTimestampByMill()-newTime)
-//	return nil
-//}
-//
-//func (d *db.DataBases) DelUserChatMongo2(uid string) error {
-//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-//	filter := bson.M{"uid": uid}
-//
-//	delTime := time.Now().Unix() - int64(config.Config.Mongo.DBRetainChatRecords)*24*3600
-//	if _, err := c.UpdateOne(ctx, filter, bson.M{"$pull": bson.M{"msg": bson.M{"sendtime": bson.M{"$lte": delTime}}}}); err != nil {
-//		return utils.Wrap(err, "")
-//	}
-//	return nil
-//}
-//
-//func (d *db.DataBases) MgoSkipUID(count int) (string, error) {
-//	return "", nil
-	//session := d.mgoSession.Clone()
-	//if session == nil {
-	//	return "", errors.New("session == nil")
-	//}
-	//defer session.Close()
-	//
-	//c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
-	//
-	//sChat := UserChat{}
-	//c.Find(nil).Skip(count).Limit(1).One(&sChat)
-	//return sChat.UID, nil
-}
-
-//func generateTagID(tagName, userID string) string {
-//	return utils.Md5(tagName + userID + strconv.Itoa(rand.Int()) + time.Now().String())
-//}
-
-
-
-//func getCurrentTimestampByMill() int64 {
-//	return time.Now().UnixNano() / 1e6
-//}
-//func GetCurrentTimestampByMill() int64 {
-//	return time.Now().UnixNano() / 1e6
-//}
-
-//func getSeqUid(uid string, seq uint32) string {
-//	seqSuffix := seq / singleGocMsgNum
-//	return indexGen(uid, seqSuffix)
-//}
-//
-//func getSeqUserIDList(userID string, maxSeq uint32) []string {
-//	seqMaxSuffix := maxSeq / singleGocMsgNum
-//	var seqUserIDList []string
-//	for i := 0; i <= int(seqMaxSuffix); i++ {
-//		seqUserID := indexGen(userID, uint32(i))
-//		seqUserIDList = append(seqUserIDList, seqUserID)
-//	}
-//	return seqUserIDList
-//}
-//
-//func getSeqSuperGroupID(groupID string, seq uint32) string {
-//	seqSuffix := seq / singleGocMsgNum
-//	return superGroupIndexGen(groupID, seqSuffix)
-//}
-//
-//func GetSeqUid(uid string, seq uint32) string {
-//	return getSeqUid(uid, seq)
-//}
-//
-//func getMsgIndex(seq uint32) int {
-//	seqSuffix := seq / singleGocMsgNum
-//	var index uint32
-//	if seqSuffix == 0 {
-//		index = (seq - seqSuffix*singleGocMsgNum) - 1
-//	} else {
-//		index = seq - seqSuffix*singleGocMsgNum
-//	}
-//	return int(index)
-//}
-
-//func isContainInt32(target uint32, List []uint32) bool {
-//	for _, element := range List {
-//		if target == element {
-//			return true
-//		}
-//	}
-//	return false
-//}
-//
-//func isNotContainInt32(target uint32, List []uint32) bool {
-//	for _, i := range List {
-//		if i == target {
-//			return false
-//		}
-//	}
-//	return true
-//}
-//
-//func indexGen(uid string, seqSuffix uint32) string {
-//	return uid + ":" + strconv.FormatInt(int64(seqSuffix), 10)
-//}
-
-//func superGroupIndexGen(groupID string, seqSuffix uint32) string {
-//	return "super_group_" + groupID + ":" + strconv.FormatInt(int64(seqSuffix), 10)
-//}
-

pkg/common/db/unrelation/msg.go

@@ -1,561 +1,131 @@
 package unrelation
 
 import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db/table/unrelation"
+	table "Open_IM/pkg/common/db/table/unrelation"
 	"Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
 	"errors"
-	"github.com/go-redis/redis/v8"
-	"github.com/gogo/protobuf/sortkeys"
+	"fmt"
+	"github.com/golang/protobuf/proto"
+	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
-	"sync"
-	"time"
 )
 
 var ErrMsgListNotExist = errors.New("user not have msg in mongoDB")
+var ErrMsgNotFound = errors.New("msg not found")
 
 type MsgMongoDriver struct {
 	mgoDB         *mongo.Database
 	MsgCollection *mongo.Collection
+	msg           table.MsgDocModel
 }
 
 func NewMsgMongoDriver(mgoDB *mongo.Database) *MsgMongoDriver {
-	return &MsgMongoDriver{mgoDB: mgoDB, MsgCollection: mgoDB.Collection(unrelation.CChat)}
+	return &MsgMongoDriver{mgoDB: mgoDB, MsgCollection: mgoDB.Collection(table.MsgDocModel{}.TableName())}
 }
 
-func (m *MsgMongoDriver) FindOneAndUpdate(ctx context.Context, filter, update, output interface{}, opts ...*options.FindOneAndUpdateOptions) error {
-	return m.MsgCollection.FindOneAndUpdate(ctx, filter, update, opts...).Decode(output)
+func (m *MsgMongoDriver) PushMsgsToDoc(ctx context.Context, docID string, msgsToMongo []table.MsgInfoModel) error {
+	filter := bson.M{"uid": docID}
+	return m.MsgCollection.FindOneAndUpdate(ctx, filter, bson.M{"$push": bson.M{"msg": bson.M{"$each": msgsToMongo}}}).Err()
 }
 
-func (m *MsgMongoDriver) UpdateOne(ctx context.Context, filter, update interface{}, opts ...*options.UpdateOptions) error {
-	_, err := m.MsgCollection.UpdateOne(ctx, filter, update, opts...)
+func (m *MsgMongoDriver) Create(ctx context.Context, model *table.MsgDocModel) error {
+	_, err := m.MsgCollection.InsertOne(ctx, model)
 	return err
 }
 
-// database controller
-func (m *MsgMongoDriver) DelMsgBySeqList(ctx context.Context, userID string, seqList []uint32) (totalUnExistSeqList []uint32, err error) {
-	sortkeys.Uint32s(seqList)
-	suffixUserID2SubSeqList := func(uid string, seqList []uint32) map[string][]uint32 {
-		t := make(map[string][]uint32)
-		for i := 0; i < len(seqList); i++ {
-			seqUid := getSeqUid(uid, seqList[i])
-			if value, ok := t[seqUid]; !ok {
-				var temp []uint32
-				t[seqUid] = append(temp, seqList[i])
-			} else {
-				t[seqUid] = append(value, seqList[i])
-			}
-		}
-		return t
-	}(userID, seqList)
-	lock := sync.Mutex{}
-	var wg sync.WaitGroup
-	wg.Add(len(suffixUserID2SubSeqList))
-	for k, v := range suffixUserID2SubSeqList {
-		go func(suffixUserID string, subSeqList []uint32) {
-			defer wg.Done()
-			unexistSeqList, err := m.DelMsgBySeqListInOneDoc(ctx, suffixUserID, subSeqList)
-			if err != nil {
-				return
-			}
-			lock.Lock()
-			totalUnExistSeqList = append(totalUnExistSeqList, unexistSeqList...)
-			lock.Unlock()
-		}(k, v)
-	}
-	return totalUnExistSeqList, nil
-}
-
-func (m *MsgMongoDriver) DelMsgBySeqListInOneDoc(ctx context.Context, suffixUserID string, seqList []uint32) ([]uint32, error) {
-	seqMsgList, indexList, unexistSeqList, err := m.GetMsgAndIndexBySeqListInOneMongo2(suffixUserID, seqList)
-	if err != nil {
-		return nil, utils.Wrap(err, "")
-	}
-	for i, v := range seqMsgList {
-		if err := m.ReplaceMsgByIndex(suffixUserID, v, operationID, indexList[i]); err != nil {
-			return nil, utils.Wrap(err, "")
-		}
-	}
-	return unexistSeqList, nil
-}
-
-// database
-func (m *MsgMongoDriver) DelMsgLogic(ctx context.Context, uid string, seqList []uint32) error {
-	sortkeys.Uint32s(seqList)
-	seqMsgs, err := d.GetMsgBySeqListMongo2(ctx, uid, seqList)
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-	for _, seqMsg := range seqMsgs {
-		seqMsg.Status = constant.MsgDeleted
-		if err = d.ReplaceMsgBySeq(ctx, uid, seqMsg); err != nil {
-			log.NewError(operationID, utils.GetSelfFuncName(), "ReplaceMsgListBySeq error", err.Error())
-		}
-	}
-	return nil
-}
-
-// model
-func (m *MsgMongoDriver) ReplaceMsgByIndex(ctx context.Context, suffixUserID string, msg *sdkws.MsgData, seqIndex int) error {
-	log.NewInfo(operationID, utils.GetSelfFuncName(), suffixUserID, *msg)
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	s := fmt.Sprintf("msg.%d.msg", seqIndex)
-	log.NewDebug(operationID, utils.GetSelfFuncName(), seqIndex, s)
-	msg.Status = constant.MsgDeleted
+func (m *MsgMongoDriver) UpdateMsgStatusByIndexInOneDoc(ctx context.Context, docID string, msg *sdkws.MsgData, seqIndex int, status int32) error {
+	msg.Status = status
 	bytes, err := proto.Marshal(msg)
 	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), "proto marshal failed ", err.Error(), msg.String())
 		return utils.Wrap(err, "")
 	}
-	updateResult, err := c.UpdateOne(ctx, bson.M{"uid": suffixUserID}, bson.M{"$set": bson.M{s: bytes}})
-	log.NewInfo(operationID, utils.GetSelfFuncName(), updateResult)
+	_, err = m.MsgCollection.UpdateOne(ctx, bson.M{"uid": docID}, bson.M{"$set": bson.M{fmt.Sprintf("msg.%d.msg", seqIndex): bytes}})
 	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), "UpdateOne", err.Error())
 		return utils.Wrap(err, "")
 	}
 	return nil
 }
 
-func (d *db.DataBases) ReplaceMsgBySeq(uid string, msg *sdkws.MsgData, operationID string) error {
-	log.NewInfo(operationID, utils.GetSelfFuncName(), uid, *msg)
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	uid = getSeqUid(uid, msg.Seq)
-	seqIndex := getMsgIndex(msg.Seq)
-	s := fmt.Sprintf("msg.%d.msg", seqIndex)
-	log.NewDebug(operationID, utils.GetSelfFuncName(), seqIndex, s)
-	bytes, err := proto.Marshal(msg)
-	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), "proto marshal", err.Error())
-		return utils.Wrap(err, "")
-	}
-
-	updateResult, err := c.UpdateOne(
-		ctx, bson.M{"uid": uid},
-		bson.M{"$set": bson.M{s: bytes}})
-	log.NewInfo(operationID, utils.GetSelfFuncName(), updateResult)
-	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), "UpdateOne", err.Error())
-		return utils.Wrap(err, "")
-	}
-	return nil
+func (m *MsgMongoDriver) FindOneByDocID(ctx context.Context, docID string) (*table.MsgDocModel, error) {
+	doc := &table.MsgDocModel{}
+	err := m.MsgCollection.FindOne(ctx, bson.M{"uid": docID}).Decode(doc)
+	return doc, err
 }
 
-func (d *db.DataBases) UpdateOneMsgList(msg *UserChat) error {
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	_, err := c.UpdateOne(ctx, bson.M{"uid": msg.UID}, bson.M{"$set": bson.M{"msg": msg.Msg}})
-	return err
-}
-
-func (d *db.DataBases) GetMsgBySeqList(uid string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, err error) {
-	log.NewInfo(operationID, utils.GetSelfFuncName(), uid, seqList)
-	var hasSeqList []uint32
-	singleCount := 0
-	session := d.mgoSession.Clone()
-	if session == nil {
-		return nil, errors.New("session == nil")
-	}
-	defer session.Close()
-	c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
-	m := func(uid string, seqList []uint32) map[string][]uint32 {
-		t := make(map[string][]uint32)
-		for i := 0; i < len(seqList); i++ {
-			seqUid := getSeqUid(uid, seqList[i])
-			if value, ok := t[seqUid]; !ok {
-				var temp []uint32
-				t[seqUid] = append(temp, seqList[i])
-			} else {
-				t[seqUid] = append(value, seqList[i])
-			}
-		}
-		return t
-	}(uid, seqList)
-	sChat := UserChat{}
-	for seqUid, value := range m {
-		if err = c.Find(bson.M{"uid": seqUid}).One(&sChat); err != nil {
-			log.NewError(operationID, "not find seqUid", seqUid, value, uid, seqList, err.Error())
-			continue
-		}
-		singleCount = 0
-		for i := 0; i < len(sChat.Msg); i++ {
-			msg := new(sdkws.MsgData)
-			if err = proto.Unmarshal(sChat.Msg[i].Msg, msg); err != nil {
-				log.NewError(operationID, "Unmarshal err", seqUid, value, uid, seqList, err.Error())
-				return nil, err
-			}
-			if isContainInt32(msg.Seq, value) {
-				seqMsg = append(seqMsg, msg)
-				hasSeqList = append(hasSeqList, msg.Seq)
-				singleCount++
-				if singleCount == len(value) {
-					break
-				}
-			}
-		}
-	}
-	if len(hasSeqList) != len(seqList) {
-		var diff []uint32
-		diff = utils.Difference(hasSeqList, seqList)
-		exceptionMSg := genExceptionMessageBySeqList(diff)
-		seqMsg = append(seqMsg, exceptionMSg...)
-
-	}
-	return seqMsg, nil
-}
-
-// model
-func (d *db.DataBases) GetUserMsgListByIndex(docID string, index int64) (*UserChat, error) {
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	regex := fmt.Sprintf("^%s", docID)
+func (m *MsgMongoDriver) GetMsgsByIndex(ctx context.Context, sourceID string, index int64) (*table.MsgDocModel, error) {
 	findOpts := options.Find().SetLimit(1).SetSkip(index).SetSort(bson.M{"uid": 1})
-	var msgs []UserChat
-	//primitive.Regex{Pattern: regex}
-	cursor, err := c.Find(ctx, bson.M{"uid": primitive.Regex{Pattern: regex}}, findOpts)
+	cursor, err := m.MsgCollection.Find(ctx, bson.M{"uid": primitive.Regex{Pattern: fmt.Sprintf("^%s", sourceID)}}, findOpts)
 	if err != nil {
 		return nil, utils.Wrap(err, "")
 	}
+	var msgs []table.MsgDocModel
 	err = cursor.All(context.Background(), &msgs)
 	if err != nil {
 		return nil, utils.Wrap(err, fmt.Sprintf("cursor is %s", cursor.Current.String()))
 	}
 	if len(msgs) > 0 {
 		return &msgs[0], nil
-	} else {
-		return nil, ErrMsgListNotExist
 	}
+	return nil, ErrMsgListNotExist
 }
 
-// model
-func (d *db.DataBases) DelMongoMsgs(IDList []string) error {
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	_, err := c.DeleteMany(ctx, bson.M{"uid": bson.M{"$in": IDList}})
+func (m *MsgMongoDriver) GetNewestMsg(ctx context.Context, sourceID string) (*table.MsgInfoModel, error) {
+	var msgDocs []table.MsgDocModel
+	cursor, err := m.MsgCollection.Find(ctx, bson.M{"uid": bson.M{"$regex": fmt.Sprintf("^%s", sourceID)}}, options.Find().SetLimit(1).SetSort(bson.M{"uid": -1}))
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	err = cursor.All(ctx, &msgDocs)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	if len(msgDocs) > 0 {
+		if len(msgDocs[0].Msg) > 0 {
+			return &msgDocs[0].Msg[len(msgDocs[0].Msg)-1], nil
+		}
+		return nil, errors.New("len(msgDocs[0].Msg) < 0")
+	}
+	return nil, ErrMsgNotFound
+}
+
+func (m *MsgMongoDriver) GetOldestMsg(ctx context.Context, sourceID string) (*table.MsgInfoModel, error) {
+	var msgDocs []table.MsgDocModel
+	cursor, err := m.MsgCollection.Find(ctx, bson.M{"uid": bson.M{"$regex": fmt.Sprintf("^%s", sourceID)}}, options.Find().SetLimit(1).SetSort(bson.M{"uid": 1}))
+	if err != nil {
+		return nil, err
+	}
+	err = cursor.All(ctx, &msgDocs)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	var oldestMsg table.MsgInfoModel
+	if len(msgDocs) > 0 {
+		for _, v := range msgDocs[0].Msg {
+			if v.SendTime != 0 {
+				oldestMsg = v
+				break
+			}
+		}
+		if len(oldestMsg.Msg) == 0 {
+			if len(msgDocs[0].Msg) > 0 {
+				oldestMsg = msgDocs[0].Msg[0]
+			}
+		}
+		return &oldestMsg, nil
+	}
+	return nil, ErrMsgNotFound
+}
+
+func (m *MsgMongoDriver) Delete(ctx context.Context, docIDs []string) error {
+	_, err := m.MsgCollection.DeleteMany(ctx, bson.M{"uid": bson.M{"$in": docIDs}})
 	return err
 }
 
-// model
-func (d *db.DataBases) ReplaceMsgToBlankByIndex(suffixID string, index int) (replaceMaxSeq uint32, err error) {
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	userChat := &UserChat{}
-	err = c.FindOne(ctx, bson.M{"uid": suffixID}).Decode(&userChat)
-	if err != nil {
-		return 0, err
-	}
-	for i, msg := range userChat.Msg {
-		if i <= index {
-			msgPb := &sdkws.MsgData{}
-			if err = proto.Unmarshal(msg.Msg, msgPb); err != nil {
-				continue
-			}
-			newMsgPb := &sdkws.MsgData{Seq: msgPb.Seq}
-			bytes, err := proto.Marshal(newMsgPb)
-			if err != nil {
-				continue
-			}
-			msg.Msg = bytes
-			msg.SendTime = 0
-			replaceMaxSeq = msgPb.Seq
-		}
-	}
-	_, err = c.UpdateOne(ctx, bson.M{"uid": suffixID}, bson.M{"$set": bson.M{"msg": userChat.Msg}})
-	return replaceMaxSeq, err
-}
-
-func (d *db.DataBases) GetNewestMsg(ID string) (msg *sdkws.MsgData, err error) {
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	regex := fmt.Sprintf("^%s", ID)
-	findOpts := options.Find().SetLimit(1).SetSort(bson.M{"uid": -1})
-	var userChats []UserChat
-	cursor, err := c.Find(ctx, bson.M{"uid": bson.M{"$regex": regex}}, findOpts)
-	if err != nil {
-		return nil, err
-	}
-	err = cursor.All(ctx, &userChats)
-	if err != nil {
-		return nil, utils.Wrap(err, "")
-	}
-	if len(userChats) > 0 {
-		if len(userChats[0].Msg) > 0 {
-			msgPb := &sdkws.MsgData{}
-			err = proto.Unmarshal(userChats[0].Msg[len(userChats[0].Msg)-1].Msg, msgPb)
-			if err != nil {
-				return nil, utils.Wrap(err, "")
-			}
-			return msgPb, nil
-		}
-		return nil, errors.New("len(userChats[0].Msg) < 0")
-	}
-	return nil, nil
-}
-
-func (d *db.DataBases) GetOldestMsg(ID string) (msg *sdkws.MsgData, err error) {
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	regex := fmt.Sprintf("^%s", ID)
-	findOpts := options.Find().SetLimit(1).SetSort(bson.M{"uid": 1})
-	var userChats []UserChat
-	cursor, err := c.Find(ctx, bson.M{"uid": bson.M{"$regex": regex}}, findOpts)
-	if err != nil {
-		return nil, err
-	}
-	err = cursor.All(ctx, &userChats)
-	if err != nil {
-		return nil, utils.Wrap(err, "")
-	}
-	var oldestMsg []byte
-	if len(userChats) > 0 {
-		for _, v := range userChats[0].Msg {
-			if v.SendTime != 0 {
-				oldestMsg = v.Msg
-				break
-			}
-		}
-		if len(oldestMsg) == 0 {
-			oldestMsg = userChats[0].Msg[len(userChats[0].Msg)-1].Msg
-		}
-		msgPb := &sdkws.MsgData{}
-		err = proto.Unmarshal(oldestMsg, msgPb)
-		if err != nil {
-			return nil, utils.Wrap(err, "")
-		}
-		return msgPb, nil
-	}
-	return nil, nil
-}
-
-func (d *db.DataBases) GetMsgBySeqListMongo2(uid string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, err error) {
-	var hasSeqList []uint32
-	singleCount := 0
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-
-	m := func(uid string, seqList []uint32) map[string][]uint32 {
-		t := make(map[string][]uint32)
-		for i := 0; i < len(seqList); i++ {
-			seqUid := getSeqUid(uid, seqList[i])
-			if value, ok := t[seqUid]; !ok {
-				var temp []uint32
-				t[seqUid] = append(temp, seqList[i])
-			} else {
-				t[seqUid] = append(value, seqList[i])
-			}
-		}
-		return t
-	}(uid, seqList)
-	sChat := UserChat{}
-	for seqUid, value := range m {
-		if err = c.FindOne(ctx, bson.M{"uid": seqUid}).Decode(&sChat); err != nil {
-			log.NewError(operationID, "not find seqUid", seqUid, value, uid, seqList, err.Error())
-			continue
-		}
-		singleCount = 0
-		for i := 0; i < len(sChat.Msg); i++ {
-			msg := new(sdkws.MsgData)
-			if err = proto.Unmarshal(sChat.Msg[i].Msg, msg); err != nil {
-				log.NewError(operationID, "Unmarshal err", seqUid, value, uid, seqList, err.Error())
-				return nil, err
-			}
-			if isContainInt32(msg.Seq, value) {
-				seqMsg = append(seqMsg, msg)
-				hasSeqList = append(hasSeqList, msg.Seq)
-				singleCount++
-				if singleCount == len(value) {
-					break
-				}
-			}
-		}
-	}
-	if len(hasSeqList) != len(seqList) {
-		var diff []uint32
-		diff = utils.Difference(hasSeqList, seqList)
-		exceptionMSg := genExceptionMessageBySeqList(diff)
-		seqMsg = append(seqMsg, exceptionMSg...)
-
-	}
-	return seqMsg, nil
-}
-func (d *db.DataBases) GetSuperGroupMsgBySeqListMongo(groupID string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, err error) {
-	var hasSeqList []uint32
-	singleCount := 0
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-
-	m := func(uid string, seqList []uint32) map[string][]uint32 {
-		t := make(map[string][]uint32)
-		for i := 0; i < len(seqList); i++ {
-			seqUid := getSeqUid(uid, seqList[i])
-			if value, ok := t[seqUid]; !ok {
-				var temp []uint32
-				t[seqUid] = append(temp, seqList[i])
-			} else {
-				t[seqUid] = append(value, seqList[i])
-			}
-		}
-		return t
-	}(groupID, seqList)
-	sChat := UserChat{}
-	for seqUid, value := range m {
-		if err = c.FindOne(ctx, bson.M{"uid": seqUid}).Decode(&sChat); err != nil {
-			log.NewError(operationID, "not find seqGroupID", seqUid, value, groupID, seqList, err.Error())
-			continue
-		}
-		singleCount = 0
-		for i := 0; i < len(sChat.Msg); i++ {
-			msg := new(sdkws.MsgData)
-			if err = proto.Unmarshal(sChat.Msg[i].Msg, msg); err != nil {
-				log.NewError(operationID, "Unmarshal err", seqUid, value, groupID, seqList, err.Error())
-				return nil, err
-			}
-			if isContainInt32(msg.Seq, value) {
-				seqMsg = append(seqMsg, msg)
-				hasSeqList = append(hasSeqList, msg.Seq)
-				singleCount++
-				if singleCount == len(value) {
-					break
-				}
-			}
-		}
-	}
-	if len(hasSeqList) != len(seqList) {
-		var diff []uint32
-		diff = utils.Difference(hasSeqList, seqList)
-		exceptionMSg := genExceptionSuperGroupMessageBySeqList(diff, groupID)
-		seqMsg = append(seqMsg, exceptionMSg...)
-
-	}
-	return seqMsg, nil
-}
-
-func (d *db.DataBases) GetMsgAndIndexBySeqListInOneMongo2(suffixUserID string, seqList []uint32, operationID string) (seqMsg []*sdkws.MsgData, indexList []int, unexistSeqList []uint32, err error) {
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	sChat := UserChat{}
-	if err = c.FindOne(ctx, bson.M{"uid": suffixUserID}).Decode(&sChat); err != nil {
-		log.NewError(operationID, "not find seqUid", suffixUserID, err.Error())
-		return nil, nil, nil, utils.Wrap(err, "")
-	}
-	singleCount := 0
-	var hasSeqList []uint32
-	for i := 0; i < len(sChat.Msg); i++ {
-		msg := new(sdkws.MsgData)
-		if err = proto.Unmarshal(sChat.Msg[i].Msg, msg); err != nil {
-			log.NewError(operationID, "Unmarshal err", msg.String(), err.Error())
-			return nil, nil, nil, err
-		}
-		if isContainInt32(msg.Seq, seqList) {
-			indexList = append(indexList, i)
-			seqMsg = append(seqMsg, msg)
-			hasSeqList = append(hasSeqList, msg.Seq)
-			singleCount++
-			if singleCount == len(seqList) {
-				break
-			}
-		}
-	}
-	for _, i := range seqList {
-		if isContainInt32(i, hasSeqList) {
-			continue
-		}
-		unexistSeqList = append(unexistSeqList, i)
-	}
-	return seqMsg, indexList, unexistSeqList, nil
-}
-
-func (d *db.DataBases) SaveUserChatMongo2(uid string, sendTime int64, m *pbMsg.MsgDataToDB) error {
-	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	newTime := getCurrentTimestampByMill()
-	operationID := ""
-	seqUid := getSeqUid(uid, m.MsgData.Seq)
-	filter := bson.M{"uid": seqUid}
-	var err error
-	sMsg := MsgInfo{}
-	sMsg.SendTime = sendTime
-	if sMsg.Msg, err = proto.Marshal(m.MsgData); err != nil {
-		return utils.Wrap(err, "")
-	}
-	err = c.FindOneAndUpdate(ctx, filter, bson.M{"$push": bson.M{"msg": sMsg}}).Err()
-	log.NewWarn(operationID, "get mgoSession cost time", getCurrentTimestampByMill()-newTime)
-	if err != nil {
-		sChat := UserChat{}
-		sChat.UID = seqUid
-		sChat.Msg = append(sChat.Msg, sMsg)
-		if _, err = c.InsertOne(ctx, &sChat); err != nil {
-			log.NewDebug(operationID, "InsertOne failed", filter)
-			return utils.Wrap(err, "")
-		}
-	} else {
-		log.NewDebug(operationID, "FindOneAndUpdate ok", filter)
-	}
-
-	log.NewDebug(operationID, "find mgo uid cost time", getCurrentTimestampByMill()-newTime)
-	return nil
-}
-
-func (d *db.DataBases) SaveUserChat(uid string, sendTime int64, m *pbMsg.MsgDataToDB) error {
-	var seqUid string
-	newTime := getCurrentTimestampByMill()
-	session := d.mgoSession.Clone()
-	if session == nil {
-		return errors.New("session == nil")
-	}
-	defer session.Close()
-	log.NewDebug("", "get mgoSession cost time", getCurrentTimestampByMill()-newTime)
-	c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
-	seqUid = getSeqUid(uid, m.MsgData.Seq)
-	n, err := c.Find(bson.M{"uid": seqUid}).Count()
-	if err != nil {
-		return err
-	}
-	log.NewDebug("", "find mgo uid cost time", getCurrentTimestampByMill()-newTime)
-	sMsg := MsgInfo{}
-	sMsg.SendTime = sendTime
-	if sMsg.Msg, err = proto.Marshal(m.MsgData); err != nil {
-		return err
-	}
-	if n == 0 {
-		sChat := UserChat{}
-		sChat.UID = seqUid
-		sChat.Msg = append(sChat.Msg, sMsg)
-		err = c.Insert(&sChat)
-		if err != nil {
-			return err
-		}
-	} else {
-		err = c.Update(bson.M{"uid": seqUid}, bson.M{"$push": bson.M{"msg": sMsg}})
-		if err != nil {
-			return err
-		}
-	}
-	log.NewDebug("", "insert mgo data cost time", getCurrentTimestampByMill()-newTime)
-	return nil
-}
-
-func (d *db.DataBases) CleanUpUserMsgFromMongo(userID string, operationID string) error {
-	ctx := context.Background()
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-	maxSeq, err := d.GetUserMaxSeq(userID)
-	if err == redis.Nil {
-		return nil
-	}
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-
-	seqUsers := getSeqUserIDList(userID, uint32(maxSeq))
-	log.Error(operationID, "getSeqUserIDList", seqUsers)
-	_, err = c.DeleteMany(ctx, bson.M{"uid": bson.M{"$in": seqUsers}})
-	if err == mongo.ErrNoDocuments {
-		return nil
-	}
-	return utils.Wrap(err, "")
+func (m *MsgMongoDriver) UpdateOneDoc(ctx context.Context, msg *table.MsgDocModel) error {
+	_, err := m.MsgCollection.UpdateOne(ctx, bson.M{"uid": msg.DocID}, bson.M{"$set": bson.M{"msg": msg.Msg}})
+	return err
 }

pkg/common/db/unrelation/super_group.go

@@ -127,7 +127,7 @@ type SuperGroupMongoDriver struct {
 //}
 
 func (s *SuperGroupMongoDriver) CreateSuperGroup(ctx context.Context, groupID string, initMemberIDs []string, tx ...any) error {
-	ctx = s.getTxCtx(ctx, tx)
+	ctx = getTxCtx(ctx, tx)
 	_, err := s.superGroupCollection.InsertOne(ctx, &unrelation.SuperGroupModel{
 		GroupID:   groupID,
 		MemberIDs: initMemberIDs,
@@ -147,7 +147,7 @@ func (s *SuperGroupMongoDriver) CreateSuperGroup(ctx context.Context, groupID st
 }
 
 func (s *SuperGroupMongoDriver) TakeSuperGroup(ctx context.Context, groupID string, tx ...any) (group *unrelation.SuperGroupModel, err error) {
-	ctx = s.getTxCtx(ctx, tx)
+	ctx = getTxCtx(ctx, tx)
 	if err := s.superGroupCollection.FindOne(ctx, bson.M{"group_id": groupID}).Decode(&group); err != nil {
 		return nil, utils.Wrap(err, "")
 	}
@@ -155,14 +155,15 @@ func (s *SuperGroupMongoDriver) TakeSuperGroup(ctx context.Context, groupID stri
 }
 
 func (s *SuperGroupMongoDriver) FindSuperGroup(ctx context.Context, groupIDs []string, tx ...any) (groups []*unrelation.SuperGroupModel, err error) {
-	ctx = s.getTxCtx(ctx, tx)
+	ctx = getTxCtx(ctx, tx)
 	cursor, err := s.superGroupCollection.Find(ctx, bson.M{"group_id": bson.M{
 		"$in": groupIDs,
 	}})
 	if err != nil {
-		return nil, utils.Wrap(err, "")
+		return nil, err
 	}
 	defer cursor.Close(ctx)
+
 	if err := cursor.All(ctx, &groups); err != nil {
 		return nil, utils.Wrap(err, "")
 	}
@@ -170,7 +171,7 @@ func (s *SuperGroupMongoDriver) FindSuperGroup(ctx context.Context, groupIDs []s
 }
 
 func (s *SuperGroupMongoDriver) AddUserToSuperGroup(ctx context.Context, groupID string, userIDs []string, tx ...any) error {
-	ctx = s.getTxCtx(ctx, tx)
+	ctx = getTxCtx(ctx, tx)
 	opts := options.Session().SetDefaultReadConcern(readconcern.Majority())
 	return s.MgoDB.Client().UseSessionWithOptions(ctx, opts, func(sCtx mongo.SessionContext) error {
 		_, err := s.superGroupCollection.UpdateOne(sCtx, bson.M{"group_id": groupID}, bson.M{"$addToSet": bson.M{"member_id_list": bson.M{"$each": userIDs}}})
@@ -194,7 +195,7 @@ func (s *SuperGroupMongoDriver) AddUserToSuperGroup(ctx context.Context, groupID
 }
 
 func (s *SuperGroupMongoDriver) RemoverUserFromSuperGroup(ctx context.Context, groupID string, userIDs []string, tx ...any) error {
-	ctx = s.getTxCtx(ctx, tx)
+	ctx = getTxCtx(ctx, tx)
 	opts := options.Session().SetDefaultReadConcern(readconcern.Majority())
 	return s.MgoDB.Client().UseSessionWithOptions(ctx, opts, func(sCtx mongo.SessionContext) error {
 		_, err := s.superGroupCollection.UpdateOne(sCtx, bson.M{"group_id": groupID}, bson.M{"$pull": bson.M{"member_id_list": bson.M{"$in": userIDs}}})
@@ -212,14 +213,14 @@ func (s *SuperGroupMongoDriver) RemoverUserFromSuperGroup(ctx context.Context, g
 }
 
 func (s *SuperGroupMongoDriver) GetSuperGroupByUserID(ctx context.Context, userID string, tx ...any) (*unrelation.UserToSuperGroupModel, error) {
-	ctx = s.getTxCtx(ctx, tx)
+	ctx = getTxCtx(ctx, tx)
 	var user unrelation.UserToSuperGroupModel
 	err := s.userToSuperGroupCollection.FindOne(ctx, bson.M{"user_id": userID}).Decode(&user)
 	return &user, utils.Wrap(err, "")
 }
 
 func (s *SuperGroupMongoDriver) DeleteSuperGroup(ctx context.Context, groupID string, tx ...any) error {
-	ctx = s.getTxCtx(ctx, tx)
+	ctx = getTxCtx(ctx, tx)
 	group, err := s.TakeSuperGroup(ctx, groupID, tx...)
 	if err != nil {
 		return err
@@ -231,7 +232,7 @@ func (s *SuperGroupMongoDriver) DeleteSuperGroup(ctx context.Context, groupID st
 }
 
 //func (s *SuperGroupMongoDriver) DeleteSuperGroup(ctx context.Context, groupID string, tx ...any) error {
-//	ctx = s.getTxCtx(ctx, tx)
+//	ctx = getTxCtx(ctx, tx)
 //	opts := options.Session().SetDefaultReadConcern(readconcern.Majority())
 //	return s.MgoDB.Client().UseSessionWithOptions(ctx, opts, func(sCtx mongo.SessionContext) error {
 //		superGroup := &unrelation.SuperGroupModel{}
@@ -249,7 +250,7 @@ func (s *SuperGroupMongoDriver) DeleteSuperGroup(ctx context.Context, groupID st
 //}
 
 func (s *SuperGroupMongoDriver) RemoveGroupFromUser(ctx context.Context, groupID string, userIDs []string, tx ...any) error {
-	ctx = s.getTxCtx(ctx, tx)
+	ctx = getTxCtx(ctx, tx)
 	_, err := s.userToSuperGroupCollection.UpdateOne(ctx, bson.M{"user_id": bson.M{"$in": userIDs}}, bson.M{"$pull": bson.M{"group_id_list": groupID}})
 	return utils.Wrap(err, "")
 }