blackteay/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2025-04-06 04:15:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

1

Browse Source
This commit is contained in:
withchao 2023-02-06 12:14:12 +08:00
parent 8c30bde86e
commit 1b09353991
3 changed files with 74 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
internal/rpc/group/copy.go
View File

@ -1 +1,28 @@
package group
import (
"Open_IM/pkg/common/db/table/relation"
open_im_sdk "Open_IM/pkg/proto/sdk_ws"
)
func ModelToGroupInfo(m *relation.GroupModel, ownerUserID string, memberCount uint32) *open_im_sdk.GroupInfo {
return &open_im_sdk.GroupInfo{
GroupID: m.GroupID,
GroupName: m.GroupName,
Notification: m.Notification,
Introduction: m.Introduction,
FaceURL: m.FaceURL,
OwnerUserID: ownerUserID,
CreateTime: m.CreateTime.UnixMilli(),
MemberCount: memberCount,
Ex: m.Ex,
Status: m.Status,
CreatorUserID: m.CreatorUserID,
GroupType: m.GroupType,
NeedVerification: m.NeedVerification,
LookMemberInfo: m.LookMemberInfo,
ApplyMemberFriend: m.ApplyMemberFriend,
NotificationUpdateTime: m.NotificationUpdateTime.UnixMilli(),
NotificationUserID: m.NotificationUserID,
}
}

26
internal/rpc/group/g.go
View File

@ -37,20 +37,32 @@ import (
// return dbGroupMember, nil
//}
func getUsersInfo(ctx context.Context, userIDs []string) ([]*sdk_ws.UserInfo, error) {
func GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdk_ws.UserInfo, error) {
return nil, nil
}
func getUserMap(ctx context.Context, userIDs []string) (map[string]*sdk_ws.UserInfo, error) {
users, err := getUsersInfo(ctx, userIDs)
func GetUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdk_ws.UserInfo, error) {
users, err := GetUsersInfo(ctx, userIDs)
if err != nil {
return nil, err
}
userMap := make(map[string]*sdk_ws.UserInfo)
for i, user := range users {
userMap[user.UserID] = users[i]
return utils.SliceToMap(users, func(e *sdk_ws.UserInfo) string {
return e.UserID
}), nil
}
func GetPublicUserInfo(ctx context.Context, userIDs []string) ([]*sdk_ws.PublicUserInfo, error) {
return nil, nil
}
func GetPublicUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdk_ws.PublicUserInfo, error) {
users, err := GetPublicUserInfo(ctx, userIDs)
if err != nil {
return nil, err
}
return userMap, nil
return utils.SliceToMap(users, func(e *sdk_ws.PublicUserInfo) string {
return e.UserID
}), nil
}
func genGroupID(ctx context.Context, groupID string) string {

71
internal/rpc/group/group.go
View File

@ -169,11 +169,11 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
if utils.Duplicate(userIDs) {
return nil, constant.ErrArgs.Wrap("group member repeated")
}
userMap, err := getUserMap(ctx, userIDs)
userMap, err := GetUserInfoMap(ctx, userIDs)
if err != nil {
return nil, err
}
if ids := utils.Single(userIDs, utils.MapKey(userMap)); len(ids) > 0 {
if ids := utils.Single(userIDs, utils.Keys(userMap)); len(ids) > 0 {
return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
}
if err := callbackBeforeCreateGroup(ctx, req); err != nil {
@ -290,14 +290,14 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
memberMap := utils.SliceToMap(members, func(e *relation2.GroupMemberModel) string {
return e.UserID
})
if ids := utils.Single(req.InvitedUserIDs, utils.MapKey(memberMap)); len(ids) > 0 {
if ids := utils.Single(req.InvitedUserIDs, utils.Keys(memberMap)); len(ids) > 0 {
return nil, constant.ErrArgs.Wrap("user in group " + strings.Join(ids, ","))
}
userMap, err := getUserMap(ctx, req.InvitedUserIDs)
userMap, err := GetUserInfoMap(ctx, req.InvitedUserIDs)
if err != nil {
return nil, err
}
if ids := utils.Single(req.InvitedUserIDs, utils.MapKey(userMap)); len(ids) > 0 {
if ids := utils.Single(req.InvitedUserIDs, utils.Keys(userMap)); len(ids) > 0 {
return nil, constant.ErrArgs.Wrap("user not found " + strings.Join(ids, ","))
}
if group.NeedVerification == constant.AllNeedVerification {
@ -540,55 +540,40 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
userIDs = append(userIDs, gr.UserID)
groupIDs = append(groupIDs, gr.GroupID)
}
userMap, err := getUserMap(ctx, userIDs)
userIDs = utils.Distinct(userIDs)
groupIDs = utils.Distinct(groupIDs)
userMap, err := GetPublicUserInfoMap(ctx, userIDs)
if err != nil {
return nil, err
}
for _, userID := range userIDs {
if _, ok := userMap[userID]; !ok {
return nil, constant.ErrUserIDNotFound.Wrap(userID)
}
if ids := utils.Single(utils.Keys(userMap), userIDs); len(ids) > 0 {
return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
}
groups, err := s.GroupInterface.FindGroupsByID(ctx, groupIDs)
groups, err := s.GroupInterface.FindGroupsByID(ctx, utils.Distinct(groupIDs))
if err != nil {
return nil, err
}
groupMap := make(map[string]*relation2.GroupModel)
for i, group := range groups {
groupMap[group.GroupID] = groups[i]
groupMap := utils.SliceToMap(groups, func(e *relation2.GroupModel) string {
return e.GroupID
})
if ids := utils.Single(utils.Keys(groupMap), groupIDs); len(ids) > 0 {
return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
}
groupMemberNumMap, err := s.GroupInterface.GetGroupMemberNum(ctx, groupIDs)
if err != nil {
return nil, err
}
groupOwnerUserIDMap, err := s.GroupInterface.GetGroupOwnerUserID(ctx, groupIDs)
if err != nil {
return nil, err
}
for _, gr := range groupRequests {
groupRequest := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
groupRequest := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}}
utils.CopyStructFields(&groupRequest, gr)
getUserMap()
groupRequest.UserInfo = userMap[gr.UserID]
groupRequest.GroupInfo = ModelToGroupInfo(groupMap[gr.GroupID], groupOwnerUserIDMap[gr.GroupID], uint32(groupMemberNumMap[gr.GroupID]))
resp.GroupRequests = append(resp.GroupRequests, &groupRequest)
}
var errResult error
tracelog.SetCtxInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", groupRequests)
for _, v := range groupRequests {
node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
err := FillGroupInfoByGroupID(tracelog.GetOperationID(ctx), v.GroupID, node.GroupInfo)
if err != nil {
if !errors.Is(errors.Unwrap(err), constant.ErrDismissedAlready) {
errResult = err
}
continue
}
tracelog.SetCtxInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo)
err = FillPublicUserInfoByUserID(tracelog.GetOperationID(ctx), v.UserID, node.UserInfo)
if err != nil {
errResult = err
continue
}
cp.GroupRequestDBCopyOpenIM(&node, &v)
resp.GroupRequestList = append(resp.GroupRequestList, &node)
}
if errResult != nil && len(resp.GroupRequestList) == 0 {
return nil, err
}
tracelog.SetRpcRespInfo(ctx, utils.GetSelfFuncName(), resp.String())
return resp, nil
}