From e7e3b6dd15126a47616eaccb7aae4a90df843498 Mon Sep 17 00:00:00 2001 From: Gordon <1432970085@qq.com> Date: Thu, 25 Nov 2021 14:12:52 +0800 Subject: [PATCH] multi terminal kick eachOther --- config/config.yaml | 5 +- internal/api/chat/get_max_min_seq.go | 6 +- internal/api/chat/pull_msg.go | 10 +- .../api/group/get_group_applicationList.go | 4 +- .../api/group/group_application_response.go | 4 +- internal/api/group/transfer_group_owner.go | 4 +- internal/api/manage/management_chat.go | 3 +- .../third/tencent_cloud_storage_credential.go | 3 +- internal/msg_gateway/gate/logic.go | 2 +- internal/msg_gateway/gate/rpc_server.go | 10 +- internal/msg_gateway/gate/ws_server.go | 87 ++++++++-- internal/push/jpush/requestBody/platform.go | 6 +- internal/push/logic/init.go | 4 +- internal/push/logic/push_to_client.go | 2 +- internal/rpc/auth/user_token.go | 4 +- internal/rpc/friend/add_blacklist.go | 10 +- internal/rpc/friend/add_friend.go | 19 +-- internal/rpc/friend/add_friend_response.go | 10 +- internal/rpc/friend/delete_friend.go | 10 +- internal/rpc/friend/get_blacklist.go | 10 +- internal/rpc/friend/get_firends_info.go | 7 +- internal/rpc/friend/get_friend_apply_list.go | 16 +- internal/rpc/friend/get_friend_list.go | 9 +- internal/rpc/friend/is_friend.go | 7 +- internal/rpc/friend/remove_blacklist.go | 10 +- internal/rpc/friend/set_friend_comment.go | 10 +- internal/rpc/group/create_group.go | 13 +- internal/rpc/group/get_groups_info.go | 8 +- internal/rpc/group/group.go | 37 ++--- internal/rpc/group/join_group.go | 12 +- internal/rpc/group/quit_group.go | 14 +- internal/rpc/group/set_group_info.go | 13 +- internal/rpc/user/management_user.go | 12 +- internal/rpc/user/update_user_info.go | 7 +- internal/utils/jwt_token_test.go | 29 ++-- .../utils/platform_number_id_to_name_test.go | 54 +++---- pkg/common/config/config.go | 8 +- pkg/common/constant/constant.go | 16 ++ pkg/common/{config => constant}/error.go | 25 ++- .../constant}/platform_number_id_to_name.go | 6 +- pkg/common/db/redisModel.go | 49 +++--- .../multi_terminal_login.go | 142 ++++++++-------- pkg/common/token_verify/jwt_token.go | 144 +++++++++++++++++ pkg/utils/jwt_token.go | 153 ------------------ pkg/utils/strings.go | 3 + 45 files changed, 553 insertions(+), 464 deletions(-) rename pkg/common/{config => constant}/error.go (73%) rename pkg/{utils => common/constant}/platform_number_id_to_name.go (94%) create mode 100644 pkg/common/token_verify/jwt_token.go delete mode 100644 pkg/utils/jwt_token.go diff --git a/config/config.yaml b/config/config.yaml index 5ac564915..4da435a3c 100644 --- a/config/config.yaml +++ b/config/config.yaml @@ -130,10 +130,7 @@ manager: secret: tuoyun -multiloginpolicy: - onlyOneTerminalAccess: false - mobileAndPCTerminalAccessButOtherTerminalKickEachOther: true - allTerminalAccess: false +multiloginpolicy: 1 #token config tokenpolicy: diff --git a/internal/api/chat/get_max_min_seq.go b/internal/api/chat/get_max_min_seq.go index 06db8fd9d..7103cae4a 100644 --- a/internal/api/chat/get_max_min_seq.go +++ b/internal/api/chat/get_max_min_seq.go @@ -3,9 +3,9 @@ package apiChat import ( "Open_IM/pkg/common/config" "Open_IM/pkg/common/log" + "Open_IM/pkg/common/token_verify" "Open_IM/pkg/grpc-etcdv3/getcdv3" pbMsg "Open_IM/pkg/proto/chat" - "Open_IM/pkg/utils" "context" "github.com/gin-gonic/gin" "net/http" @@ -27,8 +27,8 @@ func UserGetSeq(c *gin.Context) { } token := c.Request.Header.Get("token") - if !utils.VerifyToken(token, params.SendID) { - c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"}) + if ok, err := token_verify.VerifyToken(token, params.SendID); !ok { + c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()}) return } pbData := pbMsg.GetMaxAndMinSeqReq{} diff --git a/internal/api/chat/pull_msg.go b/internal/api/chat/pull_msg.go index 4fb90b61f..46b568284 100644 --- a/internal/api/chat/pull_msg.go +++ b/internal/api/chat/pull_msg.go @@ -3,9 +3,9 @@ package apiChat import ( "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/chat" - "Open_IM/pkg/utils" "context" "github.com/gin-gonic/gin" "net/http" @@ -30,8 +30,8 @@ func UserPullMsg(c *gin.Context) { } token := c.Request.Header.Get("token") - if !utils.VerifyToken(token, params.SendID) { - c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"}) + if ok, err := token_verify.VerifyToken(token, params.SendID); !ok { + c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()}) return } pbData := pbChat.PullMessageReq{} @@ -86,8 +86,8 @@ func UserPullMsgBySeqList(c *gin.Context) { } token := c.Request.Header.Get("token") - if !utils.VerifyToken(token, params.SendID) { - c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"}) + if ok, err := token_verify.VerifyToken(token, params.SendID); !ok { + c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()}) return } pbData := pbChat.PullMessageBySeqListReq{} diff --git a/internal/api/group/get_group_applicationList.go b/internal/api/group/get_group_applicationList.go index faceb921e..a9fa1c73c 100644 --- a/internal/api/group/get_group_applicationList.go +++ b/internal/api/group/get_group_applicationList.go @@ -3,9 +3,9 @@ package group import ( "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/group" - "Open_IM/pkg/utils" "context" "github.com/gin-gonic/gin" "net/http" @@ -56,7 +56,7 @@ func GetGroupApplicationList(c *gin.Context) { pbData := newUserRegisterReq(¶ms) token := c.Request.Header.Get("token") - if claims, err := utils.ParseToken(token); err != nil { + if claims, err := token_verify.ParseToken(token); err != nil { c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"}) return } else { diff --git a/internal/api/group/group_application_response.go b/internal/api/group/group_application_response.go index 70dd966eb..ea38d45a1 100644 --- a/internal/api/group/group_application_response.go +++ b/internal/api/group/group_application_response.go @@ -3,9 +3,9 @@ package group import ( "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/group" - "Open_IM/pkg/utils" "context" "github.com/gin-gonic/gin" "net/http" @@ -63,7 +63,7 @@ func ApplicationGroupResponse(c *gin.Context) { pbData := newGroupApplicationResponse(¶ms) token := c.Request.Header.Get("token") - if claims, err := utils.ParseToken(token); err != nil { + if claims, err := token_verify.ParseToken(token); err != nil { c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"}) return } else { diff --git a/internal/api/group/transfer_group_owner.go b/internal/api/group/transfer_group_owner.go index f7baaba3f..d8cc9d662 100644 --- a/internal/api/group/transfer_group_owner.go +++ b/internal/api/group/transfer_group_owner.go @@ -3,9 +3,9 @@ package group import ( "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/group" - "Open_IM/pkg/utils" "context" "github.com/gin-gonic/gin" "net/http" @@ -41,7 +41,7 @@ func TransferGroupOwner(c *gin.Context) { pbData := newTransferGroupOwnerReq(¶ms) token := c.Request.Header.Get("token") - if claims, err := utils.ParseToken(token); err != nil { + if claims, err := token_verify.ParseToken(token); err != nil { c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"}) return } else { diff --git a/internal/api/manage/management_chat.go b/internal/api/manage/management_chat.go index 3d4487aa5..ba056eba1 100644 --- a/internal/api/manage/management_chat.go +++ b/internal/api/manage/management_chat.go @@ -10,6 +10,7 @@ import ( "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/utils" @@ -125,7 +126,7 @@ func ManagementSendMsg(c *gin.Context) { } token := c.Request.Header.Get("token") - claims, err := utils.ParseToken(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": ""}) diff --git a/internal/api/third/tencent_cloud_storage_credential.go b/internal/api/third/tencent_cloud_storage_credential.go index af68d8fd8..d6814bc93 100644 --- a/internal/api/third/tencent_cloud_storage_credential.go +++ b/internal/api/third/tencent_cloud_storage_credential.go @@ -2,6 +2,7 @@ package apiThird import ( "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" log2 "Open_IM/pkg/common/log" "github.com/gin-gonic/gin" sts "github.com/tencentyun/qcloud-cos-sts-sdk/go" @@ -70,7 +71,7 @@ func TencentCloudStorageCredential(c *gin.Context) { if err != nil { log2.Error(c.Request.Header.Get("token"), c.PostForm("optionID"), "api TencentUpLoadCredential cli.GetCredential err = %s", err.Error()) c.JSON(http.StatusOK, gin.H{ - "errCode": config.ErrTencentCredential.ErrCode, + "errCode": constant.ErrTencentCredential.ErrCode, "errMsg": err.Error(), "bucket": "", "region": "", diff --git a/internal/msg_gateway/gate/logic.go b/internal/msg_gateway/gate/logic.go index 9eadb529e..9b449d4b2 100644 --- a/internal/msg_gateway/gate/logic.go +++ b/internal/msg_gateway/gate/logic.go @@ -30,7 +30,7 @@ func (ws *WServer) msgParse(conn *UserConn, binaryMsg []byte) { dec := gob.NewDecoder(b) err := dec.Decode(&m) if err != nil { - log.ErrorByKv("ws json Unmarshal err", "", "err", err.Error()) + log.ErrorByKv("ws Decode err", "", "err", err.Error()) ws.sendErrMsg(conn, 200, err.Error(), constant.WSDataError, "", "") err = conn.Close() if err != nil { diff --git a/internal/msg_gateway/gate/rpc_server.go b/internal/msg_gateway/gate/rpc_server.go index 468d0f5dd..f87e8a4ff 100644 --- a/internal/msg_gateway/gate/rpc_server.go +++ b/internal/msg_gateway/gate/rpc_server.go @@ -103,14 +103,14 @@ func (r *RPCServer) MsgToUser(_ context.Context, in *pbRelay.MsgToUserReq) (*pbR temp := &pbRelay.SingleMsgToUser{ ResultCode: resultCode, RecvID: UIDAndPID[0], - RecvPlatFormID: utils.PlatformNameToID(UIDAndPID[1]), + RecvPlatFormID: constant.PlatformNameToID(UIDAndPID[1]), } resp = append(resp, temp) } else { temp := &pbRelay.SingleMsgToUser{ ResultCode: -1, RecvID: UIDAndPID[0], - RecvPlatFormID: utils.PlatformNameToID(UIDAndPID[1]), + RecvPlatFormID: constant.PlatformNameToID(UIDAndPID[1]), } resp = append(resp, temp) } @@ -127,7 +127,7 @@ func sendMsgToUser(conn *UserConn, bMsg []byte, in *pbRelay.MsgToUserReq, RecvPl err := ws.writeMsg(conn, websocket.BinaryMessage, bMsg) if err != nil { log.ErrorByKv("PushMsgToUser is failed By Ws", "", "Addr", conn.RemoteAddr().String(), - "error", err, "senderPlatform", utils.PlatformIDToName(in.PlatformID), "recvPlatform", RecvPlatForm, "args", in.String(), "recvID", RecvID) + "error", err, "senderPlatform", constant.PlatformIDToName(in.PlatformID), "recvPlatform", RecvPlatForm, "args", in.String(), "recvID", RecvID) ResultCode = -2 return ResultCode } else { @@ -138,8 +138,8 @@ func sendMsgToUser(conn *UserConn, bMsg []byte, in *pbRelay.MsgToUserReq, RecvPl } func genUidPlatformArray(uid string) (array []string) { - for i := 1; i <= utils.LinuxPlatformID; i++ { - array = append(array, uid+" "+utils.PlatformIDToName(int32(i))) + for i := 1; i <= constant.LinuxPlatformID; i++ { + array = append(array, uid+" "+constant.PlatformIDToName(int32(i))) } return array } diff --git a/internal/msg_gateway/gate/ws_server.go b/internal/msg_gateway/gate/ws_server.go index 8faa748a9..0f9c74d36 100644 --- a/internal/msg_gateway/gate/ws_server.go +++ b/internal/msg_gateway/gate/ws_server.go @@ -2,8 +2,13 @@ package gate import ( "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/db" "Open_IM/pkg/common/log" + "Open_IM/pkg/common/token_verify" "Open_IM/pkg/utils" + "bytes" + "encoding/gob" "github.com/gorilla/websocket" "net/http" "sync" @@ -53,10 +58,10 @@ func (ws *WServer) wsHandler(w http.ResponseWriter, r *http.Request) { } else { //Connection mapping relationship, //userID+" "+platformID->conn - SendID := query["sendID"][0] + " " + utils.PlatformIDToName(int32(utils.StringToInt64(query["platformID"][0]))) + //Initialize a lock for each user newConn := &UserConn{conn, new(sync.Mutex)} - ws.addUserConn(SendID, newConn) + ws.addUserConn(query["sendID"][0], int32(utils.StringToInt64(query["platformID"][0])), newConn, query["token"][0]) go ws.readMsg(newConn) } } @@ -86,20 +91,66 @@ func (ws *WServer) writeMsg(conn *UserConn, a int, msg []byte) error { return conn.WriteMessage(a, msg) } -func (ws *WServer) addUserConn(uid string, conn *UserConn) { +func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int32, newConn *UserConn, token string) { + switch config.Config.MultiLoginPolicy { + case constant.AllLoginButSameTermKick: + if oldConn, ok := ws.wsUserToConn[genMapKey(uid, platformID)]; ok { + ws.sendKickMsg(oldConn, newConn) + m, err := db.DB.GetTokenMapByUidPid(uid, utils.Int32ToString(platformID)) + if err != nil { + log.NewError("", "get token from redis err", err.Error()) + return + } + if m == nil { + log.NewError("", "get token from redis err", "m is nil") + return + } + for k, _ := range m { + if k != token { + m[k] = constant.KickedToken + } + } + err = db.DB.SetTokenMapByUidPid(uid, utils.Int32ToString(platformID), m) + if err != nil { + log.NewError("", "SetTokenMapByUidPid err", err.Error()) + return + } + err = oldConn.Close() + delete(ws.wsConnToUser, oldConn) + if err != nil { + log.NewError("", "conn close err", err.Error()) + } + } + + case constant.SingleTerminalLogin: + case constant.WebAndOther: + } +} +func (ws *WServer) sendKickMsg(oldConn, newConn *UserConn) { + mReply := Resp{ + ReqIdentifier: constant.WSKickOnlineMsg, + ErrCode: constant.ErrTokenInvalid.ErrCode, + ErrMsg: constant.ErrTokenInvalid.ErrMsg, + } + var b bytes.Buffer + enc := gob.NewEncoder(&b) + err := enc.Encode(mReply) + if err != nil { + log.NewError(mReply.OperationID, mReply.ReqIdentifier, mReply.ErrCode, mReply.ErrMsg, "Encode Msg error", oldConn.RemoteAddr().String(), newConn.RemoteAddr().String(), err.Error()) + return + } + err = ws.writeMsg(oldConn, websocket.BinaryMessage, b.Bytes()) + if err != nil { + log.NewError(mReply.OperationID, mReply.ReqIdentifier, mReply.ErrCode, mReply.ErrMsg, "WS WriteMsg error", oldConn.RemoteAddr().String(), newConn.RemoteAddr().String(), err.Error()) + } +} +func (ws *WServer) addUserConn(uid string, platformID int32, conn *UserConn, token string) { + key := genMapKey(uid, platformID) rwLock.Lock() defer rwLock.Unlock() - if oldConn, ok := ws.wsUserToConn[uid]; ok { - err := oldConn.Close() - delete(ws.wsConnToUser, oldConn) - if err != nil { - log.ErrorByKv("close err", "", "uid", uid, "conn", conn) - } - } else { - log.InfoByKv("this user is first login", "", "uid", uid) - } - ws.wsConnToUser[conn] = uid - ws.wsUserToConn[uid] = conn + ws.MultiTerminalLoginChecker(uid, platformID, conn, token) + ws.wsConnToUser[conn] = key + ws.wsUserToConn[key] = conn log.WarnByKv("WS Add operation", "", "wsUser added", ws.wsUserToConn, "uid", uid, "online_num", len(ws.wsUserToConn)) } @@ -146,10 +197,11 @@ func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request) bool { status := http.StatusUnauthorized query := r.URL.Query() if len(query["token"]) != 0 && len(query["sendID"]) != 0 && len(query["platformID"]) != 0 { - if !utils.VerifyToken(query["token"][0], query["sendID"][0]) { + if ok, err := token_verify.VerifyToken(query["token"][0], query["sendID"][0]); !ok { + e := err.(*constant.ErrInfo) log.ErrorByKv("Token verify failed", "", "query", query) w.Header().Set("Sec-Websocket-Version", "13") - http.Error(w, http.StatusText(status), status) + http.Error(w, e.ErrMsg, int(e.ErrCode)) return false } else { log.InfoByKv("Connection Authentication Success", "", "token", query["token"][0], "userID", query["sendID"][0]) @@ -163,3 +215,6 @@ func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request) bool { } } +func genMapKey(uid string, platformID int32) string { + return uid + " " + constant.PlatformIDToName(platformID) +} diff --git a/internal/push/jpush/requestBody/platform.go b/internal/push/jpush/requestBody/platform.go index 47a08fc57..0f9d243cf 100644 --- a/internal/push/jpush/requestBody/platform.go +++ b/internal/push/jpush/requestBody/platform.go @@ -1,7 +1,7 @@ package requestBody import ( - "Open_IM/pkg/utils" + "Open_IM/pkg/common/constant" "errors" ) @@ -53,9 +53,9 @@ func (p *Platform) Set(os string) error { } func (p *Platform) SetPlatform(platform string) error { switch platform { - case utils.AndroidPlatformStr: + case constant.AndroidPlatformStr: return p.SetAndroid() - case utils.IOSPlatformStr: + case constant.IOSPlatformStr: return p.SetIOS() default: return errors.New("platform err") diff --git a/internal/push/logic/init.go b/internal/push/logic/init.go index 9fba41bdd..b8941cc6f 100644 --- a/internal/push/logic/init.go +++ b/internal/push/logic/init.go @@ -8,9 +8,9 @@ package logic import ( "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" "Open_IM/pkg/common/kafka" "Open_IM/pkg/common/log" - "Open_IM/pkg/utils" ) var ( @@ -24,7 +24,7 @@ func Init(rpcPort int) { log.NewPrivateLog(config.Config.ModuleName.PushName) rpcServer.Init(rpcPort) pushCh.Init() - pushTerminal = []int32{utils.IOSPlatformID, utils.AndroidPlatformID} + pushTerminal = []int32{constant.IOSPlatformID, constant.AndroidPlatformID} } func init() { producer = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.Ws2mschat.Topic) diff --git a/internal/push/logic/push_to_client.go b/internal/push/logic/push_to_client.go index 9a8effee8..21916a68d 100644 --- a/internal/push/logic/push_to_client.go +++ b/internal/push/logic/push_to_client.go @@ -97,7 +97,7 @@ func MsgToUser(sendPbData *pbRelay.MsgToUserReq, OfflineInfo, Options string) { default: content = constant.ContentType2PushContent[constant.Common] } - pushResult, err := push.JGAccountListPush(UIDList, content, jsonCustomContent, utils.PlatformIDToName(t)) + pushResult, err := push.JGAccountListPush(UIDList, content, jsonCustomContent, constant.PlatformIDToName(t)) if err != nil { log.NewError(sendPbData.OperationID, "offline push error", sendPbData.String(), err.Error(), t) } else { diff --git a/internal/rpc/auth/user_token.go b/internal/rpc/auth/user_token.go index 6ebb2900b..a1455b237 100644 --- a/internal/rpc/auth/user_token.go +++ b/internal/rpc/auth/user_token.go @@ -3,8 +3,8 @@ 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" - "Open_IM/pkg/utils" "context" ) @@ -18,7 +18,7 @@ func (rpc *rpcAuth) UserToken(_ context.Context, pb *pbAuth.UserTokenReq) (*pbAu } log.Info("", "", "rpc user_token call..., im_mysql_model.AppServerFindFromUserByUserID") - tokens, expTime, err := utils.CreateToken(pb.UID, pb.Platform) + 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 diff --git a/internal/rpc/friend/add_blacklist.go b/internal/rpc/friend/add_blacklist.go index f490a2934..07fa2d032 100644 --- a/internal/rpc/friend/add_blacklist.go +++ b/internal/rpc/friend/add_blacklist.go @@ -2,8 +2,10 @@ package friend 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" pbFriend "Open_IM/pkg/proto/friend" "Open_IM/pkg/utils" "context" @@ -12,10 +14,10 @@ import ( func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlacklistReq) (*pbFriend.CommonResp, error) { log.Info(req.Token, req.OperationID, "rpc add blacklist is server,args=%s", req.String()) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } isMagagerFlag := 0 @@ -29,7 +31,7 @@ func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlackl err = im_mysql_model.InsertInToUserBlackList(claims.UID, req.Uid) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,Failed to add blacklist", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrMysql.ErrCode, ErrorMsg: config.ErrMysql.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrMysql.ErrCode, ErrorMsg: constant.ErrMysql.ErrMsg}, nil } log.Info(req.Token, req.OperationID, "rpc add blacklist success return,uid=%s", req.Uid) return &pbFriend.CommonResp{}, nil @@ -38,7 +40,7 @@ func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlackl err = im_mysql_model.InsertInToUserBlackList(req.OwnerUid, req.Uid) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,Failed to add blacklist", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrMysql.ErrCode, ErrorMsg: config.ErrMysql.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrMysql.ErrCode, ErrorMsg: constant.ErrMysql.ErrMsg}, nil } log.Info(req.Token, req.OperationID, "rpc add blacklist success return,uid=%s", req.Uid) return &pbFriend.CommonResp{}, nil diff --git a/internal/rpc/friend/add_friend.go b/internal/rpc/friend/add_friend.go index bda0de95c..cc10572b5 100644 --- a/internal/rpc/friend/add_friend.go +++ b/internal/rpc/friend/add_friend.go @@ -7,6 +7,7 @@ import ( "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" pbChat "Open_IM/pkg/proto/chat" pbFriend "Open_IM/pkg/proto/friend" "Open_IM/pkg/utils" @@ -16,22 +17,22 @@ import ( func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq) (*pbFriend.CommonResp, error) { log.Info(req.Token, req.OperationID, "rpc add friend is server,userid=%s", req.Uid) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } //Cannot add non-existent users if _, err = im_mysql_model.FindUserByUID(req.Uid); err != nil { log.Error(req.Token, req.OperationID, "this user not exists,cant not add friend") - return &pbFriend.CommonResp{ErrorCode: config.ErrAddFriend.ErrCode, ErrorMsg: config.ErrSearchUserInfo.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrAddFriend.ErrCode, ErrorMsg: constant.ErrSearchUserInfo.ErrMsg}, nil } //Establish a latest relationship in the friend request table err = im_mysql_model.ReplaceIntoFriendReq(claims.UID, req.Uid, constant.ApplicationFriendFlag, req.ReqMessage) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,create friend request record failed", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrAddFriend.ErrCode, ErrorMsg: config.ErrAddFriend.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrAddFriend.ErrCode, ErrorMsg: constant.ErrAddFriend.ErrMsg}, nil } log.Info(req.Token, req.OperationID, "rpc add friend is success return,uid=%s", req.Uid) //Push message when add friend successfully @@ -57,23 +58,23 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri var resp pbFriend.ImportFriendResp var c pbFriend.CommonResp //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.NewError(req.OperationID, "parse token failed", err.Error()) - c.ErrorCode = config.ErrAddFriend.ErrCode - c.ErrorMsg = config.ErrParseToken.ErrMsg + c.ErrorCode = constant.ErrAddFriend.ErrCode + c.ErrorMsg = constant.ErrParseToken.ErrMsg return &pbFriend.ImportFriendResp{CommonResp: &c, FailedUidList: req.UidList}, nil } if !utils.IsContain(claims.UID, config.Config.Manager.AppManagerUid) { log.NewError(req.OperationID, "not manager uid", claims.UID) - c.ErrorCode = config.ErrAddFriend.ErrCode + c.ErrorCode = constant.ErrAddFriend.ErrCode c.ErrorMsg = "not authorized" return &pbFriend.ImportFriendResp{CommonResp: &c, FailedUidList: req.UidList}, nil } if _, err = im_mysql_model.FindUserByUID(req.OwnerUid); err != nil { log.NewError(req.OperationID, "this user not exists,cant not add friend", req.OwnerUid) - c.ErrorCode = config.ErrAddFriend.ErrCode + c.ErrorCode = constant.ErrAddFriend.ErrCode c.ErrorMsg = "this user not exists,cant not add friend" return &pbFriend.ImportFriendResp{CommonResp: &c, FailedUidList: req.UidList}, nil } diff --git a/internal/rpc/friend/add_friend_response.go b/internal/rpc/friend/add_friend_response.go index 048110a23..e1e914ffd 100644 --- a/internal/rpc/friend/add_friend_response.go +++ b/internal/rpc/friend/add_friend_response.go @@ -3,10 +3,10 @@ package friend import ( "Open_IM/internal/push/content_struct" "Open_IM/internal/push/logic" - "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" pbChat "Open_IM/pkg/proto/chat" pbFriend "Open_IM/pkg/proto/friend" "Open_IM/pkg/utils" @@ -16,21 +16,21 @@ import ( func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddFriendResponseReq) (*pbFriend.CommonResp, error) { log.Info(req.Token, req.OperationID, "rpc add friend response is server,args=%s", req.String()) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } //Check there application before agreeing or refuse to a friend's application if _, err = im_mysql_model.FindFriendApplyFromFriendReqByUid(req.Uid, claims.UID); err != nil { log.Error(req.Token, req.OperationID, "No such application record") - return &pbFriend.CommonResp{ErrorCode: config.ErrAgreeToAddFriend.ErrCode, ErrorMsg: config.ErrAgreeToAddFriend.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrAgreeToAddFriend.ErrCode, ErrorMsg: constant.ErrAgreeToAddFriend.ErrMsg}, nil } //Change friend request status flag err = im_mysql_model.UpdateFriendRelationshipToFriendReq(req.Uid, claims.UID, req.Flag) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,update friend request table failed", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrMysql.ErrCode, ErrorMsg: config.ErrAgreeToAddFriend.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrMysql.ErrCode, ErrorMsg: constant.ErrAgreeToAddFriend.ErrMsg}, nil } log.Info(req.Token, req.OperationID, "rpc add friend response success return,userid=%s,flag=%d", req.Uid, req.Flag) //Change the status of the friend request form diff --git a/internal/rpc/friend/delete_friend.go b/internal/rpc/friend/delete_friend.go index 2b11988b8..b1db00aa7 100644 --- a/internal/rpc/friend/delete_friend.go +++ b/internal/rpc/friend/delete_friend.go @@ -1,26 +1,26 @@ package friend 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" pbFriend "Open_IM/pkg/proto/friend" - "Open_IM/pkg/utils" "context" ) func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFriendReq) (*pbFriend.CommonResp, error) { log.Info(req.Token, req.OperationID, "rpc delete friend is server,args=%s", req.String()) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } err = im_mysql_model.DeleteSingleFriendInfo(claims.UID, req.Uid) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,delete friend failed", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrMysql.ErrCode, ErrorMsg: config.ErrMysql.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrMysql.ErrCode, ErrorMsg: constant.ErrMysql.ErrMsg}, nil } log.Info(req.Token, req.OperationID, "rpc delete friend success return") return &pbFriend.CommonResp{}, nil diff --git a/internal/rpc/friend/get_blacklist.go b/internal/rpc/friend/get_blacklist.go index 99d57fb25..503e80da6 100644 --- a/internal/rpc/friend/get_blacklist.go +++ b/internal/rpc/friend/get_blacklist.go @@ -1,11 +1,11 @@ package friend 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" pbFriend "Open_IM/pkg/proto/friend" - "Open_IM/pkg/utils" "context" ) @@ -16,15 +16,15 @@ func (s *friendServer) GetBlacklist(ctx context.Context, req *pbFriend.GetBlackl comment string ) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.GetBlacklistResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.GetBlacklistResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } blackListInfo, err := im_mysql_model.GetBlackListByUID(claims.UID) if err != nil { log.Error(req.Token, req.OperationID, "err=%s get blacklist failed", err.Error()) - return &pbFriend.GetBlacklistResp{ErrorCode: config.ErrGetBlackList.ErrCode, ErrorMsg: config.ErrGetBlackList.ErrMsg}, nil + return &pbFriend.GetBlacklistResp{ErrorCode: constant.ErrGetBlackList.ErrCode, ErrorMsg: constant.ErrGetBlackList.ErrMsg}, nil } for _, blackUser := range blackListInfo { var blackUserInfo pbFriend.UserInfo diff --git a/internal/rpc/friend/get_firends_info.go b/internal/rpc/friend/get_firends_info.go index 1aa34a43b..d103889bc 100644 --- a/internal/rpc/friend/get_firends_info.go +++ b/internal/rpc/friend/get_firends_info.go @@ -5,6 +5,7 @@ import ( "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" pbFriend "Open_IM/pkg/proto/friend" "Open_IM/pkg/utils" @@ -71,10 +72,10 @@ func (s *friendServer) GetFriendsInfo(ctx context.Context, req *pbFriend.GetFrie comment string ) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.GetFriendInfoResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.GetFriendInfoResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } friendShip, err := im_mysql_model.FindFriendRelationshipFromFriend(claims.UID, req.Uid) if err == nil { @@ -84,7 +85,7 @@ func (s *friendServer) GetFriendsInfo(ctx context.Context, req *pbFriend.GetFrie friendUserInfo, err := im_mysql_model.FindUserByUID(req.Uid) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,no this user", err.Error()) - return &pbFriend.GetFriendInfoResp{ErrorCode: config.ErrSearchUserInfo.ErrCode, ErrorMsg: config.ErrSearchUserInfo.ErrMsg}, nil + return &pbFriend.GetFriendInfoResp{ErrorCode: constant.ErrSearchUserInfo.ErrCode, ErrorMsg: constant.ErrSearchUserInfo.ErrMsg}, nil } err = im_mysql_model.FindRelationshipFromBlackList(claims.UID, req.Uid) if err == nil { diff --git a/internal/rpc/friend/get_friend_apply_list.go b/internal/rpc/friend/get_friend_apply_list.go index 556576f71..6542d9097 100644 --- a/internal/rpc/friend/get_friend_apply_list.go +++ b/internal/rpc/friend/get_friend_apply_list.go @@ -1,11 +1,11 @@ package friend 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" pbFriend "Open_IM/pkg/proto/friend" - "Open_IM/pkg/utils" "context" "fmt" "strconv" @@ -15,16 +15,16 @@ func (s *friendServer) GetFriendApplyList(ctx context.Context, req *pbFriend.Get log.Info(req.Token, req.OperationID, "rpc get friend apply list is server,args=%s", req.String()) var appleUserList []*pbFriend.ApplyUserInfo //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.GetFriendApplyResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.GetFriendApplyResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } // Find the current user friend applications received ApplyUsersInfo, err := im_mysql_model.FindFriendsApplyFromFriendReq(claims.UID) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,search applyInfo failed", err.Error()) - return &pbFriend.GetFriendApplyResp{ErrorCode: config.ErrMysql.ErrCode, ErrorMsg: config.ErrMysql.ErrMsg}, nil + return &pbFriend.GetFriendApplyResp{ErrorCode: constant.ErrMysql.ErrCode, ErrorMsg: constant.ErrMysql.ErrMsg}, nil } for _, applyUserInfo := range ApplyUsersInfo { var userInfo pbFriend.ApplyUserInfo @@ -57,16 +57,16 @@ func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetFr log.Info(req.Token, req.OperationID, "rpc get self apply list is server,args=%s", req.String()) var selfApplyOtherUserList []*pbFriend.ApplyUserInfo //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.GetFriendApplyResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.GetFriendApplyResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } // Find the self add other userinfo usersInfo, err := im_mysql_model.FindSelfApplyFromFriendReq(claims.UID) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,search self to other user Info failed", err.Error()) - return &pbFriend.GetFriendApplyResp{ErrorCode: config.ErrMysql.ErrCode, ErrorMsg: config.ErrMysql.ErrMsg}, nil + return &pbFriend.GetFriendApplyResp{ErrorCode: constant.ErrMysql.ErrCode, ErrorMsg: constant.ErrMysql.ErrMsg}, nil } for _, selfApplyOtherUserInfo := range usersInfo { var userInfo pbFriend.ApplyUserInfo diff --git a/internal/rpc/friend/get_friend_list.go b/internal/rpc/friend/get_friend_list.go index 0674cdc53..ff3e521ee 100644 --- a/internal/rpc/friend/get_friend_list.go +++ b/internal/rpc/friend/get_friend_list.go @@ -1,12 +1,11 @@ package friend 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" pbFriend "Open_IM/pkg/proto/friend" - "Open_IM/pkg/utils" "context" ) @@ -14,15 +13,15 @@ func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFrien log.Info(req.Token, req.OperationID, "rpc get friend list is server,args=%s", req.String()) var userInfoList []*pbFriend.UserInfo //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.GetFriendListResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.GetFriendListResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } friends, err := im_mysql_model.FindUserInfoFromFriend(claims.UID) if err != nil { log.Error(req.Token, req.OperationID, "err=%s search friendInfo failed", err.Error()) - return &pbFriend.GetFriendListResp{ErrorCode: config.ErrSearchUserInfo.ErrCode, ErrorMsg: config.ErrSearchUserInfo.ErrMsg}, nil + return &pbFriend.GetFriendListResp{ErrorCode: constant.ErrSearchUserInfo.ErrCode, ErrorMsg: constant.ErrSearchUserInfo.ErrMsg}, nil } for _, friendUser := range friends { var friendUserInfo pbFriend.UserInfo diff --git a/internal/rpc/friend/is_friend.go b/internal/rpc/friend/is_friend.go index 3690423e7..d8739b81f 100644 --- a/internal/rpc/friend/is_friend.go +++ b/internal/rpc/friend/is_friend.go @@ -1,12 +1,11 @@ package friend 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" pbFriend "Open_IM/pkg/proto/friend" - "Open_IM/pkg/utils" "context" "fmt" ) @@ -14,10 +13,10 @@ import ( func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq) (*pbFriend.IsFriendResp, error) { log.InfoByArgs("rpc is friend is server,args=%s", req.String()) var isFriend int32 - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.IsFriendResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.IsFriendResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } _, err = im_mysql_model.FindFriendRelationshipFromFriend(claims.UID, req.ReceiveUid) if err == nil { diff --git a/internal/rpc/friend/remove_blacklist.go b/internal/rpc/friend/remove_blacklist.go index af163e86d..f96cbf9b4 100644 --- a/internal/rpc/friend/remove_blacklist.go +++ b/internal/rpc/friend/remove_blacklist.go @@ -1,26 +1,26 @@ package friend 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" pbFriend "Open_IM/pkg/proto/friend" - "Open_IM/pkg/utils" "context" ) func (s *friendServer) RemoveBlacklist(ctx context.Context, req *pbFriend.RemoveBlacklistReq) (*pbFriend.CommonResp, error) { log.Info(req.Token, req.OperationID, "rpc remove blacklist is server,userid=%s", req.Uid) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } err = im_mysql_model.RemoveBlackList(claims.UID, req.Uid) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,remove blacklist failed", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrMysql.ErrCode, ErrorMsg: config.ErrMysql.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrMysql.ErrCode, ErrorMsg: constant.ErrMysql.ErrMsg}, nil } log.Info(req.Token, req.OperationID, "rpc remove blacklist success return,userid=%s", req.Uid) return &pbFriend.CommonResp{}, nil diff --git a/internal/rpc/friend/set_friend_comment.go b/internal/rpc/friend/set_friend_comment.go index 8b7331935..8ddfe1fb9 100644 --- a/internal/rpc/friend/set_friend_comment.go +++ b/internal/rpc/friend/set_friend_comment.go @@ -1,26 +1,26 @@ package friend 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" pbFriend "Open_IM/pkg/proto/friend" - "Open_IM/pkg/utils" "context" ) func (s *friendServer) SetFriendComment(ctx context.Context, req *pbFriend.SetFriendCommentReq) (*pbFriend.CommonResp, error) { log.Info(req.Token, req.OperationID, "rpc set friend comment is server,params=%s", req.String()) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } err = im_mysql_model.UpdateFriendComment(claims.UID, req.Uid, req.Comment) if err != nil { log.Error(req.Token, req.OperationID, "set friend comment failed,err=%s", err.Error()) - return &pbFriend.CommonResp{ErrorCode: config.ErrSetFriendComment.ErrCode, ErrorMsg: config.ErrSetFriendComment.ErrMsg}, nil + return &pbFriend.CommonResp{ErrorCode: constant.ErrSetFriendComment.ErrCode, ErrorMsg: constant.ErrSetFriendComment.ErrMsg}, nil } log.Info(req.Token, req.OperationID, "rpc set friend comment is success return") return &pbFriend.CommonResp{}, nil diff --git a/internal/rpc/group/create_group.go b/internal/rpc/group/create_group.go index b95394efd..35e6616ee 100644 --- a/internal/rpc/group/create_group.go +++ b/internal/rpc/group/create_group.go @@ -8,6 +8,7 @@ import ( "Open_IM/pkg/common/db" "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" pbGroup "Open_IM/pkg/proto/group" @@ -73,17 +74,17 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR groupId string ) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbGroup.CreateGroupResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } //Time stamp + MD5 to generate group chat id groupId = utils.Md5(strconv.FormatInt(time.Now().UnixNano(), 10)) err = im_mysql_model.InsertIntoGroup(groupId, req.GroupName, req.Introduction, req.Notification, req.FaceUrl, req.Ex) if err != nil { log.ErrorByKv("create group chat failed", req.OperationID, "err=%s", err.Error()) - return &pbGroup.CreateGroupResp{ErrorCode: config.ErrCreateGroup.ErrCode, ErrorMsg: config.ErrCreateGroup.ErrMsg}, nil + return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrCreateGroup.ErrCode, ErrorMsg: constant.ErrCreateGroup.ErrMsg}, nil } isMagagerFlag := 0 @@ -98,18 +99,18 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR us, err := im_mysql_model.FindUserByUID(claims.UID) if err != nil { log.Error("", req.OperationID, "find userInfo failed", err.Error()) - return &pbGroup.CreateGroupResp{ErrorCode: config.ErrCreateGroup.ErrCode, ErrorMsg: config.ErrCreateGroup.ErrMsg}, nil + return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrCreateGroup.ErrCode, ErrorMsg: constant.ErrCreateGroup.ErrMsg}, nil } err = im_mysql_model.InsertIntoGroupMember(groupId, claims.UID, us.Name, us.Icon, constant.GroupOwner) if err != nil { log.Error("", req.OperationID, "create group chat failed,err=%s", err.Error()) - return &pbGroup.CreateGroupResp{ErrorCode: config.ErrCreateGroup.ErrCode, ErrorMsg: config.ErrCreateGroup.ErrMsg}, nil + return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrCreateGroup.ErrCode, ErrorMsg: constant.ErrCreateGroup.ErrMsg}, nil } err = db.DB.AddGroupMember(groupId, claims.UID) if err != nil { log.Error("", "", "create mongo group member failed, db.DB.AddGroupMember fail [err: %s]", err.Error()) - return &pbGroup.CreateGroupResp{ErrorCode: config.ErrCreateGroup.ErrCode, ErrorMsg: config.ErrCreateGroup.ErrMsg}, nil + return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrCreateGroup.ErrCode, ErrorMsg: constant.ErrCreateGroup.ErrMsg}, nil } } diff --git a/internal/rpc/group/get_groups_info.go b/internal/rpc/group/get_groups_info.go index 667e3c84f..f0d952e94 100644 --- a/internal/rpc/group/get_groups_info.go +++ b/internal/rpc/group/get_groups_info.go @@ -1,21 +1,21 @@ package group 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" pbGroup "Open_IM/pkg/proto/group" - "Open_IM/pkg/utils" "context" ) func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (*pbGroup.GetGroupsInfoResp, error) { log.Info(req.Token, req.OperationID, "rpc get group info is server,args=%s", req.String()) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbGroup.GetGroupsInfoResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbGroup.GetGroupsInfoResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } log.Info("", req.OperationID, "args:", req.GroupIDList, claims.UID) groupsInfoList := make([]*pbGroup.GroupInfo, 0) diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index d7101680f..15740800f 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -6,6 +6,7 @@ import ( "Open_IM/pkg/common/config" "Open_IM/pkg/common/constant" "Open_IM/pkg/common/db" + "Open_IM/pkg/common/token_verify" pbChat "Open_IM/pkg/proto/chat" "encoding/json" @@ -19,17 +20,17 @@ import ( ) func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJoinedGroupListReq) (*pbGroup.GetJoinedGroupListResp, error) { - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbGroup.GetJoinedGroupListResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbGroup.GetJoinedGroupListResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } log.Info(claims.UID, req.OperationID, "recv req: ", req.String()) joinedGroupList, err := imdb.GetJoinedGroupIdListByMemberId(claims.UID) if err != nil { log.Error(claims.UID, req.OperationID, "GetJoinedGroupIdListByMemberId failed, err: ", err.Error()) - return &pbGroup.GetJoinedGroupListResp{ErrorCode: config.ErrParam.ErrCode, ErrorMsg: config.ErrParam.ErrMsg}, nil + return &pbGroup.GetJoinedGroupListResp{ErrorCode: constant.ErrParam.ErrCode, ErrorMsg: constant.ErrParam.ErrMsg}, nil } var resp pbGroup.GetJoinedGroupListResp @@ -57,23 +58,23 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo } func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) { - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbGroup.InviteUserToGroupResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbGroup.InviteUserToGroupResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } log.Info(claims.UID, req.OperationID, "recv req: ", req.String()) // if !imdb.IsExistGroupMember(req.GroupID, claims.UID) && claims.UID != config.Config.AppManagerUid if !imdb.IsExistGroupMember(req.GroupID, claims.UID) && !utils.IsContain(claims.UID, config.Config.Manager.AppManagerUid) { log.Error(req.Token, req.OperationID, "err= invite user not in group") - return &pbGroup.InviteUserToGroupResp{ErrorCode: config.ErrAccess.ErrCode, ErrorMsg: config.ErrAccess.ErrMsg}, nil + return &pbGroup.InviteUserToGroupResp{ErrorCode: constant.ErrAccess.ErrCode, ErrorMsg: constant.ErrAccess.ErrMsg}, nil } groupInfoFromMysql, err := imdb.FindGroupInfoByGroupId(req.GroupID) if err != nil || groupInfoFromMysql == nil { log.NewError(req.OperationID, "get group info error", req.GroupID, req.UidList) - return &pbGroup.InviteUserToGroupResp{ErrorCode: config.ErrAccess.ErrCode, ErrorMsg: config.ErrAccess.ErrMsg}, nil + return &pbGroup.InviteUserToGroupResp{ErrorCode: constant.ErrAccess.ErrCode, ErrorMsg: constant.ErrAccess.ErrMsg}, nil } // @@ -175,7 +176,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro resp.ErrorCode = 0 memberList, err := imdb.FindGroupMemberListByGroupId(req.GroupID) if err != nil { - resp.ErrorCode = config.ErrDb.ErrCode + resp.ErrorCode = constant.ErrDb.ErrCode resp.ErrorMsg = err.Error() log.NewError(req.OperationID, "FindGroupMemberListByGroupId failed,", err.Error(), req.GroupID) return &resp, nil @@ -196,10 +197,10 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro } func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGroupMemberListReq) (*pbGroup.GetGroupMemberListResp, error) { - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbGroup.GetGroupMemberListResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbGroup.GetGroupMemberListResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } // log.Info(claims.UID, req.OperationID, "recv req: ", req.String()) fmt.Println("req: ", req.GroupID) @@ -207,7 +208,7 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr resp.ErrorCode = 0 memberList, err := imdb.GetGroupMemberByGroupId(req.GroupID, req.Filter, req.NextSeq, 30) if err != nil { - resp.ErrorCode = config.ErrDb.ErrCode + resp.ErrorCode = constant.ErrDb.ErrCode resp.ErrorMsg = err.Error() log.Error(claims.UID, req.OperationID, "GetGroupMemberByGroupId failed, ", err.Error(), "params: ", req.GroupID, req.Filter, req.NextSeq) return &resp, nil @@ -256,17 +257,17 @@ func (c *kickGroupMemberApiReq) ContentToString() string { } func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (*pbGroup.KickGroupMemberResp, error) { - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbGroup.KickGroupMemberResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbGroup.KickGroupMemberResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } log.Info(claims.UID, req.OperationID, "recv req: ", req.String()) ownerList, err := imdb.GetOwnerManagerByGroupId(req.GroupID) if err != nil { log.Error(claims.UID, req.OperationID, req.GroupID, "GetOwnerManagerByGroupId, ", err.Error()) - return &pbGroup.KickGroupMemberResp{ErrorCode: config.ErrParam.ErrCode, ErrorMsg: config.ErrParam.ErrMsg}, nil + return &pbGroup.KickGroupMemberResp{ErrorCode: constant.ErrParam.ErrCode, ErrorMsg: constant.ErrParam.ErrMsg}, nil } //op is group owner? var flag = 0 @@ -285,12 +286,12 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou if flag != 1 { log.Error(claims.UID, req.OperationID, "no access kick") - return &pbGroup.KickGroupMemberResp{ErrorCode: config.ErrAccess.ErrCode, ErrorMsg: config.ErrAccess.ErrMsg}, nil + return &pbGroup.KickGroupMemberResp{ErrorCode: constant.ErrAccess.ErrCode, ErrorMsg: constant.ErrAccess.ErrMsg}, nil } if len(req.UidListInfo) == 0 { log.Error(claims.UID, req.OperationID, "kick list 0") - return &pbGroup.KickGroupMemberResp{ErrorCode: config.ErrParam.ErrCode, ErrorMsg: config.ErrParam.ErrMsg}, nil + return &pbGroup.KickGroupMemberResp{ErrorCode: constant.ErrParam.ErrCode, ErrorMsg: constant.ErrParam.ErrMsg}, nil } //remove var resp pbGroup.KickGroupMemberResp @@ -362,10 +363,10 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou } func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetGroupMembersInfoReq) (*pbGroup.GetGroupMembersInfoResp, error) { - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbGroup.GetGroupMembersInfoResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbGroup.GetGroupMembersInfoResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } log.InfoByKv(claims.UID, req.OperationID, "param: ", req.MemberList) var resp pbGroup.GetGroupMembersInfoResp diff --git a/internal/rpc/group/join_group.go b/internal/rpc/group/join_group.go index 4b1c88c89..0aed0d4e4 100644 --- a/internal/rpc/group/join_group.go +++ b/internal/rpc/group/join_group.go @@ -1,26 +1,26 @@ package group 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" pbGroup "Open_IM/pkg/proto/group" - "Open_IM/pkg/utils" "context" ) func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.CommonResp, error) { log.Info(req.Token, req.OperationID, "rpc join group is server,args=%s", req.String()) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbGroup.CommonResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } applicationUserInfo, err := im_mysql_model.FindUserByUID(claims.UID) if err != nil { log.Error(req.Token, req.OperationID, "No this user,err=%s", err.Error()) - return &pbGroup.CommonResp{ErrorCode: config.ErrSearchUserInfo.ErrCode, ErrorMsg: config.ErrSearchUserInfo.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrSearchUserInfo.ErrCode, ErrorMsg: constant.ErrSearchUserInfo.ErrMsg}, nil } _, err = im_mysql_model.FindGroupRequestUserInfoByGroupIDAndUid(req.GroupID, claims.UID) @@ -32,7 +32,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) if err = im_mysql_model.InsertIntoGroupRequest(req.GroupID, claims.UID, "0", req.Message, applicationUserInfo.Name, applicationUserInfo.Icon); err != nil { log.Error(req.Token, req.OperationID, "Insert into group request failed,er=%s", err.Error()) - return &pbGroup.CommonResp{ErrorCode: config.ErrJoinGroupApplication.ErrCode, ErrorMsg: config.ErrJoinGroupApplication.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrJoinGroupApplication.ErrCode, ErrorMsg: constant.ErrJoinGroupApplication.ErrMsg}, nil } ////Find the the group owner //groupCreatorInfo, err := im_mysql_model.FindGroupMemberListByGroupIdAndFilterInfo(req.GroupID, constant.GroupCreator) diff --git a/internal/rpc/group/quit_group.go b/internal/rpc/group/quit_group.go index 5906832a2..e77a34009 100644 --- a/internal/rpc/group/quit_group.go +++ b/internal/rpc/group/quit_group.go @@ -1,41 +1,41 @@ package group import ( - "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" "Open_IM/pkg/common/db" "Open_IM/pkg/common/db/mysql_model/im_mysql_model" "Open_IM/pkg/common/log" + "Open_IM/pkg/common/token_verify" pbGroup "Open_IM/pkg/proto/group" - "Open_IM/pkg/utils" "context" ) func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) (*pbGroup.CommonResp, error) { log.InfoByArgs("rpc quit group is server,args:", req.String()) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbGroup.CommonResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } log.InfoByKv("args:", req.OperationID, req.GetGroupID(), claims.UID) //Check to see whether there is a user in the group. _, err = im_mysql_model.FindGroupMemberInfoByGroupIdAndUserId(req.GroupID, claims.UID) if err != nil { log.Error(req.Token, req.OperationID, "no such group or you are not in the group,err=%s", err.Error(), req.OperationID, req.GroupID, claims.UID) - return &pbGroup.CommonResp{ErrorCode: config.ErrQuitGroup.ErrCode, ErrorMsg: config.ErrQuitGroup.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrQuitGroup.ErrCode, ErrorMsg: constant.ErrQuitGroup.ErrMsg}, nil } //After the user's verification is successful, user will quit the group chat. err = im_mysql_model.DeleteGroupMemberByGroupIdAndUserId(req.GroupID, claims.UID) if err != nil { log.ErrorByArgs("this user exit the group failed,err=%s", err.Error(), req.OperationID, req.GroupID, claims.UID) - return &pbGroup.CommonResp{ErrorCode: config.ErrQuitGroup.ErrCode, ErrorMsg: config.ErrQuitGroup.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrQuitGroup.ErrCode, ErrorMsg: constant.ErrQuitGroup.ErrMsg}, nil } err = db.DB.DelGroupMember(req.GroupID, claims.UID) if err != nil { log.Error("", "", "delete mongo group member failed, db.DB.DelGroupMember fail [err: %s]", err.Error()) - return &pbGroup.CommonResp{ErrorCode: config.ErrQuitGroup.ErrCode, ErrorMsg: config.ErrQuitGroup.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrQuitGroup.ErrCode, ErrorMsg: constant.ErrQuitGroup.ErrMsg}, nil } ////Push message when quit group chat //jsonInfo, _ := json.Marshal(req) diff --git a/internal/rpc/group/set_group_info.go b/internal/rpc/group/set_group_info.go index 046f8bc4f..3e1f25854 100644 --- a/internal/rpc/group/set_group_info.go +++ b/internal/rpc/group/set_group_info.go @@ -1,12 +1,11 @@ package group 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" pbGroup "Open_IM/pkg/proto/group" - "Open_IM/pkg/utils" "context" ) @@ -14,22 +13,22 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf log.Info(req.Token, req.OperationID, "rpc set group info is server,args=%s", req.String()) //Parse token, to find current user information - claims, err := utils.ParseToken(req.Token) + claims, err := token_verify.ParseToken(req.Token) if err != nil { log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error()) - return &pbGroup.CommonResp{ErrorCode: config.ErrParseToken.ErrCode, ErrorMsg: config.ErrParseToken.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil } groupUserInfo, err := im_mysql_model.FindGroupMemberInfoByGroupIdAndUserId(req.GroupID, claims.UID) if err != nil { log.Error("", req.OperationID, "your are not in the group,can not change this group info,err=%s", err.Error()) - return &pbGroup.CommonResp{ErrorCode: config.ErrSetGroupInfo.ErrCode, ErrorMsg: config.ErrSetGroupInfo.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrSetGroupInfo.ErrCode, ErrorMsg: constant.ErrSetGroupInfo.ErrMsg}, nil } if groupUserInfo.AdministratorLevel == constant.OrdinaryMember { - return &pbGroup.CommonResp{ErrorCode: config.ErrSetGroupInfo.ErrCode, ErrorMsg: config.ErrAccess.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrSetGroupInfo.ErrCode, ErrorMsg: constant.ErrAccess.ErrMsg}, nil } //only administrators can set group information if err = im_mysql_model.SetGroupInfo(req.GroupID, req.GroupName, req.Introduction, req.Notification, req.FaceUrl, ""); err != nil { - return &pbGroup.CommonResp{ErrorCode: config.ErrSetGroupInfo.ErrCode, ErrorMsg: config.ErrSetGroupInfo.ErrMsg}, nil + return &pbGroup.CommonResp{ErrorCode: constant.ErrSetGroupInfo.ErrCode, ErrorMsg: constant.ErrSetGroupInfo.ErrMsg}, nil } ////Push message when set group info //jsonInfo, _ := json.Marshal(req) diff --git a/internal/rpc/user/management_user.go b/internal/rpc/user/management_user.go index 524b98e71..51984b6dc 100644 --- a/internal/rpc/user/management_user.go +++ b/internal/rpc/user/management_user.go @@ -8,8 +8,10 @@ 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" @@ -19,10 +21,10 @@ func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq) log.InfoByKv("rpc DeleteUsers arrived server", req.OperationID, "args", req.String()) var resp pbUser.DeleteUsersResp var common pbUser.CommonResp - c, err := utils.ParseToken(req.Token) + 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: config.ErrParseToken.ErrCode, ErrorMsg: err.Error()}, FailedUidList: req.DeleteUidList}, nil + 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) @@ -43,10 +45,10 @@ func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq) 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 := utils.ParseToken(req.Token) + 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: config.ErrParseToken.ErrCode, ErrorMsg: err.Error()}}, nil + 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) @@ -55,7 +57,7 @@ func (s *userServer) GetAllUsersUid(_ context.Context, req *pbUser.GetAllUsersUi 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: config.ErrMysql.ErrCode, ErrorMsg: err.Error()}}, nil + 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 } diff --git a/internal/rpc/user/update_user_info.go b/internal/rpc/user/update_user_info.go index 14fe9f0db..079cb1b44 100644 --- a/internal/rpc/user/update_user_info.go +++ b/internal/rpc/user/update_user_info.go @@ -6,6 +6,7 @@ import ( "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" @@ -17,10 +18,10 @@ import ( 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 := utils.ParseToken(req.Token) + 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: config.ErrParseToken.ErrCode, ErrorMsg: err.Error()}, nil + return &pbUser.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: err.Error()}, nil } ownerUid := "" @@ -34,7 +35,7 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI 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: config.ErrModifyUserInfo.ErrCode, ErrorMsg: config.ErrModifyUserInfo.ErrMsg}, nil + 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) diff --git a/internal/utils/jwt_token_test.go b/internal/utils/jwt_token_test.go index 5b8cdb607..721df496e 100644 --- a/internal/utils/jwt_token_test.go +++ b/internal/utils/jwt_token_test.go @@ -2,7 +2,8 @@ package utils import ( "Open_IM/pkg/common/config" - "Open_IM/pkg/utils" + "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/token_verify" "testing" "time" @@ -13,7 +14,7 @@ func Test_BuildClaims(t *testing.T) { uid := "1" platform := "PC" ttl := int64(-1) - claim := utils.BuildClaims(uid, platform, ttl) + claim := token_verify.BuildClaims(uid, platform, ttl) now := time.Now().Unix() assert.Equal(t, claim.UID, uid, "uid should equal") @@ -25,7 +26,7 @@ func Test_BuildClaims(t *testing.T) { ttl = int64(60) now = time.Now().Unix() - claim = utils.BuildClaims(uid, platform, ttl) + claim = token_verify.BuildClaims(uid, platform, ttl) // time difference within 1s assert.Equal(t, claim.RegisteredClaims.ExpiresAt, int64(60)+now, "StandardClaims.ExpiresAt should be equal") assert.Equal(t, claim.RegisteredClaims.IssuedAt, now, "StandardClaims.IssuedAt should be equal") @@ -37,7 +38,7 @@ func Test_CreateToken(t *testing.T) { platform := int32(1) now := time.Now().Unix() - tokenString, expiresAt, err := utils.CreateToken(uid, platform) + tokenString, expiresAt, err := token_verify.CreateToken(uid, platform) assert.NotEmpty(t, tokenString) assert.Equal(t, expiresAt, 604800+now) @@ -47,35 +48,35 @@ func Test_CreateToken(t *testing.T) { func Test_VerifyToken(t *testing.T) { uid := "1" platform := int32(1) - tokenString, _, _ := utils.CreateToken(uid, platform) - result := utils.VerifyToken(tokenString, uid) + tokenString, _, _ := token_verify.CreateToken(uid, platform) + result, _ := token_verify.VerifyToken(tokenString, uid) assert.True(t, result) - result = utils.VerifyToken(tokenString, "2") + result, _ = token_verify.VerifyToken(tokenString, "2") assert.False(t, result) } func Test_ParseRedisInterfaceToken(t *testing.T) { uid := "1" platform := int32(1) - tokenString, _, _ := utils.CreateToken(uid, platform) + tokenString, _, _ := token_verify.CreateToken(uid, platform) - claims, err := utils.ParseRedisInterfaceToken([]uint8(tokenString)) + claims, err := token_verify.ParseRedisInterfaceToken([]uint8(tokenString)) assert.Nil(t, err) assert.Equal(t, claims.UID, uid) // timeout config.Config.TokenPolicy.AccessExpire = -80 - tokenString, _, _ = utils.CreateToken(uid, platform) - claims, err = utils.ParseRedisInterfaceToken([]uint8(tokenString)) - assert.Equal(t, err, utils.TokenExpired) + tokenString, _, _ = token_verify.CreateToken(uid, platform) + claims, err = token_verify.ParseRedisInterfaceToken([]uint8(tokenString)) + assert.Equal(t, err, constant.TokenExpired) assert.Nil(t, claims) } func Test_ParseToken(t *testing.T) { uid := "1" platform := int32(1) - tokenString, _, _ := utils.CreateToken(uid, platform) - claims, err := utils.ParseToken(tokenString) + tokenString, _, _ := token_verify.CreateToken(uid, platform) + claims, err := token_verify.ParseToken(tokenString) if err == nil { assert.Equal(t, claims.UID, uid) } diff --git a/internal/utils/platform_number_id_to_name_test.go b/internal/utils/platform_number_id_to_name_test.go index 9fd888f44..8a956bfac 100644 --- a/internal/utils/platform_number_id_to_name_test.go +++ b/internal/utils/platform_number_id_to_name_test.go @@ -1,46 +1,46 @@ package utils import ( - "Open_IM/pkg/utils" + "Open_IM/pkg/common/constant" "testing" "github.com/stretchr/testify/assert" ) func Test_PlatformIDToName(t *testing.T) { - assert.Equal(t, utils.PlatformIDToName(1), "IOS") - assert.Equal(t, utils.PlatformIDToName(2), "Android") - assert.Equal(t, utils.PlatformIDToName(3), "Windows") - assert.Equal(t, utils.PlatformIDToName(4), "OSX") - assert.Equal(t, utils.PlatformIDToName(5), "Web") - assert.Equal(t, utils.PlatformIDToName(6), "MiniWeb") - assert.Equal(t, utils.PlatformIDToName(7), "Linux") + assert.Equal(t, constant.PlatformIDToName(1), "IOS") + assert.Equal(t, constant.PlatformIDToName(2), "Android") + assert.Equal(t, constant.PlatformIDToName(3), "Windows") + assert.Equal(t, constant.PlatformIDToName(4), "OSX") + assert.Equal(t, constant.PlatformIDToName(5), "Web") + assert.Equal(t, constant.PlatformIDToName(6), "MiniWeb") + assert.Equal(t, constant.PlatformIDToName(7), "Linux") - assert.Equal(t, utils.PlatformIDToName(0), "") + assert.Equal(t, constant.PlatformIDToName(0), "") } func Test_PlatformNameToID(t *testing.T) { - assert.Equal(t, utils.PlatformNameToID("IOS"), int32(1)) - assert.Equal(t, utils.PlatformNameToID("Android"), int32(2)) - assert.Equal(t, utils.PlatformNameToID("Windows"), int32(3)) - assert.Equal(t, utils.PlatformNameToID("OSX"), int32(4)) - assert.Equal(t, utils.PlatformNameToID("Web"), int32(5)) - assert.Equal(t, utils.PlatformNameToID("MiniWeb"), int32(6)) - assert.Equal(t, utils.PlatformNameToID("Linux"), int32(7)) + assert.Equal(t, constant.PlatformNameToID("IOS"), int32(1)) + assert.Equal(t, constant.PlatformNameToID("Android"), int32(2)) + assert.Equal(t, constant.PlatformNameToID("Windows"), int32(3)) + assert.Equal(t, constant.PlatformNameToID("OSX"), int32(4)) + assert.Equal(t, constant.PlatformNameToID("Web"), int32(5)) + assert.Equal(t, constant.PlatformNameToID("MiniWeb"), int32(6)) + assert.Equal(t, constant.PlatformNameToID("Linux"), int32(7)) - assert.Equal(t, utils.PlatformNameToID("UnknownDevice"), int32(0)) - assert.Equal(t, utils.PlatformNameToID(""), int32(0)) + assert.Equal(t, constant.PlatformNameToID("UnknownDevice"), int32(0)) + assert.Equal(t, constant.PlatformNameToID(""), int32(0)) } func Test_PlatformNameToClass(t *testing.T) { - assert.Equal(t, utils.PlatformNameToClass("IOS"), "Mobile") - assert.Equal(t, utils.PlatformNameToClass("Android"), "Mobile") - assert.Equal(t, utils.PlatformNameToClass("OSX"), "PC") - assert.Equal(t, utils.PlatformNameToClass("Windows"), "PC") - assert.Equal(t, utils.PlatformNameToClass("Web"), "PC") - assert.Equal(t, utils.PlatformNameToClass("MiniWeb"), "Mobile") - assert.Equal(t, utils.PlatformNameToClass("Linux"), "PC") + assert.Equal(t, constant.PlatformNameToClass("IOS"), "Mobile") + assert.Equal(t, constant.PlatformNameToClass("Android"), "Mobile") + assert.Equal(t, constant.PlatformNameToClass("OSX"), "PC") + assert.Equal(t, constant.PlatformNameToClass("Windows"), "PC") + assert.Equal(t, constant.PlatformNameToClass("Web"), "PC") + assert.Equal(t, constant.PlatformNameToClass("MiniWeb"), "Mobile") + assert.Equal(t, constant.PlatformNameToClass("Linux"), "PC") - assert.Equal(t, utils.PlatformNameToClass("UnknownDevice"), "") - assert.Equal(t, utils.PlatformNameToClass(""), "") + assert.Equal(t, constant.PlatformNameToClass("UnknownDevice"), "") + assert.Equal(t, constant.PlatformNameToClass(""), "") } diff --git a/pkg/common/config/config.go b/pkg/common/config/config.go index 9bfdaa6e1..f32ca8da1 100644 --- a/pkg/common/config/config.go +++ b/pkg/common/config/config.go @@ -145,12 +145,8 @@ type config struct { } } Secret string `yaml:"secret"` - MultiLoginPolicy struct { - OnlyOneTerminalAccess bool `yaml:"onlyOneTerminalAccess"` - MobileAndPCTerminalAccessButOtherTerminalKickEachOther bool `yaml:"mobileAndPCTerminalAccessButOtherTerminalKickEachOther"` - AllTerminalAccess bool `yaml:"allTerminalAccess"` - } - TokenPolicy struct { + MultiLoginPolicy int `yaml:"multiloginpolicy"` + TokenPolicy struct { AccessSecret string `yaml:"accessSecret"` AccessExpire int64 `yaml:"accessExpire"` } diff --git a/pkg/common/constant/constant.go b/pkg/common/constant/constant.go index ca2e70919..00c73ff4e 100644 --- a/pkg/common/constant/constant.go +++ b/pkg/common/constant/constant.go @@ -22,6 +22,7 @@ const ( WSSendMsg = 1003 WSPullMsgBySeqList = 1004 WSPushMsg = 2001 + WSKickOnlineMsg = 2002 WSDataError = 3001 ///ContentType @@ -70,6 +71,21 @@ const ( //SessionType SingleChatType = 1 GroupChatType = 2 + //token + NormalToken = 0 + InValidToken = 1 + KickedToken = 2 + ExpiredToken = 3 + + //MultiTerminalLogin + //全端登录，但是同端互斥 + AllLoginButSameTermKick = 1 + //所有端中只能有一端能够登录 + SingleTerminalLogin = 2 + //web端可以同时在线，其他端只能有一端登录 + WebAndOther = 3 + //Pc端互斥，移动端互斥，但是web端可以同时在线 + PcMobileAndWeb = 4 ) var ContentType2PushContent = map[int64]string{ diff --git a/pkg/common/config/error.go b/pkg/common/constant/error.go similarity index 73% rename from pkg/common/config/error.go rename to pkg/common/constant/error.go index 4d99251f0..938b49b98 100644 --- a/pkg/common/config/error.go +++ b/pkg/common/constant/error.go @@ -1,4 +1,6 @@ -package config +package constant + +import "errors" // key = errCode, string = errMsg type ErrInfo struct { @@ -20,8 +22,6 @@ var ( ErrorUserRegister = ErrInfo{600, "User registration failed"} ErrAccountExists = ErrInfo{601, "The account is already registered and cannot be registered again"} ErrUserPassword = ErrInfo{602, "User password error"} - ErrTokenIncorrect = ErrInfo{603, "Invalid token"} - ErrTokenExpired = ErrInfo{604, "Expired token"} ErrRefreshToken = ErrInfo{605, "Failed to refresh token"} ErrAddFriend = ErrInfo{606, "Failed to add friends"} ErrAgreeToAddFriend = ErrInfo{607, "Failed to agree application"} @@ -40,9 +40,26 @@ var ( ErrJoinGroupApplication = ErrInfo{620, "Failed to apply to join the group"} ErrQuitGroup = ErrInfo{621, "Failed to quit the group"} ErrSetGroupInfo = ErrInfo{622, "Failed to set group info"} - ErrParam = ErrInfo{ErrCode: 700, ErrMsg: "param failed"} + ErrParam = ErrInfo{700, "param failed"} + ErrTokenExpired = ErrInfo{701, TokenExpired.Error()} + ErrTokenInvalid = ErrInfo{702, TokenInvalid.Error()} + ErrTokenMalformed = ErrInfo{703, TokenMalformed.Error()} + ErrTokenNotValidYet = ErrInfo{704, TokenNotValidYet.Error()} + ErrTokenUnknown = ErrInfo{705, TokenUnknown.Error()} ErrAccess = ErrInfo{ErrCode: 800, ErrMsg: "no permission"} ErrDb = ErrInfo{ErrCode: 900, ErrMsg: "db failed"} ) + +var ( + TokenExpired = errors.New("token is timed out, please log in again") + TokenInvalid = errors.New("token has been invalidated") + TokenNotValidYet = errors.New("token not active yet") + TokenMalformed = errors.New("that's not even a token") + TokenUnknown = errors.New("couldn't handle this token") +) + +func (e *ErrInfo) Error() string { + return e.ErrMsg +} diff --git a/pkg/utils/platform_number_id_to_name.go b/pkg/common/constant/platform_number_id_to_name.go similarity index 94% rename from pkg/utils/platform_number_id_to_name.go rename to pkg/common/constant/platform_number_id_to_name.go index e9a3f7fed..c3a970b69 100644 --- a/pkg/utils/platform_number_id_to_name.go +++ b/pkg/common/constant/platform_number_id_to_name.go @@ -1,4 +1,4 @@ -package utils +package constant // fixme 1<--->IOS 2<--->Android 3<--->Windows //fixme 4<--->OSX 5<--->Web 6<--->MiniWeb 7<--->Linux @@ -48,10 +48,10 @@ var PlatformName2ID = map[string]int32{ var Platform2class = map[string]string{ IOSPlatformStr: TerminalMobile, AndroidPlatformStr: TerminalMobile, - MiniWebPlatformStr: TerminalMobile, + MiniWebPlatformStr: WebPlatformStr, + WebPlatformStr: WebPlatformStr, WindowsPlatformStr: TerminalPC, OSXPlatformStr: TerminalPC, - WebPlatformStr: TerminalPC, LinuxPlatformStr: TerminalPC, } diff --git a/pkg/common/db/redisModel.go b/pkg/common/db/redisModel.go index b31fde8c1..d566a2926 100644 --- a/pkg/common/db/redisModel.go +++ b/pkg/common/db/redisModel.go @@ -2,6 +2,7 @@ package db import ( log2 "Open_IM/pkg/common/log" + "Open_IM/pkg/utils" "github.com/garyburd/redigo/redis" ) @@ -10,6 +11,7 @@ const ( appleDeviceToken = "DEVICE_TOKEN" lastGetSeq = "LAST_GET_SEQ" userMinSeq = "REDIS_USER_MIN_SEQ:" + uidPidToken = "UID_PID_TOKEN:" ) func (d *DataBases) Exec(cmd string, key interface{}, args ...interface{}) (interface{}, error) { @@ -71,36 +73,39 @@ func (d *DataBases) DelAppleDeviceToken(accountAddress string) (err error) { return err } -//Record the last time the user actively pulled the value of Seq -func (d *DataBases) SetLastGetSeq(uid string) (err error) { - key := lastGetSeq + uid - _, err = d.Exec("SET", key) - return err -} - -//Get the value of the user's last active pull Seq -func (d *DataBases) GetLastGetSeq(uid string) (int64, error) { - key := lastGetSeq + uid - return redis.Int64(d.Exec("GET", key)) -} - //Store userid and platform class to redis -func (d *DataBases) SetUserIDAndPlatform(userID, platformClass, value string, ttl int64) error { - key := userID + platformClass - _, err := d.Exec("SET", key, value, "EX", ttl) +func (d *DataBases) AddTokenFlag(userID string, platformID int32, token string, flag int) error { + key := uidPidToken + userID + ":" + utils.Int32ToString(platformID) + m, err := redis.IntMap(d.Exec("GET", key)) + if err != nil && err != redis.ErrNil { + return err + } + if err == redis.ErrNil { + m = make(map[string]int, 5) + } + m[token] = flag + _, err1 := d.Exec("SET", key, m) + return err1 +} + +func (d *DataBases) GetTokenMapByUidPid(userID, platformID string) (map[string]int, error) { + key := uidPidToken + userID + ":" + platformID + return redis.IntMap(d.Exec("GET", key)) +} +func (d *DataBases) SetTokenMapByUidPid(userID, platformID string, m map[string]int) error { + key := uidPidToken + userID + ":" + platformID + _, err := d.Exec("SET", key, m) return err } //Check exists userid and platform class from redis -func (d *DataBases) ExistsUserIDAndPlatform(userID, platformClass string) (interface{}, error) { +func (d *DataBases) ExistsUserIDAndPlatform(userID, platformClass string) (int64, error) { key := userID + platformClass - exists, err := d.Exec("EXISTS", key) - return exists, err + return redis.Int64(d.Exec("EXISTS", key)) } //Get platform class Token -func (d *DataBases) GetPlatformToken(userID, platformClass string) (interface{}, error) { +func (d *DataBases) GetPlatformToken(userID, platformClass string) (string, error) { key := userID + platformClass - token, err := d.Exec("GET", key) - return token, err + return redis.String(d.Exec("GET", key)) } diff --git a/pkg/common/multi_terminal_login/multi_terminal_login.go b/pkg/common/multi_terminal_login/multi_terminal_login.go index ba0c0525c..3c3245e63 100644 --- a/pkg/common/multi_terminal_login/multi_terminal_login.go +++ b/pkg/common/multi_terminal_login/multi_terminal_login.go @@ -1,73 +1,73 @@ package multi_terminal_login -import ( - "Open_IM/internal/push/content_struct" - "Open_IM/internal/push/logic" - "Open_IM/pkg/common/config" - "Open_IM/pkg/common/constant" - "Open_IM/pkg/common/db" - pbChat "Open_IM/pkg/proto/chat" - "Open_IM/pkg/utils" -) - -func MultiTerminalLoginChecker(uid, token string, platformID int32) error { - // 1.check userid and platform class 0 not exists and 1 exists - existsInterface, err := db.DB.ExistsUserIDAndPlatform(uid, utils.PlatformNameToClass(utils.PlatformIDToName(platformID))) - if err != nil { - return err - } - exists := existsInterface.(int64) - //get config multi login policy - if config.Config.MultiLoginPolicy.OnlyOneTerminalAccess { - //OnlyOneTerminalAccess policy need to check all terminal - if utils.PlatformNameToClass(utils.PlatformIDToName(platformID)) == "PC" { - existsInterface, err = db.DB.ExistsUserIDAndPlatform(uid, "Mobile") - if err != nil { - return err - } - } else { - existsInterface, err = db.DB.ExistsUserIDAndPlatform(uid, "PC") - if err != nil { - return err - } - } - exists = existsInterface.(int64) - if exists == 1 { - err := db.DB.SetUserIDAndPlatform(uid, utils.PlatformNameToClass(utils.PlatformIDToName(platformID)), token, config.Config.TokenPolicy.AccessExpire) - if err != nil { - return err - } - PushMessageToTheTerminal(uid, platformID) - return nil - } - } else if config.Config.MultiLoginPolicy.MobileAndPCTerminalAccessButOtherTerminalKickEachOther { - // common terminal need to kick eich other - if exists == 1 { - err := db.DB.SetUserIDAndPlatform(uid, utils.PlatformNameToClass(utils.PlatformIDToName(platformID)), token, config.Config.TokenPolicy.AccessExpire) - if err != nil { - return err - } - PushMessageToTheTerminal(uid, platformID) - return nil - } - } - err = db.DB.SetUserIDAndPlatform(uid, utils.PlatformNameToClass(utils.PlatformIDToName(platformID)), token, config.Config.TokenPolicy.AccessExpire) - if err != nil { - return err - } - PushMessageToTheTerminal(uid, platformID) - return nil -} - -func PushMessageToTheTerminal(uid string, platform int32) { - - logic.SendMsgByWS(&pbChat.WSToMsgSvrChatMsg{ - SendID: uid, - RecvID: uid, - Content: content_struct.NewContentStructString(1, "", "Your account is already logged on other terminal,please confirm"), - SendTime: utils.GetCurrentTimestampBySecond(), - MsgFrom: constant.SysMsgType, - ContentType: constant.KickOnlineTip, - PlatformID: platform, - }) -} +// +//import ( +// "Open_IM/internal/push/content_struct" +// "Open_IM/internal/push/logic" +// "Open_IM/pkg/common/config" +// "Open_IM/pkg/common/constant" +// "Open_IM/pkg/common/db" +// pbChat "Open_IM/pkg/proto/chat" +// "Open_IM/pkg/utils" +//) +// +//const DayOfSecond = 24*60*60 +//func MultiTerminalLoginChecker(uid, token string, platformID int32) error { +// // 1.check userid and platform class 0 not exists and 1 exists +// exists, err := db.DB.ExistsUserIDAndPlatform(uid, constant.PlatformNameToClass(constant.PlatformIDToName(platformID))) +// if err != nil { +// return err +// } +// //get config multi login policy +// if config.Config.MultiLoginPolicy { +// //OnlyOneTerminalAccess policy need to check all terminal +// if constant.PlatformNameToClass(constant.PlatformIDToName(platformID)) == "PC" { +// exists, err = db.DB.ExistsUserIDAndPlatform(uid, "Mobile") +// if err != nil { +// return err +// } +// } else { +// exists, err = db.DB.ExistsUserIDAndPlatform(uid, "PC") +// if err != nil { +// return err +// } +// } +// if exists == 1 { +// err := db.DB.SetUserIDAndPlatform(uid, constant.PlatformNameToClass(constant.PlatformIDToName(platformID)), token, config.Config.TokenPolicy.AccessExpire*DayOfSecond) +// if err != nil { +// return err +// } +// PushMessageToTheTerminal(uid, platformID) +// return nil +// } +// } else if config.Config.MultiLoginPolicy.MobileAndPCTerminalAccessButOtherTerminalKickEachOther { +// // common terminal need to kick eich other +// if exists == 1 { +// err := db.DB.SetUserIDAndPlatform(uid, constant.PlatformNameToClass(constant.PlatformIDToName(platformID)), token, config.Config.TokenPolicy.AccessExpire*DayOfSecond) +// if err != nil { +// return err +// } +// PushMessageToTheTerminal(uid, platformID) +// return nil +// } +// } +// err = db.DB.SetUserIDAndPlatform(uid, constant.PlatformNameToClass(constant.PlatformIDToName(platformID)), token, config.Config.TokenPolicy.AccessExpire*DayOfSecond) +// if err != nil { +// return err +// } +// PushMessageToTheTerminal(uid, platformID) +// return nil +//} +//// +////func PushMessageToTheTerminal(uid string, platform int32) { +//// +//// logic.SendMsgByWS(&pbChat.WSToMsgSvrChatMsg{ +//// SendID: uid, +//// RecvID: uid, +//// Content: content_struct.NewContentStructString(1, "", "Your account is already logged on other terminal,please confirm"), +//// SendTime: utils.GetCurrentTimestampBySecond(), +//// MsgFrom: constant.SysMsgType, +//// ContentType: constant.KickOnlineTip, +//// PlatformID: platform, +//// }) +////} diff --git a/pkg/common/token_verify/jwt_token.go b/pkg/common/token_verify/jwt_token.go new file mode 100644 index 000000000..e5419dd6b --- /dev/null +++ b/pkg/common/token_verify/jwt_token.go @@ -0,0 +1,144 @@ +package token_verify + +import ( + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + commonDB "Open_IM/pkg/common/db" + "Open_IM/pkg/common/log" + "github.com/golang-jwt/jwt/v4" + "time" +) + +//var ( +// TokenExpired = errors.New("token is timed out, please log in again") +// TokenInvalid = errors.New("token has been invalidated") +// TokenNotValidYet = errors.New("token not active yet") +// TokenMalformed = errors.New("that's not even a token") +// TokenUnknown = errors.New("couldn't handle this token") +//) + +type Claims struct { + UID string + Platform string //login platform + jwt.RegisteredClaims +} + +func BuildClaims(uid, platform string, ttl int64) Claims { + now := time.Now() + return Claims{ + UID: uid, + Platform: platform, + RegisteredClaims: jwt.RegisteredClaims{ + ExpiresAt: jwt.NewNumericDate(now.Add(time.Duration(ttl*24) * time.Hour)), //Expiration time + IssuedAt: jwt.NewNumericDate(now), //Issuing time + NotBefore: jwt.NewNumericDate(now), //Begin Effective time + }} +} + +func CreateToken(userID string, platformID int32) (string, int64, error) { + claims := BuildClaims(userID, constant.PlatformIDToName(platformID), config.Config.TokenPolicy.AccessExpire) + token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + tokenString, err := token.SignedString([]byte(config.Config.TokenPolicy.AccessSecret)) + if err != nil { + return "", 0, err + } + err = commonDB.DB.AddTokenFlag(userID, platformID, tokenString, constant.NormalToken) + if err != nil { + return "", 0, err + } + return tokenString, claims.ExpiresAt.Time.Unix(), err +} + +func secret() jwt.Keyfunc { + return func(token *jwt.Token) (interface{}, error) { + return []byte(config.Config.TokenPolicy.AccessSecret), nil + } +} + +func getClaimFromToken(tokensString string) (*Claims, error) { + token, err := jwt.ParseWithClaims(tokensString, &Claims{}, secret()) + if err != nil { + if ve, ok := err.(*jwt.ValidationError); ok { + if ve.Errors&jwt.ValidationErrorMalformed != 0 { + return nil, &constant.ErrTokenMalformed + } else if ve.Errors&jwt.ValidationErrorExpired != 0 { + return nil, &constant.ErrTokenExpired + } else if ve.Errors&jwt.ValidationErrorNotValidYet != 0 { + return nil, &constant.ErrTokenNotValidYet + } else { + return nil, &constant.ErrTokenUnknown + } + } else { + return nil, &constant.ErrTokenNotValidYet + } + } else { + if claims, ok := token.Claims.(*Claims); ok && token.Valid { + return claims, nil + } + return nil, &constant.ErrTokenNotValidYet + } +} + +func ParseToken(tokensString string) (claims *Claims, err error) { + //根据token的算法本身做出的有效性检验 + claims, err = getClaimFromToken(tokensString) + if err != nil { + log.NewError("", "token validate err", err.Error()) + return nil, err + } + //根据redis做出的有效性检验 + m, err := commonDB.DB.GetTokenMapByUidPid(claims.UID, claims.Platform) + if err != nil { + log.NewError("", "get token from redis err", err.Error()) + return nil, &constant.ErrTokenInvalid + } + if m == nil { + log.NewError("", "get token from redis err", "m is nil") + return nil, &constant.ErrTokenInvalid + } + if v, ok := m[tokensString]; ok { + switch v { + case constant.NormalToken: + return claims, nil + case constant.InValidToken: + return nil, &constant.ErrTokenInvalid + case constant.KickedToken: + return nil, &constant.ErrTokenInvalid + case constant.ExpiredToken: + return nil, &constant.ErrTokenExpired + } + } + return nil, err +} + +//func MakeTheTokenInvalid(currentClaims *Claims, platformClass string) (bool, error) { +// storedRedisTokenInterface, err := db.DB.GetPlatformToken(currentClaims.UID, platformClass) +// if err != nil { +// return false, err +// } +// storedRedisPlatformClaims, err := ParseRedisInterfaceToken(storedRedisTokenInterface) +// if err != nil { +// return false, err +// } +// //if issue time less than redis token then make this token invalid +// if currentClaims.IssuedAt.Time.Unix() < storedRedisPlatformClaims.IssuedAt.Time.Unix() { +// return true, constant.TokenInvalid +// } +// return false, nil +//} + +func ParseRedisInterfaceToken(redisToken interface{}) (*Claims, error) { + return getClaimFromToken(string(redisToken.([]uint8))) +} + +//Validation token, false means failure, true means successful verification +func VerifyToken(token, uid string) (bool, error) { + claims, err := ParseToken(token) + if err != nil { + return false, err + } + if claims.UID != uid { + return false, &constant.ErrTokenUnknown + } + return true, nil +} diff --git a/pkg/utils/jwt_token.go b/pkg/utils/jwt_token.go deleted file mode 100644 index fd6a69ea0..000000000 --- a/pkg/utils/jwt_token.go +++ /dev/null @@ -1,153 +0,0 @@ -package utils - -import ( - "Open_IM/pkg/common/config" - "Open_IM/pkg/common/db" - "errors" - "github.com/golang-jwt/jwt/v4" - "time" -) - -var ( - TokenExpired = errors.New("token is timed out, please log in again") - TokenInvalid = errors.New("token has been invalidated") - TokenNotValidYet = errors.New("token not active yet") - TokenMalformed = errors.New("that's not even a token") - TokenUnknown = errors.New("couldn't handle this token") -) - -type Claims struct { - UID string - Platform string //login platform - jwt.RegisteredClaims -} - -func BuildClaims(uid, platform string, ttl int64) Claims { - now := time.Now() - return Claims{ - UID: uid, - Platform: platform, - RegisteredClaims: jwt.RegisteredClaims{ - ExpiresAt: jwt.NewNumericDate(now.Add(time.Duration(ttl*24) * time.Hour)), //Expiration time - IssuedAt: jwt.NewNumericDate(now), //Issuing time - NotBefore: jwt.NewNumericDate(now), //Begin Effective time - }} -} - -func CreateToken(userID string, platform int32) (string, int64, error) { - claims := BuildClaims(userID, PlatformIDToName(platform), config.Config.TokenPolicy.AccessExpire) - token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) - tokenString, err := token.SignedString([]byte(config.Config.TokenPolicy.AccessSecret)) - - return tokenString, claims.ExpiresAt.Time.Unix(), err -} - -func secret() jwt.Keyfunc { - return func(token *jwt.Token) (interface{}, error) { - return []byte(config.Config.TokenPolicy.AccessSecret), nil - } -} - -func getClaimFromToken(tokensString string) (*Claims, error) { - token, err := jwt.ParseWithClaims(tokensString, &Claims{}, secret()) - if err != nil { - if ve, ok := err.(*jwt.ValidationError); ok { - if ve.Errors&jwt.ValidationErrorMalformed != 0 { - return nil, TokenMalformed - } else if ve.Errors&jwt.ValidationErrorExpired != 0 { - return nil, TokenExpired - } else if ve.Errors&jwt.ValidationErrorNotValidYet != 0 { - return nil, TokenNotValidYet - } else { - return nil, TokenUnknown - } - } - } - if claims, ok := token.Claims.(*Claims); ok && token.Valid { - return claims, nil - } - return nil, err -} - -func ParseToken(tokensString string) (claims *Claims, err error) { - claims, err = getClaimFromToken(tokensString) - - if err != nil { - return nil, err - } - - // 1.check userid and platform class 0 not exists and 1 exists - existsInterface, err := db.DB.ExistsUserIDAndPlatform(claims.UID, Platform2class[claims.Platform]) - if err != nil { - return nil, err - } - exists := existsInterface.(int64) - //get config multi login policy - if config.Config.MultiLoginPolicy.OnlyOneTerminalAccess { - //OnlyOneTerminalAccess policy need to check all terminal - //When only one end is allowed to log in, there is a situation that needs to be paid attention to. After PC login, - //mobile login should check two platform times. One of them is less than the redis storage time, which is the invalid token. - platform := "PC" - if Platform2class[claims.Platform] == "PC" { - platform = "Mobile" - } - - existsInterface, err = db.DB.ExistsUserIDAndPlatform(claims.UID, platform) - if err != nil { - return nil, err - } - - exists = existsInterface.(int64) - if exists == 1 { - res, err := MakeTheTokenInvalid(claims, platform) - if err != nil { - return nil, err - } - if res { - return nil, TokenInvalid - } - } - } - // config.Config.MultiLoginPolicy.MobileAndPCTerminalAccessButOtherTerminalKickEachOther == true - // or PC/Mobile validate success - // final check - if exists == 1 { - res, err := MakeTheTokenInvalid(claims, Platform2class[claims.Platform]) - if err != nil { - return nil, err - } - if res { - return nil, TokenInvalid - } - } - return claims, nil -} - -func MakeTheTokenInvalid(currentClaims *Claims, platformClass string) (bool, error) { - storedRedisTokenInterface, err := db.DB.GetPlatformToken(currentClaims.UID, platformClass) - if err != nil { - return false, err - } - storedRedisPlatformClaims, err := ParseRedisInterfaceToken(storedRedisTokenInterface) - if err != nil { - return false, err - } - //if issue time less than redis token then make this token invalid - if currentClaims.IssuedAt.Time.Unix() < storedRedisPlatformClaims.IssuedAt.Time.Unix() { - return true, TokenInvalid - } - return false, nil -} - -func ParseRedisInterfaceToken(redisToken interface{}) (*Claims, error) { - return getClaimFromToken(string(redisToken.([]uint8))) -} - -//Validation token, false means failure, true means successful verification -func VerifyToken(token, uid string) bool { - claims, err := ParseToken(token) - if err != nil || claims.UID != uid { - return false - } - return true -} diff --git a/pkg/utils/strings.go b/pkg/utils/strings.go index 39c797859..4249eee6b 100644 --- a/pkg/utils/strings.go +++ b/pkg/utils/strings.go @@ -24,6 +24,9 @@ func StringToInt64(i string) int64 { j, _ := strconv.ParseInt(i, 10, 64) return j } +func Int32ToString(i int32) string { + return strconv.FormatInt(int64(i), 10) +} //judge a string whether in the string list func IsContain(target string, List []string) bool {