diff --git a/cmd/open_im_api/main.go b/cmd/open_im_api/main.go index b9bcd6681..7b75efa90 100644 --- a/cmd/open_im_api/main.go +++ b/cmd/open_im_api/main.go @@ -43,6 +43,8 @@ func main() { userRouterGroup.POST("/get_self_user_info", user.GetSelfUserInfo) //1 userRouterGroup.POST("/get_users_online_status", user.GetUsersOnlineStatus) //1 userRouterGroup.POST("/get_users_info_from_cache", user.GetUsersInfoFromCache) + userRouterGroup.POST("/get_user_friend_from_cache", user.GetFriendIDListFromCache) + userRouterGroup.POST("/get_black_list_from_cache", user.GetBlackIDListFromCache) } //friend routing group friendRouterGroup := r.Group("/friend") diff --git a/internal/api/user/user.go b/internal/api/user/user.go index 0cad45eed..41042099e 100644 --- a/internal/api/user/user.go +++ b/internal/api/user/user.go @@ -26,111 +26,207 @@ func GetUsersInfoFromCache(c *gin.Context) { c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()}) return } - getUserInfoReq := &rpc.GetUserInfoReq{} - getUserInfoReq.OperationID = params.OperationID + req := &rpc.GetUserInfoReq{} + utils.CopyStructFields(req, ¶ms) var ok bool - ok, getUserInfoReq.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), getUserInfoReq.OperationID) + ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID) if !ok { - log.NewError(getUserInfoReq.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token")) + log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token")) c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"}) return } - log.NewInfo(params.OperationID, "GetUserInfo args ", getUserInfoReq.String()) - reqCacheGetUserInfo := &cacheRpc.GetUserInfoFromCacheReq{} - utils.CopyStructFields(reqCacheGetUserInfo, ¶ms) - var userInfoList []*open_im_sdk.UserInfo - var publicUserInfoList []*open_im_sdk.PublicUserInfo - etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName) - cacheClient := cacheRpc.NewCacheClient(etcdConn) - cacheResp, err := cacheClient.GetUserInfoFromCache(context.Background(), reqCacheGetUserInfo) + log.NewInfo(params.OperationID, "GetUserInfo args ", req.String()) + + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := rpc.NewUserClient(etcdConn) + RpcResp, err := client.GetUserInfo(context.Background(), req) if err != nil { - log.NewError(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed", err.Error()) - c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed: " + err.Error()}) + log.NewError(req.OperationID, "GetUserInfo failed ", err.Error(), req.String()) + c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"}) return } - if cacheResp.CommonResp.ErrCode != 0 { - log.NewError(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed", cacheResp.CommonResp) - resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}} - resp.Data = []map[string]interface{}{} - log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp) - c.JSON(http.StatusOK, resp) - return + var publicUserInfoList []*open_im_sdk.PublicUserInfo + for _, v := range RpcResp.UserInfoList { + publicUserInfoList = append(publicUserInfoList, + &open_im_sdk.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex}) } - log.NewInfo(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "cacheResp:", cacheResp.String()) - userInfoList = cacheResp.UserInfoList - var needCacheUserIDList []string - for _, userID := range reqCacheGetUserInfo.UserIDList { - isGetUserInfoFromCache := false - for _, cacheUser := range userInfoList { - if cacheUser.UserID == userID { - isGetUserInfoFromCache = true - } - } - if !isGetUserInfoFromCache { - needCacheUserIDList = append(needCacheUserIDList, userID) - } + + resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList} + resp.Data = jsonData.JsonDataList(resp.UserInfoList) + log.NewInfo(req.OperationID, "GetUserInfo api return ", resp) + c.JSON(http.StatusOK, resp) +} + +//func GetUsersInfoFromCache(c *gin.Context) { +// params := api.GetUsersInfoReq{} +// if err := c.BindJSON(¶ms); err != nil { +// log.NewError("0", "BindJSON failed ", err.Error()) +// c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()}) +// return +// } +// getUserInfoReq := &rpc.GetUserInfoReq{} +// getUserInfoReq.OperationID = params.OperationID +// var ok bool +// ok, getUserInfoReq.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), getUserInfoReq.OperationID) +// if !ok { +// log.NewError(getUserInfoReq.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token")) +// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"}) +// return +// } +// log.NewInfo(params.OperationID, "GetUserInfo args ", getUserInfoReq.String()) +// reqCacheGetUserInfo := &cacheRpc.GetUserInfoFromCacheReq{} +// utils.CopyStructFields(reqCacheGetUserInfo, ¶ms) +// var userInfoList []*open_im_sdk.UserInfo +// var publicUserInfoList []*open_im_sdk.PublicUserInfo +// etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName) +// cacheClient := cacheRpc.NewCacheClient(etcdConn) +// cacheResp, err := cacheClient.GetUserInfoFromCache(context.Background(), reqCacheGetUserInfo) +// if err != nil { +// log.NewError(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed", err.Error()) +// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed: " + err.Error()}) +// return +// } +// if cacheResp.CommonResp.ErrCode != 0 { +// log.NewError(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed", cacheResp.CommonResp) +// resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}} +// resp.Data = []map[string]interface{}{} +// log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp) +// c.JSON(http.StatusOK, resp) +// return +// } +// log.NewInfo(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "cacheResp:", cacheResp.String()) +// userInfoList = cacheResp.UserInfoList +// var needCacheUserIDList []string +// for _, userID := range reqCacheGetUserInfo.UserIDList { +// isGetUserInfoFromCache := false +// for _, cacheUser := range userInfoList { +// if cacheUser.UserID == userID { +// isGetUserInfoFromCache = true +// } +// } +// if !isGetUserInfoFromCache { +// needCacheUserIDList = append(needCacheUserIDList, userID) +// } +// } +// if len(needCacheUserIDList) == 0 { +// log.NewInfo(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "get all userInfo from cache success") +// for _, v := range userInfoList { +// publicUserInfoList = append(publicUserInfoList, +// &open_im_sdk.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex}) +// } +// resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList} +// resp.Data = jsonData.JsonDataList(resp.UserInfoList) +// log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp) +// c.JSON(http.StatusOK, resp) +// return +// } +// +// log.NewDebug(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "need cache user list", needCacheUserIDList) +// getUserInfoReq.UserIDList = needCacheUserIDList +// etcdConn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) +// client := rpc.NewUserClient(etcdConn) +// rpcResp, err := client.GetUserInfo(context.Background(), getUserInfoReq) +// if err != nil { +// log.NewError(getUserInfoReq.OperationID, "GetUserInfo failed ", err.Error(), getUserInfoReq.String()) +// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed" + err.Error()}) +// return +// } +// if rpcResp.CommonResp.ErrCode != 0 { +// log.NewError(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed", cacheResp.CommonResp) +// resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}} +// resp.Data = []map[string]interface{}{} +// log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp) +// c.JSON(http.StatusOK, resp) +// return +// } +// userInfoList = append(userInfoList, rpcResp.UserInfoList...) +// cacheUpdateUserInfoReq := &cacheRpc.UpdateUserInfoToCacheReq{ +// UserInfoList: rpcResp.UserInfoList, +// OperationID: getUserInfoReq.OperationID, +// } +// _, err = cacheClient.UpdateUserInfoToCache(context.Background(), cacheUpdateUserInfoReq) +// if err != nil { +// log.NewError(getUserInfoReq.OperationID, "GetUserInfo failed ", err.Error()) +// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed:" + err.Error()}) +// return +// } +// userInfoList = rpcResp.UserInfoList +// for _, v := range userInfoList { +// publicUserInfoList = append(publicUserInfoList, +// &open_im_sdk.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex}) +// } +// resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: rpcResp.CommonResp.ErrCode, ErrMsg: rpcResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList} +// resp.Data = jsonData.JsonDataList(resp.UserInfoList) +// log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp) +// c.JSON(http.StatusOK, resp) +//} + +func GetFriendIDListFromCache(c *gin.Context) { + var ( + req api.GetFriendIDListFromCacheReq + resp api.GetFriendIDListFromCacheResp + reqPb cacheRpc.GetFriendIDListFromCacheReq + respPb *cacheRpc.GetFriendIDListFromCacheResp + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(req.OperationID, "BindJSON failed ", err.Error()) + c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()}) + return } - if len(needCacheUserIDList) == 0 { - log.NewInfo(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "get all userInfo from cache success") - for _, v := range userInfoList { - publicUserInfoList = append(publicUserInfoList, - &open_im_sdk.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex}) - } - resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList} - resp.Data = jsonData.JsonDataList(resp.UserInfoList) - log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp) - c.JSON(http.StatusOK, resp) + reqPb.OperationID = req.OperationID + var ok bool + ok, reqPb.UserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID) + if !ok { + log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token")) + c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"}) return } - - log.NewDebug(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "need cache user list", needCacheUserIDList) - getUserInfoReq.UserIDList = needCacheUserIDList - etcdConn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) - client := rpc.NewUserClient(etcdConn) - rpcResp, err := client.GetUserInfo(context.Background(), getUserInfoReq) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName) + client := cacheRpc.NewCacheClient(etcdConn) + respPb, err := client.GetFriendIDListFromCache(context.Background(), &reqPb) if err != nil { - log.NewError(getUserInfoReq.OperationID, "GetUserInfo failed ", err.Error(), getUserInfoReq.String()) - c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed" + err.Error()}) + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetFriendIDListFromCache", err.Error()) + c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed:" + err.Error()}) return } - if rpcResp.CommonResp.ErrCode != 0 { - log.NewError(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed", cacheResp.CommonResp) - resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}} - resp.Data = []map[string]interface{}{} - log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp) - c.JSON(http.StatusOK, resp) + resp.UserIDList = respPb.UserIDList + resp.CommResp = api.CommResp{ErrMsg: respPb.CommonResp.ErrMsg, ErrCode: respPb.CommonResp.ErrCode} + c.JSON(http.StatusOK, resp) +} + +func GetBlackIDListFromCache(c *gin.Context) { + var ( + req api.GetBlackIDListFromCacheReq + resp api.GetBlackIDListFromCacheResp + reqPb cacheRpc.GetBlackIDListFromCacheReq + respPb *cacheRpc.GetBlackIDListFromCacheResp + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(req.OperationID, "BindJSON failed ", err.Error()) + c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()}) return } - userInfoList = append(userInfoList, rpcResp.UserInfoList...) - cacheUpdateUserInfoReq := &cacheRpc.UpdateUserInfoToCacheReq{ - UserInfoList: rpcResp.UserInfoList, - OperationID: getUserInfoReq.OperationID, + reqPb.OperationID = req.OperationID + var ok bool + ok, reqPb.UserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID) + if !ok { + log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token")) + c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"}) + return } - _, err = cacheClient.UpdateUserInfoToCache(context.Background(), cacheUpdateUserInfoReq) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName) + client := cacheRpc.NewCacheClient(etcdConn) + respPb, err := client.GetBlackIDListFromCache(context.Background(), &reqPb) if err != nil { - log.NewError(getUserInfoReq.OperationID, "GetUserInfo failed ", err.Error()) + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetFriendIDListFromCache", err.Error()) c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed:" + err.Error()}) return } - userInfoList = rpcResp.UserInfoList - for _, v := range userInfoList { - publicUserInfoList = append(publicUserInfoList, - &open_im_sdk.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex}) - } - resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: rpcResp.CommonResp.ErrCode, ErrMsg: rpcResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList} - resp.Data = jsonData.JsonDataList(resp.UserInfoList) - log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp) + resp.UserIDList = respPb.UserIDList + resp.CommResp = api.CommResp{ErrMsg: respPb.CommonResp.ErrMsg, ErrCode: respPb.CommonResp.ErrCode} c.JSON(http.StatusOK, resp) } -func GetUserFriendFromCache(c *gin.Context) { - -} - -func GetBlackListFromCache(c *gin.Context) { - -} - func GetUsersInfo(c *gin.Context) { params := api.GetUsersInfoReq{} if err := c.BindJSON(¶ms); err != nil { @@ -197,60 +293,11 @@ func UpdateUserInfo(c *gin.Context) { c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"}) return } - if RpcResp.CommonResp.ErrCode != 0 { - resp := api.UpdateUserInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}} - log.NewInfo(req.OperationID, "UpdateUserInfo api return ", resp) - c.JSON(http.StatusOK, resp) - return - } - var updateUserInfoReq = &cacheRpc.UpdateUserInfoToCacheReq{UserInfoList: []*open_im_sdk.UserInfo{}} - updateUserInfoReq.UserInfoList[0] = req.UserInfo - etcdConn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName) - cacheClient := cacheRpc.NewCacheClient(etcdConn) - cacheResp, err := cacheClient.UpdateUserInfoToCache(context.Background(), updateUserInfoReq) - if err != nil { - log.NewError(req.OperationID, "UpdateUserInfo failed ", err.Error(), req.String()) - c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"}) - return - } - resp := api.UpdateUserInfoResp{CommResp: api.CommResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}} + resp := api.UpdateUserInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}} log.NewInfo(req.OperationID, "UpdateUserInfo api return ", resp) c.JSON(http.StatusOK, resp) } -//func UpdateUserInfo(c *gin.Context) { -// params := api.UpdateSelfUserInfoReq{} -// if err := c.BindJSON(¶ms); err != nil { -// log.NewError("0", "BindJSON failed ", err.Error()) -// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) -// return -// } -// req := &rpc.UpdateUserInfoReq{UserInfo: &open_im_sdk.UserInfo{}} -// utils.CopyStructFields(req.UserInfo, ¶ms) -// -// req.OperationID = params.OperationID -// var ok bool -// ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID) -// if !ok { -// log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token")) -// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"}) -// return -// } -// log.NewInfo(params.OperationID, "UpdateUserInfo args ", req.String()) -// -// etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) -// client := rpc.NewUserClient(etcdConn) -// RpcResp, err := client.UpdateUserInfo(context.Background(), req) -// if err != nil { -// log.NewError(req.OperationID, "UpdateUserInfo failed ", err.Error(), req.String()) -// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"}) -// return -// } -// resp := api.UpdateUserInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}} -// log.NewInfo(req.OperationID, "UpdateUserInfo api return ", resp) -// c.JSON(http.StatusOK, resp) -//} - func GetSelfUserInfo(c *gin.Context) { params := api.GetSelfUserInfoReq{} if err := c.BindJSON(¶ms); err != nil { diff --git a/internal/rpc/cache/cache.go b/internal/rpc/cache/cache.go index 051469327..4e9c1ef5a 100644 --- a/internal/rpc/cache/cache.go +++ b/internal/rpc/cache/cache.go @@ -78,7 +78,7 @@ func SyncDB2Cache() error { if err != nil { return utils.Wrap(err, "") } - err = updateAllUserToCache(userList) + //err = updateAllUserToCache(userList) err = updateAllFriendToCache(userList) err = updateAllBlackListToCache(userList) return err @@ -98,7 +98,11 @@ func updateAllUserToCache(userList []db.User) error { CreateTime: uint32(userInfo.CreateTime.Unix()), AppMangerLevel: userInfo.AppMangerLevel, } - if err := db.DB.SetUserInfoToCache(userInfoPb); err != nil { + m, err := utils.Pb2Map(userInfoPb) + if err != nil { + log.NewError("", utils.GetSelfFuncName(), err.Error()) + } + if err := db.DB.SetUserInfoToCache(userInfo.UserID, m); err != nil { log.NewError("0", utils.GetSelfFuncName(), "set userInfo to cache failed", err.Error()) } } @@ -161,7 +165,11 @@ func (s *cacheServer) UpdateUserInfoToCache(_ context.Context, req *pbCache.Upda CommonResp: &pbCache.CommonResp{}, } for _, userInfo := range req.UserInfoList { - if err := db.DB.SetUserInfoToCache(userInfo); err != nil { + m, err := utils.Pb2Map(userInfo) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), *userInfo) + } + if err := db.DB.SetUserInfoToCache(userInfo.UserID, m); err != nil { log.NewError(req.OperationID, utils.GetSelfFuncName(), "set userInfo to cache failed", err.Error()) } } @@ -177,11 +185,11 @@ func (s *cacheServer) GetFriendIDListFromCache(_ context.Context, req *pbCache.G log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetFriendIDListFromCache", err.Error()) resp.CommonResp.ErrCode = constant.ErrDB.ErrCode resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg - return + return resp, nil } resp.UserIDList = friendIDList log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String()) - return nil, nil + return resp, nil } func (s *cacheServer) AddFriendToCache(_ context.Context, req *pbCache.AddFriendToCacheReq) (resp *pbCache.AddFriendToCacheResp, err error) { @@ -207,7 +215,7 @@ func (s *cacheServer) ReduceFriendFromCache(_ context.Context, req *pbCache.Redu return resp, nil } log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String()) - return nil, nil + return resp, nil } func (s *cacheServer) GetBlackIDListFromCache(_ context.Context, req *pbCache.GetBlackIDListFromCacheReq) (resp *pbCache.GetBlackIDListFromCacheResp, err error) { @@ -222,7 +230,7 @@ func (s *cacheServer) GetBlackIDListFromCache(_ context.Context, req *pbCache.Ge } resp.UserIDList = blackUserIDList log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String()) - return nil, nil + return resp, nil } func (s *cacheServer) AddBlackUserToCache(_ context.Context, req *pbCache.AddBlackUserToCacheReq) (resp *pbCache.AddBlackUserToCacheResp, err error) { @@ -248,5 +256,5 @@ func (s *cacheServer) ReduceBlackUserFromCache(_ context.Context, req *pbCache.R return resp, nil } log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String()) - return nil, nil + return resp, nil } diff --git a/internal/rpc/friend/firend.go b/internal/rpc/friend/firend.go index b570b8106..c9c016907 100644 --- a/internal/rpc/friend/firend.go +++ b/internal/rpc/friend/firend.go @@ -10,6 +10,7 @@ import ( "Open_IM/pkg/common/token_verify" cp "Open_IM/pkg/common/utils" "Open_IM/pkg/grpc-etcdv3/getcdv3" + pbCache "Open_IM/pkg/proto/cache" pbFriend "Open_IM/pkg/proto/friend" sdkws "Open_IM/pkg/proto/sdk_ws" "Open_IM/pkg/utils" @@ -244,6 +245,24 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF } else { log.Error(req.CommID.OperationID, "HandleResult failed ", req.HandleResult) } + + addFriendToCacheReq := &pbCache.AddFriendToCacheReq{OperationID: req.CommID.OperationID} + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName) + client := pbCache.NewCacheClient(etcdConn) + addFriendToCacheReq.UserID = req.CommID.ToUserID + addFriendToCacheReq.UserID = req.CommID.FromUserID + respPb, err := client.AddFriendToCache(context.Background(), addFriendToCacheReq) + addFriendToCacheReq.UserID = req.CommID.FromUserID + addFriendToCacheReq.UserID = req.CommID.ToUserID + respPb, err = client.AddFriendToCache(context.Background(), addFriendToCacheReq) + if err != nil { + log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", err.Error()) + return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil + } + if respPb.CommonResp.ErrCode != 0 { + log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed") + return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil + } log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok") return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{}}, nil } @@ -262,6 +281,19 @@ func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFri } log.NewInfo(req.CommID.OperationID, "DeleteFriend rpc ok") chat.FriendDeletedNotification(req) + + reduceFriendFromCache := &pbCache.ReduceFriendFromCacheReq{OperationID: req.CommID.OperationID, UserID: req.CommID.FromUserID, FriendID: req.CommID.ToUserID} + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName) + client := pbCache.NewCacheClient(etcdConn) + respPb, err := client.ReduceFriendFromCache(context.Background(), reduceFriendFromCache) + if err != nil { + log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", err.Error()) + return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil + } + if respPb.CommonResp.ErrCode != 0 { + log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed") + return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil + } return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{}}, nil } diff --git a/pkg/base_info/user_api_struct.go b/pkg/base_info/user_api_struct.go index 10f20376c..b517f24de 100644 --- a/pkg/base_info/user_api_struct.go +++ b/pkg/base_info/user_api_struct.go @@ -32,3 +32,21 @@ type GetSelfUserInfoResp struct { UserInfo *open_im_sdk.UserInfo `json:"-"` Data map[string]interface{} `json:"data"` } + +type GetFriendIDListFromCacheReq struct { + OperationID string `json:"operationID" binding:"required"` +} + +type GetFriendIDListFromCacheResp struct { + CommResp + UserIDList []string `json:"userIDList" binding:"required"` +} + +type GetBlackIDListFromCacheReq struct { + OperationID string `json:"operationID" binding:"required"` +} + +type GetBlackIDListFromCacheResp struct { + CommResp + UserIDList []string `json:"userIDList" binding:"required"` +} diff --git a/pkg/common/db/redisModel.go b/pkg/common/db/redisModel.go index e441e1ff9..4510464c7 100644 --- a/pkg/common/db/redisModel.go +++ b/pkg/common/db/redisModel.go @@ -165,13 +165,8 @@ func (d *DataBases) SearchContentType() { } -func (d *DataBases) SetUserInfoToCache(userInfo *pbCommon.UserInfo) error { - b, _ := json.Marshal(&userInfo) - m := map[string]interface{}{} - if err := json.Unmarshal(b, &m); err != nil { - return err - } - _, err := d.Exec("hmset", userInfoCache+userInfo.UserID, redis.Args{}.Add().AddFlat(m)...) +func (d *DataBases) SetUserInfoToCache(userID string, m map[string]interface{}) error { + _, err := d.Exec("hmset", userInfoCache+userID, redis.Args{}.Add().AddFlat(m)...) return err } diff --git a/pkg/common/utils/utils.go b/pkg/common/utils/utils.go index 003f659a9..cf7019492 100644 --- a/pkg/common/utils/utils.go +++ b/pkg/common/utils/utils.go @@ -154,8 +154,3 @@ func UserDBCopyOpenIM(dst *open_im_sdk.UserInfo, src *db.User) { func UserDBCopyOpenIMPublicUser(dst *open_im_sdk.PublicUserInfo, src *db.User) { utils.CopyStructFields(dst, src) } - -// -//func PublicUserDBCopyOpenIM(dst *open_im_sdk.PublicUserInfo, src *db.User){ -// -//} diff --git a/pkg/utils/utils.go b/pkg/utils/utils.go index 52cb1bf2e..86b1be180 100644 --- a/pkg/utils/utils.go +++ b/pkg/utils/utils.go @@ -1,6 +1,10 @@ package utils import ( + "bytes" + "encoding/json" + "github.com/gogo/protobuf/jsonpb" + "github.com/golang/protobuf/proto" "github.com/jinzhu/copier" "github.com/pkg/errors" "math/rand" @@ -131,3 +135,18 @@ func RemoveRepeatedStringInList(slc []string) []string { } return result } + +func Pb2Map(pb proto.Message) (map[string]interface{}, error) { + _buffer := bytes.Buffer{} + jsonbMarshaller := &jsonpb.Marshaler{ + OrigName: true, + EnumsAsInts: true, + EmitDefaults: true, + } + _ = jsonbMarshaller.Marshal(&_buffer, pb) + jsonCnt := _buffer.Bytes() + var out map[string]interface{} + err := json.Unmarshal(jsonCnt, &out) + + return out, err +}