feat: use robot to migrate code

Signed-off-by: kubbot & kubecub <3293172751ysy@gmail.com>
2026-05-05 01:25:58 +08:00 · 2023-06-30 09:45:02 +08:00
parent 2d41819008
commit 539e0fdfb6
529 changed files with 64588 additions and 54413 deletions
@@ -0,0 +1,153 @@
+package unrelation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	unRelationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"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"
+)
+
+type ExtendMsgSetMongoDriver struct {
+	mgoDB                  *mongo.Database
+	ExtendMsgSetCollection *mongo.Collection
+}
+
+func NewExtendMsgSetMongoDriver(mgoDB *mongo.Database) unRelationTb.ExtendMsgSetModelInterface {
+	return &ExtendMsgSetMongoDriver{mgoDB: mgoDB, ExtendMsgSetCollection: mgoDB.Collection(unRelationTb.CExtendMsgSet)}
+}
+
+func (e *ExtendMsgSetMongoDriver) CreateExtendMsgSet(ctx context.Context, set *unRelationTb.ExtendMsgSetModel) error {
+	_, err := e.ExtendMsgSetCollection.InsertOne(ctx, set)
+	return err
+}
+
+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 {
+		if opts.ExcludeExtendMsgs {
+			findOpts = &options.FindOptions{}
+			findOpts.SetProjection(bson.M{"extend_msgs": 0})
+		}
+	}
+	cursor, err := e.ExtendMsgSetCollection.Find(ctx, bson.M{"doc_id": primitive.Regex{Pattern: regex}}, findOpts)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	err = cursor.All(ctx, &sets)
+	if err != nil {
+		return nil, utils.Wrap(err, fmt.Sprintf("cursor is %s", cursor.Current.String()))
+	}
+	return sets, nil
+}
+
+func (e *ExtendMsgSetMongoDriver) GetExtendMsgSet(ctx context.Context, conversationID 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
+	find := bson.M{"source_id": primitive.Regex{Pattern: fmt.Sprintf("^%s", conversationID)}, "session_type": sessionType}
+	if maxMsgUpdateTime > 0 {
+		find["max_msg_update_time"] = maxMsgUpdateTime
+	}
+	result, err := e.ExtendMsgSetCollection.Find(ctx, find, findOpts)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	var setList []unRelationTb.ExtendMsgSetModel
+	if err := result.All(ctx, &setList); err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	if len(setList) == 0 {
+		return nil, nil
+	}
+	return &setList[0], nil
+}
+
+// first modify msg
+func (e *ExtendMsgSetMongoDriver) InsertExtendMsg(ctx context.Context, conversationID string, sessionType int32, msg *unRelationTb.ExtendMsgModel) error {
+	set, err := e.GetExtendMsgSet(ctx, conversationID, sessionType, 0)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	if set == nil || set.ExtendMsgNum >= set.GetExtendMsgMaxNum() {
+		var index int32
+		if set != nil {
+			index = set.SplitConversationIDAndGetIndex()
+		}
+		err = e.CreateExtendMsgSet(ctx, &unRelationTb.ExtendMsgSetModel{
+			ConversationID:   set.GetConversationID(conversationID, index),
+			SessionType:      sessionType,
+			ExtendMsgs:       map[string]unRelationTb.ExtendMsgModel{msg.ClientMsgID: *msg},
+			ExtendMsgNum:     1,
+			CreateTime:       msg.MsgFirstModifyTime,
+			MaxMsgUpdateTime: msg.MsgFirstModifyTime,
+		})
+	} else {
+		_, err = e.ExtendMsgSetCollection.UpdateOne(ctx, bson.M{"conversation_id": set.ConversationID, "session_type": sessionType}, bson.M{"$set": bson.M{"max_msg_update_time": msg.MsgFirstModifyTime, "$inc": bson.M{"extend_msg_num": 1}, fmt.Sprintf("extend_msgs.%s", msg.ClientMsgID): msg}})
+	}
+	return utils.Wrap(err, "")
+}
+
+// insert or update
+func (e *ExtendMsgSetMongoDriver) InsertOrUpdateReactionExtendMsgSet(ctx context.Context, conversationID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*unRelationTb.KeyValueModel) error {
+	var updateBson = bson.M{}
+	for _, v := range reactionExtensionList {
+		updateBson[fmt.Sprintf("extend_msgs.%s.%s", clientMsgID, v.TypeKey)] = v
+	}
+	upsert := true
+	opt := &options.UpdateOptions{
+		Upsert: &upsert,
+	}
+	set, err := e.GetExtendMsgSet(ctx, conversationID, sessionType, msgFirstModifyTime)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	if set == nil {
+		return errors.New(fmt.Sprintf("conversationID %s has no set", conversationID))
+	}
+	_, err = e.ExtendMsgSetCollection.UpdateOne(ctx, bson.M{"source_id": set.ConversationID, "session_type": sessionType}, bson.M{"$set": updateBson}, opt)
+	return utils.Wrap(err, "")
+}
+
+// delete TypeKey
+func (e *ExtendMsgSetMongoDriver) DeleteReactionExtendMsgSet(ctx context.Context, conversationID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*unRelationTb.KeyValueModel) error {
+	var updateBson = bson.M{}
+	for _, v := range reactionExtensionList {
+		updateBson[fmt.Sprintf("extend_msgs.%s.%s", clientMsgID, v.TypeKey)] = ""
+	}
+	set, err := e.GetExtendMsgSet(ctx, conversationID, sessionType, msgFirstModifyTime)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	if set == nil {
+		return errors.New(fmt.Sprintf("conversationID %s has no set", conversationID))
+	}
+	_, err = e.ExtendMsgSetCollection.UpdateOne(ctx, bson.M{"source_id": set.ConversationID, "session_type": sessionType}, bson.M{"$unset": updateBson})
+	return err
+}
+
+func (e *ExtendMsgSetMongoDriver) TakeExtendMsg(ctx context.Context, conversationID 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", conversationID)
+	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 []unRelationTb.ExtendMsgSetModel
+	if err := result.All(ctx, &setList); err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	if len(setList) == 0 {
+		return nil, utils.Wrap(errors.New("GetExtendMsg failed, len(setList) == 0"), "")
+	}
+	if v, ok := setList[0].ExtendMsgs[clientMsgID]; ok {
+		return &v, nil
+	}
+	return nil, errors.New(fmt.Sprintf("cant find client msg id: %s", clientMsgID))
+}
@@ -0,0 +1,114 @@
+package unrelation
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mw/specialerror"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"go.mongodb.org/mongo-driver/x/bsonx"
+)
+
+type Mongo struct {
+	db *mongo.Client
+}
+
+func NewMongo() (*Mongo, error) {
+	specialerror.AddReplace(mongo.ErrNoDocuments, errs.ErrRecordNotFound)
+	uri := "mongodb://sample.host:27017/?maxPoolSize=20&w=majority"
+	if config.Config.Mongo.Uri != "" {
+		// example: mongodb://$user:$password@mongo1.mongo:27017,mongo2.mongo:27017,mongo3.mongo:27017/$DBDatabase/?replicaSet=rs0&readPreference=secondary&authSource=admin&maxPoolSize=$DBMaxPoolSize
+		uri = config.Config.Mongo.Uri
+	} else {
+		//mongodb://mongodb1.example.com:27317,mongodb2.example.com:27017/?replicaSet=mySet&authSource=authDB
+		mongodbHosts := ""
+		for i, v := range config.Config.Mongo.Address {
+			if i == len(config.Config.Mongo.Address)-1 {
+				mongodbHosts += v
+			} else {
+				mongodbHosts += v + ","
+			}
+		}
+		if config.Config.Mongo.Password != "" && config.Config.Mongo.Username != "" {
+			uri = fmt.Sprintf("mongodb://%s:%s@%s/%s?maxPoolSize=%d&authSource=admin",
+				config.Config.Mongo.Username, config.Config.Mongo.Password, mongodbHosts,
+				config.Config.Mongo.Database, config.Config.Mongo.MaxPoolSize)
+		} else {
+			uri = fmt.Sprintf("mongodb://%s/%s/?maxPoolSize=%d&authSource=admin",
+				mongodbHosts, config.Config.Mongo.Database,
+				config.Config.Mongo.MaxPoolSize)
+		}
+	}
+	fmt.Println("mongo:", uri)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*60)
+	defer cancel()
+	mongoClient, err := mongo.Connect(ctx, options.Client().ApplyURI(uri))
+	if err != nil {
+		return nil, err
+	}
+	return &Mongo{db: mongoClient}, nil
+}
+
+func (m *Mongo) GetClient() *mongo.Client {
+	return m.db
+}
+
+func (m *Mongo) GetDatabase() *mongo.Database {
+	return m.db.Database(config.Config.Mongo.Database)
+}
+
+func (m *Mongo) CreateMsgIndex() error {
+	return m.createMongoIndex(unrelation.Msg, true, "doc_id")
+}
+
+func (m *Mongo) CreateSuperGroupIndex() error {
+	if err := m.createMongoIndex(unrelation.CSuperGroup, true, "group_id"); err != nil {
+		return err
+	}
+	if err := m.createMongoIndex(unrelation.CUserToSuperGroup, true, "user_id"); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m *Mongo) CreateExtendMsgSetIndex() error {
+	return m.createMongoIndex(unrelation.CExtendMsgSet, true, "-create_time", "work_moment_id")
+}
+
+func (m *Mongo) createMongoIndex(collection string, isUnique bool, keys ...string) error {
+	db := m.db.Database(config.Config.Mongo.Database).Collection(collection)
+	opts := options.CreateIndexes().SetMaxTime(10 * time.Second)
+	indexView := db.Indexes()
+	keysDoc := bsonx.Doc{}
+	// create composite indexes
+	for _, key := range keys {
+		if strings.HasPrefix(key, "-") {
+			keysDoc = keysDoc.Append(strings.TrimLeft(key, "-"), bsonx.Int32(-1))
+		} else {
+			keysDoc = keysDoc.Append(key, bsonx.Int32(1))
+		}
+	}
+	// create index
+	index := mongo.IndexModel{
+		Keys: keysDoc,
+	}
+	if isUnique {
+		index.Options = options.Index().SetUnique(true)
+	}
+	result, err := indexView.CreateOne(
+		context.Background(),
+		index,
+		opts,
+	)
+	if err != nil {
+		return utils.Wrap(err, result)
+	}
+	return nil
+}
@@ -0,0 +1,310 @@
+package unrelation
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+
+	table "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"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"
+	"google.golang.org/protobuf/proto"
+)
+
+var ErrMsgListNotExist = errors.New("user not have msg in mongoDB")
+
+type MsgMongoDriver struct {
+	MsgCollection *mongo.Collection
+	model         table.MsgDocModel
+}
+
+func NewMsgMongoDriver(database *mongo.Database) table.MsgDocModelInterface {
+	collection := database.Collection(table.MsgDocModel{}.TableName())
+	return &MsgMongoDriver{MsgCollection: collection}
+}
+
+func (m *MsgMongoDriver) PushMsgsToDoc(ctx context.Context, docID string, msgsToMongo []table.MsgInfoModel) error {
+	return m.MsgCollection.FindOneAndUpdate(ctx, bson.M{"doc_id": docID}, bson.M{"$push": bson.M{"msgs": bson.M{"$each": msgsToMongo}}}).Err()
+}
+
+func (m *MsgMongoDriver) Create(ctx context.Context, model *table.MsgDocModel) error {
+	_, err := m.MsgCollection.InsertOne(ctx, model)
+	return err
+}
+
+func (m *MsgMongoDriver) UpdateMsg(ctx context.Context, docID string, index int64, key string, value any) (*mongo.UpdateResult, error) {
+	var field string
+	if key == "" {
+		field = fmt.Sprintf("msgs.%d", index)
+	} else {
+		field = fmt.Sprintf("msgs.%d.%s", index, key)
+	}
+	filter := bson.M{"doc_id": docID}
+	update := bson.M{"$set": bson.M{field: value}}
+	res, err := m.MsgCollection.UpdateOne(ctx, filter, update)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	return res, nil
+}
+
+// PushUnique value must slice
+func (m *MsgMongoDriver) PushUnique(ctx context.Context, docID string, index int64, key string, value any) (*mongo.UpdateResult, error) {
+	var field string
+	if key == "" {
+		field = fmt.Sprintf("msgs.%d", index)
+	} else {
+		field = fmt.Sprintf("msgs.%d.%s", index, key)
+	}
+	filter := bson.M{"doc_id": docID}
+	update := bson.M{
+		"$addToSet": bson.M{
+			field: bson.M{"$each": value},
+		},
+	}
+	res, err := m.MsgCollection.UpdateOne(ctx, filter, update)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	return res, nil
+}
+
+func (m *MsgMongoDriver) UpdateMsgContent(ctx context.Context, docID string, index int64, msg []byte) error {
+	_, err := m.MsgCollection.UpdateOne(ctx, bson.M{"doc_id": docID}, bson.M{"$set": bson.M{fmt.Sprintf("msgs.%d.msg", index): msg}})
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	return nil
+}
+
+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 {
+		return utils.Wrap(err, "")
+	}
+	_, err = m.MsgCollection.UpdateOne(ctx, bson.M{"doc_id": docID}, bson.M{"$set": bson.M{fmt.Sprintf("msgs.%d.msg", seqIndex): bytes}})
+	if err != nil {
+		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{"doc_id": docID}).Decode(doc)
+	return doc, err
+}
+
+func (m *MsgMongoDriver) GetMsgDocModelByIndex(ctx context.Context, conversationID string, index, sort int64) (*table.MsgDocModel, error) {
+	if sort != 1 && sort != -1 {
+		return nil, errs.ErrArgs.Wrap("mongo sort must be 1 or -1")
+	}
+	findOpts := options.Find().SetLimit(1).SetSkip(index).SetSort(bson.M{"doc_id": sort})
+	cursor, err := m.MsgCollection.Find(ctx, bson.M{"doc_id": primitive.Regex{Pattern: fmt.Sprintf("^%s:", conversationID)}}, findOpts)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	var msgs []table.MsgDocModel
+	err = cursor.All(ctx, &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
+	}
+	return nil, ErrMsgListNotExist
+}
+
+func (m *MsgMongoDriver) GetNewestMsg(ctx context.Context, conversationID string) (*table.MsgInfoModel, error) {
+	var skip int64 = 0
+	for {
+		msgDocModel, err := m.GetMsgDocModelByIndex(ctx, conversationID, skip, -1)
+		if err != nil {
+			return nil, err
+		}
+		for i := len(msgDocModel.Msg) - 1; i >= 0; i-- {
+			if msgDocModel.Msg[i].Msg != nil {
+				return msgDocModel.Msg[i], nil
+			}
+		}
+		skip++
+	}
+}
+
+func (m *MsgMongoDriver) GetOldestMsg(ctx context.Context, conversationID string) (*table.MsgInfoModel, error) {
+	var skip int64 = 0
+	for {
+		msgDocModel, err := m.GetMsgDocModelByIndex(ctx, conversationID, skip, 1)
+		if err != nil {
+			return nil, err
+		}
+		for i, v := range msgDocModel.Msg {
+			if v.Msg != nil {
+				return msgDocModel.Msg[i], nil
+			}
+		}
+		skip++
+	}
+}
+
+func (m *MsgMongoDriver) DeleteMsgsInOneDocByIndex(ctx context.Context, docID string, indexes []int) error {
+	updates := bson.M{
+		"$set": bson.M{},
+	}
+	for _, index := range indexes {
+		updates["$set"].(bson.M)[fmt.Sprintf("msgs.%d", index)] = bson.M{
+			"msg": nil,
+		}
+	}
+	_, err := m.MsgCollection.UpdateMany(ctx, bson.M{"doc_id": docID}, updates)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	return nil
+}
+
+func (m *MsgMongoDriver) DeleteDocs(ctx context.Context, docIDs []string) error {
+	if docIDs == nil {
+		return nil
+	}
+	_, err := m.MsgCollection.DeleteMany(ctx, bson.M{"doc_id": bson.M{"$in": docIDs}})
+	return err
+}
+
+func (m *MsgMongoDriver) GetMsgBySeqIndexIn1Doc(ctx context.Context, userID string, docID string, seqs []int64) (msgs []*table.MsgInfoModel, err error) {
+	indexs := make([]int64, 0, len(seqs))
+	for _, seq := range seqs {
+		indexs = append(indexs, m.model.GetMsgIndex(seq))
+	}
+	pipeline := mongo.Pipeline{
+		{
+			{"$match", bson.D{
+				{"doc_id", docID},
+			}},
+		},
+		{
+			{"$project", bson.D{
+				{"_id", 0},
+				{"doc_id", 1},
+				{"msgs", bson.D{
+					{"$map", bson.D{
+						{"input", indexs},
+						{"as", "index"},
+						{"in", bson.D{
+							{"$let", bson.D{
+								{"vars", bson.D{
+									{"currentMsg", bson.D{
+										{"$arrayElemAt", []string{"$msgs", "$$index"}},
+									}},
+								}},
+								{"in", bson.D{
+									{"$cond", bson.D{
+										{"if", bson.D{
+											{"$in", []string{userID, "$$currentMsg.del_list"}},
+										}},
+										{"then", nil},
+										{"else", "$$currentMsg"},
+									}},
+								}},
+							}},
+						}},
+					}},
+				}},
+			}},
+		},
+		{
+			{"$project", bson.D{
+				{"msgs.del_list", 0},
+			}},
+		},
+	}
+	cur, err := m.MsgCollection.Aggregate(ctx, pipeline)
+	if err != nil {
+		return nil, errs.Wrap(err)
+	}
+	defer cur.Close(ctx)
+	var msgDocModel []table.MsgDocModel
+	if err := cur.All(ctx, &msgDocModel); err != nil {
+		return nil, errs.Wrap(err)
+	}
+	if len(msgDocModel) == 0 {
+		return nil, errs.Wrap(mongo.ErrNoDocuments)
+	}
+	msgs = make([]*table.MsgInfoModel, 0, len(msgDocModel[0].Msg))
+	for i := range msgDocModel[0].Msg {
+		msg := msgDocModel[0].Msg[i]
+		if msg == nil || msg.Msg == nil {
+			continue
+		}
+		if msg.Revoke != nil {
+			revokeContent := sdkws.MessageRevokedContent{
+				RevokerID:                   msg.Revoke.ID,
+				RevokerRole:                 msg.Revoke.Role,
+				ClientMsgID:                 msg.Msg.ClientMsgID,
+				RevokerNickname:             msg.Revoke.Nickname,
+				RevokeTime:                  msg.Revoke.Time,
+				SourceMessageSendTime:       msg.Msg.SendTime,
+				SourceMessageSendID:         msg.Msg.SendID,
+				SourceMessageSenderNickname: msg.Msg.SenderNickname,
+				SessionType:                 msg.Msg.SessionType,
+				Seq:                         msg.Msg.Seq,
+				Ex:                          msg.Msg.Ex,
+			}
+			data, err := json.Marshal(&revokeContent)
+			if err != nil {
+				return nil, err
+			}
+			elem := sdkws.NotificationElem{
+				Detail: string(data),
+			}
+			content, err := json.Marshal(&elem)
+			if err != nil {
+				return nil, err
+			}
+			msg.Msg.ContentType = constant.MsgRevokeNotification
+			msg.Msg.Content = string(content)
+		}
+		msgs = append(msgs, msg)
+	}
+	return msgs, nil
+}
+
+func (m *MsgMongoDriver) IsExistDocID(ctx context.Context, docID string) (bool, error) {
+	count, err := m.MsgCollection.CountDocuments(ctx, bson.M{"doc_id": docID})
+	if err != nil {
+		return false, errs.Wrap(err)
+	}
+	return count > 0, nil
+}
+
+func (m *MsgMongoDriver) MarkSingleChatMsgsAsRead(ctx context.Context, userID string, docID string, indexes []int64) error {
+	updates := []mongo.WriteModel{}
+	for _, index := range indexes {
+		filter := bson.M{
+			"doc_id": docID,
+			fmt.Sprintf("msgs.%d.msg.send_id", index): bson.M{
+				"$ne": userID,
+			},
+		}
+		update := bson.M{
+			"$set": bson.M{
+				fmt.Sprintf("msgs.%d.is_read", index): true,
+			},
+		}
+		updateModel := mongo.NewUpdateManyModel().
+			SetFilter(filter).
+			SetUpdate(update)
+		updates = append(updates, updateModel)
+	}
+	_, err := m.MsgCollection.BulkWrite(ctx, updates)
+	return err
+}
@@ -0,0 +1,111 @@
+package unrelation
+
+import (
+	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+func NewSuperGroupMongoDriver(database *mongo.Database) unrelation.SuperGroupModelInterface {
+	return &SuperGroupMongoDriver{superGroupCollection: database.Collection(unrelation.CSuperGroup), userToSuperGroupCollection: database.Collection(unrelation.CUserToSuperGroup)}
+}
+
+type SuperGroupMongoDriver struct {
+	superGroupCollection       *mongo.Collection
+	userToSuperGroupCollection *mongo.Collection
+}
+
+func (s *SuperGroupMongoDriver) CreateSuperGroup(ctx context.Context, groupID string, initMemberIDs []string) error {
+	_, err := s.superGroupCollection.InsertOne(ctx, &unrelation.SuperGroupModel{
+		GroupID:   groupID,
+		MemberIDs: initMemberIDs,
+	})
+	if err != nil {
+		return err
+	}
+	for _, userID := range initMemberIDs {
+		_, err = s.userToSuperGroupCollection.UpdateOne(ctx, bson.M{"user_id": userID}, bson.M{"$addToSet": bson.M{"group_id_list": groupID}}, &options.UpdateOptions{
+			Upsert: utils.ToPtr(true),
+		})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *SuperGroupMongoDriver) TakeSuperGroup(ctx context.Context, groupID string) (group *unrelation.SuperGroupModel, err error) {
+	if err := s.superGroupCollection.FindOne(ctx, bson.M{"group_id": groupID}).Decode(&group); err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	return group, nil
+}
+
+func (s *SuperGroupMongoDriver) FindSuperGroup(ctx context.Context, groupIDs []string) (groups []*unrelation.SuperGroupModel, err error) {
+	cursor, err := s.superGroupCollection.Find(ctx, bson.M{"group_id": bson.M{
+		"$in": groupIDs,
+	}})
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+	if err := cursor.All(ctx, &groups); err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	return groups, nil
+}
+
+func (s *SuperGroupMongoDriver) AddUserToSuperGroup(ctx context.Context, groupID string, userIDs []string) error {
+	_, err := s.superGroupCollection.UpdateOne(ctx, bson.M{"group_id": groupID}, bson.M{"$addToSet": bson.M{"member_id_list": bson.M{"$each": userIDs}}})
+	if err != nil {
+		return err
+	}
+	upsert := true
+	opts := &options.UpdateOptions{
+		Upsert: &upsert,
+	}
+	for _, userID := range userIDs {
+		_, err = s.userToSuperGroupCollection.UpdateOne(ctx, bson.M{"user_id": userID}, bson.M{"$addToSet": bson.M{"group_id_list": groupID}}, opts)
+		if err != nil {
+			return utils.Wrap(err, "transaction failed")
+		}
+	}
+	return nil
+}
+
+func (s *SuperGroupMongoDriver) RemoverUserFromSuperGroup(ctx context.Context, groupID string, userIDs []string) error {
+	_, err := s.superGroupCollection.UpdateOne(ctx, bson.M{"group_id": groupID}, bson.M{"$pull": bson.M{"member_id_list": bson.M{"$in": userIDs}}})
+	if err != nil {
+		return err
+	}
+	err = s.RemoveGroupFromUser(ctx, groupID, userIDs)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *SuperGroupMongoDriver) GetSuperGroupByUserID(ctx context.Context, userID string) (*unrelation.UserToSuperGroupModel, error) {
+	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) error {
+	group, err := s.TakeSuperGroup(ctx, groupID)
+	if err != nil {
+		return err
+	}
+	if _, err := s.superGroupCollection.DeleteOne(ctx, bson.M{"group_id": groupID}); err != nil {
+		return utils.Wrap(err, "")
+	}
+	return s.RemoveGroupFromUser(ctx, groupID, group.MemberIDs)
+}
+
+func (s *SuperGroupMongoDriver) RemoveGroupFromUser(ctx context.Context, groupID string, userIDs []string) error {
+	_, 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, "")
+}