blackteay/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2025-04-06 04:15:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/tuoyun' into tuoyun

Browse Source
This commit is contained in:
wenxu12345 2021-12-24 15:02:58 +08:00
commit 6a88d64a90
8 changed files with 115 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
cmd/open_im_api/main.go
View File

@ -77,10 +77,10 @@ func main() {
//Message //Message
chatGroup := r.Group("/msg") chatGroup := r.Group("/msg")
{ {
chatGroup.POST("/newest_seq", apiChat.UserGetSeq) chatGroup.POST("/newest_seq", apiChat.GetSeq)
chatGroup.POST("/pull_msg", apiChat.UserPullMsg) chatGroup.POST("/pull_msg", apiChat.PullMsg)
chatGroup.POST("/send_msg", apiChat.UserSendMsg) chatGroup.POST("/send_msg", apiChat.SendMsg)
chatGroup.POST("/pull_msg_by_seq", apiChat.UserPullMsgBySeqList) chatGroup.POST("/pull_msg_by_seq", apiChat.PullMsgBySeqList)
} }
//Manager //Manager
managementGroup := r.Group("/manager") managementGroup := r.Group("/manager")

2
internal/api/chat/get_max_min_seq.go
View File

@ -19,7 +19,7 @@ type paramsUserNewestSeq struct {
MsgIncr int `json:"msgIncr" binding:"required"` MsgIncr int `json:"msgIncr" binding:"required"`
} }
func UserGetSeq(c *gin.Context) { func GetSeq(c *gin.Context) {
params := paramsUserNewestSeq{} params := paramsUserNewestSeq{}
if err := c.BindJSON(&params); err != nil { if err := c.BindJSON(&params); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})

17
internal/api/chat/pull_msg.go
View File

@ -6,6 +6,7 @@ import (
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3" "Open_IM/pkg/grpc-etcdv3/getcdv3"
"Open_IM/pkg/proto/chat" "Open_IM/pkg/proto/chat"
"Open_IM/pkg/proto/sdk_ws"
"context" "context"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"net/http" "net/http"
@ -22,7 +23,7 @@ type paramsUserPullMsg struct {
} }
} }
func UserPullMsg(c *gin.Context) { func PullMsg(c *gin.Context) {
params := paramsUserPullMsg{} params := paramsUserPullMsg{}
if err := c.BindJSON(&params); err != nil { if err := c.BindJSON(&params); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
@ -34,7 +35,7 @@ func UserPullMsg(c *gin.Context) {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()})
return return
} }
pbData := pbChat.PullMessageReq{} pbData := open_im_sdk.PullMessageReq{}
pbData.UserID = params.SendID pbData.UserID = params.SendID
pbData.OperationID = params.OperationID pbData.OperationID = params.OperationID
pbData.SeqBegin = *params.Data.SeqBegin pbData.SeqBegin = *params.Data.SeqBegin
@ -54,12 +55,12 @@ func UserPullMsg(c *gin.Context) {
if v := reply.GetSingleUserMsg(); v != nil { if v := reply.GetSingleUserMsg(); v != nil {
msg["single"] = v msg["single"] = v
} else { } else {
msg["single"] = []pbChat.GatherFormat{} msg["single"] = []open_im_sdk.GatherFormat{}
} }
if v := reply.GetGroupUserMsg(); v != nil { if v := reply.GetGroupUserMsg(); v != nil {
msg["group"] = v msg["group"] = v
} else { } else {
msg["group"] = []pbChat.GatherFormat{} msg["group"] = []open_im_sdk.GatherFormat{}
} }
msg["maxSeq"] = reply.GetMaxSeq() msg["maxSeq"] = reply.GetMaxSeq()
msg["minSeq"] = reply.GetMinSeq() msg["minSeq"] = reply.GetMinSeq()
@ -79,7 +80,7 @@ type paramsUserPullMsgBySeqList struct {
SeqList []int64 `json:"seqList"` SeqList []int64 `json:"seqList"`
} }
func UserPullMsgBySeqList(c *gin.Context) { func PullMsgBySeqList(c *gin.Context) {
params := paramsUserPullMsgBySeqList{} params := paramsUserPullMsgBySeqList{}
if err := c.BindJSON(&params); err != nil { if err := c.BindJSON(&params); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
@ -91,7 +92,7 @@ func UserPullMsgBySeqList(c *gin.Context) {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()})
return return
} }
pbData := pbChat.PullMessageBySeqListReq{} pbData := open_im_sdk.PullMessageBySeqListReq{}
pbData.UserID = params.SendID pbData.UserID = params.SendID
pbData.OperationID = params.OperationID pbData.OperationID = params.OperationID
pbData.SeqList = params.SeqList pbData.SeqList = params.SeqList
@ -110,12 +111,12 @@ func UserPullMsgBySeqList(c *gin.Context) {
if v := reply.GetSingleUserMsg(); v != nil { if v := reply.GetSingleUserMsg(); v != nil {
msg["single"] = v msg["single"] = v
} else { } else {
msg["single"] = []pbChat.GatherFormat{} msg["single"] = []open_im_sdk.GatherFormat{}
} }
if v := reply.GetGroupUserMsg(); v != nil { if v := reply.GetGroupUserMsg(); v != nil {
msg["group"] = v msg["group"] = v
} else { } else {
msg["group"] = []pbChat.GatherFormat{} msg["group"] = []open_im_sdk.GatherFormat{}
} }
msg["maxSeq"] = reply.GetMaxSeq() msg["maxSeq"] = reply.GetMaxSeq()
msg["minSeq"] = reply.GetMinSeq() msg["minSeq"] = reply.GetMinSeq()

78
internal/api/chat/send_msg.go
View File

@ -4,7 +4,7 @@ import (
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
pbChat "Open_IM/pkg/proto/chat" pbChat "Open_IM/pkg/proto/chat"
"Open_IM/pkg/utils" "Open_IM/pkg/proto/sdk_ws"
"context" "context"
"Open_IM/pkg/grpc-etcdv3/getcdv3" "Open_IM/pkg/grpc-etcdv3/getcdv3"
@ -14,50 +14,51 @@ import (
) )
type paramsUserSendMsg struct { type paramsUserSendMsg struct {
ReqIdentifier int32 `json:"reqIdentifier" binding:"required"` SenderPlatformID int32 `json:"senderPlatformID" binding:"required"`
PlatformID int32 `json:"platformID" binding:"required"` SendID string `json:"sendID" binding:"required"`
SendID string `json:"sendID" binding:"required"` SenderNickName string `json:"senderNickName"`
SenderNickName string `json:"senderNickName"` SenderFaceURL string `json:"senderFaceUrl"`
SenderFaceURL string `json:"senderFaceUrl"` OperationID string `json:"operationID" binding:"required"`
OperationID string `json:"operationID" binding:"required"` Data struct {
Data struct { SessionType int32 `json:"sessionType" binding:"required"`
SessionType int32 `json:"sessionType" binding:"required"` MsgFrom int32 `json:"msgFrom" binding:"required"`
MsgFrom int32 `json:"msgFrom" binding:"required"` ContentType int32 `json:"contentType" binding:"required"`
ContentType int32 `json:"contentType" binding:"required"` RecvID string `json:"recvID" `
RecvID string `json:"recvID" binding:"required"` GroupID string `json:"groupID" `
ForceList []string `json:"forceList"` ForceList []string `json:"forceList"`
Content string `json:"content" binding:"required"` Content []byte `json:"content" binding:"required"`
Options map[string]int32 `json:"options" ` Options map[string]bool `json:"options" `
ClientMsgID string `json:"clientMsgID" binding:"required"` ClientMsgID string `json:"clientMsgID" binding:"required"`
OffLineInfo map[string]interface{} `json:"offlineInfo" ` CreateTime int64 `json:"createTime" binding:"required"`
Ex map[string]interface{} `json:"ext"` OffLineInfo *open_im_sdk.OfflinePushInfo `json:"offlineInfo" `
} }
} }
func newUserSendMsgReq(token string, params *paramsUserSendMsg) *pbChat.SendMsgReq { func newUserSendMsgReq(token string, params *paramsUserSendMsg) *pbChat.SendMsgReq {
pbData := pbChat.SendMsgReq{ pbData := pbChat.SendMsgReq{
ReqIdentifier: params.ReqIdentifier, Token: token,
Token: token, OperationID: params.OperationID,
SendID: params.SendID, MsgData: &open_im_sdk.MsgData{
SenderNickName: params.SenderNickName, SendID: params.SendID,
SenderFaceURL: params.SenderFaceURL, RecvID: params.Data.RecvID,
OperationID: params.OperationID, GroupID: params.Data.GroupID,
PlatformID: params.PlatformID, ClientMsgID: params.Data.ClientMsgID,
SessionType: params.Data.SessionType, SenderPlatformID: params.SenderPlatformID,
MsgFrom: params.Data.MsgFrom, SenderNickName: params.SenderNickName,
ContentType: params.Data.ContentType, SenderFaceURL: params.SenderFaceURL,
RecvID: params.Data.RecvID, SessionType: params.Data.SessionType,
ForceList: params.Data.ForceList, MsgFrom: params.Data.MsgFrom,
Content: params.Data.Content, ContentType: params.Data.ContentType,
Options: utils.MapIntToJsonString(params.Data.Options), Content: params.Data.Content,
ClientMsgID: params.Data.ClientMsgID, CreateTime: params.Data.CreateTime,
OffLineInfo: utils.MapToJsonString(params.Data.OffLineInfo), Options: params.Data.Options,
Ex: utils.MapToJsonString(params.Data.Ex), OfflinePushInfo: params.Data.OffLineInfo,
},
} }
return &pbData return &pbData
} }
func UserSendMsg(c *gin.Context) { func SendMsg(c *gin.Context) {
params := paramsUserSendMsg{} params := paramsUserSendMsg{}
if err := c.BindJSON(&params); err != nil { if err := c.BindJSON(&params); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
@ -86,9 +87,8 @@ func UserSendMsg(c *gin.Context) {
log.Info("", "", "api SendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String()) log.Info("", "", "api SendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
c.JSON(http.StatusOK, gin.H{ c.JSON(http.StatusOK, gin.H{
"errCode": reply.ErrCode, "errCode": reply.ErrCode,
"errMsg": reply.ErrMsg, "errMsg": reply.ErrMsg,
"reqIdentifier": reply.ReqIdentifier,
"data": gin.H{ "data": gin.H{
"clientMsgID": reply.ClientMsgID, "clientMsgID": reply.ClientMsgID,
"serverMsgID": reply.ServerMsgID, "serverMsgID": reply.ServerMsgID,

83
internal/api/manage/management_chat.go
View File

@ -13,6 +13,7 @@ import (
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3" "Open_IM/pkg/grpc-etcdv3/getcdv3"
pbChat "Open_IM/pkg/proto/chat" pbChat "Open_IM/pkg/proto/chat"
"Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
@ -25,20 +26,22 @@ import (
var validate *validator.Validate var validate *validator.Validate
type paramsManagementSendMsg struct { type paramsManagementSendMsg struct {
OperationID string `json:"operationID" binding:"required"` OperationID string `json:"operationID" binding:"required"`
SendID string `json:"sendID" binding:"required"` SendID string `json:"sendID" binding:"required"`
RecvID string `json:"recvID" binding:"required"` RecvID string `json:"recvID" `
SenderNickName string `json:"senderNickName" ` GroupID string `json:"groupID" `
SenderFaceURL string `json:"senderFaceURL" ` SenderNickName string `json:"senderNickName" `
SenderPlatformID int32 `json:"senderPlatformID"` SenderFaceURL string `json:"senderFaceURL" `
ForceList []string `json:"forceList" ` SenderPlatformID int32 `json:"senderPlatformID"`
Content map[string]interface{} `json:"content" binding:"required"` ForceList []string `json:"forceList" `
ContentType int32 `json:"contentType" binding:"required"` Content map[string]interface{} `json:"content" binding:"required"`
SessionType int32 `json:"sessionType" binding:"required"` ContentType int32 `json:"contentType" binding:"required"`
IsOnlineOnly bool `json:"isOnlineOnly"` SessionType int32 `json:"sessionType" binding:"required"`
IsOnlineOnly bool `json:"isOnlineOnly"`
OfflinePushInfo *open_im_sdk.OfflinePushInfo `json:"offlinePushInfo"`
} }
func newUserSendMsgReq(params *paramsManagementSendMsg) *pbChat.UserSendMsgReq { func newUserSendMsgReq(params *paramsManagementSendMsg) *pbChat.SendMsgReq {
var newContent string var newContent string
switch params.ContentType { switch params.ContentType {
case constant.Text: case constant.Text:
@ -53,26 +56,31 @@ func newUserSendMsgReq(params *paramsManagementSendMsg) *pbChat.UserSendMsgReq {
newContent = utils.StructToJsonString(params.Content) newContent = utils.StructToJsonString(params.Content)
default: default:
} }
options := make(map[string]int32, 2) options := make(map[string]bool, 2)
if params.IsOnlineOnly { if params.IsOnlineOnly {
options["history"] = 0 utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false)
options["persistent"] = 0 utils.SetSwitchFromOptions(options, constant.IsHistory, false)
utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
} }
pbData := pbChat.UserSendMsgReq{ pbData := pbChat.SendMsgReq{
ReqIdentifier: constant.WSSendMsg, OperationID: params.OperationID,
SendID: params.SendID, MsgData: &open_im_sdk.MsgData{
SenderNickName: params.SenderNickName, SendID: params.SendID,
SenderFaceURL: params.SenderFaceURL, RecvID: params.RecvID,
OperationID: params.OperationID, GroupID: params.GroupID,
PlatformID: params.SenderPlatformID, ClientMsgID: utils.GetMsgID(params.SendID),
SessionType: params.SessionType, SenderPlatformID: params.SenderPlatformID,
MsgFrom: constant.UserMsgType, SenderNickName: params.SenderNickName,
ContentType: params.ContentType, SenderFaceURL: params.SenderFaceURL,
RecvID: params.RecvID, SessionType: params.SessionType,
ForceList: params.ForceList, MsgFrom: constant.SysMsgType,
Content: newContent, ContentType: params.ContentType,
ClientMsgID: utils.GetMsgID(params.SendID), Content: []byte(newContent),
Options: utils.MapIntToJsonString(options), ForceList: params.ForceList,
CreateTime: utils.GetCurrentTimestampByNano(),
Options: options,
OfflinePushInfo: params.OfflinePushInfo,
},
} }
return &pbData return &pbData
} }
@ -135,6 +143,19 @@ func ManagementSendMsg(c *gin.Context) {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "not authorized", "sendTime": 0, "MsgID": ""}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "not authorized", "sendTime": 0, "MsgID": ""})
return return
}
switch params.SessionType {
case constant.SingleChatType:
if len(params.RecvID) == 0 {
log.NewError(params.OperationID, "recvID is a null string")
c.JSON(http.StatusBadRequest, gin.H{"errCode": 405, "errMsg": "recvID is a null string", "sendTime": 0, "MsgID": ""})
}
case constant.GroupChatType:
if len(params.GroupID) == 0 {
log.NewError(params.OperationID, "groupID is a null string")
c.JSON(http.StatusBadRequest, gin.H{"errCode": 405, "errMsg": "groupID is a null string", "sendTime": 0, "MsgID": ""})
}
} }
log.InfoByKv("Ws call success to ManagementSendMsgReq", params.OperationID, "Parameters", params) log.InfoByKv("Ws call success to ManagementSendMsgReq", params.OperationID, "Parameters", params)
@ -146,7 +167,7 @@ func ManagementSendMsg(c *gin.Context) {
log.Info("", "", "api ManagementSendMsg call, api call rpc...") log.Info("", "", "api ManagementSendMsg call, api call rpc...")
reply, err := client.UserSendMsg(context.Background(), pbData) reply, err := client.SendMsg(context.Background(), pbData)
if err != nil { if err != nil {
log.NewError(params.OperationID, "call delete UserSendMsg rpc server failed", err.Error()) log.NewError(params.OperationID, "call delete UserSendMsg rpc server failed", err.Error())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call UserSendMsg rpc server failed"}) c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call UserSendMsg rpc server failed"})

4
internal/push/jpush/push.go
View File

@ -13,14 +13,14 @@ import (
type JPushResp struct { type JPushResp struct {
} }
func JGAccountListPush(accounts []string, content, detailContent, platform string) ([]byte, error) { func JGAccountListPush(accounts []string, alert, detailContent, platform string) ([]byte, error) {
var pf requestBody.Platform var pf requestBody.Platform
_ = pf.SetPlatform(platform) _ = pf.SetPlatform(platform)
var au requestBody.Audience var au requestBody.Audience
au.SetAlias(accounts) au.SetAlias(accounts)
var no requestBody.Notification var no requestBody.Notification
no.SetAlert(content, platform) no.SetAlert(alert, platform)
var me requestBody.Message var me requestBody.Message
me.SetMsgContent(detailContent) me.SetMsgContent(detailContent)
var o requestBody.Options var o requestBody.Options

4
internal/push/logic/push_to_client.go
View File

@ -93,6 +93,10 @@ func MsgToUser(pushMsg *pbPush.PushMsgReq) {
default: default:
content = constant.ContentType2PushContent[constant.Common] content = constant.ContentType2PushContent[constant.Common]
} }
if pushMsg.MsgData.OfflinePushInfo != nil {
content = pushMsg.MsgData.OfflinePushInfo.Title
}
pushResult, err := push.JGAccountListPush(UIDList, content, jsonCustomContent, constant.PlatformIDToName(t)) pushResult, err := push.JGAccountListPush(UIDList, content, jsonCustomContent, constant.PlatformIDToName(t))
if err != nil { if err != nil {
log.NewError(pushMsg.OperationID, "offline push error", pushMsg.String(), err.Error(), constant.PlatformIDToName(t)) log.NewError(pushMsg.OperationID, "offline push error", pushMsg.String(), err.Error(), constant.PlatformIDToName(t))

9
internal/rpc/msg/send_msg.go
View File

@ -156,7 +156,6 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
client := pbGroup.NewGroupClient(etcdConn) client := pbGroup.NewGroupClient(etcdConn)
req := &pbGroup.GetGroupAllMemberReq{ req := &pbGroup.GetGroupAllMemberReq{
GroupID: pb.MsgData.GroupID, GroupID: pb.MsgData.GroupID,
Token: pb.Token,
OperationID: pb.OperationID, OperationID: pb.OperationID,
} }
reply, err := client.GetGroupAllMember(context.Background(), req) reply, err := client.GetGroupAllMember(context.Background(), req)
@ -170,13 +169,13 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
} }
groupID := pb.MsgData.GroupID groupID := pb.MsgData.GroupID
for _, v := range reply.MemberList { for _, v := range reply.MemberList {
pb.MsgData.RecvID = v.UserId pb.MsgData.RecvID = v.UserID
isSend := modifyMessageByUserMessageReceiveOpt(v.UserId, groupID, constant.GroupChatType, pb) isSend := modifyMessageByUserMessageReceiveOpt(v.UserID, groupID, constant.GroupChatType, pb)
if isSend { if isSend {
msgToMQ.MsgData = pb.MsgData msgToMQ.MsgData = pb.MsgData
err := rpc.sendMsgToKafka(&msgToMQ, v.UserId) err := rpc.sendMsgToKafka(&msgToMQ, v.UserID)
if err != nil { if err != nil {
log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v.UserId, msgToMQ.String()) log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v.UserID, msgToMQ.String())
return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0) return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
} }
} }