Merge remote-tracking branch 'origin/errcode' into errcode

internal/api/third.go

@@ -20,7 +20,7 @@ import (
 func NewThird(discov discoveryregistry.SvcDiscoveryRegistry) *Third {
 	conn, err := discov.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImThirdName)
 	if err != nil {
-		panic(err)
+		// panic(err)
 	}
 	return &Third{conn: conn, discov: discov}
 }

internal/msggateway/callback.go

@@ -33,7 +33,7 @@ func CallbackUserOnline(ctx context.Context, userID string, platformID int, isAp
 		ConnID:          connID,
 	}
 	resp := cbapi.CommonCallbackResp{}
-	return http.CallBackPostReturn(url(), &req, &resp, config.Config.Callback.CallbackUserOnline)
+	return http.CallBackPostReturn(ctx, url(), &req, &resp, config.Config.Callback.CallbackUserOnline)
 }
 
 func CallbackUserOffline(ctx context.Context, userID string, platformID int, connID string) error {
@@ -54,7 +54,7 @@ func CallbackUserOffline(ctx context.Context, userID string, platformID int, con
 		ConnID: connID,
 	}
 	resp := &cbapi.CallbackUserOfflineResp{}
-	return http.CallBackPostReturn(url(), req, resp, config.Config.Callback.CallbackUserOffline)
+	return http.CallBackPostReturn(ctx, url(), req, resp, config.Config.Callback.CallbackUserOffline)
 }
 
 func CallbackUserKickOff(ctx context.Context, userID string, platformID int) error {
@@ -74,7 +74,7 @@ func CallbackUserKickOff(ctx context.Context, userID string, platformID int) err
 		Seq: time.Now().UnixMilli(),
 	}
 	resp := &cbapi.CommonCallbackResp{}
-	return http.CallBackPostReturn(url(), req, resp, config.Config.Callback.CallbackUserOffline)
+	return http.CallBackPostReturn(ctx, url(), req, resp, config.Config.Callback.CallbackUserOffline)
 }
 
 //func callbackUserOnline(operationID, userID string, platformID int, token string, isAppBackground bool, connID string) cbApi.CommonCallbackResp {
@@ -98,7 +98,7 @@ func CallbackUserKickOff(ctx context.Context, userID string, platformID int) err
 //		ConnID:          connID,
 //	}
 //	callbackUserOnlineResp := &cbApi.CallbackUserOnlineResp{CommonCallbackResp: &callbackResp}
-//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackUserOnlineCommand, callbackUserOnlineReq, callbackUserOnlineResp, config.Config.Callback.CallbackUserOnline.CallbackTimeOut); err != nil {
+//	if err := http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, constant.CallbackUserOnlineCommand, callbackUserOnlineReq, callbackUserOnlineResp, config.Config.Callback.CallbackUserOnline.CallbackTimeOut); err != nil {
 //		callbackResp.ErrCode = http2.StatusInternalServerError
 //		callbackResp.ErrMsg = err.Error()
 //	}
@@ -123,7 +123,7 @@ func CallbackUserKickOff(ctx context.Context, userID string, platformID int) err
 //		ConnID: connID,
 //	}
 //	callbackUserOfflineResp := &cbApi.CallbackUserOfflineResp{CommonCallbackResp: &callbackResp}
-//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackUserOfflineCommand, callbackOfflineReq, callbackUserOfflineResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil {
+//	if err := http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, constant.CallbackUserOfflineCommand, callbackOfflineReq, callbackUserOfflineResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil {
 //		callbackResp.ErrCode = http2.StatusInternalServerError
 //		callbackResp.ErrMsg = err.Error()
 //	}
@@ -147,7 +147,7 @@ func CallbackUserKickOff(ctx context.Context, userID string, platformID int) err
 //		Seq: int(time.Now().UnixNano() / 1e6),
 //	}
 //	callbackUserKickOffResp := &cbApi.CallbackUserKickOffResp{CommonCallbackResp: &callbackResp}
-//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackUserKickOffCommand, callbackUserKickOffReq, callbackUserKickOffResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil {
+//	if err := http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, constant.CallbackUserKickOffCommand, callbackUserKickOffReq, callbackUserKickOffResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil {
 //		callbackResp.ErrCode = http2.StatusInternalServerError
 //		callbackResp.ErrMsg = err.Error()
 //	}

internal/push/callback.go

@@ -39,7 +39,7 @@ func callbackOfflinePush(ctx context.Context, userIDs []string, msg *sdkws.MsgDa
 		Content:         utils.GetContent(msg),
 	}
 	resp := &callbackstruct.CallbackBeforePushResp{}
-	err := http.CallBackPostReturn(url(), req, resp, config.Config.Callback.CallbackOfflinePush)
+	err := http.CallBackPostReturn(ctx, url(), req, resp, config.Config.Callback.CallbackOfflinePush)
 	if err != nil {
 		return err
 	}
@@ -75,7 +75,7 @@ func callbackOnlinePush(ctx context.Context, userIDs []string, msg *sdkws.MsgDat
 		Content:     utils.GetContent(msg),
 	}
 	resp := &callbackstruct.CallbackBeforePushResp{}
-	return http.CallBackPostReturn(url(), req, resp, config.Config.Callback.CallbackOnlinePush)
+	return http.CallBackPostReturn(ctx, url(), req, resp, config.Config.Callback.CallbackOnlinePush)
 }
 
 func callbackBeforeSuperGroupOnlinePush(ctx context.Context, groupID string, msg *sdkws.MsgData, pushToUserIDs *[]string) error {
@@ -99,7 +99,7 @@ func callbackBeforeSuperGroupOnlinePush(ctx context.Context, groupID string, msg
 		Seq:         msg.Seq,
 	}
 	resp := &callbackstruct.CallbackBeforeSuperGroupOnlinePushResp{}
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackBeforeSuperGroupOnlinePush); err != nil {
+	if err := http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackBeforeSuperGroupOnlinePush); err != nil {
 		return err
 	}
 	if len(resp.UserIDs) != 0 {

internal/push/offlinepush/getui/push.go

@@ -146,11 +146,11 @@ func (g *Client) request(ctx context.Context, url string, input interface{}, tok
 	header := map[string]string{"token": token}
 	resp := &Resp{}
 	resp.Data = output
-	return g.postReturn(config.Config.Push.Getui.PushUrl+url, header, input, resp, 3)
+	return g.postReturn(ctx, config.Config.Push.Getui.PushUrl+url, header, input, resp, 3)
 }
 
-func (g *Client) postReturn(url string, header map[string]string, input interface{}, output RespI, timeout int) error {
-	err := http2.PostReturn(url, header, input, output, timeout)
+func (g *Client) postReturn(ctx context.Context, url string, header map[string]string, input interface{}, output RespI, timeout int) error {
+	err := http2.PostReturn(ctx, url, header, input, output, timeout)
 	if err != nil {
 		return err
 	}

internal/push/offlinepush/jpush/push.go

@@ -55,9 +55,9 @@ func (j *JPush) Push(ctx context.Context, userIDs []string, title, content strin
 	pushObj.SetMessage(&msg)
 	pushObj.SetOptions(&opt)
 	var resp interface{}
-	return j.request(pushObj, resp, 5)
+	return j.request(ctx, pushObj, resp, 5)
 }
 
-func (j *JPush) request(po body.PushObj, resp interface{}, timeout int) error {
-	return http2.PostReturn(config.Config.Push.Jpns.PushUrl, map[string]string{"Authorization": j.getAuthorization(config.Config.Push.Jpns.AppKey, config.Config.Push.Jpns.MasterSecret)}, po, resp, timeout)
+func (j *JPush) request(ctx context.Context, po body.PushObj, resp interface{}, timeout int) error {
+	return http2.PostReturn(ctx, config.Config.Push.Jpns.PushUrl, map[string]string{"Authorization": j.getAuthorization(config.Config.Push.Jpns.AppKey, config.Config.Push.Jpns.MasterSecret)}, po, resp, timeout)
 }

internal/push/push_handler.go

@@ -51,7 +51,11 @@ func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
 		err = c.pusher.Push2User(ctx, []string{pbData.MsgData.SendID, pbData.MsgData.RecvID}, pbData.MsgData)
 	}
 	if err != nil {
-		log.ZError(ctx, "push failed", err, "msg", pbData.String())
+		if err == errNoOfflinePusher {
+			log.ZWarn(ctx, "offline push failed", err, "msg", pbData.String())
+		} else {
+			log.ZError(ctx, "push failed", err, "msg", pbData.String())
+		}
 	}
 }
 func (ConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }

internal/push/push_rpc_server.go

@@ -8,6 +8,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/localcache"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	pbPush "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/push"
 	"google.golang.org/grpc"
@@ -52,7 +53,11 @@ func (r *pushServer) PushMsg(ctx context.Context, pbData *pbPush.PushMsgReq) (re
 		err = r.pusher.Push2User(ctx, []string{pbData.MsgData.RecvID, pbData.MsgData.SendID}, pbData.MsgData)
 	}
 	if err != nil {
-		return nil, err
+		if err != errNoOfflinePusher {
+			return nil, err
+		} else {
+			log.ZWarn(ctx, "offline push failed", err, "msg", pbData.String())
+		}
 	}
 	return &pbPush.PushMsgResp{}, nil
 }

internal/push/push_to_client.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+
 	"github.com/OpenIMSDK/Open-IM-Server/internal/push/offlinepush"
 	"github.com/OpenIMSDK/Open-IM-Server/internal/push/offlinepush/fcm"
 	"github.com/OpenIMSDK/Open-IM-Server/internal/push/offlinepush/getui"
@@ -35,6 +36,8 @@ type Pusher struct {
 	successCount           int
 }
 
+var errNoOfflinePusher = errors.New("no offlinePusher is configured")
+
 func NewPusher(client discoveryregistry.SvcDiscoveryRegistry, offlinePusher offlinepush.OfflinePusher, database controller.PushDatabase,
 	groupLocalCache *localcache.GroupLocalCache, conversationLocalCache *localcache.ConversationLocalCache) *Pusher {
 	rpcclient.NewGroupClient(client)
@@ -286,7 +289,7 @@ func (p *Pusher) GetOfflinePushOpts(msg *sdkws.MsgData) (opts *offlinepush.Opts,
 
 func (p *Pusher) getOfflinePushInfos(conversationID string, msg *sdkws.MsgData) (title, content string, opts *offlinepush.Opts, err error) {
 	if p.offlinePusher == nil {
-		err = errors.New("no offlinePusher is configured")
+		err = errNoOfflinePusher
 		return
 	}
 	type AtContent struct {

internal/rpc/friend/callback.go

@@ -6,11 +6,13 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	pbfriend "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
 )
 
 func CallbackBeforeAddFriend(ctx context.Context, req *pbfriend.ApplyToAddFriendReq) error {
+	log.ZInfo(ctx, "CallbackBeforeAddFriend", "in", req)
 	if !config.Config.Callback.CallbackBeforeAddFriend.Enable {
 		return nil
 	}
@@ -22,5 +24,6 @@ func CallbackBeforeAddFriend(ctx context.Context, req *pbfriend.ApplyToAddFriend
 		OperationID:     mcontext.GetOperationID(ctx),
 	}
 	resp := &cbapi.CallbackBeforeAddFriendResp{}
-	return http.CallBackPostReturn(config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeAddFriend)
+	defer log.ZInfo(ctx, "CallbackBeforeAddFriend", "out", &resp)
+	return http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeAddFriend)
 }

internal/rpc/friend/friend.go

@@ -63,12 +63,12 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.Apply
 	if err := tokenverify.CheckAccessV3(ctx, req.FromUserID); err != nil {
 		return nil, err
 	}
-	if err := CallbackBeforeAddFriend(ctx, req); err != nil && err != errs.ErrCallbackContinue {
-		return nil, err
-	}
 	if req.ToUserID == req.FromUserID {
 		return nil, errs.ErrCanNotAddYourself.Wrap()
 	}
+	if err := CallbackBeforeAddFriend(ctx, req); err != nil && err != errs.ErrCallbackContinue {
+		return nil, err
+	}
 	if _, err := s.userRpcClient.GetUsersInfoMap(ctx, []string{req.ToUserID, req.FromUserID}); err != nil {
 		return nil, err
 	}

internal/rpc/group/callback.go

@@ -42,7 +42,7 @@ func CallbackBeforeCreateGroup(ctx context.Context, req *group.CreateGroupReq) (
 		})
 	}
 	resp := &callbackstruct.CallbackBeforeCreateGroupResp{}
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeCreateGroup)
+	err = http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeCreateGroup)
 	if err != nil {
 		return err
 	}
@@ -74,7 +74,7 @@ func CallbackBeforeMemberJoinGroup(ctx context.Context, groupMember *relation.Gr
 		GroupEx:         groupEx,
 	}
 	resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{}
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeMemberJoinGroup)
+	err = http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeMemberJoinGroup)
 	if err != nil {
 		return err
 	}
@@ -111,7 +111,7 @@ func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *group.SetGroupMe
 		callbackReq.Ex = &req.Ex.Value
 	}
 	resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{}
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeSetGroupMemberInfo)
+	err = http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeSetGroupMemberInfo)
 	if err != nil {
 		return err
 	}

internal/rpc/group/group.go

@@ -485,34 +485,30 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		}
 		memberMap := make(map[string]*relationTb.GroupMemberModel)
 		for i, member := range members {
-			if member.RoleLevel == constant.GroupOwner {
-				return nil, errs.ErrArgs.Wrap("can not kick group owner")
-			}
 			memberMap[member.UserID] = members[i]
 		}
+		isAppManagerUid := tokenverify.IsAppManagerUid(ctx)
+		opMember := memberMap[opUserID]
 		for _, userID := range req.KickedUserIDs {
-			if _, ok := memberMap[userID]; !ok {
+			member, ok := memberMap[userID]
+			if !ok {
 				return nil, errs.ErrUserIDNotFound.Wrap(userID)
 			}
-		}
-		if !tokenverify.IsAppManagerUid(ctx) {
-			member := memberMap[opUserID]
-			if member == nil {
-				return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("opUserID %s no in group", opUserID))
-			}
-			switch member.RoleLevel {
-			case constant.GroupOwner:
-			case constant.GroupAdmin:
-				for _, member := range members {
-					if member.UserID == opUserID {
-						continue
-					}
-					if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin {
-						return nil, errs.ErrNoPermission.Wrap("userID:" + member.UserID)
-					}
+			if !isAppManagerUid {
+				if opMember == nil {
+					return nil, errs.ErrNoPermission.Wrap("opUserID no in group")
+				}
+				switch opMember.RoleLevel {
+				case constant.GroupOwner:
+				case constant.GroupAdmin:
+					if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin {
+						return nil, errs.ErrNoPermission.Wrap("group admins cannot remove the group owner and other admins")
+					}
+				case constant.GroupOrdinaryUsers:
+					return nil, errs.ErrNoPermission.Wrap("opUserID no permission")
+				default:
+					return nil, errs.ErrNoPermission.Wrap("opUserID roleLevel unknown")
 				}
-			default:
-				return nil, errs.ErrNoPermission.Wrap("opUserID is OrdinaryUser")
 			}
 		}
 		userIDs, err := s.GroupDatabase.FindGroupMemberUserID(ctx, req.GroupID)
@@ -1343,7 +1339,17 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 		return nil, err
 	}
 	for _, member := range req.Members {
-		s.Notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID)
+		if member.RoleLevel != nil {
+			switch member.RoleLevel.Value {
+			case constant.GroupAdmin:
+				s.Notification.GroupMemberSetToAdminNotification(ctx, member.GroupID, member.UserID)
+			case constant.GroupOrdinaryUsers:
+				s.Notification.GroupMemberSetToOrdinaryUserNotification(ctx, member.GroupID, member.UserID)
+			}
+		}
+		if member.Nickname != nil || member.FaceURL != nil || member.Ex != nil {
+			s.Notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID)
+		}
 	}
 	return resp, nil
 }

internal/rpc/msg/as_read.go

@@ -3,9 +3,41 @@ package msg
 import (
 	"context"
 
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 )
 
 func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadReq) (resp *msg.MarkMsgsAsReadResp, err error) {
-	return
+	conversations, err := m.Conversation.GetConversationsByConversationID(ctx, []string{req.ConversationID})
+	if err != nil {
+		return
+	}
+	var recvID string
+	if conversations[0].ConversationType == constant.SingleChatType || conversations[0].ConversationType == constant.NotificationChatType {
+		if req.UserID == conversations[0].OwnerUserID {
+			recvID = conversations[0].UserID
+		} else {
+			recvID = conversations[0].OwnerUserID
+		}
+	} else if conversations[0].ConversationType == constant.SuperGroupChatType {
+		recvID = conversations[0].GroupID
+	}
+	err = m.MsgDatabase.MarkSingleChatMsgsAsRead(ctx, req.ConversationID, req.UserID, req.Seqs)
+	if err != nil {
+		return
+	}
+	if err = m.sendMarkAsReadNotification(ctx, req.ConversationID, req.UserID, recvID, req.Seqs); err != nil {
+		return
+	}
+	return &msg.MarkMsgsAsReadResp{}, nil
+}
+
+func (m *msgServer) sendMarkAsReadNotification(ctx context.Context, conversationID string, sendID, recvID string, seqs []int64) error {
+	// tips := &sdkws.MarkAsReadTips{
+	// 	MarkAsReadUserID: sendID,
+	// 	ConversationID:   conversationID,
+	// 	Seqs:             seqs,
+	// }
+	// m.notificationSender.NotificationWithSesstionType(ctx)
+	return nil
 }

internal/rpc/msg/callback.go

@@ -47,7 +47,7 @@ func callbackBeforeSendSingleMsg(ctx context.Context, msg *pbChat.SendMsgReq) er
 		RecvID:            msg.MsgData.RecvID,
 	}
 	resp := &cbapi.CallbackBeforeSendSingleMsgResp{}
-	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackBeforeSendSingleMsg)
+	return http.CallBackPostReturn(ctx, cbURL(), req, resp, config.Config.Callback.CallbackBeforeSendSingleMsg)
 }
 
 func callbackAfterSendSingleMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
@@ -59,7 +59,7 @@ func callbackAfterSendSingleMsg(ctx context.Context, msg *pbChat.SendMsgReq) err
 		RecvID:            msg.MsgData.RecvID,
 	}
 	resp := &cbapi.CallbackAfterSendSingleMsgResp{}
-	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendSingleMsg)
+	return http.CallBackPostReturn(ctx, cbURL(), req, resp, config.Config.Callback.CallbackAfterSendSingleMsg)
 }
 
 func callbackBeforeSendGroupMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
@@ -71,7 +71,7 @@ func callbackBeforeSendGroupMsg(ctx context.Context, msg *pbChat.SendMsgReq) err
 		GroupID:           msg.MsgData.GroupID,
 	}
 	resp := &cbapi.CallbackBeforeSendGroupMsgResp{}
-	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendSingleMsg)
+	return http.CallBackPostReturn(ctx, cbURL(), req, resp, config.Config.Callback.CallbackAfterSendSingleMsg)
 }
 
 func callbackAfterSendGroupMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
@@ -83,7 +83,7 @@ func callbackAfterSendGroupMsg(ctx context.Context, msg *pbChat.SendMsgReq) erro
 		GroupID:           msg.MsgData.GroupID,
 	}
 	resp := &cbapi.CallbackAfterSendGroupMsgResp{}
-	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
+	return http.CallBackPostReturn(ctx, cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
 }
 
 func callbackMsgModify(ctx context.Context, msg *pbChat.SendMsgReq) error {
@@ -94,7 +94,7 @@ func callbackMsgModify(ctx context.Context, msg *pbChat.SendMsgReq) error {
 		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackMsgModifyCommand),
 	}
 	resp := &cbapi.CallbackMsgModifyCommandResp{}
-	if err := http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg); err != nil {
+	if err := http.CallBackPostReturn(ctx, cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg); err != nil {
 		return err
 	}
 	if resp.Content != nil {

internal/rpc/msg/extend_msg_callback.go

@@ -28,14 +28,14 @@ func callbackSetMessageReactionExtensions(ctx context.Context, setReq *msg.SetMe
 		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
 	}
 	resp := &cbapi.CallbackBeforeSetMessageReactionExtResp{}
-	if err := http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg); err != nil {
+	if err := http.CallBackPostReturn(ctx, cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg); err != nil {
 		return err
 	}
 	setReq.MsgFirstModifyTime = resp.MsgFirstModifyTime
 	return nil
 }
 
-func callbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessagesReactionExtensionsReq) error {
+func callbackDeleteMessageReactionExtensions(ctx context.Context, setReq *msg.DeleteMessagesReactionExtensionsReq) error {
 	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
 		return nil
 	}
@@ -51,7 +51,7 @@ func callbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessagesReactionE
 		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
 	}
 	resp := &cbapi.CallbackDeleteMessageReactionExtResp{}
-	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
+	return http.CallBackPostReturn(ctx, cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
 }
 
 func callbackGetMessageListReactionExtensions(ctx context.Context, getReq *msg.GetMessagesReactionExtensionsReq) error {
@@ -67,7 +67,7 @@ func callbackGetMessageListReactionExtensions(ctx context.Context, getReq *msg.G
 		TypeKeyList:     getReq.TypeKeys,
 	}
 	resp := &cbapi.CallbackGetMessageListReactionExtResp{}
-	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
+	return http.CallBackPostReturn(ctx, cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
 }
 
 func callbackAddMessageReactionExtensions(ctx context.Context, setReq *msg.ModifyMessageReactionExtensionsReq) error {
@@ -84,5 +84,5 @@ func callbackAddMessageReactionExtensions(ctx context.Context, setReq *msg.Modif
 		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
 	}
 	resp := &cbapi.CallbackAddMessageReactionExtResp{}
-	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
+	return http.CallBackPostReturn(ctx, cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
 }