Merge branch 'errcode' of github.com:OpenIMSDK/Open-IM-Server into errcode

 Conflicts:

	internal/push/sdk/tpns-server-sdk-go/go/auth/auth.go

	pkg/proto/group/group.proto

pkg/common/db/cache/conversation.go

@@ -148,29 +148,6 @@ func (c *ConversationRedis) GetUserConversationIDs1(ctx context.Context, ownerUs
 //	return t, nil
 //}
 
-func GetCache[T any](ctx context.Context, rcClient *rockscache.Client, key string, expire time.Duration, fn func(ctx context.Context) (T, error)) (T, error) {
-	v, err := rcClient.Fetch(key, expire, func() (string, error) {
-		v, err := fn(ctx)
-		if err != nil {
-			return "", err
-		}
-		bs, err := json.Marshal(v)
-		if err != nil {
-			return "", utils.Wrap(err, "")
-		}
-		return string(bs), nil
-	})
-	var t T
-	if err != nil {
-		return t, err
-	}
-	err = json.Unmarshal([]byte(v), &t)
-	if err != nil {
-		return t, utils.Wrap(err, "")
-	}
-	return t, nil
-}
-
 func (c *ConversationRedis) DelUserConversationIDs(ctx context.Context, ownerUserID string) (err error) {
 	defer func() {
 		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID)

pkg/common/db/cache/group.go

@@ -37,19 +37,18 @@ type GroupCache interface {
 	BatchDelJoinedSuperGroupIDs(ctx context.Context, userIDs []string, fn func(ctx context.Context, userIDs []string) error) (err error)
 
 	GetJoinedSuperGroupIDs(ctx context.Context, userID string, fn func(ctx context.Context, userID string) (joinedSuperGroupIDs []string, err error)) (joinedSuperGroupIDs []string, err error)
-	DelJoinedSuperGroupIDs(ctx context.Context, userID string, fn func(ctx context.Context, userID string) error) (err error)
+	DelJoinedSuperGroupIDs(ctx context.Context, userID string) (err error)
 
 	GetGroupMembersHash(ctx context.Context, groupID string, fn func(ctx context.Context, groupID string) (hashCodeUint64 uint64, err error)) (hashCodeUint64 uint64, err error)
 	DelGroupMembersHash(ctx context.Context, groupID string) (err error)
 
 	GetGroupMemberIDs(ctx context.Context, groupID string, fn func(ctx context.Context, groupID string) (groupMemberIDs []string, err error)) (groupMemberIDs []string, err error)
-	DelGroupMemberIDs(ctx context.Context, groupID string)
+	DelGroupMemberIDs(ctx context.Context, groupID string) error
 
 	GetJoinedGroupIDs(ctx context.Context, userID string, fn func(ctx context.Context, userID string) (joinedGroupIDs []string, err error)) (joinedGroupIDs []string, err error)
 	DelJoinedGroupIDs(ctx context.Context, userID string) (err error)
 
 	GetGroupMemberInfo(ctx context.Context, groupID, userID string, fn func(ctx context.Context, groupID, userID string) (groupMember *relationTb.GroupMemberModel, err error)) (groupMember *relationTb.GroupMemberModel, err error)
-	GetGroupMembersInfo(ctx context.Context, count, offset int32, groupID string, fn func(ctx context.Context, count, offset int32, groupID string) (groupMembers []*relationTb.GroupMemberModel, err error)) (groupMembers []*relationTb.GroupMemberModel, err error)
 	DelGroupMemberInfo(ctx context.Context, groupID, userID string) (err error)
 
 	GetGroupMemberNum(ctx context.Context, groupID string, fn func(ctx context.Context, groupID string) (num int, err error)) (num int, err error)
@@ -57,16 +56,16 @@ type GroupCache interface {
 }
 
 type GroupCacheRedis struct {
-	group        *relation.GroupGorm
-	groupMember  *relation.GroupMemberGorm
-	groupRequest *relation.GroupRequestGorm
+	group        relationTb.GroupModelInterface
+	groupMember  relationTb.GroupMemberModelInterface
+	groupRequest relationTb.GroupRequestModelInterface
 	mongoDB      *unrelation.SuperGroupMongoDriver
 	expireTime   time.Duration
 	redisClient  *RedisClient
 	rcClient     *rockscache.Client
 }
 
-func NewGroupCacheRedis(rdb redis.UniversalClient, groupDB *relation.GroupGorm, groupMemberDB *relation.GroupMemberGorm, groupRequestDB *relation.GroupRequestGorm, mongoClient *unrelation.SuperGroupMongoDriver, opts rockscache.Options) *GroupCacheRedis {
+func NewGroupCacheRedis(rdb redis.UniversalClient, groupDB relationTb.GroupModelInterface, groupMemberDB relationTb.GroupMemberModelInterface, groupRequestDB relationTb.GroupRequestModelInterface, mongoClient *unrelation.SuperGroupMongoDriver, opts rockscache.Options) *GroupCacheRedis {
 	return &GroupCacheRedis{rcClient: rockscache.NewClient(rdb, opts), expireTime: groupExpireTime,
 		group: groupDB, groupMember: groupMemberDB, groupRequest: groupRequestDB, redisClient: NewRedisClient(rdb),
 		mongoDB: mongoClient,
@@ -106,39 +105,16 @@ func (g *GroupCacheRedis) getGroupMemberNumKey(groupID string) string {
 }
 
 // / groupInfo
-func (g *GroupCacheRedis) GetGroupsInfo(ctx context.Context, groupIDs []string) (groups []*relation.Group, err error) {
-	for _, groupID := range groupIDs {
-		group, err := g.GetGroupInfo(ctx, groupID)
-		if err != nil {
-			return nil, err
-		}
-		groups = append(groups, group)
-	}
-	return groups, nil
+func (g *GroupCacheRedis) GetGroupsInfo(ctx context.Context, groupIDs []string) (groups []*relationTb.GroupModel, err error) {
+	return GetCacheFor(ctx, g.rcClient, groupIDs, func(ctx context.Context, groupID string) (*relationTb.GroupModel, error) {
+		return g.GetGroupInfo(ctx, groupID)
+	})
 }
 
-func (g *GroupCacheRedis) GetGroupInfo(ctx context.Context, groupID string) (group *relation.GroupGorm, err error) {
-	getGroup := func() (string, error) {
-		groupInfo, err := g.group.Take(ctx, groupID)
-		if err != nil {
-			return "", utils.Wrap(err, "")
-		}
-		bytes, err := json.Marshal(groupInfo)
-		if err != nil {
-			return "", utils.Wrap(err, "")
-		}
-		return string(bytes), nil
-	}
-	group = &relation.GroupGorm{}
-	defer func() {
-		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
-	}()
-	groupStr, err := g.rcClient.Fetch(g.getGroupInfoKey(groupID), g.expireTime, getGroup)
-	if err != nil {
-		return nil, err
-	}
-	err = json.Unmarshal([]byte(groupStr), group)
-	return group, utils.Wrap(err, "")
+func (g *GroupCacheRedis) GetGroupInfo(ctx context.Context, groupID string) (group *relationTb.GroupModel, err error) {
+	return GetCache(ctx, g.rcClient, g.getGroupInfoKey(groupID), g.expireTime, func(ctx context.Context) (*relationTb.GroupModel, error) {
+		return g.group.Take(ctx, groupID)
+	})
 }
 
 func (g *GroupCacheRedis) DelGroupInfo(ctx context.Context, groupID string) (err error) {
@@ -339,6 +315,11 @@ func (g *GroupCacheRedis) GetGroupMemberInfo(ctx context.Context, groupID, userI
 	return groupMember, utils.Wrap(err, "")
 }
 
+func (g *GroupCacheRedis) GetGroupMembersInfo(ctx context.Context, groupID, userIDs []string) (groupMember *relationTb.GroupMemberModel, err error) {
+
+	return nil, err
+}
+
 func (g *GroupCacheRedis) GetGroupMembersInfo(ctx context.Context, count, offset int32, groupID string) (groupMembers []*relation.GroupMember, err error) {
 	defer func() {
 		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "count", count, "offset", offset, "groupID", groupID, "groupMember", groupMembers)

pkg/common/db/cache/redis.go

@@ -20,10 +20,10 @@ import (
 )
 
 const (
-	userIncrSeq             = "REDIS_USER_INCR_SEQ:" // user incr seq
-	appleDeviceToken        = "DEVICE_TOKEN"
-	userMinSeq              = "REDIS_USER_MIN_SEQ:"
-	uidPidToken             = "UID_PID_TOKEN_STATUS:"
+	userIncrSeq      = "REDIS_USER_INCR_SEQ:" // user incr seq
+	appleDeviceToken = "DEVICE_TOKEN"
+	userMinSeq       = "REDIS_USER_MIN_SEQ:"
+
 	getuiToken              = "GETUI_TOKEN"
 	getuiTaskID             = "GETUI_TASK_ID"
 	messageCache            = "MESSAGE_CACHE:"
@@ -94,33 +94,33 @@ func NewRedisClient(rdb redis.UniversalClient) *RedisClient {
 	return &RedisClient{rdb: rdb}
 }
 
-//Perform seq auto-increment operation of user messages
+// Perform seq auto-increment operation of user messages
 func (r *RedisClient) IncrUserSeq(uid string) (uint64, error) {
 	key := userIncrSeq + uid
 	seq, err := r.rdb.Incr(context.Background(), key).Result()
 	return uint64(seq), err
 }
 
-//Get the largest Seq
+// Get the largest Seq
 func (r *RedisClient) GetUserMaxSeq(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
+// set the largest Seq
 func (r *RedisClient) SetUserMaxSeq(uid string, maxSeq uint64) error {
 	key := userIncrSeq + uid
 	return r.rdb.Set(context.Background(), key, maxSeq, 0).Err()
 }
 
-//Set the user's minimum seq
+// Set the user's minimum seq
 func (r *RedisClient) SetUserMinSeq(uid string, minSeq uint32) (err error) {
 	key := userMinSeq + uid
 	return r.rdb.Set(context.Background(), key, minSeq, 0).Err()
 }
 
-//Get the smallest Seq
+// Get the smallest Seq
 func (r *RedisClient) GetUserMinSeq(uid string) (uint64, error) {
 	key := userMinSeq + uid
 	seq, err := r.rdb.Get(context.Background(), key).Result()
@@ -159,7 +159,7 @@ func (r *RedisClient) SetGroupMinSeq(groupID string, minSeq uint32) error {
 	return r.rdb.Set(context.Background(), key, minSeq, 0).Err()
 }
 
-//Store userid and platform class to redis
+// Store userid and platform class to redis
 func (r *RedisClient) AddTokenFlag(userID string, platformID int, token string, flag int) error {
 	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)
 	log2.NewDebug("", "add token key is ", key)

pkg/common/db/cache/token.go

@@ -0,0 +1,75 @@
+package cache
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/tokenverify"
+	"Open_IM/pkg/utils"
+	"context"
+	go_redis "github.com/go-redis/redis/v8"
+	"github.com/golang-jwt/jwt/v4"
+)
+
+const (
+	uidPidToken = "UID_PID_TOKEN_STATUS:"
+)
+
+type Token interface {
+	//结果为空 不返回错误
+	GetTokensWithoutError(ctx context.Context, userID, platform string) (map[string]int, error)
+	//创建token
+	CreateToken(ctx context.Context, userID string, platformID int) (string, error)
+}
+
+type TokenRedis struct {
+	RedisClient  *RedisClient
+	AccessSecret string
+	AccessExpire int64
+}
+
+func NewTokenRedis(redisClient *RedisClient, accessSecret string, accessExpire int64) *TokenRedis {
+	return &TokenRedis{redisClient, accessSecret, accessExpire}
+}
+
+// 结果为空 不返回错误
+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 {
+		return nil, nil
+	}
+	mm := make(map[string]int)
+	for k, v := range m {
+		mm[k] = utils.StringToInt(v)
+	}
+	return mm, utils.Wrap(err, "")
+}
+
+// 创建token
+func (t *TokenRedis) CreateToken(ctx context.Context, userID string, platform string) (string, error) {
+	tokens, err := t.GetTokensWithoutError(ctx, userID, platform)
+	if err != nil {
+		return "", err
+	}
+	var deleteTokenKey []string
+	for k, v := range tokens {
+		_, err = tokenverify.GetClaimFromToken(k)
+		if err != nil || v != constant.NormalToken {
+			deleteTokenKey = append(deleteTokenKey, k)
+		}
+	}
+	if len(deleteTokenKey) != 0 {
+		key := uidPidToken + userID + ":" + platform
+		err := t.RedisClient.GetClient().HDel(context.Background(), key, deleteTokenKey...).Err()
+		if err != nil {
+			return "", err
+		}
+	}
+	claims := tokenverify.BuildClaims(userID, platform, t.AccessExpire)
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	tokenString, err := token.SignedString([]byte(t.AccessSecret))
+	if err != nil {
+		return "", utils.Wrap(err, "")
+	}
+	key := uidPidToken + userID + ":" + platform
+	return "", utils.Wrap(t.RedisClient.GetClient().HSet(context.Background(), key, tokenString, constant.NormalToken).Err(), "")
+}

pkg/common/db/cache/utils.go

@@ -0,0 +1,49 @@
+package cache
+
+import (
+	"Open_IM/pkg/utils"
+	"context"
+	"encoding/json"
+	"github.com/dtm-labs/rockscache"
+	"time"
+)
+
+func GetCache[T any](ctx context.Context, rcClient *rockscache.Client, key string, expire time.Duration, fn func(ctx context.Context) (T, error)) (T, error) {
+	var t T
+	var write bool
+	v, err := rcClient.Fetch(key, expire, func() (s string, err error) {
+		t, err = fn(ctx)
+		if err != nil {
+			return "", err
+		}
+		bs, err := json.Marshal(t)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		write = true
+		return string(bs), nil
+	})
+	if err != nil {
+		return t, err
+	}
+	if write {
+		return t, nil
+	}
+	err = json.Unmarshal([]byte(v), &t)
+	if err != nil {
+		return t, utils.Wrap(err, "")
+	}
+	return t, nil
+}
+
+func GetCacheFor[E any, T any](ctx context.Context, rcClient *rockscache.Client, list []E, fn func(ctx context.Context, item E) (T, error)) ([]T, error) {
+	rs := make([]T, 0, len(list))
+	for _, e := range list {
+		r, err := fn(ctx, e)
+		if err != nil {
+			return nil, err
+		}
+		rs = append(rs, r)
+	}
+	return rs, nil
+}

pkg/common/db/controller/auth.go

@@ -1,9 +1,34 @@
 package controller
 
-import "context"
+import (
+	"Open_IM/pkg/common/db/cache"
+	"context"
+	"github.com/go-redis/redis/v8"
+)
 
 type AuthInterface interface {
-	GetTokens(ctx context.Context, userID, platform string) (map[string]int, error)
-	DeleteToken(ctx context.Context, userID, platform string) error
-	CreateToken(ctx context.Context, userID string, platformID int, ttl int64) (string, error)
+	//结果为空 不返回错误
+	GetTokensWithoutError(ctx context.Context, userID, platform string) (map[string]int, error)
+
+	//创建token
+	CreateToken(ctx context.Context, userID string, platform string) (string, error)
+}
+
+type AuthController struct {
+	database *cache.TokenRedis
+}
+
+func NewAuthController(rdb redis.UniversalClient, accessSecret string, accessExpire int64) *AuthController {
+	cache.NewRedisClient(rdb)
+	return &AuthController{database: cache.NewTokenRedis(cache.NewRedisClient(rdb), accessSecret, accessExpire)}
+}
+
+// 结果为空 不返回错误
+func (a *AuthController) GetTokensWithoutError(ctx context.Context, userID, platform string) (map[string]int, error) {
+	return a.database.GetTokensWithoutError(ctx, userID, platform)
+}
+
+// 创建token
+func (a *AuthController) CreateToken(ctx context.Context, userID string, platform string) (string, error) {
+	return a.database.CreateToken(ctx, userID, platform)
 }

pkg/common/db/controller/group.go

@@ -19,6 +19,12 @@ import (
 
 //type GroupInterface GroupDataBaseInterface
 
+type BatchUpdateGroupMember struct {
+	GroupID string
+	UserID  string
+	Map     map[string]any
+}
+
 type GroupInterface interface {
 	CreateGroup(ctx context.Context, groups []*relationTb.GroupModel, groupMembers []*relationTb.GroupMemberModel) error
 	TakeGroup(ctx context.Context, groupID string) (group *relationTb.GroupModel, err error)
@@ -30,6 +36,7 @@ type GroupInterface interface {
 	TakeGroupMember(ctx context.Context, groupID string, userID string) (groupMember *relationTb.GroupMemberModel, err error)
 	TakeGroupOwner(ctx context.Context, groupID string) (*relationTb.GroupMemberModel, error)
 	FindGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) ([]*relationTb.GroupMemberModel, error)
+	FindGroupMemberUserID(ctx context.Context, groupID string) ([]string, error)
 	PageGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32, pageNumber, showNumber int32) (uint32, []*relationTb.GroupMemberModel, error)
 	SearchGroupMember(ctx context.Context, keyword string, groupIDs []string, userIDs []string, roleLevels []int32, pageNumber, showNumber int32) (uint32, []*relationTb.GroupMemberModel, error)
 	HandlerGroupRequest(ctx context.Context, groupID string, userID string, handledMsg string, handleResult int32, member *relationTb.GroupMemberModel) error
@@ -37,7 +44,8 @@ type GroupInterface interface {
 	MapGroupMemberUserID(ctx context.Context, groupIDs []string) (map[string][]string, error)
 	MapGroupMemberNum(ctx context.Context, groupIDs []string) (map[string]uint32, error)
 	TransferGroupOwner(ctx context.Context, groupID string, oldOwnerUserID, newOwnerUserID string, roleLevel int32) error // 转让群
-	UpdateGroupMember(ctx context.Context, groupID, userID string, data map[string]any) error
+	UpdateGroupMember(ctx context.Context, groupID string, userID string, data map[string]any) error
+	UpdateGroupMembers(ctx context.Context, data []*BatchUpdateGroupMember) error
 	// GroupRequest
 	CreateGroupRequest(ctx context.Context, requests []*relationTb.GroupRequestModel) error
 	TakeGroupRequest(ctx context.Context, groupID string, userID string) (*relationTb.GroupRequestModel, error)
@@ -61,6 +69,10 @@ type GroupController struct {
 	database GroupDataBaseInterface
 }
 
+func (g *GroupController) FindGroupMemberUserID(ctx context.Context, groupID string) ([]string, error) {
+	return g.database.FindGroupMemberUserID(ctx, groupID)
+}
+
 func (g *GroupController) CreateGroup(ctx context.Context, groups []*relationTb.GroupModel, groupMembers []*relationTb.GroupMemberModel) error {
 	return g.database.CreateGroup(ctx, groups, groupMembers)
 }
@@ -125,7 +137,11 @@ func (g *GroupController) TransferGroupOwner(ctx context.Context, groupID string
 	return g.database.TransferGroupOwner(ctx, groupID, oldOwnerUserID, newOwnerUserID, roleLevel)
 }
 
-func (g *GroupController) UpdateGroupMember(ctx context.Context, groupID, userID string, data map[string]any) error {
+func (g *GroupController) UpdateGroupMembers(ctx context.Context, data []*BatchUpdateGroupMember) error {
+	return g.database.UpdateGroupMembers(ctx, data)
+}
+
+func (g *GroupController) UpdateGroupMember(ctx context.Context, groupID string, userID string, data map[string]any) error {
 	return g.database.UpdateGroupMember(ctx, groupID, userID, data)
 }
 
@@ -141,9 +157,6 @@ func (g *GroupController) PageGroupRequestUser(ctx context.Context, userID strin
 	return g.database.PageGroupRequestUser(ctx, userID, pageNumber, showNumber)
 }
 
-//	func (g *GroupController) TakeSuperGroup(ctx context.Context, groupID string) (superGroup *unrelationTb.SuperGroupModel, err error) {
-//		return g.database.TakeSuperGroup(ctx, groupID)
-//	}
 func (g *GroupController) FindSuperGroup(ctx context.Context, groupIDs []string) ([]*unrelationTb.SuperGroupModel, error) {
 	return g.database.FindSuperGroup(ctx, groupIDs)
 }
@@ -179,6 +192,7 @@ type GroupDataBaseInterface interface {
 	TakeGroupMember(ctx context.Context, groupID string, userID string) (groupMember *relationTb.GroupMemberModel, err error)
 	TakeGroupOwner(ctx context.Context, groupID string) (*relationTb.GroupMemberModel, error)
 	FindGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) ([]*relationTb.GroupMemberModel, error)
+	FindGroupMemberUserID(ctx context.Context, groupID string) ([]string, error)
 	PageGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32, pageNumber, showNumber int32) (uint32, []*relationTb.GroupMemberModel, error)
 	SearchGroupMember(ctx context.Context, keyword string, groupIDs []string, userIDs []string, roleLevels []int32, pageNumber, showNumber int32) (uint32, []*relationTb.GroupMemberModel, error)
 	HandlerGroupRequest(ctx context.Context, groupID string, userID string, handledMsg string, handleResult int32, member *relationTb.GroupMemberModel) error
@@ -186,7 +200,8 @@ type GroupDataBaseInterface interface {
 	MapGroupMemberUserID(ctx context.Context, groupIDs []string) (map[string][]string, error)
 	MapGroupMemberNum(ctx context.Context, groupIDs []string) (map[string]uint32, error)
 	TransferGroupOwner(ctx context.Context, groupID string, oldOwnerUserID, newOwnerUserID string, roleLevel int32) error // 转让群
-	UpdateGroupMember(ctx context.Context, groupID, userID string, data map[string]any) error
+	UpdateGroupMember(ctx context.Context, groupID string, userID string, data map[string]any) error
+	UpdateGroupMembers(ctx context.Context, data []*BatchUpdateGroupMember) error
 	// GroupRequest
 	CreateGroupRequest(ctx context.Context, requests []*relationTb.GroupRequestModel) error
 	TakeGroupRequest(ctx context.Context, groupID string, userID string) (*relationTb.GroupRequestModel, error)
@@ -211,7 +226,7 @@ func NewGroupDatabase(db *gorm.DB, rdb redis.UniversalClient, mgoClient *mongo.C
 		groupMemberDB:  groupMemberDB,
 		groupRequestDB: groupRequestDB,
 		db:             &newDB,
-		cache: cache.NewGroupCache(rdb, groupDB, groupMemberDB, groupRequestDB, SuperGroupMongoDriver, rockscache.Options{
+		cache: cache.NewGroupCacheRedis(rdb, groupDB, groupMemberDB, groupRequestDB, SuperGroupMongoDriver, rockscache.Options{
 			RandomExpireAdjustment: 0.2,
 			DisableCacheRead:       false,
 			DisableCacheDelete:     false,
@@ -230,10 +245,36 @@ type GroupDataBase struct {
 	groupRequestDB relationTb.GroupRequestModelInterface
 	db             *gorm.DB
 
-	cache   *cache.GroupCache
+	//cache   cache.GroupCache
+	cache   *cache.GroupCacheRedis
 	mongoDB *unrelation.SuperGroupMongoDriver
 }
 
+func (g *GroupDataBase) delGroupMemberCache(ctx context.Context, groupID string, userIDs []string) error {
+	for _, userID := range userIDs {
+		if err := g.cache.DelJoinedGroupIDs(ctx, userID); err != nil {
+			return err
+		}
+		if err := g.cache.DelJoinedSuperGroupIDs(ctx, userID); err != nil {
+			return err
+		}
+	}
+	if err := g.cache.DelGroupMemberIDs(ctx, groupID); err != nil {
+		return err
+	}
+	if err := g.cache.DelGroupMemberNum(ctx, groupID); err != nil {
+		return err
+	}
+	if err := g.cache.DelGroupMembersHash(ctx, groupID); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (g *GroupDataBase) FindGroupMemberUserID(ctx context.Context, groupID string) ([]string, error) {
+	return g.cache.GetGroupMemberIDs(ctx, groupID)
+}
+
 func (g *GroupDataBase) CreateGroup(ctx context.Context, groups []*relationTb.GroupModel, groupMembers []*relationTb.GroupMemberModel) error {
 	if len(groups) > 0 && len(groupMembers) > 0 {
 		return g.db.Transaction(func(tx *gorm.DB) error {
@@ -253,11 +294,11 @@ func (g *GroupDataBase) CreateGroup(ctx context.Context, groups []*relationTb.Gr
 }
 
 func (g *GroupDataBase) TakeGroup(ctx context.Context, groupID string) (group *relationTb.GroupModel, err error) {
-	return g.groupDB.Take(ctx, groupID)
+	return g.cache.GetGroupInfo(ctx, groupID)
 }
 
 func (g *GroupDataBase) FindGroup(ctx context.Context, groupIDs []string) (groups []*relationTb.GroupModel, err error) {
-	return g.groupDB.Find(ctx, groupIDs)
+	return g.cache.GetGroupsInfo(ctx, groupIDs)
 }
 
 func (g *GroupDataBase) SearchGroup(ctx context.Context, keyword string, pageNumber, showNumber int32) (uint32, []*relationTb.GroupModel, error) {
@@ -265,7 +306,15 @@ func (g *GroupDataBase) SearchGroup(ctx context.Context, keyword string, pageNum
 }
 
 func (g *GroupDataBase) UpdateGroup(ctx context.Context, groupID string, data map[string]any) error {
-	return g.groupDB.UpdateMap(ctx, groupID, data)
+	return g.db.Transaction(func(tx *gorm.DB) error {
+		if err := g.groupDB.UpdateMap(ctx, groupID, data, tx); err != nil {
+			return err
+		}
+		if err := g.cache.DelGroupInfo(ctx, groupID); err != nil {
+			return err
+		}
+		return nil
+	})
 }
 
 func (g *GroupDataBase) DismissGroup(ctx context.Context, groupID string) error {
@@ -273,13 +322,22 @@ func (g *GroupDataBase) DismissGroup(ctx context.Context, groupID string) error
 		if err := g.groupDB.UpdateStatus(ctx, groupID, constant.GroupStatusDismissed, tx); err != nil {
 			return err
 		}
-		return g.groupMemberDB.DeleteGroup(ctx, []string{groupID}, tx)
-
+		if err := g.groupMemberDB.DeleteGroup(ctx, []string{groupID}, tx); err != nil {
+			return err
+		}
+		userIDs, err := g.cache.GetGroupMemberIDs(ctx, groupID)
+		if err != nil {
+			return err
+		}
+		if err := g.delGroupMemberCache(ctx, groupID, userIDs); err != nil {
+			return err
+		}
+		return nil
 	})
 }
 
 func (g *GroupDataBase) TakeGroupMember(ctx context.Context, groupID string, userID string) (groupMember *relationTb.GroupMemberModel, err error) {
-	return g.groupMemberDB.Take(ctx, groupID, userID)
+	return g.cache.GetGroupMemberInfo(ctx, groupID, userID)
 }
 
 func (g *GroupDataBase) TakeGroupOwner(ctx context.Context, groupID string) (*relationTb.GroupMemberModel, error) {
@@ -287,6 +345,7 @@ func (g *GroupDataBase) TakeGroupOwner(ctx context.Context, groupID string) (*re
 }
 
 func (g *GroupDataBase) FindGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) ([]*relationTb.GroupMemberModel, error) {
+	//g.cache.GetGroupMembersInfo()
 	return g.groupMemberDB.Find(ctx, groupIDs, userIDs, roleLevels)
 }
 
@@ -299,19 +358,32 @@ func (g *GroupDataBase) SearchGroupMember(ctx context.Context, keyword string, g
 }
 
 func (g *GroupDataBase) HandlerGroupRequest(ctx context.Context, groupID string, userID string, handledMsg string, handleResult int32, member *relationTb.GroupMemberModel) error {
-	if member == nil {
-		return g.groupRequestDB.UpdateHandler(ctx, groupID, userID, handledMsg, handleResult)
-	}
 	return g.db.Transaction(func(tx *gorm.DB) error {
 		if err := g.groupRequestDB.UpdateHandler(ctx, groupID, userID, handledMsg, handleResult, tx); err != nil {
 			return err
 		}
-		return g.groupMemberDB.Create(ctx, []*relationTb.GroupMemberModel{member}, tx)
+		if member != nil {
+			if err := g.groupMemberDB.Create(ctx, []*relationTb.GroupMemberModel{member}, tx); err != nil {
+				return err
+			}
+			if err := g.delGroupMemberCache(ctx, groupID, []string{userID}); err != nil {
+				return err
+			}
+		}
+		return nil
 	})
 }
 
 func (g *GroupDataBase) DeleteGroupMember(ctx context.Context, groupID string, userIDs []string) error {
-	return g.groupMemberDB.Delete(ctx, groupID, userIDs)
+	return g.db.Transaction(func(tx *gorm.DB) error {
+		if err := g.groupMemberDB.Delete(ctx, groupID, userIDs, tx); err != nil {
+			return err
+		}
+		if err := g.delGroupMemberCache(ctx, groupID, userIDs); err != nil {
+			return err
+		}
+		return nil
+	})
 }
 
 func (g *GroupDataBase) MapGroupMemberUserID(ctx context.Context, groupIDs []string) (map[string][]string, error) {
@@ -338,12 +410,37 @@ func (g *GroupDataBase) TransferGroupOwner(ctx context.Context, groupID string,
 		if rowsAffected != 1 {
 			return utils.Wrap(fmt.Errorf("newOwnerUserID %s rowsAffected = %d", newOwnerUserID, rowsAffected), "")
 		}
+		if err := g.delGroupMemberCache(ctx, groupID, []string{oldOwnerUserID, newOwnerUserID}); err != nil {
+			return err
+		}
 		return nil
 	})
 }
 
-func (g *GroupDataBase) UpdateGroupMember(ctx context.Context, groupID, userID string, data map[string]any) error {
-	return g.groupMemberDB.Update(ctx, groupID, userID, data)
+func (g *GroupDataBase) UpdateGroupMember(ctx context.Context, groupID string, userID string, data map[string]any) error {
+	return g.db.Transaction(func(tx *gorm.DB) error {
+		if err := g.groupMemberDB.Update(ctx, groupID, userID, data, tx); err != nil {
+			return err
+		}
+		if err := g.cache.DelGroupMemberInfo(ctx, groupID, userID); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (g *GroupDataBase) UpdateGroupMembers(ctx context.Context, data []*BatchUpdateGroupMember) error {
+	return g.db.Transaction(func(tx *gorm.DB) error {
+		for _, item := range data {
+			if err := g.groupMemberDB.Update(ctx, item.GroupID, item.UserID, item.Map, tx); err != nil {
+				return err
+			}
+			if err := g.cache.DelGroupMemberInfo(ctx, item.GroupID, item.UserID); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
 }
 
 func (g *GroupDataBase) CreateGroupRequest(ctx context.Context, requests []*relationTb.GroupRequestModel) error {

pkg/common/db/localcache/group.go

@@ -52,8 +52,7 @@ func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string)
 	if ok && localHashInfo.memberListHash == resp.GroupAbstractInfos[0].GroupMemberListHash {
 		return localHashInfo.userIDs, nil
 	}
-
-	groupMembersResp, err := client.GetGroupMemberList(ctx, &group.GetGroupMemberListReq{
+	groupMembersResp, err := client.GetGroupMemberUserID(ctx, &group.GetGroupMemberUserIDReq{
 		GroupID: groupID,
 	})
 	if err != nil {
@@ -61,7 +60,7 @@ func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string)
 	}
 	g.cache[groupID] = GroupMemberIDsHash{
 		memberListHash: resp.GroupAbstractInfos[0].GroupMemberListHash,
-		userIDs:        groupMembersResp.Members,
+		userIDs:        groupMembersResp.UserIDs,
 	}
 	return g.cache[groupID].userIDs, nil
 }

pkg/common/db/relation/group_member_model.go

@@ -40,13 +40,6 @@ func (g *GroupMemberGorm) DeleteGroup(ctx context.Context, groupIDs []string, tx
 	return utils.Wrap(getDBConn(g.DB, tx).Where("group_id in (?)", groupIDs).Delete(&relation.GroupMemberModel{}).Error, "")
 }
 
-//func (g *GroupMemberGorm) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}, tx ...any) (err error) {
-//	defer func() {
-//		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
-//	}()
-//	return utils.Wrap(getDBConn(g.DB, tx).Model(&relation.GroupMemberModel{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "")
-//}
-
 func (g *GroupMemberGorm) Update(ctx context.Context, groupID string, userID string, data map[string]any, tx ...any) (err error) {
 	defer func() {
 		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "data", data)
@@ -81,23 +74,6 @@ func (g *GroupMemberGorm) Find(ctx context.Context, groupIDs []string, userIDs [
 	return groupList, utils.Wrap(db.Find(&groupList).Error, "")
 }
 
-//func (g *GroupMemberGorm) FindGroupUser(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32, tx ...any) (groupList []*relation.GroupMemberModel, err error) {
-//	defer func() {
-//		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs, "userIDs", userIDs, "groupList", groupList)
-//	}()
-//	db := getDBConn(g.DB, tx)
-//	if len(groupList) > 0 {
-//		db = db.Where("group_id in (?)", groupIDs)
-//	}
-//	if len(userIDs) > 0 {
-//		db = db.Where("user_id in (?)", userIDs)
-//	}
-//	if len(roleLevels) > 0 {
-//		db = db.Where("role_level in (?)", roleLevels)
-//	}
-//	return groupList, utils.Wrap(db.Find(&groupList).Error, "")
-//}
-
 func (g *GroupMemberGorm) Take(ctx context.Context, groupID string, userID string, tx ...any) (groupMember *relation.GroupMemberModel, err error) {
 	defer func() {
 		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
@@ -149,3 +125,10 @@ func (g *GroupMemberGorm) FindJoinUserID(ctx context.Context, groupIDs []string,
 	}
 	return groupUsers, nil
 }
+
+func (g *GroupMemberGorm) FindMemberUserID(ctx context.Context, groupID string, tx ...any) (userIDs []string, err error) {
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userIDs", userIDs)
+	}()
+	return userIDs, utils.Wrap(getDBConn(g.DB, tx).Model(&relation.GroupMemberModel{}).Where("group_id = ?", groupID).Pluck("user_id", &userIDs), "")
+}

pkg/common/db/table/relation/group_member.go

@@ -31,11 +31,10 @@ type GroupMemberModelInterface interface {
 	Create(ctx context.Context, groupMemberList []*GroupMemberModel, tx ...any) (err error)
 	Delete(ctx context.Context, groupID string, userIDs []string, tx ...any) (err error)
 	DeleteGroup(ctx context.Context, groupIDs []string, tx ...any) (err error)
-	//UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}, tx ...any) (err error)
 	Update(ctx context.Context, groupID string, userID string, data map[string]any, tx ...any) (err error)
 	UpdateRoleLevel(ctx context.Context, groupID string, userID string, roleLevel int32, tx ...any) (rowsAffected int64, err error)
 	Find(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32, tx ...any) (groupList []*GroupMemberModel, err error)
-	//FindGroupUser(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32, tx ...any) (groupList []*GroupMemberModel, err error)
+	FindMemberUserID(ctx context.Context, groupID string, tx ...any) (userIDs []string, err error)
 	Take(ctx context.Context, groupID string, userID string, tx ...any) (groupMember *GroupMemberModel, err error)
 	TakeOwner(ctx context.Context, groupID string, tx ...any) (groupMember *GroupMemberModel, err error)
 	SearchMember(ctx context.Context, keyword string, groupIDs []string, userIDs []string, roleLevels []int32, pageNumber, showNumber int32, tx ...any) (total uint32, groupList []*GroupMemberModel, err error)