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
+}