fix: callback update.

internal/push/callback.go

@@ -16,6 +16,7 @@ package push
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
@@ -26,71 +27,75 @@ import (
 )
 
 func (p *Pusher) webhookBeforeOfflinePush(ctx context.Context, before *config.BeforeConfig, userIDs []string, msg *sdkws.MsgData, offlinePushUserIDs *[]string) error {
-	if msg.ContentType == constant.Typing {
-		return nil
-	}
-	req := &callbackstruct.CallbackBeforePushReq{
-		UserStatusBatchCallbackReq: callbackstruct.UserStatusBatchCallbackReq{
-			UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
-				CallbackCommand: callbackstruct.CallbackBeforeOfflinePushCommand,
-				OperationID:     mcontext.GetOperationID(ctx),
-				PlatformID:      int(msg.SenderPlatformID),
-				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		if msg.ContentType == constant.Typing {
+			return nil
+		}
+		req := &callbackstruct.CallbackBeforePushReq{
+			UserStatusBatchCallbackReq: callbackstruct.UserStatusBatchCallbackReq{
+				UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
+					CallbackCommand: callbackstruct.CallbackBeforeOfflinePushCommand,
+					OperationID:     mcontext.GetOperationID(ctx),
+					PlatformID:      int(msg.SenderPlatformID),
+					Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+				},
+				UserIDList: userIDs,
 			},
-			UserIDList: userIDs,
-		},
-		OfflinePushInfo: msg.OfflinePushInfo,
-		ClientMsgID:     msg.ClientMsgID,
-		SendID:          msg.SendID,
-		GroupID:         msg.GroupID,
-		ContentType:     msg.ContentType,
-		SessionType:     msg.SessionType,
-		AtUserIDs:       msg.AtUserIDList,
-		Content:         GetContent(msg),
-	}
+			OfflinePushInfo: msg.OfflinePushInfo,
+			ClientMsgID:     msg.ClientMsgID,
+			SendID:          msg.SendID,
+			GroupID:         msg.GroupID,
+			ContentType:     msg.ContentType,
+			SessionType:     msg.SessionType,
+			AtUserIDs:       msg.AtUserIDList,
+			Content:         GetContent(msg),
+		}
 
-	resp := &callbackstruct.CallbackBeforePushResp{}
+		resp := &callbackstruct.CallbackBeforePushResp{}
 
-	if err := p.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
-		return err
-	}
+		if err := p.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
+			return err
+		}
 
-	if len(resp.UserIDs) != 0 {
-		*offlinePushUserIDs = resp.UserIDs
-	}
-	if resp.OfflinePushInfo != nil {
-		msg.OfflinePushInfo = resp.OfflinePushInfo
-	}
-	return nil
+		if len(resp.UserIDs) != 0 {
+			*offlinePushUserIDs = resp.UserIDs
+		}
+		if resp.OfflinePushInfo != nil {
+			msg.OfflinePushInfo = resp.OfflinePushInfo
+		}
+		return nil
+	})
 }
 
 func (p *Pusher) webhookBeforeOnlinePush(ctx context.Context, before *config.BeforeConfig, userIDs []string, msg *sdkws.MsgData) error {
-	if datautil.Contain(msg.SendID, userIDs...) || msg.ContentType == constant.Typing {
-		return nil
-	}
-	req := callbackstruct.CallbackBeforePushReq{
-		UserStatusBatchCallbackReq: callbackstruct.UserStatusBatchCallbackReq{
-			UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
-				CallbackCommand: callbackstruct.CallbackBeforeOnlinePushCommand,
-				OperationID:     mcontext.GetOperationID(ctx),
-				PlatformID:      int(msg.SenderPlatformID),
-				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		if datautil.Contain(msg.SendID, userIDs...) || msg.ContentType == constant.Typing {
+			return nil
+		}
+		req := callbackstruct.CallbackBeforePushReq{
+			UserStatusBatchCallbackReq: callbackstruct.UserStatusBatchCallbackReq{
+				UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
+					CallbackCommand: callbackstruct.CallbackBeforeOnlinePushCommand,
+					OperationID:     mcontext.GetOperationID(ctx),
+					PlatformID:      int(msg.SenderPlatformID),
+					Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+				},
+				UserIDList: userIDs,
 			},
-			UserIDList: userIDs,
-		},
-		ClientMsgID: msg.ClientMsgID,
-		SendID:      msg.SendID,
-		GroupID:     msg.GroupID,
-		ContentType: msg.ContentType,
-		SessionType: msg.SessionType,
-		AtUserIDs:   msg.AtUserIDList,
-		Content:     GetContent(msg),
-	}
-	resp := &callbackstruct.CallbackBeforePushResp{}
-	if err := p.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
-		return err
-	}
-	return nil
+			ClientMsgID: msg.ClientMsgID,
+			SendID:      msg.SendID,
+			GroupID:     msg.GroupID,
+			ContentType: msg.ContentType,
+			SessionType: msg.SessionType,
+			AtUserIDs:   msg.AtUserIDList,
+			Content:     GetContent(msg),
+		}
+		resp := &callbackstruct.CallbackBeforePushResp{}
+		if err := p.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
+			return err
+		}
+		return nil
+	})
 }
 
 func (p *Pusher) webhookBeforeGroupOnlinePush(
@@ -100,31 +105,33 @@ func (p *Pusher) webhookBeforeGroupOnlinePush(
 	msg *sdkws.MsgData,
 	pushToUserIDs *[]string,
 ) error {
-	if msg.ContentType == constant.Typing {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		if msg.ContentType == constant.Typing {
+			return nil
+		}
+		req := callbackstruct.CallbackBeforeSuperGroupOnlinePushReq{
+			UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
+				CallbackCommand: callbackstruct.CallbackBeforeGroupOnlinePushCommand,
+				OperationID:     mcontext.GetOperationID(ctx),
+				PlatformID:      int(msg.SenderPlatformID),
+				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+			},
+			ClientMsgID: msg.ClientMsgID,
+			SendID:      msg.SendID,
+			GroupID:     groupID,
+			ContentType: msg.ContentType,
+			SessionType: msg.SessionType,
+			AtUserIDs:   msg.AtUserIDList,
+			Content:     GetContent(msg),
+			Seq:         msg.Seq,
+		}
+		resp := &callbackstruct.CallbackBeforeSuperGroupOnlinePushResp{}
+		if err := p.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
+			return err
+		}
+		if len(resp.UserIDs) != 0 {
+			*pushToUserIDs = resp.UserIDs
+		}
 		return nil
-	}
-	req := callbackstruct.CallbackBeforeSuperGroupOnlinePushReq{
-		UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
-			CallbackCommand: callbackstruct.CallbackBeforeGroupOnlinePushCommand,
-			OperationID:     mcontext.GetOperationID(ctx),
-			PlatformID:      int(msg.SenderPlatformID),
-			Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
-		},
-		ClientMsgID: msg.ClientMsgID,
-		SendID:      msg.SendID,
-		GroupID:     groupID,
-		ContentType: msg.ContentType,
-		SessionType: msg.SessionType,
-		AtUserIDs:   msg.AtUserIDList,
-		Content:     GetContent(msg),
-		Seq:         msg.Seq,
-	}
-	resp := &callbackstruct.CallbackBeforeSuperGroupOnlinePushResp{}
-	if err := p.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
-		return err
-	}
-	if len(resp.UserIDs) != 0 {
-		*pushToUserIDs = resp.UserIDs
-	}
-	return nil
+	})
 }

internal/rpc/friend/callback.go

@@ -16,6 +16,7 @@ package friend
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 
 	cbapi "github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
@@ -32,19 +33,21 @@ func (s *friendServer) webhookAfterDeleteFriend(ctx context.Context, after *conf
 }
 
 func (s *friendServer) webhookBeforeAddFriend(ctx context.Context, before *config.BeforeConfig, req *pbfriend.ApplyToAddFriendReq) error {
-	cbReq := &cbapi.CallbackBeforeAddFriendReq{
-		CallbackCommand: cbapi.CallbackBeforeAddFriendCommand,
-		FromUserID:      req.FromUserID,
-		ToUserID:        req.ToUserID,
-		ReqMsg:          req.ReqMsg,
-		Ex:              req.Ex,
-	}
-	resp := &cbapi.CallbackBeforeAddFriendResp{}
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeAddFriendReq{
+			CallbackCommand: cbapi.CallbackBeforeAddFriendCommand,
+			FromUserID:      req.FromUserID,
+			ToUserID:        req.ToUserID,
+			ReqMsg:          req.ReqMsg,
+			Ex:              req.Ex,
+		}
+		resp := &cbapi.CallbackBeforeAddFriendResp{}
 
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
-	return nil
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
+		return nil
+	})
 }
 
 func (s *friendServer) webhookAfterAddFriend(ctx context.Context, after *config.AfterConfig, req *pbfriend.ApplyToAddFriendReq) {
@@ -91,65 +94,64 @@ func (s *friendServer) webhookAfterRemoveBlack(ctx context.Context, after *confi
 }
 
 func (s *friendServer) webhookBeforeSetFriendRemark(ctx context.Context, before *config.BeforeConfig, req *pbfriend.SetFriendRemarkReq) error {
-	cbReq := &cbapi.CallbackBeforeSetFriendRemarkReq{
-		CallbackCommand: cbapi.CallbackBeforeSetFriendRemarkCommand,
-		OwnerUserID:     req.OwnerUserID,
-		FriendUserID:    req.FriendUserID,
-		Remark:          req.Remark,
-	}
-	resp := &cbapi.CallbackBeforeSetFriendRemarkResp{}
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
-	if resp.Remark != "" {
-		req.Remark = resp.Remark
-	}
-	return nil
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeSetFriendRemarkReq{
+			CallbackCommand: cbapi.CallbackBeforeSetFriendRemarkCommand,
+			OwnerUserID:     req.OwnerUserID,
+			FriendUserID:    req.FriendUserID,
+			Remark:          req.Remark,
+		}
+		resp := &cbapi.CallbackBeforeSetFriendRemarkResp{}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
+		if resp.Remark != "" {
+			req.Remark = resp.Remark
+		}
+		return nil
+	})
 }
 
 func (s *friendServer) webhookBeforeAddBlack(ctx context.Context, before *config.BeforeConfig, req *pbfriend.AddBlackReq) error {
-	if !before.Enable {
-		return nil
-	}
-	cbReq := &cbapi.CallbackBeforeAddBlackReq{
-		CallbackCommand: cbapi.CallbackBeforeAddBlackCommand,
-		OwnerUserID:     req.OwnerUserID,
-		BlackUserID:     req.BlackUserID,
-	}
-	resp := &cbapi.CallbackBeforeAddBlackResp{}
-	return s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before)
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeAddBlackReq{
+			CallbackCommand: cbapi.CallbackBeforeAddBlackCommand,
+			OwnerUserID:     req.OwnerUserID,
+			BlackUserID:     req.BlackUserID,
+		}
+		resp := &cbapi.CallbackBeforeAddBlackResp{}
+		return s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before)
+	})
 }
 
 func (s *friendServer) webhookBeforeAddFriendAgree(ctx context.Context, before *config.BeforeConfig, req *pbfriend.RespondFriendApplyReq) error {
-	if !before.Enable {
-		return nil
-	}
-	cbReq := &cbapi.CallbackBeforeAddFriendAgreeReq{
-		CallbackCommand: cbapi.CallbackBeforeAddFriendAgreeCommand,
-		FromUserID:      req.FromUserID,
-		ToUserID:        req.ToUserID,
-		HandleMsg:       req.HandleMsg,
-		HandleResult:    req.HandleResult,
-	}
-	resp := &cbapi.CallbackBeforeAddFriendAgreeResp{}
-	return s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before)
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeAddFriendAgreeReq{
+			CallbackCommand: cbapi.CallbackBeforeAddFriendAgreeCommand,
+			FromUserID:      req.FromUserID,
+			ToUserID:        req.ToUserID,
+			HandleMsg:       req.HandleMsg,
+			HandleResult:    req.HandleResult,
+		}
+		resp := &cbapi.CallbackBeforeAddFriendAgreeResp{}
+		return s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before)
+	})
 }
 
 func (s *friendServer) webhookBeforeImportFriends(ctx context.Context, before *config.BeforeConfig, req *pbfriend.ImportFriendReq) error {
-	if !before.Enable {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeImportFriendsReq{
+			CallbackCommand: cbapi.CallbackBeforeImportFriendsCommand,
+			OwnerUserID:     req.OwnerUserID,
+			FriendUserIDs:   req.FriendUserIDs,
+		}
+		resp := &cbapi.CallbackBeforeImportFriendsResp{}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
+		if len(resp.FriendUserIDs) > 0 {
+			req.FriendUserIDs = resp.FriendUserIDs
+		}
 		return nil
-	}
-	cbReq := &cbapi.CallbackBeforeImportFriendsReq{
-		CallbackCommand: cbapi.CallbackBeforeImportFriendsCommand,
-		OwnerUserID:     req.OwnerUserID,
-		FriendUserIDs:   req.FriendUserIDs,
-	}
-	resp := &cbapi.CallbackBeforeImportFriendsResp{}
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
-	if len(resp.FriendUserIDs) > 0 {
-		req.FriendUserIDs = resp.FriendUserIDs
-	}
-	return nil
+	})
 }

internal/rpc/group/callback.go

@@ -20,6 +20,7 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/protocol/wrapperspb"
@@ -31,46 +32,48 @@ import (
 
 // CallbackBeforeCreateGroup callback before create group.
 func (s *groupServer) webhookBeforeCreateGroup(ctx context.Context, before *config.BeforeConfig, req *group.CreateGroupReq) error {
-	cbReq := &callbackstruct.CallbackBeforeCreateGroupReq{
-		CallbackCommand: callbackstruct.CallbackBeforeCreateGroupCommand,
-		OperationID:     mcontext.GetOperationID(ctx),
-		GroupInfo:       req.GroupInfo,
-	}
-	cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
-		UserID:    req.OwnerUserID,
-		RoleLevel: constant.GroupOwner,
-	})
-	for _, userID := range req.AdminUserIDs {
-		cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
-			UserID:    userID,
-			RoleLevel: constant.GroupAdmin,
-		})
-	}
-	for _, userID := range req.MemberUserIDs {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &callbackstruct.CallbackBeforeCreateGroupReq{
+			CallbackCommand: callbackstruct.CallbackBeforeCreateGroupCommand,
+			OperationID:     mcontext.GetOperationID(ctx),
+			GroupInfo:       req.GroupInfo,
+		}
 		cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
-			UserID:    userID,
-			RoleLevel: constant.GroupOrdinaryUsers,
+			UserID:    req.OwnerUserID,
+			RoleLevel: constant.GroupOwner,
 		})
-	}
-	resp := &callbackstruct.CallbackBeforeCreateGroupResp{}
+		for _, userID := range req.AdminUserIDs {
+			cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+				UserID:    userID,
+				RoleLevel: constant.GroupAdmin,
+			})
+		}
+		for _, userID := range req.MemberUserIDs {
+			cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+				UserID:    userID,
+				RoleLevel: constant.GroupOrdinaryUsers,
+			})
+		}
+		resp := &callbackstruct.CallbackBeforeCreateGroupResp{}
 
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
 
-	datautil.NotNilReplace(&req.GroupInfo.GroupID, resp.GroupID)
-	datautil.NotNilReplace(&req.GroupInfo.GroupName, resp.GroupName)
-	datautil.NotNilReplace(&req.GroupInfo.Notification, resp.Notification)
-	datautil.NotNilReplace(&req.GroupInfo.Introduction, resp.Introduction)
-	datautil.NotNilReplace(&req.GroupInfo.FaceURL, resp.FaceURL)
-	datautil.NotNilReplace(&req.GroupInfo.OwnerUserID, resp.OwnerUserID)
-	datautil.NotNilReplace(&req.GroupInfo.Ex, resp.Ex)
-	datautil.NotNilReplace(&req.GroupInfo.Status, resp.Status)
-	datautil.NotNilReplace(&req.GroupInfo.CreatorUserID, resp.CreatorUserID)
-	datautil.NotNilReplace(&req.GroupInfo.GroupType, resp.GroupType)
-	datautil.NotNilReplace(&req.GroupInfo.NeedVerification, resp.NeedVerification)
-	datautil.NotNilReplace(&req.GroupInfo.LookMemberInfo, resp.LookMemberInfo)
-	return nil
+		datautil.NotNilReplace(&req.GroupInfo.GroupID, resp.GroupID)
+		datautil.NotNilReplace(&req.GroupInfo.GroupName, resp.GroupName)
+		datautil.NotNilReplace(&req.GroupInfo.Notification, resp.Notification)
+		datautil.NotNilReplace(&req.GroupInfo.Introduction, resp.Introduction)
+		datautil.NotNilReplace(&req.GroupInfo.FaceURL, resp.FaceURL)
+		datautil.NotNilReplace(&req.GroupInfo.OwnerUserID, resp.OwnerUserID)
+		datautil.NotNilReplace(&req.GroupInfo.Ex, resp.Ex)
+		datautil.NotNilReplace(&req.GroupInfo.Status, resp.Status)
+		datautil.NotNilReplace(&req.GroupInfo.CreatorUserID, resp.CreatorUserID)
+		datautil.NotNilReplace(&req.GroupInfo.GroupType, resp.GroupType)
+		datautil.NotNilReplace(&req.GroupInfo.NeedVerification, resp.NeedVerification)
+		datautil.NotNilReplace(&req.GroupInfo.LookMemberInfo, resp.LookMemberInfo)
+		return nil
+	})
 }
 
 func (s *groupServer) webhookAfterCreateGroup(ctx context.Context, after *config.AfterConfig, req *group.CreateGroupReq) {
@@ -98,63 +101,67 @@ func (s *groupServer) webhookAfterCreateGroup(ctx context.Context, after *config
 }
 
 func (s *groupServer) webhookBeforeMemberJoinGroup(ctx context.Context, before *config.BeforeConfig, groupMember *relation.GroupMemberModel, groupEx string) error {
-	cbReq := &callbackstruct.CallbackBeforeMemberJoinGroupReq{
-		CallbackCommand: callbackstruct.CallbackBeforeMemberJoinGroupCommand,
-		GroupID:         groupMember.GroupID,
-		UserID:          groupMember.UserID,
-		Ex:              groupMember.Ex,
-		GroupEx:         groupEx,
-	}
-	resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{}
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &callbackstruct.CallbackBeforeMemberJoinGroupReq{
+			CallbackCommand: callbackstruct.CallbackBeforeMemberJoinGroupCommand,
+			GroupID:         groupMember.GroupID,
+			UserID:          groupMember.UserID,
+			Ex:              groupMember.Ex,
+			GroupEx:         groupEx,
+		}
+		resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
 
-	if resp.MuteEndTime != nil {
-		groupMember.MuteEndTime = time.UnixMilli(*resp.MuteEndTime)
-	}
-	datautil.NotNilReplace(&groupMember.FaceURL, resp.FaceURL)
-	datautil.NotNilReplace(&groupMember.Ex, resp.Ex)
-	datautil.NotNilReplace(&groupMember.Nickname, resp.Nickname)
-	datautil.NotNilReplace(&groupMember.RoleLevel, resp.RoleLevel)
-	return nil
+		if resp.MuteEndTime != nil {
+			groupMember.MuteEndTime = time.UnixMilli(*resp.MuteEndTime)
+		}
+		datautil.NotNilReplace(&groupMember.FaceURL, resp.FaceURL)
+		datautil.NotNilReplace(&groupMember.Ex, resp.Ex)
+		datautil.NotNilReplace(&groupMember.Nickname, resp.Nickname)
+		datautil.NotNilReplace(&groupMember.RoleLevel, resp.RoleLevel)
+		return nil
+	})
 }
 
 func (s *groupServer) webhookBeforeSetGroupMemberInfo(ctx context.Context, before *config.BeforeConfig, req *group.SetGroupMemberInfo) error {
-	cbReq := callbackstruct.CallbackBeforeSetGroupMemberInfoReq{
-		CallbackCommand: callbackstruct.CallbackBeforeSetGroupMemberInfoCommand,
-		GroupID:         req.GroupID,
-		UserID:          req.UserID,
-	}
-	if req.Nickname != nil {
-		cbReq.Nickname = &req.Nickname.Value
-	}
-	if req.FaceURL != nil {
-		cbReq.FaceURL = &req.FaceURL.Value
-	}
-	if req.RoleLevel != nil {
-		cbReq.RoleLevel = &req.RoleLevel.Value
-	}
-	if req.Ex != nil {
-		cbReq.Ex = &req.Ex.Value
-	}
-	resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{}
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
-	if resp.FaceURL != nil {
-		req.FaceURL = wrapperspb.String(*resp.FaceURL)
-	}
-	if resp.Nickname != nil {
-		req.Nickname = wrapperspb.String(*resp.Nickname)
-	}
-	if resp.RoleLevel != nil {
-		req.RoleLevel = wrapperspb.Int32(*resp.RoleLevel)
-	}
-	if resp.Ex != nil {
-		req.Ex = wrapperspb.String(*resp.Ex)
-	}
-	return nil
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := callbackstruct.CallbackBeforeSetGroupMemberInfoReq{
+			CallbackCommand: callbackstruct.CallbackBeforeSetGroupMemberInfoCommand,
+			GroupID:         req.GroupID,
+			UserID:          req.UserID,
+		}
+		if req.Nickname != nil {
+			cbReq.Nickname = &req.Nickname.Value
+		}
+		if req.FaceURL != nil {
+			cbReq.FaceURL = &req.FaceURL.Value
+		}
+		if req.RoleLevel != nil {
+			cbReq.RoleLevel = &req.RoleLevel.Value
+		}
+		if req.Ex != nil {
+			cbReq.Ex = &req.Ex.Value
+		}
+		resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
+		if resp.FaceURL != nil {
+			req.FaceURL = wrapperspb.String(*resp.FaceURL)
+		}
+		if resp.Nickname != nil {
+			req.Nickname = wrapperspb.String(*resp.Nickname)
+		}
+		if resp.RoleLevel != nil {
+			req.RoleLevel = wrapperspb.Int32(*resp.RoleLevel)
+		}
+		if resp.Ex != nil {
+			req.Ex = wrapperspb.String(*resp.Ex)
+		}
+		return nil
+	})
 }
 
 func (s *groupServer) webhookAfterSetGroupMemberInfo(ctx context.Context, after *config.AfterConfig, req *group.SetGroupMemberInfo) {
@@ -202,12 +209,14 @@ func (s *groupServer) webhookAfterDismissGroup(ctx context.Context, after *confi
 }
 
 func (s *groupServer) webhookBeforeApplyJoinGroup(ctx context.Context, before *config.BeforeConfig, req *callbackstruct.CallbackJoinGroupReq) (err error) {
-	req.CallbackCommand = callbackstruct.CallbackBeforeJoinGroupCommand
-	resp := &callbackstruct.CallbackJoinGroupResp{}
-	if err := s.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
-		return err
-	}
-	return nil
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		req.CallbackCommand = callbackstruct.CallbackBeforeJoinGroupCommand
+		resp := &callbackstruct.CallbackJoinGroupResp{}
+		if err := s.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
+			return err
+		}
+		return nil
+	})
 }
 
 func (s *groupServer) webhookAfterTransferGroupOwner(ctx context.Context, after *config.AfterConfig, req *group.TransferGroupOwnerReq) {
@@ -221,24 +230,26 @@ func (s *groupServer) webhookAfterTransferGroupOwner(ctx context.Context, after
 }
 
 func (s *groupServer) webhookBeforeInviteUserToGroup(ctx context.Context, before *config.BeforeConfig, req *group.InviteUserToGroupReq) (err error) {
-	cbReq := &callbackstruct.CallbackBeforeInviteUserToGroupReq{
-		CallbackCommand: callbackstruct.CallbackBeforeInviteJoinGroupCommand,
-		OperationID:     mcontext.GetOperationID(ctx),
-		GroupID:         req.GroupID,
-		Reason:          req.Reason,
-		InvitedUserIDs:  req.InvitedUserIDs,
-	}
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &callbackstruct.CallbackBeforeInviteUserToGroupReq{
+			CallbackCommand: callbackstruct.CallbackBeforeInviteJoinGroupCommand,
+			OperationID:     mcontext.GetOperationID(ctx),
+			GroupID:         req.GroupID,
+			Reason:          req.Reason,
+			InvitedUserIDs:  req.InvitedUserIDs,
+		}
 
-	resp := &callbackstruct.CallbackBeforeInviteUserToGroupResp{}
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
+		resp := &callbackstruct.CallbackBeforeInviteUserToGroupResp{}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
 
-	if len(resp.RefusedMembersAccount) > 0 {
-		// Handle the scenario where certain members are refused
-		// You might want to update the req.Members list or handle it as per your business logic
-	}
-	return nil
+		if len(resp.RefusedMembersAccount) > 0 {
+			// Handle the scenario where certain members are refused
+			// You might want to update the req.Members list or handle it as per your business logic
+		}
+		return nil
+	})
 }
 
 func (s *groupServer) webhookAfterJoinGroup(ctx context.Context, after *config.AfterConfig, req *group.JoinGroupReq) {
@@ -254,53 +265,52 @@ func (s *groupServer) webhookAfterJoinGroup(ctx context.Context, after *config.A
 }
 
 func (s *groupServer) webhookBeforeSetGroupInfo(ctx context.Context, before *config.BeforeConfig, req *group.SetGroupInfoReq) error {
-	if !before.Enable {
-		return nil
-	}
-	cbReq := &callbackstruct.CallbackBeforeSetGroupInfoReq{
-		CallbackCommand: callbackstruct.CallbackBeforeSetGroupInfoCommand,
-		GroupID:         req.GroupInfoForSet.GroupID,
-		Notification:    req.GroupInfoForSet.Notification,
-		Introduction:    req.GroupInfoForSet.Introduction,
-		FaceURL:         req.GroupInfoForSet.FaceURL,
-		GroupName:       req.GroupInfoForSet.GroupName,
-	}
-	if req.GroupInfoForSet.Ex != nil {
-		cbReq.Ex = req.GroupInfoForSet.Ex.Value
-	}
-	log.ZDebug(ctx, "debug CallbackBeforeSetGroupInfo", "ex", cbReq.Ex)
-	if req.GroupInfoForSet.NeedVerification != nil {
-		cbReq.NeedVerification = req.GroupInfoForSet.NeedVerification.Value
-	}
-	if req.GroupInfoForSet.LookMemberInfo != nil {
-		cbReq.LookMemberInfo = req.GroupInfoForSet.LookMemberInfo.Value
-	}
-	if req.GroupInfoForSet.ApplyMemberFriend != nil {
-		cbReq.ApplyMemberFriend = req.GroupInfoForSet.ApplyMemberFriend.Value
-	}
-	resp := &callbackstruct.CallbackBeforeSetGroupInfoResp{}
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &callbackstruct.CallbackBeforeSetGroupInfoReq{
+			CallbackCommand: callbackstruct.CallbackBeforeSetGroupInfoCommand,
+			GroupID:         req.GroupInfoForSet.GroupID,
+			Notification:    req.GroupInfoForSet.Notification,
+			Introduction:    req.GroupInfoForSet.Introduction,
+			FaceURL:         req.GroupInfoForSet.FaceURL,
+			GroupName:       req.GroupInfoForSet.GroupName,
+		}
+		if req.GroupInfoForSet.Ex != nil {
+			cbReq.Ex = req.GroupInfoForSet.Ex.Value
+		}
+		log.ZDebug(ctx, "debug CallbackBeforeSetGroupInfo", "ex", cbReq.Ex)
+		if req.GroupInfoForSet.NeedVerification != nil {
+			cbReq.NeedVerification = req.GroupInfoForSet.NeedVerification.Value
+		}
+		if req.GroupInfoForSet.LookMemberInfo != nil {
+			cbReq.LookMemberInfo = req.GroupInfoForSet.LookMemberInfo.Value
+		}
+		if req.GroupInfoForSet.ApplyMemberFriend != nil {
+			cbReq.ApplyMemberFriend = req.GroupInfoForSet.ApplyMemberFriend.Value
+		}
+		resp := &callbackstruct.CallbackBeforeSetGroupInfoResp{}
 
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
 
-	if resp.Ex != nil {
-		req.GroupInfoForSet.Ex = wrapperspb.String(*resp.Ex)
-	}
-	if resp.NeedVerification != nil {
-		req.GroupInfoForSet.NeedVerification = wrapperspb.Int32(*resp.NeedVerification)
-	}
-	if resp.LookMemberInfo != nil {
-		req.GroupInfoForSet.LookMemberInfo = wrapperspb.Int32(*resp.LookMemberInfo)
-	}
-	if resp.ApplyMemberFriend != nil {
-		req.GroupInfoForSet.ApplyMemberFriend = wrapperspb.Int32(*resp.ApplyMemberFriend)
-	}
-	datautil.NotNilReplace(&req.GroupInfoForSet.GroupID, &resp.GroupID)
-	datautil.NotNilReplace(&req.GroupInfoForSet.GroupName, &resp.GroupName)
-	datautil.NotNilReplace(&req.GroupInfoForSet.FaceURL, &resp.FaceURL)
-	datautil.NotNilReplace(&req.GroupInfoForSet.Introduction, &resp.Introduction)
-	return nil
+		if resp.Ex != nil {
+			req.GroupInfoForSet.Ex = wrapperspb.String(*resp.Ex)
+		}
+		if resp.NeedVerification != nil {
+			req.GroupInfoForSet.NeedVerification = wrapperspb.Int32(*resp.NeedVerification)
+		}
+		if resp.LookMemberInfo != nil {
+			req.GroupInfoForSet.LookMemberInfo = wrapperspb.Int32(*resp.LookMemberInfo)
+		}
+		if resp.ApplyMemberFriend != nil {
+			req.GroupInfoForSet.ApplyMemberFriend = wrapperspb.Int32(*resp.ApplyMemberFriend)
+		}
+		datautil.NotNilReplace(&req.GroupInfoForSet.GroupID, &resp.GroupID)
+		datautil.NotNilReplace(&req.GroupInfoForSet.GroupName, &resp.GroupName)
+		datautil.NotNilReplace(&req.GroupInfoForSet.FaceURL, &resp.FaceURL)
+		datautil.NotNilReplace(&req.GroupInfoForSet.Introduction, &resp.Introduction)
+		return nil
+	})
 }
 
 func (s *groupServer) webhookAfterSetGroupInfo(ctx context.Context, after *config.AfterConfig, req *group.SetGroupInfoReq) {

internal/rpc/msg/callback.go

@@ -16,6 +16,7 @@ package msg
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 
 	cbapi "github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
@@ -61,19 +62,21 @@ func GetContent(msg *sdkws.MsgData) string {
 }
 
 func (m *msgServer) webhookBeforeSendSingleMsg(ctx context.Context, before *config.BeforeConfig, msg *pbchat.SendMsgReq) error {
-	if msg.MsgData.ContentType == constant.Typing {
-		return nil
-	}
-	cbReq := &cbapi.CallbackBeforeSendSingleMsgReq{
-		CommonCallbackReq: toCommonCallback(ctx, msg, cbapi.CallbackBeforeSendSingleMsgCommand),
-		RecvID:            msg.MsgData.RecvID,
-	}
-	resp := &cbapi.CallbackBeforeSendSingleMsgResp{}
-	if err := m.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		if msg.MsgData.ContentType == constant.Typing {
+			return nil
+		}
+		cbReq := &cbapi.CallbackBeforeSendSingleMsgReq{
+			CommonCallbackReq: toCommonCallback(ctx, msg, cbapi.CallbackBeforeSendSingleMsgCommand),
+			RecvID:            msg.MsgData.RecvID,
+		}
+		resp := &cbapi.CallbackBeforeSendSingleMsgResp{}
+		if err := m.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
 
-	return nil
+		return nil
+	})
 }
 
 func (m *msgServer) webhookAfterSendSingleMsg(ctx context.Context, after *config.AfterConfig, msg *pbchat.SendMsgReq) {
@@ -88,18 +91,20 @@ func (m *msgServer) webhookAfterSendSingleMsg(ctx context.Context, after *config
 }
 
 func (m *msgServer) webhookBeforeSendGroupMsg(ctx context.Context, before *config.BeforeConfig, msg *pbchat.SendMsgReq) error {
-	if msg.MsgData.ContentType == constant.Typing {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		if msg.MsgData.ContentType == constant.Typing {
+			return nil
+		}
+		cbReq := &cbapi.CallbackBeforeSendGroupMsgReq{
+			CommonCallbackReq: toCommonCallback(ctx, msg, cbapi.CallbackBeforeSendGroupMsgCommand),
+			GroupID:           msg.MsgData.GroupID,
+		}
+		resp := &cbapi.CallbackBeforeSendGroupMsgResp{}
+		if err := m.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
 		return nil
-	}
-	cbReq := &cbapi.CallbackBeforeSendGroupMsgReq{
-		CommonCallbackReq: toCommonCallback(ctx, msg, cbapi.CallbackBeforeSendGroupMsgCommand),
-		GroupID:           msg.MsgData.GroupID,
-	}
-	resp := &cbapi.CallbackBeforeSendGroupMsgResp{}
-	if err := m.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
-	return nil
+	})
 }
 
 func (m *msgServer) webhookAfterSendGroupMsg(ctx context.Context, after *config.AfterConfig, msg *pbchat.SendMsgReq) {
@@ -114,37 +119,39 @@ func (m *msgServer) webhookAfterSendGroupMsg(ctx context.Context, after *config.
 }
 
 func (m *msgServer) webhookBeforeMsgModify(ctx context.Context, before *config.BeforeConfig, msg *pbchat.SendMsgReq) error {
-	if msg.MsgData.ContentType != constant.Text {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		if msg.MsgData.ContentType != constant.Text {
+			return nil
+		}
+		cbReq := &cbapi.CallbackMsgModifyCommandReq{
+			CommonCallbackReq: toCommonCallback(ctx, msg, cbapi.CallbackBeforeMsgModifyCommand),
+		}
+		resp := &cbapi.CallbackMsgModifyCommandResp{}
+		if err := m.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
+
+		if resp.Content != nil {
+			msg.MsgData.Content = []byte(*resp.Content)
+		}
+		datautil.NotNilReplace(msg.MsgData.OfflinePushInfo, resp.OfflinePushInfo)
+		datautil.NotNilReplace(&msg.MsgData.RecvID, resp.RecvID)
+		datautil.NotNilReplace(&msg.MsgData.GroupID, resp.GroupID)
+		datautil.NotNilReplace(&msg.MsgData.ClientMsgID, resp.ClientMsgID)
+		datautil.NotNilReplace(&msg.MsgData.ServerMsgID, resp.ServerMsgID)
+		datautil.NotNilReplace(&msg.MsgData.SenderPlatformID, resp.SenderPlatformID)
+		datautil.NotNilReplace(&msg.MsgData.SenderNickname, resp.SenderNickname)
+		datautil.NotNilReplace(&msg.MsgData.SenderFaceURL, resp.SenderFaceURL)
+		datautil.NotNilReplace(&msg.MsgData.SessionType, resp.SessionType)
+		datautil.NotNilReplace(&msg.MsgData.MsgFrom, resp.MsgFrom)
+		datautil.NotNilReplace(&msg.MsgData.ContentType, resp.ContentType)
+		datautil.NotNilReplace(&msg.MsgData.Status, resp.Status)
+		datautil.NotNilReplace(&msg.MsgData.Options, resp.Options)
+		datautil.NotNilReplace(&msg.MsgData.AtUserIDList, resp.AtUserIDList)
+		datautil.NotNilReplace(&msg.MsgData.AttachedInfo, resp.AttachedInfo)
+		datautil.NotNilReplace(&msg.MsgData.Ex, resp.Ex)
 		return nil
-	}
-	cbReq := &cbapi.CallbackMsgModifyCommandReq{
-		CommonCallbackReq: toCommonCallback(ctx, msg, cbapi.CallbackBeforeMsgModifyCommand),
-	}
-	resp := &cbapi.CallbackMsgModifyCommandResp{}
-	if err := m.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
-
-	if resp.Content != nil {
-		msg.MsgData.Content = []byte(*resp.Content)
-	}
-	datautil.NotNilReplace(msg.MsgData.OfflinePushInfo, resp.OfflinePushInfo)
-	datautil.NotNilReplace(&msg.MsgData.RecvID, resp.RecvID)
-	datautil.NotNilReplace(&msg.MsgData.GroupID, resp.GroupID)
-	datautil.NotNilReplace(&msg.MsgData.ClientMsgID, resp.ClientMsgID)
-	datautil.NotNilReplace(&msg.MsgData.ServerMsgID, resp.ServerMsgID)
-	datautil.NotNilReplace(&msg.MsgData.SenderPlatformID, resp.SenderPlatformID)
-	datautil.NotNilReplace(&msg.MsgData.SenderNickname, resp.SenderNickname)
-	datautil.NotNilReplace(&msg.MsgData.SenderFaceURL, resp.SenderFaceURL)
-	datautil.NotNilReplace(&msg.MsgData.SessionType, resp.SessionType)
-	datautil.NotNilReplace(&msg.MsgData.MsgFrom, resp.MsgFrom)
-	datautil.NotNilReplace(&msg.MsgData.ContentType, resp.ContentType)
-	datautil.NotNilReplace(&msg.MsgData.Status, resp.Status)
-	datautil.NotNilReplace(&msg.MsgData.Options, resp.Options)
-	datautil.NotNilReplace(&msg.MsgData.AtUserIDList, resp.AtUserIDList)
-	datautil.NotNilReplace(&msg.MsgData.AttachedInfo, resp.AttachedInfo)
-	datautil.NotNilReplace(&msg.MsgData.Ex, resp.Ex)
-	return nil
+	})
 }
 
 func (m *msgServer) webhookAfterGroupMsgRead(ctx context.Context, after *config.AfterConfig, req *cbapi.CallbackGroupMsgReadReq) {

internal/rpc/user/callback.go

@@ -16,6 +16,7 @@ package user
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 	"github.com/openimsdk/tools/utils/datautil"
 
 	cbapi "github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
@@ -24,21 +25,23 @@ import (
 )
 
 func (s *userServer) webhookBeforeUpdateUserInfo(ctx context.Context, before *config.BeforeConfig, req *pbuser.UpdateUserInfoReq) error {
-	cbReq := &cbapi.CallbackBeforeUpdateUserInfoReq{
-		CallbackCommand: cbapi.CallbackBeforeUpdateUserInfoCommand,
-		UserID:          req.UserInfo.UserID,
-		FaceURL:         &req.UserInfo.FaceURL,
-		Nickname:        &req.UserInfo.Nickname,
-	}
-	resp := &cbapi.CallbackBeforeUpdateUserInfoResp{}
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeUpdateUserInfoReq{
+			CallbackCommand: cbapi.CallbackBeforeUpdateUserInfoCommand,
+			UserID:          req.UserInfo.UserID,
+			FaceURL:         &req.UserInfo.FaceURL,
+			Nickname:        &req.UserInfo.Nickname,
+		}
+		resp := &cbapi.CallbackBeforeUpdateUserInfoResp{}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
 
-	datautil.NotNilReplace(&req.UserInfo.FaceURL, resp.FaceURL)
-	datautil.NotNilReplace(&req.UserInfo.Ex, resp.Ex)
-	datautil.NotNilReplace(&req.UserInfo.Nickname, resp.Nickname)
-	return nil
+		datautil.NotNilReplace(&req.UserInfo.FaceURL, resp.FaceURL)
+		datautil.NotNilReplace(&req.UserInfo.Ex, resp.Ex)
+		datautil.NotNilReplace(&req.UserInfo.Nickname, resp.Nickname)
+		return nil
+	})
 }
 
 func (s *userServer) webhookAfterUpdateUserInfo(ctx context.Context, after *config.AfterConfig, req *pbuser.UpdateUserInfoReq) {
@@ -52,21 +55,23 @@ func (s *userServer) webhookAfterUpdateUserInfo(ctx context.Context, after *conf
 }
 
 func (s *userServer) webhookBeforeUpdateUserInfoEx(ctx context.Context, before *config.BeforeConfig, req *pbuser.UpdateUserInfoExReq) error {
-	cbReq := &cbapi.CallbackBeforeUpdateUserInfoExReq{
-		CallbackCommand: cbapi.CallbackBeforeUpdateUserInfoExCommand,
-		UserID:          req.UserInfo.UserID,
-		FaceURL:         req.UserInfo.FaceURL,
-		Nickname:        req.UserInfo.Nickname,
-	}
-	resp := &cbapi.CallbackBeforeUpdateUserInfoExResp{}
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeUpdateUserInfoExReq{
+			CallbackCommand: cbapi.CallbackBeforeUpdateUserInfoExCommand,
+			UserID:          req.UserInfo.UserID,
+			FaceURL:         req.UserInfo.FaceURL,
+			Nickname:        req.UserInfo.Nickname,
+		}
+		resp := &cbapi.CallbackBeforeUpdateUserInfoExResp{}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
 
-	datautil.NotNilReplace(req.UserInfo.FaceURL, resp.FaceURL)
-	datautil.NotNilReplace(req.UserInfo.Ex, resp.Ex)
-	datautil.NotNilReplace(req.UserInfo.Nickname, resp.Nickname)
-	return nil
+		datautil.NotNilReplace(req.UserInfo.FaceURL, resp.FaceURL)
+		datautil.NotNilReplace(req.UserInfo.Ex, resp.Ex)
+		datautil.NotNilReplace(req.UserInfo.Nickname, resp.Nickname)
+		return nil
+	})
 }
 
 func (s *userServer) webhookAfterUpdateUserInfoEx(ctx context.Context, after *config.AfterConfig, req *pbuser.UpdateUserInfoExReq) {
@@ -80,22 +85,24 @@ func (s *userServer) webhookAfterUpdateUserInfoEx(ctx context.Context, after *co
 }
 
 func (s *userServer) webhookBeforeUserRegister(ctx context.Context, before *config.BeforeConfig, req *pbuser.UserRegisterReq) error {
-	cbReq := &cbapi.CallbackBeforeUserRegisterReq{
-		CallbackCommand: cbapi.CallbackBeforeUserRegisterCommand,
-		Secret:          req.Secret,
-		Users:           req.Users,
-	}
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeUserRegisterReq{
+			CallbackCommand: cbapi.CallbackBeforeUserRegisterCommand,
+			Secret:          req.Secret,
+			Users:           req.Users,
+		}
 
-	resp := &cbapi.CallbackBeforeUserRegisterResp{}
+		resp := &cbapi.CallbackBeforeUserRegisterResp{}
 
-	if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
-		return err
-	}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
 
-	if len(resp.Users) != 0 {
-		req.Users = resp.Users
-	}
-	return nil
+		if len(resp.Users) != 0 {
+			req.Users = resp.Users
+		}
+		return nil
+	})
 }
 
 func (s *userServer) webhookAfterUserRegister(ctx context.Context, after *config.AfterConfig, req *pbuser.UserRegisterReq) {

pkg/common/webhook/condition.go

@@ -0,0 +1,13 @@
+package webhook
+
+import (
+	"context"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
+)
+
+func WithCondition(ctx context.Context, before *config.BeforeConfig, callback func(context.Context) error) error {
+	if !before.Enable {
+		return nil
+	}
+	return callback(ctx)
+}

pkg/common/webhook/http_client.go

@@ -57,10 +57,7 @@ func NewWebhookClient(url string, options ...*memAsyncQueue.MemoryQueue) *Client
 }
 
 func (c *Client) SyncPost(ctx context.Context, command string, req callbackstruct.CallbackReq, resp callbackstruct.CallbackResp, before *config.BeforeConfig) error {
-	if before.Enable {
-		return c.post(ctx, command, req, resp, before.Timeout)
-	}
-	return nil
+	return c.post(ctx, command, req, resp, before.Timeout)
 }
 
 func (c *Client) AsyncPost(ctx context.Context, command string, req callbackstruct.CallbackReq, resp callbackstruct.CallbackResp, after *config.AfterConfig) {