diff --git a/internal/common/notification/extend_msg.go b/internal/common/notification/extend_msg.go new file mode 100644 index 000000000..5a3b78a07 --- /dev/null +++ b/internal/common/notification/extend_msg.go @@ -0,0 +1,100 @@ +package notification + +import ( + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/log" + "Open_IM/pkg/proto/msg" + sdkws "Open_IM/pkg/proto/sdkws" + "Open_IM/pkg/utils" + "context" +) + +func ExtendMessageUpdatedNotification(operationID, sendID string, sourceID string, sessionType int32, + req *msg.SetMessageReactionExtensionsReq, resp *msg.SetMessageReactionExtensionsResp, isHistory bool, isReactionFromCache bool) { + var m apistruct.ReactionMessageModifierNotification + m.SourceID = req.SourceID + m.OpUserID = req.OpUserID + m.SessionType = req.SessionType + keyMap := make(map[string]*sdkws.KeyValue) + for _, valueResp := range resp.Result { + if valueResp.ErrCode == 0 { + keyMap[valueResp.KeyValue.TypeKey] = valueResp.KeyValue + } + } + if len(keyMap) == 0 { + log.NewWarn(operationID, "all key set failed can not send notification", *req) + return + } + m.SuccessReactionExtensionList = keyMap + m.ClientMsgID = req.ClientMsgID + m.IsReact = resp.IsReact + m.IsExternalExtensions = req.IsExternalExtensions + m.MsgFirstModifyTime = resp.MsgFirstModifyTime + messageReactionSender(operationID, sendID, sourceID, sessionType, constant.ReactionMessageModifier, utils.StructToJsonString(m), isHistory, isReactionFromCache) +} +func ExtendMessageDeleteNotification(operationID, sendID string, sourceID string, sessionType int32, + req *msg.DeleteMessageListReactionExtensionsReq, resp *msg.DeleteMessageListReactionExtensionsResp, isHistory bool, isReactionFromCache bool) { + var m apistruct.ReactionMessageDeleteNotification + m.SourceID = req.SourceID + m.OpUserID = req.OpUserID + m.SessionType = req.SessionType + keyMap := make(map[string]*sdkws.KeyValue) + for _, valueResp := range resp.Result { + if valueResp.ErrCode == 0 { + keyMap[valueResp.KeyValue.TypeKey] = valueResp.KeyValue + } + } + if len(keyMap) == 0 { + log.NewWarn(operationID, "all key set failed can not send notification", *req) + return + } + m.SuccessReactionExtensionList = keyMap + m.ClientMsgID = req.ClientMsgID + m.MsgFirstModifyTime = req.MsgFirstModifyTime + + messageReactionSender(operationID, sendID, sourceID, sessionType, constant.ReactionMessageDeleter, utils.StructToJsonString(m), isHistory, isReactionFromCache) +} +func messageReactionSender(operationID, sendID string, sourceID string, sessionType, contentType int32, content string, isHistory bool, isReactionFromCache bool) { + options := make(map[string]bool, 5) + utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false) + utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, false) + utils.SetSwitchFromOptions(options, constant.IsSenderConversationUpdate, false) + utils.SetSwitchFromOptions(options, constant.IsUnreadCount, false) + utils.SetSwitchFromOptions(options, constant.IsReactionFromCache, isReactionFromCache) + if !isHistory { + utils.SetSwitchFromOptions(options, constant.IsHistory, false) + utils.SetSwitchFromOptions(options, constant.IsPersistent, false) + } + pbData := msg.SendMsgReq{ + OperationID: operationID, + MsgData: &sdkws.MsgData{ + SendID: sendID, + ClientMsgID: utils.GetMsgID(sendID), + SessionType: sessionType, + MsgFrom: constant.SysMsgType, + ContentType: contentType, + Content: []byte(content), + // ForceList: params.ForceList, + CreateTime: utils.GetCurrentTimestampByMill(), + Options: options, + }, + } + switch sessionType { + case constant.SingleChatType, constant.NotificationChatType: + pbData.MsgData.RecvID = sourceID + case constant.GroupChatType, constant.SuperGroupChatType: + pbData.MsgData.GroupID = sourceID + } + etcdConn, err := rpc.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImMsgName) + if err != nil { + return + } + client := msg.NewMsgClient(etcdConn) + reply, err := client.SendMsg(context.Background(), &pbData) + if err != nil { + log.NewError(operationID, "SendMsg rpc failed, ", pbData.String(), err.Error()) + } else if reply.ErrCode != 0 { + log.NewError(operationID, "SendMsg rpc failed, ", pbData.String(), reply.ErrCode, reply.ErrMsg) + } +} diff --git a/internal/common/notification/friend.go b/internal/common/notification/friend.go new file mode 100644 index 000000000..2ade47709 --- /dev/null +++ b/internal/common/notification/friend.go @@ -0,0 +1,174 @@ +package notification + +import ( + "Open_IM/internal/common/check" + "Open_IM/internal/rpc/msg" + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/log" + "Open_IM/pkg/common/tracelog" + pbFriend "Open_IM/pkg/proto/friend" + sdkws "Open_IM/pkg/proto/sdkws" + "Open_IM/pkg/utils" + "context" + "github.com/golang/protobuf/jsonpb" + "github.com/golang/protobuf/proto" +) + +func getFromToUserNickname(fromUserID, toUserID string) (string, string, error) { + users, err := check.GetUsersInfo(context.Background(), fromUserID, toUserID) + if err != nil { + return "", "", nil + } + if users[0].UserID == fromUserID { + return users[0].Nickname, users[1].Nickname, nil + } + return users[1].Nickname, users[0].Nickname, nil + +} + +func friendNotification(operationID, fromUserID, toUserID string, contentType int32, m proto.Message) { + log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType) + var err error + var tips sdkws.TipsComm + tips.Detail, err = proto.Marshal(m) + if err != nil { + log.Error(operationID, "Marshal failed ", err.Error(), m.String()) + return + } + + marshaler := jsonpb.Marshaler{ + OrigName: true, + EnumsAsInts: false, + EmitDefaults: false, + } + + tips.JsonDetail, _ = marshaler.MarshalToString(m) + + fromUserNickname, toUserNickname, err := getFromToUserNickname(fromUserID, toUserID) + if err != nil { + log.Error(operationID, "getFromToUserNickname failed ", err.Error(), fromUserID, toUserID) + return + } + cn := config.Config.Notification + switch contentType { + case constant.FriendApplicationNotification: + tips.DefaultTips = fromUserNickname + cn.FriendApplication.DefaultTips.Tips + case constant.FriendApplicationApprovedNotification: + tips.DefaultTips = fromUserNickname + cn.FriendApplicationApproved.DefaultTips.Tips + case constant.FriendApplicationRejectedNotification: + tips.DefaultTips = fromUserNickname + cn.FriendApplicationRejected.DefaultTips.Tips + case constant.FriendAddedNotification: + tips.DefaultTips = cn.FriendAdded.DefaultTips.Tips + case constant.FriendDeletedNotification: + tips.DefaultTips = cn.FriendDeleted.DefaultTips.Tips + toUserNickname + case constant.FriendRemarkSetNotification: + tips.DefaultTips = fromUserNickname + cn.FriendRemarkSet.DefaultTips.Tips + case constant.BlackAddedNotification: + tips.DefaultTips = cn.BlackAdded.DefaultTips.Tips + case constant.BlackDeletedNotification: + tips.DefaultTips = cn.BlackDeleted.DefaultTips.Tips + toUserNickname + case constant.UserInfoUpdatedNotification: + tips.DefaultTips = cn.UserInfoUpdated.DefaultTips.Tips + case constant.FriendInfoUpdatedNotification: + tips.DefaultTips = cn.FriendInfoUpdated.DefaultTips.Tips + toUserNickname + default: + log.Error(operationID, "contentType failed ", contentType) + return + } + + var n msg.NotificationMsg + n.SendID = fromUserID + n.RecvID = toUserID + n.ContentType = contentType + n.SessionType = constant.SingleChatType + n.MsgFrom = constant.SysMsgType + n.OperationID = operationID + n.Content, err = proto.Marshal(&tips) + if err != nil { + log.Error(operationID, "Marshal failed ", err.Error(), tips.String()) + return + } + msg.Notification(&n) +} + +func FriendApplicationAddNotification(ctx context.Context, req *pbFriend.AddFriendReq) { + FriendApplicationTips := sdkws.FriendApplicationTips{FromToUserID: &sdkws.FromToUserID{}} + FriendApplicationTips.FromToUserID.FromUserID = req.FromUserID + FriendApplicationTips.FromToUserID.ToUserID = req.ToUserID + friendNotification(tracelog.GetOperationID(ctx), req.FromUserID, req.ToUserID, constant.FriendApplicationNotification, &FriendApplicationTips) +} + +func FriendApplicationAgreedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) { + FriendApplicationApprovedTips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{}} + FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID + FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID + FriendApplicationApprovedTips.HandleMsg = req.HandleMsg + friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips) +} + +func FriendApplicationRefusedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) { + FriendApplicationApprovedTips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{}} + FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID + FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID + FriendApplicationApprovedTips.HandleMsg = req.HandleMsg + friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips) +} + +func FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) { + friendAddedTips := sdkws.FriendAddedTips{Friend: &sdkws.FriendInfo{}, OpUser: &sdkws.PublicUserInfo{}} + user, err := check.GetUsersInfo(context.Background(), opUserID) + if err != nil { + return + } + friendAddedTips.OpUser.UserID = user[0].UserID + friendAddedTips.OpUser.Ex = user[0].Ex + friendAddedTips.OpUser.Nickname = user[0].Nickname + friendAddedTips.OpUser.FaceURL = user[0].FaceURL + + friend, err := check.GetFriendsInfo(ctx, fromUserID, toUserID) + if err != nil { + return + } + friendAddedTips.Friend = friend + friendNotification(operationID, fromUserID, toUserID, constant.FriendAddedNotification, &friendAddedTips) +} + +func FriendDeletedNotification(ctx context.Context, req *pbFriend.DeleteFriendReq) { + friendDeletedTips := sdkws.FriendDeletedTips{FromToUserID: &sdkws.FromToUserID{}} + friendDeletedTips.FromToUserID.FromUserID = req.OwnerUserID + friendDeletedTips.FromToUserID.ToUserID = req.FriendUserID + friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.FriendUserID, constant.FriendDeletedNotification, &friendDeletedTips) +} + +func FriendRemarkSetNotification(ctx context.Context, fromUserID, toUserID string) { + friendInfoChangedTips := sdkws.FriendInfoChangedTips{FromToUserID: &sdkws.FromToUserID{}} + friendInfoChangedTips.FromToUserID.FromUserID = fromUserID + friendInfoChangedTips.FromToUserID.ToUserID = toUserID + friendNotification(tracelog.GetOperationID(ctx), fromUserID, toUserID, constant.FriendRemarkSetNotification, &friendInfoChangedTips) +} + +func BlackAddedNotification(ctx context.Context, req *pbFriend.AddBlackReq) { + blackAddedTips := sdkws.BlackAddedTips{FromToUserID: &sdkws.FromToUserID{}} + blackAddedTips.FromToUserID.FromUserID = req.OwnerUserID + blackAddedTips.FromToUserID.ToUserID = req.BlackUserID + friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackAddedNotification, &blackAddedTips) +} + +func BlackDeletedNotification(ctx context.Context, req *pbFriend.RemoveBlackReq) { + blackDeletedTips := sdkws.BlackDeletedTips{FromToUserID: &sdkws.FromToUserID{}} + blackDeletedTips.FromToUserID.FromUserID = req.OwnerUserID + blackDeletedTips.FromToUserID.ToUserID = req.BlackUserID + friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackDeletedNotification, &blackDeletedTips) +} + +// send to myself +func UserInfoUpdatedNotification(ctx context.Context, opUserID string, changedUserID string) { + selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID} + friendNotification(tracelog.GetOperationID(ctx), opUserID, changedUserID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips) +} + +func FriendInfoUpdatedNotification(ctx context.Context, changedUserID string, needNotifiedUserID string, opUserID string) { + selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID} + friendNotification(tracelog.GetOperationID(ctx), opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips) +} diff --git a/internal/common/notification/group.go b/internal/common/notification/group.go new file mode 100644 index 000000000..c3982ed6d --- /dev/null +++ b/internal/common/notification/group.go @@ -0,0 +1,622 @@ +package notification + +import ( + "Open_IM/internal/rpc/msg" + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model" + "Open_IM/pkg/common/log" + "Open_IM/pkg/common/tokenverify" + utils2 "Open_IM/pkg/common/utils" + pbGroup "Open_IM/pkg/proto/group" + "Open_IM/pkg/proto/sdkws" + "Open_IM/pkg/utils" + "context" + "github.com/golang/protobuf/jsonpb" + "github.com/golang/protobuf/proto" + "google.golang.org/protobuf/types/known/wrapperspb" +) + +//message GroupCreatedTips{ +// GroupInfo Group = 1; +// GroupMemberFullInfo Creator = 2; +// repeated GroupMemberFullInfo MemberList = 3; +// uint64 OperationTime = 4; +//} creator->group + +func setOpUserInfo(opUserID, groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error { + if tokenverify.IsManagerUserID(opUserID) { + u, err := imdb.GetUserByUserID(opUserID) + if err != nil { + return utils.Wrap(err, "GetUserByUserID failed") + } + utils.CopyStructFields(groupMemberInfo, u) + groupMemberInfo.GroupID = groupID + } else { + u, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, opUserID) + if err == nil { + if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, u); err != nil { + return utils.Wrap(err, "") + } + } + user, err := imdb.GetUserByUserID(opUserID) + if err != nil { + return utils.Wrap(err, "") + } + groupMemberInfo.GroupID = groupID + groupMemberInfo.UserID = user.UserID + groupMemberInfo.Nickname = user.Nickname + groupMemberInfo.AppMangerLevel = user.AppMangerLevel + groupMemberInfo.FaceURL = user.FaceURL + } + return nil +} + +func setGroupInfo(groupID string, groupInfo *sdkws.GroupInfo) error { + group, err := imdb.GetGroupInfoByGroupID(groupID) + if err != nil { + return utils.Wrap(err, "GetGroupInfoByGroupID failed") + } + err = utils2.GroupDBCopyOpenIM(groupInfo, group) + if err != nil { + log.NewWarn("", "GroupDBCopyOpenIM failed ", groupID, err.Error()) + return nil + } + return nil +} + +func setGroupMemberInfo(groupID, userID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error { + groupMember, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID) + if err == nil { + return utils.Wrap(utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember), "") + } + + user, err := imdb.GetUserByUserID(userID) + if err != nil { + return utils.Wrap(err, "") + } + groupMemberInfo.GroupID = groupID + groupMemberInfo.UserID = user.UserID + groupMemberInfo.Nickname = user.Nickname + groupMemberInfo.AppMangerLevel = user.AppMangerLevel + groupMemberInfo.FaceURL = user.FaceURL + return nil +} + +func setGroupOwnerInfo(groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error { + groupMember, err := imdb.GetGroupOwnerInfoByGroupID(groupID) + if err != nil { + return utils.Wrap(err, "") + } + if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember); err != nil { + return utils.Wrap(err, "") + } + return nil +} + +func setPublicUserInfo(userID string, publicUserInfo *sdkws.PublicUserInfo) error { + user, err := imdb.GetUserByUserID(userID) + if err != nil { + return utils.Wrap(err, "") + } + utils2.UserDBCopyOpenIMPublicUser(publicUserInfo, user) + return nil +} + +func groupNotification(contentType int32, m proto.Message, sendID, groupID, recvUserID, operationID string) { + log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType, sendID, groupID, recvUserID) + + var err error + var tips sdkws.TipsComm + tips.Detail, err = proto.Marshal(m) + if err != nil { + log.Error(operationID, "Marshal failed ", err.Error(), m.String()) + return + } + marshaler := jsonpb.Marshaler{ + OrigName: true, + EnumsAsInts: false, + EmitDefaults: false, + } + + tips.JsonDetail, _ = marshaler.MarshalToString(m) + var nickname string + + from, err := imdb.GetUserByUserID(sendID) + if err != nil { + log.Error(operationID, "GetUserByUserID failed ", err.Error(), sendID) + } + if from != nil { + nickname = from.Nickname + } + + to, err := imdb.GetUserByUserID(recvUserID) + if err != nil { + log.NewWarn(operationID, "GetUserByUserID failed ", err.Error(), recvUserID) + } + toNickname := "" + if to != nil { + toNickname = to.Nickname + } + + cn := config.Config.Notification + switch contentType { + case constant.GroupCreatedNotification: + tips.DefaultTips = nickname + " " + cn.GroupCreated.DefaultTips.Tips + case constant.GroupInfoSetNotification: + tips.DefaultTips = nickname + " " + cn.GroupInfoSet.DefaultTips.Tips + case constant.JoinGroupApplicationNotification: + tips.DefaultTips = nickname + " " + cn.JoinGroupApplication.DefaultTips.Tips + case constant.MemberQuitNotification: + tips.DefaultTips = nickname + " " + cn.MemberQuit.DefaultTips.Tips + case constant.GroupApplicationAcceptedNotification: // + tips.DefaultTips = toNickname + " " + cn.GroupApplicationAccepted.DefaultTips.Tips + case constant.GroupApplicationRejectedNotification: // + tips.DefaultTips = toNickname + " " + cn.GroupApplicationRejected.DefaultTips.Tips + case constant.GroupOwnerTransferredNotification: // + tips.DefaultTips = toNickname + " " + cn.GroupOwnerTransferred.DefaultTips.Tips + case constant.MemberKickedNotification: // + tips.DefaultTips = toNickname + " " + cn.MemberKicked.DefaultTips.Tips + case constant.MemberInvitedNotification: // + tips.DefaultTips = toNickname + " " + cn.MemberInvited.DefaultTips.Tips + case constant.MemberEnterNotification: + tips.DefaultTips = toNickname + " " + cn.MemberEnter.DefaultTips.Tips + case constant.GroupDismissedNotification: + tips.DefaultTips = toNickname + "" + cn.GroupDismissed.DefaultTips.Tips + case constant.GroupMutedNotification: + tips.DefaultTips = toNickname + "" + cn.GroupMuted.DefaultTips.Tips + case constant.GroupCancelMutedNotification: + tips.DefaultTips = toNickname + "" + cn.GroupCancelMuted.DefaultTips.Tips + case constant.GroupMemberMutedNotification: + tips.DefaultTips = toNickname + "" + cn.GroupMemberMuted.DefaultTips.Tips + case constant.GroupMemberCancelMutedNotification: + tips.DefaultTips = toNickname + "" + cn.GroupMemberCancelMuted.DefaultTips.Tips + case constant.GroupMemberInfoSetNotification: + tips.DefaultTips = toNickname + "" + cn.GroupMemberInfoSet.DefaultTips.Tips + case constant.GroupMemberSetToAdminNotification: + tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToAdmin.DefaultTips.Tips + case constant.GroupMemberSetToOrdinaryUserNotification: + tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToOrdinary.DefaultTips.Tips + default: + log.Error(operationID, "contentType failed ", contentType) + return + } + + var n msg.NotificationMsg + n.SendID = sendID + if groupID != "" { + n.RecvID = groupID + group, err := imdb.GetGroupInfoByGroupID(groupID) + if err != nil { + log.NewError(operationID, "GetGroupInfoByGroupID failed ", err.Error(), groupID) + } + switch group.GroupType { + case constant.NormalGroup: + n.SessionType = constant.GroupChatType + default: + n.SessionType = constant.SuperGroupChatType + } + } else { + n.RecvID = recvUserID + n.SessionType = constant.SingleChatType + } + n.ContentType = contentType + n.OperationID = operationID + n.Content, err = proto.Marshal(&tips) + if err != nil { + log.Error(operationID, "Marshal failed ", err.Error(), tips.String()) + return + } + msg.Notification(&n) +} + +// 创建群后调用 +func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberList []string) { + GroupCreatedTips := sdkws.GroupCreatedTips{Group: &sdkws.GroupInfo{}, + OpUser: &sdkws.GroupMemberFullInfo{}, GroupOwnerUser: &sdkws.GroupMemberFullInfo{}} + if err := setOpUserInfo(opUserID, groupID, GroupCreatedTips.OpUser); err != nil { + log.NewError(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, GroupCreatedTips.OpUser) + return + } + err := setGroupInfo(groupID, GroupCreatedTips.Group) + if err != nil { + log.Error(operationID, "setGroupInfo failed ", groupID, GroupCreatedTips.Group) + return + } + imdb.GetGroupOwnerInfoByGroupID(groupID) + if err := setGroupOwnerInfo(groupID, GroupCreatedTips.GroupOwnerUser); err != nil { + log.Error(operationID, "setGroupOwnerInfo failed", err.Error(), groupID) + return + } + for _, v := range initMemberList { + var groupMemberInfo sdkws.GroupMemberFullInfo + if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil { + log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, v) + continue + } + GroupCreatedTips.MemberList = append(GroupCreatedTips.MemberList, &groupMemberInfo) + if len(GroupCreatedTips.MemberList) == constant.MaxNotificationNum { + break + } + } + groupNotification(constant.GroupCreatedNotification, &GroupCreatedTips, opUserID, groupID, "", operationID) +} + +// 群信息改变后掉用 +// groupName := "" +// +// notification := "" +// introduction := "" +// faceURL := "" +func GroupInfoSetNotification(operationID, opUserID, groupID string, groupName, notification, introduction, faceURL string, needVerification *wrapperspb.Int32Value) { + GroupInfoChangedTips := sdkws.GroupInfoSetTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(groupID, GroupInfoChangedTips.Group); err != nil { + log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID) + return + } + GroupInfoChangedTips.Group.GroupName = groupName + GroupInfoChangedTips.Group.Notification = notification + GroupInfoChangedTips.Group.Introduction = introduction + GroupInfoChangedTips.Group.FaceURL = faceURL + if needVerification != nil { + GroupInfoChangedTips.Group.NeedVerification = needVerification.Value + } + + if err := setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil { + log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID) + return + } + groupNotification(constant.GroupInfoSetNotification, &GroupInfoChangedTips, opUserID, groupID, "", operationID) +} + +func GroupMutedNotification(operationID, opUserID, groupID string) { + tips := sdkws.GroupMutedTips{Group: &sdkws.GroupInfo{}, + OpUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(groupID, tips.Group); err != nil { + log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID) + return + } + if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil { + log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID) + return + } + groupNotification(constant.GroupMutedNotification, &tips, opUserID, groupID, "", operationID) +} + +func GroupCancelMutedNotification(operationID, opUserID, groupID string) { + tips := sdkws.GroupCancelMutedTips{Group: &sdkws.GroupInfo{}, + OpUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(groupID, tips.Group); err != nil { + log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID) + return + } + if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil { + log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID) + return + } + groupNotification(constant.GroupCancelMutedNotification, &tips, opUserID, groupID, "", operationID) +} + +func GroupMemberMutedNotification(operationID, opUserID, groupID, groupMemberUserID string, mutedSeconds uint32) { + tips := sdkws.GroupMemberMutedTips{Group: &sdkws.GroupInfo{}, + OpUser: &sdkws.GroupMemberFullInfo{}, MutedUser: &sdkws.GroupMemberFullInfo{}} + tips.MutedSeconds = mutedSeconds + if err := setGroupInfo(groupID, tips.Group); err != nil { + log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID) + return + } + if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil { + log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID) + return + } + if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil { + log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID) + return + } + groupNotification(constant.GroupMemberMutedNotification, &tips, opUserID, groupID, "", operationID) +} + +func GroupMemberInfoSetNotification(operationID, opUserID, groupID, groupMemberUserID string) { + tips := sdkws.GroupMemberInfoSetTips{Group: &sdkws.GroupInfo{}, + OpUser: &sdkws.GroupMemberFullInfo{}, ChangedUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(groupID, tips.Group); err != nil { + log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID) + return + } + if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil { + log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID) + return + } + if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil { + log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID) + return + } + groupNotification(constant.GroupMemberInfoSetNotification, &tips, opUserID, groupID, "", operationID) +} + +func GroupMemberRoleLevelChangeNotification(operationID, opUserID, groupID, groupMemberUserID string, notificationType int32) { + if notificationType != constant.GroupMemberSetToAdminNotification && notificationType != constant.GroupMemberSetToOrdinaryUserNotification { + log.NewError(operationID, utils.GetSelfFuncName(), "invalid notificationType: ", notificationType) + return + } + tips := sdkws.GroupMemberInfoSetTips{Group: &sdkws.GroupInfo{}, + OpUser: &sdkws.GroupMemberFullInfo{}, ChangedUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(groupID, tips.Group); err != nil { + log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID) + return + } + if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil { + log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID) + return + } + if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil { + log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID) + return + } + groupNotification(notificationType, &tips, opUserID, groupID, "", operationID) +} + +func GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMemberUserID string) { + tips := sdkws.GroupMemberCancelMutedTips{Group: &sdkws.GroupInfo{}, + OpUser: &sdkws.GroupMemberFullInfo{}, MutedUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(groupID, tips.Group); err != nil { + log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID) + return + } + if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil { + log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID) + return + } + if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil { + log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID) + return + } + groupNotification(constant.GroupMemberCancelMutedNotification, &tips, opUserID, groupID, "", operationID) +} + +// message ReceiveJoinApplicationTips{ +// GroupInfo Group = 1; +// PublicUserInfo Applicant = 2; +// string Reason = 3; +// } apply->all managers GroupID string `protobuf:"bytes,1,opt,name=GroupID" json:"GroupID,omitempty"` +// +// ReqMessage string `protobuf:"bytes,2,opt,name=ReqMessage" json:"ReqMessage,omitempty"` +// OpUserID string `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"` +// OperationID string `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"` +// +// 申请进群后调用 +func JoinGroupApplicationNotification(ctx context.Context, req *pbGroup.JoinGroupReq) { + JoinGroupApplicationTips := sdkws.JoinGroupApplicationTips{Group: &sdkws.GroupInfo{}, Applicant: &sdkws.PublicUserInfo{}} + err := setGroupInfo(req.GroupID, JoinGroupApplicationTips.Group) + if err != nil { + log.Error(utils.OperationID(ctx), "setGroupInfo failed ", err.Error(), req.GroupID) + return + } + if err = setPublicUserInfo(utils.OpUserID(ctx), JoinGroupApplicationTips.Applicant); err != nil { + log.Error(utils.OperationID(ctx), "setPublicUserInfo failed ", err.Error(), utils.OpUserID(ctx)) + return + } + JoinGroupApplicationTips.ReqMsg = req.ReqMessage + + managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID) + if err != nil { + log.NewError(utils.OperationID(ctx), "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID) + return + } + for _, v := range managerList { + groupNotification(constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, utils.OpUserID(ctx), "", v.UserID, utils.OperationID(ctx)) + log.NewInfo(utils.OperationID(ctx), "Notification ", v) + } +} + +func MemberQuitNotification(req *pbGroup.QuitGroupReq) { + MemberQuitTips := sdkws.MemberQuitTips{Group: &sdkws.GroupInfo{}, QuitUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(req.GroupID, MemberQuitTips.Group); err != nil { + log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID) + return + } + if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberQuitTips.QuitUser); err != nil { + log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID) + return + } + + groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, req.GroupID, "", req.OperationID) +} + +// message ApplicationProcessedTips{ +// GroupInfo Group = 1; +// GroupMemberFullInfo OpUser = 2; +// int32 Result = 3; +// string Reason = 4; +// } +// +// 处理进群请求后调用 +func GroupApplicationAcceptedNotification(req *pbGroup.GroupApplicationResponseReq) { + GroupApplicationAcceptedTips := sdkws.GroupApplicationAcceptedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg} + if err := setGroupInfo(req.GroupID, GroupApplicationAcceptedTips.Group); err != nil { + log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationAcceptedTips.Group) + return + } + if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser); err != nil { + log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser) + return + } + + groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", req.FromUserID, req.OperationID) + adminList, err := imdb.GetOwnerManagerByGroupID(req.GroupID) + if err != nil { + log.Error(req.OperationID, "GetOwnerManagerByGroupID failed", req.GroupID) + return + } + for _, v := range adminList { + if v.UserID == req.OpUserID { + continue + } + GroupApplicationAcceptedTips.ReceiverAs = 1 + groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", v.UserID, req.OperationID) + } +} + +func GroupApplicationRejectedNotification(req *pbGroup.GroupApplicationResponseReq) { + GroupApplicationRejectedTips := sdkws.GroupApplicationRejectedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg} + if err := setGroupInfo(req.GroupID, GroupApplicationRejectedTips.Group); err != nil { + log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationRejectedTips.Group) + return + } + if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser); err != nil { + log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser) + return + } + groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", req.FromUserID, req.OperationID) + adminList, err := imdb.GetOwnerManagerByGroupID(req.GroupID) + if err != nil { + log.Error(req.OperationID, "GetOwnerManagerByGroupID failed", req.GroupID) + return + } + for _, v := range adminList { + if v.UserID == req.OpUserID { + continue + } + GroupApplicationRejectedTips.ReceiverAs = 1 + groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", v.UserID, req.OperationID) + } +} + +func GroupOwnerTransferredNotification(req *pbGroup.TransferGroupOwnerReq) { + GroupOwnerTransferredTips := sdkws.GroupOwnerTransferredTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, NewGroupOwner: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(req.GroupID, GroupOwnerTransferredTips.Group); err != nil { + log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID) + return + } + if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupOwnerTransferredTips.OpUser); err != nil { + log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID) + return + } + if err := setGroupMemberInfo(req.GroupID, req.NewOwnerUserID, GroupOwnerTransferredTips.NewGroupOwner); err != nil { + log.Error(req.OperationID, "setGroupMemberInfo failed", req.GroupID, req.NewOwnerUserID) + return + } + groupNotification(constant.GroupOwnerTransferredNotification, &GroupOwnerTransferredTips, req.OpUserID, req.GroupID, "", req.OperationID) +} + +func GroupDismissedNotification(req *pbGroup.DismissGroupReq) { + tips := sdkws.GroupDismissedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(req.GroupID, tips.Group); err != nil { + log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID) + return + } + if err := setOpUserInfo(req.OpUserID, req.GroupID, tips.OpUser); err != nil { + log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID) + return + } + groupNotification(constant.GroupDismissedNotification, &tips, req.OpUserID, req.GroupID, "", req.OperationID) +} + +// message MemberKickedTips{ +// GroupInfo Group = 1; +// GroupMemberFullInfo OpUser = 2; +// GroupMemberFullInfo KickedUser = 3; +// uint64 OperationTime = 4; +// } +// +// 被踢后调用 +func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) { + MemberKickedTips := sdkws.MemberKickedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(req.GroupID, MemberKickedTips.Group); err != nil { + log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID) + return + } + if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberKickedTips.OpUser); err != nil { + log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID) + return + } + for _, v := range kickedUserIDList { + var groupMemberInfo sdkws.GroupMemberFullInfo + if err := setGroupMemberInfo(req.GroupID, v, &groupMemberInfo); err != nil { + log.Error(req.OperationID, "setGroupMemberInfo failed ", err.Error(), req.GroupID, v) + continue + } + MemberKickedTips.KickedUserList = append(MemberKickedTips.KickedUserList, &groupMemberInfo) + } + groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, req.GroupID, "", req.OperationID) + // + //for _, v := range kickedUserIDList { + // groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, "", v, req.OperationID) + //} +} + +// message MemberInvitedTips{ +// GroupInfo Group = 1; +// GroupMemberFullInfo OpUser = 2; +// GroupMemberFullInfo InvitedUser = 3; +// uint64 OperationTime = 4; +// } +// +// 被邀请进群后调用 +func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) { + MemberInvitedTips := sdkws.MemberInvitedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(groupID, MemberInvitedTips.Group); err != nil { + log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID) + return + } + if err := setOpUserInfo(opUserID, groupID, MemberInvitedTips.OpUser); err != nil { + log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID) + return + } + for _, v := range invitedUserIDList { + var groupMemberInfo sdkws.GroupMemberFullInfo + if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil { + log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID) + continue + } + MemberInvitedTips.InvitedUserList = append(MemberInvitedTips.InvitedUserList, &groupMemberInfo) + } + groupNotification(constant.MemberInvitedNotification, &MemberInvitedTips, opUserID, groupID, "", operationID) +} + +//message GroupInfoChangedTips{ +// int32 ChangedType = 1; //bitwise operators: 1:groupName; 10:Notification 100:Introduction; 1000:FaceUrl +// GroupInfo Group = 2; +// GroupMemberFullInfo OpUser = 3; +//} + +//message MemberLeaveTips{ +// GroupInfo Group = 1; +// GroupMemberFullInfo LeaverUser = 2; +// uint64 OperationTime = 3; +//} + +//群成员退群后调用 + +// message MemberEnterTips{ +// GroupInfo Group = 1; +// GroupMemberFullInfo EntrantUser = 2; +// uint64 OperationTime = 3; +// } +// +// 群成员主动申请进群，管理员同意后调用， +func MemberEnterNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) { + MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(req.GroupID, MemberEnterTips.Group); err != nil { + log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, MemberEnterTips.Group) + return + } + if err := setGroupMemberInfo(req.GroupID, req.FromUserID, MemberEnterTips.EntrantUser); err != nil { + log.Error(req.OperationID, "setGroupMemberInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberEnterTips.EntrantUser) + return + } + groupNotification(constant.MemberEnterNotification, &MemberEnterTips, req.OpUserID, req.GroupID, "", req.OperationID) +} + +func MemberEnterDirectlyNotification(groupID string, entrantUserID string, operationID string) { + MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}} + if err := setGroupInfo(groupID, MemberEnterTips.Group); err != nil { + log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID, MemberEnterTips.Group) + return + } + if err := setGroupMemberInfo(groupID, entrantUserID, MemberEnterTips.EntrantUser); err != nil { + log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, entrantUserID, MemberEnterTips.EntrantUser) + return + } + groupNotification(constant.MemberEnterNotification, &MemberEnterTips, entrantUserID, groupID, "", operationID) +} diff --git a/internal/common/notification/msg.go b/internal/common/notification/msg.go new file mode 100644 index 000000000..a846ce738 --- /dev/null +++ b/internal/common/notification/msg.go @@ -0,0 +1,48 @@ +package notification + +import ( + "Open_IM/internal/rpc/msg" + "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/log" + sdkws "Open_IM/pkg/proto/sdkws" + "Open_IM/pkg/utils" + "github.com/golang/protobuf/jsonpb" + "github.com/golang/protobuf/proto" +) + +func DeleteMessageNotification(opUserID, userID string, seqList []uint32, operationID string) { + DeleteMessageTips := sdkws.DeleteMessageTips{OpUserID: opUserID, UserID: userID, SeqList: seqList} + MessageNotification(operationID, userID, userID, constant.DeleteMessageNotification, &DeleteMessageTips) +} + +func MessageNotification(operationID, sendID, recvID string, contentType int32, m proto.Message) { + log.Debug(operationID, utils.GetSelfFuncName(), "args: ", m.String(), contentType) + var err error + var tips sdkws.TipsComm + tips.Detail, err = proto.Marshal(m) + if err != nil { + log.Error(operationID, "Marshal failed ", err.Error(), m.String()) + return + } + + marshaler := jsonpb.Marshaler{ + OrigName: true, + EnumsAsInts: false, + EmitDefaults: false, + } + + tips.JsonDetail, _ = marshaler.MarshalToString(m) + var n msg.NotificationMsg + n.SendID = sendID + n.RecvID = recvID + n.ContentType = contentType + n.SessionType = constant.SingleChatType + n.MsgFrom = constant.SysMsgType + n.OperationID = operationID + n.Content, err = proto.Marshal(&tips) + if err != nil { + log.Error(operationID, "Marshal failed ", err.Error(), tips.String()) + return + } + msg.Notification(&n) +} diff --git a/internal/common/notification/super_group.go b/internal/common/notification/super_group.go new file mode 100644 index 000000000..19d08dd98 --- /dev/null +++ b/internal/common/notification/super_group.go @@ -0,0 +1,24 @@ +package notification + +import ( + "Open_IM/internal/rpc/msg" + "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/log" + //sdk "Open_IM/pkg/proto/sdkws" + "Open_IM/pkg/utils" + //"github.com/golang/protobuf/jsonpb" + //"github.com/golang/protobuf/proto" +) + +func SuperGroupNotification(operationID, sendID, recvID string) { + n := &msg.NotificationMsg{ + SendID: sendID, + RecvID: recvID, + MsgFrom: constant.SysMsgType, + ContentType: constant.SuperGroupUpdateNotification, + SessionType: constant.SingleChatType, + OperationID: operationID, + } + log.NewInfo(operationID, utils.GetSelfFuncName(), string(n.Content)) + msg.Notification(n) +} diff --git a/internal/rpc/msg/extend_msg_callback.go b/internal/rpc/msg/extend_msg_callback.go new file mode 100644 index 000000000..eefcb419e --- /dev/null +++ b/internal/rpc/msg/extend_msg_callback.go @@ -0,0 +1,104 @@ +package msg + +import ( + cbApi "Open_IM/pkg/call_back_struct" + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/http" + "Open_IM/pkg/common/log" + "Open_IM/pkg/proto/msg" + "Open_IM/pkg/utils" + http2 "net/http" +) + +func callbackSetMessageReactionExtensions(setReq *msg.SetMessageReactionExtensionsReq) *cbApi.CallbackBeforeSetMessageReactionExtResp { + callbackResp := cbApi.CommonCallbackResp{OperationID: setReq.OperationID} + log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String()) + req := cbApi.CallbackBeforeSetMessageReactionExtReq{ + OperationID: setReq.OperationID, + CallbackCommand: constant.CallbackBeforeSetMessageReactionExtensionCommand, + SourceID: setReq.SourceID, + OpUserID: setReq.OpUserID, + SessionType: setReq.SessionType, + ReactionExtensionList: setReq.ReactionExtensionList, + ClientMsgID: setReq.ClientMsgID, + IsReact: setReq.IsReact, + IsExternalExtensions: setReq.IsExternalExtensions, + MsgFirstModifyTime: setReq.MsgFirstModifyTime, + } + resp := &cbApi.CallbackBeforeSetMessageReactionExtResp{CommonCallbackResp: &callbackResp} + defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp) + if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSetMessageReactionExtensionCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil { + callbackResp.ErrCode = http2.StatusInternalServerError + callbackResp.ErrMsg = err.Error() + } + return resp + +} + +func callbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessageListReactionExtensionsReq) *cbApi.CallbackDeleteMessageReactionExtResp { + callbackResp := cbApi.CommonCallbackResp{OperationID: setReq.OperationID} + log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String()) + req := cbApi.CallbackDeleteMessageReactionExtReq{ + OperationID: setReq.OperationID, + CallbackCommand: constant.CallbackBeforeDeleteMessageReactionExtensionsCommand, + SourceID: setReq.SourceID, + OpUserID: setReq.OpUserID, + SessionType: setReq.SessionType, + ReactionExtensionList: setReq.ReactionExtensionList, + ClientMsgID: setReq.ClientMsgID, + IsExternalExtensions: setReq.IsExternalExtensions, + MsgFirstModifyTime: setReq.MsgFirstModifyTime, + } + resp := &cbApi.CallbackDeleteMessageReactionExtResp{CommonCallbackResp: &callbackResp} + defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp) + if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeDeleteMessageReactionExtensionsCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil { + callbackResp.ErrCode = http2.StatusInternalServerError + callbackResp.ErrMsg = err.Error() + } + return resp +} +func callbackGetMessageListReactionExtensions(getReq *msg.GetMessageListReactionExtensionsReq) *cbApi.CallbackGetMessageListReactionExtResp { + callbackResp := cbApi.CommonCallbackResp{OperationID: getReq.OperationID} + log.NewDebug(getReq.OperationID, utils.GetSelfFuncName(), getReq.String()) + req := cbApi.CallbackGetMessageListReactionExtReq{ + OperationID: getReq.OperationID, + CallbackCommand: constant.CallbackGetMessageListReactionExtensionsCommand, + SourceID: getReq.SourceID, + OpUserID: getReq.OpUserID, + SessionType: getReq.SessionType, + TypeKeyList: getReq.TypeKeyList, + MessageKeyList: getReq.MessageReactionKeyList, + } + resp := &cbApi.CallbackGetMessageListReactionExtResp{CommonCallbackResp: &callbackResp} + defer log.NewDebug(getReq.OperationID, utils.GetSelfFuncName(), req, *resp) + if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackGetMessageListReactionExtensionsCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil { + callbackResp.ErrCode = http2.StatusInternalServerError + callbackResp.ErrMsg = err.Error() + } + return resp +} +func callbackAddMessageReactionExtensions(setReq *msg.AddMessageReactionExtensionsReq) *cbApi.CallbackAddMessageReactionExtResp { + callbackResp := cbApi.CommonCallbackResp{OperationID: setReq.OperationID} + log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String()) + req := cbApi.CallbackAddMessageReactionExtReq{ + OperationID: setReq.OperationID, + CallbackCommand: constant.CallbackAddMessageListReactionExtensionsCommand, + SourceID: setReq.SourceID, + OpUserID: setReq.OpUserID, + SessionType: setReq.SessionType, + ReactionExtensionList: setReq.ReactionExtensionList, + ClientMsgID: setReq.ClientMsgID, + IsReact: setReq.IsReact, + IsExternalExtensions: setReq.IsExternalExtensions, + MsgFirstModifyTime: setReq.MsgFirstModifyTime, + } + resp := &cbApi.CallbackAddMessageReactionExtResp{CommonCallbackResp: &callbackResp} + defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp, *resp.CommonCallbackResp, resp.IsReact, resp.MsgFirstModifyTime) + if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAddMessageListReactionExtensionsCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil { + callbackResp.ErrCode = http2.StatusInternalServerError + callbackResp.ErrMsg = err.Error() + } + return resp + +}