feat: use robot to migrate code

Signed-off-by: kubbot & kubecub <3293172751ysy@gmail.com>

pkg/common/db/localcache/conversation.go

@@ -0,0 +1,67 @@
+package localcache
+
+import (
+	"context"
+	"sync"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+)
+
+type ConversationLocalCache struct {
+	lock                              sync.Mutex
+	superGroupRecvMsgNotNotifyUserIDs map[string]Hash
+	conversationIDs                   map[string]Hash
+	client                            *rpcclient.Conversation
+}
+
+type Hash struct {
+	hash uint64
+	ids  []string
+}
+
+func NewConversationLocalCache(discov discoveryregistry.SvcDiscoveryRegistry) *ConversationLocalCache {
+	return &ConversationLocalCache{
+		superGroupRecvMsgNotNotifyUserIDs: make(map[string]Hash),
+		conversationIDs:                   make(map[string]Hash),
+		client:                            rpcclient.NewConversation(discov),
+	}
+}
+
+func (g *ConversationLocalCache) GetRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) ([]string, error) {
+	resp, err := g.client.Client.GetRecvMsgNotNotifyUserIDs(ctx, &conversation.GetRecvMsgNotNotifyUserIDsReq{
+		GroupID: groupID,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return resp.UserIDs, nil
+}
+
+func (g *ConversationLocalCache) GetConversationIDs(ctx context.Context, userID string) ([]string, error) {
+	resp, err := g.client.Client.GetUserConversationIDsHash(ctx, &conversation.GetUserConversationIDsHashReq{
+		OwnerUserID: userID,
+	})
+	if err != nil {
+		return nil, err
+	}
+	g.lock.Lock()
+	defer g.lock.Unlock()
+	hash, ok := g.conversationIDs[userID]
+	if !ok || hash.hash != resp.Hash {
+		conversationIDsResp, err := g.client.Client.GetConversationIDs(ctx, &conversation.GetConversationIDsReq{
+			UserID: userID,
+		})
+		if err != nil {
+			return nil, err
+		}
+		g.conversationIDs[userID] = Hash{
+			hash: resp.Hash,
+			ids:  conversationIDsResp.ConversationIDs,
+		}
+		return conversationIDsResp.ConversationIDs, nil
+	}
+	return hash.ids, nil
+
+}

pkg/common/db/localcache/group.go

@@ -0,0 +1,59 @@
+package localcache
+
+import (
+	"context"
+	"sync"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+)
+
+type GroupLocalCache struct {
+	lock   sync.Mutex
+	cache  map[string]GroupMemberIDsHash
+	client *rpcclient.Group
+}
+
+type GroupMemberIDsHash struct {
+	memberListHash uint64
+	userIDs        []string
+}
+
+func NewGroupLocalCache(discov discoveryregistry.SvcDiscoveryRegistry) *GroupLocalCache {
+	client := rpcclient.NewGroup(discov)
+	return &GroupLocalCache{
+		cache:  make(map[string]GroupMemberIDsHash, 0),
+		client: client,
+	}
+}
+
+func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string) ([]string, error) {
+	resp, err := g.client.Client.GetGroupAbstractInfo(ctx, &group.GetGroupAbstractInfoReq{
+		GroupIDs: []string{groupID},
+	})
+	if err != nil {
+		return nil, err
+	}
+	if len(resp.GroupAbstractInfos) < 1 {
+		return nil, errs.ErrGroupIDNotFound
+	}
+	g.lock.Lock()
+	defer g.lock.Unlock()
+	localHashInfo, ok := g.cache[groupID]
+	if ok && localHashInfo.memberListHash == resp.GroupAbstractInfos[0].GroupMemberListHash {
+		return localHashInfo.userIDs, nil
+	}
+	groupMembersResp, err := g.client.Client.GetGroupMemberUserIDs(ctx, &group.GetGroupMemberUserIDsReq{
+		GroupID: groupID,
+	})
+	if err != nil {
+		return nil, err
+	}
+	g.cache[groupID] = GroupMemberIDsHash{
+		memberListHash: resp.GroupAbstractInfos[0].GroupMemberListHash,
+		userIDs:        groupMembersResp.UserIDs,
+	}
+	return g.cache[groupID].userIDs, nil
+}

pkg/common/db/localcache/meta_local_cache.go

@@ -0,0 +1 @@
+package localcache