Merge branch 'errcode' of github.com:OpenIMSDK/Open-IM-Server into errcode

pkg/rpcclient/notification2/group.go

@@ -2,6 +2,8 @@ package notification2
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"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"
@@ -10,11 +12,12 @@ import (
 	"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/jsonpb"
 	"github.com/golang/protobuf/proto"
+	"time"
 )
 
 func NewGroupNotificationSender(db controller.GroupDatabase, sdr discoveryregistry.SvcDiscoveryRegistry, fn func(ctx context.Context, userIDs []string) ([]rpcclient.CommonUser, error)) *GroupNotificationSender {
@@ -26,26 +29,52 @@ func NewGroupNotificationSender(db controller.GroupDatabase, sdr discoveryregist
 }
 
 type GroupNotificationSender struct {
-	msgClient *rpcclient.MsgClient
-	// 找不到报错
+	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:            gm.OwnerUserID,
-		CreateTime: gm.CreateTime.UnixMilli(),
-		//MemberCount:            gm.MemberCount,
+		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,
@@ -58,6 +87,76 @@ func (g *GroupNotificationSender) getGroupInfo(ctx context.Context, groupID stri
 	}, 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,
@@ -118,83 +217,26 @@ func (g *GroupNotificationSender) getFromToUserNickname(ctx context.Context, fro
 }
 
 func (g *GroupNotificationSender) groupNotification(ctx context.Context, contentType int32, m proto.Message, sendID, groupID, recvUserID string) (err error) {
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
+	content, err := json.Marshal(m)
 	if err != nil {
 		return err
 	}
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
+	notificationMsg := rpcclient.NotificationMsg{
+		SendID:      sendID,
+		RecvID:      recvUserID,
+		ContentType: contentType,
+		SessionType: constant.GroupChatType,
+		MsgFrom:     constant.SysMsgType,
+		Content:     content,
 	}
-	tips.JsonDetail, err = marshaler.MarshalToString(m)
-	if err != nil {
-		return err
-	}
-	fromUserNickname, toUserNickname, err := g.getFromToUserNickname(ctx, sendID, recvUserID)
-	if err != nil {
-		return err
-	}
-	//cn := config.Config.Notification
-	switch contentType {
-	case constant.GroupCreatedNotification:
-		tips.DefaultTips = fromUserNickname
-	case constant.GroupInfoSetNotification:
-		tips.DefaultTips = fromUserNickname
-	case constant.JoinGroupApplicationNotification:
-		tips.DefaultTips = fromUserNickname
-	case constant.MemberQuitNotification:
-		tips.DefaultTips = fromUserNickname
-	case constant.GroupApplicationAcceptedNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.GroupApplicationRejectedNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.GroupOwnerTransferredNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.MemberKickedNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.MemberInvitedNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.MemberEnterNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.GroupDismissedNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.GroupMutedNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.GroupCancelMutedNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.GroupMemberMutedNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.GroupMemberCancelMutedNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.GroupMemberInfoSetNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.GroupMemberSetToAdminNotification:
-		tips.DefaultTips = toUserNickname
-	case constant.GroupMemberSetToOrdinaryUserNotification:
-		tips.DefaultTips = toUserNickname
-	default:
-		return errs.ErrInternalServer.Wrap("unknown group notification type")
-	}
-	var n rpcclient.NotificationMsg
-	n.SendID = sendID
-	n.RecvID = recvUserID
-	n.ContentType = contentType
-	n.SessionType = constant.SingleChatType
-	n.MsgFrom = constant.SysMsgType
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		return
-	}
-	return g.msgClient.Notification(ctx, &n)
+	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, "GroupCreatedNotification failed", err)
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
 		}
 	}()
 	groupInfo, err := g.mergeGroupFull(ctx, group.GroupID, group, &members, &userMap)
@@ -208,7 +250,7 @@ func (g *GroupNotificationSender) mergeGroupFull(ctx context.Context, groupID st
 	defer log.ZDebug(ctx, "return")
 	defer func() {
 		if err != nil {
-			log.ZError(ctx, "mergeGroupFull failed", err)
+			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
 		}
 	}()
 	if group == nil {
@@ -268,12 +310,18 @@ func (g *GroupNotificationSender) mergeGroupFull(ctx context.Context, groupID st
 			AppMangerLevel: opUser.AppMangerLevel,
 		}
 	}
-	groupInfo = &sdkws.GroupCreatedTips{Group: g.groupDB2PB(group, opUserID, uint32(len(members))),
+	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) error {
+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
@@ -285,145 +333,165 @@ func (g *GroupNotificationSender) GroupInfoSetNotification(ctx context.Context,
 	return g.groupNotification(ctx, constant.GroupInfoSetNotification, groupInfoChangedTips, mcontext.GetOpUserID(ctx), group.GroupID, "")
 }
 
-//func (g *GroupNotificationSender) mergeGroupAndUser(ctx context.Context, groupID string, userIDs []string) (*sdkws.GroupInfo, map[string]*sdkws.UserInfo, error) {
-//	//g.groupDB2PB(group, opUserID, uint32(len(members))
-//	groupInfo, err := g.db.TakeGroup(ctx, groupID)
-//	if err != nil {
-//		return nil, nil, err
-//	}
-//	owner, err := g.db.TakeGroupOwner(ctx, groupID)
-//	if err != nil {
-//		return nil, nil, err
-//	}
-//	memberUserIDs, err := g.db.FindGroupMemberUserID(ctx, groupID)
-//	if err != nil {
-//		return nil, nil, err
-//	}
-//	g.getUsersInfoMap(ctx, memberUserIDs)
-//	return nil, nil, nil
-//}
-
-func (g *GroupNotificationSender) JoinGroupApplicationNotification(ctx context.Context, req *pbGroup.JoinGroupReq) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, req.GroupID, nil, &members, &userMap)
+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
 	}
-	joinGroupApplicationTips := &sdkws.JoinGroupApplicationTips{Group: groupInfo.Group}
-	for _, member := range members {
-		if member.UserID == req.InviterUserID {
-			if user := userMap[member.UserID]; user != nil {
-				joinGroupApplicationTips.Applicant = &sdkws.PublicUserInfo{
-					UserID:   user.UserID,
-					Nickname: user.Nickname,
-					FaceURL:  user.FaceURL,
-					Ex:       user.Ex,
-				}
-			}
-			break
-		}
+	user, err := g.getUser(ctx, req.InviterUserID)
+	if err != nil {
+		return err
 	}
-	joinGroupApplicationTips.ReqMsg = req.ReqMessage
-	for _, member := range members {
-		if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin {
-			err := g.groupNotification(ctx, constant.JoinGroupApplicationNotification, joinGroupApplicationTips, mcontext.GetOpUserID(ctx), "", member.UserID)
-			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) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, req.GroupID, nil, &members, &userMap)
+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)
-	memberQuitTips := &sdkws.MemberQuitTips{Group: groupInfo.Group, QuitUser: &sdkws.GroupMemberFullInfo{}}
-	for _, member := range members {
-		if member.UserID == opUserID {
-			if user := userMap[member.UserID]; user != nil {
-				memberQuitTips.QuitUser = g.groupMemberDB2PB(member, user.AppMangerLevel)
-			}
-			break
-		}
-	}
-	for _, member := range members {
-		if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin {
-			err := g.groupNotification(ctx, constant.JoinGroupApplicationNotification, memberQuitTips, mcontext.GetOpUserID(ctx), "", member.UserID)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func (g *GroupNotificationSender) GroupApplicationAcceptedNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) error {
-	var members []*relation.GroupMemberModel
-	groupInfo, err := g.mergeGroupFull(ctx, req.GroupID, nil, &members, nil)
+	member, err := g.getGroupMemberMap(ctx, req.GroupID, []string{opUserID, req.NewOwnerUserID})
 	if err != nil {
 		return err
 	}
-	groupApplicationAcceptedTips := &sdkws.GroupApplicationAcceptedTips{Group: groupInfo.Group, OpUser: groupInfo.OpUser, HandleMsg: req.HandledMsg}
-	err = g.groupNotification(ctx, constant.GroupApplicationAcceptedNotification, groupApplicationAcceptedTips, mcontext.GetOpUserID(ctx), "", req.FromUserID)
-	if err != nil {
-		log.ZError(ctx, "groupNotification failed", err)
-	}
-	groupApplicationAcceptedTips.ReceiverAs = 1
-	for _, member := range members {
-		if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin {
-			err = g.groupNotification(ctx, constant.GroupApplicationAcceptedNotification, groupApplicationAcceptedTips, mcontext.GetOpUserID(ctx), "", req.FromUserID)
-			if err != nil {
-				log.ZError(ctx, "groupNotification failed", err)
-			}
-		}
-	}
-	return nil
-}
-
-func (g *GroupNotificationSender) GroupApplicationRejectedNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) error {
-	var members []*relation.GroupMemberModel
-	groupInfo, err := g.mergeGroupFull(ctx, req.GroupID, nil, &members, nil)
-	if err != nil {
-		return err
-	}
-	groupApplicationRejectedTips := sdkws.GroupApplicationRejectedTips{Group: groupInfo.Group, OpUser: groupInfo.OpUser, HandleMsg: req.HandledMsg}
-	if err := g.groupNotification(ctx, constant.GroupApplicationRejectedNotification, &groupApplicationRejectedTips, mcontext.GetOpUserID(ctx), "", req.FromUserID); err != nil {
-		log.ZError(ctx, "groupNotification failed", err)
-	}
-	for _, member := range members {
-		if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin {
-			if err := g.groupNotification(ctx, constant.GroupApplicationRejectedNotification, &groupApplicationRejectedTips, mcontext.GetOpUserID(ctx), "", req.FromUserID); err != nil {
-				log.ZError(ctx, "groupNotification failed", err)
-			}
-		}
-	}
-	return nil
-}
-
-func (g *GroupNotificationSender) GroupOwnerTransferredNotification(ctx context.Context, req *pbGroup.TransferGroupOwnerReq) error {
-	var members []*relation.GroupMemberModel
-	groupInfo, err := g.mergeGroupFull(ctx, req.GroupID, nil, &members, nil)
-	if err != nil {
-		return err
-	}
-	groupOwnerTransferredTips := &sdkws.GroupOwnerTransferredTips{Group: groupInfo.Group, OpUser: groupInfo.OpUser, NewGroupOwner: groupInfo.GroupOwnerUser}
+	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) error {
-	var members []*relation.GroupMemberModel
-	groupInfo, err := g.mergeGroupFull(ctx, req.GroupID, nil, &members, nil)
+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
 	}
-	memberKickedTips := &sdkws.MemberKickedTips{Group: groupInfo.Group, OpUser: groupInfo.OpUser}
+	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 {
@@ -434,45 +502,46 @@ func (g *GroupNotificationSender) MemberKickedNotification(ctx context.Context,
 	return g.groupNotification(ctx, constant.MemberKickedNotification, memberKickedTips, mcontext.GetOpUserID(ctx), req.GroupID, "")
 }
 
-func (g *GroupNotificationSender) MemberInvitedNotification(ctx context.Context, groupID, reason string, invitedUserIDList []string) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, groupID, nil, &members, &userMap)
-	if err != nil {
-		return err
-	}
-	memberInvitedTips := &sdkws.MemberInvitedTips{Group: groupInfo.Group, OpUser: groupInfo.OpUser}
-	groupMembers, err := g.db.FindGroupMember(ctx, []string{groupID}, invitedUserIDList, nil)
-	if err != nil {
-		return err
-	}
-	for _, member := range groupMembers {
-		user, ok := userMap[member.UserID]
-		if !ok {
-			continue
+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)
 		}
-		memberInvitedTips.InvitedUserList = append(memberInvitedTips.InvitedUserList, g.groupMemberDB2PB(member, user.AppMangerLevel))
+	}()
+	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) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, req.GroupID, nil, &members, &userMap)
+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
 	}
-	MemberEnterTips := sdkws.MemberEnterTips{Group: groupInfo.Group}
-	for _, member := range members {
-		if member.UserID == req.FromUserID {
-			if user := userMap[member.UserID]; user != nil {
-				MemberEnterTips.EntrantUser = g.groupMemberDB2PB(member, user.AppMangerLevel)
-			}
-			break
-		}
+	user, err := g.getGroupMember(ctx, req.GroupID, req.FromUserID)
+	if err != nil {
+		return err
 	}
-	return g.groupNotification(ctx, constant.MemberEnterNotification, &MemberEnterTips, mcontext.GetOpUserID(ctx), req.GroupID, "")
+	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 {
@@ -487,119 +556,185 @@ func (g *GroupNotificationSender) groupMemberFullInfo(members []*relation.GroupM
 	return nil
 }
 
-func (g *GroupNotificationSender) GroupDismissedNotification(ctx context.Context, req *pbGroup.DismissGroupReq) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, req.GroupID, nil, &members, &userMap)
+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
 	}
-	tips := &sdkws.GroupDismissedTips{Group: groupInfo.Group, OpUser: groupInfo.OpUser}
+	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) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, groupID, nil, &members, &userMap)
+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
 	}
-	tips := sdkws.GroupMemberMutedTips{Group: groupInfo.Group, MutedSeconds: mutedSeconds,
-		OpUser: groupInfo.OpUser, MutedUser: g.groupMemberFullInfo(members, userMap, groupMemberUserID)}
-	tips.MutedSeconds = mutedSeconds
+	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) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, groupID, nil, &members, &userMap)
+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
 	}
-	tips := sdkws.GroupMemberCancelMutedTips{Group: groupInfo.Group,
-		OpUser: groupInfo.OpUser, MutedUser: g.groupMemberFullInfo(members, userMap, groupMemberUserID)}
+	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) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, groupID, nil, &members, &userMap)
+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
 	}
-	tips := sdkws.GroupMutedTips{Group: groupInfo.Group, OpUser: groupInfo.OpUser}
+	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) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, groupID, nil, &members, &userMap)
+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
 	}
-	tips := sdkws.GroupCancelMutedTips{Group: groupInfo.Group, OpUser: groupInfo.OpUser}
+	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) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, groupID, nil, &members, &userMap)
+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
 	}
-	tips := sdkws.GroupMemberInfoSetTips{Group: groupInfo.Group,
-		OpUser: groupInfo.OpUser, ChangedUser: g.groupMemberFullInfo(members, userMap, groupMemberUserID)}
-	return g.groupNotification(ctx, constant.GroupMemberCancelMutedNotification, &tips, mcontext.GetOpUserID(ctx), groupID, "")
-}
-
-func (g *GroupNotificationSender) GroupMemberSetToAdminNotification(ctx context.Context, groupID, groupMemberUserID string, notificationType int32) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, groupID, nil, &members, &userMap)
+	user, err := g.getGroupMemberMap(ctx, groupID, []string{mcontext.GetOpUserID(ctx), groupMemberUserID})
 	if err != nil {
 		return err
 	}
-	tips := sdkws.GroupMemberInfoSetTips{Group: groupInfo.Group,
-		OpUser: groupInfo.OpUser, ChangedUser: g.groupMemberFullInfo(members, userMap, groupMemberUserID)}
+	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) error {
-	var members []*relation.GroupMemberModel
-	var userMap map[string]*sdkws.UserInfo
-	groupInfo, err := g.mergeGroupFull(ctx, groupID, nil, &members, &userMap)
+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
 	}
-	tips := sdkws.MemberEnterTips{Group: groupInfo.Group, EntrantUser: g.groupMemberFullInfo(members, userMap, entrantUserID)}
+	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, "")
 }
 
-type NotificationMsg struct {
-	SendID         string
-	RecvID         string
-	Content        []byte //  sdkws.TipsComm
-	MsgFrom        int32
-	ContentType    int32
-	SessionType    int32
-	SenderNickname string
-	SenderFaceURL  string
+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) error {
-	n := &NotificationMsg{
-		SendID:      sendID,
-		RecvID:      recvID,
-		MsgFrom:     constant.SysMsgType,
-		ContentType: constant.SuperGroupUpdateNotification,
-		SessionType: constant.SingleChatType,
+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:    "",
+			},
+		},
 	}
-	_ = n // todo
-	//g.Notification(ctx, n)
-	return nil
+	_, err = g.msgClient.SendMsg(ctx, req)
+	return err
 }