send msg file modify

internal/push/logic/push_handler.go

@@ -11,8 +11,7 @@ import (
 	kfk "Open_IM/pkg/common/kafka"
 	"Open_IM/pkg/common/log"
 	pbChat "Open_IM/pkg/proto/chat"
-	pbRelay "Open_IM/pkg/proto/relay"
-	"Open_IM/pkg/utils"
+	pbPush "Open_IM/pkg/proto/push"
 	"github.com/Shopify/sarama"
 	"github.com/golang/protobuf/proto"
 )
@@ -33,28 +32,13 @@ func (ms *PushConsumerHandler) Init() {
 }
 func (ms *PushConsumerHandler) handleMs2PsChat(msg []byte) {
 	log.InfoByKv("msg come from kafka  And push!!!", "", "msg", string(msg))
-	pbData := pbChat.MsgSvrToPushSvrChatMsg{}
-	if err := proto.Unmarshal(msg, &pbData); err != nil {
+	msgFromMQ := pbChat.PushMsgDataToMQ{}
+	if err := proto.Unmarshal(msg, &msgFromMQ); err != nil {
 		log.ErrorByKv("push Unmarshal msg err", "", "msg", string(msg), "err", err.Error())
 		return
 	}
-	sendPbData := pbRelay.MsgToUserReq{}
-	sendPbData.SendTime = pbData.SendTime
-	sendPbData.OperationID = pbData.OperationID
-	sendPbData.ServerMsgID = pbData.MsgID
-	sendPbData.MsgFrom = pbData.MsgFrom
-	sendPbData.ContentType = pbData.ContentType
-	sendPbData.SessionType = pbData.SessionType
-	sendPbData.RecvID = pbData.RecvID
-	sendPbData.Content = pbData.Content
-	sendPbData.SendID = pbData.SendID
-	sendPbData.SenderNickName = pbData.SenderNickName
-	sendPbData.SenderFaceURL = pbData.SenderFaceURL
-	sendPbData.ClientMsgID = pbData.ClientMsgID
-	sendPbData.PlatformID = pbData.PlatformID
-	sendPbData.RecvSeq = pbData.RecvSeq
 	//Call push module to send message to the user
-	MsgToUser(&sendPbData, pbData.OfflineInfo, utils.JsonStringToMap(pbData.Options))
+	MsgToUser((*pbPush.PushMsgReq)(&msgFromMQ))
 }
 func (PushConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
 func (PushConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }

internal/push/logic/push_rpc_server.go

@@ -5,7 +5,6 @@ import (
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	"Open_IM/pkg/proto/push"
-	pbRelay "Open_IM/pkg/proto/relay"
 	"Open_IM/pkg/utils"
 	"context"
 	"google.golang.org/grpc"
@@ -49,23 +48,8 @@ func (r *RPCServer) run() {
 	}
 }
 func (r *RPCServer) PushMsg(_ context.Context, pbData *pbPush.PushMsgReq) (*pbPush.PushMsgResp, error) {
-	sendPbData := pbRelay.MsgToUserReq{}
-	sendPbData.SendTime = pbData.SendTime
-	sendPbData.OperationID = pbData.OperationID
-	sendPbData.ServerMsgID = pbData.MsgID
-	sendPbData.MsgFrom = pbData.MsgFrom
-	sendPbData.ContentType = pbData.ContentType
-	sendPbData.SenderNickName = pbData.SenderNickName
-	sendPbData.SenderFaceURL = pbData.SenderFaceURL
-	sendPbData.ClientMsgID = pbData.ClientMsgID
-	sendPbData.SessionType = pbData.SessionType
-	sendPbData.RecvID = pbData.RecvID
-	sendPbData.Content = pbData.Content
-	sendPbData.SendID = pbData.SendID
-	sendPbData.PlatformID = pbData.PlatformID
-	sendPbData.RecvSeq = pbData.RecvSeq
 	//Call push module to send message to the user
-	MsgToUser(&sendPbData, pbData.OfflineInfo, utils.JsonStringToMap(pbData.Options))
+	MsgToUser(pbData)
 	return &pbPush.PushMsgResp{
 		ResultCode: 0,
 	}, nil

internal/push/logic/push_to_client.go

@@ -8,13 +8,11 @@ package logic
 
 import (
 	push "Open_IM/internal/push/jpush"
-	rpcChat "Open_IM/internal/rpc/chat"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbChat "Open_IM/pkg/proto/chat"
-	pbGroup "Open_IM/pkg/proto/group"
+	pbPush "Open_IM/pkg/proto/push"
 	pbRelay "Open_IM/pkg/proto/relay"
 	"Open_IM/pkg/utils"
 	"context"
@@ -34,122 +32,119 @@ type AtContent struct {
 	IsAtSelf   bool     `json:"isAtSelf"`
 }
 
-func MsgToUser(sendPbData *pbRelay.MsgToUserReq, OfflineInfo string, Options map[string]int32) {
+func MsgToUser(pushMsg *pbPush.PushMsgReq) {
 	var wsResult []*pbRelay.SingleMsgToUser
-	isOfflinePush := utils.GetSwitchFromOptions(Options, "offlinePush")
-	log.InfoByKv("Get chat from msg_transfer And push chat", sendPbData.OperationID, "PushData", sendPbData, Options, isOfflinePush)
+	isOfflinePush := utils.GetSwitchFromOptions(pushMsg.MsgData.Options, constant.IsOfflinePush)
+	log.InfoByKv("Get msg from msg_transfer And push msg", pushMsg.OperationID, "PushData", pushMsg.String())
 	grpcCons := getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName)
 	//Online push message
-	log.InfoByKv("test", sendPbData.OperationID, "len  grpc", len(grpcCons), "data", sendPbData)
+	log.InfoByKv("test", pushMsg.OperationID, "len  grpc", len(grpcCons), "data", pushMsg.String())
 	for _, v := range grpcCons {
 		msgClient := pbRelay.NewOnlineMessageRelayServiceClient(v)
-		reply, err := msgClient.MsgToUser(context.Background(), sendPbData)
+		reply, err := msgClient.OnlinePushMsg(context.Background(), &pbRelay.OnlinePushMsgReq{OperationID: pushMsg.OperationID, MsgData: pushMsg.MsgData})
 		if err != nil {
-			log.InfoByKv("push data to client rpc err", sendPbData.OperationID, "err", err)
+			log.InfoByKv("push data to client rpc err", pushMsg.OperationID, "err", err)
 			continue
 		}
 		if reply != nil && reply.Resp != nil {
 			wsResult = append(wsResult, reply.Resp...)
 		}
 	}
-	log.InfoByKv("push_result", sendPbData.OperationID, "result", wsResult, "sendData", sendPbData)
-	if sendPbData.ContentType != constant.Typing && sendPbData.ContentType != constant.HasReadReceipt {
-		if isOfflinePush {
-			for _, v := range wsResult {
-				if v.ResultCode == 0 {
-					continue
-				}
-				//supported terminal
-				for _, t := range pushTerminal {
-					if v.RecvPlatFormID == t {
-						//Use offline push messaging
-						var UIDList []string
-						UIDList = append(UIDList, v.RecvID)
-						customContent := OpenIMContent{
-							SessionType: int(sendPbData.SessionType),
-							From:        sendPbData.SendID,
-							To:          sendPbData.RecvID,
-							Seq:         sendPbData.RecvSeq,
-						}
-						bCustomContent, _ := json.Marshal(customContent)
-						jsonCustomContent := string(bCustomContent)
-						var content string
-						switch sendPbData.ContentType {
-						case constant.Text:
-							content = constant.ContentType2PushContent[constant.Text]
-						case constant.Picture:
-							content = constant.ContentType2PushContent[constant.Picture]
-						case constant.Voice:
-							content = constant.ContentType2PushContent[constant.Voice]
-						case constant.Video:
-							content = constant.ContentType2PushContent[constant.Video]
-						case constant.File:
-							content = constant.ContentType2PushContent[constant.File]
-						case constant.AtText:
-							a := AtContent{}
-							_ = utils.JsonStringToStruct(sendPbData.Content, &a)
-							if utils.IsContain(v.RecvID, a.AtUserList) {
-								content = constant.ContentType2PushContent[constant.AtText] + constant.ContentType2PushContent[constant.Common]
-							} else {
-								content = constant.ContentType2PushContent[constant.GroupMsg]
-							}
-						default:
-							content = constant.ContentType2PushContent[constant.Common]
-						}
-						pushResult, err := push.JGAccountListPush(UIDList, content, jsonCustomContent, constant.PlatformIDToName(t))
-						if err != nil {
-							log.NewError(sendPbData.OperationID, "offline push error", sendPbData.String(), err.Error(), constant.PlatformIDToName(t))
-						} else {
-							log.NewDebug(sendPbData.OperationID, "offline push return result is ", string(pushResult), sendPbData, constant.PlatformIDToName(t))
-						}
-
+	log.InfoByKv("push_result", pushMsg.OperationID, "result", wsResult, "sendData", pushMsg.MsgData)
+	if isOfflinePush {
+		for _, v := range wsResult {
+			if v.ResultCode == 0 {
+				continue
+			}
+			//supported terminal
+			for _, t := range pushTerminal {
+				if v.RecvPlatFormID == t {
+					//Use offline push messaging
+					var UIDList []string
+					UIDList = append(UIDList, v.RecvID)
+					customContent := OpenIMContent{
+						SessionType: int(pushMsg.MsgData.SessionType),
+						From:        pushMsg.MsgData.SendID,
+						To:          pushMsg.MsgData.RecvID,
+						Seq:         pushMsg.MsgData.Seq,
 					}
+					bCustomContent, _ := json.Marshal(customContent)
+					jsonCustomContent := string(bCustomContent)
+					var content string
+					switch pushMsg.MsgData.ContentType {
+					case constant.Text:
+						content = constant.ContentType2PushContent[constant.Text]
+					case constant.Picture:
+						content = constant.ContentType2PushContent[constant.Picture]
+					case constant.Voice:
+						content = constant.ContentType2PushContent[constant.Voice]
+					case constant.Video:
+						content = constant.ContentType2PushContent[constant.Video]
+					case constant.File:
+						content = constant.ContentType2PushContent[constant.File]
+					case constant.AtText:
+						a := AtContent{}
+						_ = utils.JsonStringToStruct(string(pushMsg.MsgData.Content), &a)
+						if utils.IsContain(v.RecvID, a.AtUserList) {
+							content = constant.ContentType2PushContent[constant.AtText] + constant.ContentType2PushContent[constant.Common]
+						} else {
+							content = constant.ContentType2PushContent[constant.GroupMsg]
+						}
+					default:
+						content = constant.ContentType2PushContent[constant.Common]
+					}
+					pushResult, err := push.JGAccountListPush(UIDList, content, jsonCustomContent, constant.PlatformIDToName(t))
+					if err != nil {
+						log.NewError(pushMsg.OperationID, "offline push error", pushMsg.String(), err.Error(), constant.PlatformIDToName(t))
+					} else {
+						log.NewDebug(pushMsg.OperationID, "offline push return result is ", string(pushResult), pushMsg.MsgData, constant.PlatformIDToName(t))
+					}
+
 				}
 			}
-
 		}
-	}
-
-}
-
-func SendMsgByWS(m *pbChat.WSToMsgSvrChatMsg) {
-	m.MsgID = rpcChat.GetMsgID(m.SendID)
-	m.ClientMsgID = m.MsgID
-	switch m.SessionType {
-	case constant.SingleChatType:
-		sendMsgToKafka(m, m.SendID, "msgKey--sendID")
-		sendMsgToKafka(m, m.RecvID, "msgKey--recvID")
-	case constant.GroupChatType:
-		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:     m.RecvID,
-			Token:       config.Config.Secret,
-			OperationID: m.OperationID,
-		}
-		reply, err := client.GetGroupAllMember(context.Background(), req)
-		if err != nil {
-			log.Error(m.Token, m.OperationID, "rpc  getGroupInfo failed, err = %s", err.Error())
-			return
-		}
-		if reply.ErrorCode != 0 {
-			log.Error(m.Token, m.OperationID, "rpc  getGroupInfo failed, err = %s", reply.ErrorMsg)
-			return
-		}
-		groupID := m.RecvID
-		for i, v := range reply.MemberList {
-			m.RecvID = v.UserId + " " + groupID
-			sendMsgToKafka(m, utils.IntToString(i), "msgKey--recvID+\" \"+groupID")
-		}
-	default:
 
 	}
 }
 
-func sendMsgToKafka(m *pbChat.WSToMsgSvrChatMsg, key string, flag string) {
-	pid, offset, err := 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(), flag, key)
-	}
-
-}
+//func SendMsgByWS(m *pbChat.WSToMsgSvrChatMsg) {
+//	m.MsgID = rpcChat.GetMsgID(m.SendID)
+//	m.ClientMsgID = m.MsgID
+//	switch m.SessionType {
+//	case constant.SingleChatType:
+//		sendMsgToKafka(m, m.SendID, "msgKey--sendID")
+//		sendMsgToKafka(m, m.RecvID, "msgKey--recvID")
+//	case constant.GroupChatType:
+//		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:     m.RecvID,
+//			Token:       config.Config.Secret,
+//			OperationID: m.OperationID,
+//		}
+//		reply, err := client.GetGroupAllMember(context.Background(), req)
+//		if err != nil {
+//			log.Error(m.Token, m.OperationID, "rpc  getGroupInfo failed, err = %s", err.Error())
+//			return
+//		}
+//		if reply.ErrorCode != 0 {
+//			log.Error(m.Token, m.OperationID, "rpc  getGroupInfo failed, err = %s", reply.ErrorMsg)
+//			return
+//		}
+//		groupID := m.RecvID
+//		for i, v := range reply.MemberList {
+//			m.RecvID = v.UserId + " " + groupID
+//			sendMsgToKafka(m, utils.IntToString(i), "msgKey--recvID+\" \"+groupID")
+//		}
+//	default:
+//
+//	}
+//}
+//
+//func sendMsgToKafka(m *pbChat.WSToMsgSvrChatMsg, key string, flag string) {
+//	pid, offset, err := 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(), flag, key)
+//	}
+//
+//}