errcode

pkg/common/db/cache/black.go

@@ -0,0 +1,64 @@
+package cache
+
+import (
+	"Open_IM/pkg/common/db/relation"
+	"Open_IM/pkg/common/tracelog"
+	"Open_IM/pkg/utils"
+	"context"
+	"encoding/json"
+	"github.com/dtm-labs/rockscache"
+	"time"
+)
+
+const (
+	blackIDsKey     = "BLACK_IDS:"
+	blackExpireTime = time.Second * 60 * 60 * 12
+)
+
+type BlackCache struct {
+	blackDB    *relation.Black
+	expireTime time.Duration
+	rcClient   *rockscache.Client
+}
+
+func NewBlackCache(blackDB *relation.Black) *BlackCache {
+	return &BlackCache{
+		blackDB:    nil,
+		expireTime: 0,
+		rcClient:   nil,
+	}
+}
+
+func (b *BlackCache) getBlackIDsKey(ownerUserID string) string {
+	return blackIDsKey + ownerUserID
+}
+
+func (b *BlackCache) GetBlackIDs(ctx context.Context, userID string) (blackIDs []string, err error) {
+	getBlackIDList := func() (string, error) {
+		blackIDs, err := b.blackDB.GetBlackIDs(ctx, userID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		bytes, err := json.Marshal(blackIDs)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "blackIDList", blackIDs)
+	}()
+	blackIDListStr, err := b.rcClient.Fetch(blackListCache+userID, time.Second*30*60, getBlackIDList)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	err = json.Unmarshal([]byte(blackIDListStr), &blackIDs)
+	return blackIDs, utils.Wrap(err, "")
+}
+
+func (b *BlackCache) DelBlackIDListFromCache(ctx context.Context, userID string) (err error) {
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ctx", ctx)
+	}()
+	return b.rcClient.TagAsDeleted(blackListCache + userID)
+}

pkg/common/db/cache/friend.go

@@ -0,0 +1,65 @@
+package cache
+
+import (
+	"Open_IM/pkg/common/db/relation"
+	"Open_IM/pkg/common/tracelog"
+	"Open_IM/pkg/utils"
+	"context"
+	"encoding/json"
+	"github.com/dtm-labs/rockscache"
+	"github.com/go-redis/redis/v8"
+	"time"
+)
+
+const (
+	friendExpireTime = time.Second * 60 * 60 * 12
+	friendIDsKey     = "FRIEND_IDS:"
+)
+
+type FriendCache struct {
+	friendDB   *relation.Friend
+	expireTime time.Duration
+	rcClient   *rockscache.Client
+}
+
+func NewFriendCache(rdb redis.UniversalClient, friendDB *relation.Friend, options rockscache.Options) *FriendCache {
+	return &FriendCache{
+		friendDB:   friendDB,
+		expireTime: friendExpireTime,
+		rcClient:   rockscache.NewClient(rdb, options),
+	}
+}
+
+func (f *FriendCache) getFriendRelationKey(ownerUserID string) string {
+	return friendIDsKey + ownerUserID
+}
+
+func (f *FriendCache) GetFriendIDs(ctx context.Context, ownerUserID string) (friendIDs []string, err error) {
+	getFriendIDList := func() (string, error) {
+		friendIDList, err := f.friendDB.GetFriendIDs(ctx, ownerUserID)
+		if err != nil {
+			return "", err
+		}
+		bytes, err := json.Marshal(friendIDList)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "friendIDs", friendIDs)
+	}()
+	friendIDListStr, err := f.rcClient.Fetch(f.getFriendRelationKey(ownerUserID), f.expireTime, getFriendIDList)
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal([]byte(friendIDListStr), &friendIDs)
+	return friendIDs, utils.Wrap(err, "")
+}
+
+func (f *FriendCache) DelFriendIDs(ctx context.Context, ownerUserID string) (err error) {
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID)
+	}()
+	return f.rcClient.TagAsDeleted(f.getFriendRelationKey(ownerUserID))
+}

pkg/common/db/cache/group.go

@@ -2,6 +2,7 @@ package cache
 
 import (
 	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db/localcache"
 	"Open_IM/pkg/common/db/relation"
 	"Open_IM/pkg/common/db/unrelation"
 	"Open_IM/pkg/common/tracelog"
@@ -39,18 +40,13 @@ type GroupCache struct {
 
 	//local cache
 	cacheGroupMtx           sync.RWMutex
-	cacheGroupMemberUserIDs map[string]*GroupMemberIDsHash
-}
-
-type GroupMemberIDsHash struct {
-	MemberListHash uint64
-	UserIDs        []string
+	cacheGroupMemberUserIDs map[string]*localcache.GroupMemberIDsHash
 }
 
 func NewGroupCache(rdb redis.UniversalClient, groupDB *relation.Group, groupMemberDB *relation.GroupMember, groupRequestDB *relation.GroupRequest, mongoClient *unrelation.SuperGroupMgoDB, opts rockscache.Options) *GroupCache {
 	return &GroupCache{rcClient: rockscache.NewClient(rdb, opts), expireTime: groupExpireTime,
 		group: groupDB, groupMember: groupMemberDB, groupRequest: groupRequestDB, redisClient: NewRedisClient(rdb),
-		mongoDB: mongoClient, cacheGroupMemberUserIDs: make(map[string]*GroupMemberIDsHash, 0),
+		mongoDB: mongoClient, cacheGroupMemberUserIDs: make(map[string]*localcache.GroupMemberIDsHash, 0),
 	}
 }
 
@@ -287,7 +283,7 @@ func (g *GroupCache) LocalGetGroupMemberIDs(ctx context.Context, groupID string)
 	if err != nil {
 		return nil, err
 	}
-	g.cacheGroupMemberUserIDs[groupID] = &GroupMemberIDsHash{
+	g.cacheGroupMemberUserIDs[groupID] = &localcache.GroupMemberIDsHash{
 		MemberListHash: remoteHash,
 		UserIDs:        groupMemberIDsRemote,
 	}
@@ -350,6 +346,51 @@ func (g *GroupCache) GetGroupMemberInfo(ctx context.Context, groupID, userID str
 	return groupMember, utils.Wrap(err, "")
 }
 
+func (g *GroupCache) 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)
+	}()
+	groupMemberIDList, err := g.GetGroupMemberIDs(ctx, groupID)
+	if err != nil {
+		return nil, err
+	}
+	if count < 0 || offset < 0 {
+		return nil, nil
+	}
+	var groupMemberList []*relation.GroupMember
+	var start, stop int32
+	start = offset
+	stop = offset + count
+	l := int32(len(groupMemberIDList))
+	if start > stop {
+		return nil, nil
+	}
+	if start >= l {
+		return nil, nil
+	}
+	if count != 0 {
+		if stop >= l {
+			stop = l
+		}
+		groupMemberIDList = groupMemberIDList[start:stop]
+	} else {
+		if l < 1000 {
+			stop = l
+		} else {
+			stop = 1000
+		}
+		groupMemberIDList = groupMemberIDList[start:stop]
+	}
+	for _, userID := range groupMemberIDList {
+		groupMember, err := g.GetGroupMemberInfo(ctx, groupID, userID)
+		if err != nil {
+			return
+		}
+		groupMembers = append(groupMembers, groupMember)
+	}
+	return groupMemberList, nil
+}
+
 func (g *GroupCache) DelGroupMemberInfo(ctx context.Context, groupID, userID string) (err error) {
 	defer func() {
 		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID)

pkg/common/db/cache/rockscache.go

@@ -21,15 +21,15 @@ import (
 
 const (
 	//userInfoCache       = "USER_INFO_CACHE:"
-	friendRelationCache = "FRIEND_RELATION_CACHE:"
-	blackListCache      = "BLACK_LIST_CACHE:"
+	//friendRelationCache = "FRIEND_RELATION_CACHE:"
+	blackListCache = "BLACK_LIST_CACHE:"
 	//groupCache          = "GROUP_CACHE:"
 	//groupInfoCache            = "GROUP_INFO_CACHE:"
 	//groupOwnerIDCache         = "GROUP_OWNER_ID:"
 	//joinedGroupListCache      = "JOINED_GROUP_LIST_CACHE:"
 	//groupMemberInfoCache      = "GROUP_MEMBER_INFO_CACHE:"
 	//groupAllMemberInfoCache   = "GROUP_ALL_MEMBER_INFO_CACHE:"
-	allFriendInfoCache = "ALL_FRIEND_INFO_CACHE:"
+	//allFriendInfoCache = "ALL_FRIEND_INFO_CACHE:"
 	//joinedSuperGroupListCache = "JOINED_SUPER_GROUP_LIST_CACHE:"
 	//groupMemberListHashCache  = "GROUP_MEMBER_LIST_HASH_CACHE:"
 	//groupMemberNumCache       = "GROUP_MEMBER_NUM_CACHE:"