v3 - main to cut out

internal/rpc/msg/callback.go

@@ -0,0 +1,159 @@
+package msg
+
+import (
+	cbApi "Open_IM/pkg/call_back_struct"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	pbChat "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/utils"
+)
+
+func copyCallbackCommonReqStruct(msg *pbChat.SendMsgReq) cbApi.CommonCallbackReq {
+	return cbApi.CommonCallbackReq{
+		SendID:           msg.MsgData.SendID,
+		ServerMsgID:      msg.MsgData.ServerMsgID,
+		ClientMsgID:      msg.MsgData.ClientMsgID,
+		OperationID:      msg.OperationID,
+		SenderPlatformID: msg.MsgData.SenderPlatformID,
+		SenderNickname:   msg.MsgData.SenderNickname,
+		SessionType:      msg.MsgData.SessionType,
+		MsgFrom:          msg.MsgData.MsgFrom,
+		ContentType:      msg.MsgData.ContentType,
+		Status:           msg.MsgData.Status,
+		CreateTime:       msg.MsgData.CreateTime,
+		Content:          string(msg.MsgData.Content),
+	}
+}
+
+func callbackBeforeSendSingleMsg(msg *pbChat.SendMsgReq) (canSend bool, err error) {
+	if !config.Config.Callback.CallbackBeforeSendSingleMsg.Enable {
+		return true, nil
+	}
+	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
+	commonCallbackReq := copyCallbackCommonReqStruct(msg)
+	commonCallbackReq.CallbackCommand = constant.CallbackBeforeSendSingleMsgCommand
+	req := cbApi.CallbackBeforeSendSingleMsgReq{
+		CommonCallbackReq: commonCallbackReq,
+		RecvID:            msg.MsgData.RecvID,
+	}
+	resp := &cbApi.CallbackBeforeSendSingleMsgResp{
+		CommonCallbackResp: cbApi.CommonCallbackResp{},
+	}
+	//utils.CopyStructFields(req, msg.MsgData)
+	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
+	if err := http.PostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackTimeOut); err != nil {
+		if !config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackFailedContinue {
+			return false, err
+		} else {
+			return true, err
+		}
+	} else {
+		if resp.ActionCode == constant.ActionForbidden && resp.ErrCode == constant.CallbackHandleSuccess {
+			return false, nil
+		}
+	}
+	return true, err
+}
+
+func callbackAfterSendSingleMsg(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.CallbackAfterSendSingleMsgCommand
+	req := cbApi.CallbackAfterSendSingleMsgReq{
+		CommonCallbackReq: commonCallbackReq,
+		RecvID:            msg.MsgData.RecvID,
+	}
+	resp := &cbApi.CallbackAfterSendSingleMsgResp{CommonCallbackResp: cbApi.CommonCallbackResp{}}
+	//utils.CopyStructFields(req, msg.MsgData)
+	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
+	if err := http.PostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackAfterSendSingleMsg.CallbackTimeOut); err != nil {
+		return err
+	}
+	return nil
+}
+
+func callbackBeforeSendGroupMsg(msg *pbChat.SendMsgReq) (canSend bool, err error) {
+	if !config.Config.Callback.CallbackBeforeSendGroupMsg.Enable {
+		return true, nil
+	}
+	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
+	commonCallbackReq := copyCallbackCommonReqStruct(msg)
+	commonCallbackReq.CallbackCommand = constant.CallbackBeforeSendGroupMsgCommand
+	req := cbApi.CallbackAfterSendGroupMsgReq{
+		CommonCallbackReq: commonCallbackReq,
+		GroupID:           msg.MsgData.GroupID,
+	}
+	resp := &cbApi.CallbackBeforeSendGroupMsgResp{CommonCallbackResp: cbApi.CommonCallbackResp{}}
+	//utils.CopyStructFields(req, msg.MsgData)
+	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
+	if err := http.PostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackTimeOut); err != nil {
+		if !config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackFailedContinue {
+			return false, err
+		} else {
+			return true, err
+		}
+	} else {
+		if resp.ActionCode == constant.ActionForbidden && resp.ErrCode == constant.CallbackHandleSuccess {
+			return false, nil
+		}
+	}
+	return true, err
+}
+
+func callbackAfterSendGroupMsg(msg *pbChat.SendMsgReq) error {
+	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
+		return nil
+	}
+	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
+	commonCallbackReq := copyCallbackCommonReqStruct(msg)
+	commonCallbackReq.CallbackCommand = constant.CallbackAfterSendGroupMsgCommand
+	req := cbApi.CallbackAfterSendGroupMsgReq{
+		CommonCallbackReq: commonCallbackReq,
+		GroupID:           msg.MsgData.GroupID,
+	}
+	resp := &cbApi.CallbackAfterSendGroupMsgResp{CommonCallbackResp: cbApi.CommonCallbackResp{}}
+
+	//utils.CopyStructFields(req, msg.MsgData)
+	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
+	if err := http.PostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil {
+		return err
+	}
+	return nil
+}
+
+func callbackWordFilter(msg *pbChat.SendMsgReq) (canSend bool, err error) {
+	if !config.Config.Callback.CallbackWordFilter.Enable || msg.MsgData.ContentType != constant.Text {
+		return true, nil
+	}
+	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
+	commonCallbackReq := copyCallbackCommonReqStruct(msg)
+	commonCallbackReq.CallbackCommand = constant.CallbackWordFilterCommand
+	req := cbApi.CallbackWordFilterReq{
+		CommonCallbackReq: commonCallbackReq,
+	}
+	resp := &cbApi.CallbackWordFilterResp{CommonCallbackResp: cbApi.CommonCallbackResp{}}
+	//utils.CopyStructFields(&req., msg.MsgData)
+	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
+	if err := http.PostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackWordFilter.CallbackTimeOut); err != nil {
+		if !config.Config.Callback.CallbackWordFilter.CallbackFailedContinue {
+			log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), "callback failed and config disable, stop this operation")
+			return false, err
+		} else {
+			return true, err
+		}
+	} else {
+		if resp.ActionCode == constant.ActionForbidden && resp.ErrCode == constant.CallbackHandleSuccess {
+			return false, nil
+		}
+		if resp.ErrCode == constant.CallbackHandleSuccess {
+			msg.MsgData.Content = []byte(resp.Content)
+		}
+		log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), string(msg.MsgData.Content))
+	}
+	return true, err
+}

internal/rpc/msg/conversation_notification.go

@@ -0,0 +1,76 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+)
+
+func SetConversationNotification(operationID, sendID, recvID string, contentType int, m proto.Message, tips open_im_sdk.TipsComm) {
+	log.NewInfo(operationID, "args: ", sendID, recvID, contentType, m.String(), tips.String())
+	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{
+		OrigName:     true,
+		EnumsAsInts:  false,
+		EmitDefaults: false,
+	}
+	tips.JsonDetail, _ = marshaler.MarshalToString(m)
+	var n NotificationMsg
+	n.SendID = sendID
+	n.RecvID = recvID
+	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)
+}
+
+// SetPrivate调用
+func ConversationSetPrivateNotification(operationID, sendID, recvID string, isPrivateChat bool) {
+	log.NewInfo(operationID, utils.GetSelfFuncName())
+	conversationSetPrivateTips := &open_im_sdk.ConversationSetPrivateTips{
+		RecvID:    recvID,
+		SendID:    sendID,
+		IsPrivate: isPrivateChat,
+	}
+	var tips open_im_sdk.TipsComm
+	var tipsMsg string
+	//var senderName string
+	//senderName, err := im_mysql_model.GetUserNameByUserID(sendID)
+	//if err != nil {
+	//	log.NewError(operationID, utils.GetSelfFuncName(), err.Error())
+	//	senderName = sendID
+	//}
+	if isPrivateChat == true {
+		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.OpenTips
+	} else {
+		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.CloseTips
+	}
+	tips.DefaultTips = tipsMsg
+	SetConversationNotification(operationID, sendID, recvID, constant.ConversationPrivateChatNotification, conversationSetPrivateTips, tips)
+}
+
+// 会话改变
+func ConversationChangeNotification(operationID, userID string) {
+	log.NewInfo(operationID, utils.GetSelfFuncName())
+	ConversationChangedTips := &open_im_sdk.ConversationUpdateTips{
+		UserID: userID,
+	}
+	var tips open_im_sdk.TipsComm
+	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
+	SetConversationNotification(operationID, userID, userID, constant.ConversationOptChangeNotification, ConversationChangedTips, tips)
+}

internal/rpc/msg/del_msg.go

@@ -0,0 +1,23 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	commonPb "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+)
+
+func (rpc *rpcChat) DelMsgList(_ context.Context, req *commonPb.DelMsgListReq) (*commonPb.DelMsgListResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &commonPb.DelMsgListResp{}
+	if err := db.DB.DelMsgLogic(req.UserID, req.SeqList, req.OperationID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelMsg failed", err.Error())
+		resp.ErrMsg = constant.ErrDB.ErrMsg
+		resp.ErrCode = constant.ErrDB.ErrCode
+		return resp, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}

internal/rpc/msg/friend_notification.go

@@ -0,0 +1,165 @@
+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"
+	utils2 "Open_IM/pkg/common/utils"
+	pbFriend "Open_IM/pkg/proto/friend"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+)
+
+func getFromToUserNickname(fromUserID, toUserID string) (string, string, error) {
+	from, err := imdb.GetUserByUserID(fromUserID)
+	if err != nil {
+		return "", "", utils.Wrap(err, "")
+	}
+	to, err := imdb.GetUserByUserID(toUserID)
+	if err != nil {
+		return "", "", utils.Wrap(err, "")
+	}
+	return from.Nickname, to.Nickname, nil
+}
+
+func friendNotification(commID *pbFriend.CommID, contentType int32, m proto.Message) {
+	log.Info(commID.OperationID, utils.GetSelfFuncName(), "args: ", commID, contentType)
+	var err error
+	var tips open_im_sdk.TipsComm
+	tips.Detail, err = proto.Marshal(m)
+	if err != nil {
+		log.Error(commID.OperationID, "Marshal failed ", err.Error(), m.String())
+		return
+	}
+
+	marshaler := jsonpb.Marshaler{
+		OrigName:     true,
+		EnumsAsInts:  false,
+		EmitDefaults: false,
+	}
+
+	tips.JsonDetail, _ = marshaler.MarshalToString(m)
+
+	fromUserNickname, toUserNickname, err := getFromToUserNickname(commID.FromUserID, commID.ToUserID)
+	if err != nil {
+		log.Error(commID.OperationID, "getFromToUserNickname failed ", err.Error(), commID.FromUserID, commID.ToUserID)
+		return
+	}
+	cn := config.Config.Notification
+	switch contentType {
+	case constant.FriendApplicationNotification:
+		tips.DefaultTips = fromUserNickname + cn.FriendApplication.DefaultTips.Tips
+	case constant.FriendApplicationApprovedNotification:
+		tips.DefaultTips = fromUserNickname + cn.FriendApplicationApproved.DefaultTips.Tips
+	case constant.FriendApplicationRejectedNotification:
+		tips.DefaultTips = fromUserNickname + cn.FriendApplicationRejected.DefaultTips.Tips
+	case constant.FriendAddedNotification:
+		tips.DefaultTips = cn.FriendAdded.DefaultTips.Tips
+	case constant.FriendDeletedNotification:
+		tips.DefaultTips = cn.FriendDeleted.DefaultTips.Tips + toUserNickname
+	case constant.FriendRemarkSetNotification:
+		tips.DefaultTips = fromUserNickname + cn.FriendRemarkSet.DefaultTips.Tips
+	case constant.BlackAddedNotification:
+		tips.DefaultTips = cn.BlackAdded.DefaultTips.Tips
+	case constant.BlackDeletedNotification:
+		tips.DefaultTips = cn.BlackDeleted.DefaultTips.Tips + toUserNickname
+	case constant.UserInfoUpdatedNotification:
+		tips.DefaultTips = cn.UserInfoUpdated.DefaultTips.Tips
+	default:
+		log.Error(commID.OperationID, "contentType failed ", contentType)
+		return
+	}
+
+	var n NotificationMsg
+	n.SendID = commID.FromUserID
+	n.RecvID = commID.ToUserID
+	n.ContentType = contentType
+	n.SessionType = constant.SingleChatType
+	n.MsgFrom = constant.SysMsgType
+	n.OperationID = commID.OperationID
+	n.Content, err = proto.Marshal(&tips)
+	if err != nil {
+		log.Error(commID.OperationID, "Marshal failed ", err.Error(), tips.String())
+		return
+	}
+	Notification(&n)
+}
+
+func FriendApplicationNotification(req *pbFriend.AddFriendReq) {
+	FriendApplicationTips := open_im_sdk.FriendApplicationTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	FriendApplicationTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	FriendApplicationTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	friendNotification(req.CommID, constant.FriendApplicationNotification, &FriendApplicationTips)
+}
+
+func FriendApplicationApprovedNotification(req *pbFriend.AddFriendResponseReq) {
+	FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
+	friendNotification(req.CommID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
+}
+
+func FriendApplicationRejectedNotification(req *pbFriend.AddFriendResponseReq) {
+	FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
+	friendNotification(req.CommID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
+}
+
+func FriendAddedNotification(operationID, opUserID, fromUserID, toUserID string) {
+	friendAddedTips := open_im_sdk.FriendAddedTips{Friend: &open_im_sdk.FriendInfo{}, OpUser: &open_im_sdk.PublicUserInfo{}}
+	user, err := imdb.GetUserByUserID(opUserID)
+	if err != nil {
+		log.NewError(operationID, "GetUserByUserID failed ", err.Error(), opUserID)
+		return
+	}
+	utils2.UserDBCopyOpenIMPublicUser(friendAddedTips.OpUser, user)
+	friend, err := imdb.GetFriendRelationshipFromFriend(fromUserID, toUserID)
+	if err != nil {
+		log.NewError(operationID, "GetFriendRelationshipFromFriend failed ", err.Error(), fromUserID, toUserID)
+		return
+	}
+	utils2.FriendDBCopyOpenIM(friendAddedTips.Friend, friend)
+	commID := pbFriend.CommID{FromUserID: fromUserID, ToUserID: toUserID, OpUserID: opUserID, OperationID: operationID}
+	friendNotification(&commID, constant.FriendAddedNotification, &friendAddedTips)
+}
+
+func FriendDeletedNotification(req *pbFriend.DeleteFriendReq) {
+	friendDeletedTips := open_im_sdk.FriendDeletedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	friendDeletedTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	friendDeletedTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	friendNotification(req.CommID, constant.FriendDeletedNotification, &friendDeletedTips)
+}
+
+func FriendRemarkSetNotification(operationID, opUserID, fromUserID, toUserID string) {
+	friendInfoChangedTips := open_im_sdk.FriendInfoChangedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	friendInfoChangedTips.FromToUserID.FromUserID = fromUserID
+	friendInfoChangedTips.FromToUserID.ToUserID = toUserID
+	commID := pbFriend.CommID{FromUserID: fromUserID, ToUserID: toUserID, OpUserID: opUserID, OperationID: operationID}
+	friendNotification(&commID, constant.FriendRemarkSetNotification, &friendInfoChangedTips)
+}
+
+func BlackAddedNotification(req *pbFriend.AddBlacklistReq) {
+	blackAddedTips := open_im_sdk.BlackAddedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	blackAddedTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	blackAddedTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	friendNotification(req.CommID, constant.BlackAddedNotification, &blackAddedTips)
+}
+
+func BlackDeletedNotification(req *pbFriend.RemoveBlacklistReq) {
+	blackDeletedTips := open_im_sdk.BlackDeletedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	blackDeletedTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	blackDeletedTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	friendNotification(req.CommID, constant.BlackDeletedNotification, &blackDeletedTips)
+}
+
+func UserInfoUpdatedNotification(operationID, userID string, needNotifiedUserID string) {
+	selfInfoUpdatedTips := open_im_sdk.UserInfoUpdatedTips{UserID: userID}
+	commID := pbFriend.CommID{FromUserID: userID, ToUserID: needNotifiedUserID, OpUserID: userID, OperationID: operationID}
+	friendNotification(&commID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
+}

internal/rpc/msg/group_notification.go

@@ -0,0 +1,508 @@
+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/token_verify"
+	utils2 "Open_IM/pkg/common/utils"
+	pbGroup "Open_IM/pkg/proto/group"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+)
+
+//message GroupCreatedTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo Creator = 2;
+//  repeated GroupMemberFullInfo MemberList = 3;
+//  uint64 OperationTime = 4;
+//} creator->group
+
+func setOpUserInfo(opUserID, groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) error {
+	if token_verify.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 *open_im_sdk.GroupInfo) error {
+	group, err := imdb.GetGroupInfoByGroupID(groupID)
+	if err != nil {
+		return utils.Wrap(err, "GetGroupInfoByGroupID failed")
+	}
+	err = utils2.GroupDBCopyOpenIM(groupInfo, group)
+	if err != nil {
+		return utils.Wrap(err, "GetGroupMemberNumByGroupID failed")
+	}
+	return nil
+}
+
+func setGroupMemberInfo(groupID, userID string, groupMemberInfo *open_im_sdk.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 *open_im_sdk.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 *open_im_sdk.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)
+
+	var err error
+	var tips open_im_sdk.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)
+
+	from, err := imdb.GetUserByUserID(sendID)
+	if err != nil {
+		log.Error(operationID, "GetUserByUserID failed ", err.Error(), sendID)
+	}
+	nickname := ""
+	if from != nil {
+		nickname = from.Nickname
+	}
+
+	to, err := imdb.GetUserByUserID(recvUserID)
+	if err != nil {
+		log.Error(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
+	default:
+		log.Error(operationID, "contentType failed ", contentType)
+		return
+	}
+
+	var n NotificationMsg
+	n.SendID = sendID
+	if groupID != "" {
+		n.RecvID = groupID
+		n.SessionType = constant.GroupChatType
+	} 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 := open_im_sdk.GroupCreatedTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}, GroupOwnerUser: &open_im_sdk.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 open_im_sdk.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)
+	}
+	groupNotification(constant.GroupCreatedNotification, &GroupCreatedTips, opUserID, groupID, "", operationID)
+}
+
+//群信息改变后掉用
+func GroupInfoSetNotification(operationID, opUserID, groupID string) {
+	GroupInfoChangedTips := open_im_sdk.GroupInfoSetTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(groupID, GroupInfoChangedTips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	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 := open_im_sdk.GroupMutedTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.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 := open_im_sdk.GroupCancelMutedTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.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 := open_im_sdk.GroupMemberMutedTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}, MutedUser: &open_im_sdk.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 GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMemberUserID string) {
+	tips := open_im_sdk.GroupMemberCancelMutedTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}, MutedUser: &open_im_sdk.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(req *pbGroup.JoinGroupReq) {
+	JoinGroupApplicationTips := open_im_sdk.JoinGroupApplicationTips{Group: &open_im_sdk.GroupInfo{}, Applicant: &open_im_sdk.PublicUserInfo{}}
+	err := setGroupInfo(req.GroupID, JoinGroupApplicationTips.Group)
+	if err != nil {
+		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
+		return
+	}
+	if err = setPublicUserInfo(req.OpUserID, JoinGroupApplicationTips.Applicant); err != nil {
+		log.Error(req.OperationID, "setPublicUserInfo failed ", err.Error(), req.OpUserID)
+		return
+	}
+	JoinGroupApplicationTips.ReqMsg = req.ReqMessage
+
+	managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID)
+		return
+	}
+	for _, v := range managerList {
+		groupNotification(constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, req.OpUserID, "", v.UserID, req.OperationID)
+		log.NewInfo(req.OperationID, "Notification ", v)
+	}
+}
+
+func MemberQuitNotification(req *pbGroup.QuitGroupReq) {
+	MemberQuitTips := open_im_sdk.MemberQuitTips{Group: &open_im_sdk.GroupInfo{}, QuitUser: &open_im_sdk.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)
+	//	groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, "", req.OpUserID, req.OperationID)
+
+}
+
+//message ApplicationProcessedTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo OpUser = 2;
+//  int32 Result = 3;
+//  string 	Reason = 4;
+//}
+//处理进群请求后调用
+func GroupApplicationAcceptedNotification(req *pbGroup.GroupApplicationResponseReq) {
+	GroupApplicationAcceptedTips := open_im_sdk.GroupApplicationAcceptedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.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)
+}
+
+func GroupApplicationRejectedNotification(req *pbGroup.GroupApplicationResponseReq) {
+	GroupApplicationRejectedTips := open_im_sdk.GroupApplicationRejectedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.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)
+}
+
+func GroupOwnerTransferredNotification(req *pbGroup.TransferGroupOwnerReq) {
+	GroupOwnerTransferredTips := open_im_sdk.GroupOwnerTransferredTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}, NewGroupOwner: &open_im_sdk.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 := open_im_sdk.GroupDismissedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.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 := open_im_sdk.MemberKickedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.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 open_im_sdk.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 := open_im_sdk.MemberInvitedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.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 open_im_sdk.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(req *pbGroup.GroupApplicationResponseReq) {
+	MemberEnterTips := open_im_sdk.MemberEnterTips{Group: &open_im_sdk.GroupInfo{}, EntrantUser: &open_im_sdk.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, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberEnterTips.EntrantUser)
+		return
+	}
+	groupNotification(constant.MemberEnterNotification, &MemberEnterTips, req.OpUserID, req.GroupID, "", req.OperationID)
+
+}

internal/rpc/msg/pull_message.go

@@ -0,0 +1,74 @@
+package msg
+
+import (
+	"context"
+	"github.com/garyburd/redigo/redis"
+
+	commonDB "Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	pbMsg "Open_IM/pkg/proto/chat"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+)
+
+func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *pbMsg.GetMaxAndMinSeqReq) (*pbMsg.GetMaxAndMinSeqResp, error) {
+	log.InfoByKv("rpc getMaxAndMinSeq is arriving", in.OperationID, in.String())
+	//seq, err := model.GetBiggestSeqFromReceive(in.UserID)
+	maxSeq, err1 := commonDB.DB.GetUserMaxSeq(in.UserID)
+	minSeq, err2 := commonDB.DB.GetUserMinSeq(in.UserID)
+	resp := new(pbMsg.GetMaxAndMinSeqResp)
+	if err1 == nil {
+		resp.MaxSeq = uint32(maxSeq)
+	} else if err1 == redis.ErrNil {
+		resp.MaxSeq = 0
+	} else {
+		log.NewError(in.OperationID, "getMaxSeq from redis error", in.String(), err1.Error())
+		resp.ErrCode = 200
+		resp.ErrMsg = "redis get err"
+	}
+	if err2 == nil {
+		resp.MinSeq = uint32(minSeq)
+	} else if err2 == redis.ErrNil {
+		resp.MinSeq = 0
+	} else {
+		log.NewError(in.OperationID, "getMaxSeq from redis error", in.String(), err2.Error())
+		resp.ErrCode = 201
+		resp.ErrMsg = "redis get err"
+	}
+	return resp, nil
+}
+func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *open_im_sdk.PullMessageBySeqListReq) (*open_im_sdk.PullMessageBySeqListResp, error) {
+	log.NewInfo(in.OperationID, "rpc PullMessageBySeqList is arriving", in.String())
+	resp := new(open_im_sdk.PullMessageBySeqListResp)
+	//msgList, err := commonDB.DB.GetMsgBySeqList(in.UserID, in.SeqList, in.OperationID)
+	msgList, err := commonDB.DB.GetMsgBySeqListMongo2(in.UserID, in.SeqList, in.OperationID)
+	if err != nil {
+		log.ErrorByKv("PullMessageBySeqList data error", in.OperationID, in.String())
+		resp.ErrCode = 201
+		resp.ErrMsg = err.Error()
+		return resp, nil
+	}
+	//respSingleMsgFormat = singleMsgHandleByUser(SingleMsgFormat, in.UserID)
+	//respGroupMsgFormat = groupMsgHandleByUser(GroupMsgFormat)
+	resp.ErrCode = 0
+	resp.ErrMsg = ""
+	resp.List = msgList
+	return resp, nil
+
+}
+
+type MsgFormats []*open_im_sdk.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/rpcChat.go

@@ -0,0 +1,67 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/kafka"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/utils"
+	"google.golang.org/grpc"
+	"net"
+	"strconv"
+	"strings"
+)
+
+type rpcChat struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+	producer        *kafka.Producer
+}
+
+func NewRpcChatServer(port int) *rpcChat {
+	log.NewPrivateLog(constant.LogFileName)
+	rc := rpcChat{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImOfflineMessageName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+	rc.producer = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.Ws2mschat.Topic)
+	return &rc
+}
+
+func (rpc *rpcChat) Run() {
+	log.Info("", "", "rpc get_token init...")
+
+	address := utils.ServerIP + ":" + strconv.Itoa(rpc.rpcPort)
+	listener, err := net.Listen("tcp", address)
+	if err != nil {
+		log.Error("", "", "listen network failed, err = %s, address = %s", err.Error(), address)
+		return
+	}
+	log.Info("", "", "listen network success, address = ", address)
+
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+
+	//service registers with etcd
+
+	pbChat.RegisterChatServer(srv, rpc)
+	err = getcdv3.RegisterEtcd(rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName, 10)
+	if err != nil {
+		log.Error("", "", "register rpc get_token to etcd failed, err = %s", err.Error())
+		return
+	}
+
+	err = srv.Serve(listener)
+	if err != nil {
+		log.Info("", "", "rpc get_token fail, err = %s", err.Error())
+		return
+	}
+	log.Info("", "", "rpc get_token init success")
+}

internal/rpc/msg/send_msg.go

@@ -0,0 +1,593 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	rpc "Open_IM/pkg/proto/friend"
+	pbGroup "Open_IM/pkg/proto/group"
+	sdk_ws "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/garyburd/redigo/redis"
+	"github.com/golang/protobuf/proto"
+	"math/rand"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type MsgCallBackReq struct {
+	SendID       string `json:"sendID"`
+	RecvID       string `json:"recvID"`
+	Content      string `json:"content"`
+	SendTime     int64  `json:"sendTime"`
+	MsgFrom      int32  `json:"msgFrom"`
+	ContentType  int32  `json:"contentType"`
+	SessionType  int32  `json:"sessionType"`
+	PlatformID   int32  `json:"senderPlatformID"`
+	MsgID        string `json:"msgID"`
+	IsOnlineOnly bool   `json:"isOnlineOnly"`
+}
+type MsgCallBackResp struct {
+	ErrCode         int32  `json:"errCode"`
+	ErrMsg          string `json:"errMsg"`
+	ResponseErrCode int32  `json:"responseErrCode"`
+	ResponseResult  struct {
+		ModifiedMsg string `json:"modifiedMsg"`
+		Ext         string `json:"ext"`
+	}
+}
+
+func userRelationshipVerification(data *pbChat.SendMsgReq) (bool, int32, string) {
+	if data.MsgData.SessionType == constant.GroupChatType {
+		return true, 0, ""
+	}
+	log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify)
+	req := &rpc.IsInBlackListReq{CommID: &rpc.CommID{}}
+	req.CommID.OperationID = data.OperationID
+	req.CommID.OpUserID = data.MsgData.RecvID
+	req.CommID.FromUserID = data.MsgData.RecvID
+	req.CommID.ToUserID = data.MsgData.SendID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	reply, err := client.IsInBlackList(context.Background(), req)
+	if err != nil {
+		log.NewDebug(data.OperationID, "IsInBlackListReq rpc failed, ", req.String(), err.Error())
+	} else if reply.Response == true {
+		log.NewDebug(data.OperationID, "IsInBlackListReq  ", req.String())
+		return false, 600, "in black list"
+	}
+	log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify)
+	if config.Config.MessageVerify.FriendVerify {
+		friendReq := &rpc.IsFriendReq{CommID: &rpc.CommID{}}
+		friendReq.CommID.OperationID = data.OperationID
+		friendReq.CommID.OpUserID = data.MsgData.RecvID
+		friendReq.CommID.FromUserID = data.MsgData.RecvID
+		friendReq.CommID.ToUserID = data.MsgData.SendID
+		friendReply, err := client.IsFriend(context.Background(), friendReq)
+		if err != nil {
+			log.NewDebug(data.OperationID, "IsFriendReq rpc failed, ", req.String(), err.Error())
+			return true, 0, ""
+		} else if friendReply.Response == false {
+			log.NewDebug(data.OperationID, "not friend  ", req.String())
+			return friendReply.Response, 601, "not friend"
+		}
+		log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify, friendReply.Response)
+		return true, 0, ""
+	} else {
+		return true, 0, ""
+	}
+}
+func (rpc *rpcChat) encapsulateMsgData(msg *sdk_ws.MsgData) {
+	msg.ServerMsgID = GetMsgID(msg.SendID)
+	msg.SendTime = utils.GetCurrentTimestampByMill()
+	switch msg.ContentType {
+	case constant.Text:
+		fallthrough
+	case constant.Picture:
+		fallthrough
+	case constant.Voice:
+		fallthrough
+	case constant.Video:
+		fallthrough
+	case constant.File:
+		fallthrough
+	case constant.AtText:
+		fallthrough
+	case constant.Merger:
+		fallthrough
+	case constant.Card:
+		fallthrough
+	case constant.Location:
+		fallthrough
+	case constant.Custom:
+		fallthrough
+	case constant.Quote:
+		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, true)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, true)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderSync, true)
+	case constant.Revoke:
+		utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false)
+	case constant.HasReadReceipt:
+		log.Info("", "this is a test start", msg, msg.Options)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false)
+		log.Info("", "this is a test end", msg, msg.Options)
+	case constant.Typing:
+		utils.SetSwitchFromOptions(msg.Options, constant.IsHistory, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsPersistent, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderSync, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false)
+
+	}
+}
+func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.SendMsgResp, error) {
+	replay := pbChat.SendMsgResp{}
+	log.NewDebug(pb.OperationID, "rpc sendMsg come here", pb.String())
+	flag, errCode, errMsg := userRelationshipVerification(pb)
+	if !flag {
+		return returnMsg(&replay, pb, errCode, errMsg, "", 0)
+	}
+	//if !utils.VerifyToken(pb.Token, pb.SendID) {
+	//	return returnMsg(&replay, pb, http.StatusUnauthorized, "token validate err,not authorized", "", 0)
+	rpc.encapsulateMsgData(pb.MsgData)
+	log.Info("", "this is a test MsgData ", pb.MsgData)
+	msgToMQ := pbChat.MsgDataToMQ{Token: pb.Token, OperationID: pb.OperationID, MsgData: pb.MsgData}
+	//options := utils.JsonStringToMap(pbData.Options)
+	isHistory := utils.GetSwitchFromOptions(pb.MsgData.Options, constant.IsHistory)
+	mReq := MsgCallBackReq{
+		SendID:      pb.MsgData.SendID,
+		RecvID:      pb.MsgData.RecvID,
+		Content:     string(pb.MsgData.Content),
+		SendTime:    pb.MsgData.SendTime,
+		MsgFrom:     pb.MsgData.MsgFrom,
+		ContentType: pb.MsgData.ContentType,
+		SessionType: pb.MsgData.SessionType,
+		PlatformID:  pb.MsgData.SenderPlatformID,
+		MsgID:       pb.MsgData.ClientMsgID,
+	}
+	if !isHistory {
+		mReq.IsOnlineOnly = true
+	}
+
+	// callback
+	canSend, err := callbackWordFilter(pb)
+	if err != nil {
+		log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackWordFilter failed", err.Error(), pb.MsgData)
+	}
+	if !canSend {
+		log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackWordFilter result", canSend, "end rpc and return", pb.MsgData)
+		return returnMsg(&replay, pb, 201, "callbackWordFilter result stop rpc and return", "", 0)
+	}
+	switch pb.MsgData.SessionType {
+	case constant.SingleChatType:
+		// callback
+		canSend, err := callbackBeforeSendSingleMsg(pb)
+		if err != nil {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg failed", err.Error())
+		}
+		if !canSend {
+			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", canSend, "end rpc and return")
+			return returnMsg(&replay, pb, 201, "callbackBeforeSendSingleMsg result stop rpc and return", "", 0)
+		}
+		isSend := modifyMessageByUserMessageReceiveOpt(pb.MsgData.RecvID, pb.MsgData.SendID, constant.SingleChatType, pb)
+		if isSend {
+			msgToMQ.MsgData = pb.MsgData
+			log.NewInfo(msgToMQ.OperationID, msgToMQ)
+			err1 := rpc.sendMsgToKafka(&msgToMQ, msgToMQ.MsgData.RecvID)
+			if err1 != nil {
+				log.NewError(msgToMQ.OperationID, "kafka send msg err:RecvID", msgToMQ.MsgData.RecvID, msgToMQ.String())
+				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+			}
+		}
+		if msgToMQ.MsgData.SendID != msgToMQ.MsgData.RecvID { //Filter messages sent to yourself
+			err2 := rpc.sendMsgToKafka(&msgToMQ, msgToMQ.MsgData.SendID)
+			if err2 != nil {
+				log.NewError(msgToMQ.OperationID, "kafka send msg err:SendID", msgToMQ.MsgData.SendID, msgToMQ.String())
+				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+			}
+		}
+		// callback
+		if err := callbackAfterSendSingleMsg(pb); err != nil {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendSingleMsg failed", err.Error())
+		}
+		return returnMsg(&replay, pb, 0, "", msgToMQ.MsgData.ServerMsgID, msgToMQ.MsgData.SendTime)
+	case constant.GroupChatType:
+		// callback
+		canSend, err := callbackBeforeSendGroupMsg(pb)
+		if err != nil {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendGroupMsg failed", err.Error())
+		}
+		if !canSend {
+			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendGroupMsg result", canSend, "end rpc and return")
+			return returnMsg(&replay, pb, 201, "callbackBeforeSendGroupMsg result stop rpc and return", "", 0)
+		}
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+		client := pbGroup.NewGroupClient(etcdConn)
+		req := &pbGroup.GetGroupAllMemberReq{
+			GroupID:     pb.MsgData.GroupID,
+			OperationID: pb.OperationID,
+		}
+		reply, err := client.GetGroupAllMember(context.Background(), req)
+		if err != nil {
+			log.Error(pb.Token, pb.OperationID, "rpc send_msg getGroupInfo failed, err = %s", err.Error())
+			return returnMsg(&replay, pb, 201, err.Error(), "", 0)
+		}
+		if reply.ErrCode != 0 {
+			log.Error(pb.Token, pb.OperationID, "rpc send_msg getGroupInfo failed, err = %s", reply.ErrMsg)
+			return returnMsg(&replay, pb, reply.ErrCode, reply.ErrMsg, "", 0)
+		}
+		var addUidList []string
+		switch pb.MsgData.ContentType {
+		case constant.MemberKickedNotification:
+			var tips sdk_ws.TipsComm
+			var memberKickedTips sdk_ws.MemberKickedTips
+			err := proto.Unmarshal(pb.MsgData.Content, &tips)
+			if err != nil {
+				log.Error(pb.OperationID, "Unmarshal err", err.Error())
+			}
+			err = proto.Unmarshal(tips.Detail, &memberKickedTips)
+			if err != nil {
+				log.Error(pb.OperationID, "Unmarshal err", err.Error())
+			}
+			log.Info(pb.OperationID, "data is ", memberKickedTips)
+			for _, v := range memberKickedTips.KickedUserList {
+				addUidList = append(addUidList, v.UserID)
+			}
+		case constant.MemberQuitNotification:
+			addUidList = append(addUidList, pb.MsgData.SendID)
+		default:
+		}
+		groupID := pb.MsgData.GroupID
+		for _, v := range reply.MemberList {
+			pb.MsgData.RecvID = v.UserID
+			isSend := modifyMessageByUserMessageReceiveOpt(v.UserID, groupID, constant.GroupChatType, pb)
+			if isSend {
+				msgToMQ.MsgData = pb.MsgData
+				err := rpc.sendMsgToKafka(&msgToMQ, v.UserID)
+				if err != nil {
+					log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v.UserID, msgToMQ.String())
+					return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+				}
+			}
+
+		}
+		log.Info(msgToMQ.OperationID, "addUidList", addUidList)
+		for _, v := range addUidList {
+			pb.MsgData.RecvID = v
+			isSend := modifyMessageByUserMessageReceiveOpt(v, groupID, constant.GroupChatType, pb)
+			log.Info(msgToMQ.OperationID, "isSend", isSend)
+			if isSend {
+				msgToMQ.MsgData = pb.MsgData
+				err := rpc.sendMsgToKafka(&msgToMQ, v)
+				if err != nil {
+					log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v, msgToMQ.String())
+					return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+				}
+			}
+		}
+		// callback
+		if err := callbackAfterSendGroupMsg(pb); err != nil {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendGroupMsg failed", err.Error())
+		}
+		return returnMsg(&replay, pb, 0, "", msgToMQ.MsgData.ServerMsgID, msgToMQ.MsgData.SendTime)
+	case constant.NotificationChatType:
+		msgToMQ.MsgData = pb.MsgData
+		log.NewInfo(msgToMQ.OperationID, msgToMQ)
+		err1 := rpc.sendMsgToKafka(&msgToMQ, msgToMQ.MsgData.RecvID)
+		if err1 != nil {
+			log.NewError(msgToMQ.OperationID, "kafka send msg err:RecvID", msgToMQ.MsgData.RecvID, msgToMQ.String())
+			return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+		}
+
+		if msgToMQ.MsgData.SendID != msgToMQ.MsgData.RecvID { //Filter messages sent to yourself
+			err2 := rpc.sendMsgToKafka(&msgToMQ, msgToMQ.MsgData.SendID)
+			if err2 != nil {
+				log.NewError(msgToMQ.OperationID, "kafka send msg err:SendID", msgToMQ.MsgData.SendID, msgToMQ.String())
+				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+			}
+		}
+		return returnMsg(&replay, pb, 0, "", msgToMQ.MsgData.ServerMsgID, msgToMQ.MsgData.SendTime)
+	default:
+		return returnMsg(&replay, pb, 203, "unkonwn sessionType", "", 0)
+	}
+}
+
+func (rpc *rpcChat) sendMsgToKafka(m *pbChat.MsgDataToMQ, key string) error {
+	pid, offset, err := rpc.producer.SendMessage(m, key)
+	if err != nil {
+		log.ErrorByKv("kafka send failed", m.OperationID, "send data", m.String(), "pid", pid, "offset", offset, "err", err.Error(), "key", key)
+	}
+	return err
+}
+func GetMsgID(sendID string) string {
+	t := time.Now().Format("2006-01-02 15:04:05")
+	return utils.Md5(t + "-" + sendID + "-" + strconv.Itoa(rand.Int()))
+}
+
+func returnMsg(replay *pbChat.SendMsgResp, pb *pbChat.SendMsgReq, errCode int32, errMsg, serverMsgID string, sendTime int64) (*pbChat.SendMsgResp, error) {
+	replay.ErrCode = errCode
+	replay.ErrMsg = errMsg
+	replay.ServerMsgID = serverMsgID
+	replay.ClientMsgID = pb.MsgData.ClientMsgID
+	replay.SendTime = sendTime
+	return replay, nil
+}
+
+func modifyMessageByUserMessageReceiveOpt(userID, sourceID string, sessionType int, pb *pbChat.SendMsgReq) bool {
+	conversationID := utils.GetConversationIDBySessionType(sourceID, sessionType)
+	opt, err := db.DB.GetSingleConversationRecvMsgOpt(userID, conversationID)
+	if err != nil && err != redis.ErrNil {
+		log.NewError(pb.OperationID, "GetSingleConversationMsgOpt from redis err", conversationID, pb.String(), err.Error())
+		return true
+	}
+	switch opt {
+	case constant.ReceiveMessage:
+		return true
+	case constant.NotReceiveMessage:
+		return false
+	case constant.ReceiveNotNotifyMessage:
+		if pb.MsgData.Options == nil {
+			pb.MsgData.Options = make(map[string]bool, 10)
+		}
+		utils.SetSwitchFromOptions(pb.MsgData.Options, constant.IsOfflinePush, false)
+		return true
+	}
+
+	return true
+}
+
+type NotificationMsg struct {
+	SendID      string
+	RecvID      string
+	Content     []byte //  open_im_sdk.TipsComm
+	MsgFrom     int32
+	ContentType int32
+	SessionType int32
+	OperationID string
+}
+
+func Notification(n *NotificationMsg) {
+	var req pbChat.SendMsgReq
+	var msg sdk_ws.MsgData
+	var offlineInfo sdk_ws.OfflinePushInfo
+	var title, desc, ex string
+	var pushSwitch, unReadCount bool
+	var reliabilityLevel int
+	req.OperationID = n.OperationID
+	msg.SendID = n.SendID
+	msg.RecvID = n.RecvID
+	msg.Content = n.Content
+	msg.MsgFrom = n.MsgFrom
+	msg.ContentType = n.ContentType
+	msg.SessionType = n.SessionType
+	msg.CreateTime = utils.GetCurrentTimestampByMill()
+	msg.ClientMsgID = utils.GetMsgID(n.SendID)
+	msg.Options = make(map[string]bool, 7)
+	switch n.SessionType {
+	case constant.GroupChatType:
+		msg.RecvID = ""
+		msg.GroupID = n.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
+	}
+	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
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	client := pbChat.NewChatClient(etcdConn)
+	reply, err := client.SendMsg(context.Background(), &req)
+	if err != nil {
+		log.NewError(req.OperationID, "SendMsg rpc failed, ", req.String(), err.Error())
+	} else if reply.ErrCode != 0 {
+		log.NewError(req.OperationID, "SendMsg rpc failed, ", req.String(), reply.ErrCode, reply.ErrMsg)
+	}
+}

internal/rpc/msg/tag_send_msg.go

@@ -0,0 +1,45 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"strings"
+)
+
+func TagSendMessage(operationID string, user *db.User, recvID, content string, senderPlatformID int32) {
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "args: ", user.UserID, recvID, content)
+	var req pbChat.SendMsgReq
+	var msgData pbCommon.MsgData
+	msgData.SendID = user.UserID
+	msgData.RecvID = recvID
+	msgData.ContentType = constant.Custom
+	msgData.SessionType = constant.SingleChatType
+	msgData.MsgFrom = constant.UserMsgType
+	msgData.Content = []byte(content)
+	msgData.SenderFaceURL = user.FaceURL
+	msgData.SenderNickname = user.Nickname
+	msgData.Options = map[string]bool{}
+	msgData.Options[constant.IsSenderConversationUpdate] = false
+	msgData.CreateTime = utils.GetCurrentTimestampByMill()
+	msgData.ClientMsgID = utils.GetMsgID(user.UserID)
+	msgData.SenderPlatformID = senderPlatformID
+	req.MsgData = &msgData
+	req.OperationID = operationID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	client := pbChat.NewChatClient(etcdConn)
+	respPb, err := client.SendMsg(context.Background(), &req)
+	if err != nil {
+		log.NewError(operationID, utils.GetSelfFuncName(), "send msg failed", err.Error())
+		return
+	}
+	if respPb.ErrCode != 0 {
+		log.NewError(operationID, utils.GetSelfFuncName(), "send tag msg failed ", respPb)
+	}
+}