From 4e10b361ed9c518af12b740dae70295847d2b356 Mon Sep 17 00:00:00 2001
From: withchao <993506633@qq.com>
Date: Sun, 29 Jan 2023 11:22:37 +0800
Subject: [PATCH] 1

---
 internal/rpc/group/group.go                   |  3 ++
 pkg/common/db/controller/group.go             | 39 +++++++++++++------
 .../db/relation/group_member_model_k.go       | 36 +++++++++--------
 3 files changed, 50 insertions(+), 28 deletions(-)

diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go
index 19891682e..3c0129f4e 100644
--- a/internal/rpc/group/group.go
+++ b/internal/rpc/group/group.go
@@ -166,6 +166,9 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if err := callbackBeforeCreateGroup(ctx, req); err != nil {
 		return nil, err
 	}
+	var groupInfo relation.Group
+	utils.CopyStructFields(&groupInfo, req.GroupInfo)
+
 	groupInfo, err := (&cp.PBGroup{req.GroupInfo}).Convert()
 	groupInfo.GroupID = genGroupID(ctx, req.GroupInfo.GroupID)
 	if req.GroupInfo.GroupType != constant.SuperGroup {
diff --git a/pkg/common/db/controller/group.go b/pkg/common/db/controller/group.go
index 677a6ce88..b03da25df 100644
--- a/pkg/common/db/controller/group.go
+++ b/pkg/common/db/controller/group.go
@@ -60,16 +60,21 @@ type DataBase interface {
 }
 
 type GroupDataBase struct {
-	sqlDB   *relation.Group
-	cache   *cache.GroupCache
-	mongoDB *unrelation.SuperGroupMgoDB
+	groupDB       *relation.Group
+	groupMemberDB *relation.GroupMember
+	cache         *cache.GroupCache
+	db            *gorm.DB
+	mongoDB       *unrelation.SuperGroupMgoDB
 }
 
 func newGroupDatabase(db *gorm.DB, rdb redis.UniversalClient, mgoDB *mongo.Database) DataBase {
-	sqlDB := relation.NewGroupDB(db)
+	group := relation.NewGroupDB(db)
+	groupMember := relation.NewGroupMemberDB(db)
 	database := &GroupDataBase{
-		sqlDB: sqlDB,
-		cache: cache.NewGroupCache(rdb, sqlDB, rockscache.Options{
+		groupDB:       group,
+		groupMemberDB: groupMember,
+		db:            db,
+		cache: cache.NewGroupCache(rdb, group, rockscache.Options{
 			RandomExpireAdjustment: 0.2,
 			DisableCacheRead:       false,
 			DisableCacheDelete:     false,
@@ -85,12 +90,12 @@ func (g *GroupDataBase) FindGroupsByID(ctx context.Context, groupIDs []string) (
 }
 
 func (g *GroupDataBase) CreateGroup(ctx context.Context, groups []*relation.Group) error {
-	return g.sqlDB.Create(ctx, groups)
+	return g.groupDB.Create(ctx, groups)
 }
 
 func (g *GroupDataBase) DeleteGroupByIDs(ctx context.Context, groupIDs []string) error {
-	return g.sqlDB.DB.Transaction(func(tx *gorm.DB) error {
-		if err := g.sqlDB.Delete(ctx, groupIDs, tx); err != nil {
+	return g.groupDB.DB.Transaction(func(tx *gorm.DB) error {
+		if err := g.groupDB.Delete(ctx, groupIDs, tx); err != nil {
 			return err
 		}
 		if err := g.cache.DelGroupsInfoFromCache(ctx, groupIDs); err != nil {
@@ -105,8 +110,8 @@ func (g *GroupDataBase) TakeGroupByID(ctx context.Context, groupID string) (grou
 }
 
 func (g *GroupDataBase) Update(ctx context.Context, groups []*relation.Group) error {
-	return g.sqlDB.DB.Transaction(func(tx *gorm.DB) error {
-		if err := g.sqlDB.Update(ctx, groups, tx); err != nil {
+	return g.groupDB.DB.Transaction(func(tx *gorm.DB) error {
+		if err := g.groupDB.Update(ctx, groups, tx); err != nil {
 			return err
 		}
 		var groupIDs []string
@@ -123,3 +128,15 @@ func (g *GroupDataBase) Update(ctx context.Context, groups []*relation.Group) er
 func (g *GroupDataBase) GetSuperGroupByID(ctx context.Context, groupID string) (superGroup *unrelation.SuperGroup, err error) {
 	return g.mongoDB.GetSuperGroup(ctx, groupID)
 }
+
+func (g *GroupDataBase) CreateGroupAndMember(ctx context.Context, groups []*relation.Group, groupMember []*relation.GroupMember) error {
+	return g.db.Transaction(func(tx *gorm.DB) error {
+		if err := g.groupDB.Create(ctx, groups, tx); err != nil {
+			return err
+		}
+		if err := g.groupMemberDB.Create(ctx, groupMember, tx); err != nil {
+			return err
+		}
+		return nil
+	})
+}
diff --git a/pkg/common/db/relation/group_member_model_k.go b/pkg/common/db/relation/group_member_model_k.go
index 405c8eff0..08fcbed7f 100644
--- a/pkg/common/db/relation/group_member_model_k.go
+++ b/pkg/common/db/relation/group_member_model_k.go
@@ -24,36 +24,40 @@ type GroupMember struct {
 	OperatorUserID string    `gorm:"column:operator_user_id;size:64"`
 	MuteEndTime    time.Time `gorm:"column:mute_end_time"`
 	Ex             string    `gorm:"column:ex;size:1024"`
-	DB             *gorm.DB
+	DB             *gorm.DB  `gorm:"-" json:"-"`
 }
 
-func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember) (err error) {
+func NewGroupMemberDB(db *gorm.DB) *GroupMember {
+	return &GroupMember{DB: db}
+}
+
+func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember, tx ...*gorm.DB) (err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList)
 	}()
-	return utils.Wrap(GroupMemberDB.Create(&groupMemberList).Error, "")
+	return utils.Wrap(getDBConn(g.DB, tx).Create(&groupMemberList).Error, "")
 }
 
-func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember) (err error) {
+func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers)
 	}()
-	return utils.Wrap(GroupMemberDB.Delete(groupMembers).Error, "")
+	return utils.Wrap(getDBConn(g.DB, tx).Delete(groupMembers).Error, "")
 }
 
-func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) {
+func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}, tx ...*gorm.DB) (err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
 	}()
-	return utils.Wrap(GroupMemberDB.Model(&GroupMember{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "")
+	return utils.Wrap(getDBConn(g.DB, tx).Model(&GroupMember{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "")
 }
 
-func (g *GroupMember) Update(ctx context.Context, groupMembers []*GroupMember) (err error) {
+func (g *GroupMember) Update(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (err error) {
 	defer func() { trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }()
-	return utils.Wrap(GroupMemberDB.Updates(&groupMembers).Error, "")
+	return utils.Wrap(getDBConn(g.DB, tx).Updates(&groupMembers).Error, "")
 }
 
-func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (groupList []*GroupMember, err error) {
+func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (groupList []*GroupMember, err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers, "groupList", groupList)
 	}()
@@ -61,25 +65,23 @@ func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (gr
 	for _, groupMember := range groupMembers {
 		where = append(where, []interface{}{groupMember.GroupID, groupMember.UserID})
 	}
-	err = utils.Wrap(GroupMemberDB.Where("(group_id, user_id) in ?", where).Find(&groupList).Error, "")
-	return groupList, err
+	return groupList, utils.Wrap(getDBConn(g.DB, tx).Where("(group_id, user_id) in ?", where).Find(&groupList).Error, "")
 }
 
-func (g *GroupMember) Take(ctx context.Context, groupID string, userID string) (groupMember *GroupMember, err error) {
+func (g *GroupMember) Take(ctx context.Context, groupID string, userID string, tx ...*gorm.DB) (groupMember *GroupMember, err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
 	}()
 	groupMember = &GroupMember{}
-	return groupMember, utils.Wrap(GroupMemberDB.Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "")
+	return groupMember, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "")
 }
 
-func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string) (groupMember *GroupMember, err error) {
+func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string, tx ...*gorm.DB) (groupMember *GroupMember, err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember)
 	}()
 	groupMember = &GroupMember{}
-	err = GroupMemberDB.Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error
-	return groupMember, utils.Wrap(err, "")
+	return groupMember, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error, "")
 }
 
 func InsertIntoGroupMember(toInsertInfo GroupMember) error {