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

tidy code

Browse Source
This commit is contained in:
wenxu12345 2021-12-28 15:33:47 +08:00
parent 38542f9888
commit b6944c4308
17 changed files with 732 additions and 717 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
cmd/open_im_api/main.go
View File

@ -26,12 +26,12 @@ func main() {
{ {
userRouterGroup.POST("/update_user_info", user.UpdateUserInfo) userRouterGroup.POST("/update_user_info", user.UpdateUserInfo)
userRouterGroup.POST("/get_user_info", user.GetUserInfo) userRouterGroup.POST("/get_user_info", user.GetUserInfo)
userRouterGroup.POST("/get_users_online_status", user.GetUsersOnlineStatus) //userRouterGroup.POST("/get_users_online_status", user.GetUsersOnlineStatus)
} }
//friend routing group //friend routing group
friendRouterGroup := r.Group("/friend") friendRouterGroup := r.Group("/friend")
{ {
friendRouterGroup.POST("/get_friends_info", friend.GetFriendsInfo) // friendRouterGroup.POST("/get_friends_info", friend.GetFriendsInfo)
friendRouterGroup.POST("/add_friend", friend.AddFriend) friendRouterGroup.POST("/add_friend", friend.AddFriend)
friendRouterGroup.POST("/get_friend_apply_list", friend.GetFriendApplyList) friendRouterGroup.POST("/get_friend_apply_list", friend.GetFriendApplyList)
friendRouterGroup.POST("/get_self_apply_list", friend.GetSelfApplyList) friendRouterGroup.POST("/get_self_apply_list", friend.GetSelfApplyList)
@ -87,15 +87,15 @@ func main() {
{ {
managementGroup.POST("/delete_user", manage.DeleteUser) managementGroup.POST("/delete_user", manage.DeleteUser)
managementGroup.POST("/send_msg", manage.ManagementSendMsg) managementGroup.POST("/send_msg", manage.ManagementSendMsg)
managementGroup.POST("/get_all_users_uid", manage.GetAllUsersUid) // managementGroup.POST("/get_all_users_uid", manage.GetAllUsersUid)
managementGroup.POST("/account_check", manage.AccountCheck) // managementGroup.POST("/account_check", manage.AccountCheck)
managementGroup.POST("/get_users_online_status", manage.GetUsersOnlineStatus) // managementGroup.POST("/get_users_online_status", manage.GetUsersOnlineStatus)
} }
//Conversation //Conversation
conversationGroup := r.Group("/conversation") conversationGroup := r.Group("/conversation")
{ {
conversationGroup.POST("/set_receive_message_opt", conversation.SetReceiveMessageOpt) conversationGroup.POST("/set_receive_message_opt", conversation.SetReceiveMessageOpt)
conversationGroup.POST("/get_receive_message_opt", conversation.GetReceiveMessageOpt) // conversationGroup.POST("/get_receive_message_opt", conversation.GetReceiveMessageOpt)
conversationGroup.POST("/get_all_conversation_message_opt", conversation.GetAllConversationMessageOpt) conversationGroup.POST("/get_all_conversation_message_opt", conversation.GetAllConversationMessageOpt)
} }

364
internal/api/conversation/conversation.go
View File

@ -1,194 +1,192 @@
package conversation package conversation
import ( import "github.com/gin-gonic/gin"
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
"Open_IM/pkg/proto/user"
"Open_IM/pkg/utils"
"context"
"github.com/gin-gonic/gin"
"net/http"
"strings"
)
type paramsSetReceiveMessageOpt struct { //
OperationID string `json:"operationID" binding:"required"` //type paramsSetReceiveMessageOpt struct {
Option *int32 `json:"option" binding:"required"` // OperationID string `json:"operationID" binding:"required"`
ConversationIdList []string `json:"conversationIdList" binding:"required"` // Option *int32 `json:"option" binding:"required"`
} // ConversationIdList []string `json:"conversationIdList" binding:"required"`
//}
type OptResult struct { //
ConversationId string `json:"conversationId" binding:"required"` //type OptResult struct {
Result int32 `json:"result" binding:"required"` // ConversationId string `json:"conversationId" binding:"required"`
} // Result int32 `json:"result" binding:"required"`
//}
type SetReceiveMessageOptResp struct { //
ErrCode int32 `json:"errCode"` //type SetReceiveMessageOptResp struct {
ErrMsg string `json:"errMsg"` // ErrCode int32 `json:"errCode"`
Data []OptResult `json:"data"` // ErrMsg string `json:"errMsg"`
} // Data []OptResult `json:"data"`
//}
type paramGetReceiveMessageOpt struct { //
ConversationIdList []string `json:"conversationIdList" binding:"required"` //type paramGetReceiveMessageOpt struct {
OperationID string `json:"operationID" binding:"required"` // ConversationIdList []string `json:"conversationIdList" binding:"required"`
} // OperationID string `json:"operationID" binding:"required"`
//}
type GetReceiveMessageOptResp struct { //
SetReceiveMessageOptResp //type GetReceiveMessageOptResp struct {
} // SetReceiveMessageOptResp
//}
type paramGetAllConversationMessageOpt struct { //
OperationID string `json:"operationID" binding:"required"` //type paramGetAllConversationMessageOpt struct {
} // OperationID string `json:"operationID" binding:"required"`
//}
type GetAllConversationMessageOptResp struct { //
SetReceiveMessageOptResp //type GetAllConversationMessageOptResp struct {
} // SetReceiveMessageOptResp
//}
//CopyStructFields //
////CopyStructFields
func GetAllConversationMessageOpt(c *gin.Context) { func GetAllConversationMessageOpt(c *gin.Context) {
params := paramGetAllConversationMessageOpt{}
if err := c.BindJSON(&params); err != nil {
log.NewError(params.OperationID, "bind json failed ", err.Error(), c)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
return
}
claims, err := token_verify.ParseToken(c.Request.Header.Get("token"))
if err != nil {
log.NewError(params.OperationID, "ParseToken failed, ", err.Error(), c.Request.Header.Get("token"))
c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "ParseToken failed, " + err.Error()})
return
}
req := &user.GetAllConversationMsgOptReq{
UId: claims.UID,
OperationID: params.OperationID,
}
log.NewInfo(req.OperationID, "GetAllConversationMsgOpt req: ", req)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
client := user.NewUserClient(etcdConn)
resp, err := client.GetAllConversationMsgOpt(context.Background(), req)
if err != nil {
log.NewError(params.OperationID, "GetAllConversationMsgOpt rpc failed, ", req, err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
return
}
var ginResp GetAllConversationMessageOptResp
ginResp.ErrCode = resp.ErrCode
ginResp.ErrMsg = resp.ErrMsg
for _, v := range resp.ConversationOptResult {
var opt OptResult
err := utils.CopyStructFields(&opt, *v, "ConversationId", "Result")
if err != nil {
log.NewError(req.OperationID, "CopyStructFields failed ", err.Error())
continue
}
ginResp.Data = append(ginResp.Data, opt)
}
log.NewInfo(req.OperationID, "GetAllConversationMsgOpt resp: ", ginResp, req)
c.JSON(http.StatusOK, ginResp)
}
func GetReceiveMessageOpt(c *gin.Context) {
params := paramGetReceiveMessageOpt{}
if err := c.BindJSON(&params); err != nil {
log.NewError(params.OperationID, "bind json failed ", err.Error(), c)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
return
}
claims, err := token_verify.ParseToken(c.Request.Header.Get("token"))
if err != nil {
log.NewError(params.OperationID, "ParseToken failed, ", err.Error(), c.Request.Header.Get("token"))
c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "ParseToken failed, " + err.Error()})
return
}
req := &user.GetReceiveMessageOptReq{
UId: claims.UID,
ConversationId: params.ConversationIdList,
OperationID: params.OperationID,
}
log.NewInfo(req.OperationID, "GetReceiveMessageOptReq req: ", req)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
client := user.NewUserClient(etcdConn)
resp, err := client.GetReceiveMessageOpt(context.Background(), req)
if err != nil {
log.NewError(params.OperationID, "GetReceiveMessageOpt rpc failed, ", req, err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "GetReceiveMessageOpt rpc failed, " + err.Error()})
return
}
log.NewInfo(req.OperationID, "GetReceiveMessageOptReq req: ", req, resp)
var ginResp GetReceiveMessageOptResp
ginResp.ErrCode = resp.ErrCode
ginResp.ErrMsg = resp.ErrMsg
for _, v := range resp.ConversationOptResult {
var opt OptResult
log.NewInfo("CopyStructFields begin ", v, req.OperationID)
err := utils.CopyStructFields(&opt, *v, "ConversationId", "Result")
log.NewInfo("CopyStructFields end ", v, req.OperationID)
if err != nil {
log.NewError(req.OperationID, "CopyStructFields failed ", err.Error())
continue
}
ginResp.Data = append(ginResp.Data, opt)
}
log.NewInfo(req.OperationID, "GetReceiveMessageOpt resp: ", ginResp)
c.JSON(http.StatusOK, ginResp)
} }
//func GetAllConversationMessageOpt(c *gin.Context) {
// params := paramGetAllConversationMessageOpt{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError(params.OperationID, "bind json failed ", err.Error(), c)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
// return
// }
//
// claims, err := token_verify.ParseToken(c.Request.Header.Get("token"))
// if err != nil {
// log.NewError(params.OperationID, "ParseToken failed, ", err.Error(), c.Request.Header.Get("token"))
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "ParseToken failed, " + err.Error()})
// return
// }
//
// req := &user.GetAllConversationMsgOptReq{
// UId: claims.UID,
// OperationID: params.OperationID,
// }
// log.NewInfo(req.OperationID, "GetAllConversationMsgOpt req: ", req)
// etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
// client := user.NewUserClient(etcdConn)
// resp, err := client.GetAllConversationMsgOpt(context.Background(), req)
// if err != nil {
// log.NewError(params.OperationID, "GetAllConversationMsgOpt rpc failed, ", req, err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
// return
// }
// var ginResp GetAllConversationMessageOptResp
// ginResp.ErrCode = resp.ErrCode
// ginResp.ErrMsg = resp.ErrMsg
// for _, v := range resp.ConversationOptResult {
// var opt OptResult
// err := utils.CopyStructFields(&opt, *v, "ConversationId", "Result")
// if err != nil {
// log.NewError(req.OperationID, "CopyStructFields failed ", err.Error())
// continue
// }
// ginResp.Data = append(ginResp.Data, opt)
// }
// log.NewInfo(req.OperationID, "GetAllConversationMsgOpt resp: ", ginResp, req)
// c.JSON(http.StatusOK, ginResp)
//}
//
//func GetReceiveMessageOpt(c *gin.Context) {
// params := paramGetReceiveMessageOpt{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError(params.OperationID, "bind json failed ", err.Error(), c)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
// return
// }
//
// claims, err := token_verify.ParseToken(c.Request.Header.Get("token"))
// if err != nil {
// log.NewError(params.OperationID, "ParseToken failed, ", err.Error(), c.Request.Header.Get("token"))
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "ParseToken failed, " + err.Error()})
// return
// }
//
// req := &user.GetReceiveMessageOptReq{
// UId: claims.UID,
// ConversationId: params.ConversationIdList,
// OperationID: params.OperationID,
// }
// log.NewInfo(req.OperationID, "GetReceiveMessageOptReq req: ", req)
// etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
// client := user.NewUserClient(etcdConn)
// resp, err := client.GetReceiveMessageOpt(context.Background(), req)
// if err != nil {
// log.NewError(params.OperationID, "GetReceiveMessageOpt rpc failed, ", req, err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "GetReceiveMessageOpt rpc failed, " + err.Error()})
// return
// }
// log.NewInfo(req.OperationID, "GetReceiveMessageOptReq req: ", req, resp)
// var ginResp GetReceiveMessageOptResp
// ginResp.ErrCode = resp.ErrCode
// ginResp.ErrMsg = resp.ErrMsg
//
// for _, v := range resp.ConversationOptResult {
// var opt OptResult
// log.NewInfo("CopyStructFields begin ", v, req.OperationID)
// err := utils.CopyStructFields(&opt, *v, "ConversationId", "Result")
// log.NewInfo("CopyStructFields end ", v, req.OperationID)
// if err != nil {
// log.NewError(req.OperationID, "CopyStructFields failed ", err.Error())
// continue
// }
// ginResp.Data = append(ginResp.Data, opt)
// }
// log.NewInfo(req.OperationID, "GetReceiveMessageOpt resp: ", ginResp)
// c.JSON(http.StatusOK, ginResp)
//}
//
func SetReceiveMessageOpt(c *gin.Context) { func SetReceiveMessageOpt(c *gin.Context) {
params := paramsSetReceiveMessageOpt{}
if err := c.BindJSON(&params); err != nil {
log.NewError(params.OperationID, "bind json failed ", err.Error(), c)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
return
}
claims, err := token_verify.ParseToken(c.Request.Header.Get("token"))
if err != nil {
log.NewError(params.OperationID, "ParseToken failed, ", err.Error(), c.Request.Header.Get("token"))
c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "ParseToken failed, " + err.Error()})
return
}
req := &user.SetReceiveMessageOptReq{
UId: claims.UID,
Opt: *params.Option,
ConversationId: params.ConversationIdList,
OperationID: params.OperationID,
}
log.NewInfo(req.OperationID, "SetReceiveMessageOpt req: ", req)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
client := user.NewUserClient(etcdConn)
resp, err := client.SetReceiveMessageOpt(context.Background(), req)
if err != nil {
log.NewError(params.OperationID, "SetReceiveMessageOpt rpc failed, ", req, err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "SetReceiveMessageOpt rpc failed, " + err.Error()})
return
}
log.NewInfo(req.OperationID, "SetReceiveMessageOpt req: ", req, resp)
ginResp := SetReceiveMessageOptResp{
ErrCode: resp.ErrCode,
ErrMsg: resp.ErrMsg,
}
for _, v := range resp.OptResult {
var opt OptResult
log.NewDebug("CopyStructFields begin ", v, req.OperationID)
err := utils.CopyStructFields(&opt, *v, "ConversationId", "Result")
log.NewDebug("CopyStructFields end ", v, req.OperationID)
if err != nil {
log.NewError(req.OperationID, "CopyStructFields failed ", err.Error())
continue
}
ginResp.Data = append(ginResp.Data, opt)
}
log.NewInfo(req.OperationID, "SetReceiveMessageOpt resp: ", ginResp)
c.JSON(http.StatusOK, ginResp)
} }
//func SetReceiveMessageOpt(c *gin.Context) {
// params := paramsSetReceiveMessageOpt{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError(params.OperationID, "bind json failed ", err.Error(), c)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
// return
// }
//
// claims, err := token_verify.ParseToken(c.Request.Header.Get("token"))
// if err != nil {
// log.NewError(params.OperationID, "ParseToken failed, ", err.Error(), c.Request.Header.Get("token"))
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "ParseToken failed, " + err.Error()})
// return
// }
//
// req := &user.SetReceiveMessageOptReq{
// UId: claims.UID,
// Opt: *params.Option,
// ConversationId: params.ConversationIdList,
// OperationID: params.OperationID,
// }
// log.NewInfo(req.OperationID, "SetReceiveMessageOpt req: ", req)
// etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
// client := user.NewUserClient(etcdConn)
// resp, err := client.SetReceiveMessageOpt(context.Background(), req)
// if err != nil {
// log.NewError(params.OperationID, "SetReceiveMessageOpt rpc failed, ", req, err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "SetReceiveMessageOpt rpc failed, " + err.Error()})
// return
// }
// log.NewInfo(req.OperationID, "SetReceiveMessageOpt req: ", req, resp)
// ginResp := SetReceiveMessageOptResp{
// ErrCode: resp.ErrCode,
// ErrMsg: resp.ErrMsg,
// }
//
// for _, v := range resp.OptResult {
// var opt OptResult
// log.NewDebug("CopyStructFields begin ", v, req.OperationID)
// err := utils.CopyStructFields(&opt, *v, "ConversationId", "Result")
// log.NewDebug("CopyStructFields end ", v, req.OperationID)
// if err != nil {
// log.NewError(req.OperationID, "CopyStructFields failed ", err.Error())
// continue
// }
// ginResp.Data = append(ginResp.Data, opt)
// }
// log.NewInfo(req.OperationID, "SetReceiveMessageOpt resp: ", ginResp)
// c.JSON(http.StatusOK, ginResp)
//}

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

@ -6,251 +6,164 @@
*/ */
package manage package manage
import ( import "github.com/gin-gonic/gin"
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbChat "Open_IM/pkg/proto/chat"
"Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"context"
"github.com/gin-gonic/gin"
"github.com/go-playground/validator/v10"
"github.com/mitchellh/mapstructure"
"net/http"
"strings"
)
var validate *validator.Validate //
//var validate *validator.Validate
type paramsManagementSendMsg struct { //
OperationID string `json:"operationID" binding:"required"` //
SendID string `json:"sendID" binding:"required"` //func newUserSendMsgReq(params *paramsManagementSendMsg) *pbChat.SendMsgReq {
RecvID string `json:"recvID" ` // var newContent string
GroupID string `json:"groupID" ` // switch params.ContentType {
SenderNickName string `json:"senderNickName" ` // case constant.Text:
SenderFaceURL string `json:"senderFaceURL" ` // newContent = params.Content["text"].(string)
SenderPlatformID int32 `json:"senderPlatformID"` // case constant.Picture:
ForceList []string `json:"forceList" ` // fallthrough
Content map[string]interface{} `json:"content" binding:"required"` // case constant.Custom:
ContentType int32 `json:"contentType" binding:"required"` // fallthrough
SessionType int32 `json:"sessionType" binding:"required"` // case constant.Voice:
IsOnlineOnly bool `json:"isOnlineOnly"` // fallthrough
OfflinePushInfo *open_im_sdk.OfflinePushInfo `json:"offlinePushInfo"` // case constant.File:
} // newContent = utils.StructToJsonString(params.Content)
// default:
func newUserSendMsgReq(params *paramsManagementSendMsg) *pbChat.SendMsgReq { // }
var newContent string // options := make(map[string]bool, 2)
switch params.ContentType { // if params.IsOnlineOnly {
case constant.Text: // utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false)
newContent = params.Content["text"].(string) // utils.SetSwitchFromOptions(options, constant.IsHistory, false)
case constant.Picture: // utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
fallthrough // }
case constant.Custom: // pbData := pbChat.SendMsgReq{
fallthrough // OperationID: params.OperationID,
case constant.Voice: // MsgData: &open_im_sdk.MsgData{
fallthrough // SendID: params.SendID,
case constant.File: // RecvID: params.RecvID,
newContent = utils.StructToJsonString(params.Content) // GroupID: params.GroupID,
default: // ClientMsgID: utils.GetMsgID(params.SendID),
} // SenderPlatformID: params.SenderPlatformID,
options := make(map[string]bool, 2) // SenderNickName: params.SenderNickName,
if params.IsOnlineOnly { // SenderFaceURL: params.SenderFaceURL,
utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false) // SessionType: params.SessionType,
utils.SetSwitchFromOptions(options, constant.IsHistory, false) // MsgFrom: constant.SysMsgType,
utils.SetSwitchFromOptions(options, constant.IsPersistent, false) // ContentType: params.ContentType,
} // Content: []byte(newContent),
pbData := pbChat.SendMsgReq{ // ForceList: params.ForceList,
OperationID: params.OperationID, // CreateTime: utils.GetCurrentTimestampByNano(),
MsgData: &open_im_sdk.MsgData{ // Options: options,
SendID: params.SendID, // OfflinePushInfo: params.OfflinePushInfo,
RecvID: params.RecvID, // },
GroupID: params.GroupID, // }
ClientMsgID: utils.GetMsgID(params.SendID), // return &pbData
SenderPlatformID: params.SenderPlatformID, //}
SenderNickName: params.SenderNickName, //func init() {
SenderFaceURL: params.SenderFaceURL, // validate = validator.New()
SessionType: params.SessionType, //}
MsgFrom: constant.SysMsgType,
ContentType: params.ContentType,
Content: []byte(newContent),
ForceList: params.ForceList,
CreateTime: utils.GetCurrentTimestampByNano(),
Options: options,
OfflinePushInfo: params.OfflinePushInfo,
},
}
return &pbData
}
func init() {
validate = validator.New()
}
func ManagementSendMsg(c *gin.Context) { func ManagementSendMsg(c *gin.Context) {
var data interface{}
params := paramsManagementSendMsg{}
if err := c.BindJSON(&params); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
log.ErrorByKv("json unmarshal err", c.PostForm("operationID"), "err", err.Error(), "content", c.PostForm("content"))
return
}
switch params.ContentType {
case constant.Text:
data = TextElem{}
case constant.Picture:
data = PictureElem{}
case constant.Voice:
data = SoundElem{}
case constant.Video:
data = VideoElem{}
case constant.File:
data = FileElem{}
//case constant.AtText:
// data = AtElem{}
//case constant.Merger:
// data =
//case constant.Card:
//case constant.Location:
case constant.Custom:
data = CustomElem{}
//case constant.Revoke:
//case constant.HasReadReceipt:
//case constant.Typing:
//case constant.Quote:
default:
c.JSON(http.StatusBadRequest, gin.H{"errCode": 404, "errMsg": "contentType err"})
log.ErrorByKv("contentType err", c.PostForm("operationID"), "content", c.PostForm("content"))
return
}
if err := mapstructure.WeakDecode(params.Content, &data); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": err.Error()})
log.ErrorByKv("content to Data struct err", "", "err", err.Error())
return
} else if err := validate.Struct(data); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 403, "errMsg": err.Error()})
log.ErrorByKv("data args validate err", "", "err", err.Error())
return
}
token := c.Request.Header.Get("token")
claims, err := token_verify.ParseToken(token)
if err != nil {
log.NewError(params.OperationID, "parse token failed", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "parse token failed", "sendTime": 0, "MsgID": ""})
}
if !utils.IsContain(claims.UID, config.Config.Manager.AppManagerUid) {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "not authorized", "sendTime": 0, "MsgID": ""})
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)
pbData := newUserSendMsgReq(&params)
log.Info("", "", "api ManagementSendMsg call start..., [data: %s]", pbData.String())
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
client := pbChat.NewChatClient(etcdConn)
log.Info("", "", "api ManagementSendMsg call, api call rpc...")
reply, err := client.SendMsg(context.Background(), pbData)
if err != nil {
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"})
return
}
log.Info("", "", "api ManagementSendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
c.JSON(http.StatusOK, gin.H{
"errCode": reply.ErrCode,
"errMsg": reply.ErrMsg,
"sendTime": reply.SendTime,
"msgID": reply.ClientMsgID,
})
} }
type PictureBaseInfo struct { //func ManagementSendMsg(c *gin.Context) {
UUID string `mapstructure:"uuid"` // var data interface{}
Type string `mapstructure:"type" validate:"required"` // params := paramsManagementSendMsg{}
Size int64 `mapstructure:"size" validate:"required"` // if err := c.BindJSON(&params); err != nil {
Width int32 `mapstructure:"width" validate:"required"` // c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
Height int32 `mapstructure:"height" validate:"required"` // log.ErrorByKv("json unmarshal err", c.PostForm("operationID"), "err", err.Error(), "content", c.PostForm("content"))
Url string `mapstructure:"url" validate:"required"` // return
} // }
// switch params.ContentType {
type PictureElem struct { // case constant.Text:
SourcePath string `mapstructure:"sourcePath"` // data = TextElem{}
SourcePicture PictureBaseInfo `mapstructure:"sourcePicture" validate:"required"` // case constant.Picture:
BigPicture PictureBaseInfo `mapstructure:"bigPicture" ` // data = PictureElem{}
SnapshotPicture PictureBaseInfo `mapstructure:"snapshotPicture"` // case constant.Voice:
} // data = SoundElem{}
type SoundElem struct { // case constant.Video:
UUID string `mapstructure:"uuid"` // data = VideoElem{}
SoundPath string `mapstructure:"soundPath"` // case constant.File:
SourceURL string `mapstructure:"sourceUrl"` // data = FileElem{}
DataSize int64 `mapstructure:"dataSize"` // //case constant.AtText:
Duration int64 `mapstructure:"duration"` // // data = AtElem{}
} // //case constant.Merger:
type VideoElem struct { // // data =
VideoPath string `mapstructure:"videoPath"` // //case constant.Card:
VideoUUID string `mapstructure:"videoUUID"` // //case constant.Location:
VideoURL string `mapstructure:"videoUrl"` // case constant.Custom:
VideoType string `mapstructure:"videoType"` // data = CustomElem{}
VideoSize int64 `mapstructure:"videoSize"` // //case constant.Revoke:
Duration int64 `mapstructure:"duration"` // //case constant.HasReadReceipt:
SnapshotPath string `mapstructure:"snapshotPath"` // //case constant.Typing:
SnapshotUUID string `mapstructure:"snapshotUUID"` // //case constant.Quote:
SnapshotSize int64 `mapstructure:"snapshotSize"` // default:
SnapshotURL string `mapstructure:"snapshotUrl"` // c.JSON(http.StatusBadRequest, gin.H{"errCode": 404, "errMsg": "contentType err"})
SnapshotWidth int32 `mapstructure:"snapshotWidth"` // log.ErrorByKv("contentType err", c.PostForm("operationID"), "content", c.PostForm("content"))
SnapshotHeight int32 `mapstructure:"snapshotHeight"` // return
} // }
type FileElem struct { // if err := mapstructure.WeakDecode(params.Content, &data); err != nil {
FilePath string `mapstructure:"filePath"` // c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": err.Error()})
UUID string `mapstructure:"uuid"` // log.ErrorByKv("content to Data struct err", "", "err", err.Error())
SourceURL string `mapstructure:"sourceUrl"` // return
FileName string `mapstructure:"fileName"` // } else if err := validate.Struct(data); err != nil {
FileSize int64 `mapstructure:"fileSize"` // c.JSON(http.StatusBadRequest, gin.H{"errCode": 403, "errMsg": err.Error()})
} // log.ErrorByKv("data args validate err", "", "err", err.Error())
// return
// }
//
// token := c.Request.Header.Get("token")
// claims, err := token_verify.ParseToken(token)
// if err != nil {
// log.NewError(params.OperationID, "parse token failed", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "parse token failed", "sendTime": 0, "MsgID": ""})
// }
// if !utils.IsContain(claims.UID, config.Config.Manager.AppManagerUid) {
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "not authorized", "sendTime": 0, "MsgID": ""})
// 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)
//
// pbData := newUserSendMsgReq(&params)
// log.Info("", "", "api ManagementSendMsg call start..., [data: %s]", pbData.String())
//
// etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
// client := pbChat.NewChatClient(etcdConn)
//
// log.Info("", "", "api ManagementSendMsg call, api call rpc...")
//
// reply, err := client.SendMsg(context.Background(), pbData)
// if err != nil {
// 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"})
// return
// }
// log.Info("", "", "api ManagementSendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
//
// c.JSON(http.StatusOK, gin.H{
// "errCode": reply.ErrCode,
// "errMsg": reply.ErrMsg,
// "sendTime": reply.SendTime,
// "msgID": reply.ClientMsgID,
// })
//
//}
//type MergeElem struct { //type MergeElem struct {
// Title string `json:"title"` // Title string `json:"title"`
// AbstractList []string `json:"abstractList"` // AbstractList []string `json:"abstractList"`
// MultiMessage []*MsgStruct `json:"multiMessage"` // MultiMessage []*MsgStruct `json:"multiMessage"`
//} //}
type AtElem struct {
Text string `mapstructure:"text"`
AtUserList []string `mapstructure:"atUserList"`
IsAtSelf bool `mapstructure:"isAtSelf"`
}
type LocationElem struct {
Description string `mapstructure:"description"`
Longitude float64 `mapstructure:"longitude"`
Latitude float64 `mapstructure:"latitude"`
}
type CustomElem struct {
Data string `mapstructure:"data" validate:"required"`
Description string `mapstructure:"description"`
Extension string `mapstructure:"extension"`
}
type TextElem struct {
Text string `mapstructure:"text" validate:"required"`
}
//type QuoteElem struct { //type QuoteElem struct {
// Text string `json:"text"` // Text string `json:"text"`

316
internal/api/manage/management_user.go
View File

@ -6,178 +6,154 @@
*/ */
package manage package manage
import ( import "github.com/gin-gonic/gin"
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbRelay "Open_IM/pkg/proto/relay"
pbUser "Open_IM/pkg/proto/user"
"Open_IM/pkg/utils"
"context"
"github.com/gin-gonic/gin"
"net/http"
"strings"
)
type paramsDeleteUsers struct {
OperationID string `json:"operationID" binding:"required"`
DeleteUidList []string `json:"deleteUidList" binding:"required"`
}
type paramsGetAllUsersUid struct {
OperationID string `json:"operationID" binding:"required"`
}
type paramsGetUsersOnlineStatus struct {
OperationID string `json:"operationID" binding:"required"`
UserIDList []string `json:"userIDList" binding:"required,lte=200"`
}
type paramsAccountCheck struct {
OperationID string `json:"operationID" binding:"required"`
UserIDList []string `json:"userIDList" binding:"required,lte=100"`
}
func DeleteUser(c *gin.Context) { func DeleteUser(c *gin.Context) {
params := paramsDeleteUsers{}
if err := c.BindJSON(&params); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
log.InfoByKv("DeleteUser req come here", params.OperationID, "DeleteUidList", params.DeleteUidList)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
client := pbUser.NewUserClient(etcdConn)
//defer etcdConn.Close()
req := &pbUser.DeleteUsersReq{
OperationID: params.OperationID,
DeleteUidList: params.DeleteUidList,
Token: c.Request.Header.Get("token"),
}
RpcResp, err := client.DeleteUsers(context.Background(), req)
if err != nil {
log.NewError(req.OperationID, "call delete users rpc server failed", err.Error())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call delete users rpc server failed"})
return
}
failedUidList := make([]string, 0)
for _, v := range RpcResp.FailedUidList {
failedUidList = append(failedUidList, v)
}
log.InfoByKv("call delete user rpc server is success", params.OperationID, "resp args", RpcResp.String())
resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "failedUidList": RpcResp.FailedUidList}
c.JSON(http.StatusOK, resp)
}
func GetAllUsersUid(c *gin.Context) {
params := paramsGetAllUsersUid{}
if err := c.BindJSON(&params); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
log.InfoByKv("GetAllUsersUid req come here", params.OperationID)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
client := pbUser.NewUserClient(etcdConn)
//defer etcdConn.Close()
req := &pbUser.GetAllUsersUidReq{
OperationID: params.OperationID,
Token: c.Request.Header.Get("token"),
}
RpcResp, err := client.GetAllUsersUid(context.Background(), req)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error(), "uidList": []string{}})
return
}
log.InfoByKv("call GetAllUsersUid rpc server is success", params.OperationID, "resp args", RpcResp.String())
resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "uidList": RpcResp.UidList}
c.JSON(http.StatusOK, resp)
} }
func AccountCheck(c *gin.Context) {
params := paramsAccountCheck{}
if err := c.BindJSON(&params); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
log.InfoByKv("AccountCheck req come here", params.OperationID, params.UserIDList)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
client := pbUser.NewUserClient(etcdConn)
//defer etcdConn.Close()
req := &pbUser.AccountCheckReq{ //
OperationID: params.OperationID, //func DeleteUser(c *gin.Context) {
Token: c.Request.Header.Get("token"), // params := paramsDeleteUsers{}
UidList: params.UserIDList, // if err := c.BindJSON(&params); err != nil {
} // c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
RpcResp, err := client.AccountCheck(context.Background(), req) // return
if err != nil { // }
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()}) // log.InfoByKv("DeleteUser req come here", params.OperationID, "DeleteUidList", params.DeleteUidList)
return // etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
} // client := pbUser.NewUserClient(etcdConn)
log.InfoByKv("call AccountCheck rpc server is success", params.OperationID, "resp args", RpcResp.String()) // //defer etcdConn.Close()
resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "result": RpcResp.Result} //
c.JSON(http.StatusOK, resp) // req := &pbUser.DeleteUsersReq{
// OperationID: params.OperationID,
} // DeleteUidList: params.DeleteUidList,
func GetUsersOnlineStatus(c *gin.Context) { // Token: c.Request.Header.Get("token"),
params := paramsGetUsersOnlineStatus{} // }
if err := c.BindJSON(&params); err != nil { // RpcResp, err := client.DeleteUsers(context.Background(), req)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) // if err != nil {
return // log.NewError(req.OperationID, "call delete users rpc server failed", err.Error())
} // c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call delete users rpc server failed"})
claims, err := token_verify.ParseToken(c.Request.Header.Get("token")) // return
if err != nil { // }
log.ErrorByKv("parse token failed", params.OperationID, "err", err.Error()) // failedUidList := make([]string, 0)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": err.Error()}) // for _, v := range RpcResp.FailedUidList {
return // failedUidList = append(failedUidList, v)
} // }
if !utils.IsContain(claims.UID, config.Config.Manager.AppManagerUid) { // log.InfoByKv("call delete user rpc server is success", params.OperationID, "resp args", RpcResp.String())
log.ErrorByKv(" Authentication failed", params.OperationID, "args", c) // resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "failedUidList": RpcResp.FailedUidList}
c.JSON(http.StatusBadRequest, gin.H{"errCode": 402, "errMsg": "not authorized"}) // c.JSON(http.StatusOK, resp)
return //}
} //func GetAllUsersUid(c *gin.Context) {
req := &pbRelay.GetUsersOnlineStatusReq{ // params := paramsGetAllUsersUid{}
OperationID: params.OperationID, // if err := c.BindJSON(&params); err != nil {
UserIDList: params.UserIDList, // c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
} // return
var wsResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult // }
var respResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult // log.InfoByKv("GetAllUsersUid req come here", params.OperationID)
flag := false // etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
log.NewDebug(params.OperationID, "GetUsersOnlineStatus req come here", params.UserIDList) // client := pbUser.NewUserClient(etcdConn)
grpcCons := getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName) // //defer etcdConn.Close()
for _, v := range grpcCons { //
client := pbRelay.NewOnlineMessageRelayServiceClient(v) // req := &pbUser.GetAllUsersUidReq{
reply, err := client.GetUsersOnlineStatus(context.Background(), req) // OperationID: params.OperationID,
if err != nil { // Token: c.Request.Header.Get("token"),
log.NewError(params.OperationID, "GetUsersOnlineStatus rpc err", req.String(), err.Error()) // }
continue // RpcResp, err := client.GetAllUsersUid(context.Background(), req)
} else { // if err != nil {
if reply.ErrCode == 0 { // c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error(), "uidList": []string{}})
wsResult = append(wsResult, reply.SuccessResult...) // return
} // }
} // log.InfoByKv("call GetAllUsersUid rpc server is success", params.OperationID, "resp args", RpcResp.String())
} // resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "uidList": RpcResp.UidList}
log.NewDebug(params.OperationID, "call GetUsersOnlineStatus rpc server is success", wsResult) // c.JSON(http.StatusOK, resp)
//Online data merge of each node //
for _, v1 := range params.UserIDList { //}
flag = false //func AccountCheck(c *gin.Context) {
temp := new(pbRelay.GetUsersOnlineStatusResp_SuccessResult) // params := paramsAccountCheck{}
for _, v2 := range wsResult { // if err := c.BindJSON(&params); err != nil {
if v2.UserID == v1 { // c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
flag = true // return
temp.UserID = v1 // }
temp.Status = constant.OnlineStatus // log.InfoByKv("AccountCheck req come here", params.OperationID, params.UserIDList)
temp.DetailPlatformStatus = append(temp.DetailPlatformStatus, v2.DetailPlatformStatus...) // etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
} // client := pbUser.NewUserClient(etcdConn)
// //defer etcdConn.Close()
} //
if !flag { // req := &pbUser.AccountCheckReq{
temp.UserID = v1 // OperationID: params.OperationID,
temp.Status = constant.OfflineStatus // Token: c.Request.Header.Get("token"),
} // UidList: params.UserIDList,
respResult = append(respResult, temp) // }
} // RpcResp, err := client.AccountCheck(context.Background(), req)
log.NewDebug(params.OperationID, "Finished merged data", respResult) // if err != nil {
resp := gin.H{"errCode": 0, "errMsg": "", "successResult": respResult} // c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
c.JSON(http.StatusOK, resp) // return
// }
} // log.InfoByKv("call AccountCheck rpc server is success", params.OperationID, "resp args", RpcResp.String())
// resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "result": RpcResp.Result}
// c.JSON(http.StatusOK, resp)
//
//}
//func GetUsersOnlineStatus(c *gin.Context) {
// params := paramsGetUsersOnlineStatus{}
// if err := c.BindJSON(&params); err != nil {
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// claims, err := token_verify.ParseToken(c.Request.Header.Get("token"))
// if err != nil {
// log.ErrorByKv("parse token failed", params.OperationID, "err", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": err.Error()})
// return
// }
// if !utils.IsContain(claims.UID, config.Config.Manager.AppManagerUid) {
// log.ErrorByKv(" Authentication failed", params.OperationID, "args", c)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 402, "errMsg": "not authorized"})
// return
// }
// req := &pbRelay.GetUsersOnlineStatusReq{
// OperationID: params.OperationID,
// UserIDList: params.UserIDList,
// }
// var wsResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
// var respResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
// flag := false
// log.NewDebug(params.OperationID, "GetUsersOnlineStatus req come here", params.UserIDList)
// grpcCons := getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName)
// for _, v := range grpcCons {
// client := pbRelay.NewOnlineMessageRelayServiceClient(v)
// reply, err := client.GetUsersOnlineStatus(context.Background(), req)
// if err != nil {
// log.NewError(params.OperationID, "GetUsersOnlineStatus rpc err", req.String(), err.Error())
// continue
// } else {
// if reply.ErrCode == 0 {
// wsResult = append(wsResult, reply.SuccessResult...)
// }
// }
// }
// log.NewDebug(params.OperationID, "call GetUsersOnlineStatus rpc server is success", wsResult)
// //Online data merge of each node
// for _, v1 := range params.UserIDList {
// flag = false
// temp := new(pbRelay.GetUsersOnlineStatusResp_SuccessResult)
// for _, v2 := range wsResult {
// if v2.UserID == v1 {
// flag = true
// temp.UserID = v1
// temp.Status = constant.OnlineStatus
// temp.DetailPlatformStatus = append(temp.DetailPlatformStatus, v2.DetailPlatformStatus...)
// }
//
// }
// if !flag {
// temp.UserID = v1
// temp.Status = constant.OfflineStatus
// }
// respResult = append(respResult, temp)
// }
// log.NewDebug(params.OperationID, "Finished merged data", respResult)
// resp := gin.H{"errCode": 0, "errMsg": "", "successResult": respResult}
// c.JSON(http.StatusOK, resp)
//
//}

5
internal/rpc/friend/firend.go
View File

@ -7,6 +7,7 @@ import (
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model" imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
cp "Open_IM/pkg/common/utils"
"Open_IM/pkg/grpc-etcdv3/getcdv3" "Open_IM/pkg/grpc-etcdv3/getcdv3"
pbFriend "Open_IM/pkg/proto/friend" pbFriend "Open_IM/pkg/proto/friend"
sdkws "Open_IM/pkg/proto/sdk_ws" sdkws "Open_IM/pkg/proto/sdk_ws"
@ -16,6 +17,7 @@ import (
"net" "net"
"strconv" "strconv"
"strings" "strings"
"time"
) )
type friendServer struct { type friendServer struct {
@ -226,6 +228,7 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
} }
friendRequest.HandleResult = req.Flag friendRequest.HandleResult = req.Flag
friendRequest.HandleTime = time.Now() friendRequest.HandleTime = time.Now()
//friendRequest.HandleTime.Unix()
friendRequest.HandleMsg = req.HandleMsg friendRequest.HandleMsg = req.HandleMsg
friendRequest.HandlerUserID = req.CommID.OpUserID friendRequest.HandlerUserID = req.CommID.OpUserID
err = imdb.UpdateFriendApplication(friendRequest) err = imdb.UpdateFriendApplication(friendRequest)
@ -454,7 +457,7 @@ func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetSe
var selfApplyOtherUserList []*sdkws.FriendRequest var selfApplyOtherUserList []*sdkws.FriendRequest
for _, selfApplyOtherUserInfo := range usersInfo { for _, selfApplyOtherUserInfo := range usersInfo {
var userInfo sdkws.FriendRequest // pbFriend.ApplyUserInfo var userInfo sdkws.FriendRequest // pbFriend.ApplyUserInfo
utils.FriendRequestDBCopyOpenIM(&userInfo, selfApplyOtherUserInfo) cp.FriendRequestDBCopyOpenIM(&userInfo, selfApplyOtherUserInfo)
selfApplyOtherUserList = append(selfApplyOtherUserList, &userInfo) selfApplyOtherUserList = append(selfApplyOtherUserList, &userInfo)
} }
log.NewInfo(req.CommID.OperationID, "rpc GetSelfApplyList ok", pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList}) log.NewInfo(req.CommID.OperationID, "rpc GetSelfApplyList ok", pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList})

9
internal/rpc/group/group.go
View File

@ -171,7 +171,7 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
group, err := imdb.GetGroupInfoByGroupID(v) group, err := imdb.GetGroupInfoByGroupID(v)
if num > 0 && owner != nil && err2 == nil && group != nil && err == nil { if num > 0 && owner != nil && err2 == nil && group != nil && err == nil {
utils.CopyStructFields(&groupNode, group) utils.CopyStructFields(&groupNode, group)
groupNode.CreateTime = group.CreateTime groupNode.CreateTime = group.CreateTime.Unix()
groupNode.MemberCount = uint32(num) groupNode.MemberCount = uint32(num)
groupNode.OwnerUserID = owner.UserID groupNode.OwnerUserID = owner.UserID
resp.GroupList = append(resp.GroupList, &groupNode) resp.GroupList = append(resp.GroupList, &groupNode)
@ -379,7 +379,7 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
continue continue
} else { } else {
utils.CopyStructFields(&memberNode, memberInfo) utils.CopyStructFields(&memberNode, memberInfo)
memberNode.JoinTime = memberInfo.JoinTime memberNode.JoinTime = memberInfo.JoinTime.Unix()
resp.MemberList = append(resp.MemberList, &memberNode) resp.MemberList = append(resp.MemberList, &memberNode)
} }
} }
@ -416,7 +416,7 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
} }
var groupInfo open_im_sdk.GroupInfo var groupInfo open_im_sdk.GroupInfo
utils.CopyStructFields(&groupInfo, groupInfoFromMysql) utils.CopyStructFields(&groupInfo, groupInfoFromMysql)
groupInfo.CreateTime = groupInfoFromMysql.CreateTime groupInfo.CreateTime = groupInfoFromMysql.CreateTime.Unix()
groupsInfoList = append(groupsInfoList, &groupInfo) groupsInfoList = append(groupsInfoList, &groupInfo)
} }
@ -451,7 +451,7 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) { func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) {
log.NewInfo(req.OperationID, "JoinGroup args ", req.String()) log.NewInfo(req.OperationID, "JoinGroup args ", req.String())
applicationUserInfo, err := imdb.GetUserByUserID(req.OpUserID) _, err := imdb.GetUserByUserID(req.OpUserID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.OpUserID) log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.OpUserID)
return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
@ -516,6 +516,7 @@ func hasAccess(req *pbGroup.SetGroupInfoReq) bool {
if groupUserInfo.RoleLevel == constant.OrdinaryMember { if groupUserInfo.RoleLevel == constant.OrdinaryMember {
return true return true
} }
return false
} }
func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInfoReq) (*pbGroup.SetGroupInfoResp, error) { func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInfoReq) (*pbGroup.SetGroupInfoResp, error) {

21
internal/rpc/msg/notification.go
View File

@ -1,6 +1,7 @@
package msg package msg
import ( import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model" imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
@ -20,6 +21,7 @@ import (
//} creator->group //} creator->group
func setOpUserInfo(operationID, opUserID, groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) { func setOpUserInfo(operationID, opUserID, groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) {
return
if token_verify.IsMangerUserID(opUserID) { if token_verify.IsMangerUserID(opUserID) {
u, err := imdb.GetUserByUserID(opUserID) u, err := imdb.GetUserByUserID(opUserID)
if err != nil { if err != nil {
@ -39,6 +41,7 @@ func setOpUserInfo(operationID, opUserID, groupID string, groupMemberInfo *open_
} }
func setGroupInfo(operationID, groupID string, groupInfo *open_im_sdk.GroupInfo, ownerUserID string) { func setGroupInfo(operationID, groupID string, groupInfo *open_im_sdk.GroupInfo, ownerUserID string) {
return
group, err := imdb.GetGroupInfoByGroupID(groupID) group, err := imdb.GetGroupInfoByGroupID(groupID)
if err != nil { if err != nil {
log.NewError(operationID, "FindGroupInfoByGroupId failed ", err.Error(), groupID) log.NewError(operationID, "FindGroupInfoByGroupId failed ", err.Error(), groupID)
@ -53,6 +56,7 @@ func setGroupInfo(operationID, groupID string, groupInfo *open_im_sdk.GroupInfo,
} }
func setGroupMemberInfo(operationID, groupID, userID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) { func setGroupMemberInfo(operationID, groupID, userID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) {
return
group, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID) group, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
if err != nil { if err != nil {
log.NewError(operationID, "FindGroupMemberInfoByGroupIdAndUserId failed ", err.Error(), groupID, userID) log.NewError(operationID, "FindGroupMemberInfoByGroupIdAndUserId failed ", err.Error(), groupID, userID)
@ -72,6 +76,7 @@ func setGroupMemberInfo(operationID, groupID, userID string, groupMemberInfo *op
//创建群后调用 //创建群后调用
func GroupCreatedNotification(operationID, opUserID, OwnerUserID, groupID string, initMemberList []string) { func GroupCreatedNotification(operationID, opUserID, OwnerUserID, groupID string, initMemberList []string) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = opUserID n.SendID = opUserID
n.RecvID = groupID n.RecvID = groupID
@ -109,6 +114,7 @@ func GroupCreatedNotification(operationID, opUserID, OwnerUserID, groupID string
// OperationID string `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"` // OperationID string `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"`
//申请进群后调用 //申请进群后调用
func JoinApplicationNotification(req *pbGroup.JoinGroupReq) { func JoinApplicationNotification(req *pbGroup.JoinGroupReq) {
return
managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID) managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID) log.NewError(req.OperationID, "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID)
@ -151,6 +157,7 @@ func JoinApplicationNotification(req *pbGroup.JoinGroupReq) {
//} //}
//处理进群请求后调用 //处理进群请求后调用
func ApplicationProcessedNotification(req *pbGroup.GroupApplicationResponseReq) { func ApplicationProcessedNotification(req *pbGroup.GroupApplicationResponseReq) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = req.OpUserID n.SendID = req.OpUserID
n.ContentType = constant.ApplicationProcessedNotification n.ContentType = constant.ApplicationProcessedNotification
@ -181,6 +188,7 @@ func ApplicationProcessedNotification(req *pbGroup.GroupApplicationResponseReq)
//} //}
//被邀请进群后调用 //被邀请进群后调用
func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) { func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = opUserID n.SendID = opUserID
n.ContentType = constant.MemberInvitedNotification n.ContentType = constant.MemberInvitedNotification
@ -212,6 +220,7 @@ func MemberInvitedNotification(operationID, groupID, opUserID, reason string, in
//} //}
//被踢后调用 //被踢后调用
func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) { func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = req.OpUserID n.SendID = req.OpUserID
n.ContentType = constant.MemberKickedNotification n.ContentType = constant.MemberKickedNotification
@ -249,6 +258,7 @@ func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList
//群信息改变后掉用 //群信息改变后掉用
func GroupInfoChangedNotification(operationID, opUserID, groupID string, changedType int32) { func GroupInfoChangedNotification(operationID, opUserID, groupID string, changedType int32) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = opUserID n.SendID = opUserID
n.ContentType = constant.GroupInfoChangedNotification n.ContentType = constant.GroupInfoChangedNotification
@ -301,6 +311,7 @@ func GroupInfoChangedNotification(operationID string, changedType int32, group *
//群成员退群后调用 //群成员退群后调用
func MemberLeaveNotification(req *pbGroup.QuitGroupReq) { func MemberLeaveNotification(req *pbGroup.QuitGroupReq) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = req.OpUserID n.SendID = req.OpUserID
n.ContentType = constant.MemberLeaveNotification n.ContentType = constant.MemberLeaveNotification
@ -331,6 +342,7 @@ func MemberLeaveNotification(req *pbGroup.QuitGroupReq) {
//} //}
//群成员主动申请进群，管理员同意后调用， //群成员主动申请进群，管理员同意后调用，
func MemberEnterNotification(req *pbGroup.GroupApplicationResponseReq) { func MemberEnterNotification(req *pbGroup.GroupApplicationResponseReq) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = req.OpUserID n.SendID = req.OpUserID
n.ContentType = constant.MemberEnterNotification n.ContentType = constant.MemberEnterNotification
@ -369,6 +381,7 @@ func MemberEnterNotification(req *pbGroup.GroupApplicationResponseReq) {
//} //}
func getFromToUserNickname(operationID, fromUserID, toUserID string) (string, string) { func getFromToUserNickname(operationID, fromUserID, toUserID string) (string, string) {
return
from, err1 := imdb.GetUserByUserID(fromUserID) from, err1 := imdb.GetUserByUserID(fromUserID)
to, err2 := imdb.GetUserByUserID(toUserID) to, err2 := imdb.GetUserByUserID(toUserID)
if err1 != nil || err2 != nil { if err1 != nil || err2 != nil {
@ -385,6 +398,7 @@ func getFromToUserNickname(operationID, fromUserID, toUserID string) (string, st
} }
func FriendApplicationAddedNotification(req *pbFriend.AddFriendReq) { func FriendApplicationAddedNotification(req *pbFriend.AddFriendReq) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = req.CommID.FromUserID n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID n.RecvID = req.CommID.ToUserID
@ -405,6 +419,7 @@ func FriendApplicationAddedNotification(req *pbFriend.AddFriendReq) {
} }
func FriendApplicationProcessedNotification(req *pbFriend.AddFriendResponseReq) { func FriendApplicationProcessedNotification(req *pbFriend.AddFriendResponseReq) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = req.CommID.FromUserID n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID n.RecvID = req.CommID.ToUserID
@ -425,6 +440,7 @@ func FriendApplicationProcessedNotification(req *pbFriend.AddFriendResponseReq)
} }
func FriendAddedNotification(operationID, opUserID, fromUserID, toUserID string) { func FriendAddedNotification(operationID, opUserID, fromUserID, toUserID string) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = fromUserID n.SendID = fromUserID
n.RecvID = toUserID n.RecvID = toUserID
@ -478,6 +494,7 @@ func FriendAddedNotification(operationID, opUserID, fromUserID, toUserID string)
// FriendInfo Friend = 1; // FriendInfo Friend = 1;
//} //}
func FriendDeletedNotification(req *pbFriend.DeleteFriendReq) { func FriendDeletedNotification(req *pbFriend.DeleteFriendReq) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = req.CommID.FromUserID n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID n.RecvID = req.CommID.ToUserID
@ -503,6 +520,7 @@ func FriendDeletedNotification(req *pbFriend.DeleteFriendReq) {
// uint64 OperationTime = 3; // uint64 OperationTime = 3;
//} //}
func FriendInfoChangedNotification(operationID, opUserID, fromUserID, toUserID string) { func FriendInfoChangedNotification(operationID, opUserID, fromUserID, toUserID string) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = fromUserID n.SendID = fromUserID
n.RecvID = toUserID n.RecvID = toUserID
@ -523,6 +541,7 @@ func FriendInfoChangedNotification(operationID, opUserID, fromUserID, toUserID s
} }
func BlackAddedNotification(req *pbFriend.AddBlacklistReq) { func BlackAddedNotification(req *pbFriend.AddBlacklistReq) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = req.CommID.FromUserID n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID n.RecvID = req.CommID.ToUserID
@ -546,6 +565,7 @@ func BlackAddedNotification(req *pbFriend.AddBlacklistReq) {
// BlackInfo Black = 1; // BlackInfo Black = 1;
//} //}
func BlackDeletedNotification(req *pbFriend.RemoveBlacklistReq) { func BlackDeletedNotification(req *pbFriend.RemoveBlacklistReq) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = req.CommID.FromUserID n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID n.RecvID = req.CommID.ToUserID
@ -571,6 +591,7 @@ func BlackDeletedNotification(req *pbFriend.RemoveBlacklistReq) {
// uint64 OperationTime = 3; // uint64 OperationTime = 3;
//} //}
func SelfInfoUpdatedNotification(operationID, userID string) { func SelfInfoUpdatedNotification(operationID, userID string) {
return
var n NotificationMsg var n NotificationMsg
n.SendID = userID n.SendID = userID
n.RecvID = userID n.RecvID = userID

48
internal/rpc/user/user.go
View File

@ -10,6 +10,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"
pbFriend "Open_IM/pkg/proto/friend" pbFriend "Open_IM/pkg/proto/friend"
sdkws "Open_IM/pkg/proto/sdk_ws"
pbUser "Open_IM/pkg/proto/user" pbUser "Open_IM/pkg/proto/user"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
@ -17,7 +18,6 @@ import (
"net" "net"
"strconv" "strconv"
"strings" "strings"
sdkws "Open_IM/pkg/proto/sdk_ws"
) )
type userServer struct { type userServer struct {
@ -27,6 +27,16 @@ type userServer struct {
etcdAddr []string etcdAddr []string
} }
func NewUserServer(port int) *userServer {
log.NewPrivateLog("user")
return &userServer{
rpcPort: port,
rpcRegisterName: config.Config.RpcRegisterName.OpenImUserName,
etcdSchema: config.Config.Etcd.EtcdSchema,
etcdAddr: config.Config.Etcd.EtcdAddr,
}
}
func (s *userServer) Run() { func (s *userServer) Run() {
log.NewInfo("0", "", "rpc user start...") log.NewInfo("0", "", "rpc user start...")
@ -38,7 +48,7 @@ func (s *userServer) Run() {
log.NewError("0", "listen network failed ", err.Error(), registerAddress) log.NewError("0", "listen network failed ", err.Error(), registerAddress)
return return
} }
log.NewInfo("0", "listen network success, address ", registerAddress, listener) log.NewInfo("0", "listen network success, address ", registerAddress, listener)
defer listener.Close() defer listener.Close()
//grpc server //grpc server
srv := grpc.NewServer() srv := grpc.NewServer()
@ -55,7 +65,7 @@ func (s *userServer) Run() {
log.NewError("0", "Serve failed ", err.Error()) log.NewError("0", "Serve failed ", err.Error())
return return
} }
log.NewInfo("0", "rpc user success") log.NewInfo("0", "rpc user success")
} }
func (s *userServer) GetUserInfo(ctx context.Context, req *pbUser.GetUserInfoReq) (*pbUser.GetUserInfoResp, error) { func (s *userServer) GetUserInfo(ctx context.Context, req *pbUser.GetUserInfoReq) (*pbUser.GetUserInfoResp, error) {
@ -76,12 +86,10 @@ func (s *userServer) GetUserInfo(ctx context.Context, req *pbUser.GetUserInfoReq
return &pbUser.GetUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}}, nil return &pbUser.GetUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}}, nil
} }
log.NewInfo(req.OperationID, "GetUserInfo rpc return ", pbUser.GetUserInfoResp{CommonResp: &pbUser.CommonResp{}, UserInfoList:userInfoList}) log.NewInfo(req.OperationID, "GetUserInfo rpc return ", pbUser.GetUserInfoResp{CommonResp: &pbUser.CommonResp{}, UserInfoList: userInfoList})
return &pbUser.GetUserInfoResp{CommonResp: &pbUser.CommonResp{}, UserInfoList:userInfoList}, nil return &pbUser.GetUserInfoResp{CommonResp: &pbUser.CommonResp{}, UserInfoList: userInfoList}, nil
} }
func (s *userServer) SetReceiveMessageOpt(ctx context.Context, req *pbUser.SetReceiveMessageOptReq) (*pbUser.SetReceiveMessageOptResp, error) { func (s *userServer) SetReceiveMessageOpt(ctx context.Context, req *pbUser.SetReceiveMessageOptReq) (*pbUser.SetReceiveMessageOptResp, error) {
log.NewInfo(req.OperationID, "SetReceiveMessageOpt args ", req.String()) log.NewInfo(req.OperationID, "SetReceiveMessageOpt args ", req.String())
m := make(map[string]int, len(req.ConversationIDList)) m := make(map[string]int, len(req.ConversationIDList))
@ -132,10 +140,9 @@ func (s *userServer) GetAllConversationMsgOpt(ctx context.Context, req *pbUser.G
return &resp, nil return &resp, nil
} }
func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq) (*pbUser.DeleteUsersResp, error) { func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq) (*pbUser.DeleteUsersResp, error) {
log.NewInfo(req.OperationID, "DeleteUsers args ", req.String()) log.NewInfo(req.OperationID, "DeleteUsers args ", req.String())
if token_verify.IsMangerUserID(req.OpUserID){ if token_verify.IsMangerUserID(req.OpUserID) {
log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID) log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
return &pbUser.DeleteUsersResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, FailedUserIDList: req.DeleteUserIDList}, nil return &pbUser.DeleteUsersResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, FailedUserIDList: req.DeleteUserIDList}, nil
} }
@ -154,8 +161,8 @@ func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq)
} }
func (s *userServer) GetAllUserID(_ context.Context, req *pbUser.GetAllUserIDReq) (*pbUser.GetAllUserIDResp, error) { func (s *userServer) GetAllUserID(_ context.Context, req *pbUser.GetAllUserIDReq) (*pbUser.GetAllUserIDResp, error) {
log.NewInfo(req.OperationID,"GetAllUserID args ", req.String()) log.NewInfo(req.OperationID, "GetAllUserID args ", req.String())
if token_verify.IsMangerUserID(req.OpUserID){ if token_verify.IsMangerUserID(req.OpUserID) {
log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID) log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
} }
@ -169,10 +176,9 @@ func (s *userServer) GetAllUserID(_ context.Context, req *pbUser.GetAllUserIDReq
} }
} }
func (s *userServer) AccountCheck(_ context.Context, req *pbUser.AccountCheckReq) (*pbUser.AccountCheckResp, error) { func (s *userServer) AccountCheck(_ context.Context, req *pbUser.AccountCheckReq) (*pbUser.AccountCheckResp, error) {
log.NewInfo(req.OperationID,"AccountCheck args ", req.String()) log.NewInfo(req.OperationID, "AccountCheck args ", req.String())
if token_verify.IsMangerUserID(req.OpUserID){ if token_verify.IsMangerUserID(req.OpUserID) {
log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID) log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
} }
@ -199,12 +205,9 @@ func (s *userServer) AccountCheck(_ context.Context, req *pbUser.AccountCheckReq
} }
func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserInfoReq) (*pbUser.UpdateUserInfoResp, error) { func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserInfoReq) (*pbUser.UpdateUserInfoResp, error) {
log.NewInfo(req.OperationID,"UpdateUserInfo args ", req.String()) log.NewInfo(req.OperationID, "UpdateUserInfo args ", req.String())
if !token_verify.CheckAccess(req.OpUserID, req.UserInfo.UserID){ if !token_verify.CheckAccess(req.OpUserID, req.UserInfo.UserID) {
log.NewError(req.OperationID, "CheckAccess false ", req.OpUserID, req.UserInfo.UserID) log.NewError(req.OperationID, "CheckAccess false ", req.OpUserID, req.UserInfo.UserID)
return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
} }
@ -219,7 +222,7 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName) etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
client := pbFriend.NewFriendClient(etcdConn) client := pbFriend.NewFriendClient(etcdConn)
newReq := &pbFriend.GetFriendListReq{ newReq := &pbFriend.GetFriendListReq{
CommID: &pbFriend.CommID{OperationID: req.OperationID, FromUserID: req.UserInfo.UserID, OpUserID: req.OpUserID} CommID: &pbFriend.CommID{OperationID: req.OperationID, FromUserID: req.UserInfo.UserID, OpUserID: req.OpUserID},
} }
RpcResp, err := client.GetFriendList(context.Background(), newReq) RpcResp, err := client.GetFriendList(context.Background(), newReq)
@ -227,12 +230,9 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
log.NewError(req.OperationID, "GetFriendList failed ", err.Error(), newReq) log.NewError(req.OperationID, "GetFriendList failed ", err.Error(), newReq)
return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
} }
for _, v := range RpcResp.FriendInfoList{ for _, v := range RpcResp.FriendInfoList {
chat.FriendInfoChangedNotification(req.OperationID, req.OpUserID, req.UserInfo.UserID, v.FriendUser.UserID) chat.FriendInfoChangedNotification(req.OperationID, req.OpUserID, req.UserInfo.UserID, v.FriendUser.UserID)
} }
chat.SelfInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID) chat.SelfInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID)
return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
} }

1
pkg/base_info/conversation_api_struct.go Normal file
View File

@ -0,0 +1 @@
package base_info

98
pkg/base_info/manage_api_struct.go Normal file
View File

@ -0,0 +1,98 @@
package base_info
import open_im_sdk "Open_IM/pkg/proto/sdk_ws"
type paramsManagementSendMsg struct {
OperationID string `json:"operationID" binding:"required"`
SendID string `json:"sendID" binding:"required"`
RecvID string `json:"recvID" `
GroupID string `json:"groupID" `
SenderNickName string `json:"senderNickName" `
SenderFaceURL string `json:"senderFaceURL" `
SenderPlatformID int32 `json:"senderPlatformID"`
ForceList []string `json:"forceList" `
Content map[string]interface{} `json:"content" binding:"required"`
ContentType int32 `json:"contentType" binding:"required"`
SessionType int32 `json:"sessionType" binding:"required"`
IsOnlineOnly bool `json:"isOnlineOnly"`
OfflinePushInfo *open_im_sdk.OfflinePushInfo `json:"offlinePushInfo"`
}
type PictureBaseInfo struct {
UUID string `mapstructure:"uuid"`
Type string `mapstructure:"type" validate:"required"`
Size int64 `mapstructure:"size" validate:"required"`
Width int32 `mapstructure:"width" validate:"required"`
Height int32 `mapstructure:"height" validate:"required"`
Url string `mapstructure:"url" validate:"required"`
}
type PictureElem struct {
SourcePath string `mapstructure:"sourcePath"`
SourcePicture PictureBaseInfo `mapstructure:"sourcePicture" validate:"required"`
BigPicture PictureBaseInfo `mapstructure:"bigPicture" `
SnapshotPicture PictureBaseInfo `mapstructure:"snapshotPicture"`
}
type SoundElem struct {
UUID string `mapstructure:"uuid"`
SoundPath string `mapstructure:"soundPath"`
SourceURL string `mapstructure:"sourceUrl"`
DataSize int64 `mapstructure:"dataSize"`
Duration int64 `mapstructure:"duration"`
}
type VideoElem struct {
VideoPath string `mapstructure:"videoPath"`
VideoUUID string `mapstructure:"videoUUID"`
VideoURL string `mapstructure:"videoUrl"`
VideoType string `mapstructure:"videoType"`
VideoSize int64 `mapstructure:"videoSize"`
Duration int64 `mapstructure:"duration"`
SnapshotPath string `mapstructure:"snapshotPath"`
SnapshotUUID string `mapstructure:"snapshotUUID"`
SnapshotSize int64 `mapstructure:"snapshotSize"`
SnapshotURL string `mapstructure:"snapshotUrl"`
SnapshotWidth int32 `mapstructure:"snapshotWidth"`
SnapshotHeight int32 `mapstructure:"snapshotHeight"`
}
type FileElem struct {
FilePath string `mapstructure:"filePath"`
UUID string `mapstructure:"uuid"`
SourceURL string `mapstructure:"sourceUrl"`
FileName string `mapstructure:"fileName"`
FileSize int64 `mapstructure:"fileSize"`
}
type paramsDeleteUsers struct {
OperationID string `json:"operationID" binding:"required"`
DeleteUidList []string `json:"deleteUidList" binding:"required"`
}
type paramsGetAllUsersUid struct {
OperationID string `json:"operationID" binding:"required"`
}
type paramsGetUsersOnlineStatus struct {
OperationID string `json:"operationID" binding:"required"`
UserIDList []string `json:"userIDList" binding:"required,lte=200"`
}
type paramsAccountCheck struct {
OperationID string `json:"operationID" binding:"required"`
UserIDList []string `json:"userIDList" binding:"required,lte=100"`
}
type AtElem struct {
Text string `mapstructure:"text"`
AtUserList []string `mapstructure:"atUserList"`
IsAtSelf bool `mapstructure:"isAtSelf"`
}
type LocationElem struct {
Description string `mapstructure:"description"`
Longitude float64 `mapstructure:"longitude"`
Latitude float64 `mapstructure:"latitude"`
}
type CustomElem struct {
Data string `mapstructure:"data" validate:"required"`
Description string `mapstructure:"description"`
Extension string `mapstructure:"extension"`
}
type TextElem struct {
Text string `mapstructure:"text" validate:"required"`
}

1
pkg/common/db/mysql_model/im_mysql_model/friend_request_model.go
View File

@ -2,6 +2,7 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/db" "Open_IM/pkg/common/db"
"time"
) )
//type FriendRequest struct { //type FriendRequest struct {

3
pkg/common/db/mysql_model/im_mysql_model/group_member_model.go
View File

@ -2,6 +2,7 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/db" "Open_IM/pkg/common/db"
"time"
) )
//type GroupMember struct { //type GroupMember struct {
@ -61,7 +62,7 @@ func GetGroupMemberListByGroupIDAndRoleLevel(groupID string, roleLevel int32) ([
return nil, err return nil, err
} }
var groupMemberList []GroupMember var groupMemberList []GroupMember
err = dbConn.Table("group_member").Where("group_id=? and role_level=?", groupID, role_level).Find(&groupMemberList).Error err = dbConn.Table("group_member").Where("group_id=? and role_level=?", groupID, roleLevel).Find(&groupMemberList).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
pkg/common/db/mysql_model/im_mysql_model/group_model.go
View File

@ -2,8 +2,6 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/db" "Open_IM/pkg/common/db"
"Open_IM/pkg/proto/group"
"errors"
"time" "time"
) )

2
pkg/common/db/mysql_model/im_mysql_model/group_request_model.go
View File

@ -2,8 +2,6 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/db" "Open_IM/pkg/common/db"
"Open_IM/pkg/common/log"
"Open_IM/pkg/proto/group"
"time" "time"
) )

2
pkg/common/db/mysql_model/im_mysql_model/model_struct.go
View File

@ -95,7 +95,7 @@ type GroupMember struct {
JoinTime time.Time `gorm:"column:join_time"` JoinTime time.Time `gorm:"column:join_time"`
Nickname string `gorm:"column:nickname"` Nickname string `gorm:"column:nickname"`
FaceUrl string `gorm:"user_group_face_url"` FaceUrl string `gorm:"user_group_face_url"`
JoinSource int32 `gorm:"column:join_source"` JoinSource time.Time `gorm:"column:join_source"`
OperatorUserID string `gorm:"column:operator_user_id"` OperatorUserID string `gorm:"column:operator_user_id"`
Ex string `gorm:"column:ex"` Ex string `gorm:"column:ex"`
} }

95
pkg/common/utils/utils.go Normal file
View File

@ -0,0 +1,95 @@
package utils
import (
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/token_verify"
open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"math/rand"
"strconv"
"time"
)
func OperationIDGenerator() string {
return strconv.FormatInt(time.Now().UnixNano()+int64(rand.Uint32()), 10)
}
func FriendOpenIMCopyDB(dst *imdb.Friend, src open_im_sdk.FriendInfo) {
utils.CopyStructFields(dst, src)
dst.FriendUserID = src.FriendUser.UserID
}
func FriendDBCopyOpenIM(dst *open_im_sdk.FriendInfo, src imdb.Friend) {
utils.CopyStructFields(dst, src)
user, _ := imdb.GetUserByUserID(src.FriendUserID)
if user != nil {
utils.CopyStructFields(dst.FriendUser, user)
}
}
//
func FriendRequestOpenIMCopyDB(dst *imdb.FriendRequest, src open_im_sdk.FriendRequest) {
utils.CopyStructFields(dst, src)
}
func FriendRequestDBCopyOpenIM(dst *open_im_sdk.FriendRequest, src imdb.FriendRequest) {
utils.CopyStructFields(dst, src)
}
func GroupOpenIMCopyDB(dst *imdb.Group, src open_im_sdk.GroupInfo) {
utils.CopyStructFields(dst, src)
}
func GroupDBCopyOpenIM(dst *open_im_sdk.GroupInfo, src imdb.Group) {
utils.CopyStructFields(dst, src)
user, _ := imdb.GetGroupOwnerInfoByGroupID(src.GroupID)
if user != nil {
dst.OwnerUserID = user.UserID
}
dst.MemberCount = imdb.GetGroupMemberNumByGroupID(src.GroupID)
}
func GroupMemberOpenIMCopyDB(dst *imdb.GroupMember, src open_im_sdk.GroupMemberFullInfo) {
utils.CopyStructFields(dst, src)
}
func GroupMemberDBCopyOpenIM(dst *open_im_sdk.GroupMemberFullInfo, src imdb.GroupMember) {
utils.CopyStructFields(dst, src)
if token_verify.IsMangerUserID(src.UserID) {
u, _ := imdb.GetUserByUserID(src.UserID)
if u != nil {
utils.CopyStructFields(dst, u)
}
dst.AppMangerLevel = 1
}
}
func GroupRequestOpenIMCopyDB(dst *imdb.GroupRequest, src open_im_sdk.GroupRequest) {
utils.CopyStructFields(dst, src)
}
func GroupRequestDBCopyOpenIM(dst *open_im_sdk.GroupRequest, src imdb.GroupRequest) {
utils.CopyStructFields(dst, src)
}
func UserOpenIMCopyDB(dst *imdb.User, src open_im_sdk.UserInfo) {
utils.CopyStructFields(dst, src)
}
func UserDBCopyOpenIM(dst *open_im_sdk.UserInfo, src imdb.User) {
utils.CopyStructFields(dst, src)
}
func BlackOpenIMCopyDB(dst *imdb.Black, src open_im_sdk.BlackInfo) {
utils.CopyStructFields(dst, src)
dst.BlockUserID = src.BlackUserInfo.UserID
}
func BlackDBCopyOpenIM(dst *open_im_sdk.BlackInfo, src imdb.Black) {
utils.CopyStructFields(dst, src)
dst.CreateTime = src.CreateTime.Unix()
user, _ := imdb.GetUserByUserID(src.BlockUserID)
if user != nil {
utils.CopyStructFields(dst.BlackUserInfo, user)
}
}

89
pkg/utils/utils.go
View File

@ -1,14 +1,8 @@
package utils package utils
import ( import (
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/token_verify"
open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"fmt" "fmt"
"math/rand"
"reflect" "reflect"
"strconv"
"time"
) )
// copy a by b b->a // copy a by b b->a
@ -49,86 +43,3 @@ func CopyStructFields(a interface{}, b interface{}, fields ...string) (err error
} }
return nil return nil
} }
func OperationIDGenerator() string {
return strconv.FormatInt(time.Now().UnixNano()+int64(rand.Uint32()), 10)
}
func FriendOpenIMCopyDB(dst *imdb.Friend, src open_im_sdk.FriendInfo) {
CopyStructFields(dst, src)
dst.FriendUserID = src.FriendUser.UserID
}
func FriendDBCopyOpenIM(dst *open_im_sdk.FriendInfo, src imdb.Friend) {
CopyStructFields(dst, src)
user, _ := imdb.GetUserByUserID(src.FriendUserID)
if user != nil {
CopyStructFields(dst.FriendUser, user)
}
}
//
func FriendRequestOpenIMCopyDB(dst *imdb.FriendRequest, src open_im_sdk.FriendRequest) {
CopyStructFields(dst, src)
}
func FriendRequestDBCopyOpenIM(dst *open_im_sdk.FriendRequest, src imdb.FriendRequest) {
CopyStructFields(dst, src)
}
func GroupOpenIMCopyDB(dst *imdb.Group, src open_im_sdk.GroupInfo) {
CopyStructFields(dst, src)
}
func GroupDBCopyOpenIM(dst *open_im_sdk.GroupInfo, src imdb.Group) {
CopyStructFields(dst, src)
user, _ := imdb.GetGroupOwnerInfoByGroupID(src.GroupID)
if user != nil {
dst.OwnerUserID = user.UserID
}
dst.MemberCount = imdb.GetGroupMemberNumByGroupID(src.GroupID)
}
func GroupMemberOpenIMCopyDB(dst *imdb.GroupMember, src open_im_sdk.GroupMemberFullInfo) {
CopyStructFields(dst, src)
}
func GroupMemberDBCopyOpenIM(dst *open_im_sdk.GroupMemberFullInfo, src imdb.GroupMember) {
CopyStructFields(dst, src)
if token_verify.IsMangerUserID(src.UserID) {
u, _ := imdb.GetUserByUserID(src.UserID)
if u != nil {
CopyStructFields(dst, u)
}
dst.AppMangerLevel = 1
}
}
func GroupRequestOpenIMCopyDB(dst *imdb.GroupRequest, src open_im_sdk.GroupRequest) {
CopyStructFields(dst, src)
}
func GroupRequestDBCopyOpenIM(dst *open_im_sdk.GroupRequest, src imdb.GroupRequest) {
CopyStructFields(dst, src)
}
func UserOpenIMCopyDB(dst *imdb.User, src open_im_sdk.UserInfo) {
CopyStructFields(dst, src)
}
func UserDBCopyOpenIM(dst *open_im_sdk.UserInfo, src imdb.User) {
CopyStructFields(dst, src)
}
func BlackOpenIMCopyDB(dst *imdb.Black, src open_im_sdk.BlackInfo) {
CopyStructFields(dst, src)
dst.BlockUserID = src.BlackUserInfo.UserID
}
func BlackDBCopyOpenIM(dst *open_im_sdk.BlackInfo, src imdb.Black) {
CopyStructFields(dst, src)
user, _ := imdb.GetUserByUserID(src.BlockUserID)
if user != nil {
CopyStructFields(dst.BlackUserInfo, user)
}
}