modify dictory

pkg/rpcclient/notification/conevrsation.go

@@ -0,0 +1,63 @@
+package notification
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+	"github.com/golang/protobuf/proto"
+)
+
+type ConversationNotificationSender struct {
+	*rpcclient.MsgClient
+}
+
+func NewConversationNotificationSender(client discoveryregistry.SvcDiscoveryRegistry) *ConversationNotificationSender {
+	return &ConversationNotificationSender{rpcclient.NewMsgClient(client)}
+}
+
+func (c *ConversationNotificationSender) SetConversationNotification(ctx context.Context, sendID, recvID string, contentType int, m proto.Message) {
+	var err error
+	var n rpcclient.NotificationMsg
+	n.SendID = sendID
+	n.RecvID = recvID
+	n.ContentType = int32(contentType)
+	n.SessionType = constant.SingleChatType
+	n.MsgFrom = constant.SysMsgType
+	n.Content, err = json.Marshal(m)
+	if err != nil {
+		return
+	}
+	c.Notification(ctx, &n)
+}
+
+// SetPrivate调用
+func (c *ConversationNotificationSender) ConversationSetPrivateNotification(ctx context.Context, sendID, recvID string, isPrivateChat bool) {
+	tips := &sdkws.ConversationSetPrivateTips{
+		RecvID:    recvID,
+		SendID:    sendID,
+		IsPrivate: isPrivateChat,
+	}
+	c.SetConversationNotification(ctx, sendID, recvID, constant.ConversationPrivateChatNotification, tips)
+}
+
+// 会话改变
+func (c *ConversationNotificationSender) ConversationChangeNotification(ctx context.Context, userID string) {
+	tips := &sdkws.ConversationUpdateTips{
+		UserID: userID,
+	}
+	c.SetConversationNotification(ctx, userID, userID, constant.ConversationOptChangeNotification, tips)
+}
+
+// 会话未读数同步
+func (c *ConversationNotificationSender) ConversationUnreadChangeNotification(ctx context.Context, userID, conversationID string, updateUnreadCountTime int64) {
+	tips := &sdkws.ConversationUpdateTips{
+		UserID:                userID,
+		ConversationIDList:    []string{conversationID},
+		UpdateUnreadCountTime: updateUnreadCountTime,
+	}
+	c.SetConversationNotification(ctx, userID, userID, constant.ConversationUnreadNotification, tips)
+}

pkg/rpcclient/notification/extend_msg.go

@@ -0,0 +1,103 @@
+package notification
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/golang/protobuf/proto"
+)
+
+type ExtendMsgNotificationSender struct {
+	*rpcclient.MsgClient
+}
+
+func NewExtendMsgNotificationSender(client discoveryregistry.SvcDiscoveryRegistry) *ExtendMsgNotificationSender {
+	return &ExtendMsgNotificationSender{rpcclient.NewMsgClient(client)}
+}
+
+func (e *ExtendMsgNotificationSender) ExtendMessageUpdatedNotification(ctx context.Context, sendID string, sourceID string, sessionType int32,
+	req *msg.SetMessageReactionExtensionsReq, resp *msg.SetMessageReactionExtensionsResp, isHistory bool, isReactionFromCache bool) {
+	var content sdkws.ReactionMessageModifierNotification
+	content.SourceID = req.SourceID
+	content.OpUserID = mcontext.GetOpUserID(ctx)
+	content.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 {
+		return
+	}
+	content.SuccessReactionExtensions = keyMap
+	content.ClientMsgID = req.ClientMsgID
+	content.IsReact = resp.IsReact
+	content.IsExternalExtensions = req.IsExternalExtensions
+	content.MsgFirstModifyTime = resp.MsgFirstModifyTime
+	e.messageReactionSender(ctx, sendID, sourceID, sessionType, constant.ReactionMessageModifier, &content, isHistory, isReactionFromCache)
+}
+func (e *ExtendMsgNotificationSender) ExtendMessageDeleteNotification(ctx context.Context, sendID string, sourceID string, sessionType int32,
+	req *msg.DeleteMessagesReactionExtensionsReq, resp *msg.DeleteMessagesReactionExtensionsResp, isHistory bool, isReactionFromCache bool) {
+	var content sdkws.ReactionMessageDeleteNotification
+	content.SourceID = req.SourceID
+	content.OpUserID = req.OpUserID
+	content.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 {
+		return
+	}
+	content.SuccessReactionExtensions = keyMap
+	content.ClientMsgID = req.ClientMsgID
+	content.MsgFirstModifyTime = req.MsgFirstModifyTime
+	e.messageReactionSender(ctx, sendID, sourceID, sessionType, constant.ReactionMessageDeleter, &content, isHistory, isReactionFromCache)
+}
+func (e *ExtendMsgNotificationSender) messageReactionSender(ctx context.Context, sendID string, sourceID string, sessionType, contentType int32, m proto.Message, isHistory bool, isReactionFromCache bool) error {
+	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)
+	}
+	bytes, err := json.Marshal(m)
+	if err != nil {
+		return errs.ErrData.Wrap(err.Error())
+	}
+	pbData := msg.SendMsgReq{
+		MsgData: &sdkws.MsgData{
+			SendID:      sendID,
+			ClientMsgID: utils.GetMsgID(sendID),
+			SessionType: sessionType,
+			MsgFrom:     constant.SysMsgType,
+			ContentType: contentType,
+			Content:     bytes,
+			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
+	}
+	_, err = e.SendMsg(ctx, &pbData)
+	return err
+}

pkg/rpcclient/notification/friend.go

@@ -0,0 +1,192 @@
+package notification
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
+	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	pbFriend "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+
+	"github.com/golang/protobuf/proto"
+)
+
+type FriendNotificationSender struct {
+	*rpcclient.MsgClient
+	// 找不到报错
+	getUsersInfo func(ctx context.Context, userIDs []string) ([]rpcclient.CommonUser, error)
+	// db controller
+	db controller.FriendDatabase
+}
+
+type friendNotificationSenderOptions func(*FriendNotificationSender)
+
+func WithFriendDB(db controller.FriendDatabase) friendNotificationSenderOptions {
+	return func(s *FriendNotificationSender) {
+		s.db = db
+	}
+}
+
+func WithDBFunc(fn func(ctx context.Context, userIDs []string) (users []*relationTb.UserModel, err error)) friendNotificationSenderOptions {
+	return func(s *FriendNotificationSender) {
+		f := func(ctx context.Context, userIDs []string) (result []rpcclient.CommonUser, err error) {
+			users, err := fn(ctx, userIDs)
+			if err != nil {
+				return nil, err
+			}
+			for _, user := range users {
+				result = append(result, user)
+			}
+			return result, nil
+		}
+		s.getUsersInfo = f
+	}
+}
+
+func WithRpcFunc(fn func(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error)) friendNotificationSenderOptions {
+	return func(s *FriendNotificationSender) {
+		f := func(ctx context.Context, userIDs []string) (result []rpcclient.CommonUser, err error) {
+			users, err := fn(ctx, userIDs)
+			if err != nil {
+				return nil, err
+			}
+			for _, user := range users {
+				result = append(result, user)
+			}
+			return result, err
+		}
+		s.getUsersInfo = f
+	}
+}
+
+func NewFriendNotificationSender(client discoveryregistry.SvcDiscoveryRegistry, opts ...friendNotificationSenderOptions) *FriendNotificationSender {
+	f := &FriendNotificationSender{
+		MsgClient: rpcclient.NewMsgClient(client),
+	}
+	for _, opt := range opts {
+		opt(f)
+	}
+	return f
+}
+
+func (c *FriendNotificationSender) getUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
+	users, err := c.getUsersInfo(ctx, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	result := make(map[string]*sdkws.UserInfo)
+	for _, user := range users {
+		result[user.GetUserID()] = user.(*sdkws.UserInfo)
+	}
+	return result, nil
+}
+
+func (c *FriendNotificationSender) getFromToUserNickname(ctx context.Context, fromUserID, toUserID string) (string, string, error) {
+	users, err := c.getUsersInfoMap(ctx, []string{fromUserID, toUserID})
+	if err != nil {
+		return "", "", nil
+	}
+	return users[fromUserID].Nickname, users[toUserID].Nickname, nil
+}
+
+func (c *FriendNotificationSender) friendNotification(ctx context.Context, fromUserID, toUserID string, contentType int32, m proto.Message) {
+	var err error
+	var n rpcclient.NotificationMsg
+	n.SendID = fromUserID
+	n.RecvID = toUserID
+	n.ContentType = contentType
+	n.SessionType = constant.SingleChatType
+	n.MsgFrom = constant.SysMsgType
+	n.Content, err = json.Marshal(m)
+	if err != nil {
+		return
+	}
+	c.Notification(ctx, &n)
+}
+
+func (u *FriendNotificationSender) UserInfoUpdatedNotification(ctx context.Context, opUserID string, changedUserID string) {
+	tips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
+	u.friendNotification(ctx, opUserID, changedUserID, constant.UserInfoUpdatedNotification, &tips)
+}
+
+func (c *FriendNotificationSender) FriendApplicationAddNotification(ctx context.Context, req *pbFriend.ApplyToAddFriendReq) {
+	FriendApplicationTips := sdkws.FriendApplicationTips{FromToUserID: &sdkws.FromToUserID{}}
+	FriendApplicationTips.FromToUserID.FromUserID = req.FromUserID
+	FriendApplicationTips.FromToUserID.ToUserID = req.ToUserID
+	c.friendNotification(ctx, req.FromUserID, req.ToUserID, constant.FriendApplicationNotification, &FriendApplicationTips)
+}
+
+func (c *FriendNotificationSender) 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
+	c.friendNotification(ctx, req.ToUserID, req.FromUserID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
+}
+
+func (c *FriendNotificationSender) 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
+	c.friendNotification(ctx, req.ToUserID, req.FromUserID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
+}
+
+func (c *FriendNotificationSender) FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) {
+	friendAddedTips := sdkws.FriendAddedTips{Friend: &sdkws.FriendInfo{}, OpUser: &sdkws.PublicUserInfo{}}
+	user, err := c.getUsersInfo(ctx, []string{opUserID})
+	if err != nil {
+		return
+	}
+	friendAddedTips.OpUser.UserID = user[0].GetUserID()
+	friendAddedTips.OpUser.Ex = user[0].GetEx()
+	friendAddedTips.OpUser.Nickname = user[0].GetNickname()
+	friendAddedTips.OpUser.FaceURL = user[0].GetFaceURL()
+	friends, err := c.db.FindFriendsWithError(ctx, fromUserID, []string{toUserID})
+	if err != nil {
+		return
+	}
+	friendAddedTips.Friend, err = convert.FriendDB2Pb(ctx, friends[0], c.getUsersInfoMap)
+	if err != nil {
+		return
+	}
+	c.friendNotification(ctx, fromUserID, toUserID, constant.FriendAddedNotification, &friendAddedTips)
+}
+
+func (c *FriendNotificationSender) FriendDeletedNotification(ctx context.Context, req *pbFriend.DeleteFriendReq) {
+	friendDeletedTips := sdkws.FriendDeletedTips{FromToUserID: &sdkws.FromToUserID{}}
+	friendDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
+	friendDeletedTips.FromToUserID.ToUserID = req.FriendUserID
+	c.friendNotification(ctx, req.OwnerUserID, req.FriendUserID, constant.FriendDeletedNotification, &friendDeletedTips)
+}
+
+func (c *FriendNotificationSender) FriendRemarkSetNotification(ctx context.Context, fromUserID, toUserID string) {
+	friendInfoChangedTips := sdkws.FriendInfoChangedTips{FromToUserID: &sdkws.FromToUserID{}}
+	friendInfoChangedTips.FromToUserID.FromUserID = fromUserID
+	friendInfoChangedTips.FromToUserID.ToUserID = toUserID
+	c.friendNotification(ctx, fromUserID, toUserID, constant.FriendRemarkSetNotification, &friendInfoChangedTips)
+}
+
+func (c *FriendNotificationSender) BlackAddedNotification(ctx context.Context, req *pbFriend.AddBlackReq) {
+	blackAddedTips := sdkws.BlackAddedTips{FromToUserID: &sdkws.FromToUserID{}}
+	blackAddedTips.FromToUserID.FromUserID = req.OwnerUserID
+	blackAddedTips.FromToUserID.ToUserID = req.BlackUserID
+	c.friendNotification(ctx, req.OwnerUserID, req.BlackUserID, constant.BlackAddedNotification, &blackAddedTips)
+}
+
+func (c *FriendNotificationSender) BlackDeletedNotification(ctx context.Context, req *pbFriend.RemoveBlackReq) {
+	blackDeletedTips := sdkws.BlackDeletedTips{FromToUserID: &sdkws.FromToUserID{}}
+	blackDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
+	blackDeletedTips.FromToUserID.ToUserID = req.BlackUserID
+	c.friendNotification(ctx, req.OwnerUserID, req.BlackUserID, constant.BlackDeletedNotification, &blackDeletedTips)
+}
+
+func (c *FriendNotificationSender) FriendInfoUpdatedNotification(ctx context.Context, changedUserID string, needNotifiedUserID string, opUserID string) {
+	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
+	c.friendNotification(ctx, opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
+}

pkg/rpcclient/notification/group.go

@@ -0,0 +1,741 @@
+package notification
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	pbGroup "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/golang/protobuf/proto"
+)
+
+func NewGroupNotificationSender(db controller.GroupDatabase, sdr discoveryregistry.SvcDiscoveryRegistry, fn func(ctx context.Context, userIDs []string) ([]rpcclient.CommonUser, error)) *GroupNotificationSender {
+	return &GroupNotificationSender{
+		msgClient:    rpcclient.NewMsgClient(sdr),
+		getUsersInfo: fn,
+		db:           db,
+	}
+}
+
+type GroupNotificationSender struct {
+	msgClient    *rpcclient.MsgClient
+	getUsersInfo func(ctx context.Context, userIDs []string) ([]rpcclient.CommonUser, error)
+	db           controller.GroupDatabase
+}
+
+func (g *GroupNotificationSender) getUser(ctx context.Context, userID string) (*sdkws.PublicUserInfo, error) {
+	users, err := g.getUsersInfo(ctx, []string{userID})
+	if err != nil {
+		return nil, err
+	}
+	if len(users) == 0 {
+		return nil, errs.ErrUserIDNotFound.Wrap(fmt.Sprintf("user %s not found", userID))
+	}
+	return &sdkws.PublicUserInfo{
+		UserID:   users[0].GetUserID(),
+		Nickname: users[0].GetNickname(),
+		FaceURL:  users[0].GetFaceURL(),
+		Ex:       users[0].GetEx(),
+	}, nil
+}
+
+func (g *GroupNotificationSender) getGroupInfo(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
+	gm, err := g.db.TakeGroup(ctx, groupID)
+	if err != nil {
+		return nil, err
+	}
+	userIDs, err := g.db.FindGroupMemberUserID(ctx, groupID)
+	if err != nil {
+		return nil, err
+	}
+	owner, err := g.db.FindGroupMember(ctx, []string{groupID}, nil, []int32{constant.GroupOwner})
+	if err != nil {
+		return nil, err
+	}
+	if len(owner) == 0 {
+		return nil, errs.ErrInternalServer.Wrap(fmt.Sprintf("group %s owner not found", groupID))
+	}
+	return &sdkws.GroupInfo{
+		GroupID:                gm.GroupID,
+		GroupName:              gm.GroupName,
+		Notification:           gm.Notification,
+		Introduction:           gm.Introduction,
+		FaceURL:                gm.FaceURL,
+		OwnerUserID:            owner[0].UserID,
+		CreateTime:             gm.CreateTime.UnixMilli(),
+		MemberCount:            uint32(len(userIDs)),
+		Ex:                     gm.Ex,
+		Status:                 gm.Status,
+		CreatorUserID:          gm.CreatorUserID,
+		GroupType:              gm.GroupType,
+		NeedVerification:       gm.NeedVerification,
+		LookMemberInfo:         gm.LookMemberInfo,
+		ApplyMemberFriend:      gm.ApplyMemberFriend,
+		NotificationUpdateTime: gm.NotificationUpdateTime.UnixMilli(),
+		NotificationUserID:     gm.NotificationUserID,
+	}, nil
+}
+
+func (g *GroupNotificationSender) getGroupMembers(ctx context.Context, groupID string, userIDs []string) ([]*sdkws.GroupMemberFullInfo, error) {
+	members, err := g.db.FindGroupMember(ctx, []string{groupID}, userIDs, []int32{constant.GroupOwner})
+	if err != nil {
+		return nil, err
+	}
+	users, err := g.getUsersInfoMap(ctx, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	res := make([]*sdkws.GroupMemberFullInfo, 0, len(members))
+	for _, member := range members {
+		var appMangerLevel int32
+		if user := users[member.UserID]; user != nil {
+			appMangerLevel = user.AppMangerLevel
+			if member.Nickname == "" {
+				member.Nickname = user.Nickname
+			}
+			if member.FaceURL == "" {
+				member.FaceURL = user.FaceURL
+			}
+		}
+		res = append(res, g.groupMemberDB2PB(member, appMangerLevel))
+		delete(users, member.UserID)
+	}
+	for userID, info := range users {
+		if info.AppMangerLevel == constant.AppAdmin {
+			res = append(res, &sdkws.GroupMemberFullInfo{
+				GroupID:        groupID,
+				UserID:         userID,
+				Nickname:       info.Nickname,
+				FaceURL:        info.FaceURL,
+				AppMangerLevel: info.AppMangerLevel,
+			})
+		}
+	}
+	return res, nil
+}
+
+func (g *GroupNotificationSender) getGroupMemberMap(ctx context.Context, groupID string, userIDs []string) (map[string]*sdkws.GroupMemberFullInfo, error) {
+	members, err := g.getGroupMembers(ctx, groupID, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	m := make(map[string]*sdkws.GroupMemberFullInfo)
+	for i, member := range members {
+		m[member.UserID] = members[i]
+	}
+	return m, nil
+}
+
+func (g *GroupNotificationSender) getGroupMember(ctx context.Context, groupID string, userID string) (*sdkws.GroupMemberFullInfo, error) {
+	members, err := g.getGroupMembers(ctx, groupID, []string{userID})
+	if err != nil {
+		return nil, err
+	}
+	if len(members) == 0 {
+		return nil, errs.ErrInternalServer.Wrap(fmt.Sprintf("group %s member %s not found", groupID, userID))
+	}
+	return members[0], nil
+}
+
+func (g *GroupNotificationSender) getGroupOwnerAndAdminUserID(ctx context.Context, groupID string) ([]string, error) {
+	members, err := g.db.FindGroupMember(ctx, []string{groupID}, nil, []int32{constant.GroupOwner, constant.GroupAdmin})
+	if err != nil {
+		return nil, err
+	}
+	fn := func(e *relation.GroupMemberModel) string { return e.UserID }
+	return utils.Slice(members, fn), nil
+}
+
+func (g *GroupNotificationSender) groupDB2PB(group *relation.GroupModel, ownerUserID string, memberCount uint32) *sdkws.GroupInfo {
+	return &sdkws.GroupInfo{
+		GroupID:                group.GroupID,
+		GroupName:              group.GroupName,
+		Notification:           group.Notification,
+		Introduction:           group.Introduction,
+		FaceURL:                group.FaceURL,
+		OwnerUserID:            ownerUserID,
+		CreateTime:             group.CreateTime.UnixMilli(),
+		MemberCount:            memberCount,
+		Ex:                     group.Ex,
+		Status:                 group.Status,
+		CreatorUserID:          group.CreatorUserID,
+		GroupType:              group.GroupType,
+		NeedVerification:       group.NeedVerification,
+		LookMemberInfo:         group.LookMemberInfo,
+		ApplyMemberFriend:      group.ApplyMemberFriend,
+		NotificationUpdateTime: group.NotificationUpdateTime.UnixMilli(),
+		NotificationUserID:     group.NotificationUserID,
+	}
+}
+
+func (g *GroupNotificationSender) groupMemberDB2PB(member *relation.GroupMemberModel, appMangerLevel int32) *sdkws.GroupMemberFullInfo {
+	return &sdkws.GroupMemberFullInfo{
+		GroupID:        member.GroupID,
+		UserID:         member.UserID,
+		RoleLevel:      member.RoleLevel,
+		JoinTime:       member.JoinTime.UnixMilli(),
+		Nickname:       member.Nickname,
+		FaceURL:        member.FaceURL,
+		AppMangerLevel: appMangerLevel,
+		JoinSource:     member.JoinSource,
+		OperatorUserID: member.OperatorUserID,
+		Ex:             member.Ex,
+		MuteEndTime:    member.MuteEndTime.UnixMilli(),
+		InviterUserID:  member.InviterUserID,
+	}
+}
+
+func (g *GroupNotificationSender) getUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
+	users, err := g.getUsersInfo(ctx, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	result := make(map[string]*sdkws.UserInfo)
+	for _, user := range users {
+		result[user.GetUserID()] = user.(*sdkws.UserInfo)
+	}
+	return result, nil
+}
+
+func (g *GroupNotificationSender) getFromToUserNickname(ctx context.Context, fromUserID, toUserID string) (string, string, error) {
+	users, err := g.getUsersInfoMap(ctx, []string{fromUserID, toUserID})
+	if err != nil {
+		return "", "", nil
+	}
+	return users[fromUserID].Nickname, users[toUserID].Nickname, nil
+}
+
+func (g *GroupNotificationSender) groupNotification(ctx context.Context, contentType int32, m proto.Message, sendID, groupID, recvUserID string) (err error) {
+	content, err := json.Marshal(m)
+	if err != nil {
+		return err
+	}
+	notificationMsg := rpcclient.NotificationMsg{
+		SendID:      sendID,
+		RecvID:      recvUserID,
+		ContentType: contentType,
+		SessionType: constant.GroupChatType,
+		MsgFrom:     constant.SysMsgType,
+		Content:     content,
+	}
+	return g.msgClient.Notification(ctx, &notificationMsg)
+}
+
+func (g *GroupNotificationSender) GroupCreatedNotification(ctx context.Context, group *relation.GroupModel, members []*relation.GroupMemberModel, userMap map[string]*sdkws.UserInfo) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	groupInfo, err := g.mergeGroupFull(ctx, group.GroupID, group, &members, &userMap)
+	if err != nil {
+		return err
+	}
+	return g.groupNotification(ctx, constant.GroupCreatedNotification, groupInfo, mcontext.GetOpUserID(ctx), group.GroupID, "")
+}
+
+func (g *GroupNotificationSender) mergeGroupFull(ctx context.Context, groupID string, group *relation.GroupModel, ms *[]*relation.GroupMemberModel, users *map[string]*sdkws.UserInfo) (groupInfo *sdkws.GroupCreatedTips, err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	if group == nil {
+		group, err = g.db.TakeGroup(ctx, groupID)
+		if err != nil {
+			return nil, err
+		}
+	}
+	var members []*relation.GroupMemberModel
+	if ms == nil || len(*ms) == 0 {
+		members, err = g.db.FindGroupMember(ctx, []string{groupID}, nil, nil)
+		if err != nil {
+			return nil, err
+		}
+		if ms != nil {
+			*ms = members
+		}
+	} else {
+		members = *ms
+	}
+	opUserID := mcontext.GetOpUserID(ctx)
+	var userMap map[string]*sdkws.UserInfo
+	if users == nil || len(*users) == 0 {
+		userIDs := utils.Slice(members, func(e *relation.GroupMemberModel) string { return e.UserID })
+		userIDs = append(userIDs, opUserID)
+		userMap, err = g.getUsersInfoMap(ctx, userIDs)
+		if err != nil {
+			return nil, err
+		}
+		if users != nil {
+			*users = userMap
+		}
+	} else {
+		userMap = *users
+	}
+	var (
+		opUserMember     *sdkws.GroupMemberFullInfo
+		groupOwnerMember *sdkws.GroupMemberFullInfo
+	)
+	for _, member := range members {
+		if member.UserID == opUserID {
+			opUserMember = g.groupMemberDB2PB(member, userMap[member.UserID].AppMangerLevel)
+		}
+		if member.RoleLevel == constant.GroupOwner {
+			groupOwnerMember = g.groupMemberDB2PB(member, userMap[member.UserID].AppMangerLevel)
+		}
+		if opUserMember != nil && groupOwnerMember != nil {
+			break
+		}
+	}
+	if opUser := userMap[opUserID]; opUser != nil && opUserMember == nil {
+		opUserMember = &sdkws.GroupMemberFullInfo{
+			GroupID:        group.GroupID,
+			UserID:         opUser.UserID,
+			Nickname:       opUser.Nickname,
+			FaceURL:        opUser.FaceURL,
+			AppMangerLevel: opUser.AppMangerLevel,
+		}
+	}
+	groupInfo = &sdkws.GroupCreatedTips{Group: g.groupDB2PB(group, groupOwnerMember.UserID, uint32(len(members))),
+		OpUser: opUserMember, GroupOwnerUser: groupOwnerMember}
+	return groupInfo, nil
+}
+
+func (g *GroupNotificationSender) GroupInfoSetNotification(ctx context.Context, group *relation.GroupModel, members []*relation.GroupMemberModel, needVerification *int32) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	groupInfo, err := g.mergeGroupFull(ctx, group.GroupID, group, &members, nil)
+	if err != nil {
+		return err
+	}
+	groupInfoChangedTips := &sdkws.GroupInfoSetTips{Group: groupInfo.Group, OpUser: groupInfo.GroupOwnerUser}
+	if needVerification != nil {
+		groupInfoChangedTips.Group.NeedVerification = *needVerification
+	}
+	return g.groupNotification(ctx, constant.GroupInfoSetNotification, groupInfoChangedTips, mcontext.GetOpUserID(ctx), group.GroupID, "")
+}
+
+func (g *GroupNotificationSender) JoinGroupApplicationNotification(ctx context.Context, req *pbGroup.JoinGroupReq) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getUser(ctx, req.InviterUserID)
+	if err != nil {
+		return err
+	}
+	userIDs, err := g.getGroupOwnerAndAdminUserID(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	joinGroupApplicationTips := &sdkws.JoinGroupApplicationTips{Group: group, Applicant: user, ReqMsg: req.ReqMessage}
+	for _, userID := range userIDs {
+		err := g.groupNotification(ctx, constant.JoinGroupApplicationNotification, joinGroupApplicationTips, mcontext.GetOpUserID(ctx), "", userID)
+		if err != nil {
+			log.ZError(ctx, "JoinGroupApplicationNotification failed", err, "group", req.GroupID, "userID", userID)
+		}
+	}
+	return nil
+}
+
+func (g *GroupNotificationSender) MemberQuitNotification(ctx context.Context, req *pbGroup.QuitGroupReq) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	// todo 退群后查不到
+	opUserID := mcontext.GetOpUserID(ctx)
+	user, err := g.getUser(ctx, opUserID)
+	if err != nil {
+		return err
+	}
+	userIDs, err := g.getGroupOwnerAndAdminUserID(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	memberQuitTips := &sdkws.MemberQuitTips{Group: group, QuitUser: &sdkws.GroupMemberFullInfo{
+		GroupID:  group.GroupID,
+		UserID:   user.UserID,
+		Nickname: user.Nickname,
+		FaceURL:  user.FaceURL,
+	}}
+	for _, userID := range append(userIDs, opUserID) {
+		err := g.groupNotification(ctx, constant.MemberQuitNotification, memberQuitTips, mcontext.GetOpUserID(ctx), "", userID)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (g *GroupNotificationSender) GroupApplicationAcceptedNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
+	if err != nil {
+		return err
+	}
+	userIDs, err := g.getGroupOwnerAndAdminUserID(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	groupApplicationAcceptedTips := &sdkws.GroupApplicationAcceptedTips{Group: group, OpUser: user, HandleMsg: req.HandledMsg, ReceiverAs: 1}
+	for _, userID := range append(userIDs, mcontext.GetOpUserID(ctx)) {
+		err = g.groupNotification(ctx, constant.GroupApplicationAcceptedNotification, groupApplicationAcceptedTips, mcontext.GetOpUserID(ctx), "", userID)
+		if err != nil {
+			log.ZError(ctx, "failed", err)
+		}
+	}
+	return nil
+}
+
+func (g *GroupNotificationSender) GroupApplicationRejectedNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
+	if err != nil {
+		return err
+	}
+	userIDs, err := g.getGroupOwnerAndAdminUserID(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	groupApplicationAcceptedTips := &sdkws.GroupApplicationRejectedTips{Group: group, OpUser: user, HandleMsg: req.HandledMsg}
+	for _, userID := range append(userIDs, mcontext.GetOpUserID(ctx)) {
+		err = g.groupNotification(ctx, constant.GroupApplicationRejectedNotification, groupApplicationAcceptedTips, mcontext.GetOpUserID(ctx), "", userID)
+		if err != nil {
+			log.ZError(ctx, "failed", err)
+		}
+	}
+	return nil
+}
+
+func (g *GroupNotificationSender) GroupOwnerTransferredNotification(ctx context.Context, req *pbGroup.TransferGroupOwnerReq) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	opUserID := mcontext.GetOpUserID(ctx)
+	member, err := g.getGroupMemberMap(ctx, req.GroupID, []string{opUserID, req.NewOwnerUserID})
+	if err != nil {
+		return err
+	}
+	groupOwnerTransferredTips := &sdkws.GroupOwnerTransferredTips{Group: group, OpUser: member[opUserID], NewGroupOwner: member[req.NewOwnerUserID]}
+	return g.groupNotification(ctx, constant.GroupOwnerTransferredNotification, groupOwnerTransferredTips, mcontext.GetOpUserID(ctx), req.GroupID, "")
+}
+
+func (g *GroupNotificationSender) MemberKickedNotification(ctx context.Context, req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
+	if err != nil {
+		return err
+	}
+	memberKickedTips := &sdkws.MemberKickedTips{Group: group, OpUser: user}
+	//for _, v := range kickedUserIDList {
+	//	var groupMemberInfo sdkws.GroupMemberFullInfo
+	//	if err := c.setGroupMemberInfo(ctx, req.GroupID, v, &groupMemberInfo); err != nil {
+	//		continue
+	//	}
+	//	MemberKickedTips.KickedUserList = append(MemberKickedTips.KickedUserList, &groupMemberInfo)
+	//}
+	return g.groupNotification(ctx, constant.MemberKickedNotification, memberKickedTips, mcontext.GetOpUserID(ctx), req.GroupID, "")
+}
+
+func (g *GroupNotificationSender) MemberInvitedNotification(ctx context.Context, groupID, reason string, invitedUserIDList []string) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, groupID)
+	if err != nil {
+		return err
+	}
+	opUser, err := g.getGroupMember(ctx, groupID, mcontext.GetOpUserID(ctx))
+	if err != nil {
+		return err
+	}
+	users, err := g.getGroupMembers(ctx, groupID, invitedUserIDList)
+	if err != nil {
+		return err
+	}
+	memberInvitedTips := &sdkws.MemberInvitedTips{Group: group, OpUser: opUser, InvitedUserList: users}
+	return g.groupNotification(ctx, constant.MemberInvitedNotification, memberInvitedTips, mcontext.GetOpUserID(ctx), groupID, "")
+}
+
+func (g *GroupNotificationSender) MemberEnterNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMember(ctx, req.GroupID, req.FromUserID)
+	if err != nil {
+		return err
+	}
+	memberEnterTips := sdkws.MemberEnterTips{Group: group, EntrantUser: user}
+	return g.groupNotification(ctx, constant.MemberEnterNotification, &memberEnterTips, mcontext.GetOpUserID(ctx), req.GroupID, "")
+}
+
+func (g *GroupNotificationSender) groupMemberFullInfo(members []*relation.GroupMemberModel, userMap map[string]*sdkws.UserInfo, userID string) *sdkws.GroupMemberFullInfo {
+	for _, member := range members {
+		if member.UserID == userID {
+			if user := userMap[member.UserID]; user != nil {
+				return g.groupMemberDB2PB(member, user.AppMangerLevel)
+			}
+			return g.groupMemberDB2PB(member, 0)
+		}
+	}
+	return nil
+}
+
+func (g *GroupNotificationSender) GroupDismissedNotification(ctx context.Context, req *pbGroup.DismissGroupReq) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, req.GroupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
+	if err != nil {
+		return err
+	}
+	tips := &sdkws.GroupDismissedTips{Group: group, OpUser: user}
+	return g.groupNotification(ctx, constant.GroupDismissedNotification, tips, mcontext.GetOpUserID(ctx), req.GroupID, "")
+}
+
+func (g *GroupNotificationSender) GroupMemberMutedNotification(ctx context.Context, groupID, groupMemberUserID string, mutedSeconds uint32) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, groupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMemberMap(ctx, groupID, []string{mcontext.GetOpUserID(ctx), groupMemberUserID})
+	if err != nil {
+		return err
+	}
+	tips := sdkws.GroupMemberMutedTips{Group: group, MutedSeconds: mutedSeconds,
+		OpUser: user[mcontext.GetOpUserID(ctx)], MutedUser: user[groupMemberUserID]}
+	return g.groupNotification(ctx, constant.GroupMemberMutedNotification, &tips, mcontext.GetOpUserID(ctx), groupID, "")
+}
+
+func (g *GroupNotificationSender) GroupMemberCancelMutedNotification(ctx context.Context, groupID, groupMemberUserID string) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, groupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMemberMap(ctx, groupID, []string{mcontext.GetOpUserID(ctx), groupMemberUserID})
+	if err != nil {
+		return err
+	}
+	tips := sdkws.GroupMemberCancelMutedTips{Group: group, OpUser: user[mcontext.GetOpUserID(ctx)], MutedUser: user[groupMemberUserID]}
+	return g.groupNotification(ctx, constant.GroupMemberCancelMutedNotification, &tips, mcontext.GetOpUserID(ctx), groupID, "")
+}
+
+func (g *GroupNotificationSender) GroupMutedNotification(ctx context.Context, groupID string) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, groupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMember(ctx, groupID, mcontext.GetOpUserID(ctx))
+	if err != nil {
+		return err
+	}
+	tips := sdkws.GroupMutedTips{Group: group, OpUser: user}
+	return g.groupNotification(ctx, constant.GroupMutedNotification, &tips, mcontext.GetOpUserID(ctx), groupID, "")
+}
+
+func (g *GroupNotificationSender) GroupCancelMutedNotification(ctx context.Context, groupID string) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, groupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMember(ctx, groupID, mcontext.GetOpUserID(ctx))
+	if err != nil {
+		return err
+	}
+	tips := sdkws.GroupCancelMutedTips{Group: group, OpUser: user}
+	return g.groupNotification(ctx, constant.GroupMutedNotification, &tips, mcontext.GetOpUserID(ctx), groupID, "")
+}
+
+func (g *GroupNotificationSender) GroupMemberInfoSetNotification(ctx context.Context, groupID, groupMemberUserID string) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, groupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMemberMap(ctx, groupID, []string{mcontext.GetOpUserID(ctx), groupMemberUserID})
+	if err != nil {
+		return err
+	}
+	tips := sdkws.GroupMemberInfoSetTips{Group: group, OpUser: user[mcontext.GetOpUserID(ctx)], ChangedUser: user[groupMemberUserID]}
+	return g.groupNotification(ctx, constant.GroupMemberCancelMutedNotification, &tips, mcontext.GetOpUserID(ctx), groupID, "")
+}
+
+func (g *GroupNotificationSender) GroupMemberSetToAdminNotification(ctx context.Context, groupID, groupMemberUserID string, notificationType int32) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, groupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMemberMap(ctx, groupID, []string{mcontext.GetOpUserID(ctx), groupMemberUserID})
+	if err != nil {
+		return err
+	}
+	tips := sdkws.GroupMemberInfoSetTips{Group: group, OpUser: user[mcontext.GetOpUserID(ctx)], ChangedUser: user[groupMemberUserID]}
+	return g.groupNotification(ctx, constant.GroupMemberCancelMutedNotification, &tips, mcontext.GetOpUserID(ctx), groupID, "")
+}
+
+func (g *GroupNotificationSender) MemberEnterDirectlyNotification(ctx context.Context, groupID string, entrantUserID string) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	group, err := g.getGroupInfo(ctx, groupID)
+	if err != nil {
+		return err
+	}
+	user, err := g.getGroupMember(ctx, groupID, entrantUserID)
+	if err != nil {
+		return err
+	}
+	tips := sdkws.MemberEnterTips{Group: group, EntrantUser: user}
+	return g.groupNotification(ctx, constant.GroupMemberCancelMutedNotification, &tips, mcontext.GetOpUserID(ctx), groupID, "")
+}
+
+func (g *GroupNotificationSender) SuperGroupNotification(ctx context.Context, sendID, recvID string) (err error) {
+	defer log.ZDebug(ctx, "return")
+	defer func() {
+		if err != nil {
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
+		}
+	}()
+	req := &msg.SendMsgReq{
+		MsgData: &sdkws.MsgData{
+			SendID:         sendID,
+			RecvID:         recvID,
+			Content:        nil,
+			MsgFrom:        constant.SysMsgType,
+			ContentType:    constant.SuperGroupUpdateNotification,
+			SessionType:    constant.SingleChatType,
+			CreateTime:     time.Now().UnixMilli(),
+			ClientMsgID:    utils.GetMsgID(sendID),
+			SenderNickname: "",
+			SenderFaceURL:  "",
+			OfflinePushInfo: &sdkws.OfflinePushInfo{
+				Title: "",
+				Desc:  "",
+				Ex:    "",
+			},
+		},
+	}
+	_, err = g.msgClient.SendMsg(ctx, req)
+	return err
+}