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

 Conflicts:

	cmd/rpc/auth/main.go

	cmd/rpc/friend/main.go

	cmd/rpc/group/main.go

	cmd/rpc/msg/main.go

	cmd/rpc/user/main.go

	internal/rpc/auth/auth.go

	internal/rpc/conversation/conversaion.go

	internal/rpc/friend/friend.go

	internal/rpc/group/callback.go

	internal/rpc/group/group.go

	internal/rpc/msg/pull_message.go

	internal/rpc/msg/query_msg.go

	internal/rpc/msg/rpc_chat.go

	internal/rpc/msg/send_msg.go

	internal/rpc/user/user.go

	pkg/common/db/cache/redis.go

	pkg/common/db/controller/msg.go

	pkg/common/http/http_client.go

internal/common/check/access.go

@@ -5,8 +5,8 @@ import (
 	"context"
 )
 
-func Access(ctx context.Context, ownerUserID string) (err error) {
-	_, err = GetUsersInfo(ctx, ownerUserID)
+func (u *UserCheck) Access(ctx context.Context, ownerUserID string) (err error) {
+	_, err = u.GetUsersInfo(ctx, ownerUserID)
 	if err != nil {
 		return err
 	}

internal/common/check/black.go

@@ -0,0 +1,21 @@
+package check
+
+import (
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	"context"
+)
+
+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) {
+
+}

internal/common/check/conversation.go

@@ -0,0 +1,35 @@
+package check
+
+import (
+	"Open_IM/pkg/common/config"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	"Open_IM/pkg/proto/conversation"
+	pbConversation "Open_IM/pkg/proto/conversation"
+	"context"
+	"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) {
+
+}

internal/common/check/friend.go

@@ -1,11 +1,41 @@
 package check
 
 import (
+	"Open_IM/pkg/common/config"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	"Open_IM/pkg/proto/friend"
 	sdkws "Open_IM/pkg/proto/sdkws"
 	"context"
-	"errors"
+	"google.golang.org/grpc"
 )
 
-func GetFriendsInfo(ctx context.Context, ownerUserID, friendUserID string) (*sdkws.FriendInfo, error) {
-	return nil, errors.New("TODO:GetUserInfo")
+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).GetPaginationFriends(ctx, &friend.GetPaginationFriendsReq{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) {
+
 }

internal/common/check/group.go

@@ -1,17 +1,130 @@
 package check
 
 import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	"Open_IM/pkg/proto/group"
 	sdkws "Open_IM/pkg/proto/sdkws"
-	"errors"
+	"Open_IM/pkg/utils"
+	"context"
+	"google.golang.org/grpc"
+	"strings"
 )
 
 type GroupChecker struct {
+	zk discoveryRegistry.SvcDiscoveryRegistry
 }
 
-func NewGroupChecker() *GroupChecker {
-	return &GroupChecker{}
+func NewGroupChecker(zk discoveryRegistry.SvcDiscoveryRegistry) *GroupChecker {
+	return &GroupChecker{
+		zk: zk,
+	}
 }
 
-func (g *GroupChecker) GetGroupInfo(groupID string) (*sdkws.GroupInfo, error) {
-	return nil, errors.New("TODO:GetUserInfo")
+func (g *GroupChecker) getConn() (*grpc.ClientConn, error) {
+	return g.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
+}
+
+func (g *GroupChecker) GetGroupInfos(ctx context.Context, groupIDs []string, complete bool) ([]*sdkws.GroupInfo, error) {
+	cc, err := g.getConn()
+	if err != nil {
+		return nil, err
+	}
+	resp, err := group.NewGroupClient(cc).GetGroupsInfo(ctx, &group.GetGroupsInfoReq{
+		GroupIDs: groupIDs,
+	})
+	if err != nil {
+		return nil, err
+	}
+	if complete {
+		if ids := utils.Single(groupIDs, utils.Slice(resp.GroupInfos, func(e *sdkws.GroupInfo) string {
+			return e.GroupID
+		})); len(ids) > 0 {
+			return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
+		}
+	}
+	return resp.GroupInfos, nil
+}
+
+func (g *GroupChecker) GetGroupInfo(ctx context.Context, groupID string) (*sdkws.GroupInfo, error) {
+	groups, err := g.GetGroupInfos(ctx, []string{groupID}, true)
+	if err != nil {
+		return nil, err
+	}
+	return groups[0], nil
+}
+
+func (g *GroupChecker) GetGroupInfoMap(ctx context.Context, groupIDs []string, complete bool) (map[string]*sdkws.GroupInfo, error) {
+	groups, err := g.GetGroupInfos(ctx, groupIDs, complete)
+	if err != nil {
+		return nil, err
+	}
+	return utils.SliceToMap(groups, func(e *sdkws.GroupInfo) string {
+		return e.GroupID
+	}), nil
+}
+
+func (g *GroupChecker) GetGroupMemberInfos(ctx context.Context, groupID string, userIDs []string, complete bool) ([]*sdkws.GroupMemberFullInfo, error) {
+	cc, err := g.getConn()
+	if err != nil {
+		return nil, err
+	}
+	resp, err := group.NewGroupClient(cc).GetGroupMembersInfo(ctx, &group.GetGroupMembersInfoReq{
+		GroupID: groupID,
+		Members: userIDs,
+	})
+	if err != nil {
+		return nil, err
+	}
+	if complete {
+		if ids := utils.Single(userIDs, utils.Slice(resp.Members, func(e *sdkws.GroupMemberFullInfo) string {
+			return e.UserID
+		})); len(ids) > 0 {
+			return nil, constant.ErrNotInGroupYet.Wrap(strings.Join(ids, ","))
+		}
+	}
+	return resp.Members, nil
+}
+
+func (g *GroupChecker) GetGroupMemberInfo(ctx context.Context, groupID string, userID string) (*sdkws.GroupMemberFullInfo, error) {
+	members, err := g.GetGroupMemberInfos(ctx, groupID, []string{userID}, true)
+	if err != nil {
+		return nil, err
+	}
+	return members[0], nil
+}
+
+func (g *GroupChecker) GetGroupMemberInfoMap(ctx context.Context, groupID string, userIDs []string, complete bool) (map[string]*sdkws.GroupMemberFullInfo, error) {
+	members, err := g.GetGroupMemberInfos(ctx, groupID, userIDs, true)
+	if err != nil {
+		return nil, err
+	}
+	return utils.SliceToMap(members, func(e *sdkws.GroupMemberFullInfo) string {
+		return e.UserID
+	}), nil
+}
+
+func (g *GroupChecker) GetOwnerAndAdminInfos(ctx context.Context, groupID string) ([]*sdkws.GroupMemberFullInfo, error) {
+	cc, err := g.getConn()
+	if err != nil {
+		return nil, err
+	}
+	resp, err := group.NewGroupClient(cc).GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
+		GroupID:    groupID,
+		RoleLevels: []int32{constant.GroupOwner, constant.GroupAdmin},
+	})
+	return resp.Members, err
+}
+
+func (g *GroupChecker) GetOwnerInfo(ctx context.Context, groupID string) (*sdkws.GroupMemberFullInfo, error) {
+	cc, err := g.getConn()
+	if err != nil {
+		return nil, err
+	}
+	resp, err := group.NewGroupClient(cc).GetGroupMemberRoleLevel(ctx, &group.GetGroupMemberRoleLevelReq{
+		GroupID:    groupID,
+		RoleLevels: []int32{constant.GroupOwner},
+	})
+	return resp.Members[0], err
 }

internal/common/check/msg.go

@@ -0,0 +1,30 @@
+package check
+
+import (
+	"Open_IM/pkg/common/config"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	"Open_IM/pkg/proto/msg"
+	"context"
+	"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
+}

internal/common/check/user.go

@@ -1,11 +1,108 @@
 package check
 
 import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
 	sdkws "Open_IM/pkg/proto/sdkws"
+	"Open_IM/pkg/proto/user"
+	"Open_IM/pkg/utils"
 	"context"
-	"errors"
+	"google.golang.org/grpc"
+	"strings"
 )
 
-func GetUsersInfo(ctx context.Context, args ...interface{}) ([]*sdkws.UserInfo, error) {
-	return nil, errors.New("TODO:GetUserInfo")
+//func GetUsersInfo(ctx context.Context, args ...interface{}) ([]*sdkws.UserInfo, error) {
+//	return nil, errors.New("TODO:GetUserInfo")
+//}
+
+func NewUserCheck(zk discoveryRegistry.SvcDiscoveryRegistry) *UserCheck {
+	return &UserCheck{
+		zk: zk,
+	}
+}
+
+type UserCheck struct {
+	zk discoveryRegistry.SvcDiscoveryRegistry
+}
+
+func (u *UserCheck) getConn() (*grpc.ClientConn, error) {
+	return u.zk.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, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
+		}
+	}
+	return resp.UsersInfo, nil
+}
+
+func (u *UserCheck) GetUsersInfo(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,
+			Gender:   e.Gender,
+			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) {
+
 }

internal/common/convert/convert.go

@@ -1,29 +1,23 @@
 package convert
 
 import (
+	"Open_IM/internal/common/check"
 	"Open_IM/pkg/common/db/table/relation"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
 	sdk "Open_IM/pkg/proto/sdkws"
+	utils2 "Open_IM/pkg/utils"
+	"context"
 	utils "github.com/OpenIMSDK/open_utils"
 	"time"
 )
 
-func getUsersInfo(userIDs []string) ([]*sdk.UserInfo, error) {
-	return nil, nil
-}
-
-func getGroupOwnerInfo(groupID string) (*sdk.GroupMemberFullInfo, error) {
-	return nil, nil
-}
-func getNumberOfGroupMember(groupID string) (int32, error) {
-	return 0, nil
-}
-
 type DBFriend struct {
 	*relation.FriendModel
+	userCheck *check.UserCheck
 }
 
-func NewDBFriend(friend *relation.FriendModel) *DBFriend {
-	return &DBFriend{FriendModel: friend}
+func NewDBFriend(friend *relation.FriendModel, zk discoveryRegistry.SvcDiscoveryRegistry) *DBFriend {
+	return &DBFriend{FriendModel: friend, userCheck: check.NewUserCheck(zk)}
 }
 
 type PBFriend struct {
@@ -45,29 +39,34 @@ func (*PBFriend) PB2DB(friends []*sdk.FriendInfo) (DBFriends []*relation.FriendM
 	return
 }
 
-func (*DBFriend) DB2PB(friends []*relation.FriendModel) (PBFriends []*sdk.FriendInfo, err error) {
+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 {
-		u, err := NewDBFriend(v).Convert()
-		if err != nil {
-			return nil, err
-		}
-		PBFriends = append(PBFriends, u)
+		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()
 	}
 	return
 }
 
-func (db *DBFriend) Convert() (*sdk.FriendInfo, error) {
-	pbFriend := &sdk.FriendInfo{FriendUser: &sdk.UserInfo{}}
-	utils.CopyStructFields(pbFriend, db)
-	user, err := getUsersInfo([]string{db.FriendUserID})
+func (db *DBFriend) Convert(ctx context.Context) (*sdk.FriendInfo, error) {
+	pbfriend := &sdk.FriendInfo{FriendUser: &sdk.UserInfo{}}
+	utils.CopyStructFields(pbfriend, db)
+	user, err := db.userCheck.GetUsersInfo(ctx, db.FriendUserID)
 	if err != nil {
 		return nil, err
 	}
-	utils.CopyStructFields(pbFriend.FriendUser, user[0])
-	pbFriend.CreateTime = db.CreateTime.Unix()
+	utils.CopyStructFields(pbfriend.FriendUser, user)
+	pbfriend.CreateTime = db.CreateTime.Unix()
 
-	pbFriend.FriendUser.CreateTime = db.CreateTime.Unix()
-	return pbFriend, nil
+	pbfriend.FriendUser.CreateTime = db.CreateTime.Unix()
+	return pbfriend, nil
 }
 
 func (pb *PBFriend) Convert() (*relation.FriendModel, error) {
@@ -80,10 +79,11 @@ func (pb *PBFriend) Convert() (*relation.FriendModel, error) {
 
 type DBFriendRequest struct {
 	*relation.FriendRequestModel
+	userCheck *check.UserCheck
 }
 
-func NewDBFriendRequest(friendRequest *relation.FriendRequestModel) *DBFriendRequest {
-	return &DBFriendRequest{FriendRequestModel: friendRequest}
+func NewDBFriendRequest(friendRequest *relation.FriendRequestModel, zk discoveryRegistry.SvcDiscoveryRegistry) *DBFriendRequest {
+	return &DBFriendRequest{FriendRequestModel: friendRequest, userCheck: check.NewUserCheck(zk)}
 }
 
 type PBFriendRequest struct {
@@ -105,13 +105,26 @@ func (*PBFriendRequest) PB2DB(friendRequests []*sdk.FriendRequest) (DBFriendRequ
 	return
 }
 
-func (*DBFriendRequest) DB2PB(friendRequests []*relation.FriendRequestModel) (PBFriendRequests []*sdk.FriendRequest, err error) {
+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)
+	}
+	users, err := db.userCheck.GetUsersInfoMap(ctx, userIDs, true)
+	if err != nil {
+		return nil, err
+	}
 	for _, v := range friendRequests {
-		u, err := NewDBFriendRequest(v).Convert()
-		if err != nil {
-			return nil, err
-		}
-		PBFriendRequests = append(PBFriendRequests, u)
+		pbFriendRequest := &sdk.FriendRequest{}
+		pbFriendRequest.FromNickname = users[v.FromUserID].Nickname
+		pbFriendRequest.FromFaceURL = users[v.FromUserID].FaceURL
+		pbFriendRequest.FromGender = users[v.FromUserID].Gender
+		pbFriendRequest.ToNickname = users[v.ToUserID].Nickname
+		pbFriendRequest.ToFaceURL = users[v.ToUserID].FaceURL
+		pbFriendRequest.ToGender = users[v.ToUserID].Gender
+		pbFriendRequest.CreateTime = db.CreateTime.Unix()
+		pbFriendRequest.HandleTime = db.HandleTime.Unix()
+		PBFriendRequests = append(PBFriendRequests, pbFriendRequest)
 	}
 	return
 }
@@ -123,23 +136,23 @@ func (pb *PBFriendRequest) Convert() (*relation.FriendRequestModel, error) {
 	dbFriendRequest.HandleTime = utils.UnixSecondToTime(int64(pb.HandleTime))
 	return dbFriendRequest, nil
 }
-func (db *DBFriendRequest) Convert() (*sdk.FriendRequest, error) {
+func (db *DBFriendRequest) Convert(ctx context.Context) (*sdk.FriendRequest, error) {
 	pbFriendRequest := &sdk.FriendRequest{}
 	utils.CopyStructFields(pbFriendRequest, db)
-	user, err := getUsersInfo([]string{db.FromUserID})
+	user, err := db.userCheck.GetUsersInfo(ctx, db.FromUserID)
 	if err != nil {
 		return nil, err
 	}
-	pbFriendRequest.FromNickname = user[0].Nickname
-	pbFriendRequest.FromFaceURL = user[0].FaceURL
-	pbFriendRequest.FromGender = user[0].Gender
-	user, err = getUsersInfo([]string{db.ToUserID})
+	pbFriendRequest.FromNickname = user.Nickname
+	pbFriendRequest.FromFaceURL = user.FaceURL
+	pbFriendRequest.FromGender = user.Gender
+	user, err = db.userCheck.GetUsersInfo(ctx, db.ToUserID)
 	if err != nil {
 		return nil, err
 	}
-	pbFriendRequest.ToNickname = user[0].Nickname
-	pbFriendRequest.ToFaceURL = user[0].FaceURL
-	pbFriendRequest.ToGender = user[0].Gender
+	pbFriendRequest.ToNickname = user.Nickname
+	pbFriendRequest.ToFaceURL = user.FaceURL
+	pbFriendRequest.ToGender = user.Gender
 	pbFriendRequest.CreateTime = db.CreateTime.Unix()
 	pbFriendRequest.HandleTime = db.HandleTime.Unix()
 	return pbFriendRequest, nil
@@ -147,6 +160,7 @@ func (db *DBFriendRequest) Convert() (*sdk.FriendRequest, error) {
 
 type DBBlack struct {
 	*relation.BlackModel
+	userCheck *check.UserCheck
 }
 
 func (*PBBlack) PB2DB(blacks []*sdk.BlackInfo) (DBBlacks []*relation.BlackModel, err error) {
@@ -160,19 +174,31 @@ func (*PBBlack) PB2DB(blacks []*sdk.BlackInfo) (DBBlacks []*relation.BlackModel,
 	return
 }
 
-func (*DBBlack) DB2PB(blacks []*relation.BlackModel) (PBBlacks []*sdk.BlackInfo, err error) {
+func (db *DBBlack) DB2PB(ctx context.Context, blacks []*relation.BlackModel) (PBBlacks []*sdk.BlackInfo, err error) {
+	userIDs := make([]string, 0)
 	for _, v := range blacks {
-		u, err := NewDBBlack(v).Convert()
-		if err != nil {
-			return nil, err
-		}
-		PBBlacks = append(PBBlacks, u)
+		userIDs = append(userIDs, v.BlockUserID)
+	}
+	if len(blacks) > 0 {
+		userIDs = append(userIDs, blacks[0].OwnerUserID)
+	}
+
+	users, err := db.userCheck.GetUsersInfoMap(ctx, userIDs, true)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range blacks {
+		pbBlack := &sdk.BlackInfo{}
+		utils.CopyStructFields(pbBlack, users[v.OwnerUserID])
+		utils.CopyStructFields(pbBlack.BlackUserInfo, users[v.BlockUserID])
+		PBBlacks = append(PBBlacks, pbBlack)
 	}
 	return
 }
 
-func NewDBBlack(black *relation.BlackModel) *DBBlack {
-	return &DBBlack{BlackModel: black}
+func NewDBBlack(black *relation.BlackModel, zk discoveryRegistry.SvcDiscoveryRegistry) *DBBlack {
+	return &DBBlack{BlackModel: black, userCheck: check.NewUserCheck(zk)}
 }
 
 type PBBlack struct {
@@ -186,14 +212,14 @@ func NewPBBlack(blackInfo *sdk.BlackInfo) *PBBlack {
 func (pb *PBBlack) Convert() (*relation.BlackModel, error) {
 	dbBlack := &relation.BlackModel{}
 	dbBlack.BlockUserID = pb.BlackUserInfo.UserID
-	dbBlack.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
+	dbBlack.CreateTime = utils.UnixSecondToTime(pb.CreateTime)
 	return dbBlack, nil
 }
-func (db *DBBlack) Convert() (*sdk.BlackInfo, error) {
+func (db *DBBlack) Convert(ctx context.Context) (*sdk.BlackInfo, error) {
 	pbBlack := &sdk.BlackInfo{}
 	utils.CopyStructFields(pbBlack, db)
 	pbBlack.CreateTime = db.CreateTime.Unix()
-	user, err := getUsersInfo([]string{db.BlockUserID})
+	user, err := db.userCheck.GetUsersInfo(ctx, db.BlockUserID)
 	if err != nil {
 		return nil, err
 	}
@@ -203,6 +229,8 @@ func (db *DBBlack) Convert() (*sdk.BlackInfo, error) {
 
 type DBGroup struct {
 	*relation.GroupModel
+	zk         discoveryRegistry.SvcDiscoveryRegistry
+	groupCheck *check.GroupChecker
 }
 
 func (*PBGroup) PB2DB(groups []*sdk.GroupInfo) (DBGroups []*relation.GroupModel, err error) {
@@ -216,19 +244,19 @@ func (*PBGroup) PB2DB(groups []*sdk.GroupInfo) (DBGroups []*relation.GroupModel,
 	return
 }
 
-func (*DBGroup) DB2PB(groups []*relation.GroupModel) (PBGroups []*sdk.GroupInfo, err error) {
-	for _, v := range groups {
-		u, err := NewDBGroup(v).Convert()
-		if err != nil {
-			return nil, err
-		}
-		PBGroups = append(PBGroups, u)
-	}
-	return
-}
+//func (db *DBGroup) DB2PB(ctx context.Context, zk discoveryRegistry.SvcDiscoveryRegistry, groups []*relation.GroupModel) (PBGroups []*sdk.GroupInfo, err error) {
+//	for _, v := range groups {
+//		u, err := NewDBGroup(v, zk).Convert(ctx)
+//		if err != nil {
+//			return nil, err
+//		}
+//		PBGroups = append(PBGroups, u)
+//	}
+//	return
+//}
 
-func NewDBGroup(group *relation.GroupModel) *DBGroup {
-	return &DBGroup{GroupModel: group}
+func NewDBGroup(groupModel *relation.GroupModel, zk discoveryRegistry.SvcDiscoveryRegistry) *DBGroup {
+	return &DBGroup{GroupModel: groupModel, groupCheck: check.NewGroupChecker(zk)}
 }
 
 type PBGroup struct {
@@ -244,20 +272,20 @@ func (pb *PBGroup) Convert() (*relation.GroupModel, error) {
 	err := utils.CopyStructFields(dst, pb)
 	return dst, err
 }
-func (db *DBGroup) Convert() (*sdk.GroupInfo, error) {
+func (db *DBGroup) Convert(ctx context.Context) (*sdk.GroupInfo, error) {
 	dst := &sdk.GroupInfo{}
 	utils.CopyStructFields(dst, db)
-	user, err := getGroupOwnerInfo(db.GroupID)
+	user, err := db.groupCheck.GetOwnerInfo(ctx, db.GroupID)
 	if err != nil {
 		return nil, err
 	}
 	dst.OwnerUserID = user.UserID
 
-	memberCount, err := getNumberOfGroupMember(db.GroupID)
+	g, err := db.groupCheck.GetGroupInfo(ctx, db.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	dst.MemberCount = uint32(memberCount)
+	dst.MemberCount = g.MemberCount
 	dst.CreateTime = db.CreateTime.Unix()
 	dst.NotificationUpdateTime = db.NotificationUpdateTime.Unix()
 	if db.NotificationUpdateTime.Unix() < 0 {
@@ -268,6 +296,7 @@ func (db *DBGroup) Convert() (*sdk.GroupInfo, error) {
 
 type DBGroupMember struct {
 	*relation.GroupMemberModel
+	userCheck *check.UserCheck
 }
 
 func (*PBGroupMember) PB2DB(groupMembers []*sdk.GroupMemberFullInfo) (DBGroupMembers []*relation.GroupMemberModel, err error) {
@@ -281,16 +310,16 @@ func (*PBGroupMember) PB2DB(groupMembers []*sdk.GroupMemberFullInfo) (DBGroupMem
 	return
 }
 
-func (*DBGroupMember) DB2PB(groupMembers []*relation.GroupMemberModel) (PBGroupMembers []*sdk.GroupMemberFullInfo, err error) {
-	for _, v := range groupMembers {
-		u, err := NewDBGroupMember(v).Convert()
-		if err != nil {
-			return nil, err
-		}
-		PBGroupMembers = append(PBGroupMembers, u)
-	}
-	return
-}
+//func (*DBGroupMember) DB2PB(ctx context.Context, groupMembers []*relation.GroupMemberModel) (PBGroupMembers []*sdk.GroupMemberFullInfo, err error) {
+//	for _, v := range groupMembers {
+//		u, err := NewDBGroupMember(v).Convert(ctx)
+//		if err != nil {
+//			return nil, err
+//		}
+//		PBGroupMembers = append(PBGroupMembers, u)
+//	}
+//	return
+//}
 
 func NewDBGroupMember(groupMember *relation.GroupMemberModel) *DBGroupMember {
 	return &DBGroupMember{GroupMemberModel: groupMember}
@@ -311,15 +340,15 @@ func (pb *PBGroupMember) Convert() (*relation.GroupMemberModel, error) {
 	dst.MuteEndTime = utils.UnixSecondToTime(int64(pb.MuteEndTime))
 	return dst, nil
 }
-func (db *DBGroupMember) Convert() (*sdk.GroupMemberFullInfo, error) {
+func (db *DBGroupMember) Convert(ctx context.Context) (*sdk.GroupMemberFullInfo, error) {
 	dst := &sdk.GroupMemberFullInfo{}
 	utils.CopyStructFields(dst, db)
 
-	user, err := getUsersInfo([]string{db.UserID})
+	user, err := db.userCheck.GetUsersInfo(ctx, db.UserID)
 	if err != nil {
 		return nil, err
 	}
-	dst.AppMangerLevel = user[0].AppMangerLevel
+	dst.AppMangerLevel = user.AppMangerLevel
 
 	dst.JoinTime = db.JoinTime.Unix()
 	if db.JoinTime.Unix() < 0 {
@@ -347,16 +376,16 @@ func (*PBGroupRequest) PB2DB(groupRequests []*sdk.GroupRequest) (DBGroupRequests
 	return
 }
 
-func (*DBGroupRequest) DB2PB(groupRequests []*relation.GroupRequestModel) (PBGroupRequests []*sdk.GroupRequest, err error) {
-	for _, v := range groupRequests {
-		u, err := NewDBGroupRequest(v).Convert()
-		if err != nil {
-			return nil, err
-		}
-		PBGroupRequests = append(PBGroupRequests, u)
-	}
-	return
-}
+//func (*DBGroupRequest) DB2PB(groupRequests []*relation.GroupRequestModel) (PBGroupRequests []*sdk.GroupRequest, err error) {
+//	for _, v := range groupRequests {
+//		u, err := NewDBGroupRequest(v).Convert()
+//		if err != nil {
+//			return nil, err
+//		}
+//		PBGroupRequests = append(PBGroupRequests, u)
+//	}
+//	return
+//}
 
 func NewDBGroupRequest(groupRequest *relation.GroupRequestModel) *DBGroupRequest {
 	return &DBGroupRequest{GroupRequestModel: groupRequest}

internal/common/notification/c.go

@@ -0,0 +1,305 @@
+package notification
+
+import (
+	"Open_IM/internal/common/check"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/tracelog"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	"Open_IM/pkg/proto/msg"
+	"Open_IM/pkg/proto/sdkws"
+	utils2 "Open_IM/pkg/utils"
+	"context"
+	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) {
+	var err error
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils2.GetFuncName(1), err, "notificationMsg", notificationMsg)
+	}()
+
+	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)
+}

internal/common/notification/conversation.go

@@ -1,22 +1,18 @@
-package msg
+package notification
 
 import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
 	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
 	"context"
 	"github.com/golang/protobuf/jsonpb"
 	"github.com/golang/protobuf/proto"
 )
 
-func SetConversationNotification(operationID, sendID, recvID string, contentType int, m proto.Message, tips sdkws.TipsComm) {
-	log.NewInfo(operationID, "args: ", sendID, recvID, contentType, m.String(), tips.String())
+func (c *Check) 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 {
-		log.NewError(operationID, "Marshal failed ", err.Error(), m.String())
 		return
 	}
 	marshaler := jsonpb.Marshaler{
@@ -31,18 +27,16 @@ func SetConversationNotification(operationID, sendID, recvID string, contentType
 	n.ContentType = int32(contentType)
 	n.SessionType = constant.SingleChatType
 	n.MsgFrom = constant.SysMsgType
-	n.OperationID = operationID
 	n.Content, err = proto.Marshal(&tips)
 	if err != nil {
-		log.Error(operationID, utils.GetSelfFuncName(), "Marshal failed ", err.Error(), tips.String())
 		return
 	}
-	Notification(&n)
+	c.Notification(ctx, &n)
 }
 
 // SetPrivate调用
-func ConversationSetPrivateNotification(operationID, sendID, recvID string, isPrivateChat bool) {
-	log.NewInfo(operationID, utils.GetSelfFuncName())
+func (c *Check) ConversationSetPrivateNotification(ctx context.Context, sendID, recvID string, isPrivateChat bool) {
+
 	conversationSetPrivateTips := &sdkws.ConversationSetPrivateTips{
 		RecvID:    recvID,
 		SendID:    sendID,
@@ -56,23 +50,23 @@ func ConversationSetPrivateNotification(operationID, sendID, recvID string, isPr
 		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.CloseTips
 	}
 	tips.DefaultTips = tipsMsg
-	SetConversationNotification(operationID, sendID, recvID, constant.ConversationPrivateChatNotification, conversationSetPrivateTips, tips)
+	c.SetConversationNotification(ctx, sendID, recvID, constant.ConversationPrivateChatNotification, conversationSetPrivateTips, tips)
 }
 
 // 会话改变
-func ConversationChangeNotification(ctx context.Context, userID string) {
-	log.NewInfo(operationID, utils.GetSelfFuncName())
+func (c *Check) ConversationChangeNotification(ctx context.Context, userID string) {
+
 	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(ctx, userID, userID, constant.ConversationOptChangeNotification, ConversationChangedTips, tips)
 }
 
-//会话未读数同步
-func ConversationUnreadChangeNotification(operationID, userID, conversationID string, updateUnreadCountTime int64) {
-	log.NewInfo(operationID, utils.GetSelfFuncName())
+// 会话未读数同步
+func (c *Check) ConversationUnreadChangeNotification(ctx context.Context, userID, conversationID string, updateUnreadCountTime int64) {
+
 	ConversationChangedTips := &sdkws.ConversationUpdateTips{
 		UserID:                userID,
 		ConversationIDList:    []string{conversationID},
@@ -80,5 +74,5 @@ func ConversationUnreadChangeNotification(operationID, userID, conversationID st
 	}
 	var tips sdkws.TipsComm
 	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
-	SetConversationNotification(operationID, userID, userID, constant.ConversationUnreadNotification, ConversationChangedTips, tips)
+	c.SetConversationNotification(ctx, userID, userID, constant.ConversationUnreadNotification, ConversationChangedTips, tips)
 }

internal/common/notification/extend_msg.go

@@ -1,18 +1,16 @@
-package msg
+package notification
 
 import (
-	"Open_IM/pkg/api_struct"
-	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/apistruct"
 	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/getcdv3"
+	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/proto/msg"
 	sdkws "Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
 )
 
-func ExtendMessageUpdatedNotification(operationID, sendID string, sourceID string, sessionType int32,
+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
@@ -25,7 +23,6 @@ func ExtendMessageUpdatedNotification(operationID, sendID string, sourceID strin
 		}
 	}
 	if len(keyMap) == 0 {
-		log.NewWarn(operationID, "all key set failed can not send notification", *req)
 		return
 	}
 	m.SuccessReactionExtensionList = keyMap
@@ -33,9 +30,9 @@ func ExtendMessageUpdatedNotification(operationID, sendID string, sourceID strin
 	m.IsReact = resp.IsReact
 	m.IsExternalExtensions = req.IsExternalExtensions
 	m.MsgFirstModifyTime = resp.MsgFirstModifyTime
-	messageReactionSender(operationID, sendID, sourceID, sessionType, constant.ReactionMessageModifier, utils.StructToJsonString(m), isHistory, isReactionFromCache)
+	c.messageReactionSender(ctx, sendID, sourceID, sessionType, constant.ReactionMessageModifier, utils.StructToJsonString(m), isHistory, isReactionFromCache)
 }
-func ExtendMessageDeleteNotification(operationID, sendID string, sourceID string, sessionType int32,
+func (c *Check) ExtendMessageDeleteNotification(ctx context.Context, sendID string, sourceID string, sessionType int32,
 	req *msg.DeleteMessageListReactionExtensionsReq, resp *msg.DeleteMessageListReactionExtensionsResp, isHistory bool, isReactionFromCache bool) {
 	var m apistruct.ReactionMessageDeleteNotification
 	m.SourceID = req.SourceID
@@ -48,16 +45,20 @@ func ExtendMessageDeleteNotification(operationID, sendID string, sourceID string
 		}
 	}
 	if len(keyMap) == 0 {
-		log.NewWarn(operationID, "all key set failed can not send notification", *req)
 		return
 	}
 	m.SuccessReactionExtensionList = keyMap
 	m.ClientMsgID = req.ClientMsgID
 	m.MsgFirstModifyTime = req.MsgFirstModifyTime
 
-	messageReactionSender(operationID, sendID, sourceID, sessionType, constant.ReactionMessageDeleter, utils.StructToJsonString(m), isHistory, isReactionFromCache)
+	c.messageReactionSender(ctx, sendID, sourceID, sessionType, constant.ReactionMessageDeleter, utils.StructToJsonString(m), isHistory, isReactionFromCache)
 }
-func messageReactionSender(operationID, sendID string, sourceID string, sessionType, contentType int32, content string, isHistory bool, isReactionFromCache bool) {
+func (c *Check) messageReactionSender(ctx context.Context, sendID string, sourceID string, sessionType, contentType int32, content string, isHistory bool, isReactionFromCache bool) {
+	var err error
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "sendID", sendID, "sourceID", sourceID, "sessionType", sessionType)
+	}()
+
 	options := make(map[string]bool, 5)
 	utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false)
 	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, false)
@@ -69,7 +70,6 @@ func messageReactionSender(operationID, sendID string, sourceID string, sessionT
 		utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
 	}
 	pbData := msg.SendMsgReq{
-		OperationID: operationID,
 		MsgData: &sdkws.MsgData{
 			SendID:      sendID,
 			ClientMsgID: utils.GetMsgID(sendID),
@@ -77,9 +77,8 @@ func messageReactionSender(operationID, sendID string, sourceID string, sessionT
 			MsgFrom:     constant.SysMsgType,
 			ContentType: contentType,
 			Content:     []byte(content),
-			//	ForceList:        params.ForceList,
-			CreateTime: utils.GetCurrentTimestampByMill(),
-			Options:    options,
+			CreateTime:  utils.GetCurrentTimestampByMill(),
+			Options:     options,
 		},
 	}
 	switch sessionType {
@@ -88,15 +87,5 @@ func messageReactionSender(operationID, sendID string, sourceID string, sessionT
 	case constant.GroupChatType, constant.SuperGroupChatType:
 		pbData.MsgData.GroupID = sourceID
 	}
-	etcdConn, err := rpc.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImMsgName)
-	if err != nil {
-		return
-	}
-	client := msg.NewMsgClient(etcdConn)
-	reply, err := client.SendMsg(context.Background(), &pbData)
-	if err != nil {
-		log.NewError(operationID, "SendMsg rpc failed, ", pbData.String(), err.Error())
-	} else if reply.ErrCode != 0 {
-		log.NewError(operationID, "SendMsg rpc failed, ", pbData.String(), reply.ErrCode, reply.ErrMsg)
-	}
+	_, err = c.msg.SendMsg(ctx, &pbData)
 }

internal/common/notification/friend.go

@@ -1,38 +1,28 @@
-package msg
+package notification
 
 import (
-	"Open_IM/internal/common/check"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tracelog"
 	pbFriend "Open_IM/pkg/proto/friend"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
+	"Open_IM/pkg/proto/sdkws"
 	"context"
 	"github.com/golang/protobuf/jsonpb"
 	"github.com/golang/protobuf/proto"
 )
 
-func getFromToUserNickname(fromUserID, toUserID string) (string, string, error) {
-	users, err := check.GetUsersInfo(context.Background(), fromUserID, toUserID)
+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
 	}
-	if users[0].UserID == fromUserID {
-		return users[0].Nickname, users[1].Nickname, nil
-	}
-	return users[1].Nickname, users[0].Nickname, nil
-
+	return users[fromUserID].Nickname, users[toUserID].Nickname, nil
 }
 
-func friendNotification(operationID, fromUserID, toUserID string, contentType int32, m proto.Message) {
-	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType)
+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 {
-		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
 		return
 	}
 
@@ -44,9 +34,8 @@ func friendNotification(operationID, fromUserID, toUserID string, contentType in
 
 	tips.JsonDetail, _ = marshaler.MarshalToString(m)
 
-	fromUserNickname, toUserNickname, err := getFromToUserNickname(fromUserID, toUserID)
+	fromUserNickname, toUserNickname, err := c.getFromToUserNickname(ctx, fromUserID, toUserID)
 	if err != nil {
-		log.Error(operationID, "getFromToUserNickname failed ", err.Error(), fromUserID, toUserID)
 		return
 	}
 	cn := config.Config.Notification
@@ -72,7 +61,6 @@ func friendNotification(operationID, fromUserID, toUserID string, contentType in
 	case constant.FriendInfoUpdatedNotification:
 		tips.DefaultTips = cn.FriendInfoUpdated.DefaultTips.Tips + toUserNickname
 	default:
-		log.Error(operationID, "contentType failed ", contentType)
 		return
 	}
 
@@ -82,41 +70,39 @@ func friendNotification(operationID, fromUserID, toUserID string, contentType in
 	n.ContentType = contentType
 	n.SessionType = constant.SingleChatType
 	n.MsgFrom = constant.SysMsgType
-	n.OperationID = operationID
 	n.Content, err = proto.Marshal(&tips)
 	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
 		return
 	}
-	Notification(&n)
+	c.Notification(ctx, &n)
 }
 
-func FriendApplicationAddNotification(ctx context.Context, req *pbFriend.AddFriendReq) {
+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)
+	c.friendNotification(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
 	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
-	friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
+	c.friendNotification(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
 	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
-	friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
+	c.friendNotification(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.GetUsersInfo(context.Background(), opUserID)
+	user, err := c.user.GetUsersInfos(ctx, []string{opUserID}, true)
 	if err != nil {
 		return
 	}
@@ -125,49 +111,43 @@ func FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUse
 	friendAddedTips.OpUser.Nickname = user[0].Nickname
 	friendAddedTips.OpUser.FaceURL = user[0].FaceURL
 
-	friend, err := check.GetFriendsInfo(ctx, fromUserID, toUserID)
+	friend, err := c.friend.GetFriendsInfo(ctx, fromUserID, toUserID)
 	if err != nil {
 		return
 	}
 	friendAddedTips.Friend = friend
-	friendNotification(operationID, fromUserID, toUserID, constant.FriendAddedNotification, &friendAddedTips)
+	c.friendNotification(ctx, 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)
+	c.friendNotification(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)
+	c.friendNotification(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)
+	c.friendNotification(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
-	friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackDeletedNotification, &blackDeletedTips)
+	c.friendNotification(ctx, req.OwnerUserID, req.BlackUserID, constant.BlackDeletedNotification, &blackDeletedTips)
 }
 
-// send to myself
-func UserInfoUpdatedNotification(ctx context.Context, opUserID string, changedUserID string) {
+func (c *Check) FriendInfoUpdatedNotification(ctx context.Context, changedUserID string, needNotifiedUserID string, opUserID string) {
 	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
-	friendNotification(tracelog.GetOperationID(ctx), opUserID, changedUserID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
-}
-
-func FriendInfoUpdatedNotification(ctx context.Context, changedUserID string, needNotifiedUserID string, opUserID string) {
-	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
-	friendNotification(tracelog.GetOperationID(ctx), opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
+	c.friendNotification(ctx, opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
 }

internal/common/notification/group.go

@@ -0,0 +1,548 @@
+package notification
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/tokenverify"
+	"Open_IM/pkg/common/tracelog"
+	pbGroup "Open_IM/pkg/proto/group"
+	"Open_IM/pkg/proto/sdkws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+)
+
+func (c *Check) setOpUserInfo(ctx context.Context, groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
+	opUserID := tracelog.GetOpUserID(ctx)
+	if tokenverify.IsManagerUserID(opUserID) {
+		user, err := c.user.GetUsersInfos(ctx, []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
+	}
+	u, err := c.group.GetGroupMemberInfo(ctx, groupID, opUserID)
+	if err == nil {
+		*groupMemberInfo = *u
+		return nil
+	}
+	user, err := c.user.GetUsersInfos(ctx, []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 (c *Check) setGroupInfo(ctx context.Context, groupID string, groupInfo *sdkws.GroupInfo) error {
+	group, err := c.group.GetGroupInfos(ctx, []string{groupID}, true)
+	if err != nil {
+		return err
+	}
+	*groupInfo = *group[0]
+	return nil
+}
+
+func (c *Check) setGroupMemberInfo(ctx context.Context, groupID, userID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
+	groupMember, err := c.group.GetGroupMemberInfo(ctx, groupID, userID)
+	if err == nil {
+		*groupMemberInfo = *groupMember
+		return nil
+	}
+	user, err := c.user.GetUsersInfos(ctx, []string{userID}, 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 (c *Check) setGroupOwnerInfo(ctx context.Context, groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
+	group, err := c.group.GetGroupInfo(ctx, groupID)
+	if err != nil {
+		return err
+	}
+	groupMember, err := c.group.GetGroupMemberInfo(ctx, groupID, group.OwnerUserID)
+	if err != nil {
+		return err
+	}
+	*groupMemberInfo = *groupMember
+	return nil
+}
+
+func (c *Check) setPublicUserInfo(ctx context.Context, userID string, publicUserInfo *sdkws.PublicUserInfo) error {
+	user, err := c.user.GetPublicUserInfos(ctx, []string{userID}, true)
+	if err != nil {
+		return err
+	}
+	*publicUserInfo = *user[0]
+	return nil
+}
+
+func (c *Check) groupNotification(ctx context.Context, contentType int32, m proto.Message, sendID, groupID, recvUserID string) {
+	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 nickname, toNickname string
+	if sendID != "" {
+
+		from, err := c.user.GetUsersInfos(ctx, []string{sendID}, true)
+		if err != nil {
+			return
+		}
+		nickname = from[0].Nickname
+	}
+	if recvUserID != "" {
+		to, err := c.user.GetUsersInfos(ctx, []string{recvUserID}, true)
+		if err != nil {
+			return
+		}
+		toNickname = to[0].Nickname
+	}
+
+	cn := config.Config.Notification
+	switch contentType {
+	case constant.GroupCreatedNotification:
+		tips.DefaultTips = nickname + " " + cn.GroupCreated.DefaultTips.Tips
+	case constant.GroupInfoSetNotification:
+		tips.DefaultTips = nickname + " " + cn.GroupInfoSet.DefaultTips.Tips
+	case constant.JoinGroupApplicationNotification:
+		tips.DefaultTips = nickname + " " + cn.JoinGroupApplication.DefaultTips.Tips
+	case constant.MemberQuitNotification:
+		tips.DefaultTips = nickname + " " + cn.MemberQuit.DefaultTips.Tips
+	case constant.GroupApplicationAcceptedNotification: //
+		tips.DefaultTips = toNickname + " " + cn.GroupApplicationAccepted.DefaultTips.Tips
+	case constant.GroupApplicationRejectedNotification: //
+		tips.DefaultTips = toNickname + " " + cn.GroupApplicationRejected.DefaultTips.Tips
+	case constant.GroupOwnerTransferredNotification: //
+		tips.DefaultTips = toNickname + " " + cn.GroupOwnerTransferred.DefaultTips.Tips
+	case constant.MemberKickedNotification: //
+		tips.DefaultTips = toNickname + " " + cn.MemberKicked.DefaultTips.Tips
+	case constant.MemberInvitedNotification: //
+		tips.DefaultTips = toNickname + " " + cn.MemberInvited.DefaultTips.Tips
+	case constant.MemberEnterNotification:
+		tips.DefaultTips = toNickname + " " + cn.MemberEnter.DefaultTips.Tips
+	case constant.GroupDismissedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupDismissed.DefaultTips.Tips
+	case constant.GroupMutedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMuted.DefaultTips.Tips
+	case constant.GroupCancelMutedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupCancelMuted.DefaultTips.Tips
+	case constant.GroupMemberMutedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberMuted.DefaultTips.Tips
+	case constant.GroupMemberCancelMutedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberCancelMuted.DefaultTips.Tips
+	case constant.GroupMemberInfoSetNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberInfoSet.DefaultTips.Tips
+	case constant.GroupMemberSetToAdminNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToAdmin.DefaultTips.Tips
+	case constant.GroupMemberSetToOrdinaryUserNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToOrdinary.DefaultTips.Tips
+	default:
+		return
+	}
+
+	var n NotificationMsg
+	n.SendID = sendID
+	if groupID != "" {
+		n.RecvID = groupID
+
+		group, err := c.group.GetGroupInfo(ctx, groupID)
+		if err != nil {
+			return
+		}
+		switch group.GroupType {
+		case constant.NormalGroup:
+			n.SessionType = constant.GroupChatType
+		default:
+			n.SessionType = constant.SuperGroupChatType
+		}
+	} else {
+		n.RecvID = recvUserID
+		n.SessionType = constant.SingleChatType
+	}
+	n.ContentType = contentType
+	n.Content, err = proto.Marshal(&tips)
+	if err != nil {
+		return
+	}
+	c.Notification(ctx, &n)
+}
+
+// 创建群后调用
+func (c *Check) GroupCreatedNotification(ctx context.Context, groupID string, initMemberList []string) {
+	GroupCreatedTips := sdkws.GroupCreatedTips{Group: &sdkws.GroupInfo{},
+		OpUser: &sdkws.GroupMemberFullInfo{}, GroupOwnerUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setOpUserInfo(ctx, groupID, GroupCreatedTips.OpUser); err != nil {
+		return
+	}
+	err := c.setGroupInfo(ctx, groupID, GroupCreatedTips.Group)
+	if err != nil {
+		return
+	}
+
+	if err := c.setGroupOwnerInfo(ctx, groupID, GroupCreatedTips.GroupOwnerUser); err != nil {
+		return
+	}
+	for _, v := range initMemberList {
+		var groupMemberInfo sdkws.GroupMemberFullInfo
+		if err := c.setGroupMemberInfo(ctx, groupID, v, &groupMemberInfo); err != nil {
+			continue
+		}
+		GroupCreatedTips.MemberList = append(GroupCreatedTips.MemberList, &groupMemberInfo)
+		if len(GroupCreatedTips.MemberList) == constant.MaxNotificationNum {
+			break
+		}
+	}
+
+	c.groupNotification(ctx, constant.GroupCreatedNotification, &GroupCreatedTips, tracelog.GetOpUserID(ctx), groupID, "")
+}
+
+// 群信息改变后掉用
+// groupName := ""
+//
+//	notification := ""
+//	introduction := ""
+//	faceURL := ""
+func (c *Check) GroupInfoSetNotification(ctx context.Context, groupID string, groupName, notification, introduction, faceURL string, needVerification *wrapperspb.Int32Value) {
+	GroupInfoChangedTips := sdkws.GroupInfoSetTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, groupID, GroupInfoChangedTips.Group); err != nil {
+		return
+	}
+	GroupInfoChangedTips.Group.GroupName = groupName
+	GroupInfoChangedTips.Group.Notification = notification
+	GroupInfoChangedTips.Group.Introduction = introduction
+	GroupInfoChangedTips.Group.FaceURL = faceURL
+	if needVerification != nil {
+		GroupInfoChangedTips.Group.NeedVerification = needVerification.Value
+	}
+
+	if err := c.setOpUserInfo(ctx, groupID, GroupInfoChangedTips.OpUser); err != nil {
+		return
+	}
+	c.groupNotification(ctx, constant.GroupInfoSetNotification, &GroupInfoChangedTips, tracelog.GetOpUserID(ctx), groupID, "")
+}
+
+func (c *Check) GroupMutedNotification(ctx context.Context, groupID string) {
+	tips := sdkws.GroupMutedTips{Group: &sdkws.GroupInfo{},
+		OpUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, groupID, tips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, groupID, tips.OpUser); err != nil {
+		return
+	}
+	c.groupNotification(ctx, constant.GroupMutedNotification, &tips, tracelog.GetOpUserID(ctx), groupID, "")
+}
+
+func (c *Check) GroupCancelMutedNotification(ctx context.Context, groupID string) {
+	tips := sdkws.GroupCancelMutedTips{Group: &sdkws.GroupInfo{},
+		OpUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, groupID, tips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, groupID, tips.OpUser); err != nil {
+		return
+	}
+	c.groupNotification(ctx, constant.GroupCancelMutedNotification, &tips, tracelog.GetOpUserID(ctx), groupID, "")
+}
+
+func (c *Check) GroupMemberMutedNotification(ctx context.Context, groupID, groupMemberUserID string, mutedSeconds uint32) {
+	tips := sdkws.GroupMemberMutedTips{Group: &sdkws.GroupInfo{},
+		OpUser: &sdkws.GroupMemberFullInfo{}, MutedUser: &sdkws.GroupMemberFullInfo{}}
+	tips.MutedSeconds = mutedSeconds
+	if err := c.setGroupInfo(ctx, groupID, tips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, groupID, tips.OpUser); err != nil {
+		return
+	}
+	if err := c.setGroupMemberInfo(ctx, groupID, groupMemberUserID, tips.MutedUser); err != nil {
+		return
+	}
+	c.groupNotification(ctx, constant.GroupMemberMutedNotification, &tips, tracelog.GetOpUserID(ctx), groupID, "")
+}
+
+func (c *Check) GroupMemberInfoSetNotification(ctx context.Context, groupID, groupMemberUserID string) {
+	tips := sdkws.GroupMemberInfoSetTips{Group: &sdkws.GroupInfo{},
+		OpUser: &sdkws.GroupMemberFullInfo{}, ChangedUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, groupID, tips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, groupID, tips.OpUser); err != nil {
+		return
+	}
+	if err := c.setGroupMemberInfo(ctx, groupID, groupMemberUserID, tips.ChangedUser); err != nil {
+		return
+	}
+	c.groupNotification(ctx, constant.GroupMemberInfoSetNotification, &tips, tracelog.GetOpUserID(ctx), groupID, "")
+}
+
+func (c *Check) GroupMemberRoleLevelChangeNotification(ctx context.Context, 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 := c.setGroupInfo(ctx, groupID, tips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	if err := c.setOpUserInfo(ctx, groupID, tips.OpUser); err != nil {
+		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
+		return
+	}
+	if err := c.setGroupMemberInfo(ctx, groupID, groupMemberUserID, tips.ChangedUser); err != nil {
+		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
+		return
+	}
+	c.groupNotification(ctx, notificationType, &tips, tracelog.GetOpUserID(ctx), groupID, "")
+}
+
+func (c *Check) GroupMemberCancelMutedNotification(ctx context.Context, groupID, groupMemberUserID string) {
+	tips := sdkws.GroupMemberCancelMutedTips{Group: &sdkws.GroupInfo{},
+		OpUser: &sdkws.GroupMemberFullInfo{}, MutedUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, groupID, tips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, groupID, tips.OpUser); err != nil {
+		return
+	}
+	if err := c.setGroupMemberInfo(ctx, groupID, groupMemberUserID, tips.MutedUser); err != nil {
+		return
+	}
+	c.groupNotification(ctx, constant.GroupMemberCancelMutedNotification, &tips, tracelog.GetOpUserID(ctx), groupID, "")
+}
+
+//	message ReceiveJoinApplicationTips{
+//	 GroupInfo Group = 1;
+//	 PublicUserInfo Applicant  = 2;
+//	 string 	Reason = 3;
+//	}  apply->all managers GroupID              string   `protobuf:"bytes,1,opt,name=GroupID" json:"GroupID,omitempty"`
+//
+//	ReqMessage           string   `protobuf:"bytes,2,opt,name=ReqMessage" json:"ReqMessage,omitempty"`
+//	OpUserID             string   `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"`
+//	OperationID          string   `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"`
+//
+// 申请进群后调用
+func (c *Check) JoinGroupApplicationNotification(ctx context.Context, req *pbGroup.JoinGroupReq) {
+	JoinGroupApplicationTips := sdkws.JoinGroupApplicationTips{Group: &sdkws.GroupInfo{}, Applicant: &sdkws.PublicUserInfo{}}
+	err := c.setGroupInfo(ctx, req.GroupID, JoinGroupApplicationTips.Group)
+	if err != nil {
+
+		return
+	}
+	if err = c.setPublicUserInfo(ctx, tracelog.GetOpUserID(ctx), JoinGroupApplicationTips.Applicant); err != nil {
+
+		return
+	}
+	JoinGroupApplicationTips.ReqMsg = req.ReqMessage
+	managerList, err := c.group.GetOwnerAndAdminInfos(ctx, req.GroupID)
+	if err != nil {
+		return
+	}
+	for _, v := range managerList {
+		c.groupNotification(ctx, constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, tracelog.GetOpUserID(ctx), "", v.UserID)
+	}
+}
+
+func (c *Check) MemberQuitNotification(ctx context.Context, req *pbGroup.QuitGroupReq) {
+	MemberQuitTips := sdkws.MemberQuitTips{Group: &sdkws.GroupInfo{}, QuitUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, req.GroupID, MemberQuitTips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, req.GroupID, MemberQuitTips.QuitUser); err != nil {
+		return
+	}
+
+	c.groupNotification(ctx, constant.MemberQuitNotification, &MemberQuitTips, tracelog.GetOpUserID(ctx), req.GroupID, "")
+}
+
+//	message ApplicationProcessedTips{
+//	 GroupInfo Group = 1;
+//	 GroupMemberFullInfo OpUser = 2;
+//	 int32 Result = 3;
+//	 string 	Reason = 4;
+//	}
+//
+// 处理进群请求后调用
+func (c *Check) GroupApplicationAcceptedNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) {
+	GroupApplicationAcceptedTips := sdkws.GroupApplicationAcceptedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
+	if err := c.setGroupInfo(ctx, req.GroupID, GroupApplicationAcceptedTips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, req.GroupID, GroupApplicationAcceptedTips.OpUser); err != nil {
+		return
+	}
+
+	c.groupNotification(ctx, constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, tracelog.GetOpUserID(ctx), "", req.FromUserID)
+	adminList, err := c.group.GetOwnerAndAdminInfos(ctx, req.GroupID)
+	if err != nil {
+		return
+	}
+	for _, v := range adminList {
+		if v.UserID == tracelog.GetOpUserID(ctx) {
+			continue
+		}
+		GroupApplicationAcceptedTips.ReceiverAs = 1
+		c.groupNotification(ctx, constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, tracelog.GetOpUserID(ctx), "", v.UserID)
+	}
+}
+
+func (c *Check) GroupApplicationRejectedNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) {
+	GroupApplicationRejectedTips := sdkws.GroupApplicationRejectedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
+	if err := c.setGroupInfo(ctx, req.GroupID, GroupApplicationRejectedTips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, req.GroupID, GroupApplicationRejectedTips.OpUser); err != nil {
+		return
+	}
+	c.groupNotification(ctx, constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, tracelog.GetOpUserID(ctx), "", req.FromUserID)
+	adminList, err := c.group.GetOwnerAndAdminInfos(ctx, req.GroupID)
+	if err != nil {
+		return
+	}
+	for _, v := range adminList {
+		if v.UserID == tracelog.GetOpUserID(ctx) {
+			continue
+		}
+		GroupApplicationRejectedTips.ReceiverAs = 1
+		c.groupNotification(ctx, constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, tracelog.GetOpUserID(ctx), "", v.UserID)
+	}
+}
+
+func (c *Check) GroupOwnerTransferredNotification(ctx context.Context, req *pbGroup.TransferGroupOwnerReq) {
+	GroupOwnerTransferredTips := sdkws.GroupOwnerTransferredTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, NewGroupOwner: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, req.GroupID, GroupOwnerTransferredTips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, req.GroupID, GroupOwnerTransferredTips.OpUser); err != nil {
+		return
+	}
+	if err := c.setGroupMemberInfo(ctx, req.GroupID, req.NewOwnerUserID, GroupOwnerTransferredTips.NewGroupOwner); err != nil {
+		return
+	}
+	c.groupNotification(ctx, constant.GroupOwnerTransferredNotification, &GroupOwnerTransferredTips, tracelog.GetOpUserID(ctx), req.GroupID, "")
+}
+
+func (c *Check) GroupDismissedNotification(ctx context.Context, req *pbGroup.DismissGroupReq) {
+	tips := sdkws.GroupDismissedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, req.GroupID, tips.Group); err != nil {
+
+		return
+	}
+	if err := c.setOpUserInfo(ctx, req.GroupID, tips.OpUser); err != nil {
+
+		return
+	}
+	c.groupNotification(ctx, constant.GroupDismissedNotification, &tips, tracelog.GetOpUserID(ctx), req.GroupID, "")
+}
+
+//	message MemberKickedTips{
+//	 GroupInfo Group = 1;
+//	 GroupMemberFullInfo OpUser = 2;
+//	 GroupMemberFullInfo KickedUser = 3;
+//	 uint64 OperationTime = 4;
+//	}
+//
+// 被踢后调用
+func (c *Check) MemberKickedNotification(ctx context.Context, req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
+	MemberKickedTips := sdkws.MemberKickedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, req.GroupID, MemberKickedTips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, req.GroupID, MemberKickedTips.OpUser); err != nil {
+		return
+	}
+	for _, v := range kickedUserIDList {
+		var groupMemberInfo sdkws.GroupMemberFullInfo
+		if err := c.setGroupMemberInfo(ctx, req.GroupID, v, &groupMemberInfo); err != nil {
+			continue
+		}
+		MemberKickedTips.KickedUserList = append(MemberKickedTips.KickedUserList, &groupMemberInfo)
+	}
+	c.groupNotification(ctx, constant.MemberKickedNotification, &MemberKickedTips, tracelog.GetOpUserID(ctx), req.GroupID, "")
+	//
+	//for _, v := range kickedUserIDList {
+	//	groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, "", v, req.OperationID)
+	//}
+}
+
+//	message MemberInvitedTips{
+//	 GroupInfo Group = 1;
+//	 GroupMemberFullInfo OpUser = 2;
+//	 GroupMemberFullInfo InvitedUser = 3;
+//	 uint64 OperationTime = 4;
+//	}
+//
+// 被邀请进群后调用
+func (c *Check) MemberInvitedNotification(ctx context.Context, groupID, reason string, invitedUserIDList []string) {
+	MemberInvitedTips := sdkws.MemberInvitedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, groupID, MemberInvitedTips.Group); err != nil {
+		return
+	}
+	if err := c.setOpUserInfo(ctx, groupID, MemberInvitedTips.OpUser); err != nil {
+
+		return
+	}
+	for _, v := range invitedUserIDList {
+		var groupMemberInfo sdkws.GroupMemberFullInfo
+		if err := c.setGroupMemberInfo(ctx, groupID, v, &groupMemberInfo); err != nil {
+			continue
+		}
+		MemberInvitedTips.InvitedUserList = append(MemberInvitedTips.InvitedUserList, &groupMemberInfo)
+	}
+	c.groupNotification(ctx, constant.MemberInvitedNotification, &MemberInvitedTips, tracelog.GetOpUserID(ctx), groupID, "")
+}
+
+// 群成员主动申请进群，管理员同意后调用，
+func (c *Check) MemberEnterNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) {
+	MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, req.GroupID, MemberEnterTips.Group); err != nil {
+		return
+	}
+	if err := c.setGroupMemberInfo(ctx, req.GroupID, req.FromUserID, MemberEnterTips.EntrantUser); err != nil {
+		return
+	}
+	c.groupNotification(ctx, constant.MemberEnterNotification, &MemberEnterTips, tracelog.GetOpUserID(ctx), req.GroupID, "")
+}
+
+func (c *Check) MemberEnterDirectlyNotification(ctx context.Context, groupID string, entrantUserID string, operationID string) {
+	MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}}
+	if err := c.setGroupInfo(ctx, groupID, MemberEnterTips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID, MemberEnterTips.Group)
+		return
+	}
+	if err := c.setGroupMemberInfo(ctx, groupID, entrantUserID, MemberEnterTips.EntrantUser); err != nil {
+		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, entrantUserID, MemberEnterTips.EntrantUser)
+		return
+	}
+	c.groupNotification(ctx, constant.MemberEnterNotification, &MemberEnterTips, entrantUserID, groupID, "")
+}

internal/common/notification/msg.go

@@ -0,0 +1,42 @@
+package notification
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/proto/sdkws"
+	"context"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+)
+
+func (c *Check) DeleteMessageNotification(ctx context.Context, userID string, seqList []uint32, operationID string) {
+	DeleteMessageTips := sdkws.DeleteMessageTips{UserID: userID, SeqList: seqList}
+	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)
+}

internal/common/notification/super_group.go

@@ -1,23 +1,19 @@
-package msg
+package notification
 
 import (
 	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	//sdk "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
+	"context"
 	//"github.com/golang/protobuf/jsonpb"
 	//"github.com/golang/protobuf/proto"
 )
 
-func SuperGroupNotification(operationID, sendID, recvID string) {
+func (c *Check) SuperGroupNotification(ctx context.Context, sendID, recvID string) {
 	n := &NotificationMsg{
 		SendID:      sendID,
 		RecvID:      recvID,
 		MsgFrom:     constant.SysMsgType,
 		ContentType: constant.SuperGroupUpdateNotification,
 		SessionType: constant.SingleChatType,
-		OperationID: operationID,
 	}
-	log.NewInfo(operationID, utils.GetSelfFuncName(), string(n.Content))
-	Notification(n)
+	c.Notification(ctx, n)
 }

internal/common/notification/user.go

@@ -0,0 +1,13 @@
+package notification
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/proto/sdkws"
+	"context"
+)
+
+// 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)
+}

internal/msggateway/callback.go

@@ -1,89 +1,155 @@
 package msggateway
 
 import (
-	cbApi "Open_IM/pkg/callback_struct"
+	cbapi "Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/http"
-	http2 "net/http"
+	"Open_IM/pkg/common/tracelog"
+	"context"
 	"time"
 )
 
-func callbackUserOnline(operationID, userID string, platformID int, token string, isAppBackground bool, connID string) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+func url() string {
+	return config.Config.Callback.CallbackUrl
+}
+
+func CallbackUserOnline(ctx context.Context, userID string, platformID int, isAppBackground bool, connID string) error {
 	if !config.Config.Callback.CallbackUserOnline.Enable {
-		return callbackResp
+		return nil
 	}
-	callbackUserOnlineReq := cbApi.CallbackUserOnlineReq{
-		Token: token,
-		UserStatusCallbackReq: cbApi.UserStatusCallbackReq{
-			UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+	req := cbapi.CallbackUserOnlineReq{
+		UserStatusCallbackReq: cbapi.UserStatusCallbackReq{
+			UserStatusBaseCallback: cbapi.UserStatusBaseCallback{
 				CallbackCommand: constant.CallbackUserOnlineCommand,
-				OperationID:     operationID,
-				PlatformID:      int32(platformID),
+				OperationID:     tracelog.GetOperationID(ctx),
+				PlatformID:      platformID,
 				Platform:        constant.PlatformIDToName(platformID),
 			},
 			UserID: userID,
 		},
-		Seq:             int(time.Now().UnixNano() / 1e6),
+		Seq:             time.Now().UnixMilli(),
 		IsAppBackground: isAppBackground,
 		ConnID:          connID,
 	}
-	callbackUserOnlineResp := &cbApi.CallbackUserOnlineResp{CommonCallbackResp: &callbackResp}
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackUserOnlineCommand, callbackUserOnlineReq, callbackUserOnlineResp, config.Config.Callback.CallbackUserOnline.CallbackTimeOut); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-	}
-	return callbackResp
+	resp := cbapi.CommonCallbackResp{}
+	return http.CallBackPostReturn(url(), &req, &resp, config.Config.Callback.CallbackUserOnline)
 }
 
-func callbackUserOffline(operationID, userID string, platformID int, connID string) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+func CallbackUserOffline(ctx context.Context, userID string, platformID int, connID string) error {
 	if !config.Config.Callback.CallbackUserOffline.Enable {
-		return callbackResp
+		return nil
 	}
-	callbackOfflineReq := cbApi.CallbackUserOfflineReq{
-		UserStatusCallbackReq: cbApi.UserStatusCallbackReq{
-			UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+	req := &cbapi.CallbackUserOfflineReq{
+		UserStatusCallbackReq: cbapi.UserStatusCallbackReq{
+			UserStatusBaseCallback: cbapi.UserStatusBaseCallback{
 				CallbackCommand: constant.CallbackUserOfflineCommand,
-				OperationID:     operationID,
-				PlatformID:      int32(platformID),
+				OperationID:     tracelog.GetOperationID(ctx),
+				PlatformID:      platformID,
 				Platform:        constant.PlatformIDToName(platformID),
 			},
 			UserID: userID,
 		},
-		Seq:    int(time.Now().UnixNano() / 1e6),
+		Seq:    time.Now().UnixMilli(),
 		ConnID: connID,
 	}
-	callbackUserOfflineResp := &cbApi.CallbackUserOfflineResp{CommonCallbackResp: &callbackResp}
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackUserOfflineCommand, callbackOfflineReq, callbackUserOfflineResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-	}
-	return callbackResp
+	resp := &cbapi.CallbackUserOfflineResp{}
+	return http.CallBackPostReturn(url(), req, resp, config.Config.Callback.CallbackUserOffline)
 }
 
-func callbackUserKickOff(operationID string, userID string, platformID int) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+func CallbackUserKickOff(ctx context.Context, userID string, platformID int) error {
 	if !config.Config.Callback.CallbackUserKickOff.Enable {
-		return callbackResp
+		return nil
 	}
-	callbackUserKickOffReq := cbApi.CallbackUserKickOffReq{
-		UserStatusCallbackReq: cbApi.UserStatusCallbackReq{
-			UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+	req := &cbapi.CallbackUserKickOffReq{
+		UserStatusCallbackReq: cbapi.UserStatusCallbackReq{
+			UserStatusBaseCallback: cbapi.UserStatusBaseCallback{
 				CallbackCommand: constant.CallbackUserKickOffCommand,
-				OperationID:     operationID,
-				PlatformID:      int32(platformID),
+				OperationID:     tracelog.GetOperationID(ctx),
+				PlatformID:      platformID,
 				Platform:        constant.PlatformIDToName(platformID),
 			},
 			UserID: userID,
 		},
-		Seq: int(time.Now().UnixNano() / 1e6),
+		Seq: time.Now().UnixMilli(),
 	}
-	callbackUserKickOffResp := &cbApi.CallbackUserKickOffResp{CommonCallbackResp: &callbackResp}
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackUserKickOffCommand, callbackUserKickOffReq, callbackUserKickOffResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-	}
-	return callbackResp
+	resp := &cbapi.CommonCallbackResp{}
+	return http.CallBackPostReturn(url(), req, resp, config.Config.Callback.CallbackUserOffline)
 }
+
+//func callbackUserOnline(operationID, userID string, platformID int, token string, isAppBackground bool, connID string) cbApi.CommonCallbackResp {
+//	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+//	if !config.Config.Callback.CallbackUserOnline.Enable {
+//		return callbackResp
+//	}
+//	callbackUserOnlineReq := cbApi.CallbackUserOnlineReq{
+//		Token: token,
+//		UserStatusCallbackReq: cbApi.UserStatusCallbackReq{
+//			UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+//				CallbackCommand: constant.CallbackUserOnlineCommand,
+//				OperationID:     operationID,
+//				PlatformID:      int32(platformID),
+//				Platform:        constant.PlatformIDToName(platformID),
+//			},
+//			UserID: userID,
+//		},
+//		Seq:             int(time.Now().UnixNano() / 1e6),
+//		IsAppBackground: isAppBackground,
+//		ConnID:          connID,
+//	}
+//	callbackUserOnlineResp := &cbApi.CallbackUserOnlineResp{CommonCallbackResp: &callbackResp}
+//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackUserOnlineCommand, callbackUserOnlineReq, callbackUserOnlineResp, config.Config.Callback.CallbackUserOnline.CallbackTimeOut); err != nil {
+//		callbackResp.ErrCode = http2.StatusInternalServerError
+//		callbackResp.ErrMsg = err.Error()
+//	}
+//	return callbackResp
+//}
+//func callbackUserOffline(operationID, userID string, platformID int, connID string) cbApi.CommonCallbackResp {
+//	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+//	if !config.Config.Callback.CallbackUserOffline.Enable {
+//		return callbackResp
+//	}
+//	callbackOfflineReq := cbApi.CallbackUserOfflineReq{
+//		UserStatusCallbackReq: cbApi.UserStatusCallbackReq{
+//			UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+//				CallbackCommand: constant.CallbackUserOfflineCommand,
+//				OperationID:     operationID,
+//				PlatformID:      int32(platformID),
+//				Platform:        constant.PlatformIDToName(platformID),
+//			},
+//			UserID: userID,
+//		},
+//		Seq:    int(time.Now().UnixNano() / 1e6),
+//		ConnID: connID,
+//	}
+//	callbackUserOfflineResp := &cbApi.CallbackUserOfflineResp{CommonCallbackResp: &callbackResp}
+//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackUserOfflineCommand, callbackOfflineReq, callbackUserOfflineResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil {
+//		callbackResp.ErrCode = http2.StatusInternalServerError
+//		callbackResp.ErrMsg = err.Error()
+//	}
+//	return callbackResp
+//}
+//func callbackUserKickOff(operationID string, userID string, platformID int) cbApi.CommonCallbackResp {
+//	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+//	if !config.Config.Callback.CallbackUserKickOff.Enable {
+//		return callbackResp
+//	}
+//	callbackUserKickOffReq := cbApi.CallbackUserKickOffReq{
+//		UserStatusCallbackReq: cbApi.UserStatusCallbackReq{
+//			UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+//				CallbackCommand: constant.CallbackUserKickOffCommand,
+//				OperationID:     operationID,
+//				PlatformID:      int32(platformID),
+//				Platform:        constant.PlatformIDToName(platformID),
+//			},
+//			UserID: userID,
+//		},
+//		Seq: int(time.Now().UnixNano() / 1e6),
+//	}
+//	callbackUserKickOffResp := &cbApi.CallbackUserKickOffResp{CommonCallbackResp: &callbackResp}
+//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackUserKickOffCommand, callbackUserKickOffReq, callbackUserKickOffResp, config.Config.Callback.CallbackUserOffline.CallbackTimeOut); err != nil {
+//		callbackResp.ErrCode = http2.StatusInternalServerError
+//		callbackResp.ErrMsg = err.Error()
+//	}
+//	return callbackResp
+//}

internal/msggateway/new/client.go

@@ -0,0 +1,148 @@
+package new
+
+import (
+	"Open_IM/pkg/common/constant"
+	promePkg "Open_IM/pkg/common/prometheus"
+	"context"
+	"errors"
+	"fmt"
+	"github.com/envoyproxy/protoc-gen-validate/validate"
+	"github.com/go-playground/validator/v10"
+	"open_im_sdk/pkg/log"
+	"open_im_sdk/pkg/utils"
+	"runtime/debug"
+	"sync"
+)
+
+const (
+	// MessageText is for UTF-8 encoded text messages like JSON.
+	MessageText  = iota + 1
+	// MessageBinary is for binary messages like protobufs.
+	MessageBinary
+	// CloseMessage denotes a close control message. The optional message
+	// payload contains a numeric code and text. Use the FormatCloseMessage
+	// function to format a close message payload.
+	CloseMessage = 8
+
+	// PingMessage denotes a ping control message. The optional message payload
+	// is UTF-8 encoded text.
+	PingMessage = 9
+
+	// PongMessage denotes a pong control message. The optional message payload
+	// is UTF-8 encoded text.
+	PongMessage = 10
+)
+
+type Client struct {
+	w            *sync.Mutex
+	conn         LongConn
+	PlatformID   int32
+	PushedMaxSeq uint32
+	IsCompress   bool
+	userID       string
+	IsBackground bool
+	token        string
+	connID       string
+	onlineAt     int64 // 上线时间戳（毫秒）
+	handler      MessageHandler
+	unregisterChan    chan *Client
+	compressor     Compressor
+	encoder        Encoder
+	userContext   UserConnContext
+	validate            *validator.Validate
+}
+
+func newClient(	conn   LongConn,isCompress bool, userID string, isBackground bool, token string,
+	connID string, onlineAt int64,	handler  MessageHandler,unregisterChan chan *Client) *Client {
+	return &Client{
+		conn: conn,
+		IsCompress: isCompress,
+		userID:     userID, IsBackground:
+		isBackground, token: token,
+		connID:              connID,
+		onlineAt:            onlineAt,
+		handler: handler,
+		unregisterChan:    unregisterChan,
+	}
+}
+func(c *Client) readMessage(){
+	defer func() {
+		if r:=recover(); r != nil {
+			fmt.Println("socket have panic err:", r, string(debug.Stack()))
+		}
+		//c.close()
+	}()
+    var returnErr error
+	for  {
+		 messageType, message, returnErr := c.conn.ReadMessage()
+		if returnErr!=nil{
+			break
+		}
+		switch messageType {
+		case PingMessage:
+		case PongMessage:
+		case CloseMessage:
+			return
+		case MessageText:
+		case MessageBinary:
+			if len(message) == 0 {
+				continue
+			}
+			returnErr = c.handleMessage(message)
+			if returnErr!=nil{
+				break
+			}
+
+		}
+	}
+
+}
+func (c *Client) handleMessage(message []byte)error  {
+	if c.IsCompress  {
+		var decompressErr error
+		message,decompressErr = c.compressor.DeCompress(message)
+		if decompressErr != nil {
+			return utils.Wrap(decompressErr,"")
+		}
+	}
+	var binaryReq  Req
+	err := c.encoder.Decode(message, &binaryReq)
+	if err != nil {
+		return utils.Wrap(err,"")
+	}
+	if err := c.validate.Struct(binaryReq); err != nil {
+	   return  utils.Wrap(err,"")
+	}
+	if binaryReq.SendID != c.userID {
+		return errors.New("exception conn userID not same to req userID")
+	}
+	ctx:=context.Background()
+	ctx =context.WithValue(ctx,"operationID",binaryReq.OperationID)
+	ctx = context.WithValue(ctx,"userID",binaryReq.SendID)
+	var messageErr error
+	var resp   []byte
+	switch binaryReq.ReqIdentifier {
+	case constant.WSGetNewestSeq:
+       resp,messageErr=c.handler.GetSeq(ctx,binaryReq)
+	case constant.WSSendMsg:
+		resp,messageErr=c.handler.SendMessage(ctx,binaryReq)
+	case constant.WSSendSignalMsg:
+		resp,messageErr=c.handler.SendSignalMessage(ctx,binaryReq)
+	case constant.WSPullMsgBySeqList:
+		resp,messageErr=c.handler.PullMessageBySeqList(ctx,binaryReq)
+	case constant.WsLogoutMsg:
+		resp,messageErr=c.handler.UserLogout(ctx,binaryReq)
+	case constant.WsSetBackgroundStatus:
+		resp,messageErr=c.handler.SetUserDeviceBackground(ctx,binaryReq)
+	default:
+		return errors.New(fmt.Sprintf("ReqIdentifier failed,sendID:%d,msgIncr:%s,reqIdentifier:%s",binaryReq.SendID,binaryReq.MsgIncr,binaryReq.ReqIdentifier))
+	}
+
+
+}
+func (c *Client) close()  {
+
+}
+func ()  {
+	
+}

internal/msggateway/new/compressor.go

@@ -0,0 +1,44 @@
+package new
+
+import (
+	"bytes"
+	"compress/gzip"
+	"io/ioutil"
+	"open_im_sdk/pkg/utils"
+)
+
+type Compressor interface {
+	Compress(rawData []byte) ([]byte, error)
+	DeCompress(compressedData []byte) ([]byte, error)
+}
+type GzipCompressor struct {
+	compressProtocol string
+}
+
+func NewGzipCompressor() *GzipCompressor {
+	return &GzipCompressor{compressProtocol: "gzip"}
+}
+func (g *GzipCompressor) Compress(rawData []byte) ([]byte, error) {
+	gzipBuffer := bytes.Buffer{}
+	gz := gzip.NewWriter(&gzipBuffer)
+	if _, err := gz.Write(rawData); err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	if err := gz.Close(); err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	return gzipBuffer.Bytes(), nil
+}
+func (g *GzipCompressor) DeCompress(compressedData []byte) ([]byte, error) {
+	buff := bytes.NewBuffer(compressedData)
+	reader, err := gzip.NewReader(buff)
+	if err != nil {
+		return nil, utils.Wrap(err, "NewReader failed")
+	}
+	compressedData, err = ioutil.ReadAll(reader)
+	if err != nil {
+		return nil, utils.Wrap(err, "ReadAll failed")
+	}
+	_ = reader.Close()
+	return compressedData, nil
+}

internal/msggateway/new/context.go

@@ -0,0 +1,27 @@
+package new
+
+import "net/http"
+
+type UserConnContext struct {
+	RespWriter http.ResponseWriter
+	Req        *http.Request
+	Path       string
+	Method     string
+	RemoteAddr string
+}
+
+func newContext(respWriter http.ResponseWriter, req *http.Request) *UserConnContext {
+	return &UserConnContext{
+		RespWriter: respWriter,
+		Req:        req,
+		Path:       req.URL.Path,
+		Method:     req.Method,
+		RemoteAddr: req.RemoteAddr,
+	}
+}
+func (c *UserConnContext) Query(key string) string {
+	return c.Req.URL.Query().Get(key)
+}
+func (c *UserConnContext) GetHeader(key string) string {
+	return c.Req.Header.Get(key)
+}

internal/msggateway/new/encoder.go

@@ -0,0 +1,37 @@
+package new
+
+import (
+	"bytes"
+	"encoding/gob"
+	"open_im_sdk/pkg/utils"
+)
+
+type Encoder interface {
+	Encode(data interface{}) ([]byte, error)
+	Decode(encodeData []byte, decodeData interface{}) error
+}
+
+type GobEncoder struct {
+}
+
+func NewGobEncoder() *GobEncoder {
+	return &GobEncoder{}
+}
+func (g *GobEncoder) Encode(data interface{}) ([]byte, error) {
+	buff := bytes.Buffer{}
+	enc := gob.NewEncoder(&buff)
+	err := enc.Encode(data)
+	if err != nil {
+		return nil, err
+	}
+	return buff.Bytes(), nil
+}
+func (g *GobEncoder) Decode(encodeData []byte, decodeData interface{}) error {
+	buff := bytes.NewBuffer(encodeData)
+	dec := gob.NewDecoder(buff)
+	err := dec.Decode(decodeData)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	return nil
+}

internal/msggateway/new/long_conn.go

@@ -0,0 +1,83 @@
+package new
+
+import (
+	"github.com/gorilla/websocket"
+	"net/http"
+	"time"
+)
+
+type LongConn interface {
+	//Close this connection
+	Close() error
+	//Write message to connection,messageType means data type,can be set binary(2) and text(1).
+	WriteMessage(messageType int, message []byte) error
+	//Read message from connection.
+	ReadMessage() (int, []byte, error)
+	//SetReadTimeout sets the read deadline on the underlying network connection,
+	//after a read has timed out, will return an error.
+	SetReadTimeout(timeout int) error
+	//SetWriteTimeout sets the write deadline when send message,when read has timed out,will return error.
+	SetWriteTimeout(timeout int) error
+	//Try to dial a connection,url must set auth args,header can control compress data
+	Dial(urlStr string, requestHeader http.Header) (*http.Response, error)
+	//Whether the connection of the current long connection is nil
+	IsNil() bool
+	//Set the connection of the current long connection to nil
+	SetConnNil()
+	//Check the connection of the current and when it was sent are the same
+	CheckSendConnDiffNow() bool
+}
+type GWebSocket struct {
+	protocolType int
+	conn         *websocket.Conn
+}
+
+func NewDefault(protocolType int) *GWebSocket {
+	return &GWebSocket{protocolType: protocolType}
+}
+func (d *GWebSocket) Close() error {
+	return d.conn.Close()
+}
+
+func (d *GWebSocket) WriteMessage(messageType int, message []byte) error {
+	d.setSendConn(d.conn)
+	return d.conn.WriteMessage(messageType, message)
+}
+
+func (d *GWebSocket) setSendConn(sendConn *websocket.Conn) {
+	d.sendConn = sendConn
+}
+
+func (d *GWebSocket) ReadMessage() (int, []byte, error) {
+	return d.conn.ReadMessage()
+}
+func (d *GWebSocket) SetReadTimeout(timeout int) error {
+	return d.conn.SetReadDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
+}
+
+func (d *GWebSocket) SetWriteTimeout(timeout int) error {
+	return d.conn.SetWriteDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
+}
+
+func (d *GWebSocket) Dial(urlStr string, requestHeader http.Header) (*http.Response, error) {
+	conn, httpResp, err := websocket.DefaultDialer.Dial(urlStr, requestHeader)
+	if err == nil {
+		d.conn = conn
+	}
+	return httpResp, err
+
+}
+
+func (d *GWebSocket) IsNil() bool {
+	if d.conn != nil {
+		return false
+	}
+	return true
+}
+
+func (d *GWebSocket) SetConnNil() {
+	d.conn = nil
+}
+func (d *GWebSocket) CheckSendConnDiffNow() bool {
+	return d.conn == d.sendConn
+}

internal/msggateway/new/message_handler.go

@@ -0,0 +1,49 @@
+package new
+
+import "context"
+
+type Req struct {
+	ReqIdentifier int32  `json:"reqIdentifier" validate:"required"`
+	Token         string `json:"token" `
+	SendID        string `json:"sendID" validate:"required"`
+	OperationID   string `json:"operationID" validate:"required"`
+	MsgIncr       string `json:"msgIncr" validate:"required"`
+	Data          []byte `json:"data"`
+}
+type MessageHandler interface {
+	GetSeq(context context.Context, data Req) ([]byte, error)
+	SendMessage(context context.Context, data Req) ([]byte, error)
+	SendSignalMessage(context context.Context, data Req) ([]byte, error)
+	PullMessageBySeqList(context context.Context, data Req) ([]byte, error)
+	UserLogout(context context.Context, data Req) ([]byte, error)
+	SetUserDeviceBackground(context context.Context, data Req) ([]byte, error)
+}
+
+var _ MessageHandler = (*GrpcHandler)(nil)
+
+type GrpcHandler struct {
+}
+
+func (g GrpcHandler) GetSeq(context context.Context, data Req) ([]byte, error) {
+	panic("implement me")
+}
+
+func (g GrpcHandler) SendMessage(context context.Context, data Req) ([]byte, error) {
+	panic("implement me")
+}
+
+func (g GrpcHandler) SendSignalMessage(context context.Context, data Req) ([]byte, error) {
+	panic("implement me")
+}
+
+func (g GrpcHandler) PullMessageBySeqList(context context.Context, data Req) ([]byte, error) {
+	panic("implement me")
+}
+
+func (g GrpcHandler) UserLogout(context context.Context, data Req) ([]byte, error) {
+	panic("implement me")
+}
+
+func (g GrpcHandler) SetUserDeviceBackground(context context.Context, data Req) ([]byte, error) {
+	panic("implement me")
+}

internal/msggateway/new/n_ws_server.go

@@ -0,0 +1,81 @@
+package new
+
+import (
+	"errors"
+	"github.com/gorilla/websocket"
+	"net/http"
+	"open_im_sdk/pkg/utils"
+	"sync"
+	"time"
+)
+
+type LongConnServer interface {
+	Run() error
+}
+
+type Server struct {
+	rpcPort        int
+	wsMaxConnNum   int
+	longConnServer *LongConnServer
+	rpcServer      *RpcServer
+}
+type WsServer struct {
+	port              int
+	wsMaxConnNum      int
+	wsUpGrader        *websocket.Upgrader
+	registerChan      chan *Client
+	unregisterChan    chan *Client
+	clients           *UserMap
+	clientPool        sync.Pool
+	onlineUserNum     int64
+	onlineUserConnNum int64
+	compressor        Compressor
+	handler           MessageHandler
+}
+
+func newWsServer(opts ...Option) (*WsServer, error) {
+	var config configs
+	for _, o := range opts {
+		o(&config)
+	}
+	if config.port < 1024 {
+		return nil, errors.New("port not allow to listen")
+
+	}
+	return &WsServer{
+		port:         config.port,
+		wsMaxConnNum: config.maxConnNum,
+		wsUpGrader: &websocket.Upgrader{
+			HandshakeTimeout: config.handshakeTimeout,
+			ReadBufferSize:   config.messageMaxMsgLength,
+			CheckOrigin:      func(r *http.Request) bool { return true },
+		},
+		clientPool: sync.Pool{
+			New: func() interface{} {
+				return new(Client)
+			},
+		},
+	}, nil
+}
+func (ws *WsServer) Run() error {
+	http.HandleFunc("/", ws.wsHandler)                              //Get request from client to handle by wsHandler
+	return http.ListenAndServe(":"+utils.IntToString(ws.port), nil) //Start listening
+
+}
+func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
+	context := newContext(w, r)
+	if isPass, compression := ws.headerCheck(w, r, operationID); isPass {
+		conn, err := ws.wsUpGrader.Upgrade(w, r, nil) //Conn is obtained through the upgraded escalator
+		if err != nil {
+			log.Error(operationID, "upgrade http conn err", err.Error(), query)
+			return
+		} else {
+			newConn := &UserConn{conn, new(sync.Mutex), utils.StringToInt32(query["platformID"][0]), 0, compression, query["sendID"][0], false, query["token"][0], conn.RemoteAddr().String() + "_" + strconv.Itoa(int(utils.GetCurrentTimestampByMill()))}
+			userCount++
+			ws.addUserConn(query["sendID"][0], utils.StringToInt(query["platformID"][0]), newConn, query["token"][0], newConn.connID, operationID)
+			go ws.readMsg(newConn)
+		}
+	} else {
+		log.Error(operationID, "headerCheck failed ")
+	}
+}

internal/msggateway/new/options.go

@@ -0,0 +1,36 @@
+package new
+
+import "time"
+
+type Option func(opt *configs)
+type configs struct {
+	//长连接监听端口
+	port int
+	//长连接允许最大链接数
+	maxConnNum int
+	//连接握手超时时间
+	handshakeTimeout time.Duration
+	//允许消息最大长度
+	messageMaxMsgLength int
+}
+
+func WithPort(port int) Option {
+	return func(opt *configs) {
+		opt.port = port
+	}
+}
+func WithMaxConnNum(num int) Option {
+	return func(opt *configs) {
+		opt.maxConnNum = num
+	}
+}
+func WithHandshakeTimeout(t time.Duration) Option {
+	return func(opt *configs) {
+		opt.handshakeTimeout = t
+	}
+}
+func WithMessageMaxMsgLength(length int) Option {
+	return func(opt *configs) {
+		opt.messageMaxMsgLength = length
+	}
+}

internal/msggateway/new/user_map.go

@@ -0,0 +1,64 @@
+package new
+
+import "sync"
+
+type UserMap struct {
+	m sync.Map
+}
+
+func newUserMap() *UserMap {
+	return &UserMap{}
+}
+func (u *UserMap) GetAll(key string) []*Client {
+	allClients, ok := u.m.Load(key)
+	if ok {
+		return allClients.([]*Client)
+	}
+	return nil
+}
+func (u *UserMap) Get(key string, platformID int32) (*Client, bool) {
+	allClients, existed := u.m.Load(key)
+	if existed {
+		for _, client := range allClients.([]*Client) {
+			if client.PlatformID == platformID {
+				return client, existed
+			}
+		}
+		return nil, false
+	}
+	return nil, existed
+}
+func (u *UserMap) Set(key string, v *Client) {
+	allClients, existed := u.m.Load(key)
+	if existed {
+		oldClients := allClients.([]*Client)
+		oldClients = append(oldClients, v)
+		u.m.Store(key, oldClients)
+	} else {
+		clients := make([]*Client, 3)
+		clients = append(clients, v)
+		u.m.Store(key, clients)
+	}
+}
+func (u *UserMap) delete(key string, platformID int32) {
+	allClients, existed := u.m.Load(key)
+	if existed {
+		oldClients := allClients.([]*Client)
+
+		a := make([]*Client, len(oldClients))
+		for _, client := range oldClients {
+			if client.PlatformID != platformID {
+				a = append(a, client)
+			}
+		}
+		if len(a) == 0 {
+			u.m.Delete(key)
+		} else {
+			u.m.Store(key, a)
+
+		}
+	}
+}
+func (u *UserMap) DeleteAll(key string) {
+	u.m.Delete(key)
+}

internal/push/logic/callback.go

@@ -1,28 +1,30 @@
 package logic
 
 import (
-	cbApi "Open_IM/pkg/callback_struct"
-	"Open_IM/pkg/common/callback"
+	cbapi "Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/http"
-	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/tracelog"
 	common "Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
-	http2 "net/http"
+	"context"
 )
 
-func callbackOfflinePush(operationID string, userIDList []string, msg *common.MsgData, offlinePushUserIDList *[]string) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+func url() string {
+	return config.Config.Callback.CallbackUrl
+}
+
+func CallbackOfflinePush(ctx context.Context, userIDList []string, msg *common.MsgData, offlinePushUserIDList *[]string) error {
 	if !config.Config.Callback.CallbackOfflinePush.Enable {
-		return callbackResp
+		return nil
 	}
-	req := cbApi.CallbackBeforePushReq{
-		UserStatusBatchCallbackReq: cbApi.UserStatusBatchCallbackReq{
-			UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+	req := &cbapi.CallbackBeforePushReq{
+		UserStatusBatchCallbackReq: cbapi.UserStatusBatchCallbackReq{
+			UserStatusBaseCallback: cbapi.UserStatusBaseCallback{
 				CallbackCommand: constant.CallbackOfflinePushCommand,
-				OperationID:     operationID,
-				PlatformID:      msg.SenderPlatformID,
+				OperationID:     tracelog.GetOperationID(ctx),
+				PlatformID:      int(msg.SenderPlatformID),
 				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
 			},
 			UserIDList: userIDList,
@@ -34,120 +36,214 @@ func callbackOfflinePush(operationID string, userIDList []string, msg *common.Ms
 		ContentType:     msg.ContentType,
 		SessionType:     msg.SessionType,
 		AtUserIDList:    msg.AtUserIDList,
-		Content:         callback.GetContent(msg),
+		Content:         utils.GetContent(msg),
 	}
-	resp := &cbApi.CallbackBeforePushResp{CommonCallbackResp: &callbackResp}
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackOfflinePushCommand, req, resp, config.Config.Callback.CallbackOfflinePush.CallbackTimeOut); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !*config.Config.Callback.CallbackOfflinePush.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
+	resp := &cbapi.CallbackBeforePushResp{}
+	err := http.CallBackPostReturn(url(), req, resp, config.Config.Callback.CallbackOfflinePush)
+	if err != nil {
+		return err
 	}
-	if resp.ErrCode == constant.CallbackHandleSuccess && resp.ActionCode == constant.ActionAllow {
-		if len(resp.UserIDList) != 0 {
-			*offlinePushUserIDList = resp.UserIDList
-		}
-		if resp.OfflinePushInfo != nil {
-			msg.OfflinePushInfo = resp.OfflinePushInfo
-		}
+	if len(resp.UserIDList) != 0 {
+		*offlinePushUserIDList = resp.UserIDList
 	}
-	log.NewDebug(operationID, utils.GetSelfFuncName(), offlinePushUserIDList, resp.UserIDList)
-	return callbackResp
+	if resp.OfflinePushInfo != nil {
+		msg.OfflinePushInfo = resp.OfflinePushInfo
+	}
+	return nil
 }
 
-func callbackOnlinePush(operationID string, userIDList []string, msg *common.MsgData) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
-	if !config.Config.Callback.CallbackOnlinePush.Enable || utils.IsContain(msg.SendID, userIDList) {
-		return callbackResp
+func CallbackOnlinePush(operationID string, userIDList []string, msg *common.MsgData) error {
+	if !config.Config.Callback.CallbackOnlinePush.Enable || utils.Contain(msg.SendID, userIDList...) {
+		return nil
 	}
-	req := cbApi.CallbackBeforePushReq{
-		UserStatusBatchCallbackReq: cbApi.UserStatusBatchCallbackReq{
-			UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+	req := cbapi.CallbackBeforePushReq{
+		UserStatusBatchCallbackReq: cbapi.UserStatusBatchCallbackReq{
+			UserStatusBaseCallback: cbapi.UserStatusBaseCallback{
 				CallbackCommand: constant.CallbackOnlinePushCommand,
 				OperationID:     operationID,
-				PlatformID:      msg.SenderPlatformID,
+				PlatformID:      int(msg.SenderPlatformID),
 				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
 			},
 			UserIDList: userIDList,
 		},
-		//OfflinePushInfo: msg.OfflinePushInfo,
 		ClientMsgID:  msg.ClientMsgID,
 		SendID:       msg.SendID,
 		GroupID:      msg.GroupID,
 		ContentType:  msg.ContentType,
 		SessionType:  msg.SessionType,
 		AtUserIDList: msg.AtUserIDList,
-		Content:      callback.GetContent(msg),
+		Content:      utils.GetContent(msg),
 	}
-	resp := &cbApi.CallbackBeforePushResp{CommonCallbackResp: &callbackResp}
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackOnlinePushCommand, req, resp, config.Config.Callback.CallbackOnlinePush.CallbackTimeOut); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !config.Config.Callback.CallbackOnlinePush.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
-	}
-	if resp.ErrCode == constant.CallbackHandleSuccess && resp.ActionCode == constant.ActionAllow {
-		//if resp.OfflinePushInfo != nil {
-		//	msg.OfflinePushInfo = resp.OfflinePushInfo
-		//}
-	}
-	return callbackResp
+	resp := &cbapi.CallbackBeforePushResp{}
+	return http.CallBackPostReturn(url(), req, resp, config.Config.Callback.CallbackOnlinePush)
 }
 
-func callbackBeforeSuperGroupOnlinePush(operationID string, groupID string, msg *common.MsgData, pushToUserList *[]string) cbApi.CommonCallbackResp {
-	log.Debug(operationID, utils.GetSelfFuncName(), groupID, msg.String(), pushToUserList)
-	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+func CallbackBeforeSuperGroupOnlinePush(ctx context.Context, groupID string, msg *common.MsgData, pushToUserList *[]string) error {
 	if !config.Config.Callback.CallbackBeforeSuperGroupOnlinePush.Enable {
-		return callbackResp
+		return nil
 	}
-	req := cbApi.CallbackBeforeSuperGroupOnlinePushReq{
-		UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+	req := cbapi.CallbackBeforeSuperGroupOnlinePushReq{
+		UserStatusBaseCallback: cbapi.UserStatusBaseCallback{
 			CallbackCommand: constant.CallbackSuperGroupOnlinePushCommand,
-			OperationID:     operationID,
-			PlatformID:      msg.SenderPlatformID,
+			OperationID:     tracelog.GetOperationID(ctx),
+			PlatformID:      int(msg.SenderPlatformID),
 			Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
 		},
-		//OfflinePushInfo: msg.OfflinePushInfo,
 		ClientMsgID:  msg.ClientMsgID,
 		SendID:       msg.SendID,
 		GroupID:      groupID,
 		ContentType:  msg.ContentType,
 		SessionType:  msg.SessionType,
 		AtUserIDList: msg.AtUserIDList,
-		Content:      callback.GetContent(msg),
+		Content:      utils.GetContent(msg),
 		Seq:          msg.Seq,
 	}
-	resp := &cbApi.CallbackBeforeSuperGroupOnlinePushResp{CommonCallbackResp: &callbackResp}
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackSuperGroupOnlinePushCommand, req, resp, config.Config.Callback.CallbackBeforeSuperGroupOnlinePush.CallbackTimeOut); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !config.Config.Callback.CallbackBeforeSuperGroupOnlinePush.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
+	resp := &cbapi.CallbackBeforeSuperGroupOnlinePushResp{}
+	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackBeforeSuperGroupOnlinePush); err != nil {
+		return err
 	}
-	if resp.ErrCode == constant.CallbackHandleSuccess && resp.ActionCode == constant.ActionAllow {
-		if len(resp.UserIDList) != 0 {
-			*pushToUserList = resp.UserIDList
-		}
-		//if resp.OfflinePushInfo != nil {
-		//	msg.OfflinePushInfo = resp.OfflinePushInfo
-		//}
+	if len(resp.UserIDList) != 0 {
+		*pushToUserList = resp.UserIDList
 	}
-	log.NewDebug(operationID, utils.GetSelfFuncName(), pushToUserList, resp.UserIDList)
-	return callbackResp
-
+	return nil
 }
+
+//func callbackOfflinePush(operationID string, userIDList []string, msg *common.MsgData, offlinePushUserIDList *[]string) cbApi.CommonCallbackResp {
+//	callbackResp := cbapi.CommonCallbackResp{OperationID: operationID}
+//	if !config.Config.Callback.CallbackOfflinePush.Enable {
+//		return callbackResp
+//	}
+//	req := cbApi.CallbackBeforePushReq{
+//		UserStatusBatchCallbackReq: cbApi.UserStatusBatchCallbackReq{
+//			UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+//				CallbackCommand: constant.CallbackOfflinePushCommand,
+//				OperationID:     operationID,
+//				PlatformID:      msg.SenderPlatformID,
+//				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+//			},
+//			UserIDList: userIDList,
+//		},
+//		OfflinePushInfo: msg.OfflinePushInfo,
+//		ClientMsgID:     msg.ClientMsgID,
+//		SendID:          msg.SendID,
+//		GroupID:         msg.GroupID,
+//		ContentType:     msg.ContentType,
+//		SessionType:     msg.SessionType,
+//		AtUserIDList:    msg.AtUserIDList,
+//		Content:         callback.GetContent(msg),
+//	}
+//	resp := &cbApi.CallbackBeforePushResp{CommonCallbackResp: &callbackResp}
+//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackOfflinePushCommand, req, resp, config.Config.Callback.CallbackOfflinePush.CallbackTimeOut); err != nil {
+//		callbackResp.ErrCode = http2.StatusInternalServerError
+//		callbackResp.ErrMsg = err.Error()
+//		if !*config.Config.Callback.CallbackOfflinePush.CallbackFailedContinue {
+//			callbackResp.ActionCode = constant.ActionForbidden
+//			return callbackResp
+//		} else {
+//			callbackResp.ActionCode = constant.ActionAllow
+//			return callbackResp
+//		}
+//	}
+//	if resp.ErrCode == constant.CallbackHandleSuccess && resp.ActionCode == constant.ActionAllow {
+//		if len(resp.UserIDList) != 0 {
+//			*offlinePushUserIDList = resp.UserIDList
+//		}
+//		if resp.OfflinePushInfo != nil {
+//			msg.OfflinePushInfo = resp.OfflinePushInfo
+//		}
+//	}
+//	log.NewDebug(operationID, utils.GetSelfFuncName(), offlinePushUserIDList, resp.UserIDList)
+//	return callbackResp
+//}
+//
+//func callbackOnlinePush(operationID string, userIDList []string, msg *common.MsgData) cbApi.CommonCallbackResp {
+//	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+//	if !config.Config.Callback.CallbackOnlinePush.Enable || utils.IsContain(msg.SendID, userIDList) {
+//		return callbackResp
+//	}
+//	req := cbApi.CallbackBeforePushReq{
+//		UserStatusBatchCallbackReq: cbApi.UserStatusBatchCallbackReq{
+//			UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+//				CallbackCommand: constant.CallbackOnlinePushCommand,
+//				OperationID:     operationID,
+//				PlatformID:      msg.SenderPlatformID,
+//				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+//			},
+//			UserIDList: userIDList,
+//		},
+//		//OfflinePushInfo: msg.OfflinePushInfo,
+//		ClientMsgID:  msg.ClientMsgID,
+//		SendID:       msg.SendID,
+//		GroupID:      msg.GroupID,
+//		ContentType:  msg.ContentType,
+//		SessionType:  msg.SessionType,
+//		AtUserIDList: msg.AtUserIDList,
+//		Content:      callback.GetContent(msg),
+//	}
+//	resp := &cbApi.CallbackBeforePushResp{CommonCallbackResp: &callbackResp}
+//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackOnlinePushCommand, req, resp, config.Config.Callback.CallbackOnlinePush.CallbackTimeOut); err != nil {
+//		callbackResp.ErrCode = http2.StatusInternalServerError
+//		callbackResp.ErrMsg = err.Error()
+//		if !config.Config.Callback.CallbackOnlinePush.CallbackFailedContinue {
+//			callbackResp.ActionCode = constant.ActionForbidden
+//			return callbackResp
+//		} else {
+//			callbackResp.ActionCode = constant.ActionAllow
+//			return callbackResp
+//		}
+//	}
+//	if resp.ErrCode == constant.CallbackHandleSuccess && resp.ActionCode == constant.ActionAllow {
+//		//if resp.OfflinePushInfo != nil {
+//		//	msg.OfflinePushInfo = resp.OfflinePushInfo
+//		//}
+//	}
+//	return callbackResp
+//}
+//
+//func callbackBeforeSuperGroupOnlinePush(operationID string, groupID string, msg *common.MsgData, pushToUserList *[]string) cbApi.CommonCallbackResp {
+//	log.Debug(operationID, utils.GetSelfFuncName(), groupID, msg.String(), pushToUserList)
+//	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+//	if !config.Config.Callback.CallbackBeforeSuperGroupOnlinePush.Enable {
+//		return callbackResp
+//	}
+//	req := cbApi.CallbackBeforeSuperGroupOnlinePushReq{
+//		UserStatusBaseCallback: cbApi.UserStatusBaseCallback{
+//			CallbackCommand: constant.CallbackSuperGroupOnlinePushCommand,
+//			OperationID:     operationID,
+//			PlatformID:      msg.SenderPlatformID,
+//			Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+//		},
+//		//OfflinePushInfo: msg.OfflinePushInfo,
+//		ClientMsgID:  msg.ClientMsgID,
+//		SendID:       msg.SendID,
+//		GroupID:      groupID,
+//		ContentType:  msg.ContentType,
+//		SessionType:  msg.SessionType,
+//		AtUserIDList: msg.AtUserIDList,
+//		Content:      callback.GetContent(msg),
+//		Seq:          msg.Seq,
+//	}
+//	resp := &cbApi.CallbackBeforeSuperGroupOnlinePushResp{CommonCallbackResp: &callbackResp}
+//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackSuperGroupOnlinePushCommand, req, resp, config.Config.Callback.CallbackBeforeSuperGroupOnlinePush.CallbackTimeOut); err != nil {
+//		callbackResp.ErrCode = http2.StatusInternalServerError
+//		callbackResp.ErrMsg = err.Error()
+//		if !config.Config.Callback.CallbackBeforeSuperGroupOnlinePush.CallbackFailedContinue {
+//			callbackResp.ActionCode = constant.ActionForbidden
+//			return callbackResp
+//		} else {
+//			callbackResp.ActionCode = constant.ActionAllow
+//			return callbackResp
+//		}
+//	}
+//	if resp.ErrCode == constant.CallbackHandleSuccess && resp.ActionCode == constant.ActionAllow {
+//		if len(resp.UserIDList) != 0 {
+//			*pushToUserList = resp.UserIDList
+//		}
+//		//if resp.OfflinePushInfo != nil {
+//		//	msg.OfflinePushInfo = resp.OfflinePushInfo
+//		//}
+//	}
+//	log.NewDebug(operationID, utils.GetSelfFuncName(), pushToUserList, resp.UserIDList)
+//	return callbackResp
+//
+//}

internal/rpc/auth/auth.go

@@ -2,70 +2,47 @@ package auth
 
 import (
 	"Open_IM/internal/common/check"
-	"Open_IM/internal/common/rpc_server"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/cache"
 	"Open_IM/pkg/common/db/controller"
+	"Open_IM/pkg/common/db/relation"
+	relationTb "Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/log"
-	prome "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
 	pbAuth "Open_IM/pkg/proto/auth"
 	pbRelay "Open_IM/pkg/proto/relay"
 	"Open_IM/pkg/utils"
 	"context"
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
+	"github.com/OpenIMSDK/openKeeper"
 	"google.golang.org/grpc"
 )
 
-func NewRpcAuthServer(port int) *rpcAuth {
-	r, err := rpcserver.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImAuthName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
+	mysql, err := relation.NewGormDB()
 	if err != nil {
-		panic(err)
+		return err
 	}
-	var redis cache.RedisClient
-	redis.InitRedis()
-	return &rpcAuth{
-		RpcServer:     r,
-		AuthInterface: controller.NewAuthController(redis.GetClient(), config.Config.TokenPolicy.AccessSecret, config.Config.TokenPolicy.AccessExpire),
+	if err := mysql.AutoMigrate(&relationTb.FriendModel{}, &relationTb.FriendRequestModel{}, &relationTb.BlackModel{}); err != nil {
+		return err
 	}
+	redis, err := cache.NewRedis()
+	if err != nil {
+		return err
+	}
+	pbAuth.RegisterAuthServer(server, &authServer{
+		userCheck:      check.NewUserCheck(client),
+		RegisterCenter: client,
+		AuthInterface:  controller.NewAuthController(redis.GetClient(), config.Config.TokenPolicy.AccessSecret, config.Config.TokenPolicy.AccessExpire),
+	})
+	return nil
 }
 
-func (s *rpcAuth) Run() {
-	operationID := utils.OperationIDGenerator()
-	log.NewInfo(operationID, "rpc auth start...")
-	listener, address, err := rpcserver.GetTcpListen(config.Config.ListenIP, s.Port)
-	if err != nil {
-		panic(err)
-	}
-	log.NewInfo(operationID, "listen network success ", listener, address)
-	var grpcOpts []grpc.ServerOption
-	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
-		prome.NewUserRegisterCounter()
-		prome.NewUserLoginCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	pbAuth.RegisterAuthServer(srv, s)
-	err = srv.Serve(listener)
-	if err != nil {
-		panic(err)
-	}
-	log.NewInfo(operationID, "rpc auth ok")
-}
-
-func (s *rpcAuth) UserToken(ctx context.Context, req *pbAuth.UserTokenReq) (*pbAuth.UserTokenResp, error) {
+func (s *authServer) UserToken(ctx context.Context, req *pbAuth.UserTokenReq) (*pbAuth.UserTokenResp, error) {
 	resp := pbAuth.UserTokenResp{}
-	if _, err := check.GetUsersInfo(ctx, req.UserID); err != nil {
+	if _, err := s.userCheck.GetUsersInfo(ctx, req.UserID); err != nil {
 		return nil, err
 	}
 	token, err := s.CreateToken(ctx, req.UserID, constant.PlatformIDToName(int(req.PlatformID)))
@@ -77,7 +54,7 @@ func (s *rpcAuth) UserToken(ctx context.Context, req *pbAuth.UserTokenReq) (*pbA
 	return &resp, nil
 }
 
-func (s *rpcAuth) parseToken(ctx context.Context, tokensString string) (claims *tokenverify.Claims, err error) {
+func (s *authServer) parseToken(ctx context.Context, tokensString string) (claims *tokenverify.Claims, err error) {
 	claims, err = tokenverify.GetClaimFromToken(tokensString)
 	if err != nil {
 		return nil, utils.Wrap(err, "")
@@ -102,7 +79,7 @@ func (s *rpcAuth) parseToken(ctx context.Context, tokensString string) (claims *
 	return nil, constant.ErrTokenNotExist.Wrap()
 }
 
-func (s *rpcAuth) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (resp *pbAuth.ParseTokenResp, err error) {
+func (s *authServer) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (resp *pbAuth.ParseTokenResp, err error) {
 	resp = &pbAuth.ParseTokenResp{}
 	claims, err := s.parseToken(ctx, req.Token)
 	if err != nil {
@@ -114,7 +91,7 @@ func (s *rpcAuth) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (re
 	return resp, nil
 }
 
-func (s *rpcAuth) ForceLogout(ctx context.Context, req *pbAuth.ForceLogoutReq) (*pbAuth.ForceLogoutResp, error) {
+func (s *authServer) ForceLogout(ctx context.Context, req *pbAuth.ForceLogoutReq) (*pbAuth.ForceLogoutResp, error) {
 	resp := pbAuth.ForceLogoutResp{}
 	if err := tokenverify.CheckAdmin(ctx); err != nil {
 		return nil, err
@@ -125,7 +102,7 @@ func (s *rpcAuth) ForceLogout(ctx context.Context, req *pbAuth.ForceLogoutReq) (
 	return &resp, nil
 }
 
-func (s *rpcAuth) forceKickOff(ctx context.Context, userID string, platformID int32, operationID string) error {
+func (s *authServer) forceKickOff(ctx context.Context, userID string, platformID int32, operationID string) error {
 	grpcCons, err := s.RegisterCenter.GetConns(config.Config.RpcRegisterName.OpenImRelayName)
 	if err != nil {
 		return err
@@ -140,7 +117,8 @@ func (s *rpcAuth) forceKickOff(ctx context.Context, userID string, platformID in
 	return constant.ErrInternalServer.Wrap()
 }
 
-type rpcAuth struct {
-	*rpcserver.RpcServer
+type authServer struct {
 	controller.AuthInterface
+	userCheck      *check.UserCheck
+	RegisterCenter discoveryRegistry.SvcDiscoveryRegistry
 }

internal/rpc/conversation/conversaion.go

@@ -6,11 +6,14 @@ import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/cache"
 	"Open_IM/pkg/common/db/controller"
-	relationTb "Open_IM/pkg/common/db/relation"
-	unrealationTb "Open_IM/pkg/common/db/unrelation"
+	"Open_IM/pkg/common/db/relation"
+	tableRelation "Open_IM/pkg/common/db/table/relation"
+	"Open_IM/pkg/common/db/unrelation"
 	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/prome"
+	promePkg "Open_IM/pkg/common/prometheus"
+	"Open_IM/pkg/getcdv3"
 	pbConversation "Open_IM/pkg/proto/conversation"
+	pbUser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
 	"github.com/dtm-labs/rockscache"
@@ -47,7 +50,7 @@ func NewConversationServer(port int) *conversationServer {
 	var cCache cache.ConversationCache
 	//mysql init
 	var mysql relation.Mysql
-	err := mysql.InitConn().AutoMigrateModel(&table.ConversationModel{})
+	err := mysql.InitConn().AutoMigrateModel(&tableRelation.ConversationModel{})
 	if err != nil {
 		panic("db init err:" + err.Error())
 	}
@@ -92,11 +95,11 @@ func (c *conversationServer) Run() {
 	//grpc server
 	var grpcOpts []grpc.ServerOption
 	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
+		promePkg.NewGrpcRequestCounter()
+		promePkg.NewGrpcRequestFailedCounter()
+		promePkg.NewGrpcRequestSuccessCounter()
 		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
+			// grpc.UnaryInterceptor(promePkg.UnaryServerInterceptorProme),
 			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
 			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
 		}...)
@@ -170,7 +173,7 @@ func (c *conversationServer) GetConversations(ctx context.Context, req *pbConver
 
 func (c *conversationServer) BatchSetConversations(ctx context.Context, req *pbConversation.BatchSetConversationsReq) (*pbConversation.BatchSetConversationsResp, error) {
 	resp := &pbConversation.BatchSetConversationsResp{}
-	var conversations []*table.ConversationModel
+	var conversations []*tableRelation.ConversationModel
 	if err := utils.CopyStructFields(&conversations, req.Conversations); err != nil {
 		return nil, err
 	}
@@ -203,16 +206,16 @@ func (c *conversationServer) ModifyConversationField(ctx context.Context, req *p
 			return nil, err
 		}
 	}
-	var conversation table.ConversationModel
+	var conversation tableRelation.ConversationModel
 	if err := utils.CopyStructFields(&conversation, req.Conversation); err != nil {
 		return nil, err
 	}
 	if req.FieldType == constant.FieldIsPrivateChat {
-		err := c.ConversationInterface.SyncPeerUserPrivateConversationTx(ctx, req.Conversation)
+		err := c.ConversationInterface.SyncPeerUserPrivateConversationTx(ctx, &conversation)
 		if err != nil {
 			return nil, err
 		}
-		chat.ConversationSetPrivateNotification(req.OperationID, req.Conversation.OwnerUserID, req.Conversation.UserID, req.Conversation.IsPrivateChat)
+		chat.ConversationSetPrivateNotification(ctx, req.Conversation.OwnerUserID, req.Conversation.UserID, req.Conversation.IsPrivateChat)
 		return resp, nil
 	}
 	//haveUserID, err := c.ConversationInterface.GetUserIDExistConversation(ctx, req.UserIDList, req.Conversation.ConversationID)
@@ -239,29 +242,18 @@ func (c *conversationServer) ModifyConversationField(ctx context.Context, req *p
 	case constant.FieldBurnDuration:
 		filedMap["burn_duration"] = req.Conversation.BurnDuration
 	}
-	c.ConversationInterface.SetUsersConversationFiledTx(ctx, req.UserIDList, &conversation, filedMap)
-	err = c.ConversationInterface.UpdateUsersConversationFiled(ctx, haveUserID, req.Conversation.ConversationID, filedMap)
-	if err != nil {
-		return nil, err
-	}
-	var conversations []*pbConversation.Conversation
-	for _, v := range utils.DifferenceString(haveUserID, req.UserIDList) {
-		temp := new(pbConversation.Conversation)
-		_ = utils.CopyStructFields(temp, req.Conversation)
-		temp.OwnerUserID = v
-		conversations = append(conversations, temp)
-	}
-	err = c.ConversationInterface.CreateConversation(ctx, conversations)
+	err = c.ConversationInterface.SetUsersConversationFiledTx(ctx, req.UserIDList, &conversation, filedMap)
 	if err != nil {
 		return nil, err
 	}
+
 	if isSyncConversation {
 		for _, v := range req.UserIDList {
-			chat.ConversationChangeNotification(req.OperationID, v)
+			chat.ConversationChangeNotification(ctx, v)
 		}
 	} else {
 		for _, v := range req.UserIDList {
-			chat.ConversationUnreadChangeNotification(req.OperationID, v, req.Conversation.ConversationID, req.Conversation.UpdateUnreadCountTime)
+			chat.ConversationUnreadChangeNotification(ctx, v, req.Conversation.ConversationID, req.Conversation.UpdateUnreadCountTime)
 		}
 	}
 	return resp, nil

internal/rpc/friend/black.go

@@ -1,9 +1,7 @@
 package friend
 
 import (
-	"Open_IM/internal/common/check"
 	"Open_IM/internal/common/convert"
-	chat "Open_IM/internal/rpc/msg"
 	"Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
@@ -13,14 +11,14 @@ import (
 
 func (s *friendServer) GetPaginationBlacks(ctx context.Context, req *pbFriend.GetPaginationBlacksReq) (resp *pbFriend.GetPaginationBlacksResp, err error) {
 	resp = &pbFriend.GetPaginationBlacksResp{}
-	if err := check.Access(ctx, req.UserID); err != nil {
+	if err := s.userCheck.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
 	blacks, total, err := s.BlackInterface.FindOwnerBlacks(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-	resp.Blacks, err = (*convert.DBBlack)(nil).DB2PB(blacks)
+	resp.Blacks, err = (*convert.NewDBBlack(nil, s.RegisterCenter)).DB2PB(ctx, blacks)
 	if err != nil {
 		return nil, err
 	}
@@ -41,13 +39,13 @@ func (s *friendServer) IsBlack(ctx context.Context, req *pbFriend.IsBlackReq) (*
 
 func (s *friendServer) RemoveBlack(ctx context.Context, req *pbFriend.RemoveBlackReq) (*pbFriend.RemoveBlackResp, error) {
 	resp := &pbFriend.RemoveBlackResp{}
-	if err := check.Access(ctx, req.OwnerUserID); err != nil {
+	if err := s.userCheck.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
 	if err := s.BlackInterface.Delete(ctx, []*relation.BlackModel{{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID}}); err != nil {
 		return nil, err
 	}
-	chat.BlackDeletedNotification(ctx, req)
+	s.notification.BlackDeletedNotification(ctx, req)
 	return resp, nil
 }
 
@@ -60,6 +58,6 @@ func (s *friendServer) AddBlack(ctx context.Context, req *pbFriend.AddBlackReq)
 	if err := s.BlackInterface.Create(ctx, []*relation.BlackModel{&black}); err != nil {
 		return nil, err
 	}
-	chat.BlackAddedNotification(ctx, req)
+	s.notification.BlackAddedNotification(ctx, req)
 	return resp, nil
 }

internal/rpc/friend/callback.go

@@ -1,59 +1,26 @@
 package friend
 
 import (
-	cbApi "Open_IM/pkg/callback_struct"
+	cbapi "Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/http"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/tracelog"
-	pbFriend "Open_IM/pkg/proto/friend"
+	pbfriend "Open_IM/pkg/proto/friend"
 	"context"
-
-	//"Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	http2 "net/http"
 )
 
-func callbackBeforeAddFriendV1(ctx context.Context, req *pbFriend.AddFriendReq) error {
-	resp := callbackBeforeAddFriend(ctx, req)
-	if resp.ErrCode != 0 {
-		return (&constant.ErrInfo{
-			ErrCode: resp.ErrCode,
-			ErrMsg:  resp.ErrMsg,
-		}).Wrap()
-	}
-	return nil
-}
-
-func callbackBeforeAddFriend(ctx context.Context, req *pbFriend.AddFriendReq) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: tracelog.GetOperationID(ctx)}
+func CallbackBeforeAddFriend(ctx context.Context, req *pbfriend.ApplyToAddFriendReq) error {
 	if !config.Config.Callback.CallbackBeforeAddFriend.Enable {
-		return callbackResp
+		return nil
 	}
-
-	commonCallbackReq := &cbApi.CallbackBeforeAddFriendReq{
+	cbReq := &cbapi.CallbackBeforeAddFriendReq{
 		CallbackCommand: constant.CallbackBeforeAddFriendCommand,
 		FromUserID:      req.FromUserID,
 		ToUserID:        req.ToUserID,
 		ReqMsg:          req.ReqMsg,
 		OperationID:     tracelog.GetOperationID(ctx),
 	}
-	resp := &cbApi.CallbackBeforeAddFriendResp{
-		CommonCallbackResp: &callbackResp,
-	}
-	//utils.CopyStructFields(req, msg.MsgData)
-	defer log.NewDebug(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), commonCallbackReq, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeAddFriendCommand, commonCallbackReq, resp, config.Config.Callback.CallbackBeforeAddFriend); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !*config.Config.Callback.CallbackBeforeAddFriend.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
-	}
-	return callbackResp
+	resp := &cbapi.CallbackBeforeAddFriendResp{}
+	return http.CallBackPostReturn(config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeAddFriend)
 }

internal/rpc/friend/friend.go

@@ -3,110 +3,60 @@ package friend
 import (
 	"Open_IM/internal/common/check"
 	"Open_IM/internal/common/convert"
-	"Open_IM/internal/common/rpc_server"
-	chat "Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/config"
+	"Open_IM/internal/common/notification"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/db/relation"
 	relationTb "Open_IM/pkg/common/db/table/relation"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/middleware"
-	prome "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
-	pbFriend "Open_IM/pkg/proto/friend"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	pbfriend "Open_IM/pkg/proto/friend"
 	"Open_IM/pkg/utils"
 	"context"
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
+	"github.com/OpenIMSDK/openKeeper"
 	"google.golang.org/grpc"
 )
 
 type friendServer struct {
-	*rpcserver.RpcServer
-
 	controller.FriendInterface
 	controller.BlackInterface
+	notification   *notification.Check
+	userCheck      *check.UserCheck
+	RegisterCenter discoveryRegistry.SvcDiscoveryRegistry
 }
 
-func NewFriendServer(port int) *friendServer {
-	r, err := rpcserver.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImFriendName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
+	mysql, err := relation.NewGormDB()
 	if err != nil {
-		panic(err)
+		return err
 	}
-	//mysql init
-	var mysql relation.Mysql
-	var model relation.FriendGorm
-	err = mysql.InitConn().AutoMigrateModel(&relationTb.FriendModel{})
-	if err != nil {
-		panic("db init err:" + err.Error())
-	}
-	err = mysql.InitConn().AutoMigrateModel(&relationTb.FriendRequestModel{})
-	if err != nil {
-		panic("db init err:" + err.Error())
-	}
-	err = mysql.InitConn().AutoMigrateModel(&relationTb.BlackModel{})
-	if err != nil {
-		panic("db init err:" + err.Error())
-	}
-	if mysql.GormConn() != nil {
-		model.DB = mysql.GormConn()
-	} else {
-		panic("db init err:" + "conn is nil")
-	}
-	return &friendServer{
-		RpcServer:       r,
-		FriendInterface: controller.NewFriendController(model.DB),
-		BlackInterface:  controller.NewBlackController(model.DB),
-	}
-}
-
-func (s *friendServer) Run() {
-	operationID := utils.OperationIDGenerator()
-	log.NewInfo(operationID, "friendServer run...")
-	listener, address, err := rpcserver.GetTcpListen(config.Config.ListenIP, s.Port)
-	if err != nil {
-		panic(err)
-	}
-
-	log.NewInfo(operationID, "listen ok ", address)
-	defer listener.Close()
-	//grpc server
-	var grpcOpts []grpc.ServerOption
-	grpcOpts = append(grpcOpts, grpc.UnaryInterceptor(middleware.RpcServerInterceptor))
-	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	pbFriend.RegisterFriendServer(srv, s)
-	err = srv.Serve(listener)
-	if err != nil {
-		log.NewError(operationID, "Serve failed ", err.Error(), listener)
-		return
+	if err := mysql.AutoMigrate(&relationTb.FriendModel{}, &relationTb.FriendRequestModel{}, &relationTb.BlackModel{}); err != nil {
+		return err
 	}
+	pbfriend.RegisterFriendServer(server, &friendServer{
+		FriendInterface: controller.NewFriendController(mysql),
+		BlackInterface:  controller.NewBlackController(mysql),
+		notification:    notification.NewCheck(client),
+		userCheck:       check.NewUserCheck(client),
+		RegisterCenter:  client,
+	})
+	return nil
 }
 
 // ok
-func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbFriend.ApplyToAddFriendReq) (resp *pbFriend.ApplyToAddFriendResp, err error) {
-	resp = &pbFriend.ApplyToAddFriendResp{}
+func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.ApplyToAddFriendReq) (resp *pbfriend.ApplyToAddFriendResp, err error) {
+	resp = &pbfriend.ApplyToAddFriendResp{}
 	if err := tokenverify.CheckAccessV3(ctx, req.FromUserID); err != nil {
 		return nil, err
 	}
-	if err := callbackBeforeAddFriendV1(ctx, req); err != nil {
+	if err := CallbackBeforeAddFriend(ctx, req); err != nil {
 		return nil, err
 	}
 	if req.ToUserID == req.FromUserID {
 		return nil, constant.ErrCanNotAddYourself.Wrap()
 	}
-	if _, err := check.GetUsersInfo(ctx, req.ToUserID, req.FromUserID); err != nil {
+	if _, err := s.userCheck.GetUsersInfoMap(ctx, []string{req.ToUserID, req.FromUserID}, true); err != nil {
 		return nil, err
 	}
 	in1, in2, err := s.FriendInterface.CheckIn(ctx, req.FromUserID, req.ToUserID)
@@ -119,17 +69,17 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbFriend.Apply
 	if err = s.FriendInterface.AddFriendRequest(ctx, req.FromUserID, req.ToUserID, req.ReqMsg, req.Ex); err != nil {
 		return nil, err
 	}
-	chat.FriendApplicationAddNotification(ctx, req)
+	s.notification.FriendApplicationAddNotification(ctx, req)
 	return resp, nil
 }
 
 // ok
-func (s *friendServer) ImportFriends(ctx context.Context, req *pbFriend.ImportFriendReq) (resp *pbFriend.ImportFriendResp, err error) {
-	resp = &pbFriend.ImportFriendResp{}
+func (s *friendServer) ImportFriends(ctx context.Context, req *pbfriend.ImportFriendReq) (resp *pbfriend.ImportFriendResp, err error) {
+	resp = &pbfriend.ImportFriendResp{}
 	if err := tokenverify.CheckAdmin(ctx); err != nil {
 		return nil, err
 	}
-	if _, err := check.GetUsersInfo(ctx, req.OwnerUserID, req.FriendUserIDs); err != nil {
+	if _, err := s.userCheck.GetUsersInfos(ctx, append([]string{req.OwnerUserID}, req.FriendUserIDs...), true); err != nil {
 		return nil, err
 	}
 
@@ -147,9 +97,9 @@ func (s *friendServer) ImportFriends(ctx context.Context, req *pbFriend.ImportFr
 }
 
 // ok
-func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.RespondFriendApplyReq) (resp *pbFriend.RespondFriendApplyResp, err error) {
-	resp = &pbFriend.RespondFriendApplyResp{}
-	if err := check.Access(ctx, req.ToUserID); err != nil {
+func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbfriend.RespondFriendApplyReq) (resp *pbfriend.RespondFriendApplyResp, err error) {
+	resp = &pbfriend.RespondFriendApplyResp{}
+	if err := s.userCheck.Access(ctx, req.ToUserID); err != nil {
 		return nil, err
 	}
 	friendRequest := relationTb.FriendRequestModel{FromUserID: req.FromUserID, ToUserID: req.ToUserID, HandleMsg: req.HandleMsg, HandleResult: req.HandleResult}
@@ -158,7 +108,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.Res
 		if err != nil {
 			return nil, err
 		}
-		chat.FriendApplicationAgreedNotification(ctx, req)
+		s.notification.FriendApplicationAgreedNotification(ctx, req)
 		return resp, nil
 	}
 	if req.HandleResult == constant.FriendResponseRefuse {
@@ -166,16 +116,16 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.Res
 		if err != nil {
 			return nil, err
 		}
-		chat.FriendApplicationRefusedNotification(ctx, req)
+		s.notification.FriendApplicationRefusedNotification(ctx, req)
 		return resp, nil
 	}
 	return nil, constant.ErrArgs.Wrap("req.HandleResult != -1/1")
 }
 
 // ok
-func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFriendReq) (resp *pbFriend.DeleteFriendResp, err error) {
-	resp = &pbFriend.DeleteFriendResp{}
-	if err := check.Access(ctx, req.OwnerUserID); err != nil {
+func (s *friendServer) DeleteFriend(ctx context.Context, req *pbfriend.DeleteFriendReq) (resp *pbfriend.DeleteFriendResp, err error) {
+	resp = &pbfriend.DeleteFriendResp{}
+	if err := s.userCheck.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
 	_, err = s.FindFriendsWithError(ctx, req.OwnerUserID, []string{req.FriendUserID})
@@ -185,14 +135,14 @@ func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFri
 	if err := s.FriendInterface.Delete(ctx, req.OwnerUserID, []string{req.FriendUserID}); err != nil {
 		return nil, err
 	}
-	chat.FriendDeletedNotification(ctx, req)
+	s.notification.FriendDeletedNotification(ctx, req)
 	return resp, nil
 }
 
 // ok
-func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFriendRemarkReq) (resp *pbFriend.SetFriendRemarkResp, err error) {
-	resp = &pbFriend.SetFriendRemarkResp{}
-	if err := check.Access(ctx, req.OwnerUserID); err != nil {
+func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbfriend.SetFriendRemarkReq) (resp *pbfriend.SetFriendRemarkResp, err error) {
+	resp = &pbfriend.SetFriendRemarkResp{}
+	if err := s.userCheck.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
 	_, err = s.FindFriendsWithError(ctx, req.OwnerUserID, []string{req.FriendUserID})
@@ -202,21 +152,21 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFri
 	if err := s.FriendInterface.UpdateRemark(ctx, req.OwnerUserID, req.FriendUserID, req.Remark); err != nil {
 		return nil, err
 	}
-	chat.FriendRemarkSetNotification(ctx, req.OwnerUserID, req.FriendUserID)
+	s.notification.FriendRemarkSetNotification(ctx, req.OwnerUserID, req.FriendUserID)
 	return resp, nil
 }
 
 // ok
-func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbFriend.GetDesignatedFriendsReq) (resp *pbFriend.GetDesignatedFriendsResp, err error) {
-	resp = &pbFriend.GetDesignatedFriendsResp{}
-	if err := check.Access(ctx, req.UserID); err != nil {
+func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbfriend.GetDesignatedFriendsReq) (resp *pbfriend.GetDesignatedFriendsResp, err error) {
+	resp = &pbfriend.GetDesignatedFriendsResp{}
+	if err := s.userCheck.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
 	friends, total, err := s.FriendInterface.PageOwnerFriends(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-	resp.FriendsInfo, err = (*convert.DBFriend)(nil).DB2PB(friends)
+	resp.FriendsInfo, err = (*convert.NewDBFriend(nil, s.RegisterCenter)).DB2PB(ctx, friends)
 	if err != nil {
 		return nil, err
 	}
@@ -225,16 +175,16 @@ func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbFriend.G
 }
 
 // ok 获取接收到的好友申请（即别人主动申请的）
-func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *pbFriend.GetPaginationFriendsApplyToReq) (resp *pbFriend.GetPaginationFriendsApplyToResp, err error) {
-	resp = &pbFriend.GetPaginationFriendsApplyToResp{}
-	if err := check.Access(ctx, req.UserID); err != nil {
+func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *pbfriend.GetPaginationFriendsApplyToReq) (resp *pbfriend.GetPaginationFriendsApplyToResp, err error) {
+	resp = &pbfriend.GetPaginationFriendsApplyToResp{}
+	if err := s.userCheck.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
 	friendRequests, total, err := s.FriendInterface.PageFriendRequestToMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-	resp.FriendRequests, err = (*convert.DBFriendRequest)(nil).DB2PB(friendRequests)
+	resp.FriendRequests, err = (*convert.NewDBFriendRequest(nil, s.RegisterCenter)).DB2PB(ctx, friendRequests)
 	if err != nil {
 		return nil, err
 	}
@@ -243,16 +193,16 @@ func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *pbF
 }
 
 // ok 获取主动发出去的好友申请列表
-func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *pbFriend.GetPaginationFriendsApplyFromReq) (resp *pbFriend.GetPaginationFriendsApplyFromResp, err error) {
-	resp = &pbFriend.GetPaginationFriendsApplyFromResp{}
-	if err := check.Access(ctx, req.UserID); err != nil {
+func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *pbfriend.GetPaginationFriendsApplyFromReq) (resp *pbfriend.GetPaginationFriendsApplyFromResp, err error) {
+	resp = &pbfriend.GetPaginationFriendsApplyFromResp{}
+	if err := s.userCheck.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
 	friendRequests, total, err := s.FriendInterface.PageFriendRequestFromMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-	resp.FriendRequests, err = (*convert.DBFriendRequest)(nil).DB2PB(friendRequests)
+	resp.FriendRequests, err = (*convert.NewDBFriendRequest(nil, s.RegisterCenter)).DB2PB(ctx, friendRequests)
 	if err != nil {
 		return nil, err
 	}
@@ -261,8 +211,8 @@ func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *p
 }
 
 // ok
-func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq) (resp *pbFriend.IsFriendResp, err error) {
-	resp = &pbFriend.IsFriendResp{}
+func (s *friendServer) IsFriend(ctx context.Context, req *pbfriend.IsFriendReq) (resp *pbfriend.IsFriendResp, err error) {
+	resp = &pbfriend.IsFriendResp{}
 	resp.InUser1Friends, resp.InUser2Friends, err = s.FriendInterface.CheckIn(ctx, req.UserID1, req.UserID2)
 	if err != nil {
 		return nil, err
@@ -271,8 +221,8 @@ func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq)
 }
 
 // ok
-func (s *friendServer) GetPaginationFriends(ctx context.Context, req *pbFriend.GetPaginationFriendsReq) (resp *pbFriend.GetPaginationFriendsResp, err error) {
-	resp = &pbFriend.GetPaginationFriendsResp{}
+func (s *friendServer) GetPaginationFriends(ctx context.Context, req *pbfriend.GetPaginationFriendsReq) (resp *pbfriend.GetPaginationFriendsResp, err error) {
+	resp = &pbfriend.GetPaginationFriendsResp{}
 	if utils.Duplicate(req.FriendUserIDs) {
 		return nil, constant.ErrArgs.Wrap("friend userID repeated")
 	}
@@ -280,7 +230,7 @@ func (s *friendServer) GetPaginationFriends(ctx context.Context, req *pbFriend.G
 	if err != nil {
 		return nil, err
 	}
-	if resp.FriendsInfo, err = (*convert.DBFriend)(nil).DB2PB(friends); err != nil {
+	if resp.FriendsInfo, err = (*convert.NewDBFriend(nil, s.RegisterCenter)).DB2PB(ctx, friends); err != nil {
 		return nil, err
 	}
 	return resp, nil

internal/rpc/group/callback.go

@@ -1,167 +1,139 @@
 package group
 
 import (
+	"Open_IM/pkg/apistruct"
 	"Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/http"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/tracelog"
-	pbGroup "Open_IM/pkg/proto/group"
+	"Open_IM/pkg/proto/group"
 	"Open_IM/pkg/utils"
 	"context"
 	"google.golang.org/protobuf/types/known/wrapperspb"
+	"time"
 )
 
-func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (err error) {
-	defer func() {
-		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", req)
-	}()
+func CallbackBeforeCreateGroup(ctx context.Context, req *group.CreateGroupReq) (err error) {
 	if !config.Config.Callback.CallbackBeforeCreateGroup.Enable {
 		return nil
 	}
-	commonCallbackReq := &cbApi.CallbackBeforeCreateGroupReq{
+	defer func() {
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", req)
+	}()
+	cbReq := &callbackstruct.CallbackBeforeCreateGroupReq{
 		CallbackCommand: constant.CallbackBeforeCreateGroupCommand,
-		OperationID:     req.OperationID,
+		OperationID:     tracelog.GetOperationID(ctx),
 		GroupInfo:       *req.GroupInfo,
-		InitMemberList:  req.InitMemberList,
 	}
-	callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID}
-	resp := &cbApi.CallbackBeforeCreateGroupResp{
-		CommonCallbackResp: &callbackResp,
+	cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+		UserID:    req.OwnerUserID,
+		RoleLevel: constant.GroupOwner,
+	})
+	for _, userID := range req.AdminUserIDs {
+		cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+			UserID:    userID,
+			RoleLevel: constant.GroupAdmin,
+		})
 	}
-	//utils.CopyStructFields(req, msg.MsgData)
-	defer log.NewDebug(req.OperationID, utils.GetSelfFuncName(), commonCallbackReq, *resp)
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeCreateGroupCommand, commonCallbackReq,
-		resp, config.Config.Callback.CallbackBeforeCreateGroup)
-	if err == nil {
-		if resp.GroupID != nil {
-			req.GroupInfo.GroupID = *resp.GroupID
-		}
-		if resp.GroupName != nil {
-			req.GroupInfo.GroupName = *resp.GroupName
-		}
-		if resp.Notification != nil {
-			req.GroupInfo.Notification = *resp.Notification
-		}
-		if resp.Introduction != nil {
-			req.GroupInfo.Introduction = *resp.Introduction
-		}
-		if resp.FaceURL != nil {
-			req.GroupInfo.FaceURL = *resp.FaceURL
-		}
-		if resp.OwnerUserID != nil {
-			req.GroupInfo.OwnerUserID = *resp.OwnerUserID
-		}
-		if resp.Ex != nil {
-			req.GroupInfo.Ex = *resp.Ex
-		}
-		if resp.Status != nil {
-			req.GroupInfo.Status = *resp.Status
-		}
-		if resp.CreatorUserID != nil {
-			req.GroupInfo.CreatorUserID = *resp.CreatorUserID
-		}
-		if resp.GroupType != nil {
-			req.GroupInfo.GroupType = *resp.GroupType
-		}
-		if resp.NeedVerification != nil {
-			req.GroupInfo.NeedVerification = *resp.NeedVerification
-		}
-		if resp.LookMemberInfo != nil {
-			req.GroupInfo.LookMemberInfo = *resp.LookMemberInfo
-		}
+	for _, userID := range req.AdminUserIDs {
+		cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+			UserID:    userID,
+			RoleLevel: constant.GroupOrdinaryUsers,
+		})
 	}
-	return err
+	resp := &callbackstruct.CallbackBeforeCreateGroupResp{}
+	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeCreateGroup)
+	if err != nil {
+		return err
+	}
+	utils.NotNilReplace(&req.GroupInfo.GroupID, resp.GroupID)
+	utils.NotNilReplace(&req.GroupInfo.GroupName, resp.GroupName)
+	utils.NotNilReplace(&req.GroupInfo.Notification, resp.Notification)
+	utils.NotNilReplace(&req.GroupInfo.Introduction, resp.Introduction)
+	utils.NotNilReplace(&req.GroupInfo.FaceURL, resp.FaceURL)
+	utils.NotNilReplace(&req.GroupInfo.OwnerUserID, resp.OwnerUserID)
+	utils.NotNilReplace(&req.GroupInfo.Ex, resp.Ex)
+	utils.NotNilReplace(&req.GroupInfo.Status, resp.Status)
+	utils.NotNilReplace(&req.GroupInfo.CreatorUserID, resp.CreatorUserID)
+	utils.NotNilReplace(&req.GroupInfo.GroupType, resp.GroupType)
+	utils.NotNilReplace(&req.GroupInfo.NeedVerification, resp.NeedVerification)
+	utils.NotNilReplace(&req.GroupInfo.LookMemberInfo, resp.LookMemberInfo)
+	return nil
 }
 
-func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, groupMember *relation.GroupMemberModel, groupEx string) (err error) {
-	defer func() {
-		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx)
-	}()
-	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+func CallbackBeforeMemberJoinGroup(ctx context.Context, groupMember *relation.GroupMemberModel, groupEx string) (err error) {
 	if !config.Config.Callback.CallbackBeforeMemberJoinGroup.Enable {
 		return nil
 	}
-	log.NewDebug(operationID, "args: ", *groupMember)
-	callbackReq := cbApi.CallbackBeforeMemberJoinGroupReq{
+	defer func() {
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx)
+	}()
+	callbackReq := &callbackstruct.CallbackBeforeMemberJoinGroupReq{
 		CallbackCommand: constant.CallbackBeforeMemberJoinGroupCommand,
-		OperationID:     operationID,
+		OperationID:     tracelog.GetOperationID(ctx),
 		GroupID:         groupMember.GroupID,
 		UserID:          groupMember.UserID,
 		Ex:              groupMember.Ex,
 		GroupEx:         groupEx,
 	}
-	resp := &cbApi.CallbackBeforeMemberJoinGroupResp{
-		CommonCallbackResp: &callbackResp,
+	resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{}
+	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeMemberJoinGroup)
+	if err != nil {
+		return err
 	}
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeMemberJoinGroupCommand, callbackReq,
-		resp, config.Config.Callback.CallbackBeforeMemberJoinGroup)
-	if err == nil {
-		if resp.MuteEndTime != nil {
-			groupMember.MuteEndTime = utils.UnixSecondToTime(*resp.MuteEndTime)
-		}
-		if resp.FaceURL != nil {
-			groupMember.FaceURL = *resp.FaceURL
-		}
-		if resp.Ex != nil {
-			groupMember.Ex = *resp.Ex
-		}
-		if resp.NickName != nil {
-			groupMember.Nickname = *resp.NickName
-		}
-		if resp.RoleLevel != nil {
-			groupMember.RoleLevel = *resp.RoleLevel
-		}
+	if resp.MuteEndTime != nil {
+		groupMember.MuteEndTime = time.UnixMilli(*resp.MuteEndTime)
 	}
-	return err
+	utils.NotNilReplace(&groupMember.FaceURL, resp.FaceURL)
+	utils.NotNilReplace(&groupMember.Ex, resp.Ex)
+	utils.NotNilReplace(&groupMember.Nickname, resp.Nickname)
+	utils.NotNilReplace(&groupMember.RoleLevel, resp.RoleLevel)
+	return nil
 }
 
-func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfo) (err error) {
-	defer func() {
-		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req)
-	}()
-	callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID}
+func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *group.SetGroupMemberInfo) (err error) {
 	if !config.Config.Callback.CallbackBeforeSetGroupMemberInfo.Enable {
 		return nil
 	}
-	callbackReq := cbApi.CallbackBeforeSetGroupMemberInfoReq{
+	defer func() {
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req)
+	}()
+	callbackReq := callbackstruct.CallbackBeforeSetGroupMemberInfoReq{
 		CallbackCommand: constant.CallbackBeforeSetGroupMemberInfoCommand,
-		OperationID:     req.OperationID,
+		OperationID:     tracelog.GetOperationID(ctx),
 		GroupID:         req.GroupID,
 		UserID:          req.UserID,
 	}
 	if req.Nickname != nil {
-		callbackReq.Nickname = req.Nickname.Value
+		callbackReq.Nickname = &req.Nickname.Value
 	}
 	if req.FaceURL != nil {
-		callbackReq.FaceURL = req.FaceURL.Value
+		callbackReq.FaceURL = &req.FaceURL.Value
 	}
 	if req.RoleLevel != nil {
-		callbackReq.RoleLevel = req.RoleLevel.Value
+		callbackReq.RoleLevel = &req.RoleLevel.Value
 	}
 	if req.Ex != nil {
-		callbackReq.Ex = req.Ex.Value
+		callbackReq.Ex = &req.Ex.Value
 	}
-	resp := &cbApi.CallbackBeforeSetGroupMemberInfoResp{
-		CommonCallbackResp: &callbackResp,
+	resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{}
+	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeSetGroupMemberInfo)
+	if err != nil {
+		return err
 	}
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSetGroupMemberInfoCommand, callbackReq,
-		resp, config.Config.Callback.CallbackBeforeSetGroupMemberInfo.CallbackTimeOut, &config.Config.Callback.CallbackBeforeSetGroupMemberInfo.CallbackFailedContinue)
-	if err == nil {
-		if resp.FaceURL != nil {
-			req.FaceURL = &wrapperspb.StringValue{Value: *resp.FaceURL}
-		}
-		if resp.Nickname != nil {
-			req.Nickname = &wrapperspb.StringValue{Value: *resp.Nickname}
-		}
-		if resp.RoleLevel != nil {
-			req.RoleLevel = &wrapperspb.Int32Value{Value: *resp.RoleLevel}
-		}
-		if resp.Ex != nil {
-			req.Ex = &wrapperspb.StringValue{Value: *resp.Ex}
-		}
+	if resp.FaceURL != nil {
+		req.FaceURL = wrapperspb.String(*resp.FaceURL)
 	}
-	return err
+	if resp.Nickname != nil {
+		req.Nickname = wrapperspb.String(*resp.Nickname)
+	}
+	if resp.RoleLevel != nil {
+		req.RoleLevel = wrapperspb.Int32(*resp.RoleLevel)
+	}
+	if resp.Ex != nil {
+		req.Ex = wrapperspb.String(*resp.Ex)
+	}
+	return nil
 }

internal/rpc/group/db_map.go

@@ -12,7 +12,7 @@ func UpdateGroupInfoMap(group *sdkws.GroupInfoForSet) map[string]any {
 		m["group_name"] = group.GroupName
 	}
 	if group.Notification != "" {
-		m["notification"] = group.Notification
+		m["Notification"] = group.Notification
 	}
 	if group.Introduction != "" {
 		m["introduction"] = group.Introduction

internal/rpc/group/g.go

@@ -1,94 +0,0 @@
-package group
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/tracelog"
-	pbConversation "Open_IM/pkg/proto/conversation"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"errors"
-	"math/big"
-	"strconv"
-	"strings"
-	"time"
-)
-
-func GetPublicUserInfoOne(ctx context.Context, userID string) (*sdkws.PublicUserInfo, error) {
-	return nil, errors.New("todo")
-}
-
-func GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) {
-	return nil, errors.New("todo")
-}
-
-func GetUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
-	users, err := GetUsersInfo(ctx, userIDs)
-	if err != nil {
-		return nil, err
-	}
-	return utils.SliceToMap(users, func(e *sdkws.UserInfo) string {
-		return e.UserID
-	}), nil
-}
-
-func GetPublicUserInfo(ctx context.Context, userIDs []string) ([]*sdkws.PublicUserInfo, error) {
-	return nil, errors.New("todo")
-}
-
-func GetPublicUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.PublicUserInfo, error) {
-	users, err := GetPublicUserInfo(ctx, userIDs)
-	if err != nil {
-		return nil, err
-	}
-	return utils.SliceToMap(users, func(e *sdkws.PublicUserInfo) string {
-		return e.UserID
-	}), nil
-}
-
-func GetUsername(ctx context.Context, userIDs []string) (map[string]string, error) {
-	if len(userIDs) == 0 {
-		return map[string]string{}, nil
-	}
-	users, err := GetPublicUserInfo(ctx, userIDs)
-	if err != nil {
-		return nil, err
-	}
-	if ids := utils.Single(userIDs, utils.Slice(users, func(e *sdkws.PublicUserInfo) string {
-		return e.UserID
-	})); len(ids) > 0 {
-		return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-	}
-	return utils.SliceToMapAny(users, func(e *sdkws.PublicUserInfo) (string, string) {
-		return e.UserID, e.Nickname
-	}), nil
-}
-
-func GroupNotification(ctx context.Context, groupID string) {
-	var conversationReq pbConversation.ModifyConversationFieldReq
-	conversation := pbConversation.Conversation{
-		OwnerUserID:      tracelog.GetOpUserID(ctx),
-		ConversationID:   utils.GetConversationIDBySessionType(groupID, constant.GroupChatType),
-		ConversationType: constant.GroupChatType,
-		GroupID:          groupID,
-	}
-	conversationReq.Conversation = &conversation
-	conversationReq.OperationID = tracelog.GetOperationID(ctx)
-	conversationReq.FieldType = constant.FieldGroupAtType
-	conversation.GroupAtType = constant.GroupNotification
-	conversationReq.UserIDList = cacheResp.UserIDList
-
-	_, err = pbConversation.NewConversationClient(s.etcdConn.GetConn("", config.Config.RpcRegisterName.OpenImConversationName)).ModifyConversationField(ctx, &conversationReq)
-	tracelog.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply)
-}
-
-func genGroupID(ctx context.Context, groupID string) string {
-	if groupID != "" {
-		return groupID
-	}
-	groupID = utils.Md5(tracelog.GetOperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
-	bi := big.NewInt(0)
-	bi.SetString(groupID[0:8], 16)
-	groupID = bi.String()
-	return groupID
-}

internal/rpc/group/group.go

@@ -1,120 +1,61 @@
 package group
 
 import (
-	"Open_IM/internal/common/network"
-	chat "Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/config"
+	"Open_IM/internal/common/check"
+	"Open_IM/internal/common/notification"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/cache"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/db/relation"
 	relationTb "Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/db/unrelation"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/middleware"
-	prome "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
-	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	pbConversation "Open_IM/pkg/proto/conversation"
 	pbGroup "Open_IM/pkg/proto/group"
 	"Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
 	"fmt"
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-	"net"
+	"github.com/OpenIMSDK/openKeeper"
+	"google.golang.org/grpc"
+	"gorm.io/gorm"
+	"math/big"
+	"math/rand"
 	"strconv"
 	"strings"
 	"time"
-
-	"github.com/OpenIMSDK/openKeeper"
-	"google.golang.org/grpc"
 )
 
+func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
+	db, err := relation.NewGormDB()
+	if err != nil {
+		return err
+	}
+	if err := db.AutoMigrate(&relationTb.GroupModel{}, &relationTb.GroupMemberModel{}, &relationTb.GroupRequestModel{}); err != nil {
+		return err
+	}
+	redis, err := cache.NewRedis()
+	if err != nil {
+		return err
+	}
+	mongo, err := unrelation.NewMongo()
+	if err != nil {
+		return err
+	}
+	pbGroup.RegisterGroupServer(server, &groupServer{
+		GroupInterface:      controller.NewGroupInterface(controller.NewGroupDatabase(db, redis.GetClient(), mongo.GetClient())),
+		UserCheck:           check.NewUserCheck(client),
+		ConversationChecker: check.NewConversationChecker(client),
+	})
+	return nil
+}
+
 type groupServer struct {
-	rpcPort         int
-	rpcRegisterName string
-	schema          string
-	zkAddr          []string
-	GroupInterface  controller.GroupInterface
-	registerCenter  discoveryRegistry.SvcDiscoveryRegistry
-}
-
-func NewGroupServer(port int) *groupServer {
-	log.NewPrivateLog(constant.LogFileName)
-	g := groupServer{
-		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImGroupName,
-		schema:          config.Config.Zookeeper.Schema,
-		zkAddr:          config.Config.Zookeeper.ZkAddr,
-	}
-	//mysql init
-	var mysql relation.Mysql
-	var mongo unrelation.Mongo
-	var groupModel relationTb.GroupModel
-	var redis cache.RedisClient
-	err := mysql.InitConn().AutoMigrateModel(&groupModel)
-	if err != nil {
-		panic("db init err:" + err.Error())
-	}
-	mongo.InitMongo()
-	redis.InitRedis()
-	mongo.CreateSuperGroupIndex()
-	zkClient, err := openKeeper.NewClient(config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema, 10, "", "")
-	if err != nil {
-		panic(err.Error())
-	}
-	registerIP, err := network.GetRpcRegisterIP(config.Config.RpcRegisterIP)
-	g.registerCenter = zkClient
-	err = g.registerCenter.Register(config.Config.RpcRegisterName.OpenImGroupName, registerIP, port)
-	if err != nil {
-		panic(err.Error())
-	}
-	//conns, err := g.registerCenter.GetConns(config.Config.RpcRegisterName.OpenImConversationName)
-	g.GroupInterface = controller.NewGroupInterface(mysql.GormConn(), redis.GetClient(), mongo.GetClient())
-	return &g
-}
-
-func (s *groupServer) Run() {
-	operationID := utils.OperationIDGenerator()
-	log.NewInfo(operationID, "group rpc start ")
-	address := network.GetListenIP(config.Config.ListenIP) + ":" + strconv.Itoa(s.rpcPort)
-	//listener network
-	listener, err := net.Listen("tcp", address)
-	if err != nil {
-		panic("listening err:" + err.Error() + s.rpcRegisterName)
-	}
-	log.NewInfo(operationID, "listen network success, ", address, listener)
-
-	defer listener.Close()
-	//grpc server
-	recvSize := 1024 * 1024 * constant.GroupRPCRecvSize
-	sendSize := 1024 * 1024 * constant.GroupRPCSendSize
-	var grpcOpts = []grpc.ServerOption{
-		grpc.MaxRecvMsgSize(recvSize),
-		grpc.MaxSendMsgSize(sendSize),
-		grpc.UnaryInterceptor(middleware.RpcServerInterceptor),
-	}
-	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	//Service registers with etcd
-	pbGroup.RegisterGroupServer(srv, s)
-	err = srv.Serve(listener)
-	if err != nil {
-		log.NewError(operationID, "Serve failed ", err.Error())
-		return
-	}
-	log.NewInfo(operationID, "group rpc success")
+	GroupInterface      controller.GroupInterface
+	UserCheck           *check.UserCheck
+	Notification        *notification.Check
+	ConversationChecker *check.ConversationChecker
 }
 
 func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error {
@@ -130,6 +71,52 @@ func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error
 	return nil
 }
 
+func (s *groupServer) GetUsernameMap(ctx context.Context, userIDs []string, complete bool) (map[string]string, error) {
+	if len(userIDs) == 0 {
+		return map[string]string{}, nil
+	}
+	users, err := s.UserCheck.GetPublicUserInfos(ctx, userIDs, complete)
+	if err != nil {
+		return nil, err
+	}
+	return utils.SliceToMapAny(users, func(e *sdkws.PublicUserInfo) (string, string) {
+		return e.UserID, e.Nickname
+	}), nil
+}
+
+func (s *groupServer) IsNotFound(err error) bool {
+	return utils.Unwrap(err) == gorm.ErrRecordNotFound
+}
+
+func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
+	if *groupID != "" {
+		_, err := s.GroupInterface.TakeGroup(ctx, *groupID)
+		if err == nil {
+			return constant.ErrGroupIDExisted.Wrap("group id existed " + *groupID)
+		} else if s.IsNotFound(err) {
+			return nil
+		} else {
+			return err
+		}
+	}
+	for i := 0; i < 10; i++ {
+		id := utils.Md5(strings.Join([]string{tracelog.GetOperationID(ctx), strconv.FormatInt(time.Now().UnixNano(), 10), strconv.Itoa(rand.Int())}, ",;,"))
+		bi := big.NewInt(0)
+		bi.SetString(id[0:8], 16)
+		id = bi.String()
+		_, err := s.GroupInterface.TakeGroup(ctx, id)
+		if err == nil {
+			continue
+		} else if s.IsNotFound(err) {
+			*groupID = id
+			return nil
+		} else {
+			return err
+		}
+	}
+	return constant.ErrData.Wrap("group id gen error")
+}
+
 func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) {
 	resp := &pbGroup.CreateGroupResp{GroupInfo: &sdkws.GroupInfo{}}
 	if err := tokenverify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
@@ -142,19 +129,18 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if utils.Duplicate(userIDs) {
 		return nil, constant.ErrArgs.Wrap("group member repeated")
 	}
-	userMap, err := GetUserInfoMap(ctx, userIDs)
+	userMap, err := s.UserCheck.GetUsersInfoMap(ctx, userIDs, true)
 	if err != nil {
 		return nil, err
 	}
-	if ids := utils.Single(userIDs, utils.Keys(userMap)); len(ids) > 0 {
-		return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-	}
-	if err := callbackBeforeCreateGroup(ctx, req); err != nil {
+	if err := CallbackBeforeCreateGroup(ctx, req); err != nil {
 		return nil, err
 	}
 	var groupMembers []*relationTb.GroupMemberModel
 	group := PbToDBGroupInfo(req.GroupInfo)
-	group.GroupID = genGroupID(ctx, req.GroupInfo.GroupID)
+	if err := s.GenGroupID(ctx, &group.GroupID); err != nil {
+		return nil, err
+	}
 	joinGroup := func(userID string, roleLevel int32) error {
 		groupMember := PbToDbGroupMember(userMap[userID])
 		groupMember.Nickname = ""
@@ -163,7 +149,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 		groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
 		groupMember.JoinSource = constant.JoinByInvitation
 		groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
-		if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), groupMember, group.Ex); err != nil {
+		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil {
 			return err
 		}
 		groupMembers = append(groupMembers, groupMember)
@@ -196,11 +182,11 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if req.GroupInfo.GroupType == constant.SuperGroup {
 		go func() {
 			for _, userID := range userIDs {
-				chat.SuperGroupNotification(tracelog.GetOperationID(ctx), userID, userID)
+				s.Notification.SuperGroupNotification(ctx, userID, userID)
 			}
 		}()
 	} else {
-		chat.GroupCreatedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), group.GroupID, userIDs)
+		s.Notification.GroupCreatedNotification(ctx, group.GroupID, userIDs)
 	}
 	return resp, nil
 }
@@ -269,13 +255,10 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	if ids := utils.Single(req.InvitedUserIDs, utils.Keys(memberMap)); len(ids) > 0 {
 		return nil, constant.ErrArgs.Wrap("user in group " + strings.Join(ids, ","))
 	}
-	userMap, err := GetUserInfoMap(ctx, req.InvitedUserIDs)
+	userMap, err := s.UserCheck.GetUsersInfoMap(ctx, req.InvitedUserIDs, true)
 	if err != nil {
 		return nil, err
 	}
-	if ids := utils.Single(req.InvitedUserIDs, utils.Keys(userMap)); len(ids) > 0 {
-		return nil, constant.ErrArgs.Wrap("user not found " + strings.Join(ids, ","))
-	}
 	if group.NeedVerification == constant.AllNeedVerification {
 		if !tokenverify.IsAppManagerUid(ctx) {
 			opUserID := tracelog.GetOpUserID(ctx)
@@ -297,7 +280,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 					return nil, err
 				}
 				for _, request := range requests {
-					chat.JoinGroupApplicationNotification(ctx, &pbGroup.JoinGroupReq{
+					s.Notification.JoinGroupApplicationNotification(ctx, &pbGroup.JoinGroupReq{
 						GroupID:       request.GroupID,
 						ReqMessage:    request.ReqMsg,
 						JoinSource:    request.JoinSource,
@@ -313,7 +296,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			return nil, err
 		}
 		for _, userID := range req.InvitedUserIDs {
-			chat.SuperGroupNotification(tracelog.GetOperationID(ctx), userID, userID)
+			s.Notification.SuperGroupNotification(ctx, userID, userID)
 		}
 	} else {
 		opUserID := tracelog.GetOpUserID(ctx)
@@ -326,7 +309,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			member.OperatorUserID = opUserID
 			member.InviterUserID = opUserID
 			member.JoinSource = constant.JoinByInvitation
-			if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), member, group.Ex); err != nil {
+			if err := CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil {
 				return nil, err
 			}
 			groupMembers = append(groupMembers, member)
@@ -334,7 +317,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 		if err := s.GroupInterface.CreateGroup(ctx, nil, groupMembers); err != nil {
 			return nil, err
 		}
-		chat.MemberInvitedNotification(tracelog.GetOperationID(ctx), req.GroupID, tracelog.GetOpUserID(ctx), req.Reason, req.InvitedUserIDs)
+		s.Notification.MemberInvitedNotification(ctx, req.GroupID, req.Reason, req.InvitedUserIDs)
 	}
 	return resp, nil
 }
@@ -352,9 +335,9 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
 	if err != nil {
 		return nil, err
 	}
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	if err != nil {
 		return nil, err
 	}
@@ -374,9 +357,9 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
 		return nil, err
 	}
 	resp.Total = total
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	if err != nil {
 		return nil, err
 	}
@@ -411,7 +394,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		}
 		go func() {
 			for _, userID := range req.KickedUserIDs {
-				chat.SuperGroupNotification(tracelog.GetOperationID(ctx), userID, userID)
+				s.Notification.SuperGroupNotification(ctx, userID, userID)
 			}
 		}()
 	} else {
@@ -451,7 +434,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		if err := s.GroupInterface.DeleteGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil {
 			return nil, err
 		}
-		chat.MemberKickedNotification(req, req.KickedUserIDs)
+		s.Notification.MemberKickedNotification(ctx, req, req.KickedUserIDs)
 	}
 	return resp, nil
 }
@@ -468,9 +451,9 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 	if err != nil {
 		return nil, err
 	}
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	if err != nil {
 		return nil, err
 	}
@@ -503,13 +486,10 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	}
 	userIDs = utils.Distinct(userIDs)
 	groupIDs = utils.Distinct(groupIDs)
-	userMap, err := GetPublicUserInfoMap(ctx, userIDs)
+	userMap, err := s.UserCheck.GetPublicUserInfoMap(ctx, userIDs, true)
 	if err != nil {
 		return nil, err
 	}
-	if ids := utils.Single(utils.Keys(userMap), userIDs); len(ids) > 0 {
-		return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-	}
 	groups, err := s.GroupInterface.FindGroup(ctx, utils.Distinct(groupIDs))
 	if err != nil {
 		return nil, err
@@ -588,19 +568,18 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 	if groupRequest.HandleResult != 0 {
 		return nil, constant.ErrArgs.Wrap("group request already processed")
 	}
-	if _, err := s.GroupInterface.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err != nil {
-		if !IsNotFound(err) {
-			return nil, err
-		}
-	} else {
-		return nil, constant.ErrArgs.Wrap("already in group")
+	var join bool
+	if _, err = s.GroupInterface.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err == nil {
+		join = true // 已经在群里了
+	} else if !s.IsNotFound(err) {
+		return nil, err
 	}
-	user, err := GetPublicUserInfoOne(ctx, req.FromUserID)
+	user, err := s.UserCheck.GetPublicUserInfo(ctx, req.FromUserID)
 	if err != nil {
 		return nil, err
 	}
 	var member *relationTb.GroupMemberModel
-	if req.HandleResult == constant.GroupResponseAgree {
+	if (!join) && req.HandleResult == constant.GroupResponseAgree {
 		member = &relationTb.GroupMemberModel{
 			GroupID:        req.GroupID,
 			UserID:         user.UserID,
@@ -613,25 +592,27 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 			OperatorUserID: tracelog.GetOpUserID(ctx),
 			Ex:             groupRequest.Ex,
 		}
-		if err = CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), member, group.Ex); err != nil {
+		if err = CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil {
 			return nil, err
 		}
 	}
 	if err := s.GroupInterface.HandlerGroupRequest(ctx, req.GroupID, req.FromUserID, req.HandledMsg, req.HandleResult, member); err != nil {
 		return nil, err
 	}
-	if req.HandleResult == constant.GroupResponseAgree {
-		chat.GroupApplicationAcceptedNotification(req)
-		chat.MemberEnterNotification(req)
-	} else if req.HandleResult == constant.GroupResponseRefuse {
-		chat.GroupApplicationRejectedNotification(req)
+	if !join {
+		if req.HandleResult == constant.GroupResponseAgree {
+			s.Notification.GroupApplicationAcceptedNotification(ctx, req)
+			s.Notification.MemberEnterNotification(ctx, req)
+		} else if req.HandleResult == constant.GroupResponseRefuse {
+			s.Notification.GroupApplicationRejectedNotification(ctx, req)
+		}
 	}
 	return resp, nil
 }
 
 func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) {
 	resp := &pbGroup.JoinGroupResp{}
-	if _, err := GetPublicUserInfoOne(ctx, tracelog.GetOpUserID(ctx)); err != nil {
+	if _, err := s.UserCheck.GetPublicUserInfo(ctx, tracelog.GetOpUserID(ctx)); err != nil {
 		return nil, err
 	}
 	group, err := s.GroupInterface.TakeGroup(ctx, req.GroupID)
@@ -655,13 +636,13 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
 		groupMember.JoinSource = constant.JoinByInvitation
 		groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
-		if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), groupMember, group.Ex); err != nil {
+		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil {
 			return nil, err
 		}
 		if err := s.GroupInterface.CreateGroup(ctx, nil, []*relationTb.GroupMemberModel{groupMember}); err != nil {
 			return nil, err
 		}
-		chat.MemberEnterDirectlyNotification(req.GroupID, tracelog.GetOpUserID(ctx), tracelog.GetOperationID(ctx))
+		s.Notification.MemberEnterDirectlyNotification(ctx, req.GroupID, tracelog.GetOpUserID(ctx), tracelog.GetOperationID(ctx))
 		return resp, nil
 	}
 	groupRequest := relationTb.GroupRequestModel{
@@ -674,7 +655,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 	if err := s.GroupInterface.CreateGroupRequest(ctx, []*relationTb.GroupRequestModel{&groupRequest}); err != nil {
 		return nil, err
 	}
-	chat.JoinGroupApplicationNotification(ctx, req)
+	s.Notification.JoinGroupApplicationNotification(ctx, req)
 	return resp, nil
 }
 
@@ -688,13 +669,13 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
 		if err := s.GroupInterface.DeleteSuperGroupMember(ctx, req.GroupID, []string{tracelog.GetOpUserID(ctx)}); err != nil {
 			return nil, err
 		}
-		chat.SuperGroupNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), tracelog.GetOpUserID(ctx))
+		s.Notification.SuperGroupNotification(ctx, tracelog.GetOpUserID(ctx), tracelog.GetOpUserID(ctx))
 	} else {
 		_, err := s.GroupInterface.TakeGroupMember(ctx, req.GroupID, tracelog.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
-		chat.MemberQuitNotification(req)
+		s.Notification.MemberQuitNotification(ctx, req)
 	}
 	return resp, nil
 }
@@ -717,6 +698,10 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 	if group.Status == constant.GroupStatusDismissed {
 		return nil, utils.Wrap(constant.ErrDismissedAlready, "")
 	}
+	userIDs, err := s.GroupInterface.FindGroupMemberUserID(ctx, group.GroupID)
+	if err != nil {
+		return nil, err
+	}
 	data := UpdateGroupInfoMap(req.GroupInfoForSet)
 	if len(data) > 0 {
 		return resp, nil
@@ -728,9 +713,21 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 	if err != nil {
 		return nil, err
 	}
-	chat.GroupInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupInfoForSet.GroupID, group.GroupName, group.Notification, group.Introduction, group.FaceURL, req.GroupInfoForSet.NeedVerification)
+	s.Notification.GroupInfoSetNotification(ctx, req.GroupInfoForSet.GroupID, group.GroupName, group.Notification, group.Introduction, group.FaceURL, req.GroupInfoForSet.NeedVerification)
 	if req.GroupInfoForSet.Notification != "" {
-		GroupNotification(ctx, group.GroupID)
+		args := pbConversation.ModifyConversationFieldReq{
+			Conversation: &pbConversation.Conversation{
+				OwnerUserID:      tracelog.GetOpUserID(ctx),
+				ConversationID:   utils.GetConversationIDBySessionType(group.GroupID, constant.GroupChatType),
+				ConversationType: constant.GroupChatType,
+				GroupID:          group.GroupID,
+			},
+			FieldType:  constant.FieldGroupAtType,
+			UserIDList: userIDs,
+		}
+		if err := s.ConversationChecker.ModifyConversationField(ctx, &args); err != nil {
+			tracelog.SetCtxWarn(ctx, "ModifyConversationField", err, args)
+		}
 	}
 	return resp, nil
 }
@@ -778,7 +775,7 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
 	if err := s.GroupInterface.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil {
 		return nil, err
 	}
-	chat.GroupOwnerTransferredNotification(req)
+	s.Notification.GroupOwnerTransferredNotification(ctx, req)
 	return resp, nil
 }
 
@@ -828,9 +825,9 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
 		return nil, err
 	}
 	resp.Total = total
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	if err != nil {
 		return nil, err
 	}
@@ -845,7 +842,7 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
 
 func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGroup.GetUserReqApplicationListReq) (*pbGroup.GetUserReqApplicationListResp, error) {
 	resp := &pbGroup.GetUserReqApplicationListResp{}
-	user, err := GetPublicUserInfoOne(ctx, req.UserID)
+	user, err := s.UserCheck.GetPublicUserInfo(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -910,7 +907,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 			return nil, err
 		}
 	} else {
-		chat.GroupDismissedNotification(req)
+		s.Notification.GroupDismissedNotification(ctx, req)
 	}
 	return resp, nil
 }
@@ -934,7 +931,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
 	if err := s.GroupInterface.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
 		return nil, err
 	}
-	chat.GroupMemberMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID, req.MutedSeconds)
+	s.Notification.GroupMemberMutedNotification(ctx, req.GroupID, req.UserID, req.MutedSeconds)
 	return resp, nil
 }
 
@@ -957,7 +954,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 	if err := s.GroupInterface.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
 		return nil, err
 	}
-	chat.GroupMemberCancelMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID)
+	s.Notification.GroupMemberCancelMutedNotification(ctx, req.GroupID, req.UserID)
 	return resp, nil
 }
 
@@ -969,7 +966,7 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq)
 	if err := s.GroupInterface.UpdateGroup(ctx, req.GroupID, UpdateGroupStatusMap(constant.GroupStatusMuted)); err != nil {
 		return nil, err
 	}
-	chat.GroupMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID)
+	s.Notification.GroupMutedNotification(ctx, req.GroupID)
 	return resp, nil
 }
 
@@ -981,7 +978,7 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
 	if err := s.GroupInterface.UpdateGroup(ctx, req.GroupID, UpdateGroupStatusMap(constant.GroupOk)); err != nil {
 		return nil, err
 	}
-	chat.GroupCancelMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID)
+	s.Notification.GroupCancelMutedNotification(ctx, req.GroupID)
 	return resp, nil
 }
 
@@ -1058,7 +1055,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 		return nil, err
 	}
 	for _, member := range req.Members {
-		chat.GroupMemberInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), member.GroupID, member.UserID)
+		s.Notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID)
 	}
 	return resp, nil
 }
@@ -1103,9 +1100,9 @@ func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.Ge
 	if err != nil {
 		return nil, err
 	}
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	if err != nil {
 		return nil, err
 	}
@@ -1127,3 +1124,27 @@ func (s *groupServer) GetGroupMemberUserID(ctx context.Context, req *pbGroup.Get
 	}
 	return resp, nil
 }
+
+func (s *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbGroup.GetGroupMemberRoleLevelReq) (*pbGroup.GetGroupMemberRoleLevelResp, error) {
+	resp := &pbGroup.GetGroupMemberRoleLevelResp{}
+	if len(req.RoleLevels) == 0 {
+		return nil, constant.ErrArgs.Wrap("RoleLevels empty")
+	}
+	members, err := s.GroupInterface.FindGroupMember(ctx, []string{req.GroupID}, nil, req.RoleLevels)
+	if err != nil {
+		return nil, err
+	}
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+		return e.UserID, e.Nickname == ""
+	}), true)
+	if err != nil {
+		return nil, err
+	}
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
+		if e.Nickname == "" {
+			e.Nickname = nameMap[e.UserID]
+		}
+		return DbToPbGroupMembersCMSResp(e)
+	})
+	return resp, nil
+}

internal/rpc/group/utils.go

@@ -1,13 +0,0 @@
-package group
-
-import (
-	"Open_IM/pkg/common/tracelog"
-	"gorm.io/gorm"
-)
-
-func IsNotFound(err error) bool {
-	if err == nil {
-		return false
-	}
-	return tracelog.Unwrap(err) == gorm.ErrRecordNotFound
-}

internal/rpc/msg/callback.go

@@ -1,23 +1,27 @@
 package msg
 
 import (
-	cbApi "Open_IM/pkg/callback_struct"
-	"Open_IM/pkg/common/callback"
+	cbapi "Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/http"
-	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/tracelog"
 	pbChat "Open_IM/pkg/proto/msg"
 	"Open_IM/pkg/utils"
-	http2 "net/http"
+	"context"
 )
 
-func copyCallbackCommonReqStruct(msg *pbChat.SendMsgReq) cbApi.CommonCallbackReq {
-	req := cbApi.CommonCallbackReq{
+func cbURL() string {
+	return config.Config.Callback.CallbackUrl
+}
+
+func toCommonCallback(ctx context.Context, msg *pbChat.SendMsgReq, command string) cbapi.CommonCallbackReq {
+	return cbapi.CommonCallbackReq{
 		SendID:           msg.MsgData.SendID,
 		ServerMsgID:      msg.MsgData.ServerMsgID,
+		CallbackCommand:  command,
 		ClientMsgID:      msg.MsgData.ClientMsgID,
-		OperationID:      msg.OperationID,
+		OperationID:      tracelog.GetOperationID(ctx),
 		SenderPlatformID: msg.MsgData.SenderPlatformID,
 		SenderNickname:   msg.MsgData.SenderNickname,
 		SessionType:      msg.MsgData.SessionType,
@@ -27,202 +31,90 @@ func copyCallbackCommonReqStruct(msg *pbChat.SendMsgReq) cbApi.CommonCallbackReq
 		CreateTime:       msg.MsgData.CreateTime,
 		AtUserIDList:     msg.MsgData.AtUserIDList,
 		SenderFaceURL:    msg.MsgData.SenderFaceURL,
-		Content:          callback.GetContent(msg.MsgData),
+		Content:          utils.GetContent(msg.MsgData),
 		Seq:              msg.MsgData.Seq,
 		Ex:               msg.MsgData.Ex,
 	}
-	return req
 }
 
-func callbackBeforeSendSingleMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: msg.OperationID}
+func CallbackBeforeSendSingleMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
 	if !config.Config.Callback.CallbackBeforeSendSingleMsg.Enable {
-		return callbackResp
+		return nil
 	}
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
-	commonCallbackReq := copyCallbackCommonReqStruct(msg)
-	commonCallbackReq.CallbackCommand = constant.CallbackBeforeSendSingleMsgCommand
-	req := cbApi.CallbackBeforeSendSingleMsgReq{
-		CommonCallbackReq: commonCallbackReq,
+	req := &cbapi.CallbackBeforeSendSingleMsgReq{
+		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackBeforeSendSingleMsgCommand),
 		RecvID:            msg.MsgData.RecvID,
 	}
-	resp := &cbApi.CallbackBeforeSendSingleMsgResp{
-		CommonCallbackResp: &callbackResp,
-	}
-	//utils.CopyStructFields(req, msg.MsgData)
-	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSendSingleMsgCommand,
-		req, resp, config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackTimeOut, &config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackFailedContinue); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
-	}
-	return callbackResp
+	resp := &cbapi.CallbackBeforeSendSingleMsgResp{}
+	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackBeforeSendSingleMsg)
 }
 
-func callbackAfterSendSingleMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: msg.OperationID}
+func CallbackAfterSendSingleMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
 	if !config.Config.Callback.CallbackAfterSendSingleMsg.Enable {
-		return callbackResp
+		return nil
 	}
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
-	commonCallbackReq := copyCallbackCommonReqStruct(msg)
-	commonCallbackReq.CallbackCommand = constant.CallbackAfterSendSingleMsgCommand
-	req := cbApi.CallbackAfterSendSingleMsgReq{
-		CommonCallbackReq: commonCallbackReq,
+	req := &cbapi.CallbackAfterSendSingleMsgReq{
+		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackBeforeSendSingleMsgCommand),
 		RecvID:            msg.MsgData.RecvID,
 	}
-	resp := &cbApi.CallbackAfterSendSingleMsgResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAfterSendSingleMsgCommand,
-		req, resp, config.Config.Callback.CallbackAfterSendSingleMsg.CallbackTimeOut, &config.Config.Callback.CallbackAfterSendSingleMsg.CallbackFailedContinue); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		return callbackResp
-	}
-	return callbackResp
+	resp := &cbapi.CallbackAfterSendSingleMsgResp{}
+	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendSingleMsg)
 }
 
-func callbackBeforeSendGroupMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: msg.OperationID}
-	if !config.Config.Callback.CallbackBeforeSendGroupMsg.Enable {
-		return callbackResp
+func CallbackBeforeSendGroupMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
+	if !config.Config.Callback.CallbackAfterSendSingleMsg.Enable {
+		return nil
 	}
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
-	commonCallbackReq := copyCallbackCommonReqStruct(msg)
-	commonCallbackReq.CallbackCommand = constant.CallbackBeforeSendGroupMsgCommand
-	req := cbApi.CallbackAfterSendGroupMsgReq{
-		CommonCallbackReq: commonCallbackReq,
+	req := &cbapi.CallbackAfterSendGroupMsgReq{
+		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackBeforeSendSingleMsgCommand),
 		GroupID:           msg.MsgData.GroupID,
 	}
-	resp := &cbApi.CallbackBeforeSendGroupMsgResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSendGroupMsgCommand,
-		req, resp, config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackTimeOut, &config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackFailedContinue); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
-	}
-	return callbackResp
+	resp := &cbapi.CallbackBeforeSendGroupMsgResp{}
+	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendSingleMsg)
 }
 
-func callbackAfterSendGroupMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: msg.OperationID}
+func CallbackAfterSendGroupMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
 	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
-		return callbackResp
+		return nil
 	}
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
-	commonCallbackReq := copyCallbackCommonReqStruct(msg)
-	commonCallbackReq.CallbackCommand = constant.CallbackAfterSendGroupMsgCommand
-	req := cbApi.CallbackAfterSendGroupMsgReq{
-		CommonCallbackReq: commonCallbackReq,
+	req := &cbapi.CallbackAfterSendGroupMsgReq{
+		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackAfterSendGroupMsgCommand),
 		GroupID:           msg.MsgData.GroupID,
 	}
-	resp := &cbApi.CallbackAfterSendGroupMsgResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAfterSendGroupMsgCommand, req, resp,
-		config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		return callbackResp
-	}
-	return callbackResp
+	resp := &cbapi.CallbackAfterSendGroupMsgResp{}
+	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
 }
 
-func callbackMsgModify(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
-	callbackResp := cbApi.CommonCallbackResp{OperationID: msg.OperationID}
+func CallbackMsgModify(ctx context.Context, msg *pbChat.SendMsgReq) error {
 	if !config.Config.Callback.CallbackMsgModify.Enable || msg.MsgData.ContentType != constant.Text {
-		return callbackResp
+		return nil
 	}
-	commonCallbackReq := copyCallbackCommonReqStruct(msg)
-	commonCallbackReq.CallbackCommand = constant.CallbackMsgModifyCommand
-	req := cbApi.CallbackMsgModifyCommandReq{
-		CommonCallbackReq: commonCallbackReq,
+	req := &cbapi.CallbackMsgModifyCommandReq{
+		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackMsgModifyCommand),
 	}
-	resp := &cbApi.CallbackMsgModifyCommandResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackMsgModifyCommand, req, resp,
-		config.Config.Callback.CallbackMsgModify.CallbackTimeOut, &config.Config.Callback.CallbackMsgModify.CallbackFailedContinue); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !config.Config.Callback.CallbackMsgModify.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
+	resp := &cbapi.CallbackMsgModifyCommandResp{}
+	if err := http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg); err != nil {
+		return err
 	}
-	if resp.ErrCode == constant.CallbackHandleSuccess && resp.ActionCode == constant.ActionAllow {
-		if resp.Content != nil {
-			msg.MsgData.Content = []byte(*resp.Content)
-		}
-		if resp.RecvID != nil {
-			msg.MsgData.RecvID = *resp.RecvID
-		}
-		if resp.GroupID != nil {
-			msg.MsgData.GroupID = *resp.GroupID
-		}
-		if resp.ClientMsgID != nil {
-			msg.MsgData.ClientMsgID = *resp.ClientMsgID
-		}
-		if resp.ServerMsgID != nil {
-			msg.MsgData.ServerMsgID = *resp.ServerMsgID
-		}
-		if resp.SenderPlatformID != nil {
-			msg.MsgData.SenderPlatformID = *resp.SenderPlatformID
-		}
-		if resp.SenderNickname != nil {
-			msg.MsgData.SenderNickname = *resp.SenderNickname
-		}
-		if resp.SenderFaceURL != nil {
-			msg.MsgData.SenderFaceURL = *resp.SenderFaceURL
-		}
-		if resp.SessionType != nil {
-			msg.MsgData.SessionType = *resp.SessionType
-		}
-		if resp.MsgFrom != nil {
-			msg.MsgData.MsgFrom = *resp.MsgFrom
-		}
-		if resp.ContentType != nil {
-			msg.MsgData.ContentType = *resp.ContentType
-		}
-		if resp.Status != nil {
-			msg.MsgData.Status = *resp.Status
-		}
-		if resp.Options != nil {
-			msg.MsgData.Options = *resp.Options
-		}
-		if resp.OfflinePushInfo != nil {
-			msg.MsgData.OfflinePushInfo = resp.OfflinePushInfo
-		}
-		if resp.AtUserIDList != nil {
-			msg.MsgData.AtUserIDList = *resp.AtUserIDList
-		}
-		if resp.MsgDataList != nil {
-			msg.MsgData.MsgDataList = *resp.MsgDataList
-		}
-		if resp.AttachedInfo != nil {
-			msg.MsgData.AttachedInfo = *resp.AttachedInfo
-		}
-		if resp.Ex != nil {
-			msg.MsgData.Ex = *resp.Ex
-		}
-
+	if resp.Content != nil {
+		msg.MsgData.Content = []byte(*resp.Content)
 	}
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), string(msg.MsgData.Content))
-	return callbackResp
+	utils.NotNilReplace(msg.MsgData.OfflinePushInfo, resp.OfflinePushInfo)
+	utils.NotNilReplace(&msg.MsgData.RecvID, resp.RecvID)
+	utils.NotNilReplace(&msg.MsgData.GroupID, resp.GroupID)
+	utils.NotNilReplace(&msg.MsgData.ClientMsgID, resp.ClientMsgID)
+	utils.NotNilReplace(&msg.MsgData.ServerMsgID, resp.ServerMsgID)
+	utils.NotNilReplace(&msg.MsgData.SenderPlatformID, resp.SenderPlatformID)
+	utils.NotNilReplace(&msg.MsgData.SenderNickname, resp.SenderNickname)
+	utils.NotNilReplace(&msg.MsgData.SenderFaceURL, resp.SenderFaceURL)
+	utils.NotNilReplace(&msg.MsgData.SessionType, resp.SessionType)
+	utils.NotNilReplace(&msg.MsgData.MsgFrom, resp.MsgFrom)
+	utils.NotNilReplace(&msg.MsgData.ContentType, resp.ContentType)
+	utils.NotNilReplace(&msg.MsgData.Status, resp.Status)
+	utils.NotNilReplace(&msg.MsgData.Options, resp.Options)
+	utils.NotNilReplace(&msg.MsgData.AtUserIDList, resp.AtUserIDList)
+	utils.NotNilReplace(&msg.MsgData.MsgDataList, resp.MsgDataList)
+	utils.NotNilReplace(&msg.MsgData.AttachedInfo, resp.AttachedInfo)
+	utils.NotNilReplace(&msg.MsgData.Ex, resp.Ex)
+	return nil
 }

internal/rpc/msg/chat.go

@@ -1,63 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tokenverify"
-	pbChat "Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	"context"
-)
-
-func (rpc *rpcChat) ClearMsg(_ context.Context, req *pbChat.ClearMsgReq) (*pbChat.ClearMsgResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc req: ", req.String())
-	if req.OpUserID != req.UserID && !tokenverify.IsManagerUserID(req.UserID) {
-		errMsg := "No permission" + req.OpUserID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.ClearMsgResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: errMsg}, nil
-	}
-	log.Debug(req.OperationID, "CleanUpOneUserAllMsgFromRedis args", req.UserID)
-	err := db.DB.CleanUpOneUserAllMsgFromRedis(req.UserID, req.OperationID)
-	if err != nil {
-		errMsg := "CleanUpOneUserAllMsgFromRedis failed " + err.Error() + req.OperationID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-	}
-	log.Debug(req.OperationID, "CleanUpUserMsgFromMongo args", req.UserID)
-	err = db.DB.CleanUpUserMsgFromMongo(req.UserID, req.OperationID)
-	if err != nil {
-		errMsg := "CleanUpUserMsgFromMongo failed " + err.Error() + req.OperationID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-	}
-
-	resp := pbChat.ClearMsgResp{ErrCode: 0}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return &resp, nil
-}
-
-func (rpc *rpcChat) SetMsgMinSeq(_ context.Context, req *pbChat.SetMsgMinSeqReq) (*pbChat.SetMsgMinSeqResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc req: ", req.String())
-	if req.OpUserID != req.UserID && !tokenverify.IsManagerUserID(req.UserID) {
-		errMsg := "No permission" + req.OpUserID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: errMsg}, nil
-	}
-	if req.GroupID == "" {
-		err := db.DB.SetUserMinSeq(req.UserID, req.MinSeq)
-		if err != nil {
-			errMsg := "SetUserMinSeq failed " + err.Error() + req.OperationID + req.UserID + utils.Uint32ToString(req.MinSeq)
-			log.Error(req.OperationID, errMsg)
-			return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-		}
-		return &pbChat.SetMsgMinSeqResp{}, nil
-	}
-	err := db.DB.SetGroupUserMinSeq(req.GroupID, req.UserID, uint64(req.MinSeq))
-	if err != nil {
-		errMsg := "SetGroupUserMinSeq failed " + err.Error() + req.OperationID + req.GroupID + req.UserID + utils.Uint32ToString(req.MinSeq)
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-	}
-	return &pbChat.SetMsgMinSeqResp{}, nil
-}

internal/rpc/msg/del_msg.go

@@ -1,56 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tokenverify"
-	"Open_IM/pkg/proto/msg"
-	common "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"time"
-)
-
-func (rpc *rpcChat) DelMsgList(_ context.Context, req *common.DelMsgListReq) (*common.DelMsgListResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &common.DelMsgListResp{}
-	select {
-	case rpc.delMsgCh <- deleteMsg{
-		UserID:      req.UserID,
-		OpUserID:    req.OpUserID,
-		SeqList:     req.SeqList,
-		OperationID: req.OperationID,
-	}:
-	case <-time.After(1 * time.Second):
-		resp.ErrCode = constant.ErrSendLimit.ErrCode
-		resp.ErrMsg = constant.ErrSendLimit.ErrMsg
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-func (rpc *rpcChat) DelSuperGroupMsg(ctx context.Context, req *msg.DelSuperGroupMsgReq) (*msg.DelSuperGroupMsgResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	if !tokenverify.CheckAccess(ctx, req.OpUserID, req.UserID) {
-		log.NewError(req.OperationID, "CheckAccess false ", req.OpUserID, req.UserID)
-		return &msg.DelSuperGroupMsgResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}, nil
-	}
-	resp := &msg.DelSuperGroupMsgResp{}
-	groupMaxSeq, err := db.DB.GetGroupMaxSeq(req.GroupID)
-	if err != nil {
-		log.NewError(req.OperationID, "GetGroupMaxSeq false ", req.OpUserID, req.UserID, req.GroupID)
-		resp.ErrCode = constant.ErrDB.ErrCode
-		resp.ErrMsg = err.Error()
-		return resp, nil
-	}
-	err = db.DB.SetGroupUserMinSeq(req.GroupID, req.UserID, groupMaxSeq)
-	if err != nil {
-		log.NewError(req.OperationID, "SetGroupUserMinSeq false ", req.OpUserID, req.UserID, req.GroupID)
-		resp.ErrCode = constant.ErrDB.ErrCode
-		resp.ErrMsg = err.Error()
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}

internal/rpc/msg/delete.go

@@ -0,0 +1,43 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/tokenverify"
+	"Open_IM/pkg/proto/msg"
+	common "Open_IM/pkg/proto/sdkws"
+	"context"
+)
+
+func (m *msgServer) DelMsgList(ctx context.Context, req *common.DelMsgListReq) (*common.DelMsgListResp, error) {
+	resp := &common.DelMsgListResp{}
+	if err := m.MsgInterface.DelMsgFromCache(ctx, req.UserID, req.SeqList); err != nil {
+		return nil, err
+	}
+	DeleteMessageNotification(ctx, req.UserID, req.SeqList)
+	return resp, nil
+}
+
+func (m *msgServer) DelSuperGroupMsg(ctx context.Context, req *msg.DelSuperGroupMsgReq) (*msg.DelSuperGroupMsgResp, error) {
+	resp := &msg.DelSuperGroupMsgResp{}
+	if err := tokenverify.CheckAdmin(ctx); err != nil {
+		return nil, err
+	}
+	maxSeq, err := m.MsgInterface.GetGroupMaxSeq(ctx, req.GroupID)
+	if err != nil {
+		return nil, err
+	}
+	if err := m.MsgInterface.SetGroupUserMinSeq(ctx, req.GroupID, maxSeq); err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+func (m *msgServer) ClearMsg(ctx context.Context, req *msg.ClearMsgReq) (*msg.ClearMsgResp, error) {
+	resp := &msg.ClearMsgResp{}
+	if err := tokenverify.CheckAccessV3(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+	if err := m.MsgInterface.DelUserAllSeq(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+	return resp, nil
+}

internal/rpc/msg/extend_msg.go

@@ -1,6 +1,7 @@
 package msg
 
 import (
+	"Open_IM/internal/common/notification"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/log"
@@ -13,12 +14,12 @@ import (
 	"time"
 )
 
-func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.SetMessageReactionExtensionsReq) (resp *msg.SetMessageReactionExtensionsResp, err error) {
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc args is:", req.String())
+func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.SetMessageReactionExtensionsReq) (resp *msg.SetMessageReactionExtensionsResp, err error) {
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m args is:", req.String())
 	var rResp msg.SetMessageReactionExtensionsResp
 	rResp.ClientMsgID = req.ClientMsgID
 	rResp.MsgFirstModifyTime = req.MsgFirstModifyTime
-	callbackResp := callbackSetMessageReactionExtensions(req)
+	callbackResp := notification.callbackSetMessageReactionExtensions(req)
 	if callbackResp.ActionCode != constant.ActionAllow || callbackResp.ErrCode != 0 {
 		rResp.ErrCode = int32(callbackResp.ErrCode)
 		rResp.ErrMsg = callbackResp.ErrMsg
@@ -41,7 +42,7 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 		}
 		rResp.MsgFirstModifyTime = callbackResp.MsgFirstModifyTime
 		rResp.Result = callbackResp.ResultReactionExtensionList
-		ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, isHistory, false)
+		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, isHistory, false)
 		return &rResp, nil
 	}
 	for _, v := range callbackResp.ResultReactionExtensionList {
@@ -71,7 +72,7 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 			log.Debug(req.OperationID, "redis handle firstly", req.String())
 			rResp.MsgFirstModifyTime = utils.GetCurrentTimestampByMill()
 			for k, v := range req.ReactionExtensionList {
-				err := rpc.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, k)
+				err := m.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, k)
 				if err != nil {
 					setKeyResultInfo(&rResp, 100, err.Error(), req.ClientMsgID, k, v)
 					continue
@@ -90,7 +91,7 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 				log.Error(req.OperationID, "SetMessageReactionExpire err:", err.Error(), req.String())
 			}
 		} else {
-			err := rpc.dMessageLocker.LockGlobalMessage(req.ClientMsgID)
+			err := m.dMessageLocker.LockGlobalMessage(req.ClientMsgID)
 			if err != nil {
 				rResp.ErrCode = 100
 				rResp.ErrMsg = err.Error()
@@ -148,7 +149,7 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 					rResp.Result = append(rResp.Result, temp)
 				}
 			}
-			lockErr := rpc.dMessageLocker.UnLockGlobalMessage(req.ClientMsgID)
+			lockErr := m.dMessageLocker.UnLockGlobalMessage(req.ClientMsgID)
 			if lockErr != nil {
 				log.Error(req.OperationID, "UnLockGlobalMessage err:", lockErr.Error())
 			}
@@ -158,7 +159,7 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 		log.Debug(req.OperationID, "redis handle secondly", req.String())
 
 		for k, v := range req.ReactionExtensionList {
-			err := rpc.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, k)
+			err := m.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, k)
 			if err != nil {
 				setKeyResultInfo(&rResp, 100, err.Error(), req.ClientMsgID, k, v)
 				continue
@@ -187,14 +188,14 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	}
 	if !isExists {
 		if !req.IsReact {
-			ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, true, true)
+			notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, true, true)
 		} else {
-			ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, false)
+			notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, false)
 		}
 	} else {
-		ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, true)
+		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, true)
 	}
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc return is:", rResp.String())
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m return is:", rResp.String())
 	return &rResp, nil
 
 }
@@ -215,8 +216,8 @@ func setDeleteKeyResultInfo(r *msg.DeleteMessageListReactionExtensionsResp, errC
 	_ = db.DB.UnLockMessageTypeKey(clientMsgID, typeKey)
 }
 
-func (rpc *rpcChat) GetMessageListReactionExtensions(ctx context.Context, req *msg.GetMessageListReactionExtensionsReq) (resp *msg.GetMessageListReactionExtensionsResp, err error) {
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc args is:", req.String())
+func (m *msgServer) GetMessageListReactionExtensions(ctx context.Context, req *msg.GetMessageListReactionExtensionsReq) (resp *msg.GetMessageListReactionExtensionsResp, err error) {
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m args is:", req.String())
 	var rResp msg.GetMessageListReactionExtensionsResp
 	for _, messageValue := range req.MessageReactionKeyList {
 		var oneMessage msg.SingleMessageExtensionResult
@@ -266,19 +267,19 @@ func (rpc *rpcChat) GetMessageListReactionExtensions(ctx context.Context, req *m
 		}
 		rResp.SingleMessageResult = append(rResp.SingleMessageResult, &oneMessage)
 	}
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc return is:", rResp.String())
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m return is:", rResp.String())
 	return &rResp, nil
 
 }
 
-func (rpc *rpcChat) AddMessageReactionExtensions(ctx context.Context, req *msg.ModifyMessageReactionExtensionsReq) (resp *msg.ModifyMessageReactionExtensionsResp, err error) {
+func (m *msgServer) AddMessageReactionExtensions(ctx context.Context, req *msg.ModifyMessageReactionExtensionsReq) (resp *msg.ModifyMessageReactionExtensionsResp, err error) {
 	return
 }
 
-func (rpc *rpcChat) DeleteMessageReactionExtensions(ctx context.Context, req *msg.DeleteMessageListReactionExtensionsReq) (resp *msg.DeleteMessageListReactionExtensionsResp, err error) {
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc args is:", req.String())
+func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *msg.DeleteMessageListReactionExtensionsReq) (resp *msg.DeleteMessageListReactionExtensionsResp, err error) {
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m args is:", req.String())
 	var rResp msg.DeleteMessageListReactionExtensionsResp
-	callbackResp := callbackDeleteMessageReactionExtensions(req)
+	callbackResp := notification.callbackDeleteMessageReactionExtensions(req)
 	if callbackResp.ActionCode != constant.ActionAllow || callbackResp.ErrCode != 0 {
 		rResp.ErrCode = int32(callbackResp.ErrCode)
 		rResp.ErrMsg = callbackResp.ErrMsg
@@ -294,7 +295,7 @@ func (rpc *rpcChat) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	//if ExternalExtension
 	if req.IsExternalExtensions {
 		rResp.Result = callbackResp.ResultReactionExtensionList
-		ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, false)
+		notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, false)
 		return &rResp, nil
 
 	}
@@ -327,7 +328,7 @@ func (rpc *rpcChat) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	if isExists {
 		log.Debug(req.OperationID, "redis handle this delete", req.String())
 		for _, v := range req.ReactionExtensionList {
-			err := rpc.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, v.TypeKey)
+			err := m.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, v.TypeKey)
 			if err != nil {
 				setDeleteKeyResultInfo(&rResp, 100, err.Error(), req.ClientMsgID, v.TypeKey, v)
 				continue
@@ -353,7 +354,7 @@ func (rpc *rpcChat) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 			}
 		}
 	} else {
-		err := rpc.dMessageLocker.LockGlobalMessage(req.ClientMsgID)
+		err := m.dMessageLocker.LockGlobalMessage(req.ClientMsgID)
 		if err != nil {
 			rResp.ErrCode = 100
 			rResp.ErrMsg = err.Error()
@@ -412,13 +413,13 @@ func (rpc *rpcChat) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 				rResp.Result = append(rResp.Result, temp)
 			}
 		}
-		lockErr := rpc.dMessageLocker.UnLockGlobalMessage(req.ClientMsgID)
+		lockErr := m.dMessageLocker.UnLockGlobalMessage(req.ClientMsgID)
 		if lockErr != nil {
 			log.Error(req.OperationID, "UnLockGlobalMessage err:", lockErr.Error())
 		}
 
 	}
-	ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, isExists)
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc return is:", rResp.String())
+	notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, isExists)
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m return is:", rResp.String())
 	return &rResp, nil
 }

internal/rpc/msg/extend_msg_callback.go

@@ -1,21 +1,23 @@
 package msg
 
 import (
-	cbApi "Open_IM/pkg/callback_struct"
+	cbapi "Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/http"
 	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/proto/msg"
 	"Open_IM/pkg/utils"
-	http2 "net/http"
+	"context"
 )
 
-func callbackSetMessageReactionExtensions(setReq *msg.SetMessageReactionExtensionsReq) *cbApi.CallbackBeforeSetMessageReactionExtResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: setReq.OperationID}
-	log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String())
-	req := cbApi.CallbackBeforeSetMessageReactionExtReq{
-		OperationID:           setReq.OperationID,
+func CallbackSetMessageReactionExtensions(ctx context.Context, setReq *msg.SetMessageReactionExtensionsReq) error {
+	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
+		return nil
+	}
+	req := &cbapi.CallbackBeforeSetMessageReactionExtReq{
+		OperationID:           tracelog.GetOperationID(ctx),
 		CallbackCommand:       constant.CallbackBeforeSetMessageReactionExtensionCommand,
 		SourceID:              setReq.SourceID,
 		OpUserID:              setReq.OpUserID,
@@ -26,21 +28,15 @@ func callbackSetMessageReactionExtensions(setReq *msg.SetMessageReactionExtensio
 		IsExternalExtensions:  setReq.IsExternalExtensions,
 		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
 	}
-	resp := &cbApi.CallbackBeforeSetMessageReactionExtResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSetMessageReactionExtensionCommand,
-		req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-	}
-	return resp
-
+	resp := &cbapi.CallbackBeforeSetMessageReactionExtResp{}
+	return http.CallBackPostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
 }
 
-func callbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessageListReactionExtensionsReq) *cbApi.CallbackDeleteMessageReactionExtResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: setReq.OperationID}
-	log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String())
-	req := cbApi.CallbackDeleteMessageReactionExtReq{
+func CallbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessageListReactionExtensionsReq) error {
+	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
+		return nil
+	}
+	req := &cbapi.CallbackDeleteMessageReactionExtReq{
 		OperationID:           setReq.OperationID,
 		CallbackCommand:       constant.CallbackBeforeDeleteMessageReactionExtensionsCommand,
 		SourceID:              setReq.SourceID,
@@ -51,12 +47,53 @@ func callbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessageListReacti
 		IsExternalExtensions:  setReq.IsExternalExtensions,
 		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
 	}
-	resp := &cbApi.CallbackDeleteMessageReactionExtResp{CommonCallbackResp: &callbackResp}
+	resp := &cbapi.CallbackDeleteMessageReactionExtResp{}
 	defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeDeleteMessageReactionExtensionsCommand,
-		req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-	}
-	return resp
+	return http.CallBackPostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
 }
+
+//func CallbackGetMessageListReactionExtensions(getReq *msg.GetMessageListReactionExtensionsReq) error {
+//	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
+//		return nil
+//	}
+//	req := cbapi.CallbackGetMessageListReactionExtReq{
+//		OperationID:     getReq.OperationID,
+//		CallbackCommand: constant.CallbackGetMessageListReactionExtensionsCommand,
+//		SourceID:        getReq.SourceID,
+//		OpUserID:        getReq.OpUserID,
+//		SessionType:     getReq.SessionType,
+//		TypeKeyList:     getReq.TypeKeyList,
+//		MessageKeyList:  getReq.MessageReactionKeyList,
+//	}
+//	resp := &cbApi.CallbackGetMessageListReactionExtResp{CommonCallbackResp: &callbackResp}
+//	defer log.NewDebug(getReq.OperationID, utils.GetSelfFuncName(), req, *resp)
+//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackGetMessageListReactionExtensionsCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil {
+//		callbackResp.ErrCode = http2.StatusInternalServerError
+//		callbackResp.ErrMsg = err.Error()
+//	}
+//	return resp
+//}
+//func callbackAddMessageReactionExtensions(setReq *msg.AddMessageReactionExtensionsReq) *cb.CallbackAddMessageReactionExtResp {
+//	callbackResp := cbapi.CommonCallbackResp{OperationID: setReq.OperationID}
+//	log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String())
+//	req := cbapi.CallbackAddMessageReactionExtReq{
+//		OperationID:           setReq.OperationID,
+//		CallbackCommand:       constant.CallbackAddMessageListReactionExtensionsCommand,
+//		SourceID:              setReq.SourceID,
+//		OpUserID:              setReq.OpUserID,
+//		SessionType:           setReq.SessionType,
+//		ReactionExtensionList: setReq.ReactionExtensionList,
+//		ClientMsgID:           setReq.ClientMsgID,
+//		IsReact:               setReq.IsReact,
+//		IsExternalExtensions:  setReq.IsExternalExtensions,
+//		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
+//	}
+//	resp := &cbapi.CallbackAddMessageReactionExtResp{CommonCallbackResp: &callbackResp}
+//	defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp, *resp.CommonCallbackResp, resp.IsReact, resp.MsgFirstModifyTime)
+//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAddMessageListReactionExtensionsCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil {
+//		callbackResp.ErrCode = http2.StatusInternalServerError
+//		callbackResp.ErrMsg = err.Error()
+//	}
+//	return resp
+//
+//}

internal/rpc/msg/group_notification.go

@@ -1,621 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tokenverify"
-	utils2 "Open_IM/pkg/common/utils"
-	pbGroup "Open_IM/pkg/proto/group"
-	"Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-	"google.golang.org/protobuf/types/known/wrapperspb"
-)
-
-//message GroupCreatedTips{
-//  GroupInfo Group = 1;
-//  GroupMemberFullInfo Creator = 2;
-//  repeated GroupMemberFullInfo MemberList = 3;
-//  uint64 OperationTime = 4;
-//} creator->group
-
-func setOpUserInfo(opUserID, groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	if tokenverify.IsManagerUserID(opUserID) {
-		u, err := imdb.GetUserByUserID(opUserID)
-		if err != nil {
-			return utils.Wrap(err, "GetUserByUserID failed")
-		}
-		utils.CopyStructFields(groupMemberInfo, u)
-		groupMemberInfo.GroupID = groupID
-	} else {
-		u, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, opUserID)
-		if err == nil {
-			if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, u); err != nil {
-				return utils.Wrap(err, "")
-			}
-		}
-		user, err := imdb.GetUserByUserID(opUserID)
-		if err != nil {
-			return utils.Wrap(err, "")
-		}
-		groupMemberInfo.GroupID = groupID
-		groupMemberInfo.UserID = user.UserID
-		groupMemberInfo.Nickname = user.Nickname
-		groupMemberInfo.AppMangerLevel = user.AppMangerLevel
-		groupMemberInfo.FaceURL = user.FaceURL
-	}
-	return nil
-}
-
-func setGroupInfo(groupID string, groupInfo *sdkws.GroupInfo) error {
-	group, err := imdb.GetGroupInfoByGroupID(groupID)
-	if err != nil {
-		return utils.Wrap(err, "GetGroupInfoByGroupID failed")
-	}
-	err = utils2.GroupDBCopyOpenIM(groupInfo, group)
-	if err != nil {
-		log.NewWarn("", "GroupDBCopyOpenIM failed ", groupID, err.Error())
-		return nil
-	}
-	return nil
-}
-
-func setGroupMemberInfo(groupID, userID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	groupMember, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
-	if err == nil {
-		return utils.Wrap(utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember), "")
-	}
-
-	user, err := imdb.GetUserByUserID(userID)
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-	groupMemberInfo.GroupID = groupID
-	groupMemberInfo.UserID = user.UserID
-	groupMemberInfo.Nickname = user.Nickname
-	groupMemberInfo.AppMangerLevel = user.AppMangerLevel
-	groupMemberInfo.FaceURL = user.FaceURL
-	return nil
-}
-
-func setGroupOwnerInfo(groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	groupMember, err := imdb.GetGroupOwnerInfoByGroupID(groupID)
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-	if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember); err != nil {
-		return utils.Wrap(err, "")
-	}
-	return nil
-}
-
-func setPublicUserInfo(userID string, publicUserInfo *sdkws.PublicUserInfo) error {
-	user, err := imdb.GetUserByUserID(userID)
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-	utils2.UserDBCopyOpenIMPublicUser(publicUserInfo, user)
-	return nil
-}
-
-func groupNotification(contentType int32, m proto.Message, sendID, groupID, recvUserID, operationID string) {
-	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType, sendID, groupID, recvUserID)
-
-	var err error
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
-		return
-	}
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-	var nickname string
-
-	from, err := imdb.GetUserByUserID(sendID)
-	if err != nil {
-		log.Error(operationID, "GetUserByUserID failed ", err.Error(), sendID)
-	}
-	if from != nil {
-		nickname = from.Nickname
-	}
-
-	to, err := imdb.GetUserByUserID(recvUserID)
-	if err != nil {
-		log.NewWarn(operationID, "GetUserByUserID failed ", err.Error(), recvUserID)
-	}
-	toNickname := ""
-	if to != nil {
-		toNickname = to.Nickname
-	}
-
-	cn := config.Config.Notification
-	switch contentType {
-	case constant.GroupCreatedNotification:
-		tips.DefaultTips = nickname + " " + cn.GroupCreated.DefaultTips.Tips
-	case constant.GroupInfoSetNotification:
-		tips.DefaultTips = nickname + " " + cn.GroupInfoSet.DefaultTips.Tips
-	case constant.JoinGroupApplicationNotification:
-		tips.DefaultTips = nickname + " " + cn.JoinGroupApplication.DefaultTips.Tips
-	case constant.MemberQuitNotification:
-		tips.DefaultTips = nickname + " " + cn.MemberQuit.DefaultTips.Tips
-	case constant.GroupApplicationAcceptedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.GroupApplicationAccepted.DefaultTips.Tips
-	case constant.GroupApplicationRejectedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.GroupApplicationRejected.DefaultTips.Tips
-	case constant.GroupOwnerTransferredNotification: //
-		tips.DefaultTips = toNickname + " " + cn.GroupOwnerTransferred.DefaultTips.Tips
-	case constant.MemberKickedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.MemberKicked.DefaultTips.Tips
-	case constant.MemberInvitedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.MemberInvited.DefaultTips.Tips
-	case constant.MemberEnterNotification:
-		tips.DefaultTips = toNickname + " " + cn.MemberEnter.DefaultTips.Tips
-	case constant.GroupDismissedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupDismissed.DefaultTips.Tips
-	case constant.GroupMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMuted.DefaultTips.Tips
-	case constant.GroupCancelMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupCancelMuted.DefaultTips.Tips
-	case constant.GroupMemberMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberMuted.DefaultTips.Tips
-	case constant.GroupMemberCancelMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberCancelMuted.DefaultTips.Tips
-	case constant.GroupMemberInfoSetNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberInfoSet.DefaultTips.Tips
-	case constant.GroupMemberSetToAdminNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToAdmin.DefaultTips.Tips
-	case constant.GroupMemberSetToOrdinaryUserNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToOrdinary.DefaultTips.Tips
-	default:
-		log.Error(operationID, "contentType failed ", contentType)
-		return
-	}
-
-	var n NotificationMsg
-	n.SendID = sendID
-	if groupID != "" {
-		n.RecvID = groupID
-		group, err := imdb.GetGroupInfoByGroupID(groupID)
-		if err != nil {
-			log.NewError(operationID, "GetGroupInfoByGroupID failed ", err.Error(), groupID)
-		}
-		switch group.GroupType {
-		case constant.NormalGroup:
-			n.SessionType = constant.GroupChatType
-		default:
-			n.SessionType = constant.SuperGroupChatType
-		}
-	} else {
-		n.RecvID = recvUserID
-		n.SessionType = constant.SingleChatType
-	}
-	n.ContentType = contentType
-	n.OperationID = operationID
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
-		return
-	}
-	Notification(&n)
-}
-
-// 创建群后调用
-func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberList []string) {
-	GroupCreatedTips := sdkws.GroupCreatedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, GroupOwnerUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setOpUserInfo(opUserID, groupID, GroupCreatedTips.OpUser); err != nil {
-		log.NewError(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, GroupCreatedTips.OpUser)
-		return
-	}
-	err := setGroupInfo(groupID, GroupCreatedTips.Group)
-	if err != nil {
-		log.Error(operationID, "setGroupInfo failed ", groupID, GroupCreatedTips.Group)
-		return
-	}
-	imdb.GetGroupOwnerInfoByGroupID(groupID)
-	if err := setGroupOwnerInfo(groupID, GroupCreatedTips.GroupOwnerUser); err != nil {
-		log.Error(operationID, "setGroupOwnerInfo failed", err.Error(), groupID)
-		return
-	}
-	for _, v := range initMemberList {
-		var groupMemberInfo sdkws.GroupMemberFullInfo
-		if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
-			log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, v)
-			continue
-		}
-		GroupCreatedTips.MemberList = append(GroupCreatedTips.MemberList, &groupMemberInfo)
-		if len(GroupCreatedTips.MemberList) == constant.MaxNotificationNum {
-			break
-		}
-	}
-	groupNotification(constant.GroupCreatedNotification, &GroupCreatedTips, opUserID, groupID, "", operationID)
-}
-
-// 群信息改变后掉用
-// groupName := ""
-//
-//	notification := ""
-//	introduction := ""
-//	faceURL := ""
-func GroupInfoSetNotification(operationID, opUserID, groupID string, groupName, notification, introduction, faceURL string, needVerification *wrapperspb.Int32Value) {
-	GroupInfoChangedTips := sdkws.GroupInfoSetTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, GroupInfoChangedTips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	GroupInfoChangedTips.Group.GroupName = groupName
-	GroupInfoChangedTips.Group.Notification = notification
-	GroupInfoChangedTips.Group.Introduction = introduction
-	GroupInfoChangedTips.Group.FaceURL = faceURL
-	if needVerification != nil {
-		GroupInfoChangedTips.Group.NeedVerification = needVerification.Value
-	}
-
-	if err := setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	groupNotification(constant.GroupInfoSetNotification, &GroupInfoChangedTips, opUserID, groupID, "", operationID)
-}
-
-func GroupMutedNotification(operationID, opUserID, groupID string) {
-	tips := sdkws.GroupMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	groupNotification(constant.GroupMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupCancelMutedNotification(operationID, opUserID, groupID string) {
-	tips := sdkws.GroupCancelMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	groupNotification(constant.GroupCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberMutedNotification(operationID, opUserID, groupID, groupMemberUserID string, mutedSeconds uint32) {
-	tips := sdkws.GroupMemberMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, MutedUser: &sdkws.GroupMemberFullInfo{}}
-	tips.MutedSeconds = mutedSeconds
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(constant.GroupMemberMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberInfoSetNotification(operationID, opUserID, groupID, groupMemberUserID string) {
-	tips := sdkws.GroupMemberInfoSetTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, ChangedUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(constant.GroupMemberInfoSetNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberRoleLevelChangeNotification(operationID, opUserID, groupID, groupMemberUserID string, notificationType int32) {
-	if notificationType != constant.GroupMemberSetToAdminNotification && notificationType != constant.GroupMemberSetToOrdinaryUserNotification {
-		log.NewError(operationID, utils.GetSelfFuncName(), "invalid notificationType: ", notificationType)
-		return
-	}
-	tips := sdkws.GroupMemberInfoSetTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, ChangedUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(notificationType, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMemberUserID string) {
-	tips := sdkws.GroupMemberCancelMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, MutedUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(constant.GroupMemberCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-//	message ReceiveJoinApplicationTips{
-//	 GroupInfo Group = 1;
-//	 PublicUserInfo Applicant  = 2;
-//	 string 	Reason = 3;
-//	}  apply->all managers GroupID              string   `protobuf:"bytes,1,opt,name=GroupID" json:"GroupID,omitempty"`
-//
-//	ReqMessage           string   `protobuf:"bytes,2,opt,name=ReqMessage" json:"ReqMessage,omitempty"`
-//	OpUserID             string   `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"`
-//	OperationID          string   `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"`
-//
-// 申请进群后调用
-func JoinGroupApplicationNotification(ctx context.Context, req *pbGroup.JoinGroupReq) {
-	JoinGroupApplicationTips := sdkws.JoinGroupApplicationTips{Group: &sdkws.GroupInfo{}, Applicant: &sdkws.PublicUserInfo{}}
-	err := setGroupInfo(req.GroupID, JoinGroupApplicationTips.Group)
-	if err != nil {
-		log.Error(utils.OperationID(ctx), "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err = setPublicUserInfo(utils.OpUserID(ctx), JoinGroupApplicationTips.Applicant); err != nil {
-		log.Error(utils.OperationID(ctx), "setPublicUserInfo failed ", err.Error(), utils.OpUserID(ctx))
-		return
-	}
-	JoinGroupApplicationTips.ReqMsg = req.ReqMessage
-
-	managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
-	if err != nil {
-		log.NewError(utils.OperationID(ctx), "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID)
-		return
-	}
-	for _, v := range managerList {
-		groupNotification(constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, utils.OpUserID(ctx), "", v.UserID, utils.OperationID(ctx))
-		log.NewInfo(utils.OperationID(ctx), "Notification ", v)
-	}
-}
-
-func MemberQuitNotification(req *pbGroup.QuitGroupReq) {
-	MemberQuitTips := sdkws.MemberQuitTips{Group: &sdkws.GroupInfo{}, QuitUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberQuitTips.Group); err != nil {
-		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberQuitTips.QuitUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID)
-		return
-	}
-
-	groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-//	message ApplicationProcessedTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo OpUser = 2;
-//	 int32 Result = 3;
-//	 string 	Reason = 4;
-//	}
-//
-// 处理进群请求后调用
-func GroupApplicationAcceptedNotification(req *pbGroup.GroupApplicationResponseReq) {
-	GroupApplicationAcceptedTips := sdkws.GroupApplicationAcceptedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
-	if err := setGroupInfo(req.GroupID, GroupApplicationAcceptedTips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationAcceptedTips.Group)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser)
-		return
-	}
-
-	groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
-	adminList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
-	if err != nil {
-		log.Error(req.OperationID, "GetOwnerManagerByGroupID failed", req.GroupID)
-		return
-	}
-	for _, v := range adminList {
-		if v.UserID == req.OpUserID {
-			continue
-		}
-		GroupApplicationAcceptedTips.ReceiverAs = 1
-		groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", v.UserID, req.OperationID)
-	}
-}
-
-func GroupApplicationRejectedNotification(req *pbGroup.GroupApplicationResponseReq) {
-	GroupApplicationRejectedTips := sdkws.GroupApplicationRejectedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
-	if err := setGroupInfo(req.GroupID, GroupApplicationRejectedTips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationRejectedTips.Group)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser)
-		return
-	}
-	groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
-	adminList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
-	if err != nil {
-		log.Error(req.OperationID, "GetOwnerManagerByGroupID failed", req.GroupID)
-		return
-	}
-	for _, v := range adminList {
-		if v.UserID == req.OpUserID {
-			continue
-		}
-		GroupApplicationRejectedTips.ReceiverAs = 1
-		groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", v.UserID, req.OperationID)
-	}
-}
-
-func GroupOwnerTransferredNotification(req *pbGroup.TransferGroupOwnerReq) {
-	GroupOwnerTransferredTips := sdkws.GroupOwnerTransferredTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, NewGroupOwner: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, GroupOwnerTransferredTips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupOwnerTransferredTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID)
-		return
-	}
-	if err := setGroupMemberInfo(req.GroupID, req.NewOwnerUserID, GroupOwnerTransferredTips.NewGroupOwner); err != nil {
-		log.Error(req.OperationID, "setGroupMemberInfo failed", req.GroupID, req.NewOwnerUserID)
-		return
-	}
-	groupNotification(constant.GroupOwnerTransferredNotification, &GroupOwnerTransferredTips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-func GroupDismissedNotification(req *pbGroup.DismissGroupReq) {
-	tips := sdkws.GroupDismissedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, tips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, tips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID)
-		return
-	}
-	groupNotification(constant.GroupDismissedNotification, &tips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-//	message MemberKickedTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo OpUser = 2;
-//	 GroupMemberFullInfo KickedUser = 3;
-//	 uint64 OperationTime = 4;
-//	}
-//
-// 被踢后调用
-func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
-	MemberKickedTips := sdkws.MemberKickedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberKickedTips.Group); err != nil {
-		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberKickedTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID)
-		return
-	}
-	for _, v := range kickedUserIDList {
-		var groupMemberInfo sdkws.GroupMemberFullInfo
-		if err := setGroupMemberInfo(req.GroupID, v, &groupMemberInfo); err != nil {
-			log.Error(req.OperationID, "setGroupMemberInfo failed ", err.Error(), req.GroupID, v)
-			continue
-		}
-		MemberKickedTips.KickedUserList = append(MemberKickedTips.KickedUserList, &groupMemberInfo)
-	}
-	groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, req.GroupID, "", req.OperationID)
-	//
-	//for _, v := range kickedUserIDList {
-	//	groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, "", v, req.OperationID)
-	//}
-}
-
-//	message MemberInvitedTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo OpUser = 2;
-//	 GroupMemberFullInfo InvitedUser = 3;
-//	 uint64 OperationTime = 4;
-//	}
-//
-// 被邀请进群后调用
-func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) {
-	MemberInvitedTips := sdkws.MemberInvitedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, MemberInvitedTips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, MemberInvitedTips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	for _, v := range invitedUserIDList {
-		var groupMemberInfo sdkws.GroupMemberFullInfo
-		if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
-			log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID)
-			continue
-		}
-		MemberInvitedTips.InvitedUserList = append(MemberInvitedTips.InvitedUserList, &groupMemberInfo)
-	}
-	groupNotification(constant.MemberInvitedNotification, &MemberInvitedTips, opUserID, groupID, "", operationID)
-}
-
-//message GroupInfoChangedTips{
-//  int32 ChangedType = 1; //bitwise operators: 1:groupName; 10:Notification  100:Introduction; 1000:FaceUrl
-//  GroupInfo Group = 2;
-//  GroupMemberFullInfo OpUser = 3;
-//}
-
-//message MemberLeaveTips{
-//  GroupInfo Group = 1;
-//  GroupMemberFullInfo LeaverUser = 2;
-//  uint64 OperationTime = 3;
-//}
-
-//群成员退群后调用
-
-//	message MemberEnterTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo EntrantUser = 2;
-//	 uint64 OperationTime = 3;
-//	}
-//
-// 群成员主动申请进群，管理员同意后调用，
-func MemberEnterNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) {
-	MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberEnterTips.Group); err != nil {
-		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, MemberEnterTips.Group)
-		return
-	}
-	if err := setGroupMemberInfo(req.GroupID, req.FromUserID, MemberEnterTips.EntrantUser); err != nil {
-		log.Error(req.OperationID, "setGroupMemberInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberEnterTips.EntrantUser)
-		return
-	}
-	groupNotification(constant.MemberEnterNotification, &MemberEnterTips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-func MemberEnterDirectlyNotification(groupID string, entrantUserID string, operationID string) {
-	MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, MemberEnterTips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID, MemberEnterTips.Group)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, entrantUserID, MemberEnterTips.EntrantUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, entrantUserID, MemberEnterTips.EntrantUser)
-		return
-	}
-	groupNotification(constant.MemberEnterNotification, &MemberEnterTips, entrantUserID, groupID, "", operationID)
-}

internal/rpc/msg/msg_notification.go

@@ -1,47 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-)
-
-func DeleteMessageNotification(opUserID, userID string, seqList []uint32, operationID string) {
-	DeleteMessageTips := sdkws.DeleteMessageTips{OpUserID: opUserID, UserID: userID, SeqList: seqList}
-	MessageNotification(operationID, userID, userID, constant.DeleteMessageNotification, &DeleteMessageTips)
-}
-
-func MessageNotification(operationID, sendID, recvID string, contentType int32, m proto.Message) {
-	log.Debug(operationID, utils.GetSelfFuncName(), "args: ", m.String(), contentType)
-	var err error
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
-		return
-	}
-
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-	var n NotificationMsg
-	n.SendID = sendID
-	n.RecvID = recvID
-	n.ContentType = contentType
-	n.SessionType = constant.SingleChatType
-	n.MsgFrom = constant.SysMsgType
-	n.OperationID = operationID
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
-		return
-	}
-	Notification(&n)
-}

internal/rpc/msg/msg_status.go

@@ -2,45 +2,28 @@ package msg
 
 import (
 	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/tracelog"
 	pbMsg "Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
 	"context"
-
-	goRedis "github.com/go-redis/redis/v8"
 )
 
-func (rpc *rpcChat) SetSendMsgStatus(_ context.Context, req *pbMsg.SetSendMsgStatusReq) (resp *pbMsg.SetSendMsgStatusResp, err error) {
-	resp = &pbMsg.SetSendMsgStatusResp{}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
-	if err := db.DB.SetSendMsgStatus(req.Status, req.OperationID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-		resp.ErrCode = constant.ErrDatabase.ErrCode
-		resp.ErrMsg = err.Error()
-		return resp, nil
+func (m *msgServer) SetSendMsgStatus(ctx context.Context, req *pbMsg.SetSendMsgStatusReq) (*pbMsg.SetSendMsgStatusResp, error) {
+	resp := &pbMsg.SetSendMsgStatusResp{}
+	if err := m.MsgInterface.SetSendMsgStatus(ctx, tracelog.GetOperationID(ctx), req.Status); err != nil {
+		return nil, err
 	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp.String())
 	return resp, nil
 }
 
-func (rpc *rpcChat) GetSendMsgStatus(_ context.Context, req *pbMsg.GetSendMsgStatusReq) (resp *pbMsg.GetSendMsgStatusResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
-	resp = &pbMsg.GetSendMsgStatusResp{}
-	status, err := db.DB.GetSendMsgStatus(req.OperationID)
-	if err != nil {
+func (m *msgServer) GetSendMsgStatus(ctx context.Context, req *pbMsg.GetSendMsgStatusReq) (*pbMsg.GetSendMsgStatusResp, error) {
+	resp := &pbMsg.GetSendMsgStatusResp{}
+	status, err := m.MsgInterface.GetSendMsgStatus(ctx, tracelog.GetOperationID(ctx))
+	if IsNotFound(err) {
 		resp.Status = constant.MsgStatusNotExist
-		if err == goRedis.Nil {
-			log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.OperationID, "not exist")
-			return resp, nil
-		} else {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-			resp.ErrMsg = err.Error()
-			resp.ErrCode = constant.ErrDB.ErrCode
-			return resp, nil
-		}
+		return resp, nil
+	} else if err != nil {
+		return nil, err
 	}
-	resp.Status = int32(status)
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp.String())
+	resp.Status = status
 	return resp, nil
 }

internal/rpc/msg/notification.go

@@ -0,0 +1,7 @@
+package msg
+
+import "context"
+
+func DeleteMessageNotification(ctx context.Context, userID string, seqs []uint32) {
+	panic("todo")
+}

internal/rpc/msg/pull_message.go

@@ -1,126 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/utils"
-	"context"
-	go_redis "github.com/go-redis/redis/v8"
-
-	commonDB "Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	sdkws "Open_IM/pkg/proto/sdkws"
-
-	prome "Open_IM/pkg/common/prometheus"
-)
-
-func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *sdkws.GetMaxAndMinSeqReq) (*sdkws.GetMaxAndMinSeqResp, error) {
-	log.NewInfo(in.OperationID, "rpc getMaxAndMinSeq is arriving", in.String())
-	resp := new(sdkws.GetMaxAndMinSeqResp)
-	m := make(map[string]*sdkws.MaxAndMinSeq)
-	var maxSeq, minSeq uint64
-	var err1, err2 error
-	maxSeq, err1 = commonDB.DB.GetUserMaxSeq(in.UserID)
-	minSeq, err2 = commonDB.DB.GetUserMinSeq(in.UserID)
-	if (err1 != nil && err1 != go_redis.Nil) || (err2 != nil && err2 != go_redis.Nil) {
-		log.NewError(in.OperationID, "getMaxSeq from redis error", in.String())
-		if err1 != nil {
-			log.NewError(in.OperationID, utils.GetSelfFuncName(), err1.Error())
-		}
-		if err2 != nil {
-			log.NewError(in.OperationID, utils.GetSelfFuncName(), err2.Error())
-		}
-		resp.ErrCode = 200
-		resp.ErrMsg = "redis get err"
-		return resp, nil
-	}
-	resp.MaxSeq = uint32(maxSeq)
-	resp.MinSeq = uint32(minSeq)
-	for _, groupID := range in.GroupIDList {
-		x := new(sdkws.MaxAndMinSeq)
-		maxSeq, _ := commonDB.DB.GetGroupMaxSeq(groupID)
-		minSeq, _ := commonDB.DB.GetGroupUserMinSeq(groupID, in.UserID)
-		x.MaxSeq = uint32(maxSeq)
-		x.MinSeq = uint32(minSeq)
-		m[groupID] = x
-	}
-	resp.GroupMaxAndMinSeq = m
-	return resp, nil
-}
-
-func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *sdkws.PullMessageBySeqListReq) (*sdkws.PullMessageBySeqListResp, error) {
-	log.NewInfo(in.OperationID, "rpc PullMessageBySeqList is arriving", in.String())
-	resp := new(sdkws.PullMessageBySeqListResp)
-	m := make(map[string]*sdkws.MsgDataList)
-	redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(in.UserID, in.SeqList, in.OperationID)
-	if err != nil {
-		if err != go_redis.Nil {
-			prome.PromeAdd(prome.MsgPullFromRedisFailedCounter, len(failedSeqList))
-			log.Error(in.OperationID, "get message from redis exception", err.Error(), failedSeqList)
-		} else {
-			log.Debug(in.OperationID, "get message from redis is nil", failedSeqList)
-		}
-		msgList, err1 := commonDB.DB.GetMsgBySeqs(in.UserID, failedSeqList, in.OperationID)
-		if err1 != nil {
-			prome.PromeAdd(prome.MsgPullFromMongoFailedCounter, len(failedSeqList))
-			log.Error(in.OperationID, "PullMessageBySeqList data error", in.String(), err1.Error())
-			resp.ErrCode = 201
-			resp.ErrMsg = err1.Error()
-			return resp, nil
-		} else {
-			prome.PromeAdd(prome.MsgPullFromMongoSuccessCounter, len(msgList))
-			redisMsgList = append(redisMsgList, msgList...)
-			resp.List = redisMsgList
-		}
-	} else {
-		prome.PromeAdd(prome.MsgPullFromRedisSuccessCounter, len(redisMsgList))
-		resp.List = redisMsgList
-	}
-
-	for k, v := range in.GroupSeqList {
-		x := new(sdkws.MsgDataList)
-		redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(k, v.SeqList, in.OperationID)
-		if err != nil {
-			if err != go_redis.Nil {
-				prome.PromeAdd(prome.MsgPullFromRedisFailedCounter, len(failedSeqList))
-				log.Error(in.OperationID, "get message from redis exception", err.Error(), failedSeqList)
-			} else {
-				log.Debug(in.OperationID, "get message from redis is nil", failedSeqList)
-			}
-			msgList, err1 := commonDB.DB.GetSuperGroupMsgBySeqs(k, failedSeqList, in.OperationID)
-			if err1 != nil {
-				prome.PromeAdd(prome.MsgPullFromMongoFailedCounter, len(failedSeqList))
-				log.Error(in.OperationID, "PullMessageBySeqList data error", in.String(), err1.Error())
-				resp.ErrCode = 201
-				resp.ErrMsg = err1.Error()
-				return resp, nil
-			} else {
-				prome.PromeAdd(prome.MsgPullFromMongoSuccessCounter, len(msgList))
-				redisMsgList = append(redisMsgList, msgList...)
-				x.MsgDataList = redisMsgList
-				m[k] = x
-			}
-		} else {
-			prome.PromeAdd(prome.MsgPullFromRedisSuccessCounter, len(redisMsgList))
-			x.MsgDataList = redisMsgList
-			m[k] = x
-		}
-	}
-	resp.GroupMsgDataList = m
-	return resp, nil
-}
-
-type MsgFormats []*sdkws.MsgData
-
-// Implement the sort.Interface interface to get the number of elements method
-func (s MsgFormats) Len() int {
-	return len(s)
-}
-
-//Implement the sort.Interface interface comparison element method
-func (s MsgFormats) Less(i, j int) bool {
-	return s[i].SendTime < s[j].SendTime
-}
-
-//Implement the sort.Interface interface exchange element method
-func (s MsgFormats) Swap(i, j int) {
-	s[i], s[j] = s[j], s[i]
-}

internal/rpc/msg/query_msg.go

@@ -1,51 +0,0 @@
-package msg
-
-import (
-	commonDB "Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	prome "Open_IM/pkg/common/prometheus"
-	"Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	"context"
-	go_redis "github.com/go-redis/redis/v8"
-)
-
-func (rpc *rpcChat) GetSuperGroupMsg(context context.Context, req *msg.GetSuperGroupMsgReq) (*msg.GetSuperGroupMsgResp, error) {
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), req.String())
-	resp := new(msg.GetSuperGroupMsgResp)
-	redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(req.GroupID, []uint32{req.Seq}, req.OperationID)
-	if err != nil {
-		if err != go_redis.Nil {
-			prome.PromeAdd(prome.MsgPullFromRedisFailedCounter, len(failedSeqList))
-			log.Error(req.OperationID, "get message from redis exception", err.Error(), failedSeqList)
-		} else {
-			log.Debug(req.OperationID, "get message from redis is nil", failedSeqList)
-		}
-		msgList, err1 := commonDB.DB.GetSuperGroupMsgBySeqs(req.GroupID, failedSeqList, req.OperationID)
-		if err1 != nil {
-			prome.PromeAdd(prome.MsgPullFromMongoFailedCounter, len(failedSeqList))
-			log.Error(req.OperationID, "GetSuperGroupMsg data error", req.String(), err.Error())
-			resp.ErrCode = 201
-			resp.ErrMsg = err.Error()
-			return resp, nil
-		} else {
-			prome.PromeAdd(prome.MsgPullFromMongoSuccessCounter, len(msgList))
-			redisMsgList = append(redisMsgList, msgList...)
-			for _, m := range msgList {
-				resp.MsgData = m
-			}
-
-		}
-	} else {
-		prome.PromeAdd(prome.MsgPullFromRedisSuccessCounter, len(redisMsgList))
-		for _, m := range redisMsgList {
-			resp.MsgData = m
-		}
-	}
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), resp.String())
-	return resp, nil
-}
-
-func (rpc *rpcChat) GetWriteDiffMsg(context context.Context, req *msg.GetWriteDiffMsgReq) (*msg.GetWriteDiffMsgResp, error) {
-	panic("implement me")
-}

internal/rpc/msg/rpc_chat.go

@@ -1,159 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/kafka"
-	"Open_IM/pkg/common/log"
-	prome "Open_IM/pkg/common/prometheus"
-	"Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	"github.com/OpenIMSDK/getcdv3"
-	"net"
-	"strconv"
-	"strings"
-
-	"github.com/golang/protobuf/proto"
-
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-
-	"google.golang.org/grpc"
-)
-
-type MessageWriter interface {
-	SendMessage(m proto.Message, key string, operationID string) (int32, int64, error)
-}
-type rpcChat struct {
-	rpcPort         int
-	rpcRegisterName string
-	etcdSchema      string
-	etcdAddr        []string
-	messageWriter   MessageWriter
-	//offlineProducer *kafka.Producer
-	delMsgCh       chan deleteMsg
-	dMessageLocker MessageLocker
-}
-
-type deleteMsg struct {
-	UserID      string
-	OpUserID    string
-	SeqList     []uint32
-	OperationID string
-}
-
-func NewRpcChatServer(port int) *rpcChat {
-	log.NewPrivateLog(constant.LogFileName)
-	rc := rpcChat{
-		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImMsgName,
-		etcdSchema:      config.Config.Etcd.EtcdSchema,
-		etcdAddr:        config.Config.Etcd.EtcdAddr,
-		dMessageLocker:  NewLockerMessage(),
-	}
-	rc.messageWriter = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.Ws2mschat.Topic)
-	//rc.offlineProducer = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschatOffline.Addr, config.Config.Kafka.Ws2mschatOffline.Topic)
-	rc.delMsgCh = make(chan deleteMsg, 1000)
-	return &rc
-}
-
-func (rpc *rpcChat) initPrometheus() {
-	//sendMsgSuccessCounter = promauto.NewCounter(prometheus.CounterOpts{
-	//	Name: "send_msg_success",
-	//	Help: "The number of send msg success",
-	//})
-	//sendMsgFailedCounter = promauto.NewCounter(prometheus.CounterOpts{
-	//	Name: "send_msg_failed",
-	//	Help: "The number of send msg failed",
-	//})
-	prome.NewMsgPullFromRedisSuccessCounter()
-	prome.NewMsgPullFromRedisFailedCounter()
-	prome.NewMsgPullFromMongoSuccessCounter()
-	prome.NewMsgPullFromMongoFailedCounter()
-
-	prome.NewSingleChatMsgRecvSuccessCounter()
-	prome.NewGroupChatMsgRecvSuccessCounter()
-	prome.NewWorkSuperGroupChatMsgRecvSuccessCounter()
-
-	prome.NewSingleChatMsgProcessSuccessCounter()
-	prome.NewSingleChatMsgProcessFailedCounter()
-	prome.NewGroupChatMsgProcessSuccessCounter()
-	prome.NewGroupChatMsgProcessFailedCounter()
-	prome.NewWorkSuperGroupChatMsgProcessSuccessCounter()
-	prome.NewWorkSuperGroupChatMsgProcessFailedCounter()
-}
-
-func (rpc *rpcChat) Run() {
-	log.Info("", "rpcChat init...")
-	listenIP := ""
-	if config.Config.ListenIP == "" {
-		listenIP = "0.0.0.0"
-	} else {
-		listenIP = config.Config.ListenIP
-	}
-	address := listenIP + ":" + strconv.Itoa(rpc.rpcPort)
-	listener, err := net.Listen("tcp", address)
-	if err != nil {
-		panic("listening err:" + err.Error() + rpc.rpcRegisterName)
-	}
-	log.Info("", "listen network success, address ", address)
-	recvSize := 1024 * 1024 * 30
-	sendSize := 1024 * 1024 * 30
-	var grpcOpts = []grpc.ServerOption{
-		grpc.MaxRecvMsgSize(recvSize),
-		grpc.MaxSendMsgSize(sendSize),
-	}
-	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-
-	rpcRegisterIP := config.Config.RpcRegisterIP
-	msg.RegisterMsgServer(srv, rpc)
-	if config.Config.RpcRegisterIP == "" {
-		rpcRegisterIP, err = utils.GetLocalIP()
-		if err != nil {
-			log.Error("", "GetLocalIP failed ", err.Error())
-		}
-	}
-	err = getcdv3.RegisterEtcd(rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), rpcRegisterIP, rpc.rpcPort, rpc.rpcRegisterName, 10, "")
-	if err != nil {
-		log.Error("", "register rpcChat to etcd failed ", err.Error())
-		panic(utils.Wrap(err, "register chat module  rpc to etcd err"))
-	}
-	go rpc.runCh()
-	rpc.initPrometheus()
-	err = srv.Serve(listener)
-	if err != nil {
-		log.Error("", "rpc rpcChat failed ", err.Error())
-		return
-	}
-	log.Info("", "rpc rpcChat init success")
-}
-
-func (rpc *rpcChat) runCh() {
-	log.NewInfo("", "start del msg chan ")
-	for {
-		select {
-		case msg := <-rpc.delMsgCh:
-			log.NewInfo(msg.OperationID, utils.GetSelfFuncName(), "delmsgch recv new: ", msg)
-			db.DB.DelMsgFromCache(msg.UserID, msg.SeqList, msg.OperationID)
-			unexistSeqList, err := db.DB.DelMsgBySeqs(msg.UserID, msg.SeqList, msg.OperationID)
-			if err != nil {
-				log.NewError(msg.OperationID, utils.GetSelfFuncName(), "DelMsgBySeqs args: ", msg.UserID, msg.SeqList, msg.OperationID, err.Error())
-				continue
-			}
-			if len(unexistSeqList) > 0 {
-				DeleteMessageNotification(msg.OpUserID, msg.UserID, unexistSeqList, msg.OperationID)
-			}
-		}
-	}
-}

internal/rpc/msg/send_pull.go

@@ -0,0 +1,304 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/constant"
+	promePkg "Open_IM/pkg/common/prometheus"
+	pbConversation "Open_IM/pkg/proto/conversation"
+	"Open_IM/pkg/proto/msg"
+	"Open_IM/pkg/proto/sdkws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/golang/protobuf/proto"
+	"sync"
+)
+
+func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
+	promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter)
+	// callback
+	if err = CallbackBeforeSendGroupMsg(ctx, req); err != nil {
+		return nil, err
+	}
+
+	if _, err = m.messageVerification(ctx, req); err != nil {
+		promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
+		return nil, err
+	}
+	msgToMQSingle := msg.MsgDataToMQ{MsgData: req.MsgData}
+	err = m.MsgInterface.MsgToMQ(ctx, msgToMQSingle.MsgData.GroupID, &msgToMQSingle)
+	if err != nil {
+		return nil, err
+	}
+	// callback
+	if err = CallbackAfterSendGroupMsg(ctx, req); err != nil {
+		return nil, err
+	}
+
+	promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessSuccessCounter)
+	resp.SendTime = msgToMQSingle.MsgData.SendTime
+	resp.ServerMsgID = msgToMQSingle.MsgData.ServerMsgID
+	resp.ClientMsgID = msgToMQSingle.MsgData.ClientMsgID
+	return resp, nil
+}
+func (m *msgServer) sendMsgNotification(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
+	msgToMQSingle := msg.MsgDataToMQ{MsgData: req.MsgData}
+	err = m.MsgInterface.MsgToMQ(ctx, msgToMQSingle.MsgData.RecvID, &msgToMQSingle)
+	if err != nil {
+		return nil, err
+	}
+	if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
+		err = m.MsgInterface.MsgToMQ(ctx, msgToMQSingle.MsgData.SendID, &msgToMQSingle)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	resp.SendTime = msgToMQSingle.MsgData.SendTime
+	resp.ServerMsgID = msgToMQSingle.MsgData.ServerMsgID
+	resp.ClientMsgID = msgToMQSingle.MsgData.ClientMsgID
+	return resp, nil
+}
+
+func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
+	promePkg.PromeInc(promePkg.SingleChatMsgRecvSuccessCounter)
+	if err = CallbackBeforeSendSingleMsg(ctx, req); err != nil {
+		return nil, err
+	}
+	_, err = m.messageVerification(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	isSend, err := modifyMessageByUserMessageReceiveOpt(req.MsgData.RecvID, req.MsgData.SendID, constant.SingleChatType, req)
+	if err != nil {
+		return nil, err
+	}
+	msgToMQSingle := msg.MsgDataToMQ{MsgData: req.MsgData}
+	if isSend {
+		err = m.MsgInterface.MsgToMQ(ctx, req.MsgData.RecvID, &msgToMQSingle)
+		if err != nil {
+			return nil, constant.ErrInternalServer.Wrap("insert to mq")
+		}
+	}
+	if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
+		err = m.MsgInterface.MsgToMQ(ctx, req.MsgData.SendID, &msgToMQSingle)
+		if err != nil {
+			return nil, constant.ErrInternalServer.Wrap("insert to mq")
+		}
+	}
+	err = CallbackAfterSendSingleMsg(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	promePkg.PromeInc(promePkg.SingleChatMsgProcessSuccessCounter)
+	resp.SendTime = msgToMQSingle.MsgData.SendTime
+	resp.ServerMsgID = msgToMQSingle.MsgData.ServerMsgID
+	resp.ClientMsgID = msgToMQSingle.MsgData.ClientMsgID
+	return resp, nil
+}
+
+func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
+	// callback
+	promePkg.PromeInc(promePkg.GroupChatMsgRecvSuccessCounter)
+	err = CallbackBeforeSendGroupMsg(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	var memberUserIDList []string
+	if memberUserIDList, err = m.messageVerification(ctx, req); err != nil {
+		promePkg.PromeInc(promePkg.GroupChatMsgProcessFailedCounter)
+		return nil, err
+	}
+
+	var addUidList []string
+	switch req.MsgData.ContentType {
+	case constant.MemberKickedNotification:
+		var tips sdkws.TipsComm
+		var memberKickedTips sdkws.MemberKickedTips
+		err := proto.Unmarshal(req.MsgData.Content, &tips)
+		if err != nil {
+			return nil, err
+		}
+		err = proto.Unmarshal(tips.Detail, &memberKickedTips)
+		if err != nil {
+			return nil, err
+		}
+		for _, v := range memberKickedTips.KickedUserList {
+			addUidList = append(addUidList, v.UserID)
+		}
+	case constant.MemberQuitNotification:
+		addUidList = append(addUidList, req.MsgData.SendID)
+
+	default:
+	}
+	if len(addUidList) > 0 {
+		memberUserIDList = append(memberUserIDList, addUidList...)
+	}
+
+	//split  parallel send
+	var wg sync.WaitGroup
+	var split = 20
+	msgToMQSingle := msg.MsgDataToMQ{MsgData: req.MsgData}
+	mErr := make([]error, 0)
+	var mutex sync.RWMutex
+	remain := len(memberUserIDList) % split
+	for i := 0; i < len(memberUserIDList)/split; i++ {
+		wg.Add(1)
+		tmp := valueCopy(req)
+		go func() {
+			err := m.sendMsgToGroupOptimization(ctx, memberUserIDList[i*split:(i+1)*split], tmp, &wg)
+			if err != nil {
+				mutex.Lock()
+				mErr = append(mErr, err)
+				mutex.Unlock()
+			}
+
+		}()
+	}
+	if remain > 0 {
+		wg.Add(1)
+		tmp := valueCopy(req)
+		go m.sendMsgToGroupOptimization(ctx, memberUserIDList[split*(len(memberUserIDList)/split):], tmp, &wg)
+	}
+
+	wg.Wait()
+
+	// callback
+	err = CallbackAfterSendGroupMsg(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range mErr {
+		if v != nil {
+			return nil, v
+		}
+	}
+
+	if req.MsgData.ContentType == constant.AtText {
+		go func() {
+			var conversationReq pbConversation.ModifyConversationFieldReq
+			var tag bool
+			var atUserID []string
+			conversation := pbConversation.Conversation{
+				OwnerUserID:      req.MsgData.SendID,
+				ConversationID:   utils.GetConversationIDBySessionType(req.MsgData.GroupID, constant.GroupChatType),
+				ConversationType: constant.GroupChatType,
+				GroupID:          req.MsgData.GroupID,
+			}
+			conversationReq.Conversation = &conversation
+			conversationReq.FieldType = constant.FieldGroupAtType
+			tagAll := utils.IsContain(constant.AtAllString, req.MsgData.AtUserIDList)
+			if tagAll {
+				atUserID = utils.DifferenceString([]string{constant.AtAllString}, req.MsgData.AtUserIDList)
+				if len(atUserID) == 0 { //just @everyone
+					conversationReq.UserIDList = memberUserIDList
+					conversation.GroupAtType = constant.AtAll
+				} else { //@Everyone and @other people
+					conversationReq.UserIDList = atUserID
+					conversation.GroupAtType = constant.AtAllAtMe
+					tag = true
+				}
+			} else {
+				conversationReq.UserIDList = req.MsgData.AtUserIDList
+				conversation.GroupAtType = constant.AtMe
+			}
+
+			err := m.Conversation.ModifyConversationField(ctx, &conversationReq)
+			if err != nil {
+				return
+			}
+
+			if tag {
+				conversationReq.UserIDList = utils.DifferenceString(atUserID, memberUserIDList)
+				conversation.GroupAtType = constant.AtAll
+				err := m.Conversation.ModifyConversationField(ctx, &conversationReq)
+				if err != nil {
+					return
+				}
+			}
+		}()
+	}
+	//
+
+	promePkg.PromeInc(promePkg.GroupChatMsgProcessSuccessCounter)
+	resp.SendTime = msgToMQSingle.MsgData.SendTime
+	resp.ServerMsgID = msgToMQSingle.MsgData.ServerMsgID
+	resp.ClientMsgID = msgToMQSingle.MsgData.ClientMsgID
+	return resp, nil
+}
+
+func (m *msgServer) SendMsg(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, error error) {
+	resp = &msg.SendMsgResp{}
+	flag := isMessageHasReadEnabled(req.MsgData)
+	if !flag {
+		return nil, constant.ErrMessageHasReadDisable.Wrap()
+	}
+	m.encapsulateMsgData(req.MsgData)
+	if err := CallbackMsgModify(ctx, req); err != nil {
+		return nil, err
+	}
+	switch req.MsgData.SessionType {
+	case constant.SingleChatType:
+		return m.sendMsgSingleChat(ctx, req)
+	case constant.GroupChatType:
+		return m.sendMsgGroupChat(ctx, req)
+	case constant.NotificationChatType:
+		return m.sendMsgNotification(ctx, req)
+	case constant.SuperGroupChatType:
+		return m.sendMsgSuperGroupChat(ctx, req)
+	default:
+		return nil, constant.ErrArgs.Wrap("unknown sessionType")
+	}
+}
+
+func (m *msgServer) GetMaxAndMinSeq(ctx context.Context, req *sdkws.GetMaxAndMinSeqReq) (*sdkws.GetMaxAndMinSeqResp, error) {
+	resp := new(sdkws.GetMaxAndMinSeqResp)
+	m2 := make(map[string]*sdkws.MaxAndMinSeq)
+	maxSeq, err := m.MsgInterface.GetUserMaxSeq(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	minSeq, err := m.MsgInterface.GetUserMinSeq(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	resp.MaxSeq = maxSeq
+	resp.MinSeq = minSeq
+	if len(req.GroupIDList) > 0 {
+		resp.GroupMaxAndMinSeq = make(map[string]*sdkws.MaxAndMinSeq)
+		for _, groupID := range req.GroupIDList {
+			maxSeq, err := m.MsgInterface.GetGroupMaxSeq(ctx, groupID)
+			if err != nil {
+				return nil, err
+			}
+			minSeq, err := m.MsgInterface.GetGroupMinSeq(ctx, groupID)
+			if err != nil {
+				return nil, err
+			}
+			m2[groupID] = &sdkws.MaxAndMinSeq{
+				MaxSeq: maxSeq,
+				MinSeq: minSeq,
+			}
+		}
+	}
+	return resp, nil
+}
+
+func (m *msgServer) PullMessageBySeqList(ctx context.Context, req *sdkws.PullMessageBySeqListReq) (*sdkws.PullMessageBySeqListResp, error) {
+	resp := &sdkws.PullMessageBySeqListResp{GroupMsgDataList: make(map[string]*sdkws.MsgDataList)}
+	msgs, err := m.MsgInterface.GetMessageListBySeq(ctx, req.UserID, req.SeqList)
+	if err != nil {
+		return nil, err
+	}
+	resp.List = msgs
+	for userID, list := range req.GroupSeqList {
+		msgs, err := m.MsgInterface.GetMessageListBySeq(ctx, userID, list.SeqList)
+		if err != nil {
+			return nil, err
+		}
+		resp.GroupMsgDataList[userID] = &sdkws.MsgDataList{
+			MsgDataList: msgs,
+		}
+	}
+	return resp, nil
+}

internal/rpc/msg/server.go

@@ -0,0 +1,72 @@
+package msg
+
+import (
+	"Open_IM/internal/common/check"
+	"Open_IM/pkg/common/db/controller"
+	"Open_IM/pkg/common/db/localcache"
+	"Open_IM/pkg/common/db/relation"
+	tablerelation "Open_IM/pkg/common/db/table/relation"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/openKeeper"
+
+	promePkg "Open_IM/pkg/common/prometheus"
+	"Open_IM/pkg/proto/msg"
+	"google.golang.org/grpc"
+)
+
+type msgServer struct {
+	RegisterCenter discoveryRegistry.SvcDiscoveryRegistry
+	MsgInterface   controller.MsgInterface
+	Group          *check.GroupChecker
+	User           *check.UserCheck
+	Conversation   *check.ConversationChecker
+	friend         *check.FriendChecker
+	*localcache.GroupLocalCache
+	black *check.BlackChecker
+}
+
+type deleteMsg struct {
+	UserID      string
+	OpUserID    string
+	SeqList     []uint32
+	OperationID string
+}
+
+func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
+	mysql, err := relation.NewGormDB()
+	if err != nil {
+		return err
+	}
+	if err := mysql.AutoMigrate(&tablerelation.UserModel{}); err != nil {
+		return err
+	}
+	s := &msgServer{
+		Conversation: check.NewConversationChecker(client),
+		User:         check.NewUserCheck(client),
+		Group:        check.NewGroupChecker(client),
+		//MsgInterface: controller.MsgInterface(),
+		RegisterCenter:  client,
+		GroupLocalCache: localcache.NewGroupMemberIDsLocalCache(client),
+		black:           check.NewBlackChecker(client),
+		friend:          check.NewFriendChecker(client),
+	}
+	s.initPrometheus()
+	msg.RegisterMsgServer(server, s)
+	return nil
+}
+
+func (m *msgServer) initPrometheus() {
+	promePkg.NewMsgPullFromRedisSuccessCounter()
+	promePkg.NewMsgPullFromRedisFailedCounter()
+	promePkg.NewMsgPullFromMongoSuccessCounter()
+	promePkg.NewMsgPullFromMongoFailedCounter()
+	promePkg.NewSingleChatMsgRecvSuccessCounter()
+	promePkg.NewGroupChatMsgRecvSuccessCounter()
+	promePkg.NewWorkSuperGroupChatMsgRecvSuccessCounter()
+	promePkg.NewSingleChatMsgProcessSuccessCounter()
+	promePkg.NewSingleChatMsgProcessFailedCounter()
+	promePkg.NewGroupChatMsgProcessSuccessCounter()
+	promePkg.NewGroupChatMsgProcessFailedCounter()
+	promePkg.NewWorkSuperGroupChatMsgProcessSuccessCounter()
+	promePkg.NewWorkSuperGroupChatMsgProcessFailedCounter()
+}

internal/rpc/msg/utils.go

@@ -0,0 +1,37 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/proto/sdkws"
+	"Open_IM/pkg/utils"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+)
+
+func isMessageHasReadEnabled(msgData *sdkws.MsgData) bool {
+	switch msgData.ContentType {
+	case constant.HasReadReceipt:
+		if config.Config.SingleMessageHasReadReceiptEnable {
+			return true
+		} else {
+			return false
+		}
+	case constant.GroupHasReadReceipt:
+		if config.Config.GroupMessageHasReadReceiptEnable {
+			return true
+		} else {
+			return false
+		}
+	}
+	return true
+}
+
+func IsNotFound(err error) bool {
+	switch utils.Unwrap(err) {
+	case redis.Nil, gorm.ErrRecordNotFound:
+		return true
+	default:
+		return false
+	}
+}

internal/rpc/user/user.go

@@ -1,187 +1,49 @@
 package user
 
 import (
+	"Open_IM/internal/common/check"
 	"Open_IM/internal/common/convert"
-	"Open_IM/internal/common/rpc_server"
-	"Open_IM/internal/common/rpcserver"
-	chat "Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/config"
+	"Open_IM/internal/common/notification"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/db/relation"
 	tablerelation "Open_IM/pkg/common/db/table/relation"
-	"Open_IM/pkg/common/log"
-	prome "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
 	"Open_IM/pkg/proto/sdkws"
 	pbuser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-
+	"github.com/OpenIMSDK/openKeeper"
 	"google.golang.org/grpc"
 )
 
 type userServer struct {
-	rpcPort         int
-	rpcRegisterName string
-	*rpcserver.RpcServer
 	controller.UserInterface
+	notification        *notification.Check
+	userCheck           *check.UserCheck
+	ConversationChecker *check.ConversationChecker
+	RegisterCenter      discoveryRegistry.SvcDiscoveryRegistry
 }
 
-func NewUserServer(port int) *userServer {
-	r, err := rpcserver.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImUserName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
+	mysql, err := relation.NewGormDB()
 	if err != nil {
-		panic(err)
+		return err
 	}
-	//mysql init
-	var mysql relation.Mysql
-	var model relation.UserGorm
-	err = mysql.InitConn().AutoMigrateModel(&model)
-	if err != nil {
-		panic("db init err:" + err.Error())
+	if err := mysql.AutoMigrate(&tablerelation.UserModel{}); err != nil {
+		return err
 	}
-	if mysql.GormConn() != nil {
-		model.DB = mysql.GormConn()
-	} else {
-		panic("db init err:" + "conn is nil")
-	}
-	return &userServer{RpcServer: r, UserInterface: controller.NewUserController(model.DB)}
+	pbuser.RegisterUserServer(server, &userServer{
+		UserInterface:  controller.NewUserController(mysql),
+		notification:   notification.NewCheck(client),
+		userCheck:      check.NewUserCheck(client),
+		RegisterCenter: client,
+	})
+	return nil
 }
 
-func (s *userServer) Run() {
-	operationID := utils.OperationIDGenerator()
-	log.NewInfo(operationID, "rpc user start...")
-	listener, address, err := rpcserver.GetTcpListen(config.Config.ListenIP, s.Port)
-	if err != nil {
-		panic(err)
-	}
-	log.NewInfo(operationID, "listen ok ", address)
-	defer listener.Close()
-	//grpc server
-	var grpcOpts []grpc.ServerOption
-	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	//Service registers with etcd
-	pbuser.RegisterUserServer(srv, s)
-
-	err = srv.Serve(listener)
-	if err != nil {
-		panic(err)
-	}
-	log.NewInfo(operationID, "rpc  user success")
-}
-
-// ok
-//func (s *userServer) SyncJoinedGroupMemberFaceURL(ctx context.Context, userID string, faceURL string, operationID string, opUserID string) {
-//	members, err := s.GetJoinedGroupMembers(ctx, userID)
-//	if err != nil {
-//		return
-//	}
-//	groupIDs := make([]string, 0)
-//	for _, v := range members {
-//		groupIDs = append(groupIDs, v.GroupID)
-//	}
-//	if s.SetGroupMemberInfo(ctx, "", faceURL, "", 0, groupIDs, userID) != nil {
-//		return
-//	}
-//	for _, v := range groupIDs {
-//		chat.GroupMemberInfoSetNotification(operationID, opUserID, v, userID)
-//	}
-//}
-
-// ok
-//func (s *userServer) SyncJoinedGroupMemberNickname(ctx context.Context, userID string, newNickname, oldNickname string, operationID string, opUserID string) {
-//	members, err := s.GetJoinedGroupMembers(ctx, userID)
-//	if err != nil {
-//		return
-//	}
-//	groupIDs := make([]string, 0)
-//	for _, v := range members {
-//		if v.Nickname == oldNickname {
-//			groupIDs = append(groupIDs, v.GroupID)
-//		}
-//	}
-//	s.SetGroupMemberInfo(ctx, newNickname, "", "", 0, groupIDs, userID)
-//	for _, v := range groupIDs {
-//		chat.GroupMemberInfoSetNotification(operationID, opUserID, v, userID)
-//	}
-//}
-
-// 设置群头像
-//func (s *userServer) SetGroupMemberInfo(ctx context.Context, nickname, faceURL, ex string, roleLevel int32, groupIDs []string, userID string) (err error) {
-//
-//	req := pbgroup.SetGroupMemberInfo{UserID: userID}
-//	if nickname != "" {
-//		req.Nickname = &wrappers.StringValue{Value: nickname}
-//	}
-//	if faceURL != "" {
-//		req.FaceURL = &wrappers.StringValue{Value: faceURL}
-//	}
-//	if ex != "" {
-//		req.Ex = &wrappers.StringValue{Value: ex}
-//	}
-//	if roleLevel != 0 {
-//		req.RoleLevel = &wrappers.Int32Value{Value: roleLevel}
-//	}
-//
-//	setGroupMemberInfoReq := &pbgroup.SetGroupMemberInfoReq{}
-//	for _, v := range groupIDs {
-//		req.GroupID = v
-//		setGroupMemberInfoReq.Members = append(setGroupMemberInfoReq.Members, &req)
-//	}
-//	conn, err := s.RegisterCenter.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
-//	if err != nil {
-//		return err
-//	}
-//	client := group.NewGroupClient(conn)
-//	_, err = client.SetGroupMemberInfo(ctx, setGroupMemberInfoReq)
-//	return
-//}
-
-// 获取加入的群成员信息
-//func (s *userServer) GetJoinedGroupMembers(ctx context.Context, userID string) (members []*sdkws.GroupMemberFullInfo, err error) {
-//	conn, err := s.RegisterCenter.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
-//	if err != nil {
-//		return nil, err
-//	}
-//
-//	client := group.NewGroupClient(conn)
-//	for {
-//		idx := int32(0)
-//		req := pbgroup.GetJoinedGroupListReq{FromUserID: userID, Pagination: &sdkws.RequestPagination{PageNumber: idx, ShowNumber: constant.ShowNumber}}
-//		resp, err := client.GetJoinedGroupList(ctx, &req)
-//		if err != nil {
-//			return nil, err
-//		}
-//		groupIDs := make([]string, 0)
-//
-//		for _, v := range resp.Groups {
-//			groupIDs = append(groupIDs, v.GroupID)
-//		}
-//
-//		client.GetGroupMembersInfo()
-//
-//		if len(resp.Groups) < constant.ShowNumber {
-//			break
-//		}
-//		idx++
-//	}
-//
-//	return
-//}
-
 // ok
 func (s *userServer) GetDesignateUsers(ctx context.Context, req *pbuser.GetDesignateUsersReq) (resp *pbuser.GetDesignateUsersResp, err error) {
 	resp = &pbuser.GetDesignateUsersResp{}
@@ -229,11 +91,11 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserI
 	}
 	go func() {
 		for _, v := range friends {
-			chat.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, v.FriendUser.UserID, tracelog.GetOpUserID(ctx))
+			s.notification.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, v.FriendUser.UserID, tracelog.GetOpUserID(ctx))
 		}
 	}()
 
-	chat.UserInfoUpdatedNotification(ctx, tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
+	s.notification.UserInfoUpdatedNotification(ctx, tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
 
 	return resp, nil
 }
@@ -249,7 +111,7 @@ func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.Se
 	if err := s.UpdateByMap(ctx, req.UserID, m); err != nil {
 		return nil, err
 	}
-	chat.UserInfoUpdatedNotification(ctx, req.UserID, req.UserID)
+	s.notification.UserInfoUpdatedNotification(ctx, req.UserID, req.UserID)
 	return resp, nil
 }
 

internal/startrpc/start.go

@@ -0,0 +1,67 @@
+package startrpc
+
+import (
+	"Open_IM/internal/common/network"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/middleware"
+	promePkg "Open_IM/pkg/common/prometheus"
+	"flag"
+	"fmt"
+	"github.com/OpenIMSDK/openKeeper"
+	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
+	"google.golang.org/grpc"
+	"net"
+)
+
+func start(rpcPorts []int, rpcRegisterName string, prometheusPorts []int, rpcFn func(client *openKeeper.ZkClient, server *grpc.Server) error, options []grpc.ServerOption) error {
+	flagRpcPort := flag.Int("port", rpcPorts[0], "get RpcGroupPort from cmd,default 16000 as port")
+	flagPrometheusPort := flag.Int("prometheus_port", prometheusPorts[0], "groupPrometheusPort default listen port")
+	flag.Parse()
+	fmt.Println("start group rpc server, port: ", *flagRpcPort, ", OpenIM version: ", constant.CurrentVersion)
+	log.NewPrivateLog(constant.LogFileName)
+	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", config.Config.ListenIP, *flagRpcPort))
+	if err != nil {
+		return err
+	}
+	defer listener.Close()
+	zkClient, err := openKeeper.NewClient(config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema, 10, "", "")
+	if err != nil {
+		return err
+	}
+	defer zkClient.Close()
+	registerIP, err := network.GetRpcRegisterIP(config.Config.RpcRegisterIP)
+	if err != nil {
+		return err
+	}
+	options = append(options, grpc.UnaryInterceptor(middleware.RpcServerInterceptor)) // ctx 中间件
+	if config.Config.Prometheus.Enable {
+		promePkg.NewGrpcRequestCounter()
+		promePkg.NewGrpcRequestFailedCounter()
+		promePkg.NewGrpcRequestSuccessCounter()
+		options = append(options, []grpc.ServerOption{
+			// grpc.UnaryInterceptor(promePkg.UnaryServerInterceptorProme),
+			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
+			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
+		}...)
+	}
+	srv := grpc.NewServer(options...)
+	defer srv.GracefulStop()
+	err = zkClient.Register(rpcRegisterName, registerIP, *flagRpcPort)
+	if err != nil {
+		return err
+	}
+	if config.Config.Prometheus.Enable {
+		err := promePkg.StartPromeSrv(*flagPrometheusPort)
+		if err != nil {
+			return err
+		}
+	}
+	return rpcFn(zkClient, srv)
+}
+
+func Start(rpcPorts []int, rpcRegisterName string, prometheusPorts []int, rpcFn func(client *openKeeper.ZkClient, server *grpc.Server) error, options ...grpc.ServerOption) {
+	err := start(rpcPorts, rpcRegisterName, prometheusPorts, rpcFn, options)
+	fmt.Println("end", err)
+}