Error code standardization

internal/common/notification/c.go

@@ -1,6 +1,7 @@
 package notification
 
 import (
+	"Open_IM/internal/common/check"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/proto/msg"
@@ -9,6 +10,11 @@ import (
 	utils "github.com/OpenIMSDK/open_utils"
 )
 
+type Check struct {
+	user  *check.UserCheck
+	group *check.GroupChecker
+}
+
 type NotificationMsg struct {
 	SendID         string
 	RecvID         string
@@ -21,7 +27,7 @@ type NotificationMsg struct {
 	SenderFaceURL  string
 }
 
-func Notification(n *NotificationMsg) {
+func (c *Check) Notification(n *NotificationMsg) {
 	var req msg.SendMsgReq
 	var msg sdkws.MsgData
 	var offlineInfo sdkws.OfflinePushInfo

internal/common/notification/conversation.go

@@ -4,6 +4,7 @@ import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/tracelog"
 	sdkws "Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
@@ -11,7 +12,7 @@ import (
 	"github.com/golang/protobuf/proto"
 )
 
-func SetConversationNotification(operationID, sendID, recvID string, contentType int, m proto.Message, tips sdkws.TipsComm) {
+func (c *Check) SetConversationNotification(operationID, sendID, recvID string, contentType int, m proto.Message, tips sdkws.TipsComm) {
 	log.NewInfo(operationID, "args: ", sendID, recvID, contentType, m.String(), tips.String())
 	var err error
 	tips.Detail, err = proto.Marshal(m)
@@ -37,12 +38,12 @@ func SetConversationNotification(operationID, sendID, recvID string, contentType
 		log.Error(operationID, utils.GetSelfFuncName(), "Marshal failed ", err.Error(), tips.String())
 		return
 	}
-	Notification(&n)
+	c.Notification(&n)
 }
 
 // SetPrivate调用
-func ConversationSetPrivateNotification(ctx context.Context, sendID, recvID string, isPrivateChat bool) {
+func (c *Check) ConversationSetPrivateNotification(ctx context.Context, sendID, recvID string, isPrivateChat bool) {
-	log.NewInfo(operationID, utils.GetSelfFuncName())
+
 	conversationSetPrivateTips := &sdkws.ConversationSetPrivateTips{
 		RecvID:    recvID,
 		SendID:    sendID,
@@ -56,23 +57,23 @@ func ConversationSetPrivateNotification(ctx context.Context, sendID, recvID stri
 		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.CloseTips
 	}
 	tips.DefaultTips = tipsMsg
-	SetConversationNotification(operationID, sendID, recvID, constant.ConversationPrivateChatNotification, conversationSetPrivateTips, tips)
+	c.SetConversationNotification(tracelog.GetOperationID(ctx), sendID, recvID, constant.ConversationPrivateChatNotification, conversationSetPrivateTips, tips)
 }
 
 // 会话改变
-func ConversationChangeNotification(ctx context.Context, userID string) {
+func (c *Check) ConversationChangeNotification(ctx context.Context, userID string) {
-	log.NewInfo(operationID, utils.GetSelfFuncName())
+
 	ConversationChangedTips := &sdkws.ConversationUpdateTips{
 		UserID: userID,
 	}
 	var tips sdkws.TipsComm
 	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
-	SetConversationNotification(operationID, userID, userID, constant.ConversationOptChangeNotification, ConversationChangedTips, tips)
+	c.SetConversationNotification(tracelog.GetOperationID(ctx), userID, userID, constant.ConversationOptChangeNotification, ConversationChangedTips, tips)
 }
 
 // 会话未读数同步
-func ConversationUnreadChangeNotification(context context.Context, userID, conversationID string, updateUnreadCountTime int64) {
+func (c *Check) ConversationUnreadChangeNotification(context context.Context, userID, conversationID string, updateUnreadCountTime int64) {
-	log.NewInfo(operationID, utils.GetSelfFuncName())
+
 	ConversationChangedTips := &sdkws.ConversationUpdateTips{
 		UserID:                userID,
 		ConversationIDList:    []string{conversationID},
@@ -80,5 +81,5 @@ func ConversationUnreadChangeNotification(context context.Context, userID, conve
 	}
 	var tips sdkws.TipsComm
 	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
-	SetConversationNotification(operationID, userID, userID, constant.ConversationUnreadNotification, ConversationChangedTips, tips)
+	c.SetConversationNotification(tracelog.GetOperationID(ctx), userID, userID, constant.ConversationUnreadNotification, ConversationChangedTips, tips)
 }

internal/common/notification/friend.go

@@ -14,8 +14,8 @@ import (
 	"github.com/golang/protobuf/proto"
 )
 
-func getFromToUserNickname(fromUserID, toUserID string) (string, string, error) {
+func getFromToUserNickname(userCheck *check.UserCheck, fromUserID, toUserID string) (string, string, error) {
-	users, err := check.NewUserCheck().GetUsersInfoMap(context.Background(), []string{fromUserID, toUserID}, true)
+	users, err := userCheck.GetUsersInfoMap(context.Background(), []string{fromUserID, toUserID}, true)
 	if err != nil {
 		return "", "", nil
 	}
@@ -87,14 +87,14 @@ func friendNotification(operationID, fromUserID, toUserID string, contentType in
 	Notification(&n)
 }
 
-func FriendApplicationAddNotification(ctx context.Context, req *pbFriend.ApplyToAddFriendReq) {
+func (c *Check) FriendApplicationAddNotification(ctx context.Context, req *pbFriend.ApplyToAddFriendReq) {
 	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) {
+func (c *Check) FriendApplicationAgreedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
 	FriendApplicationApprovedTips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{}}
 	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID
 	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID
@@ -102,7 +102,7 @@ func FriendApplicationAgreedNotification(ctx context.Context, req *pbFriend.Resp
 	friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
 }
 
-func FriendApplicationRefusedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
+func (c *Check) FriendApplicationRefusedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
 	FriendApplicationApprovedTips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{}}
 	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID
 	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID
@@ -110,7 +110,7 @@ func FriendApplicationRefusedNotification(ctx context.Context, req *pbFriend.Res
 	friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
 }
 
-func FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) {
+func (c *Check) FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) {
 	friendAddedTips := sdkws.FriendAddedTips{Friend: &sdkws.FriendInfo{}, OpUser: &sdkws.PublicUserInfo{}}
 	user, err := check.NewUserCheck().GetUsersInfos(context.Background(), []string{opUserID}, true)
 	if err != nil {
@@ -129,28 +129,28 @@ func FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUse
 	friendNotification(operationID, fromUserID, toUserID, constant.FriendAddedNotification, &friendAddedTips)
 }
 
-func FriendDeletedNotification(ctx context.Context, req *pbFriend.DeleteFriendReq) {
+func (c *Check) 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) {
+func (c *Check) 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) {
+func (c *Check) 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) {
+func (c *Check) BlackDeletedNotification(ctx context.Context, req *pbFriend.RemoveBlackReq) {
 	blackDeletedTips := sdkws.BlackDeletedTips{FromToUserID: &sdkws.FromToUserID{}}
 	blackDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
 	blackDeletedTips.FromToUserID.ToUserID = req.BlackUserID
@@ -158,12 +158,12 @@ func BlackDeletedNotification(ctx context.Context, req *pbFriend.RemoveBlackReq)
 }
 
 // send to myself
-func UserInfoUpdatedNotification(ctx context.Context, opUserID string, changedUserID string) {
+func (c *Check) 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) {
+func (c *Check) FriendInfoUpdatedNotification(ctx context.Context, changedUserID string, needNotifiedUserID string, opUserID string) {
 	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
 	friendNotification(tracelog.GetOperationID(ctx), opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
 }

internal/common/notification/group.go

@@ -14,77 +14,78 @@ import (
 	"google.golang.org/protobuf/types/known/wrapperspb"
 )
 
-func setOpUserInfo(opUserID, groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
+func (c *Check) setOpUserInfo(opUserID, groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
 	if tokenverify.IsManagerUserID(opUserID) {
-		u, err := imdb.GetUserByUserID(opUserID)
+		user, err := c.user.GetUsersInfos(context.Background(), []string{opUserID}, true)
 		if err != nil {
-			return utils.Wrap(err, "GetUserByUserID failed")
+			return err
 		}
-		utils.CopyStructFields(groupMemberInfo, u)
 		groupMemberInfo.GroupID = groupID
-	} else {
+		groupMemberInfo.UserID = user[0].UserID
-		u, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, opUserID)
+		groupMemberInfo.Nickname = user[0].Nickname
-		if err == nil {
+		groupMemberInfo.AppMangerLevel = user[0].AppMangerLevel
-			if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, u); err != nil {
+		groupMemberInfo.FaceURL = user[0].FaceURL
-				return utils.Wrap(err, "")
+		return nil
-			}
-		}
-		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
 	}
+	u, err := c.group.GetGroupMemberInfo(context.Background(), groupID, opUserID)
+	if err == nil {
+		*groupMemberInfo = *u
+		return nil
+	}
+	user, err := c.user.GetUsersInfos(context.Background(), []string{opUserID}, true)
+	if err != nil {
+		return err
+	}
+	groupMemberInfo.GroupID = groupID
+	groupMemberInfo.UserID = user[0].UserID
+	groupMemberInfo.Nickname = user[0].Nickname
+	groupMemberInfo.AppMangerLevel = user[0].AppMangerLevel
+	groupMemberInfo.FaceURL = user[0].FaceURL
+
 	return nil
 }
 
-func setGroupInfo(groupID string, groupInfo *sdkws.GroupInfo) error {
+func (c *Check) setGroupInfo(groupID string, groupInfo *sdkws.GroupInfo) error {
-	group, err := imdb.GetGroupInfoByGroupID(groupID)
+	group, err := c.group.GetGroupInfos(context.Background(), []string{groupID}, true)
-	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 err
-		return nil
 	}
+	*groupInfo = *group[0]
 	return nil
 }
 
-func setGroupMemberInfo(groupID, userID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
+func (c *Check) setGroupMemberInfo(groupID, userID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	groupMember, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
+	groupMember, err := c.group.GetGroupMemberInfo(context.Background(), groupID, userID)
 	if err == nil {
-		return utils.Wrap(utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember), "")
+		*groupMemberInfo = *groupMember
+		return nil
 	}
-
+	user, err := c.user.GetUsersInfos(context.Background(), []string{userID}, true)
-	user, err := imdb.GetUserByUserID(userID)
 	if err != nil {
-		return utils.Wrap(err, "")
+		return err
 	}
 	groupMemberInfo.GroupID = groupID
-	groupMemberInfo.UserID = user.UserID
+	groupMemberInfo.UserID = user[0].UserID
-	groupMemberInfo.Nickname = user.Nickname
+	groupMemberInfo.Nickname = user[0].Nickname
-	groupMemberInfo.AppMangerLevel = user.AppMangerLevel
+	groupMemberInfo.AppMangerLevel = user[0].AppMangerLevel
-	groupMemberInfo.FaceURL = user.FaceURL
+	groupMemberInfo.FaceURL = user[0].FaceURL
 	return nil
 }
 
-func setGroupOwnerInfo(groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
+func (c *Check) setGroupOwnerInfo(groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	groupMember, err := imdb.GetGroupOwnerInfoByGroupID(groupID)
+	group, err := c.group.GetGroupInfo(context.Background(), groupID)
 	if err != nil {
-		return utils.Wrap(err, "")
+		return err
 	}
-	if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember); err != nil {
+	groupMember, err := c.group.GetGroupMemberInfo(context.Background(), groupID, group.OwnerUserID)
-		return utils.Wrap(err, "")
+	if err != nil {
+		return err
 	}
+	*groupMemberInfo = *groupMember
 	return nil
 }
 
-func setPublicUserInfo(userID string, publicUserInfo *sdkws.PublicUserInfo) error {
+func (c *Check) setPublicUserInfo(userID string, publicUserInfo *sdkws.PublicUserInfo) error {
 	user, err := imdb.GetUserByUserID(userID)
 	if err != nil {
 		return utils.Wrap(err, "")
@@ -93,7 +94,7 @@ func setPublicUserInfo(userID string, publicUserInfo *sdkws.PublicUserInfo) erro
 	return nil
 }
 
-func groupNotification(contentType int32, m proto.Message, sendID, groupID, recvUserID, operationID string) {
+func (c *Check) groupNotification(contentType int32, m proto.Message, sendID, groupID, recvUserID, operationID string) {
 	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType, sendID, groupID, recvUserID)
 
 	var err error
@@ -197,30 +198,30 @@ func groupNotification(contentType int32, m proto.Message, sendID, groupID, recv
 		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
 		return
 	}
-	Notification(&n)
+	c.Notification(&n)
 }
 
 // 创建群后调用
-func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberList []string) {
+func (c *Check) 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 {
+	if err := c.setOpUserInfo(opUserID, groupID, GroupCreatedTips.OpUser); err != nil {
 		log.NewError(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, GroupCreatedTips.OpUser)
 		return
 	}
-	err := setGroupInfo(groupID, GroupCreatedTips.Group)
+	err := c.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 {
+	if err := c.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 {
+		if err := c.setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
 			log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, v)
 			continue
 		}
@@ -229,7 +230,7 @@ func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberL
 			break
 		}
 	}
-	groupNotification(constant.GroupCreatedNotification, &GroupCreatedTips, opUserID, groupID, "", operationID)
+	c.groupNotification(constant.GroupCreatedNotification, &GroupCreatedTips, opUserID, groupID, "", operationID)
 }
 
 // 群信息改变后掉用
@@ -238,9 +239,9 @@ func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberL
 //	notification := ""
 //	introduction := ""
 //	faceURL := ""
-func GroupInfoSetNotification(operationID, opUserID, groupID string, groupName, notification, introduction, faceURL string, needVerification *wrapperspb.Int32Value) {
+func (c *Check) 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 {
+	if err := c.setGroupInfo(groupID, GroupInfoChangedTips.Group); err != nil {
 		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
 		return
 	}
@@ -252,116 +253,116 @@ func GroupInfoSetNotification(operationID, opUserID, groupID string, groupName,
 		GroupInfoChangedTips.Group.NeedVerification = needVerification.Value
 	}
 
-	if err := setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil {
+	if err := c.setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil {
 		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
 		return
 	}
-	groupNotification(constant.GroupInfoSetNotification, &GroupInfoChangedTips, opUserID, groupID, "", operationID)
+	c.groupNotification(constant.GroupInfoSetNotification, &GroupInfoChangedTips, opUserID, groupID, "", operationID)
 }
 
-func GroupMutedNotification(operationID, opUserID, groupID string) {
+func (c *Check) GroupMutedNotification(operationID, opUserID, groupID string) {
 	tips := sdkws.GroupMutedTips{Group: &sdkws.GroupInfo{},
 		OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
+	if err := c.setGroupInfo(groupID, tips.Group); err != nil {
 		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
 		return
 	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+	if err := c.setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
 		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
 		return
 	}
-	groupNotification(constant.GroupMutedNotification, &tips, opUserID, groupID, "", operationID)
+	c.groupNotification(constant.GroupMutedNotification, &tips, opUserID, groupID, "", operationID)
 }
 
-func GroupCancelMutedNotification(operationID, opUserID, groupID string) {
+func (c *Check) GroupCancelMutedNotification(operationID, opUserID, groupID string) {
 	tips := sdkws.GroupCancelMutedTips{Group: &sdkws.GroupInfo{},
 		OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
+	if err := c.setGroupInfo(groupID, tips.Group); err != nil {
 		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
 		return
 	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+	if err := c.setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
 		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
 		return
 	}
-	groupNotification(constant.GroupCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
+	c.groupNotification(constant.GroupCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
 }
 
-func GroupMemberMutedNotification(operationID, opUserID, groupID, groupMemberUserID string, mutedSeconds uint32) {
+func (c *Check) 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 {
+	if err := c.setGroupInfo(groupID, tips.Group); err != nil {
 		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
 		return
 	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+	if err := c.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 {
+	if err := c.setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil {
 		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
 		return
 	}
-	groupNotification(constant.GroupMemberMutedNotification, &tips, opUserID, groupID, "", operationID)
+	c.groupNotification(constant.GroupMemberMutedNotification, &tips, opUserID, groupID, "", operationID)
 }
 
-func GroupMemberInfoSetNotification(operationID, opUserID, groupID, groupMemberUserID string) {
+func (c *Check) 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 {
+	if err := c.setGroupInfo(groupID, tips.Group); err != nil {
 		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
 		return
 	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+	if err := c.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 {
+	if err := c.setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
 		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
 		return
 	}
-	groupNotification(constant.GroupMemberInfoSetNotification, &tips, opUserID, groupID, "", operationID)
+	c.groupNotification(constant.GroupMemberInfoSetNotification, &tips, opUserID, groupID, "", operationID)
 }
 
-func GroupMemberRoleLevelChangeNotification(operationID, opUserID, groupID, groupMemberUserID string, notificationType int32) {
+func (c *Check) 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 {
+	if err := c.setGroupInfo(groupID, tips.Group); err != nil {
 		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
 		return
 	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+	if err := c.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 {
+	if err := c.setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
 		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
 		return
 	}
-	groupNotification(notificationType, &tips, opUserID, groupID, "", operationID)
+	c.groupNotification(notificationType, &tips, opUserID, groupID, "", operationID)
 }
 
-func GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMemberUserID string) {
+func (c *Check) 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 {
+	if err := c.setGroupInfo(groupID, tips.Group); err != nil {
 		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
 		return
 	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+	if err := c.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 {
+	if err := c.setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil {
 		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
 		return
 	}
-	groupNotification(constant.GroupMemberCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
+	c.groupNotification(constant.GroupMemberCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
 }
 
 //	message ReceiveJoinApplicationTips{
@@ -375,14 +376,14 @@ func GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMem
 //	OperationID          string   `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"`
 //
 // 申请进群后调用
-func JoinGroupApplicationNotification(ctx context.Context, req *pbGroup.JoinGroupReq) {
+func (c *Check) JoinGroupApplicationNotification(ctx context.Context, req *pbGroup.JoinGroupReq) {
 	JoinGroupApplicationTips := sdkws.JoinGroupApplicationTips{Group: &sdkws.GroupInfo{}, Applicant: &sdkws.PublicUserInfo{}}
-	err := setGroupInfo(req.GroupID, JoinGroupApplicationTips.Group)
+	err := c.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 {
+	if err = c.setPublicUserInfo(utils.OpUserID(ctx), JoinGroupApplicationTips.Applicant); err != nil {
 		log.Error(utils.OperationID(ctx), "setPublicUserInfo failed ", err.Error(), utils.OpUserID(ctx))
 		return
 	}
@@ -394,23 +395,23 @@ func JoinGroupApplicationNotification(ctx context.Context, req *pbGroup.JoinGrou
 		return
 	}
 	for _, v := range managerList {
-		groupNotification(constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, utils.OpUserID(ctx), "", v.UserID, utils.OperationID(ctx))
+		c.groupNotification(constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, utils.OpUserID(ctx), "", v.UserID, utils.OperationID(ctx))
 		log.NewInfo(utils.OperationID(ctx), "Notification ", v)
 	}
 }
 
-func MemberQuitNotification(req *pbGroup.QuitGroupReq) {
+func (c *Check) MemberQuitNotification(req *pbGroup.QuitGroupReq) {
 	MemberQuitTips := sdkws.MemberQuitTips{Group: &sdkws.GroupInfo{}, QuitUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberQuitTips.Group); err != nil {
+	if err := c.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 {
+	if err := c.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)
+	c.groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, req.GroupID, "", req.OperationID)
 }
 
 //	message ApplicationProcessedTips{
@@ -421,18 +422,18 @@ func MemberQuitNotification(req *pbGroup.QuitGroupReq) {
 //	}
 //
 // 处理进群请求后调用
-func GroupApplicationAcceptedNotification(req *pbGroup.GroupApplicationResponseReq) {
+func (c *Check) 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 {
+	if err := c.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 {
+	if err := c.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)
+	c.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)
@@ -443,21 +444,21 @@ func GroupApplicationAcceptedNotification(req *pbGroup.GroupApplicationResponseR
 			continue
 		}
 		GroupApplicationAcceptedTips.ReceiverAs = 1
-		groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", v.UserID, req.OperationID)
+		c.groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", v.UserID, req.OperationID)
 	}
 }
 
-func GroupApplicationRejectedNotification(req *pbGroup.GroupApplicationResponseReq) {
+func (c *Check) 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 {
+	if err := c.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 {
+	if err := c.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)
+	c.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)
@@ -468,38 +469,38 @@ func GroupApplicationRejectedNotification(req *pbGroup.GroupApplicationResponseR
 			continue
 		}
 		GroupApplicationRejectedTips.ReceiverAs = 1
-		groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", v.UserID, req.OperationID)
+		c.groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", v.UserID, req.OperationID)
 	}
 }
 
-func GroupOwnerTransferredNotification(req *pbGroup.TransferGroupOwnerReq) {
+func (c *Check) 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 {
+	if err := c.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 {
+	if err := c.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 {
+	if err := c.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)
+	c.groupNotification(constant.GroupOwnerTransferredNotification, &GroupOwnerTransferredTips, req.OpUserID, req.GroupID, "", req.OperationID)
 }
 
-func GroupDismissedNotification(req *pbGroup.DismissGroupReq) {
+func (c *Check) GroupDismissedNotification(req *pbGroup.DismissGroupReq) {
 	tips := sdkws.GroupDismissedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, tips.Group); err != nil {
+	if err := c.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 {
+	if err := c.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)
+	c.groupNotification(constant.GroupDismissedNotification, &tips, req.OpUserID, req.GroupID, "", req.OperationID)
 }
 
 //	message MemberKickedTips{
@@ -510,25 +511,25 @@ func GroupDismissedNotification(req *pbGroup.DismissGroupReq) {
 //	}
 //
 // 被踢后调用
-func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
+func (c *Check) MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
 	MemberKickedTips := sdkws.MemberKickedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberKickedTips.Group); err != nil {
+	if err := c.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 {
+	if err := c.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 {
+		if err := c.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)
+	c.groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, req.GroupID, "", req.OperationID)
 	//
 	//for _, v := range kickedUserIDList {
 	//	groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, "", v, req.OperationID)
@@ -543,50 +544,50 @@ func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList
 //	}
 //
 // 被邀请进群后调用
-func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) {
+func (c *Check) 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 {
+	if err := c.setGroupInfo(groupID, MemberInvitedTips.Group); err != nil {
 		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
 		return
 	}
-	if err := setOpUserInfo(opUserID, groupID, MemberInvitedTips.OpUser); err != nil {
+	if err := c.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 {
+		if err := c.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)
+	c.groupNotification(constant.MemberInvitedNotification, &MemberInvitedTips, opUserID, groupID, "", operationID)
 }
 
 // 群成员主动申请进群，管理员同意后调用，
-func MemberEnterNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) {
+func (c *Check) 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 {
+	if err := c.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 {
+	if err := c.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)
+	c.groupNotification(constant.MemberEnterNotification, &MemberEnterTips, req.OpUserID, req.GroupID, "", req.OperationID)
 }
 
-func MemberEnterDirectlyNotification(groupID string, entrantUserID string, operationID string) {
+func (c *Check) MemberEnterDirectlyNotification(groupID string, entrantUserID string, operationID string) {
 	MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, MemberEnterTips.Group); err != nil {
+	if err := c.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 {
+	if err := c.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)
+	c.groupNotification(constant.MemberEnterNotification, &MemberEnterTips, entrantUserID, groupID, "", operationID)
 }

internal/common/notification/msg.go

@@ -3,18 +3,18 @@ package notification
 import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
-	sdkws "Open_IM/pkg/proto/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) {
+func (c *Check) DeleteMessageNotification(opUserID, userID string, seqList []uint32, operationID string) {
 	DeleteMessageTips := sdkws.DeleteMessageTips{OpUserID: opUserID, UserID: userID, SeqList: seqList}
-	MessageNotification(operationID, userID, userID, constant.DeleteMessageNotification, &DeleteMessageTips)
+	c.MessageNotification(operationID, userID, userID, constant.DeleteMessageNotification, &DeleteMessageTips)
 }
 
-func MessageNotification(operationID, sendID, recvID string, contentType int32, m proto.Message) {
+func (c *Check) 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
@@ -43,5 +43,5 @@ func MessageNotification(operationID, sendID, recvID string, contentType int32,
 		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
 		return
 	}
-	Notification(&n)
+	c.Notification(&n)
 }

internal/common/notification/super_group.go

@@ -9,7 +9,7 @@ import (
 	//"github.com/golang/protobuf/proto"
 )
 
-func SuperGroupNotification(operationID, sendID, recvID string) {
+func (c *Check) SuperGroupNotification(operationID, sendID, recvID string) {
 	n := &NotificationMsg{
 		SendID:      sendID,
 		RecvID:      recvID,
@@ -19,5 +19,5 @@ func SuperGroupNotification(operationID, sendID, recvID string) {
 		OperationID: operationID,
 	}
 	log.NewInfo(operationID, utils.GetSelfFuncName(), string(n.Content))
-	Notification(n)
+	c.Notification(n)
 }

internal/rpc/msg/server.go

@@ -27,6 +27,7 @@ type msgServer struct {
 	*rpcserver.RpcServer
 	MsgInterface controller.MsgInterface
 	Group        *check.GroupChecker
+	User         *check.UserCheck
 }
 
 type deleteMsg struct {

internal/rpc/user/user.go

@@ -23,8 +23,6 @@ import (
 )
 
 type userServer struct {
-	rpcPort         int
-	rpcRegisterName string
 	*rpcserver.RpcServer
 	controller.UserInterface
 }

pkg/common/tokenverify/jwt_token.go

@@ -87,3 +87,6 @@ func CheckAdmin(ctx context.Context) error {
 func ParseRedisInterfaceToken(redisToken interface{}) (*Claims, error) {
 	return GetClaimFromToken(string(redisToken.([]uint8)))
 }
+func IsManagerUserID(opUserID string) bool {
+	return utils.IsContain(opUserID, config.Config.Manager.AppManagerUid)
+}