复制项目

pkg/rpcli/auth.go

@@ -0,0 +1,31 @@
+package rpcli
+
+import (
+	"context"
+
+	"git.imall.cloud/openim/protocol/auth"
+	"google.golang.org/grpc"
+)
+
+func NewAuthClient(cc grpc.ClientConnInterface) *AuthClient {
+	return &AuthClient{auth.NewAuthClient(cc)}
+}
+
+type AuthClient struct {
+	auth.AuthClient
+}
+
+func (x *AuthClient) KickTokens(ctx context.Context, tokens []string) error {
+	if len(tokens) == 0 {
+		return nil
+	}
+	return ignoreResp(x.AuthClient.KickTokens(ctx, &auth.KickTokensReq{Tokens: tokens}))
+}
+
+func (x *AuthClient) InvalidateToken(ctx context.Context, req *auth.InvalidateTokenReq) error {
+	return ignoreResp(x.AuthClient.InvalidateToken(ctx, req))
+}
+
+func (x *AuthClient) ParseToken(ctx context.Context, token string) (*auth.ParseTokenResp, error) {
+	return x.AuthClient.ParseToken(ctx, &auth.ParseTokenReq{Token: token})
+}

pkg/rpcli/conversation.go

@@ -0,0 +1,95 @@
+package rpcli
+
+import (
+	"context"
+
+	"git.imall.cloud/openim/protocol/conversation"
+	"google.golang.org/grpc"
+)
+
+func NewConversationClient(cc grpc.ClientConnInterface) *ConversationClient {
+	return &ConversationClient{conversation.NewConversationClient(cc)}
+}
+
+type ConversationClient struct {
+	conversation.ConversationClient
+}
+
+func (x *ConversationClient) SetConversationMaxSeq(ctx context.Context, conversationID string, ownerUserIDs []string, maxSeq int64) error {
+	if len(ownerUserIDs) == 0 {
+		return nil
+	}
+	req := &conversation.SetConversationMaxSeqReq{ConversationID: conversationID, OwnerUserID: ownerUserIDs, MaxSeq: maxSeq}
+	return ignoreResp(x.ConversationClient.SetConversationMaxSeq(ctx, req))
+}
+
+func (x *ConversationClient) SetConversations(ctx context.Context, ownerUserIDs []string, info *conversation.ConversationReq) error {
+	if len(ownerUserIDs) == 0 {
+		return nil
+	}
+	req := &conversation.SetConversationsReq{UserIDs: ownerUserIDs, Conversation: info}
+	return ignoreResp(x.ConversationClient.SetConversations(ctx, req))
+}
+
+func (x *ConversationClient) GetConversationsByConversationIDs(ctx context.Context, conversationIDs []string) ([]*conversation.Conversation, error) {
+	if len(conversationIDs) == 0 {
+		return nil, nil
+	}
+	req := &conversation.GetConversationsByConversationIDReq{ConversationIDs: conversationIDs}
+	return extractField(ctx, x.ConversationClient.GetConversationsByConversationID, req, (*conversation.GetConversationsByConversationIDResp).GetConversations)
+}
+
+func (x *ConversationClient) GetConversationsByConversationID(ctx context.Context, conversationID string) (*conversation.Conversation, error) {
+	return firstValue(x.GetConversationsByConversationIDs(ctx, []string{conversationID}))
+}
+
+func (x *ConversationClient) SetConversationMinSeq(ctx context.Context, conversationID string, ownerUserIDs []string, minSeq int64) error {
+	if len(ownerUserIDs) == 0 {
+		return nil
+	}
+	req := &conversation.SetConversationMinSeqReq{ConversationID: conversationID, OwnerUserID: ownerUserIDs, MinSeq: minSeq}
+	return ignoreResp(x.ConversationClient.SetConversationMinSeq(ctx, req))
+}
+
+func (x *ConversationClient) GetConversation(ctx context.Context, conversationID string, ownerUserID string) (*conversation.Conversation, error) {
+	req := &conversation.GetConversationReq{ConversationID: conversationID, OwnerUserID: ownerUserID}
+	return extractField(ctx, x.ConversationClient.GetConversation, req, (*conversation.GetConversationResp).GetConversation)
+}
+
+func (x *ConversationClient) GetConversations(ctx context.Context, conversationIDs []string, ownerUserID string) ([]*conversation.Conversation, error) {
+	if len(conversationIDs) == 0 {
+		return nil, nil
+	}
+	req := &conversation.GetConversationsReq{ConversationIDs: conversationIDs, OwnerUserID: ownerUserID}
+	return extractField(ctx, x.ConversationClient.GetConversations, req, (*conversation.GetConversationsResp).GetConversations)
+}
+
+func (x *ConversationClient) GetConversationIDs(ctx context.Context, ownerUserID string) ([]string, error) {
+	req := &conversation.GetConversationIDsReq{UserID: ownerUserID}
+	return extractField(ctx, x.ConversationClient.GetConversationIDs, req, (*conversation.GetConversationIDsResp).GetConversationIDs)
+}
+
+func (x *ConversationClient) GetPinnedConversationIDs(ctx context.Context, ownerUserID string) ([]string, error) {
+	req := &conversation.GetPinnedConversationIDsReq{UserID: ownerUserID}
+	return extractField(ctx, x.ConversationClient.GetPinnedConversationIDs, req, (*conversation.GetPinnedConversationIDsResp).GetConversationIDs)
+}
+
+func (x *ConversationClient) CreateGroupChatConversations(ctx context.Context, groupID string, userIDs []string) error {
+	if len(userIDs) == 0 {
+		return nil
+	}
+	req := &conversation.CreateGroupChatConversationsReq{GroupID: groupID, UserIDs: userIDs}
+	return ignoreResp(x.ConversationClient.CreateGroupChatConversations(ctx, req))
+}
+
+func (x *ConversationClient) CreateSingleChatConversations(ctx context.Context, req *conversation.CreateSingleChatConversationsReq) error {
+	return ignoreResp(x.ConversationClient.CreateSingleChatConversations(ctx, req))
+}
+
+func (x *ConversationClient) GetConversationOfflinePushUserIDs(ctx context.Context, conversationID string, userIDs []string) ([]string, error) {
+	if len(userIDs) == 0 {
+		return nil, nil
+	}
+	req := &conversation.GetConversationOfflinePushUserIDsReq{ConversationID: conversationID, UserIDs: userIDs}
+	return extractField(ctx, x.ConversationClient.GetConversationOfflinePushUserIDs, req, (*conversation.GetConversationOfflinePushUserIDsResp).GetUserIDs)
+}

pkg/rpcli/group.go

@@ -0,0 +1,73 @@
+package rpcli
+
+import (
+	"context"
+
+	"git.imall.cloud/openim/protocol/group"
+	"git.imall.cloud/openim/protocol/sdkws"
+	"google.golang.org/grpc"
+)
+
+func NewGroupClient(cc grpc.ClientConnInterface) *GroupClient {
+	return &GroupClient{group.NewGroupClient(cc)}
+}
+
+type GroupClient struct {
+	group.GroupClient
+}
+
+func (x *GroupClient) GetGroupsInfo(ctx context.Context, groupIDs []string) ([]*sdkws.GroupInfo, error) {
+	if len(groupIDs) == 0 {
+		return nil, nil
+	}
+	req := &group.GetGroupsInfoReq{GroupIDs: groupIDs}
+	return extractField(ctx, x.GroupClient.GetGroupsInfo, req, (*group.GetGroupsInfoResp).GetGroupInfos)
+}
+
+func (x *GroupClient) GetGroupInfo(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
+	return firstValue(x.GetGroupsInfo(ctx, []string{groupID}))
+}
+
+func (x *GroupClient) GetGroupInfoCache(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
+	req := &group.GetGroupInfoCacheReq{GroupID: groupID}
+	return extractField(ctx, x.GroupClient.GetGroupInfoCache, req, (*group.GetGroupInfoCacheResp).GetGroupInfo)
+}
+
+func (x *GroupClient) GetGroupMemberCache(ctx context.Context, groupID string, userID string) (*sdkws.GroupMemberFullInfo, error) {
+	req := &group.GetGroupMemberCacheReq{GroupID: groupID, GroupMemberID: userID}
+	return extractField(ctx, x.GroupClient.GetGroupMemberCache, req, (*group.GetGroupMemberCacheResp).GetMember)
+}
+
+func (x *GroupClient) DismissGroup(ctx context.Context, groupID string, deleteMember bool) error {
+	req := &group.DismissGroupReq{GroupID: groupID, DeleteMember: deleteMember}
+	return ignoreResp(x.GroupClient.DismissGroup(ctx, req))
+}
+
+func (x *GroupClient) GetGroupMemberUserIDs(ctx context.Context, groupID string) ([]string, error) {
+	req := &group.GetGroupMemberUserIDsReq{GroupID: groupID}
+	return extractField(ctx, x.GroupClient.GetGroupMemberUserIDs, req, (*group.GetGroupMemberUserIDsResp).GetUserIDs)
+}
+
+func (x *GroupClient) GetGroupMembersInfo(ctx context.Context, groupID string, userIDs []string) ([]*sdkws.GroupMemberFullInfo, error) {
+	if len(userIDs) == 0 {
+		return nil, nil
+	}
+	req := &group.GetGroupMembersInfoReq{GroupID: groupID, UserIDs: userIDs}
+	return extractField(ctx, x.GroupClient.GetGroupMembersInfo, req, (*group.GetGroupMembersInfoResp).GetMembers)
+}
+
+func (x *GroupClient) GetGroupMemberInfo(ctx context.Context, groupID string, userID string) (*sdkws.GroupMemberFullInfo, error) {
+	return firstValue(x.GetGroupMembersInfo(ctx, groupID, []string{userID}))
+}
+
+func (x *GroupClient) GetGroupMemberMapInfo(ctx context.Context, groupID string, userIDs []string) (map[string]*sdkws.GroupMemberFullInfo, error) {
+	members, err := x.GetGroupMembersInfo(ctx, groupID, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	memberMap := make(map[string]*sdkws.GroupMemberFullInfo)
+	for _, member := range members {
+		memberMap[member.UserID] = member
+	}
+	return memberMap, nil
+}

pkg/rpcli/msg.go

@@ -0,0 +1,92 @@
+package rpcli
+
+import (
+	"context"
+
+	"google.golang.org/grpc"
+
+	"git.imall.cloud/openim/protocol/msg"
+	"git.imall.cloud/openim/protocol/sdkws"
+)
+
+func NewMsgClient(cc grpc.ClientConnInterface) *MsgClient {
+	return &MsgClient{msg.NewMsgClient(cc)}
+}
+
+type MsgClient struct {
+	msg.MsgClient
+}
+
+func (x *MsgClient) GetMaxSeqs(ctx context.Context, conversationIDs []string) (map[string]int64, error) {
+	if len(conversationIDs) == 0 {
+		return nil, nil
+	}
+	req := &msg.GetMaxSeqsReq{ConversationIDs: conversationIDs}
+	return extractField(ctx, x.MsgClient.GetMaxSeqs, req, (*msg.SeqsInfoResp).GetMaxSeqs)
+}
+
+func (x *MsgClient) GetMsgByConversationIDs(ctx context.Context, conversationIDs []string, maxSeqs map[string]int64) (map[string]*sdkws.MsgData, error) {
+	if len(conversationIDs) == 0 || len(maxSeqs) == 0 {
+		return nil, nil
+	}
+	req := &msg.GetMsgByConversationIDsReq{ConversationIDs: conversationIDs, MaxSeqs: maxSeqs}
+	return extractField(ctx, x.MsgClient.GetMsgByConversationIDs, req, (*msg.GetMsgByConversationIDsResp).GetMsgDatas)
+}
+
+func (x *MsgClient) GetHasReadSeqs(ctx context.Context, conversationIDs []string, userID string) (map[string]int64, error) {
+	if len(conversationIDs) == 0 {
+		return nil, nil
+	}
+	req := &msg.GetHasReadSeqsReq{ConversationIDs: conversationIDs, UserID: userID}
+	return extractField(ctx, x.MsgClient.GetHasReadSeqs, req, (*msg.SeqsInfoResp).GetMaxSeqs)
+}
+
+func (x *MsgClient) SetUserConversationMaxSeq(ctx context.Context, conversationID string, ownerUserIDs []string, maxSeq int64) error {
+	if len(ownerUserIDs) == 0 {
+		return nil
+	}
+	req := &msg.SetUserConversationMaxSeqReq{ConversationID: conversationID, OwnerUserID: ownerUserIDs, MaxSeq: maxSeq}
+	return ignoreResp(x.MsgClient.SetUserConversationMaxSeq(ctx, req))
+}
+
+func (x *MsgClient) SetUserConversationMin(ctx context.Context, conversationID string, ownerUserIDs []string, minSeq int64) error {
+	if len(ownerUserIDs) == 0 {
+		return nil
+	}
+	req := &msg.SetUserConversationsMinSeqReq{ConversationID: conversationID, UserIDs: ownerUserIDs, Seq: minSeq}
+	return ignoreResp(x.MsgClient.SetUserConversationsMinSeq(ctx, req))
+}
+
+func (x *MsgClient) GetLastMessageSeqByTime(ctx context.Context, conversationID string, lastTime int64) (int64, error) {
+	req := &msg.GetLastMessageSeqByTimeReq{ConversationID: conversationID, Time: lastTime}
+	return extractField(ctx, x.MsgClient.GetLastMessageSeqByTime, req, (*msg.GetLastMessageSeqByTimeResp).GetSeq)
+}
+
+func (x *MsgClient) GetConversationMaxSeq(ctx context.Context, conversationID string) (int64, error) {
+	req := &msg.GetConversationMaxSeqReq{ConversationID: conversationID}
+	return extractField(ctx, x.MsgClient.GetConversationMaxSeq, req, (*msg.GetConversationMaxSeqResp).GetMaxSeq)
+}
+
+func (x *MsgClient) GetActiveConversation(ctx context.Context, conversationIDs []string) ([]*msg.ActiveConversation, error) {
+	if len(conversationIDs) == 0 {
+		return nil, nil
+	}
+	req := &msg.GetActiveConversationReq{ConversationIDs: conversationIDs}
+	return extractField(ctx, x.MsgClient.GetActiveConversation, req, (*msg.GetActiveConversationResp).GetConversations)
+}
+
+func (x *MsgClient) GetSeqMessage(ctx context.Context, userID string, conversations []*msg.ConversationSeqs) (map[string]*sdkws.PullMsgs, error) {
+	if len(conversations) == 0 {
+		return nil, nil
+	}
+	req := &msg.GetSeqMessageReq{UserID: userID, Conversations: conversations}
+	return extractField(ctx, x.MsgClient.GetSeqMessage, req, (*msg.GetSeqMessageResp).GetMsgs)
+}
+
+func (x *MsgClient) SetUserConversationsMinSeq(ctx context.Context, conversationID string, userIDs []string, seq int64) error {
+	if len(userIDs) == 0 {
+		return nil
+	}
+	req := &msg.SetUserConversationsMinSeqReq{ConversationID: conversationID, UserIDs: userIDs, Seq: seq}
+	return ignoreResp(x.MsgClient.SetUserConversationsMinSeq(ctx, req))
+}

pkg/rpcli/msggateway.go

@@ -0,0 +1,14 @@
+package rpcli
+
+import (
+	"git.imall.cloud/openim/protocol/msggateway"
+	"google.golang.org/grpc"
+)
+
+func NewMsgGatewayClient(cc grpc.ClientConnInterface) *MsgGatewayClient {
+	return &MsgGatewayClient{msggateway.NewMsgGatewayClient(cc)}
+}
+
+type MsgGatewayClient struct {
+	msggateway.MsgGatewayClient
+}

pkg/rpcli/push.go

@@ -0,0 +1,14 @@
+package rpcli
+
+import (
+	"git.imall.cloud/openim/protocol/push"
+	"google.golang.org/grpc"
+)
+
+func NewPushMsgServiceClient(cc grpc.ClientConnInterface) *PushMsgServiceClient {
+	return &PushMsgServiceClient{push.NewPushMsgServiceClient(cc)}
+}
+
+type PushMsgServiceClient struct {
+	push.PushMsgServiceClient
+}

pkg/rpcli/relation.go

@@ -0,0 +1,24 @@
+package rpcli
+
+import (
+	"context"
+
+	"git.imall.cloud/openim/protocol/relation"
+	"google.golang.org/grpc"
+)
+
+func NewRelationClient(cc grpc.ClientConnInterface) *RelationClient {
+	return &RelationClient{relation.NewFriendClient(cc)}
+}
+
+type RelationClient struct {
+	relation.FriendClient
+}
+
+func (x *RelationClient) GetFriendsInfo(ctx context.Context, ownerUserID string, friendUserIDs []string) ([]*relation.FriendInfoOnly, error) {
+	if len(friendUserIDs) == 0 {
+		return nil, nil
+	}
+	req := &relation.GetFriendInfoReq{OwnerUserID: ownerUserID, FriendUserIDs: friendUserIDs}
+	return extractField(ctx, x.FriendClient.GetFriendInfo, req, (*relation.GetFriendInfoResp).GetFriendInfos)
+}

pkg/rpcli/rtc.go

@@ -0,0 +1,14 @@
+package rpcli
+
+import (
+	"git.imall.cloud/openim/protocol/rtc"
+	"google.golang.org/grpc"
+)
+
+func NewRtcServiceClient(cc grpc.ClientConnInterface) *RtcServiceClient {
+	return &RtcServiceClient{rtc.NewRtcServiceClient(cc)}
+}
+
+type RtcServiceClient struct {
+	rtc.RtcServiceClient
+}

pkg/rpcli/third.go

@@ -0,0 +1,14 @@
+package rpcli
+
+import (
+	"git.imall.cloud/openim/protocol/third"
+	"google.golang.org/grpc"
+)
+
+func NewThirdClient(cc grpc.ClientConnInterface) *ThirdClient {
+	return &ThirdClient{third.NewThirdClient(cc)}
+}
+
+type ThirdClient struct {
+	third.ThirdClient
+}

pkg/rpcli/tool.go

@@ -0,0 +1,32 @@
+package rpcli
+
+import (
+	"context"
+	"github.com/openimsdk/tools/errs"
+	"google.golang.org/grpc"
+)
+
+func extractField[A, B, C any](ctx context.Context, fn func(ctx context.Context, req *A, opts ...grpc.CallOption) (*B, error), req *A, get func(*B) C) (C, error) {
+	resp, err := fn(ctx, req)
+	if err != nil {
+		var c C
+		return c, err
+	}
+	return get(resp), nil
+}
+
+func firstValue[A any](val []A, err error) (A, error) {
+	if err != nil {
+		var a A
+		return a, err
+	}
+	if len(val) == 0 {
+		var a A
+		return a, errs.ErrRecordNotFound.WrapMsg("record not found")
+	}
+	return val[0], nil
+}
+
+func ignoreResp(_ any, err error) error {
+	return err
+}

pkg/rpcli/user.go

@@ -0,0 +1,96 @@
+package rpcli
+
+import (
+	"context"
+
+	"git.imall.cloud/openim/protocol/sdkws"
+	"git.imall.cloud/openim/protocol/user"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/utils/datautil"
+	"google.golang.org/grpc"
+)
+
+func NewUserClient(cc grpc.ClientConnInterface) *UserClient {
+	return &UserClient{user.NewUserClient(cc)}
+}
+
+type UserClient struct {
+	user.UserClient
+}
+
+func (x *UserClient) GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) {
+	if len(userIDs) == 0 {
+		return nil, nil
+	}
+	req := &user.GetDesignateUsersReq{UserIDs: userIDs}
+	return extractField(ctx, x.UserClient.GetDesignateUsers, req, (*user.GetDesignateUsersResp).GetUsersInfo)
+}
+
+func (x *UserClient) GetUserInfo(ctx context.Context, userID string) (*sdkws.UserInfo, error) {
+	return firstValue(x.GetUsersInfo(ctx, []string{userID}))
+}
+
+func (x *UserClient) CheckUser(ctx context.Context, userIDs []string) error {
+	if len(userIDs) == 0 {
+		return nil
+	}
+	users, err := x.GetUsersInfo(ctx, userIDs)
+	if err != nil {
+		return err
+	}
+	if len(users) != len(userIDs) {
+		return errs.ErrRecordNotFound.WrapMsg("user not found")
+	}
+	return nil
+}
+
+func (x *UserClient) GetUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
+	users, err := x.GetUsersInfo(ctx, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	return datautil.SliceToMap(users, func(e *sdkws.UserInfo) string {
+		return e.UserID
+	}), nil
+}
+
+func (x *UserClient) GetAllOnlineUsers(ctx context.Context, cursor uint64) (*user.GetAllOnlineUsersResp, error) {
+	req := &user.GetAllOnlineUsersReq{Cursor: cursor}
+	return x.UserClient.GetAllOnlineUsers(ctx, req)
+}
+
+func (x *UserClient) GetUsersOnlinePlatform(ctx context.Context, userIDs []string) ([]*user.OnlineStatus, error) {
+	if len(userIDs) == 0 {
+		return nil, nil
+	}
+	req := &user.GetUserStatusReq{UserIDs: userIDs}
+	return extractField(ctx, x.UserClient.GetUserStatus, req, (*user.GetUserStatusResp).GetStatusList)
+
+}
+
+func (x *UserClient) GetUserOnlinePlatform(ctx context.Context, userID string) ([]int32, error) {
+	status, err := x.GetUsersOnlinePlatform(ctx, []string{userID})
+	if err != nil {
+		return nil, err
+	}
+	if len(status) == 0 {
+		return nil, nil
+	}
+	return status[0].PlatformIDs, nil
+}
+
+func (x *UserClient) SetUserOnlineStatus(ctx context.Context, req *user.SetUserOnlineStatusReq) error {
+	if len(req.Status) == 0 {
+		return nil
+	}
+	return ignoreResp(x.UserClient.SetUserOnlineStatus(ctx, req))
+}
+
+func (x *UserClient) GetNotificationByID(ctx context.Context, userID string) error {
+	return ignoreResp(x.UserClient.GetNotificationAccount(ctx, &user.GetNotificationAccountReq{UserID: userID}))
+}
+
+func (x *UserClient) GetAllUserIDs(ctx context.Context, pageNumber, showNumber int32) ([]string, error) {
+	req := &user.GetAllUserIDReq{Pagination: &sdkws.RequestPagination{PageNumber: pageNumber, ShowNumber: showNumber}}
+	return extractField(ctx, x.UserClient.GetAllUserID, req, (*user.GetAllUserIDResp).GetUserIDs)
+}