feat: update webhookBeforeMemberJoinGroup to batch method.

internal/msggateway/client.go

@@ -397,11 +397,9 @@ func (c *Client) writePongMsg(appData string) error {
 		return nil
 	}
 
-	log.ZDebug(c.ctx, "write Pong Msg in Server", "appData", appData)
 	c.w.Lock()
 	defer c.w.Unlock()
 
-	log.ZDebug(c.ctx, "write Pong Msg in Server", "appData", appData)
 	err := c.conn.SetWriteDeadline(writeWait)
 	if err != nil {
 		log.ZWarn(c.ctx, "SetWriteDeadline in Server have error", errs.Wrap(err), "writeWait", writeWait, "appData", appData)
@@ -412,6 +410,5 @@ func (c *Client) writePongMsg(appData string) error {
 		log.ZWarn(c.ctx, "Write Message have error", errs.Wrap(err), "Pong msg", PongMessage)
 	}
 
-	log.ZDebug(c.ctx, "write message is success", "appdata", appData, "closed err", c.closedErr)
 	return errs.Wrap(err)
 }

internal/rpc/group/callback.go

@@ -16,6 +16,8 @@ package group
 
 import (
 	"context"
+	"time"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/apistruct"
 	"github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
@@ -27,7 +29,6 @@ import (
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
 	"github.com/openimsdk/tools/utils/datautil"
-	"time"
 )
 
 // CallbackBeforeCreateGroup callback before create group.
@@ -125,6 +126,42 @@ func (s *groupServer) webhookBeforeMemberJoinGroup(ctx context.Context, before *
 	})
 }
 
+func (s *groupServer) webhookBeforeMemberJoinGroupBatch(ctx context.Context, before *config.BeforeConfig, groupMembers []*model.GroupMember, groupEx string) error {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		groupMembersMap := datautil.SliceToMap(groupMembers, func(e *model.GroupMember) string {
+			return e.UserID
+		})
+		var groupMembersCallback []*callbackstruct.CallbackGroupMember
+
+		for _, member := range groupMembers {
+			groupMembersCallback = append(groupMembersCallback, &callbackstruct.CallbackGroupMember{
+				UserID:  member.UserID,
+				Ex:      member.Ex,
+				GroupEx: groupEx,
+			})
+		}
+
+		cbReq := &callbackstruct.CallbackBeforeMemberJoinGroupBatchReq{
+			CallbackCommand: callbackstruct.CallbackBeforeMemberJoinGroupBatchCommand,
+			MembersList:     groupMembersCallback,
+		}
+		resp := &callbackstruct.CallbackBeforeMemberJoinGroupBatchResp{}
+
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
+
+		for _, memberCallbackResp := range resp.MemberCallbacks {
+			datautil.NotNilReplace(&groupMembersMap[(*memberCallbackResp.UserID)].FaceURL, memberCallbackResp.FaceURL)
+			datautil.NotNilReplace(&groupMembersMap[(*memberCallbackResp.UserID)].Ex, memberCallbackResp.Ex)
+			datautil.NotNilReplace(&groupMembersMap[(*memberCallbackResp.UserID)].Nickname, memberCallbackResp.Nickname)
+			datautil.NotNilReplace(&groupMembersMap[(*memberCallbackResp.UserID)].RoleLevel, memberCallbackResp.RoleLevel)
+		}
+
+		return nil
+	})
+}
+
 func (s *groupServer) webhookBeforeSetGroupMemberInfo(ctx context.Context, before *config.BeforeConfig, req *group.SetGroupMemberInfo) error {
 	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
 		cbReq := callbackstruct.CallbackBeforeSetGroupMemberInfoReq{

internal/rpc/group/group.go

@@ -246,7 +246,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		return nil, err
 	}
 
-	joinGroup := func(userID string, roleLevel int32) error {
+	joinGroupFunc := func(userID string, roleLevel int32) {
 		groupMember := &model.GroupMember{
 			GroupID:        group.GroupID,
 			UserID:         userID,
@@ -258,25 +258,23 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 			MuteEndTime:    time.UnixMilli(0),
 		}
 
-		if err := s.webhookBeforeMemberJoinGroup(ctx, &s.config.WebhooksConfig.BeforeMemberJoinGroup, groupMember, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
-			return err
-		}
 		groupMembers = append(groupMembers, groupMember)
-		return nil
-	}
-	if err := joinGroup(req.OwnerUserID, constant.GroupOwner); err != nil {
-		return nil, err
 	}
+
+	joinGroupFunc(req.OwnerUserID, constant.GroupOwner)
+
 	for _, userID := range req.AdminUserIDs {
-		if err := joinGroup(userID, constant.GroupAdmin); err != nil {
-			return nil, err
-		}
+		joinGroupFunc(userID, constant.GroupAdmin)
 	}
+
 	for _, userID := range req.MemberUserIDs {
-		if err := joinGroup(userID, constant.GroupOrdinaryUsers); err != nil {
-			return nil, err
+		joinGroupFunc(userID, constant.GroupOrdinaryUsers)
 	}
+
+	if err := s.webhookBeforeMemberJoinGroupBatch(ctx, &s.config.WebhooksConfig.BeforeMemberJoinGroup, groupMembers, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
+		return nil, err
 	}
+
 	if err := s.db.CreateGroup(ctx, []*model.Group{group}, groupMembers); err != nil {
 		return nil, err
 	}
@@ -442,12 +440,13 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 			MuteEndTime:    time.UnixMilli(0),
 		}
 
-		if err := s.webhookBeforeMemberJoinGroup(ctx, &s.config.WebhooksConfig.BeforeMemberJoinGroup, member, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
-			return nil, err
-		}
 		groupMembers = append(groupMembers, member)
+	}
 
+	if err := s.webhookBeforeMemberJoinGroupBatch(ctx, &s.config.WebhooksConfig.BeforeMemberJoinGroup, groupMembers, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
+		return nil, err
 	}
+
 	if err := s.db.CreateGroup(ctx, nil, groupMembers); err != nil {
 		return nil, err
 	}
@@ -811,7 +810,6 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 			MuteEndTime:    time.Unix(0, 0),
 			InviterUserID:  groupRequest.InviterUserID,
 			OperatorUserID: mcontext.GetOpUserID(ctx),
-			Ex:             groupRequest.Ex,
 		}
 		if err := s.webhookBeforeMemberJoinGroup(ctx, &s.config.WebhooksConfig.BeforeMemberJoinGroup, member, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
 			return nil, err
@@ -898,6 +896,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
 
 		return &pbgroup.JoinGroupResp{}, nil
 	}
+
 	groupRequest := model.GroupRequest{
 		UserID:      req.InviterUserID,
 		ReqMsg:      req.ReqMessage,

pkg/callbackstruct/constant.go

@@ -57,6 +57,7 @@ const (
 	CallbackBeforeCreateGroupCommand          = "callbackBeforeCreateGroupCommand"
 	CallbackAfterCreateGroupCommand           = "callbackAfterCreateGroupCommand"
 	CallbackBeforeMemberJoinGroupCommand      = "callbackBeforeMemberJoinGroupCommand"
+	CallbackBeforeMemberJoinGroupBatchCommand = "callbackBeforeMemberJoinGroupBatchCommand"
 	CallbackBeforeSetGroupMemberInfoCommand   = "callbackBeforeSetGroupMemberInfoCommand"
 	CallbackAfterSetGroupMemberInfoCommand    = "callbackAfterSetGroupMemberInfoCommand"
 )

pkg/callbackstruct/group.go

@@ -67,6 +67,30 @@ type CallbackBeforeMemberJoinGroupReq struct {
 	GroupEx         string `json:"groupEx"`
 }
 
+type CallbackGroupMember struct {
+	UserID  string `json:"userID"`
+	Ex      string `json:"ex"`
+	GroupEx string `json:"groupEx"`
+}
+
+type CallbackBeforeMemberJoinGroupBatchReq struct {
+	CallbackCommand `json:"callbackCommand"`
+	MembersList     []*CallbackGroupMember
+}
+
+type MemberJoinGroupCallBack struct {
+	UserID      *string `json:"userID"`
+	Nickname    *string `json:"nickname"`
+	FaceURL     *string `json:"faceURL"`
+	RoleLevel   *int32  `json:"roleLevel"`
+	MuteEndTime *int64  `json:"muteEndTime"`
+	Ex          *string `json:"ex"`
+}
+type CallbackBeforeMemberJoinGroupBatchResp struct {
+	CommonCallbackResp
+	MemberCallbacks []*MemberJoinGroupCallBack
+}
+
 type CallbackBeforeMemberJoinGroupResp struct {
 	CommonCallbackResp
 	Nickname    *string `json:"nickname"`