1

internal/rpc/group/copy.go

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

internal/rpc/group/g.go

@@ -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) {
+func GetUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdk_ws.UserInfo, error) {
-	users, err := getUsersInfo(ctx, userIDs)
+	users, err := GetUsersInfo(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}
-	userMap := make(map[string]*sdk_ws.UserInfo)
+	return utils.SliceToMap(users, func(e *sdk_ws.UserInfo) string {
-	for i, user := range users {
+		return e.UserID
-		userMap[user.UserID] = users[i]
+	}), 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 {

internal/rpc/group/group.go

@@ -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 ids := utils.Single(utils.Keys(userMap), userIDs); len(ids) > 0 {
-		if _, ok := userMap[userID]; !ok {
+		return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-			return nil, constant.ErrUserIDNotFound.Wrap(userID)
-		}
 	}
-	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)
+	groupMap := utils.SliceToMap(groups, func(e *relation2.GroupModel) string {
-	for i, group := range groups {
+		return e.GroupID
-		groupMap[group.GroupID] = groups[i]
+	})
-	}
+	if ids := utils.Single(utils.Keys(groupMap), groupIDs); len(ids) > 0 {
-
+		return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
-	for _, gr := range groupRequests {
-		groupRequest := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
-		utils.CopyStructFields(&groupRequest, gr)
-		getUserMap()
-
 	}
-
+	groupMemberNumMap, err := s.GroupInterface.GetGroupMemberNum(ctx, groupIDs)
-	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) {
+		return nil, err
-				errResult = err
-			}
-			continue
 	}
-		tracelog.SetCtxInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo)
+	groupOwnerUserIDMap, err := s.GroupInterface.GetGroupOwnerUserID(ctx, groupIDs)
-		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())
+	for _, gr := range groupRequests {
+		groupRequest := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}}
+		utils.CopyStructFields(&groupRequest, gr)
+		groupRequest.UserInfo = userMap[gr.UserID]
+		groupRequest.GroupInfo = ModelToGroupInfo(groupMap[gr.GroupID], groupOwnerUserIDMap[gr.GroupID], uint32(groupMemberNumMap[gr.GroupID]))
+		resp.GroupRequests = append(resp.GroupRequests, &groupRequest)
+	}
 	return resp, nil
 }