notification

pkg/rpcclient/black.go

@@ -0,0 +1,30 @@
+package rpcclient
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
+)
+
+type BlackClient struct {
+	*MetaClient
+}
+
+func NewBlackClient(zk discoveryRegistry.SvcDiscoveryRegistry) *BlackClient {
+	return &BlackClient{NewMetaClient(zk, config.Config.RpcRegisterName.OpenImFriendName)}
+}
+
+// possibleBlackUserID是否被userID拉黑，也就是是否在userID的黑名单中
+func (b *BlackClient) IsBlocked(ctx context.Context, possibleBlackUserID, userID string) (bool, error) {
+	cc, err := b.getConn()
+	if err != nil {
+		return false, err
+	}
+	r, err := friend.NewFriendClient(cc).IsBlack(ctx, &friend.IsBlackReq{UserID1: possibleBlackUserID, UserID2: userID})
+	if err != nil {
+		return false, err
+	}
+	return r.InUser2Blacks, nil
+}

pkg/rpcclient/check/access.go

@@ -1,14 +0,0 @@
-package check
-
-import (
-	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-)
-
-func (u *UserCheck) Access(ctx context.Context, ownerUserID string) (err error) {
-	_, err = u.GetUserInfo(ctx, ownerUserID)
-	if err != nil {
-		return err
-	}
-	return tokenverify.CheckAccessV3(ctx, ownerUserID)
-}

pkg/rpcclient/check/black.go

@@ -1,21 +0,0 @@
-package check
-
-import (
-	"context"
-	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-)
-
-type BlackChecker struct {
-	zk discoveryRegistry.SvcDiscoveryRegistry
-}
-
-func NewBlackChecker(zk discoveryRegistry.SvcDiscoveryRegistry) *BlackChecker {
-	return &BlackChecker{
-		zk: zk,
-	}
-}
-
-// possibleBlackUserID是否被userID拉黑，也就是是否在userID的黑名单中
-func (b *BlackChecker) IsBlocked(ctx context.Context, possibleBlackUserID, userID string) (bool, error) {
-	return false, nil
-}

pkg/rpcclient/check/conversation.go

@@ -1,46 +0,0 @@
-package check
-
-import (
-	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
-	pbConversation "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
-	"google.golang.org/grpc"
-)
-
-type ConversationChecker struct {
-	zk discoveryRegistry.SvcDiscoveryRegistry
-}
-
-func NewConversationChecker(zk discoveryRegistry.SvcDiscoveryRegistry) *ConversationChecker {
-	return &ConversationChecker{zk: zk}
-}
-
-func (c *ConversationChecker) ModifyConversationField(ctx context.Context, req *pbConversation.ModifyConversationFieldReq) error {
-	cc, err := c.getConn()
-	if err != nil {
-		return err
-	}
-	_, err = conversation.NewConversationClient(cc).ModifyConversationField(ctx, req)
-	return err
-}
-
-func (c *ConversationChecker) getConn() (*grpc.ClientConn, error) {
-	return c.zk.GetConn(config.Config.RpcRegisterName.OpenImConversationName)
-}
-
-func (c *ConversationChecker) GetSingleConversationRecvMsgOpt(ctx context.Context, userID, conversationID string) (int32, error) {
-	cc, err := c.getConn()
-	if err != nil {
-		return 0, err
-	}
-	var req conversation.GetConversationReq
-	req.OwnerUserID = userID
-	req.ConversationID = conversationID
-	sConversation, err := conversation.NewConversationClient(cc).GetConversation(ctx, &req)
-	if err != nil {
-		return 0, err
-	}
-	return sConversation.GetConversation().RecvMsgOpt, err
-}

pkg/rpcclient/check/friend.go

@@ -1,63 +0,0 @@
-package check
-
-import (
-	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
-	sdkws "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-	"google.golang.org/grpc"
-)
-
-type FriendChecker struct {
-	zk discoveryRegistry.SvcDiscoveryRegistry
-}
-
-func NewFriendChecker(zk discoveryRegistry.SvcDiscoveryRegistry) *FriendChecker {
-	return &FriendChecker{
-		zk: zk,
-	}
-}
-
-func (f *FriendChecker) GetFriendsInfo(ctx context.Context, ownerUserID, friendUserID string) (resp *sdkws.FriendInfo, err error) {
-	cc, err := f.getConn()
-	if err != nil {
-		return nil, err
-	}
-	r, err := friend.NewFriendClient(cc).GetDesignatedFriends(ctx, &friend.GetDesignatedFriendsReq{OwnerUserID: ownerUserID, FriendUserIDs: []string{friendUserID}})
-	if err != nil {
-		return nil, err
-	}
-	resp = r.FriendsInfo[0]
-	return
-}
-func (f *FriendChecker) getConn() (*grpc.ClientConn, error) {
-	return f.zk.GetConn(config.Config.RpcRegisterName.OpenImFriendName)
-}
-
-// possibleFriendUserID是否在userID的好友中
-func (f *FriendChecker) IsFriend(ctx context.Context, possibleFriendUserID, userID string) (bool, error) {
-	cc, err := f.getConn()
-	if err != nil {
-		return false, err
-	}
-	resp, err := friend.NewFriendClient(cc).IsFriend(ctx, &friend.IsFriendReq{UserID1: userID, UserID2: possibleFriendUserID})
-	if err != nil {
-		return false, err
-	}
-	return resp.InUser1Friends, nil
-
-}
-
-func (f *FriendChecker) GetFriendIDs(ctx context.Context, ownerUserID string) (friendIDs []string, err error) {
-	cc, err := f.getConn()
-	if err != nil {
-		return nil, err
-	}
-	req := friend.GetFriendIDsReq{UserID: ownerUserID}
-	resp, err := friend.NewFriendClient(cc).GetFriendIDs(ctx, &req)
-	if err != nil {
-		return nil, err
-	}
-	return resp.FriendIDs, err
-}

pkg/rpcclient/check/msg.go

@@ -1,49 +0,0 @@
-package check
-
-import (
-	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-	"google.golang.org/grpc"
-)
-
-type MsgCheck struct {
-	zk discoveryRegistry.SvcDiscoveryRegistry
-}
-
-func NewMsgCheck(zk discoveryRegistry.SvcDiscoveryRegistry) *MsgCheck {
-	return &MsgCheck{zk: zk}
-}
-
-func (m *MsgCheck) getConn() (*grpc.ClientConn, error) {
-	return m.zk.GetConn(config.Config.RpcRegisterName.OpenImMsgName)
-}
-
-func (m *MsgCheck) SendMsg(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
-	cc, err := m.getConn()
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).SendMsg(ctx, req)
-	return resp, err
-}
-
-func (m *MsgCheck) GetMaxAndMinSeq(ctx context.Context, req *sdkws.GetMaxAndMinSeqReq) (*sdkws.GetMaxAndMinSeqResp, error) {
-	cc, err := m.getConn()
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).GetMaxAndMinSeq(ctx, req)
-	return resp, err
-}
-
-func (m *MsgCheck) PullMessageBySeqList(ctx context.Context, req *sdkws.PullMessageBySeqsReq) (*sdkws.PullMessageBySeqsResp, error) {
-	cc, err := m.getConn()
-	if err != nil {
-		return nil, err
-	}
-	resp, err := msg.NewMsgClient(cc).PullMessageBySeqs(ctx, req)
-	return resp, err
-}

pkg/rpcclient/check/user.go

@@ -1,114 +0,0 @@
-package check
-
-import (
-	"context"
-	"strings"
-
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/user"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
-	"google.golang.org/grpc"
-)
-
-func NewUserCheck(client discoveryregistry.SvcDiscoveryRegistry) *UserCheck {
-	return &UserCheck{
-		client: client,
-	}
-}
-
-type UserCheck struct {
-	client discoveryregistry.SvcDiscoveryRegistry
-}
-
-func (u *UserCheck) getConn() (*grpc.ClientConn, error) {
-	return u.client.GetConn(config.Config.RpcRegisterName.OpenImUserName)
-}
-
-func (u *UserCheck) GetUsersInfos(ctx context.Context, userIDs []string, complete bool) ([]*sdkws.UserInfo, error) {
-	cc, err := u.getConn()
-	if err != nil {
-		return nil, err
-	}
-	resp, err := user.NewUserClient(cc).GetDesignateUsers(ctx, &user.GetDesignateUsersReq{
-		UserIDs: userIDs,
-	})
-	if err != nil {
-		return nil, err
-	}
-	if complete {
-		if ids := utils.Single(userIDs, utils.Slice(resp.UsersInfo, func(e *sdkws.UserInfo) string {
-			return e.UserID
-		})); len(ids) > 0 {
-			return nil, errs.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-		}
-	}
-	return resp.UsersInfo, nil
-}
-
-func (u *UserCheck) GetUserInfo(ctx context.Context, userID string) (*sdkws.UserInfo, error) {
-	users, err := u.GetUsersInfos(ctx, []string{userID}, true)
-	if err != nil {
-		return nil, err
-	}
-	return users[0], nil
-}
-
-func (u *UserCheck) GetUsersInfoMap(ctx context.Context, userIDs []string, complete bool) (map[string]*sdkws.UserInfo, error) {
-	users, err := u.GetUsersInfos(ctx, userIDs, complete)
-	if err != nil {
-		return nil, err
-	}
-	return utils.SliceToMap(users, func(e *sdkws.UserInfo) string {
-		return e.UserID
-	}), nil
-}
-
-func (u *UserCheck) GetPublicUserInfos(ctx context.Context, userIDs []string, complete bool) ([]*sdkws.PublicUserInfo, error) {
-	users, err := u.GetUsersInfos(ctx, userIDs, complete)
-	if err != nil {
-		return nil, err
-	}
-	return utils.Slice(users, func(e *sdkws.UserInfo) *sdkws.PublicUserInfo {
-		return &sdkws.PublicUserInfo{
-			UserID:   e.UserID,
-			Nickname: e.Nickname,
-			FaceURL:  e.FaceURL,
-			Ex:       e.Ex,
-		}
-	}), nil
-}
-
-func (u *UserCheck) GetPublicUserInfo(ctx context.Context, userID string) (*sdkws.PublicUserInfo, error) {
-	users, err := u.GetPublicUserInfos(ctx, []string{userID}, true)
-	if err != nil {
-		return nil, err
-	}
-	return users[0], nil
-}
-
-func (u *UserCheck) GetPublicUserInfoMap(ctx context.Context, userIDs []string, complete bool) (map[string]*sdkws.PublicUserInfo, error) {
-	users, err := u.GetPublicUserInfos(ctx, userIDs, complete)
-	if err != nil {
-		return nil, err
-	}
-	return utils.SliceToMap(users, func(e *sdkws.PublicUserInfo) string {
-		return e.UserID
-	}), nil
-}
-
-func (u *UserCheck) GetUserGlobalMsgRecvOpt(ctx context.Context, userID string) (int32, error) {
-	cc, err := u.getConn()
-	if err != nil {
-		return 0, err
-	}
-	resp, err := user.NewUserClient(cc).GetGlobalRecvMessageOpt(ctx, &user.GetGlobalRecvMessageOptReq{
-		UserID: userID,
-	})
-	if err != nil {
-		return 0, err
-	}
-	return resp.GlobalRecvMsgOpt, err
-}

pkg/rpcclient/conversation.go

@@ -0,0 +1,42 @@
+package rpcclient
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
+	pbConversation "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
+)
+
+type ConversationClient struct {
+	*MetaClient
+}
+
+func NewConversationClient(zk discoveryRegistry.SvcDiscoveryRegistry) *ConversationClient {
+	return &ConversationClient{NewMetaClient(zk, config.Config.RpcRegisterName.OpenImConversationName)}
+}
+
+func (c *ConversationClient) ModifyConversationField(ctx context.Context, req *pbConversation.ModifyConversationFieldReq) error {
+	cc, err := c.getConn()
+	if err != nil {
+		return err
+	}
+	_, err = conversation.NewConversationClient(cc).ModifyConversationField(ctx, req)
+	return err
+}
+
+func (c *ConversationClient) GetSingleConversationRecvMsgOpt(ctx context.Context, userID, conversationID string) (int32, error) {
+	cc, err := c.getConn()
+	if err != nil {
+		return 0, err
+	}
+	var req conversation.GetConversationReq
+	req.OwnerUserID = userID
+	req.ConversationID = conversationID
+	conversation, err := conversation.NewConversationClient(cc).GetConversation(ctx, &req)
+	if err != nil {
+		return 0, err
+	}
+	return conversation.GetConversation().RecvMsgOpt, err
+}

pkg/rpcclient/convert/convert.go

@@ -8,172 +8,11 @@ import (
 	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	sdk "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/check"
-	utils2 "github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	utils "github.com/OpenIMSDK/open_utils"
 )
 
-type DBFriend struct {
-	*relation.FriendModel
-	userCheck *check.UserCheck
-}
-
-func NewDBFriend(friend *relation.FriendModel, zk discoveryRegistry.SvcDiscoveryRegistry) *DBFriend {
-	return &DBFriend{FriendModel: friend, userCheck: check.NewUserCheck(zk)}
-}
-
-type PBFriend struct {
-	*sdk.FriendInfo
-}
-
-func NewPBFriend(friendInfo *sdk.FriendInfo) *PBFriend {
-	return &PBFriend{FriendInfo: friendInfo}
-}
-
-func (*PBFriend) PB2DB(friends []*sdk.FriendInfo) (DBFriends []*relation.FriendModel, err error) {
-	for _, v := range friends {
-		u, err := NewPBFriend(v).Convert()
-		if err != nil {
-			return nil, err
-		}
-		DBFriends = append(DBFriends, u)
-	}
-	return
-}
-
-func (db *DBFriend) DB2PB(ctx context.Context, friends []*relation.FriendModel) (pbFriends []*sdk.FriendInfo, err error) {
-	userIDs := utils2.Slice(friends, func(e *relation.FriendModel) string { return e.FriendUserID })
-	users, err := db.userCheck.GetUsersInfoMap(ctx, userIDs, true)
-	if err != nil {
-		return nil, err
-	}
-	for _, v := range friends {
-		pbfriend := &sdk.FriendInfo{FriendUser: &sdk.UserInfo{}}
-		utils.CopyStructFields(pbfriend, users[v.OwnerUserID])
-		utils.CopyStructFields(pbfriend.FriendUser, users[v.FriendUserID])
-		pbfriend.CreateTime = v.CreateTime.Unix()
-		pbfriend.FriendUser.CreateTime = v.CreateTime.Unix()
-		pbfriend.OperatorUserID = v.OperatorUserID
-		pbfriend.OwnerUserID = v.OwnerUserID
-		pbfriend.Remark = v.Remark
-		pbfriend.AddSource = v.AddSource
-		pbfriend.Ex = v.Ex
-		pbFriends = append(pbFriends, pbfriend)
-	}
-	return
-}
-
-func (db *DBFriend) Convert(ctx context.Context) (*sdk.FriendInfo, error) {
-	pbfriend := &sdk.FriendInfo{FriendUser: &sdk.UserInfo{}}
-	utils.CopyStructFields(pbfriend, db)
-	user, err := db.userCheck.GetUserInfo(ctx, db.FriendUserID)
-	if err != nil {
-		return nil, err
-	}
-	utils.CopyStructFields(pbfriend.FriendUser, user)
-	pbfriend.CreateTime = db.CreateTime.Unix()
-
-	pbfriend.FriendUser.CreateTime = db.CreateTime.Unix()
-	return pbfriend, nil
-}
-
-func (pb *PBFriend) Convert() (*relation.FriendModel, error) {
-	dbFriend := &relation.FriendModel{}
-	utils.CopyStructFields(dbFriend, pb)
-	dbFriend.FriendUserID = pb.FriendUser.UserID
-	dbFriend.CreateTime = utils.UnixSecondToTime(pb.CreateTime)
-	return dbFriend, nil
-}
-
-type DBFriendRequest struct {
-	*relation.FriendRequestModel
-	userCheck *check.UserCheck
-}
-
-func NewDBFriendRequest(friendRequest *relation.FriendRequestModel, zk discoveryRegistry.SvcDiscoveryRegistry) *DBFriendRequest {
-	return &DBFriendRequest{FriendRequestModel: friendRequest, userCheck: check.NewUserCheck(zk)}
-}
-
-type PBFriendRequest struct {
-	*sdk.FriendRequest
-}
-
-func NewPBFriendRequest(friendRequest *sdk.FriendRequest) *PBFriendRequest {
-	return &PBFriendRequest{FriendRequest: friendRequest}
-}
-
-func (*PBFriendRequest) PB2DB(friendRequests []*sdk.FriendRequest) (DBFriendRequests []*relation.FriendRequestModel, err error) {
-	for _, v := range friendRequests {
-		u, err := NewPBFriendRequest(v).Convert()
-		if err != nil {
-			return nil, err
-		}
-		DBFriendRequests = append(DBFriendRequests, u)
-	}
-	return
-}
-
-func (db *DBFriendRequest) DB2PB(ctx context.Context, friendRequests []*relation.FriendRequestModel) (PBFriendRequests []*sdk.FriendRequest, err error) {
-	userIDs := make([]string, 0)
-	if len(friendRequests) > 0 {
-		userIDs = append(userIDs, friendRequests[0].FromUserID)
-	}
-	for _, v := range friendRequests {
-		userIDs = append(userIDs, v.ToUserID)
-	}
-	users, err := db.userCheck.GetUsersInfoMap(ctx, userIDs, true)
-	if err != nil {
-		return nil, err
-	}
-	for _, v := range friendRequests {
-		pbFriendRequest := &sdk.FriendRequest{}
-		pbFriendRequest.FromUserID = users[v.FromUserID].UserID
-		pbFriendRequest.FromNickname = users[v.FromUserID].Nickname
-		pbFriendRequest.FromFaceURL = users[v.FromUserID].FaceURL
-		pbFriendRequest.ToUserID = users[v.ToUserID].UserID
-		pbFriendRequest.ToNickname = users[v.ToUserID].Nickname
-		pbFriendRequest.ToFaceURL = users[v.ToUserID].FaceURL
-		pbFriendRequest.CreateTime = v.CreateTime.Unix()
-		pbFriendRequest.HandleTime = v.HandleTime.Unix()
-		pbFriendRequest.HandlerUserID = v.HandlerUserID
-		pbFriendRequest.HandleResult = v.HandleResult
-		pbFriendRequest.Ex = v.Ex
-		pbFriendRequest.HandleMsg = v.HandleMsg
-		pbFriendRequest.ReqMsg = v.ReqMsg
-		PBFriendRequests = append(PBFriendRequests, pbFriendRequest)
-	}
-	return
-}
-
-func (pb *PBFriendRequest) Convert() (*relation.FriendRequestModel, error) {
-	dbFriendRequest := &relation.FriendRequestModel{}
-	utils.CopyStructFields(dbFriendRequest, pb)
-	dbFriendRequest.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
-	dbFriendRequest.HandleTime = utils.UnixSecondToTime(int64(pb.HandleTime))
-	return dbFriendRequest, nil
-}
-func (db *DBFriendRequest) Convert(ctx context.Context) (*sdk.FriendRequest, error) {
-	pbFriendRequest := &sdk.FriendRequest{}
-	utils.CopyStructFields(pbFriendRequest, db)
-	user, err := db.userCheck.GetUserInfo(ctx, db.FromUserID)
-	if err != nil {
-		return nil, err
-	}
-	pbFriendRequest.FromNickname = user.Nickname
-	pbFriendRequest.FromFaceURL = user.FaceURL
-	user, err = db.userCheck.GetUserInfo(ctx, db.ToUserID)
-	if err != nil {
-		return nil, err
-	}
-	pbFriendRequest.ToNickname = user.Nickname
-	pbFriendRequest.ToFaceURL = user.FaceURL
-	pbFriendRequest.CreateTime = db.CreateTime.Unix()
-	pbFriendRequest.HandleTime = db.HandleTime.Unix()
-	return pbFriendRequest, nil
-}
-
 type DBBlack struct {
 	*relation.BlackModel
-	userCheck *check.UserCheck
 }
 
 func (*PBBlack) PB2DB(blacks []*sdk.BlackInfo) (DBBlacks []*relation.BlackModel, err error) {

pkg/rpcclient/convert/user.go

@@ -0,0 +1,34 @@
+package convert
+
+import (
+	"time"
+
+	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+)
+
+func UsersDB2Pb(users []*relationTb.UserModel) (result []*sdkws.UserInfo) {
+	for _, user := range users {
+		var userPb sdkws.UserInfo
+		userPb.UserID = user.UserID
+		userPb.Nickname = user.Nickname
+		userPb.FaceURL = user.FaceURL
+		userPb.Ex = user.Ex
+		userPb.CreateTime = user.CreateTime.Unix()
+		userPb.AppMangerLevel = user.AppMangerLevel
+		userPb.GlobalRecvMsgOpt = user.GlobalRecvMsgOpt
+	}
+	return result
+}
+
+func UserPb2DB(user *sdkws.UserInfo) *relationTb.UserModel {
+	var userDB relationTb.UserModel
+	userDB.UserID = user.UserID
+	userDB.Nickname = user.Nickname
+	userDB.FaceURL = user.FaceURL
+	userDB.Ex = user.Ex
+	userDB.CreateTime = time.Unix(user.CreateTime, 0)
+	userDB.AppMangerLevel = user.AppMangerLevel
+	userDB.GlobalRecvMsgOpt = user.GlobalRecvMsgOpt
+	return &userDB
+}

pkg/rpcclient/notification/c.go

@@ -1,299 +0,0 @@
-package notification
-
-import (
-	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
-	discoveryRegistry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
-	"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/check"
-	utils "github.com/OpenIMSDK/open_utils"
-)
-
-type Check struct {
-	user         *check.UserCheck
-	group        *check.GroupChecker
-	Msg          *check.MsgCheck
-	friend       *check.FriendChecker
-	conversation *check.ConversationChecker
-}
-
-func NewCheck(zk discoveryRegistry.SvcDiscoveryRegistry) *Check {
-	return &Check{
-		user:         check.NewUserCheck(zk),
-		group:        check.NewGroupChecker(zk),
-		Msg:          check.NewMsgCheck(zk),
-		friend:       check.NewFriendChecker(zk),
-		conversation: check.NewConversationChecker(zk),
-	}
-}
-
-type NotificationMsg struct {
-	SendID         string
-	RecvID         string
-	Content        []byte //  sdkws.TipsComm
-	MsgFrom        int32
-	ContentType    int32
-	SessionType    int32
-	SenderNickname string
-	SenderFaceURL  string
-}
-
-func (c *Check) Notification(ctx context.Context, notificationMsg *NotificationMsg) error {
-	var err error
-	var req msg.SendMsgReq
-	var msg sdkws.MsgData
-	var offlineInfo sdkws.OfflinePushInfo
-	var title, desc, ex string
-	var pushSwitch, unReadCount bool
-	var reliabilityLevel int
-	msg.SendID = notificationMsg.SendID
-	msg.RecvID = notificationMsg.RecvID
-	msg.Content = notificationMsg.Content
-	msg.MsgFrom = notificationMsg.MsgFrom
-	msg.ContentType = notificationMsg.ContentType
-	msg.SessionType = notificationMsg.SessionType
-	msg.CreateTime = utils.GetCurrentTimestampByMill()
-	msg.ClientMsgID = utils.GetMsgID(notificationMsg.SendID)
-	msg.Options = make(map[string]bool, 7)
-	msg.SenderNickname = notificationMsg.SenderNickname
-	msg.SenderFaceURL = notificationMsg.SenderFaceURL
-	switch notificationMsg.SessionType {
-	case constant.GroupChatType, constant.SuperGroupChatType:
-		msg.RecvID = ""
-		msg.GroupID = notificationMsg.RecvID
-	}
-	offlineInfo.IOSBadgeCount = config.Config.IOSPush.BadgeCount
-	offlineInfo.IOSPushSound = config.Config.IOSPush.PushSound
-	switch msg.ContentType {
-	case constant.GroupCreatedNotification:
-		pushSwitch = config.Config.Notification.GroupCreated.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupCreated.OfflinePush.Title
-		desc = config.Config.Notification.GroupCreated.OfflinePush.Desc
-		ex = config.Config.Notification.GroupCreated.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupCreated.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupCreated.Conversation.UnreadCount
-	case constant.GroupInfoSetNotification:
-		pushSwitch = config.Config.Notification.GroupInfoSet.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupInfoSet.OfflinePush.Title
-		desc = config.Config.Notification.GroupInfoSet.OfflinePush.Desc
-		ex = config.Config.Notification.GroupInfoSet.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupInfoSet.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupInfoSet.Conversation.UnreadCount
-	case constant.JoinGroupApplicationNotification:
-		pushSwitch = config.Config.Notification.JoinGroupApplication.OfflinePush.PushSwitch
-		title = config.Config.Notification.JoinGroupApplication.OfflinePush.Title
-		desc = config.Config.Notification.JoinGroupApplication.OfflinePush.Desc
-		ex = config.Config.Notification.JoinGroupApplication.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.JoinGroupApplication.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.JoinGroupApplication.Conversation.UnreadCount
-	case constant.MemberQuitNotification:
-		pushSwitch = config.Config.Notification.MemberQuit.OfflinePush.PushSwitch
-		title = config.Config.Notification.MemberQuit.OfflinePush.Title
-		desc = config.Config.Notification.MemberQuit.OfflinePush.Desc
-		ex = config.Config.Notification.MemberQuit.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.MemberQuit.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.MemberQuit.Conversation.UnreadCount
-	case constant.GroupApplicationAcceptedNotification:
-		pushSwitch = config.Config.Notification.GroupApplicationAccepted.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Title
-		desc = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Desc
-		ex = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupApplicationAccepted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupApplicationAccepted.Conversation.UnreadCount
-	case constant.GroupApplicationRejectedNotification:
-		pushSwitch = config.Config.Notification.GroupApplicationRejected.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupApplicationRejected.OfflinePush.Title
-		desc = config.Config.Notification.GroupApplicationRejected.OfflinePush.Desc
-		ex = config.Config.Notification.GroupApplicationRejected.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupApplicationRejected.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupApplicationRejected.Conversation.UnreadCount
-	case constant.GroupOwnerTransferredNotification:
-		pushSwitch = config.Config.Notification.GroupOwnerTransferred.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Title
-		desc = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Desc
-		ex = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupOwnerTransferred.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupOwnerTransferred.Conversation.UnreadCount
-	case constant.MemberKickedNotification:
-		pushSwitch = config.Config.Notification.MemberKicked.OfflinePush.PushSwitch
-		title = config.Config.Notification.MemberKicked.OfflinePush.Title
-		desc = config.Config.Notification.MemberKicked.OfflinePush.Desc
-		ex = config.Config.Notification.MemberKicked.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.MemberKicked.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.MemberKicked.Conversation.UnreadCount
-	case constant.MemberInvitedNotification:
-		pushSwitch = config.Config.Notification.MemberInvited.OfflinePush.PushSwitch
-		title = config.Config.Notification.MemberInvited.OfflinePush.Title
-		desc = config.Config.Notification.MemberInvited.OfflinePush.Desc
-		ex = config.Config.Notification.MemberInvited.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.MemberInvited.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.MemberInvited.Conversation.UnreadCount
-	case constant.MemberEnterNotification:
-		pushSwitch = config.Config.Notification.MemberEnter.OfflinePush.PushSwitch
-		title = config.Config.Notification.MemberEnter.OfflinePush.Title
-		desc = config.Config.Notification.MemberEnter.OfflinePush.Desc
-		ex = config.Config.Notification.MemberEnter.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.MemberEnter.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.MemberEnter.Conversation.UnreadCount
-	case constant.UserInfoUpdatedNotification:
-		pushSwitch = config.Config.Notification.UserInfoUpdated.OfflinePush.PushSwitch
-		title = config.Config.Notification.UserInfoUpdated.OfflinePush.Title
-		desc = config.Config.Notification.UserInfoUpdated.OfflinePush.Desc
-		ex = config.Config.Notification.UserInfoUpdated.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.UserInfoUpdated.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.UserInfoUpdated.Conversation.UnreadCount
-	case constant.FriendApplicationNotification:
-		pushSwitch = config.Config.Notification.FriendApplication.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendApplication.OfflinePush.Title
-		desc = config.Config.Notification.FriendApplication.OfflinePush.Desc
-		ex = config.Config.Notification.FriendApplication.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendApplication.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendApplication.Conversation.UnreadCount
-	case constant.FriendApplicationApprovedNotification:
-		pushSwitch = config.Config.Notification.FriendApplicationApproved.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendApplicationApproved.OfflinePush.Title
-		desc = config.Config.Notification.FriendApplicationApproved.OfflinePush.Desc
-		ex = config.Config.Notification.FriendApplicationApproved.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendApplicationApproved.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendApplicationApproved.Conversation.UnreadCount
-	case constant.FriendApplicationRejectedNotification:
-		pushSwitch = config.Config.Notification.FriendApplicationRejected.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendApplicationRejected.OfflinePush.Title
-		desc = config.Config.Notification.FriendApplicationRejected.OfflinePush.Desc
-		ex = config.Config.Notification.FriendApplicationRejected.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendApplicationRejected.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendApplicationRejected.Conversation.UnreadCount
-	case constant.FriendAddedNotification:
-		pushSwitch = config.Config.Notification.FriendAdded.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendAdded.OfflinePush.Title
-		desc = config.Config.Notification.FriendAdded.OfflinePush.Desc
-		ex = config.Config.Notification.FriendAdded.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendAdded.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendAdded.Conversation.UnreadCount
-	case constant.FriendDeletedNotification:
-		pushSwitch = config.Config.Notification.FriendDeleted.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendDeleted.OfflinePush.Title
-		desc = config.Config.Notification.FriendDeleted.OfflinePush.Desc
-		ex = config.Config.Notification.FriendDeleted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendDeleted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendDeleted.Conversation.UnreadCount
-	case constant.FriendRemarkSetNotification:
-		pushSwitch = config.Config.Notification.FriendRemarkSet.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendRemarkSet.OfflinePush.Title
-		desc = config.Config.Notification.FriendRemarkSet.OfflinePush.Desc
-		ex = config.Config.Notification.FriendRemarkSet.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendRemarkSet.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendRemarkSet.Conversation.UnreadCount
-	case constant.BlackAddedNotification:
-		pushSwitch = config.Config.Notification.BlackAdded.OfflinePush.PushSwitch
-		title = config.Config.Notification.BlackAdded.OfflinePush.Title
-		desc = config.Config.Notification.BlackAdded.OfflinePush.Desc
-		ex = config.Config.Notification.BlackAdded.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.BlackAdded.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.BlackAdded.Conversation.UnreadCount
-	case constant.BlackDeletedNotification:
-		pushSwitch = config.Config.Notification.BlackDeleted.OfflinePush.PushSwitch
-		title = config.Config.Notification.BlackDeleted.OfflinePush.Title
-		desc = config.Config.Notification.BlackDeleted.OfflinePush.Desc
-		ex = config.Config.Notification.BlackDeleted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.BlackDeleted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.BlackDeleted.Conversation.UnreadCount
-	case constant.ConversationOptChangeNotification:
-		pushSwitch = config.Config.Notification.ConversationOptUpdate.OfflinePush.PushSwitch
-		title = config.Config.Notification.ConversationOptUpdate.OfflinePush.Title
-		desc = config.Config.Notification.ConversationOptUpdate.OfflinePush.Desc
-		ex = config.Config.Notification.ConversationOptUpdate.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.ConversationOptUpdate.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.ConversationOptUpdate.Conversation.UnreadCount
-
-	case constant.GroupDismissedNotification:
-		pushSwitch = config.Config.Notification.GroupDismissed.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupDismissed.OfflinePush.Title
-		desc = config.Config.Notification.GroupDismissed.OfflinePush.Desc
-		ex = config.Config.Notification.GroupDismissed.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupDismissed.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupDismissed.Conversation.UnreadCount
-
-	case constant.GroupMutedNotification:
-		pushSwitch = config.Config.Notification.GroupMuted.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupMuted.OfflinePush.Title
-		desc = config.Config.Notification.GroupMuted.OfflinePush.Desc
-		ex = config.Config.Notification.GroupMuted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupMuted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupMuted.Conversation.UnreadCount
-
-	case constant.GroupCancelMutedNotification:
-		pushSwitch = config.Config.Notification.GroupCancelMuted.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupCancelMuted.OfflinePush.Title
-		desc = config.Config.Notification.GroupCancelMuted.OfflinePush.Desc
-		ex = config.Config.Notification.GroupCancelMuted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupCancelMuted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupCancelMuted.Conversation.UnreadCount
-
-	case constant.GroupMemberMutedNotification:
-		pushSwitch = config.Config.Notification.GroupMemberMuted.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupMemberMuted.OfflinePush.Title
-		desc = config.Config.Notification.GroupMemberMuted.OfflinePush.Desc
-		ex = config.Config.Notification.GroupMemberMuted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupMemberMuted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupMemberMuted.Conversation.UnreadCount
-
-	case constant.GroupMemberCancelMutedNotification:
-		pushSwitch = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Title
-		desc = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Desc
-		ex = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupMemberCancelMuted.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupMemberCancelMuted.Conversation.UnreadCount
-
-	case constant.GroupMemberInfoSetNotification:
-		pushSwitch = config.Config.Notification.GroupMemberInfoSet.OfflinePush.PushSwitch
-		title = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Title
-		desc = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Desc
-		ex = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.GroupMemberInfoSet.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.GroupMemberInfoSet.Conversation.UnreadCount
-
-	case constant.ConversationPrivateChatNotification:
-		pushSwitch = config.Config.Notification.ConversationSetPrivate.OfflinePush.PushSwitch
-		title = config.Config.Notification.ConversationSetPrivate.OfflinePush.Title
-		desc = config.Config.Notification.ConversationSetPrivate.OfflinePush.Desc
-		ex = config.Config.Notification.ConversationSetPrivate.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.ConversationSetPrivate.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.ConversationSetPrivate.Conversation.UnreadCount
-	case constant.FriendInfoUpdatedNotification:
-		pushSwitch = config.Config.Notification.FriendInfoUpdated.OfflinePush.PushSwitch
-		title = config.Config.Notification.FriendInfoUpdated.OfflinePush.Title
-		desc = config.Config.Notification.FriendInfoUpdated.OfflinePush.Desc
-		ex = config.Config.Notification.FriendInfoUpdated.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.FriendInfoUpdated.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.FriendInfoUpdated.Conversation.UnreadCount
-	case constant.DeleteMessageNotification:
-		reliabilityLevel = constant.ReliableNotificationNoMsg
-	case constant.ConversationUnreadNotification, constant.SuperGroupUpdateNotification:
-		reliabilityLevel = constant.UnreliableNotification
-	}
-	switch reliabilityLevel {
-	case constant.UnreliableNotification:
-		utils.SetSwitchFromOptions(msg.Options, constant.IsHistory, false)
-		utils.SetSwitchFromOptions(msg.Options, constant.IsPersistent, false)
-		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
-		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
-	case constant.ReliableNotificationNoMsg:
-		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
-		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
-	case constant.ReliableNotificationMsg:
-
-	}
-	utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, unReadCount)
-	utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, pushSwitch)
-	offlineInfo.Title = title
-	offlineInfo.Desc = desc
-	offlineInfo.Ex = ex
-	msg.OfflinePushInfo = &offlineInfo
-	req.MsgData = &msg
-	_, err = c.Msg.SendMsg(ctx, &req)
-	return err
-}

pkg/rpcclient/notification/friend.go

@@ -1,153 +0,0 @@
-package notification
-
-import (
-	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
-	pbFriend "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-)
-
-func (c *Check) getFromToUserNickname(ctx context.Context, fromUserID, toUserID string) (string, string, error) {
-	users, err := c.user.GetUsersInfoMap(ctx, []string{fromUserID, toUserID}, true)
-	if err != nil {
-		return "", "", nil
-	}
-	return users[fromUserID].Nickname, users[toUserID].Nickname, nil
-}
-
-func (c *Check) friendNotification(ctx context.Context, fromUserID, toUserID string, contentType int32, m proto.Message) {
-	var err error
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		return
-	}
-
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-
-	fromUserNickname, toUserNickname, err := c.getFromToUserNickname(ctx, fromUserID, toUserID)
-	if err != nil {
-		return
-	}
-	cn := config.Config.Notification
-	switch contentType {
-	case constant.FriendApplicationNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendApplication.DefaultTips.Tips
-	case constant.FriendApplicationApprovedNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendApplicationApproved.DefaultTips.Tips
-	case constant.FriendApplicationRejectedNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendApplicationRejected.DefaultTips.Tips
-	case constant.FriendAddedNotification:
-		tips.DefaultTips = cn.FriendAdded.DefaultTips.Tips
-	case constant.FriendDeletedNotification:
-		tips.DefaultTips = cn.FriendDeleted.DefaultTips.Tips + toUserNickname
-	case constant.FriendRemarkSetNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendRemarkSet.DefaultTips.Tips
-	case constant.BlackAddedNotification:
-		tips.DefaultTips = cn.BlackAdded.DefaultTips.Tips
-	case constant.BlackDeletedNotification:
-		tips.DefaultTips = cn.BlackDeleted.DefaultTips.Tips + toUserNickname
-	case constant.UserInfoUpdatedNotification:
-		tips.DefaultTips = cn.UserInfoUpdated.DefaultTips.Tips
-	case constant.FriendInfoUpdatedNotification:
-		tips.DefaultTips = cn.FriendInfoUpdated.DefaultTips.Tips + toUserNickname
-	default:
-		return
-	}
-
-	var n NotificationMsg
-	n.SendID = fromUserID
-	n.RecvID = toUserID
-	n.ContentType = contentType
-	n.SessionType = constant.SingleChatType
-	n.MsgFrom = constant.SysMsgType
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		return
-	}
-	c.Notification(ctx, &n)
-}
-
-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
-	c.friendNotification(ctx, req.FromUserID, req.ToUserID, constant.FriendApplicationNotification, &FriendApplicationTips)
-}
-
-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
-	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
-	c.friendNotification(ctx, req.ToUserID, req.FromUserID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
-}
-
-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
-	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
-	c.friendNotification(ctx, req.ToUserID, req.FromUserID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
-}
-
-func (c *Check) FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) {
-	friendAddedTips := sdkws.FriendAddedTips{Friend: &sdkws.FriendInfo{}, OpUser: &sdkws.PublicUserInfo{}}
-	user, err := c.user.GetUsersInfos(ctx, []string{opUserID}, true)
-	if err != nil {
-		return
-	}
-	friendAddedTips.OpUser.UserID = user[0].UserID
-	friendAddedTips.OpUser.Ex = user[0].Ex
-	friendAddedTips.OpUser.Nickname = user[0].Nickname
-	friendAddedTips.OpUser.FaceURL = user[0].FaceURL
-
-	friend, err := c.friend.GetFriendsInfo(ctx, fromUserID, toUserID)
-	if err != nil {
-		return
-	}
-	friendAddedTips.Friend = friend
-	c.friendNotification(ctx, fromUserID, toUserID, constant.FriendAddedNotification, &friendAddedTips)
-}
-
-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
-	c.friendNotification(ctx, req.OwnerUserID, req.FriendUserID, constant.FriendDeletedNotification, &friendDeletedTips)
-}
-
-func (c *Check) 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 *Check) 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 *Check) 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 *Check) 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/msg.go

@@ -1,42 +0,0 @@
-package notification
-
-import (
-	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-)
-
-func (c *Check) DeleteMessageNotification(ctx context.Context, userID string, seqs []int64, operationID string) {
-	DeleteMessageTips := sdkws.DeleteMessageTips{UserID: userID, Seqs: seqs}
-	c.MessageNotification(ctx, userID, userID, constant.DeleteMessageNotification, &DeleteMessageTips)
-}
-
-func (c *Check) MessageNotification(ctx context.Context, sendID, recvID string, contentType int32, m proto.Message) {
-	var err error
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		return
-	}
-
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-	var n NotificationMsg
-	n.SendID = sendID
-	n.RecvID = recvID
-	n.ContentType = contentType
-	n.SessionType = constant.SingleChatType
-	n.MsgFrom = constant.SysMsgType
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		return
-	}
-	c.Notification(ctx, &n)
-}

pkg/rpcclient/notification/user.go

@@ -1,13 +0,0 @@
-package notification
-
-import (
-	"context"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
-)
-
-// send to myself
-func (c *Check) UserInfoUpdatedNotification(ctx context.Context, opUserID string, changedUserID string) {
-	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
-	c.friendNotification(ctx, opUserID, changedUserID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
-}

pkg/rpcclient/notification2/conevrsation.go

@@ -1,15 +1,26 @@
-package notification
+package notification2
 
 import (
 	"context"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
-	sdkws "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"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/jsonpb"
 	"github.com/golang/protobuf/proto"
 )
 
-func (c *Check) SetConversationNotification(ctx context.Context, sendID, recvID string, contentType int, m proto.Message, tips sdkws.TipsComm) {
+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, tips *sdkws.TipsComm) {
 	var err error
 	tips.Detail, err = proto.Marshal(m)
 	if err != nil {
@@ -21,13 +32,13 @@ func (c *Check) SetConversationNotification(ctx context.Context, sendID, recvID
 		EmitDefaults: false,
 	}
 	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-	var n NotificationMsg
+	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 = proto.Marshal(&tips)
+	n.Content, err = proto.Marshal(tips)
 	if err != nil {
 		return
 	}
@@ -35,8 +46,7 @@ func (c *Check) SetConversationNotification(ctx context.Context, sendID, recvID
 }
 
 // SetPrivate调用
-func (c *Check) ConversationSetPrivateNotification(ctx context.Context, sendID, recvID string, isPrivateChat bool) {
-
+func (c *ConversationNotificationSender) ConversationSetPrivateNotification(ctx context.Context, sendID, recvID string, isPrivateChat bool) {
 	conversationSetPrivateTips := &sdkws.ConversationSetPrivateTips{
 		RecvID:    recvID,
 		SendID:    sendID,
@@ -50,23 +60,21 @@ func (c *Check) ConversationSetPrivateNotification(ctx context.Context, sendID,
 		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.CloseTips
 	}
 	tips.DefaultTips = tipsMsg
-	c.SetConversationNotification(ctx, sendID, recvID, constant.ConversationPrivateChatNotification, conversationSetPrivateTips, tips)
+	c.SetConversationNotification(ctx, sendID, recvID, constant.ConversationPrivateChatNotification, conversationSetPrivateTips, &tips)
 }
 
 // 会话改变
-func (c *Check) ConversationChangeNotification(ctx context.Context, userID string) {
-
+func (c *ConversationNotificationSender) ConversationChangeNotification(ctx context.Context, userID string) {
 	ConversationChangedTips := &sdkws.ConversationUpdateTips{
 		UserID: userID,
 	}
 	var tips sdkws.TipsComm
 	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
-	c.SetConversationNotification(ctx, userID, userID, constant.ConversationOptChangeNotification, ConversationChangedTips, tips)
+	c.SetConversationNotification(ctx, userID, userID, constant.ConversationOptChangeNotification, ConversationChangedTips, &tips)
 }
 
 // 会话未读数同步
-func (c *Check) ConversationUnreadChangeNotification(ctx context.Context, userID, conversationID string, updateUnreadCountTime int64) {
-
+func (c *ConversationNotificationSender) ConversationUnreadChangeNotification(ctx context.Context, userID, conversationID string, updateUnreadCountTime int64) {
 	ConversationChangedTips := &sdkws.ConversationUpdateTips{
 		UserID:                userID,
 		ConversationIDList:    []string{conversationID},
@@ -74,5 +82,5 @@ func (c *Check) ConversationUnreadChangeNotification(ctx context.Context, userID
 	}
 	var tips sdkws.TipsComm
 	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
-	c.SetConversationNotification(ctx, userID, userID, constant.ConversationUnreadNotification, ConversationChangedTips, tips)
+	c.SetConversationNotification(ctx, userID, userID, constant.ConversationUnreadNotification, ConversationChangedTips, &tips)
 }

pkg/rpcclient/notification2/extend_msg.go

@@ -1,59 +1,69 @@
-package notification
+package notification2
 
 import (
 	"context"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/apistruct"
 	"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/proto/msg"
-	sdkws "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"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"
 )
 
-func (c *Check) ExtendMessageUpdatedNotification(ctx context.Context, sendID string, sourceID string, sessionType int32,
-	req *msg.SetMessageReactionExtensionsReq, resp *msg.SetMessageReactionExtensionsResp, isHistory bool, isReactionFromCache bool) {
-	var m apistruct.ReactionMessageModifierNotification
-	m.SourceID = req.SourceID
-	m.OpUserID = mcontext.GetOpUserID(ctx)
-	m.SessionType = req.SessionType
-	keyMap := make(map[string]*sdkws.KeyValue)
-	for _, valueResp := range resp.Result {
-		if valueResp.ErrCode == 0 {
-			keyMap[valueResp.KeyValue.TypeKey] = valueResp.KeyValue
-		}
-	}
-	if len(keyMap) == 0 {
-		return
-	}
-	m.SuccessReactionExtensions = keyMap
-	m.ClientMsgID = req.ClientMsgID
-	m.IsReact = resp.IsReact
-	m.IsExternalExtensions = req.IsExternalExtensions
-	m.MsgFirstModifyTime = resp.MsgFirstModifyTime
-	c.messageReactionSender(ctx, sendID, sourceID, sessionType, constant.ReactionMessageModifier, utils.StructToJsonString(m), isHistory, isReactionFromCache)
+type ExtendMsgNotificationSender struct {
+	*rpcclient.MsgClient
 }
-func (c *Check) ExtendMessageDeleteNotification(ctx context.Context, sendID string, sourceID string, sessionType int32,
-	req *msg.DeleteMessagesReactionExtensionsReq, resp *msg.DeleteMessagesReactionExtensionsResp, isHistory bool, isReactionFromCache bool) {
-	var m apistruct.ReactionMessageDeleteNotification
-	m.SourceID = req.SourceID
-	m.OpUserID = req.OpUserID
-	m.SessionType = req.SessionType
-	keyMap := make(map[string]*sdkws.KeyValue)
-	for _, valueResp := range resp.Result {
-		if valueResp.ErrCode == 0 {
-			keyMap[valueResp.KeyValue.TypeKey] = valueResp.KeyValue
-		}
-	}
-	if len(keyMap) == 0 {
-		return
-	}
-	m.SuccessReactionExtensions = keyMap
-	m.ClientMsgID = req.ClientMsgID
-	m.MsgFirstModifyTime = req.MsgFirstModifyTime
 
-	c.messageReactionSender(ctx, sendID, sourceID, sessionType, constant.ReactionMessageDeleter, utils.StructToJsonString(m), isHistory, isReactionFromCache)
+func NewExtendMsgNotificationSender(client discoveryregistry.SvcDiscoveryRegistry) *ExtendMsgNotificationSender {
+	return &ExtendMsgNotificationSender{rpcclient.NewMsgClient(client)}
 }
-func (c *Check) messageReactionSender(ctx context.Context, sendID string, sourceID string, sessionType, contentType int32, content string, isHistory bool, isReactionFromCache bool) error {
+
+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 apistruct.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, utils.StructToJsonString(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 apistruct.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, utils.StructToJsonString(content), isHistory, isReactionFromCache)
+}
+func (e *ExtendMsgNotificationSender) messageReactionSender(ctx context.Context, sendID string, sourceID string, sessionType, contentType int32, content string, isHistory bool, isReactionFromCache bool) error {
 	options := make(map[string]bool, 5)
 	utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false)
 	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, false)
@@ -82,6 +92,6 @@ func (c *Check) messageReactionSender(ctx context.Context, sendID string, source
 	case constant.GroupChatType, constant.SuperGroupChatType:
 		pbData.MsgData.GroupID = sourceID
 	}
-	_, err := c.Msg.SendMsg(ctx, &pbData)
+	_, err := e.SendMsg(ctx, &pbData)
 	return err
 }

pkg/rpcclient/notification2/friend.go

@@ -26,6 +26,12 @@ type FriendNotificationSender struct {
 
 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) {
@@ -146,6 +152,11 @@ func (c *FriendNotificationSender) friendNotification(ctx context.Context, fromU
 	c.Notification(ctx, &n)
 }
 
+func (u *FriendNotificationSender) UserInfoUpdatedNotification(ctx context.Context, opUserID string, changedUserID string) {
+	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
+	u.friendNotification(ctx, opUserID, changedUserID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
+}
+
 func (c *FriendNotificationSender) FriendApplicationAddNotification(ctx context.Context, req *pbFriend.ApplyToAddFriendReq) {
 	FriendApplicationTips := sdkws.FriendApplicationTips{FromToUserID: &sdkws.FromToUserID{}}
 	FriendApplicationTips.FromToUserID.FromUserID = req.FromUserID
@@ -185,6 +196,9 @@ func (c *FriendNotificationSender) FriendAddedNotification(ctx context.Context,
 		return
 	}
 	friendAddedTips.Friend, err = convert.FriendDB2Pb(ctx, friends[0], c.getUsersInfoMap)
+	if err != nil {
+		return
+	}
 	c.friendNotification(ctx, fromUserID, toUserID, constant.FriendAddedNotification, &friendAddedTips)
 }