msb-public
/
Open-IM-Server
mirror of https://github.com/OpenIMSDK/Open-IM-Server
2
0
Code Issues Projects Releases Wiki Activity

tidy code

Browse Source
pull/131/head
wenxu12345 4 years ago
parent 30024c9814
commit f0f1c54244
10 changed files with 113 additions and 108 deletions
Show Stats Download Patch File Download Diff File

10
internal/api/group/group.go
Unescape View File

@ -348,7 +348,7 @@ func ApplicationGroupResponse(c *gin.Context) {
return return
} }
resp := api.CommResp{ErrCode: reply.ErrCode, ErrMsg: reply.ErrMsg} resp := api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}
c.JSON(http.StatusOK, resp) c.JSON(http.StatusOK, resp)
log.NewInfo(req.OperationID, "ApplicationGroupResponse api return ", resp) log.NewInfo(req.OperationID, "ApplicationGroupResponse api return ", resp)
} }
@ -379,7 +379,7 @@ func JoinGroup(c *gin.Context) {
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"}) c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"})
return return
} }
resp := api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg} resp := api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}
c.JSON(http.StatusOK, resp) c.JSON(http.StatusOK, resp)
log.NewInfo("JoinGroup api return", RpcResp.String()) log.NewInfo("JoinGroup api return", RpcResp.String())
} }
@ -410,7 +410,7 @@ func QuitGroup(c *gin.Context) {
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"}) c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"})
return return
} }
resp := api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg} resp := api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}
c.JSON(http.StatusOK, resp) c.JSON(http.StatusOK, resp)
log.NewInfo("QuitGroup api return", RpcResp.String()) log.NewInfo("QuitGroup api return", RpcResp.String())
} }
@ -441,7 +441,7 @@ func SetGroupInfo(c *gin.Context) {
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"}) c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"})
return return
} }
resp := api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg} resp := api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}
c.JSON(http.StatusOK, resp) c.JSON(http.StatusOK, resp)
log.NewInfo(req.OperationID, "SetGroupInfo api return ", resp) log.NewInfo(req.OperationID, "SetGroupInfo api return ", resp)
} }
@ -473,7 +473,7 @@ func TransferGroupOwner(c *gin.Context) {
return return
} }
resp := api.CommResp{ErrCode: reply.ErrCode, ErrMsg: reply.ErrMsg} resp := api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}
c.JSON(http.StatusOK, resp) c.JSON(http.StatusOK, resp)
log.NewInfo(req.OperationID, "TransferGroupOwner api return ", resp) log.NewInfo(req.OperationID, "TransferGroupOwner api return ", resp)
} }

1
internal/api/user/update_user_info.go
Unescape View File

@ -1 +0,0 @@
package user

58
internal/rpc/friend/firend.go
Unescape View File

@ -113,8 +113,9 @@ func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlackl
if !ok { if !ok {
log.NewError(req.CommID.OperationID, "CheckAccess failed ", req.CommID.OpUserID, req.CommID.FromUserID) log.NewError(req.CommID.OperationID, "CheckAccess failed ", req.CommID.OpUserID, req.CommID.FromUserID)
} }
black := imdb.Black{OwnerUserID: req.CommID.FromUserID, BlockUserID: req.CommID.ToUserID}
err := imdb.InsertInToUserBlackList(req.CommID.FromUserID, req.CommID.ToUserID) err := imdb.InsertInToUserBlackList(black)
if err != nil { if err != nil {
log.NewError(req.CommID.OperationID, "InsertInToUserBlackList failed ", err.Error()) log.NewError(req.CommID.OperationID, "InsertInToUserBlackList failed ", err.Error())
return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
@ -131,15 +132,17 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
log.NewError(req.CommID.OperationID, "CheckAccess failed ", req.CommID.OpUserID, req.CommID.FromUserID) log.NewError(req.CommID.OperationID, "CheckAccess failed ", req.CommID.OpUserID, req.CommID.FromUserID)
} }
//Cannot add non-existent users //Cannot add non-existent users
if _, err := imdb.FindUserByUID(req.CommID.ToUserID); err != nil { if _, err := imdb.GetUserByUserID(req.CommID.ToUserID); err != nil {
log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error(), req.CommID.ToUserID) log.NewError(req.CommID.OperationID, "GetUserByUserID failed ", err.Error(), req.CommID.ToUserID)
return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
//Establish a latest relationship in the friend request table //Establish a latest relationship in the friend request table
err := imdb.ReplaceIntoFriendReq(req.CommID.FromUserID, req.CommID.ToUserID, constant.ApplicationFriendFlag, req.ReqMsg) friendRequest := imdb.FriendRequest{ReqMessage: req.ReqMsg}
utils.CopyStructFields(&friendRequest, req.CommID)
err := imdb.UpdateFriendApplication(&friendRequest)
if err != nil { if err != nil {
log.NewError(req.CommID.OperationID, "ReplaceIntoFriendReq failed ", err.Error()) log.NewError(req.CommID.OperationID, "UpdateFriendApplication failed ", err.Error())
return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
@ -158,8 +161,7 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri
c.ErrMsg = constant.ErrAccess.ErrMsg c.ErrMsg = constant.ErrAccess.ErrMsg
return &pbFriend.ImportFriendResp{CommonResp: &c, FailedFriendUserIDList: req.FriendUserIDList}, nil return &pbFriend.ImportFriendResp{CommonResp: &c, FailedFriendUserIDList: req.FriendUserIDList}, nil
} }
if _, err := imdb.GetUserByUserID(req.FromUserID); err != nil {
if _, err := imdb.FindUserByUID(req.FromUserID); err != nil {
log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.FromUserID) log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.FromUserID)
c.ErrCode = constant.ErrDB.ErrCode c.ErrCode = constant.ErrDB.ErrCode
c.ErrMsg = "this user not exists,cant not add friend" c.ErrMsg = "this user not exists,cant not add friend"
@ -167,14 +169,15 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri
} }
for _, v := range req.FriendUserIDList { for _, v := range req.FriendUserIDList {
if _, fErr := imdb.FindUserByUID(v); fErr != nil { if _, fErr := imdb.GetUserByUserID(v); fErr != nil {
c.ErrMsg = "some uid establish failed" c.ErrMsg = "some uid establish failed"
c.ErrCode = 408 c.ErrCode = 408
resp.FailedFriendUserIDList = append(resp.FailedFriendUserIDList, v) resp.FailedFriendUserIDList = append(resp.FailedFriendUserIDList, v)
} else { } else {
if _, err := imdb.FindFriendRelationshipFromFriend(req.FromUserID, v); err != nil { if _, err := imdb.GetFriendRelationshipFromFriend(req.FromUserID, v); err != nil {
//Establish two single friendship //Establish two single friendship
err1 := imdb.InsertToFriend(req.FromUserID, v, 1) toInsertFollow := imdb.Friend{OwnerUserID: req.FromUserID, FriendUserID: v}
err1 := imdb.InsertToFriend(&toInsertFollow)
if err1 != nil { if err1 != nil {
resp.FailedFriendUserIDList = append(resp.FailedFriendUserIDList, v) resp.FailedFriendUserIDList = append(resp.FailedFriendUserIDList, v)
log.NewError(req.OperationID, "InsertToFriend failed", req.FromUserID, v, err1.Error()) log.NewError(req.OperationID, "InsertToFriend failed", req.FromUserID, v, err1.Error())
@ -182,7 +185,8 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri
c.ErrCode = 408 c.ErrCode = 408
continue continue
} }
err2 := imdb.InsertToFriend(v, req.FromUserID, 1) toInsertFollow = imdb.Friend{OwnerUserID: v, FriendUserID: req.FromUserID}
err2 := imdb.InsertToFriend(&toInsertFollow)
if err2 != nil { if err2 != nil {
resp.FailedFriendUserIDList = append(resp.FailedFriendUserIDList, v) resp.FailedFriendUserIDList = append(resp.FailedFriendUserIDList, v)
log.NewError(req.OperationID, "InsertToFriend failed", v, req.FromUserID, err2.Error()) log.NewError(req.OperationID, "InsertToFriend failed", v, req.FromUserID, err2.Error())
@ -193,7 +197,6 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri
for _, v := range req.FriendUserIDList { for _, v := range req.FriendUserIDList {
chat.FriendAddedNotification(req.OperationID, req.OpUserID, req.FromUserID, v) chat.FriendAddedNotification(req.OperationID, req.OpUserID, req.FromUserID, v)
} }
} }
} }
} }
@ -213,18 +216,21 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
//Check there application before agreeing or refuse to a friend's application //Check there application before agreeing or refuse to a friend's application
//req.CommID.FromUserID process req.CommID.ToUserID //req.CommID.FromUserID process req.CommID.ToUserID
if _, err := imdb.FindFriendApplyFromFriendReqByUid(req.CommID.ToUserID, req.CommID.FromUserID); err != nil { friendRequest, err := imdb.GetFriendApplicationByBothUserID(req.CommID.ToUserID, req.CommID.FromUserID)
log.NewError(req.CommID.OperationID, "FindFriendApplyFromFriendReqByUid failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID) if err != nil {
log.NewError(req.CommID.OperationID, "GetFriendApplicationByBothUserID failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID)
return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
friendRequest.HandleResult = req.Flag
//Change friend request status flag //Change friend request status flag
err := imdb.UpdateFriendRelationshipToFriendReq(req.CommID.ToUserID, req.CommID.FromUserID, req.Flag) err = imdb.UpdateFriendApplication(friendRequest)
if err != nil { if err != nil {
log.NewError(req.CommID.OperationID, "UpdateFriendRelationshipToFriendReq failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID, req.Flag) log.NewError(req.CommID.OperationID, "UpdateFriendApplication failed ", err.Error(), friendRequest)
return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok") log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok")
//Change the status of the friend request form //Change the status of the friend request form
if req.Flag == constant.FriendFlag { if req.Flag == constant.FriendFlag {
//Establish friendship after find friend relationship not exists //Establish friendship after find friend relationship not exists
@ -284,7 +290,7 @@ func (s *friendServer) GetBlacklist(ctx context.Context, req *pbFriend.GetBlackl
return &pbFriend.GetBlacklistResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil return &pbFriend.GetBlacklistResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
} }
blackListInfo, err := imdb.GetBlackListByUID(req.CommID.FromUserID) blackListInfo, err := imdb.GetBlackListByUserID(req.CommID.FromUserID)
if err != nil { if err != nil {
log.NewError(req.CommID.OperationID, "GetBlackListByUID failed ", err.Error(), req.CommID.FromUserID) log.NewError(req.CommID.OperationID, "GetBlackListByUID failed ", err.Error(), req.CommID.FromUserID)
return &pbFriend.GetBlacklistResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil return &pbFriend.GetBlacklistResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
@ -296,7 +302,7 @@ func (s *friendServer) GetBlacklist(ctx context.Context, req *pbFriend.GetBlackl
for _, blackUser := range blackListInfo { for _, blackUser := range blackListInfo {
var blackUserInfo sdkws.PublicUserInfo var blackUserInfo sdkws.PublicUserInfo
//Find black user information //Find black user information
us, err := imdb.FindUserByUID(blackUser.BlockUserID) us, err := imdb.GetUserByUserID(blackUser.BlockUserID)
if err != nil { if err != nil {
log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error(), blackUser.BlockUserID) log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error(), blackUser.BlockUserID)
continue continue
@ -322,7 +328,7 @@ func (s *friendServer) SetFriendComment(ctx context.Context, req *pbFriend.SetFr
return &pbFriend.SetFriendCommentResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbFriend.SetFriendCommentResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
log.NewInfo(req.CommID.OperationID, "rpc SetFriendComment ok") log.NewInfo(req.CommID.OperationID, "rpc SetFriendComment ok")
chat.FriendInfoChangedNotification(req) chat.FriendInfoChangedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
return &pbFriend.SetFriendCommentResp{CommonResp: &pbFriend.CommonResp{}}, nil return &pbFriend.SetFriendCommentResp{CommonResp: &pbFriend.CommonResp{}}, nil
} }
@ -352,7 +358,7 @@ func (s *friendServer) IsInBlackList(ctx context.Context, req *pbFriend.IsInBlac
} }
var isInBlacklist = false var isInBlacklist = false
err := imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, req.CommID.ToUserID) err := imdb.CheckBlack(req.CommID.FromUserID, req.CommID.ToUserID)
if err == nil { if err == nil {
isInBlacklist = true isInBlacklist = true
} }
@ -367,7 +373,7 @@ func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq)
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
return &pbFriend.IsFriendResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil return &pbFriend.IsFriendResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
} }
_, err := imdb.FindFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID) _, err := imdb.GetFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
if err == nil { if err == nil {
isFriend = true isFriend = true
} else { } else {
@ -386,7 +392,7 @@ func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFrien
return &pbFriend.GetFriendListResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil return &pbFriend.GetFriendListResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
} }
friends, err := imdb.FindUserInfoFromFriend(req.CommID.FromUserID) friends, err := imdb.GetUserInfoFromFriend(req.CommID.FromUserID)
if err != nil { if err != nil {
log.NewError(req.CommID.OperationID, "FindUserInfoFromFriend failed", err.Error(), req.CommID.FromUserID) log.NewError(req.CommID.OperationID, "FindUserInfoFromFriend failed", err.Error(), req.CommID.FromUserID)
return &pbFriend.GetFriendListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil return &pbFriend.GetFriendListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
@ -394,14 +400,14 @@ func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFrien
for _, friendUser := range friends { for _, friendUser := range friends {
var friendUserInfo sdkws.FriendInfo var friendUserInfo sdkws.FriendInfo
//find user is in blackList //find user is in blackList
err = imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, friendUser.FriendUserID) // err = imdb.GetRelationshipFromBlackList(req.CommID.FromUserID, friendUser.FriendUserID)
//if err == nil { //if err == nil {
// friendUserInfo.IsBlack = constant.BlackListFlag // friendUserInfo.IsBlack = constant.BlackListFlag
//} else { //} else {
// friendUserInfo.IsBlack = 0 // friendUserInfo.IsBlack = 0
//} //}
//Find user information //Find user information
us, err := imdb.FindUserByUID(friendUser.FriendUserID) us, err := imdb.GetUserByUserID(friendUser.FriendUserID)
if err != nil { if err != nil {
log.NewError(req.CommID.OperationID, "FindUserByUID failed", err.Error(), friendUser.FriendUserID) log.NewError(req.CommID.OperationID, "FindUserByUID failed", err.Error(), friendUser.FriendUserID)
continue continue
@ -426,7 +432,7 @@ func (s *friendServer) GetFriendApplyList(ctx context.Context, req *pbFriend.Get
} }
// Find the current user friend applications received // Find the current user friend applications received
ApplyUsersInfo, err := imdb.FindFriendsApplyFromFriendReq(req.CommID.FromUserID) ApplyUsersInfo, err := imdb.GetReceivedFriendsApplicationListByUserID(req.CommID.FromUserID)
if err != nil { if err != nil {
log.NewError(req.CommID.OperationID, "FindFriendsApplyFromFriendReq ", err.Error(), req.CommID.FromUserID) log.NewError(req.CommID.OperationID, "FindFriendsApplyFromFriendReq ", err.Error(), req.CommID.FromUserID)
return &pbFriend.GetFriendApplyListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil return &pbFriend.GetFriendApplyListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
@ -453,7 +459,7 @@ func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetSe
} }
// Find the self add other userinfo // Find the self add other userinfo
usersInfo, err := imdb.FindSelfApplyFromFriendReq(req.CommID.FromUserID) usersInfo, err := imdb.GetSendFriendApplicationListByUserID(req.CommID.FromUserID)
if err != nil { if err != nil {
log.NewError(req.CommID.OperationID, "FindSelfApplyFromFriendReq failed ", err.Error(), req.CommID.FromUserID) log.NewError(req.CommID.OperationID, "FindSelfApplyFromFriendReq failed ", err.Error(), req.CommID.FromUserID)
return &pbFriend.GetSelfApplyListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil return &pbFriend.GetSelfApplyListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil

136
internal/rpc/group/group.go
Unescape View File

@ -39,17 +39,16 @@ func NewGroupServer(port int) *groupServer {
} }
func (s *groupServer) Run() { func (s *groupServer) Run() {
log.Info("", "", "rpc group init....") log.NewInfo("0", "group rpc start ")
ip := utils.ServerIP ip := utils.ServerIP
registerAddress := ip + ":" + strconv.Itoa(s.rpcPort) registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
//listener network //listener network
listener, err := net.Listen("tcp", registerAddress) listener, err := net.Listen("tcp", registerAddress)
if err != nil { if err != nil {
log.InfoByArgs("listen network failed,err=%s", err.Error()) log.NewError("0", "Listen failed ", err.Error(), registerAddress)
return return
} }
log.Info("", "", "listen network success, address = %s", registerAddress) log.NewInfo("0", "listen network success, ", registerAddress, listener)
defer listener.Close() defer listener.Close()
//grpc server //grpc server
srv := grpc.NewServer() srv := grpc.NewServer()
@ -58,15 +57,15 @@ func (s *groupServer) Run() {
pbGroup.RegisterGroupServer(srv, s) pbGroup.RegisterGroupServer(srv, s)
err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10) err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
if err != nil { if err != nil {
log.ErrorByArgs("get etcd failed,err=%s", err.Error()) log.NewError("0", "RegisterEtcd failed ", err.Error())
return return
} }
err = srv.Serve(listener) err = srv.Serve(listener)
if err != nil { if err != nil {
log.ErrorByArgs("listen rpc_group error,err=%s", err.Error()) log.NewError("0", "Serve failed ", err.Error())
return return
} }
log.Info("", "", "rpc create group init success") log.NewInfo("0", "group rpc success")
} }
func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) { func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) {
@ -79,20 +78,24 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
//Time stamp + MD5 to generate group chat id //Time stamp + MD5 to generate group chat id
groupId := utils.Md5(strconv.FormatInt(time.Now().UnixNano(), 10)) groupId := utils.Md5(strconv.FormatInt(time.Now().UnixNano(), 10))
//to group //to group
err := im_mysql_model.InsertIntoGroup(groupId, req.GroupInfo.GroupName, req.GroupInfo.Introduction, req.GroupInfo.Notification, req.GroupInfo.FaceUrl, req.GroupInfo.Ex, req.GroupInfo.GroupType) groupInfo := imdb.Group{}
utils.CopyStructFields(&groupInfo, req.GroupInfo)
err := im_mysql_model.InsertIntoGroup(groupInfo)
if err != nil { if err != nil {
log.NewError(req.OperationID, "InsertIntoGroup failed, ", err.Error(), groupId, req.GroupInfo.GroupName, req.GroupInfo.Introduction, req.GroupInfo.Notification, req.GroupInfo.FaceUrl, req.GroupInfo.Ex, req.GroupInfo.GroupType) log.NewError(req.OperationID, "InsertIntoGroup failed, ", err.Error(), groupId, req.GroupInfo.GroupName, req.GroupInfo.Introduction, req.GroupInfo.Notification, req.GroupInfo.FaceUrl, req.GroupInfo.Ex, req.GroupInfo.GroupType)
return &pbGroup.CreateGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil return &pbGroup.CreateGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
} }
us, err := im_mysql_model.FindUserByUID(req.OwnerUserID) us, err := imdb.GetUserByUserID(req.OwnerUserID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.OwnerUserID) log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.OwnerUserID)
return &pbGroup.CreateGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil return &pbGroup.CreateGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
} }
//to group member //to group member
err = im_mysql_model.InsertIntoGroupMember(groupId, us.UserID, us.Nickname, us.FaceUrl, constant.GroupOwner) groupMember := imdb.GroupMember{GroupID: groupId, RoleLevel: 1}
utils.CopyStructFields(&groupMember, us)
err = im_mysql_model.InsertIntoGroupMember(groupMember)
if err != nil { if err != nil {
log.NewError(req.OperationID, "InsertIntoGroupMember failed ", err.Error()) log.NewError(req.OperationID, "InsertIntoGroupMember failed ", err.Error())
return &pbGroup.CreateGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil return &pbGroup.CreateGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
@ -106,7 +109,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
//to group member //to group member
for _, user := range req.InitMemberList { for _, user := range req.InitMemberList {
us, err := im_mysql_model.FindUserByUID(user.UserID) us, err := im_mysql_model.GetUserByUserID(user.UserID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), user.UserID) log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), user.UserID)
continue continue
@ -115,9 +118,10 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
log.NewError(req.OperationID, "only one owner, failed ", user) log.NewError(req.OperationID, "only one owner, failed ", user)
continue continue
} }
err = im_mysql_model.InsertIntoGroupMember(groupId, user.UserID, us.Nickname, us.FaceUrl, user.RoleLevel) utils.CopyStructFields(&groupMember, us)
err = im_mysql_model.InsertIntoGroupMember(groupMember)
if err != nil { if err != nil {
log.NewError(req.OperationID, "InsertIntoGroupMember failed ", groupId, user.UserID, us.Nickname, us.FaceUrl, user.RoleLevel) log.NewError(req.OperationID, "InsertIntoGroupMember failed ", err.Error(), groupMember)
} }
okUserIDList = append(okUserIDList, user.UserID) okUserIDList = append(okUserIDList, user.UserID)
err = db.DB.AddGroupMember(groupId, user.UserID) err = db.DB.AddGroupMember(groupId, user.UserID)
@ -127,9 +131,9 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
} }
resp := &pbGroup.CreateGroupResp{} resp := &pbGroup.CreateGroupResp{}
group, err := im_mysql_model.FindGroupInfoByGroupId(groupId) group, err := im_mysql_model.GetGroupInfoByGroupID(groupId)
if err != nil { if err != nil {
log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", err.Error(), groupId) log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", err.Error(), groupId)
resp.ErrCode = constant.ErrDB.ErrCode resp.ErrCode = constant.ErrDB.ErrCode
resp.ErrMsg = constant.ErrDB.ErrMsg resp.ErrMsg = constant.ErrDB.ErrMsg
return resp, nil return resp, nil
@ -146,20 +150,19 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
log.NewError(req.OperationID, "CheckAccess false ", req.OpUserID, req.FromUserID) log.NewError(req.OperationID, "CheckAccess false ", req.OpUserID, req.FromUserID)
return &pbGroup.GetJoinedGroupListResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil return &pbGroup.GetJoinedGroupListResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
} }
//group list //group list
joinedGroupList, err := imdb.GetJoinedGroupIdListByMemberId(req.FromUserID) joinedGroupList, err := imdb.GetJoinedGroupIDListByUserID(req.FromUserID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "GetJoinedGroupIdListByMemberId failed ", err.Error(), req.FromUserID) log.NewError(req.OperationID, "GetJoinedGroupIDListByUserID failed ", err.Error(), req.FromUserID)
return &pbGroup.GetJoinedGroupListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil return &pbGroup.GetJoinedGroupListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
} }
var resp pbGroup.GetJoinedGroupListResp var resp pbGroup.GetJoinedGroupListResp
for _, v := range joinedGroupList { for _, v := range joinedGroupList {
var groupNode open_im_sdk.GroupInfo var groupNode open_im_sdk.GroupInfo
num := imdb.GetGroupMemberNumByGroupId(v.GroupID) num := imdb.GetGroupMemberNumByGroupID(v)
owner, err2 := imdb.GetGroupOwnerInfoByGroupId(v.GroupID) owner, err2 := imdb.GetGroupOwnerInfoByGroupID(v)
group, err := imdb.FindGroupInfoByGroupId(v.GroupID) 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
@ -184,7 +187,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
} }
groupInfoFromMysql, err := imdb.FindGroupInfoByGroupId(req.GroupID) groupInfoFromMysql, err := imdb.GetGroupInfoByGroupID(req.GroupID)
if err != nil || groupInfoFromMysql == nil { if err != nil || groupInfoFromMysql == nil {
log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", req.GroupID, err) log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", req.GroupID, err)
return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
@ -198,7 +201,8 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
var resultNode pbGroup.Id2Result var resultNode pbGroup.Id2Result
resultNode.UserID = v resultNode.UserID = v
resultNode.Result = 0 resultNode.Result = 0
toUserInfo, err := imdb.FindUserByUID(v) toUserInfo, err := imdb.GetUserByUserID(v)
if err != nil { if err != nil {
log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), v) log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), v)
resultNode.Result = -1 resultNode.Result = -1
@ -212,10 +216,13 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue continue
} }
var toInsertInfo imdb.GroupMember
err = imdb.InsertGroupMember(req.GroupID, toUserInfo.UserID, toUserInfo.Nickname, toUserInfo.FaceUrl, 0) utils.CopyStructFields(&toInsertInfo, toUserInfo)
toInsertInfo.GroupID = req.GroupID
toInsertInfo.RoleLevel = 0
err = imdb.InsertIntoGroupMember(toInsertInfo)
if err != nil { if err != nil {
log.NewError(req.OperationID, "InsertGroupMember failed ", req.GroupID, toUserInfo.UserID, toUserInfo.Nickname, toUserInfo.FaceUrl) log.NewError(req.OperationID, "InsertIntoGroupMember failed ", req.GroupID, toUserInfo.UserID, toUserInfo.Nickname, toUserInfo.FaceUrl)
resultNode.Result = -1 resultNode.Result = -1
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue continue
@ -238,7 +245,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
log.NewInfo(req.OperationID, "GetGroupAllMember, args ", req.String()) log.NewInfo(req.OperationID, "GetGroupAllMember, args ", req.String())
var resp pbGroup.GetGroupAllMemberResp var resp pbGroup.GetGroupAllMemberResp
resp.ErrCode = 0 resp.ErrCode = 0
memberList, err := imdb.FindGroupMemberListByGroupId(req.GroupID) memberList, err := imdb.GetGroupMemberListByGroupID(req.GroupID)
if err != nil { if err != nil {
resp.ErrCode = constant.ErrDB.ErrCode resp.ErrCode = constant.ErrDB.ErrCode
resp.ErrMsg = constant.ErrDB.ErrMsg resp.ErrMsg = constant.ErrDB.ErrMsg
@ -270,7 +277,7 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
var resp pbGroup.GetGroupMemberListResp var resp pbGroup.GetGroupMemberListResp
resp.ErrCode = 0 resp.ErrCode = 0
memberList, err := imdb.GetGroupMemberByGroupId(req.GroupID, req.Filter, req.NextSeq, 30) memberList, err := imdb.GetGroupMemberByGroupID(req.GroupID, req.Filter, req.NextSeq, 30)
if err != nil { if err != nil {
resp.ErrCode = constant.ErrDB.ErrCode resp.ErrCode = constant.ErrDB.ErrCode
resp.ErrMsg = err.Error() resp.ErrMsg = err.Error()
@ -297,7 +304,7 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (*pbGroup.KickGroupMemberResp, error) { func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (*pbGroup.KickGroupMemberResp, error) {
log.NewInfo(req.OperationID, "KickGroupMember args ", req.String()) log.NewInfo(req.OperationID, "KickGroupMember args ", req.String())
ownerList, err := imdb.GetOwnerManagerByGroupId(req.GroupID) ownerList, 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)
return &pbGroup.KickGroupMemberResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil return &pbGroup.KickGroupMemberResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
@ -332,7 +339,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
groupOwnerUserID := "" groupOwnerUserID := ""
for _, v := range ownerList { for _, v := range ownerList {
if v.AdministratorLevel == 1 { if v.RoleLevel == 1 {
groupOwnerUserID = v.UserID groupOwnerUserID = v.UserID
} }
} }
@ -374,7 +381,7 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
for _, v := range req.MemberList { for _, v := range req.MemberList {
var memberNode open_im_sdk.GroupMemberFullInfo var memberNode open_im_sdk.GroupMemberFullInfo
memberInfo, err := imdb.GetMemberInfoById(req.GroupID, v) memberInfo, err := imdb.GetMemberInfoByID(req.GroupID, v)
memberNode.UserID = v memberNode.UserID = v
if err != nil { if err != nil {
log.NewError(req.OperationID, "GetMemberInfoById failed ", err.Error(), req.GroupID, v) log.NewError(req.OperationID, "GetMemberInfoById failed ", err.Error(), req.GroupID, v)
@ -397,15 +404,21 @@ func (s *groupServer) GetGroupApplicationList(_ context.Context, req *pbGroup.Ge
log.NewError(req.OperationID, "GetGroupApplicationList failed ", err.Error(), req.OpUserID) log.NewError(req.OperationID, "GetGroupApplicationList failed ", err.Error(), req.OpUserID)
return &pbGroup.GetGroupApplicationListResp{ErrCode: 701, ErrMsg: "GetGroupApplicationList failed"}, nil return &pbGroup.GetGroupApplicationListResp{ErrCode: 701, ErrMsg: "GetGroupApplicationList failed"}, nil
} }
log.NewInfo(req.OperationID, "GetGroupMembersInfo rpc return ", reply)
return reply, nil resp := pbGroup.GetGroupApplicationListResp{}
for _, v := range reply {
var node open_im_sdk.GroupRequest
utils.CopyStructFields(&node, v)
}
log.NewInfo(req.OperationID, "GetGroupMembersInfo rpc return ", resp)
return &resp, nil
} }
func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (*pbGroup.GetGroupsInfoResp, error) { func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (*pbGroup.GetGroupsInfoResp, error) {
log.NewInfo(req.OperationID, "GetGroupsInfo args ", req.String()) log.NewInfo(req.OperationID, "GetGroupsInfo args ", req.String())
groupsInfoList := make([]*open_im_sdk.GroupInfo, 0) groupsInfoList := make([]*open_im_sdk.GroupInfo, 0)
for _, groupID := range req.GroupIDList { for _, groupID := range req.GroupIDList {
groupInfoFromMysql, err := im_mysql_model.FindGroupInfoByGroupId(groupID) groupInfoFromMysql, err := im_mysql_model.GetGroupInfoByGroupID(groupID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", err.Error(), groupID) log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", err.Error(), groupID)
continue continue
@ -439,17 +452,6 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
chat.ApplicationProcessedNotification(req) chat.ApplicationProcessedNotification(req)
if req.HandleResult == 1 { if req.HandleResult == 1 {
chat.MemberEnterNotification(req) chat.MemberEnterNotification(req)
//if req.ToUserID == "0" {
// err = db.DB.AddGroupMember(req.GroupID, req.FromUserID)
// if err != nil {
// log.NewError(req.OperationID, "AddGroupMember failed ", err.Error(), req.GroupID, req.FromUserID)
// }
//} else {
// err = db.DB.AddGroupMember(req.GroupID, req.ToUserID)
// if err != nil {
// log.NewError(req.OperationID, "AddGroupMember failed ", err.Error(), req.GroupID, req.ToUserID)
// }
//}
} }
log.NewInfo(req.OperationID, "rpc GroupApplicationResponse return ") log.NewInfo(req.OperationID, "rpc GroupApplicationResponse return ")
@ -458,26 +460,23 @@ 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)
applicationUserInfo, err := im_mysql_model.FindUserByUID(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
} }
_, err = im_mysql_model.FindGroupRequestUserInfoByGroupIDAndUid(req.GroupID, req.OpUserID) var groupRequest imdb.GroupRequest
if err == nil { utils.CopyStructFields(&groupRequest, req)
err = im_mysql_model.DelGroupRequest(req.GroupID, req.OpUserID, "0") err = imdb.UpdateGroupRequest(groupRequest)
} if err != nil {
log.NewError(req.OperationID, "UpdateGroupRequest ", err.Error(), groupRequest)
if err = im_mysql_model.InsertIntoGroupRequest(req.GroupID, req.OpUserID, "0", req.ReqMessage, applicationUserInfo.Nickname, applicationUserInfo.FaceUrl); err != nil {
log.NewError(req.OperationID, "InsertIntoGroupRequest ", err.Error(), req.GroupID, req.OpUserID, "0", req.ReqMessage, applicationUserInfo.Nickname, applicationUserInfo.FaceUrl)
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
} }
memberList, err := im_mysql_model.FindGroupMemberListByGroupIdAndFilterInfo(req.GroupID, constant.GroupOwner) _, err = imdb.GetGroupMemberListByGroupIDAndRoleLevel(req.GroupID, constant.GroupOwner)
if len(memberList) == 0 { if err != nil {
log.NewError(req.OperationID, "FindGroupMemberListByGroupIdAndFilterInfo failed ", req.GroupID, constant.GroupOwner, err) log.NewError(req.OperationID, "GetGroupMemberListByGroupIDAndRoleLevel failed ", err.Error(), req.GroupID, constant.GroupOwner)
return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
} }
@ -490,13 +489,13 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) (*pbGroup.QuitGroupResp, error) { func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) (*pbGroup.QuitGroupResp, error) {
log.NewError("QuitGroup args ", req.String()) log.NewError("QuitGroup args ", req.String())
_, err := im_mysql_model.FindGroupMemberInfoByGroupIdAndUserId(req.GroupID, req.OpUserID) _, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.OpUserID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "FindGroupMemberInfoByGroupIdAndUserId failed", err.Error(), req.GroupID, req.OpUserID) log.NewError(req.OperationID, "FindGroupMemberInfoByGroupIdAndUserId failed", err.Error(), req.GroupID, req.OpUserID)
return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} }
err = im_mysql_model.DeleteGroupMemberByGroupIdAndUserId(req.GroupID, req.OpUserID) err = imdb.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, req.OpUserID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "DeleteGroupMemberByGroupIdAndUserId failed ", err.Error(), req.GroupID, req.OpUserID) log.NewError(req.OperationID, "DeleteGroupMemberByGroupIdAndUserId failed ", err.Error(), req.GroupID, req.OpUserID)
return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
@ -517,13 +516,13 @@ func hasAccess(req *pbGroup.SetGroupInfoReq) bool {
if utils.IsContain(req.OpUserID, config.Config.Manager.AppManagerUid) { if utils.IsContain(req.OpUserID, config.Config.Manager.AppManagerUid) {
return true return true
} }
groupUserInfo, err := im_mysql_model.FindGroupMemberInfoByGroupIdAndUserId(req.GroupInfo.GroupID, req.OpUserID) groupUserInfo, err := im_mysql_model.GetGroupMemberInfoByGroupIDAndUserID(req.GroupInfo.GroupID, req.OpUserID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "FindGroupMemberInfoByGroupIdAndUserId failed, ", err.Error(), req.GroupInfo.GroupID, req.OpUserID) log.NewError(req.OperationID, "FindGroupMemberInfoByGroupIdAndUserId failed, ", err.Error(), req.GroupInfo.GroupID, req.OpUserID)
return false return false
} }
if groupUserInfo.AdministratorLevel == constant.OrdinaryMember { if groupUserInfo.RoleLevel == constant.OrdinaryMember {
return true return true
} }
} }
@ -535,9 +534,9 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
} }
group, err := im_mysql_model.FindGroupInfoByGroupId(req.GroupInfo.GroupID) group, err := im_mysql_model.GetGroupInfoByGroupID(req.GroupInfo.GroupID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "FindGroupInfoByGroupId failed, ", err.Error(), req.GroupInfo.GroupID) log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", err.Error(), req.GroupInfo.GroupID)
return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
} }
@ -556,15 +555,18 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
changedType = changedType | (1 << 3) changedType = changedType | (1 << 3)
} }
//only administrators can set group information //only administrators can set group information
if err = im_mysql_model.SetGroupInfo(req.GroupInfo.GroupID, req.GroupInfo.GroupName, req.GroupInfo.Introduction, req.GroupInfo.Notification, req.GroupInfo.FaceUrl, ""); err != nil { var groupInfo imdb.Group
return &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil utils.CopyStructFields(&groupInfo, req.GroupInfo)
err = imdb.SetGroupInfo(groupInfo)
if err != nil {
return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
} }
if changedType != 0 { if changedType != 0 {
chat.GroupInfoChangedNotification(req.OperationID, req.OpUserID, req.GroupInfo.GroupID, changedType) chat.GroupInfoChangedNotification(req.OperationID, req.OpUserID, req.GroupInfo.GroupID, changedType)
} }
log.NewInfo("SetGroupInfo rpc return ") log.NewInfo("SetGroupInfo rpc return ", pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}})
return &pbGroup.CommonResp{}, nil return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}}, nil
} }
func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.TransferGroupOwnerReq) (*pbGroup.TransferGroupOwnerResp, error) { func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.TransferGroupOwnerReq) (*pbGroup.TransferGroupOwnerResp, error) {

1
pkg/base_info/public_struct.go
Unescape View File

@ -16,7 +16,6 @@ type UserInfo struct {
Ex string `json:"ex" binding:"omitempty,max=1024"` Ex string `json:"ex" binding:"omitempty,max=1024"`
} }
//c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
func SetErrCodeMsg(c *gin.Context, status int) *CommResp { func SetErrCodeMsg(c *gin.Context, status int) *CommResp {
resp := CommResp{ErrCode: int32(status), ErrMsg: http.StatusText(status)} resp := CommResp{ErrCode: int32(status), ErrMsg: http.StatusText(status)}
c.JSON(status, resp) c.JSON(status, resp)

1
pkg/base_info/user_api_struct.go
Unescape View File

@ -22,7 +22,6 @@ type GetUserInfoReq struct {
OperationID string `json:"operationID" binding:"required"` OperationID string `json:"operationID" binding:"required"`
UserIDList []string `json:"userIDList" binding:"required"` UserIDList []string `json:"userIDList" binding:"required"`
} }
type GetUserInfoResp struct { type GetUserInfoResp struct {
CommResp CommResp
UserInfoList []*open_im_sdk.UserInfo `json:"data"` UserInfoList []*open_im_sdk.UserInfo `json:"data"`

4
pkg/common/db/mysql_model/im_mysql_model/friend_model.go
Unescape View File

@ -20,7 +20,7 @@ func InsertToFriend(toInsertFollow *Friend) error {
return nil return nil
} }
func FindFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend, error) { func GetFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend, error) {
dbConn, err := db.DB.MysqlDB.DefaultGormDB() dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil { if err != nil {
return nil, err return nil, err
@ -33,7 +33,7 @@ func FindFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend
return &friend, err return &friend, err
} }
func FindUserInfoFromFriend(OwnerUserID string) ([]Friend, error) { func GetUserInfoFromFriend(OwnerUserID string) ([]Friend, error) {
dbConn, err := db.DB.MysqlDB.DefaultGormDB() dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil { if err != nil {
return nil, err return nil, err

4
pkg/common/db/mysql_model/im_mysql_model/friend_request_model.go
Unescape View File

@ -45,7 +45,7 @@ func GetSendFriendApplicationListByUserID(FromUserID string) ([]FriendRequest, e
} }
//reqId apply to add userId already //reqId apply to add userId already
func FindFriendApplicationByBothUserID(FromUserId, ToUserID string) (*FriendRequest, error) { func GetFriendApplicationByBothUserID(FromUserId, ToUserID string) (*FriendRequest, error) {
dbConn, err := db.DB.MysqlDB.DefaultGormDB() dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil { if err != nil {
return nil, err return nil, err
@ -58,7 +58,7 @@ func FindFriendApplicationByBothUserID(FromUserId, ToUserID string) (*FriendRequ
return &friendRequest, nil return &friendRequest, nil
} }
func UpdateFriendApplication(friendRequest FriendRequest) error { func UpdateFriendApplication(friendRequest *FriendRequest) error {
dbConn, err := db.DB.MysqlDB.DefaultGormDB() dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil { if err != nil {
return err return err

5
pkg/common/db/mysql_model/im_mysql_model/group_member_model.go
Unescape View File

@ -21,6 +21,7 @@ func InsertIntoGroupMember(toInsertInfo GroupMember) error {
if err != nil { if err != nil {
return err return err
} }
toInsertInfo.JoinSource = time.Now()
err = dbConn.Table("group_member").Create(toInsertInfo).Error err = dbConn.Table("group_member").Create(toInsertInfo).Error
if err != nil { if err != nil {
return err return err
@ -54,13 +55,13 @@ func GetGroupMemberListByGroupID(groupID string) ([]GroupMember, error) {
return groupMemberList, nil return groupMemberList, nil
} }
func GetGroupMemberListByGroupIDAndFilter(groupID string, filter int32) ([]GroupMember, error) { func GetGroupMemberListByGroupIDAndRoleLevel(groupID string, roleLevel int32) ([]GroupMember, error) {
dbConn, err := db.DB.MysqlDB.DefaultGormDB() dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil { if err != nil {
return nil, err return nil, err
} }
var groupMemberList []GroupMember var groupMemberList []GroupMember
err = dbConn.Table("group_member").Where("group_id=? and role_level=?", groupID, filter).Find(&groupMemberList).Error err = dbConn.Table("group_member").Where("group_id=? and role_level=?", groupID, role_level).Find(&groupMemberList).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }

1
pkg/common/db/mysql_model/im_mysql_model/group_model.go
Unescape View File

@ -2,7 +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" "Open_IM/pkg/proto/group"
"errors" "errors"
"time" "time"

Write Preview
Loading…
Cancel
Save