IM/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2026-05-09 03:25:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

tidy code

Browse Source
This commit is contained in:
wenxu12345
2021-12-27 16:48:05 +08:00
parent 3d4e0a0479
commit e439ef4ddd
26 changed files with 1421 additions and 1899 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/rpc/auth/auth.go
+100
View File
@@ -0,0 +1,100 @@
package auth
import (
"Open_IM/pkg/common/constant"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbAuth "Open_IM/pkg/proto/auth"
"Open_IM/pkg/utils"
"context"
"net"
"strconv"
"strings"
"Open_IM/pkg/common/config"
"google.golang.org/grpc"
)
func (rpc *rpcAuth) UserRegister(_ context.Context, req *pbAuth.UserRegisterReq) (*pbAuth.UserRegisterResp, error) {
log.NewInfo(req.OperationID, "UserRegister args ", req.String())
var user imdb.User
utils.CopyStructFields(&user, req.UserInfo)
err := imdb.UserRegister(user)
if err != nil {
log.NewError(req.OperationID, "UserRegister failed ", err.Error(), user)
return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
log.NewInfo(req.OperationID, "rpc UserRegister return")
return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{}}, nil
}
func (rpc *rpcAuth) UserToken(_ context.Context, req *pbAuth.UserTokenReq) (*pbAuth.UserTokenResp, error) {
log.NewInfo(req.OperationID, "UserToken args ", req.String())
_, err := imdb.GetUserByUserID(req.FromUserID)
if err != nil {
log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), req.FromUserID)
return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
tokens, expTime, err := token_verify.CreateToken(req.FromUserID, req.Platform)
if err != nil {
log.NewError(req.OperationID, "CreateToken failed ", err.Error(), req.FromUserID, req.Platform)
return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
log.NewInfo(req.OperationID, "rpc UserToken return ")
return &pbAuth.UserTokenResp{Token: tokens, ExpiredTime: expTime}, nil
}
type rpcAuth struct {
rpcPort int
rpcRegisterName string
etcdSchema string
etcdAddr []string
}
func NewRpcAuthServer(port int) *rpcAuth {
log.NewPrivateLog("auth")
return &rpcAuth{
rpcPort: port,
rpcRegisterName: config.Config.RpcRegisterName.OpenImAuthName,
etcdSchema: config.Config.Etcd.EtcdSchema,
etcdAddr: config.Config.Etcd.EtcdAddr,
}
}
func (rpc *rpcAuth) Run() {
log.NewInfo("0", "rpc auth start...")
address := utils.ServerIP + ":" + strconv.Itoa(rpc.rpcPort)
listener, err := net.Listen("tcp", address)
if err != nil {
log.NewError("0", "listen network failed ", err.Error(), address)
return
}
log.NewInfo("0", "listen network success, ", address, listener)
//grpc server
srv := grpc.NewServer()
defer srv.GracefulStop()
//service registers with etcd
pbAuth.RegisterAuthServer(srv, rpc)
err = getcdv3.RegisterEtcd(rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName, 10)
if err != nil {
log.NewError("0", "RegisterEtcd failed ", err.Error(),
rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName)
return
}
log.NewInfo("0", "RegisterAuthServer ok ", rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName)
err = srv.Serve(listener)
if err != nil {
log.NewError("0", "Serve failed ", err.Error())
return
}
log.NewInfo("0", "rpc auth ok")
}
internal/rpc/auth/rpcAuth.go
-62
View File
@@ -1,62 +0,0 @@
package auth
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbAuth "Open_IM/pkg/proto/auth"
"Open_IM/pkg/utils"
"google.golang.org/grpc"
"net"
"strconv"
"strings"
)
type rpcAuth struct {
rpcPort int
rpcRegisterName string
etcdSchema string
etcdAddr []string
}
func NewRpcAuthServer(port int) *rpcAuth {
log.NewPrivateLog("auth")
return &rpcAuth{
rpcPort: port,
rpcRegisterName: config.Config.RpcRegisterName.OpenImAuthName,
etcdSchema: config.Config.Etcd.EtcdSchema,
etcdAddr: config.Config.Etcd.EtcdAddr,
}
}
func (rpc *rpcAuth) Run() {
log.Info("", "", "rpc get_token init...")
address := utils.ServerIP + ":" + strconv.Itoa(rpc.rpcPort)
listener, err := net.Listen("tcp", address)
if err != nil {
log.Error("", "", "listen network failed, err = %s, address = %s", err.Error(), address)
return
}
log.Info("", "", "listen network success, address = %s", address)
//grpc server
srv := grpc.NewServer()
defer srv.GracefulStop()
//service registers with etcd
pbAuth.RegisterAuthServer(srv, rpc)
err = getcdv3.RegisterEtcd(rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName, 10)
if err != nil {
log.Error("", "", "register rpc get_token to etcd failed, err = %s", err.Error())
return
}
err = srv.Serve(listener)
if err != nil {
log.Info("", "", "rpc get_token fail, err = %s", err.Error())
return
}
log.Info("", "", "rpc get_token init success")
}
internal/rpc/auth/user_register.go
-20
View File
@@ -1,20 +0,0 @@
package auth
import (
"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
pbAuth "Open_IM/pkg/proto/auth"
"context"
)
func (rpc *rpcAuth) UserRegister(_ context.Context, pb *pbAuth.UserRegisterReq) (*pbAuth.UserRegisterResp, error) {
log.Info("", "", "rpc user_register start, [data: %s]", pb.String())
if err := im_mysql_model.UserRegister(pb); err != nil {
log.Error("", "", "rpc user_register error, [data: %s] [err: %s]", pb.String(), err.Error())
return &pbAuth.UserRegisterResp{Success: false}, err
}
log.Info("", "", "rpc user_register success return")
return &pbAuth.UserRegisterResp{Success: true}, nil
}
internal/rpc/auth/user_token.go
-29
View File
@@ -1,29 +0,0 @@
package auth
import (
"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
pbAuth "Open_IM/pkg/proto/auth"
"context"
)
func (rpc *rpcAuth) UserToken(_ context.Context, pb *pbAuth.UserTokenReq) (*pbAuth.UserTokenResp, error) {
log.Info("", "", "rpc user_token call start..., [pbTokenReq: %s]", pb.String())
_, err := im_mysql_model.FindUserByUID(pb.UID)
if err != nil {
log.Error("", "", "rpc user_token call..., im_mysql_model.AppServerFindFromUserByUserID fail [uid: %s] [err: %s]", pb.UID, err.Error())
return &pbAuth.UserTokenResp{ErrCode: 500, ErrMsg: err.Error()}, err
}
log.Info("", "", "rpc user_token call..., im_mysql_model.AppServerFindFromUserByUserID")
tokens, expTime, err := token_verify.CreateToken(pb.UID, pb.Platform)
if err != nil {
log.Error("", "", "rpc user_token call..., utils.CreateToken fail [uid: %s] [err: %s]", pb.UID, err.Error())
return &pbAuth.UserTokenResp{ErrCode: 500, ErrMsg: err.Error()}, err
}
log.Info("", "", "rpc user_token success return, [uid: %s] [tokens: %s]", pb.UID, tokens)
return &pbAuth.UserTokenResp{Token: tokens, ExpiredTime: expTime}, nil
}
internal/rpc/group/group.go
+38 -42
View File
@@ -423,51 +423,37 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) {
log.NewInfo(req.OperationID, "GroupApplicationResponse args ", req.String())
reply, err := imdb.GroupApplicationResponse(req)
groupRequest := imdb.GroupRequest{}
groupRequest.UserID = req.FromUserID
groupRequest.GroupID = req.GroupID
groupRequest.HandledTime = time.Now()
groupRequest.HandleResult = req.HandleResult
groupRequest.HandleUserID = req.OpUserID
groupRequest.HandledMsg = req.HandledMsg
err := imdb.UpdateGroupRequest(groupRequest)
if err != nil {
log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), req.String())
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: 702, ErrMsg: err.Error()}}, nil
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
chat.ApplicationProcessedNotification(req)
if req.HandleResult == 1 {
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)
}
}
}
if req.ToUserID == "0" {
//group, err := imdb.FindGroupInfoByGroupId(req.GroupID)
//if err != nil {
// log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", req.GroupID)
// return reply, nil
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)
// }
//}
//member, err := imdb.FindGroupMemberInfoByGroupIdAndUserId(req.GroupID, req.OpUserID)
//if err != nil {
// log.NewError(req.OperationID, "FindGroupMemberInfoByGroupIdAndUserId failed ", req.GroupID, req.OpUserID)
// return reply, nil
//}
chat.ApplicationProcessedNotification(req)
if req.HandleResult == 1 {
// entrantUser, err := imdb.FindGroupMemberInfoByGroupIdAndUserId(req.GroupID, req.FromUserID)
// if err != nil {
// log.NewError(req.OperationID, "FindGroupMemberInfoByGroupIdAndUserId failed ", err.Error(), req.GroupID, req.FromUserID)
// return reply, nil
// }
chat.MemberEnterNotification(req)
}
} else {
log.NewError(req.OperationID, "args failed ", req.String())
}
log.NewInfo(req.OperationID, "rpc GroupApplicationResponse return ", reply)
return reply, nil
log.NewInfo(req.OperationID, "rpc GroupApplicationResponse return ")
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{}}, nil
}
func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) {
@@ -584,13 +570,23 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.TransferGroupOwnerReq) (*pbGroup.TransferGroupOwnerResp, error) {
log.NewInfo(req.OperationID, "TransferGroupOwner ", req.String())
reply, err := im_mysql_model.TransferGroupOwner(req)
if req.OldOwnerUserID == req.NewOwnerUserID {
log.NewError(req.OperationID, "same owner ", req.String())
return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}}, nil
}
groupMemberInfo := imdb.GroupMember{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: 0}
err := imdb.UpdateGroupMemberInfo(groupMemberInfo)
if err != nil {
return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
groupMemberInfo = imdb.GroupMember{GroupID: req.GroupID, UserID: req.NewOwnerUserID, RoleLevel: 1}
err = imdb.UpdateGroupMemberInfo(groupMemberInfo)
if err != nil {
log.NewError("TransferGroupOwner ", req.String())
return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
changedType := int32(1) << 4
chat.GroupInfoChangedNotification(req.OperationID, req.OpUserID, req.GroupID, changedType)
log.NewInfo("TransferGroupOwner rpc return ", reply.String())
return reply, nil
return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
}
internal/rpc/msg/send_msg.go
+7 -16
View File
@@ -792,19 +792,19 @@ func FriendDeletedNotification(req *pbFriend.DeleteFriendReq) {
// PublicUserInfo OpUser = 2;
// uint64 OperationTime = 3;
//}
func FriendInfoChangedNotification(req *pbFriend.SetFriendCommentReq) {
func FriendInfoChangedNotification(operationID, opUserID, fromUserID, toUserID string) {
var n NotificationMsg
n.SendID = req.CommID.FromUserID
n.RecvID = req.CommID.ToUserID
n.SendID = fromUserID
n.RecvID = toUserID
n.ContentType = constant.FriendInfoChangedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.CommID.OperationID
n.OperationID = operationID
var FriendInfoChangedTips open_im_sdk.FriendInfoChangedTips
FriendInfoChangedTips.FromToUserID.FromUserID = req.CommID.FromUserID
FriendInfoChangedTips.FromToUserID.ToUserID = req.CommID.ToUserID
fromUserNickname, toUserNickname := getFromToUserNickname(req.CommID.OperationID, req.CommID.FromUserID, req.CommID.ToUserID)
FriendInfoChangedTips.FromToUserID.FromUserID = fromUserID
FriendInfoChangedTips.FromToUserID.ToUserID = toUserID
fromUserNickname, toUserNickname := getFromToUserNickname(operationID, fromUserID, toUserID)
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(FriendInfoChangedTips)
tips.DefaultTips = fromUserNickname + " FriendDeletedNotification " + toUserNickname
@@ -812,15 +812,6 @@ func FriendInfoChangedNotification(req *pbFriend.SetFriendCommentReq) {
Notification(&n, true)
}
//message BlackAddedTips{
// BlackInfo Black = 1;
//}
//message BlackInfo{
// PublicUserInfo OwnerUser = 1;
// string Remark = 2;
// uint64 CreateTime = 3;
// PublicUserInfo BlackUser = 4;
//}
func BlackAddedNotification(req *pbFriend.AddBlacklistReq) {
var n NotificationMsg
n.SendID = req.CommID.FromUserID
internal/rpc/user/conversation.go
-59
View File
@@ -1,59 +0,0 @@
package user
import (
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/log"
pbUser "Open_IM/pkg/proto/user"
"context"
)
func (s *userServer) SetReceiveMessageOpt(ctx context.Context, req *pbUser.SetReceiveMessageOptReq) (*pbUser.SetReceiveMessageOptResp, error) {
m := make(map[string]int, len(req.ConversationId))
for _, v := range req.ConversationId {
m[v] = int(req.Opt)
}
err := db.DB.SetMultiConversationMsgOpt(req.UId, m)
if err != nil {
log.NewError(req.OperationID, "SetMultiConversationMsgOpt failed ", err.Error(), req)
return &pbUser.SetReceiveMessageOptResp{ErrCode: constant.DatabaseError, ErrMsg: err.Error()}, nil
}
var resp pbUser.SetReceiveMessageOptResp
resp.ErrCode = 0
for _, v := range req.ConversationId {
resp.OptResult = append(resp.OptResult, &pbUser.OptResult{ConversationId: v, Result: 0})
}
log.NewInfo(req.OperationID, "SetReceiveMessageOpt req, resp ", req, resp)
return &resp, nil
}
func (s *userServer) GetReceiveMessageOpt(ctx context.Context, req *pbUser.GetReceiveMessageOptReq) (*pbUser.GetReceiveMessageOptResp, error) {
m, err := db.DB.GetMultiConversationMsgOpt(req.UId, req.ConversationId)
if err != nil {
log.NewError(req.OperationID, "GetMultiConversationMsgOpt failed ", err.Error(), req)
return &pbUser.GetReceiveMessageOptResp{ErrCode: constant.DatabaseError, ErrMsg: err.Error()}, nil
}
var resp pbUser.GetReceiveMessageOptResp
resp.ErrCode = 0
for k, v := range m {
resp.ConversationOptResult = append(resp.ConversationOptResult, &pbUser.OptResult{ConversationId: k, Result: int32(v)})
}
log.NewInfo(req.OperationID, "GetReceiveMessageOpt, req, resp", req, resp)
return &resp, nil
}
func (s *userServer) GetAllConversationMsgOpt(ctx context.Context, req *pbUser.GetAllConversationMsgOptReq) (*pbUser.GetAllConversationMsgOptResp, error) {
m, err := db.DB.GetAllConversationMsgOpt(req.UId)
if err != nil {
log.NewError(req.OperationID, "GetAllConversationMsgOpt failed ", err.Error(), req)
return &pbUser.GetAllConversationMsgOptResp{ErrCode: constant.DatabaseError, ErrMsg: err.Error()}, nil
}
var resp pbUser.GetAllConversationMsgOptResp
resp.ErrCode = 0
for k, v := range m {
resp.ConversationOptResult = append(resp.ConversationOptResult, &pbUser.OptResult{ConversationId: k, Result: int32(v)})
}
log.NewInfo(req.OperationID, "GetAllConversationMsgOpt, req, resp", req, resp)
return &resp, nil
}
internal/rpc/user/get_user_info.go
-90
View File
@@ -1,90 +0,0 @@
package user
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbUser "Open_IM/pkg/proto/user"
"Open_IM/pkg/utils"
"context"
"google.golang.org/grpc"
"net"
"strconv"
"strings"
)
type userServer struct {
rpcPort int
rpcRegisterName string
etcdSchema 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() {
log.Info("", "", "rpc user init....")
ip := utils.ServerIP
registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
//listener network
listener, err := net.Listen("tcp", registerAddress)
if err != nil {
log.InfoByArgs("listen network failed,err=%s", err.Error())
return
}
log.Info("", "", "listen network success, address = %s", registerAddress)
defer listener.Close()
//grpc server
srv := grpc.NewServer()
defer srv.GracefulStop()
//Service registers with etcd
pbUser.RegisterUserServer(srv, s)
err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
if err != nil {
log.ErrorByArgs("register rpc token to etcd failed,err=%s", err.Error())
return
}
err = srv.Serve(listener)
if err != nil {
log.ErrorByArgs("listen token failed,err=%s", err.Error())
return
}
log.Info("", "", "rpc token init success")
}
func (s *userServer) GetUserInfo(ctx context.Context, req *pbUser.GetUserInfoReq) (*pbUser.GetUserInfoResp, error) {
log.InfoByKv("rpc get_user_info is server", req.OperationID)
var userInfoList []*pbUser.UserInfo
//Obtain user information according to userID
if len(req.UserIDList) > 0 {
for _, userID := range req.UserIDList {
var userInfo pbUser.UserInfo
user, err := im_mysql_model.FindUserByUID(userID)
if err != nil {
log.ErrorByKv("search userinfo failed", req.OperationID, "userID", userID, "err=%s", err.Error())
continue
}
utils.CopyStructFields(&userInfo, user)
userInfoList = append(userInfoList, &userInfo)
}
} else {
return &pbUser.GetUserInfoResp{ErrorCode: 999, ErrorMsg: "uidList is nil"}, nil
}
log.InfoByKv("rpc get userInfo return success", req.OperationID, "token", req.Token)
return &pbUser.GetUserInfoResp{
ErrorCode: 0,
ErrorMsg: "",
Data: userInfoList,
}, nil
}
internal/rpc/user/internal_service/get_user_info_to_client.go
-16
View File
@@ -1,16 +0,0 @@
package internal_service
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbUser "Open_IM/pkg/proto/user"
"context"
"strings"
)
func GetUserInfoClient(req *pbUser.GetUserInfoReq) (*pbUser.GetUserInfoResp, error) {
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
client := pbUser.NewUserClient(etcdConn)
RpcResp, err := client.GetUserInfo(context.Background(), req)
return RpcResp, err
}
internal/rpc/user/management_user.go
-96
View File
@@ -1,96 +0,0 @@
/*
** description("").
** copyright('open-im,www.open-im.io').
** author("fg,Gordon@tuoyun.net").
** time(2021/9/15 10:28).
*/
package user
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
pbUser "Open_IM/pkg/proto/user"
"Open_IM/pkg/utils"
"context"
)
func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq) (*pbUser.DeleteUsersResp, error) {
log.InfoByKv("rpc DeleteUsers arrived server", req.OperationID, "args", req.String())
var resp pbUser.DeleteUsersResp
var common pbUser.CommonResp
c, err := token_verify.ParseToken(req.Token)
if err != nil {
log.ErrorByKv("parse token failed", req.OperationID, "err", err.Error())
return &pbUser.DeleteUsersResp{CommonResp: &pbUser.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: err.Error()}, FailedUidList: req.DeleteUidList}, nil
}
if !utils.IsContain(c.UID, config.Config.Manager.AppManagerUid) {
log.ErrorByKv(" Authentication failed", req.OperationID, "args", c)
return &pbUser.DeleteUsersResp{CommonResp: &pbUser.CommonResp{ErrorCode: 401, ErrorMsg: "not authorized"}, FailedUidList: req.DeleteUidList}, nil
}
for _, uid := range req.DeleteUidList {
err = im_mysql_model.UserDelete(uid)
if err != nil {
common.ErrorCode = 201
common.ErrorMsg = "some uid deleted failed"
resp.FailedUidList = append(resp.FailedUidList, uid)
}
}
resp.CommonResp = &common
return &resp, nil
}
func (s *userServer) GetAllUsersUid(_ context.Context, req *pbUser.GetAllUsersUidReq) (*pbUser.GetAllUsersUidResp, error) {
log.InfoByKv("rpc GetAllUsersUid arrived server", req.OperationID, "args", req.String())
c, err := token_verify.ParseToken(req.Token)
if err != nil {
log.InfoByKv("parse token failed", req.OperationID, "err", err.Error())
return &pbUser.GetAllUsersUidResp{CommonResp: &pbUser.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: err.Error()}}, nil
}
if !utils.IsContain(c.UID, config.Config.Manager.AppManagerUid) {
log.ErrorByKv(" Authentication failed", req.OperationID, "args", c)
return &pbUser.GetAllUsersUidResp{CommonResp: &pbUser.CommonResp{ErrorCode: 401, ErrorMsg: "not authorized"}}, nil
}
uidList, err := im_mysql_model.SelectAllUID()
if err != nil {
log.ErrorByKv("db get failed", req.OperationID, "err", err.Error())
return &pbUser.GetAllUsersUidResp{CommonResp: &pbUser.CommonResp{ErrorCode: constant.ErrMysql.ErrCode, ErrorMsg: err.Error()}}, nil
} else {
return &pbUser.GetAllUsersUidResp{CommonResp: &pbUser.CommonResp{ErrorCode: 0, ErrorMsg: ""}, UidList: uidList}, nil
}
}
func (s *userServer) AccountCheck(_ context.Context, req *pbUser.AccountCheckReq) (*pbUser.AccountCheckResp, error) {
log.InfoByKv("rpc AccountCheck arrived server", req.OperationID, "args", req.String())
c, err := token_verify.ParseToken(req.Token)
if err != nil {
log.InfoByKv("parse token failed", req.OperationID, "err", err.Error())
return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: err.Error()}}, nil
}
if !utils.IsContain(c.UID, config.Config.Manager.AppManagerUid) {
log.ErrorByKv(" Authentication failed", req.OperationID, "args", c)
return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrorCode: 401, ErrorMsg: "not authorized"}}, nil
}
uidList, err := im_mysql_model.SelectSomeUID(req.UidList)
if err != nil {
log.ErrorByKv("db get SelectSomeUID failed", req.OperationID, "err", err.Error())
return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrorCode: constant.ErrMysql.ErrCode, ErrorMsg: err.Error()}}, nil
} else {
var r []*pbUser.AccountCheckResp_SingleUserStatus
for _, v := range req.UidList {
temp := new(pbUser.AccountCheckResp_SingleUserStatus)
temp.UserID = v
if utils.IsContain(v, uidList) {
temp.AccountStatus = constant.Registered
} else {
temp.AccountStatus = constant.UnRegistered
}
r = append(r, temp)
}
return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrorCode: 0, ErrorMsg: ""}, Result: r}, nil
}
}
internal/rpc/user/update_user_info.go
-85
View File
@@ -1,85 +0,0 @@
package user
import (
"Open_IM/internal/push/logic"
chat "Open_IM/internal/rpc/msg"
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbChat "Open_IM/pkg/proto/chat"
pbFriend "Open_IM/pkg/proto/friend"
pbUser "Open_IM/pkg/proto/user"
"Open_IM/pkg/utils"
"context"
"strings"
)
func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserInfoReq) (*pbUser.CommonResp, error) {
log.Info(req.Token, req.OperationID, "rpc modify user is server,args=%s", req.String())
claims, err := token_verify.ParseToken(req.Token)
if err != nil {
log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error())
return &pbUser.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: err.Error()}, nil
}
ownerUid := ""
//if claims.UID == config.Config.AppManagerUid {
if utils.IsContain(claims.UID, config.Config.Manager.AppManagerUid) {
ownerUid = req.Uid
} else {
ownerUid = claims.UID
}
err = im_mysql_model.UpDateUserInfo(ownerUid, req.Name, req.Icon, req.Mobile, req.Birth, req.Email, req.Ex, req.Gender)
if err != nil {
log.Error(req.Token, req.OperationID, "update user some attribute failed,err=%s", err.Error())
return &pbUser.CommonResp{ErrorCode: constant.ErrModifyUserInfo.ErrCode, ErrorMsg: constant.ErrModifyUserInfo.ErrMsg}, nil
}
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
client := pbFriend.NewFriendClient(etcdConn)
newReq := &pbFriend.GetFriendListReq{
OperationID: req.OperationID,
Token: req.Token,
}
RpcResp, err := client.GetFriendList(context.Background(), newReq)
if err != nil {
log.ErrorByKv("get friend list rpc server failed", req.OperationID, "err", err.Error(), "req", req.String())
return &pbUser.CommonResp{}, nil
}
if RpcResp.ErrCode != 0 {
log.ErrorByKv("get friend list rpc server failed", req.OperationID, "err", err.Error(), "req", req.String())
return &pbUser.CommonResp{}, nil
}
self, err := im_mysql_model.FindUserByUID(ownerUid)
if err != nil {
log.ErrorByKv("get self info failed", req.OperationID, "err", err.Error(), "req", req.String())
return &pbUser.CommonResp{}, nil
}
var name, faceUrl string
if self != nil {
name, faceUrl = self.Name, self.Icon
}
chat.SelfInfoUpdatedNotification(req.OperationID, req.Uid)
for _, v := range RpcResp.Data {
logic.SendMsgByWS(&pbChat.WSToMsgSvrChatMsg{
SendID: ownerUid,
RecvID: v.Uid,
SenderNickName: name,
SenderFaceURL: faceUrl,
Content: ownerUid + "'s info has changed",
SendTime: utils.GetCurrentTimestampByNano(),
MsgFrom: constant.SysMsgType,
ContentType: constant.SetSelfInfoTip,
SessionType: constant.SingleChatType,
OperationID: req.OperationID,
Token: req.Token,
})
}
return &pbUser.CommonResp{}, nil
}
internal/rpc/user/user.go
+238
View File
@@ -0,0 +1,238 @@
package user
import (
chat "Open_IM/internal/rpc/msg"
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbFriend "Open_IM/pkg/proto/friend"
pbUser "Open_IM/pkg/proto/user"
"Open_IM/pkg/utils"
"context"
"google.golang.org/grpc"
"net"
"strconv"
"strings"
sdkws "Open_IM/pkg/proto/sdk_ws"
)
type userServer struct {
rpcPort int
rpcRegisterName string
etcdSchema string
etcdAddr []string
}
func (s *userServer) Run() {
log.NewInfo("0", "", "rpc user start...")
ip := utils.ServerIP
registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
//listener network
listener, err := net.Listen("tcp", registerAddress)
if err != nil {
log.NewError("0", "listen network failed ", err.Error(), registerAddress)
return
}
log.NewInfo("0", "listen network success, address ", registerAddress, listener)
defer listener.Close()
//grpc server
srv := grpc.NewServer()
defer srv.GracefulStop()
//Service registers with etcd
pbUser.RegisterUserServer(srv, s)
err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
if err != nil {
log.NewError("0", "RegisterEtcd failed ", err.Error(), s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName)
return
}
err = srv.Serve(listener)
if err != nil {
log.NewError("0", "Serve failed ", err.Error())
return
}
log.NewInfo("0", "rpc user success")
}
func (s *userServer) GetUserInfo(ctx context.Context, req *pbUser.GetUserInfoReq) (*pbUser.GetUserInfoResp, error) {
log.NewInfo(req.OperationID, "GetUserInfo args ", req.String())
var userInfoList []*sdkws.UserInfo
if len(req.UserIDList) > 0 {
for _, userID := range req.UserIDList {
var userInfo sdkws.UserInfo
user, err := imdb.GetUserByUserID(userID)
if err != nil {
log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), userID)
continue
}
utils.CopyStructFields(&userInfo, user)
userInfoList = append(userInfoList, &userInfo)
}
} else {
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})
return &pbUser.GetUserInfoResp{CommonResp: &pbUser.CommonResp{}, UserInfoList:userInfoList}, nil
}
func (s *userServer) SetReceiveMessageOpt(ctx context.Context, req *pbUser.SetReceiveMessageOptReq) (*pbUser.SetReceiveMessageOptResp, error) {
log.NewInfo(req.OperationID, "SetReceiveMessageOpt args ", req.String())
m := make(map[string]int, len(req.ConversationIDList))
for _, v := range req.ConversationIDList {
m[v] = int(req.Opt)
}
err := db.DB.SetMultiConversationMsgOpt(req.FromUserID, m)
if err != nil {
log.NewError(req.OperationID, "SetMultiConversationMsgOpt failed ", err.Error(), req)
return &pbUser.SetReceiveMessageOptResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
resp := pbUser.SetReceiveMessageOptResp{CommonResp: &pbUser.CommonResp{}}
for _, v := range req.ConversationIDList {
resp.OptResultList = append(resp.OptResultList, &pbUser.OptResult{ConversationId: v, Result: 0})
}
log.NewInfo(req.OperationID, "SetReceiveMessageOpt rpc return ", resp.String())
return &resp, nil
}
func (s *userServer) GetReceiveMessageOpt(ctx context.Context, req *pbUser.GetReceiveMessageOptReq) (*pbUser.GetReceiveMessageOptResp, error) {
log.NewInfo(req.OperationID, "GetReceiveMessageOpt args ", req.String())
m, err := db.DB.GetMultiConversationMsgOpt(req.FromUserID, req.ConversationId)
if err != nil {
log.NewError(req.OperationID, "GetMultiConversationMsgOpt failed ", err.Error(), req.FromUserID, req.ConversationId)
return &pbUser.GetReceiveMessageOptResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
resp := pbUser.GetReceiveMessageOptResp{CommonResp: &pbUser.CommonResp{}}
for k, v := range m {
resp.ConversationOptResultList = append(resp.ConversationOptResultList, &pbUser.OptResult{ConversationId: k, Result: int32(v)})
}
log.NewInfo(req.OperationID, "GetReceiveMessageOpt rpc return ", resp.String())
return &resp, nil
}
func (s *userServer) GetAllConversationMsgOpt(ctx context.Context, req *pbUser.GetAllConversationMsgOptReq) (*pbUser.GetAllConversationMsgOptResp, error) {
log.NewInfo(req.OperationID, "GetAllConversationMsgOpt args ", req.String())
m, err := db.DB.GetAllConversationMsgOpt(req.FromUserId)
if err != nil {
log.NewError(req.OperationID, "GetAllConversationMsgOpt failed ", err.Error(), req.FromUserId)
return &pbUser.GetAllConversationMsgOptResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
resp := pbUser.GetAllConversationMsgOptResp{CommonResp: &pbUser.CommonResp{}}
for k, v := range m {
resp.ConversationOptResultList = append(resp.ConversationOptResultList, &pbUser.OptResult{ConversationId: k, Result: int32(v)})
}
log.NewInfo(req.OperationID, "GetAllConversationMsgOpt rpc return ", resp.String())
return &resp, nil
}
func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq) (*pbUser.DeleteUsersResp, error) {
log.NewInfo(req.OperationID, "DeleteUsers args ", req.String())
if token_verify.IsMangerUserID(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
}
var common pbUser.CommonResp
resp := pbUser.DeleteUsersResp{CommonResp: &common}
for _, userID := range req.DeleteUserIDList {
err := imdb.DeleteUser(userID)
if err != nil {
common.ErrCode = 201
common.ErrMsg = "some uid deleted failed"
resp.FailedUserIDList = append(resp.FailedUserIDList, userID)
}
}
log.NewInfo(req.OperationID, "DeleteUsers rpc return ", resp.String())
return &resp, nil
}
func (s *userServer) GetAllUserID(_ context.Context, req *pbUser.GetAllUserIDReq) (*pbUser.GetAllUserIDResp, error) {
log.NewInfo(req.OperationID,"GetAllUserID args ", req.String())
if token_verify.IsMangerUserID(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
}
uidList, err := imdb.SelectAllUserID()
if err != nil {
log.NewError(req.OperationID, "SelectAllUserID false ", err.Error())
return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} else {
log.NewInfo(req.OperationID, "GetAllUserID rpc return ", pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{}, UserIDList: uidList})
return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{}, UserIDList: uidList}, nil
}
}
func (s *userServer) AccountCheck(_ context.Context, req *pbUser.AccountCheckReq) (*pbUser.AccountCheckResp, error) {
log.NewInfo(req.OperationID,"AccountCheck args ", req.String())
if token_verify.IsMangerUserID(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
}
uidList, err := imdb.SelectSomeUserID(req.CheckUserIDList)
if err != nil {
log.NewError(req.OperationID, "SelectSomeUserID failed ", err.Error(), req.CheckUserIDList)
return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} else {
var r []*pbUser.AccountCheckResp_SingleUserStatus
for _, v := range req.CheckUserIDList {
temp := new(pbUser.AccountCheckResp_SingleUserStatus)
temp.UserID = v
if utils.IsContain(v, uidList) {
temp.AccountStatus = constant.Registered
} else {
temp.AccountStatus = constant.UnRegistered
}
r = append(r, temp)
}
resp := pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrCode: 0, ErrMsg: ""}, ResultList: r}
log.NewInfo(req.OperationID, "AccountCheck rpc return ", resp.String())
return &resp, nil
}
}
func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserInfoReq) (*pbUser.UpdateUserInfoResp, error) {
log.NewInfo(req.OperationID,"UpdateUserInfo args ", req.String())
if !token_verify.CheckAccess(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
}
var user imdb.User
utils.CopyStructFields(&user, req.UserInfo)
err := imdb.UpdateUserInfo(user)
if err != nil {
log.NewError(req.OperationID, "UpdateUserInfo failed ", err.Error(), user)
return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
client := pbFriend.NewFriendClient(etcdConn)
newReq := &pbFriend.GetFriendListReq{
CommID: &pbFriend.CommID{OperationID: req.OperationID, FromUserID: req.UserInfo.UserID, OpUserID: req.OpUserID}
}
RpcResp, err := client.GetFriendList(context.Background(), newReq)
if err != nil {
log.NewError(req.OperationID, "GetFriendList failed ", err.Error(), newReq)
return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
}
for _, v := range RpcResp.FriendInfoList{
chat.FriendInfoChangedNotification(req.OperationID, req.OpUserID, req.UserInfo.UserID, v.FriendUser.UserID)
}
chat.SelfInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID)
return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
}