From 62a67905af21b3ab4a2059ea16d42dffeb4195a2 Mon Sep 17 00:00:00 2001 From: withchao <993506633@qq.com> Date: Mon, 16 Jan 2023 15:53:40 +0800 Subject: [PATCH] 1 --- internal/rpc/friend/friend.go | 512 +++++------------- internal/rpc/friend/other.go | 4 + .../im_mysql_model/friend_model_k.go | 27 +- .../im_mysql_model/friend_request_model.go | 20 +- 4 files changed, 177 insertions(+), 386 deletions(-) diff --git a/internal/rpc/friend/friend.go b/internal/rpc/friend/friend.go index ebe24b7f1..c392f7fec 100644 --- a/internal/rpc/friend/friend.go +++ b/internal/rpc/friend/friend.go @@ -11,6 +11,7 @@ import ( promePkg "Open_IM/pkg/common/prometheus" "Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/tools" + "Open_IM/pkg/common/trace_log" cp "Open_IM/pkg/common/utils" "Open_IM/pkg/getcdv3" pbCache "Open_IM/pkg/proto/cache" @@ -18,6 +19,8 @@ import ( sdkws "Open_IM/pkg/proto/sdk_ws" "Open_IM/pkg/utils" "context" + "errors" + "gorm.io/gorm" "net" "strconv" "strings" @@ -45,7 +48,7 @@ func NewFriendServer(port int) *friendServer { rpcRegisterName: config.Config.RpcRegisterName.OpenImFriendName, etcdSchema: config.Config.Etcd.EtcdSchema, etcdAddr: config.Config.Etcd.EtcdAddr, - friendModel: imdb.NewFriend(nil), + friendModel: imdb.NewFriend(nil), // TODO friendRequestModel: imdb.NewFriendRequest(nil), blackModel: imdb.NewBlack(nil), } @@ -119,7 +122,7 @@ func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlackl if err != nil { return nil, err } - _, err = pbCache.NewCacheClient(etcdConn).DelBlackIDListFromCache(ctx, &pbCache.DelBlackIDListFromCacheReq{UserID: req.CommID.FromUserID, OperationID: req.CommID.OperationID}) + _, err = pbCache.NewCacheClient(etcdConn).DelBlackIDListFromCache(ctx, &pbCache.DelBlackIDListFromCacheReq{UserID: req.CommID.FromUserID}) if err != nil { return nil, err } @@ -179,199 +182,113 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFriendReq) (*pbFriend.ImportFriendResp, error) { resp := &pbFriend.ImportFriendResp{} - //var c sdkws.CommonResp if !utils.IsContain(tools.OpUserID(ctx), config.Config.Manager.AppManagerUid) { - //log.NewError(req.OperationID, "not authorized", req.OpUserID, config.Config.Manager.AppManagerUid) - //c.ErrCode = constant.ErrNoPermission.ErrCode - //c.ErrMsg = constant.ErrNoPermission.ErrMsg - //for _, userID := range req.FriendUserIDList { - // resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: -1}) - //} return nil, constant.ErrNoPermission.Wrap() } if _, err := GetUserInfo(ctx, req.FromUserID); err != nil { - //log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), req.FromUserID) - //c.ErrCode = constant.ErrDB.ErrCode - //c.ErrMsg = "this user not exists,cant not add friend" - //for _, userID := range req.FriendUserIDList { - // resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: -1}) - //} - //resp.CommonResp = &c return nil, err } - for _, userID := range req.FriendUserIDList { - if _, fErr := GetUserInfo(ctx, userID); fErr != nil { - resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: -1}) - } else { - if _, err := imdb.GetFriendRelationshipFromFriend(req.FromUserID, userID); err != nil { - //Establish two single friendship - toInsertFollow := imdb.Friend{OwnerUserID: req.FromUserID, FriendUserID: userID} - err1 := imdb.InsertToFriend(&toInsertFollow) - if err1 != nil { - log.NewError(req.OperationID, "InsertToFriend failed ", err1.Error(), toInsertFollow) - resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: -1}) - continue - } - toInsertFollow = imdb.Friend{OwnerUserID: userID, FriendUserID: req.FromUserID} - err2 := imdb.InsertToFriend(&toInsertFollow) - if err2 != nil { - log.NewError(req.OperationID, "InsertToFriend failed ", err2.Error(), toInsertFollow) - resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: -1}) - continue - } - resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: 0}) - log.NewDebug(req.OperationID, "UserIDResultList ", resp.UserIDResultList) - chat.FriendAddedNotification(req.OperationID, req.OpUserID, req.FromUserID, userID) + if _, err := GetUserInfo(ctx, userID); err != nil { + return nil, err + } + fs, err := s.friendModel.FindUserState(ctx, req.FromUserID, userID) + if err != nil { + return nil, err + } + var friends []*imdb.Friend + switch len(fs) { + case 1: + if fs[0].OwnerUserID == req.FromUserID { + friends = append(friends, &imdb.Friend{OwnerUserID: userID, FriendUserID: req.FromUserID}) } else { - log.NewWarn(req.OperationID, "GetFriendRelationshipFromFriend ok", req.FromUserID, userID) - resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: userID, Result: 0}) + friends = append(friends, &imdb.Friend{OwnerUserID: req.FromUserID, FriendUserID: userID}) } + case 0: + friends = append(friends, &imdb.Friend{OwnerUserID: userID, FriendUserID: req.FromUserID}, &imdb.Friend{OwnerUserID: req.FromUserID, FriendUserID: userID}) + default: + continue + } + if err := s.friendModel.Create(ctx, friends); err != nil { + return nil, err } } - - etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID, config.Config.Etcd.UserName, config.Config.Etcd.Password) - if etcdConn == nil { - errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil" - log.NewError(req.OperationID, errMsg) - resp.CommonResp.ErrMsg = errMsg - resp.CommonResp.ErrCode = 500 - return &resp, nil - } - cacheClient := pbCache.NewCacheClient(etcdConn) - cacheResp, err := cacheClient.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.FromUserID, OperationID: req.OperationID}) + etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName) if err != nil { - log.NewError(req.OperationID, "DelBlackIDListFromCache rpc call failed ", err.Error()) - resp.CommonResp.ErrCode = 500 - resp.CommonResp.ErrMsg = err.Error() - return &resp, nil + return nil, err } - if cacheResp.CommonResp.ErrCode != 0 { - log.NewError(req.OperationID, "DelBlackIDListFromCache rpc logic call failed ", cacheResp.String()) - resp.CommonResp.ErrCode = 500 - resp.CommonResp.ErrMsg = cacheResp.CommonResp.ErrMsg - return &resp, nil + cacheClient := pbCache.NewCacheClient(etcdConn) + if _, err := cacheClient.DelFriendIDListFromCache(ctx, &pbCache.DelFriendIDListFromCacheReq{UserID: req.FromUserID}); err != nil { + return nil, err } if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.FromUserID); err != nil { - log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.FromUserID) + trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "userID", req.FromUserID) } - for _, userID := range req.FriendUserIDList { - cacheResp, err := cacheClient.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: userID, OperationID: req.OperationID}) - if err != nil { - log.NewError(req.OperationID, "DelBlackIDListFromCache rpc call failed ", err.Error()) - } - if cacheResp != nil && cacheResp.CommonResp != nil { - if cacheResp.CommonResp.ErrCode != 0 { - log.NewError(req.OperationID, "DelBlackIDListFromCache rpc logic call failed ", cacheResp.String()) - resp.CommonResp.ErrCode = 500 - resp.CommonResp.ErrMsg = cacheResp.CommonResp.ErrMsg - return &resp, nil - } + if _, err = cacheClient.DelFriendIDListFromCache(ctx, &pbCache.DelFriendIDListFromCacheReq{UserID: userID}); err != nil { + return nil, err } if err := rocksCache.DelAllFriendsInfoFromCache(ctx, userID); err != nil { - log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), userID) + trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "userID", userID) } } - - resp.CommonResp.ErrCode = 0 - log.NewInfo(req.OperationID, "ImportFriend rpc ok ", resp.String()) - return &resp, nil + return resp, nil } // process Friend application func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddFriendResponseReq) (*pbFriend.AddFriendResponseResp, error) { - log.NewInfo(req.CommID.OperationID, "AddFriendResponse args ", req.String()) - if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) { - log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil + resp := &pbFriend.AddFriendResponseResp{} + if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil { + return nil, err } - - //Check there application before agreeing or refuse to a friend's application - //req.CommID.FromUserID process req.CommID.ToUserID - friendRequest, err := imdb.GetFriendApplicationByBothUserID(req.CommID.ToUserID, req.CommID.FromUserID) + friendRequest, err := s.friendRequestModel.Take(ctx, req.CommID.ToUserID, req.CommID.FromUserID) if err != nil { - log.NewError(req.CommID.OperationID, "GetFriendApplicationByBothUserID failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID) - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil + return nil, err } friendRequest.HandleResult = req.HandleResult friendRequest.HandleTime = time.Now() - //friendRequest.HandleTime.Unix() friendRequest.HandleMsg = req.HandleMsg friendRequest.HandlerUserID = req.CommID.OpUserID err = imdb.UpdateFriendApplication(friendRequest) if err != nil { - log.NewError(req.CommID.OperationID, "UpdateFriendApplication failed ", err.Error(), friendRequest) - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil + return nil, err } //Change the status of the friend request form if req.HandleResult == constant.FriendFlag { - var isInsert int + var isInsert bool //Establish friendship after find friend relationship not exists - _, err := imdb.GetFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID) - if err == nil { - log.NewWarn(req.CommID.OperationID, "GetFriendRelationshipFromFriend exist", req.CommID.FromUserID, req.CommID.ToUserID) - } else { - //Establish two single friendship - toInsertFollow := imdb.Friend{OwnerUserID: req.CommID.FromUserID, FriendUserID: req.CommID.ToUserID, OperatorUserID: req.CommID.OpUserID} - err = imdb.InsertToFriend(&toInsertFollow) - if err != nil { - log.NewError(req.CommID.OperationID, "InsertToFriend failed ", err.Error(), toInsertFollow) - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil + _, err := s.friendModel.Take(ctx, req.CommID.FromUserID, req.CommID.ToUserID) + if errors.Is(err, gorm.ErrRecordNotFound) { + if err := s.friendModel.Create(ctx, []*imdb.Friend{{OwnerUserID: req.CommID.FromUserID, FriendUserID: req.CommID.ToUserID, OperatorUserID: req.CommID.OpUserID}}); err != nil { + return nil, err } - isInsert = 1 + isInsert = true + } else if err != nil { + return nil, err } - _, err = imdb.GetFriendRelationshipFromFriend(req.CommID.ToUserID, req.CommID.FromUserID) - if err == nil { - log.NewWarn(req.CommID.OperationID, "GetFriendRelationshipFromFriend exist", req.CommID.ToUserID, req.CommID.FromUserID) - } else { - toInsertFollow := imdb.Friend{OwnerUserID: req.CommID.ToUserID, FriendUserID: req.CommID.FromUserID, OperatorUserID: req.CommID.OpUserID} - err = imdb.InsertToFriend(&toInsertFollow) - if err != nil { - log.NewError(req.CommID.OperationID, "InsertToFriend failed ", err.Error(), toInsertFollow) - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil - } - isInsert = 1 - } // cache rpc - if isInsert == 1 { - delFriendIDListFromCacheReq := &pbCache.DelFriendIDListFromCacheReq{OperationID: req.CommID.OperationID} - etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.CommID.OperationID, config.Config.Etcd.UserName, config.Config.Etcd.Password) - if etcdConn == nil { - errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil" - log.NewError(req.CommID.OperationID, errMsg) - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrInternalServer.ErrCode, ErrMsg: errMsg}}, nil - } - client := pbCache.NewCacheClient(etcdConn) - delFriendIDListFromCacheReq.UserID = req.CommID.ToUserID - respPb, err := client.DelFriendIDListFromCache(context.Background(), delFriendIDListFromCacheReq) + if isInsert { + etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName) if err != nil { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache failed", err.Error()) - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil - } - if respPb.CommonResp.ErrCode != 0 { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache failed", respPb.CommonResp.String()) - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil + return nil, err } - delFriendIDListFromCacheReq.UserID = req.CommID.FromUserID - respPb, err = client.DelFriendIDListFromCache(context.Background(), delFriendIDListFromCacheReq) - if err != nil { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache failed", err.Error()) - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil + client := pbCache.NewCacheClient(etcdConn) + + if _, err := client.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.CommID.ToUserID}); err != nil { + return nil, err } - if respPb.CommonResp.ErrCode != 0 { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache failed", respPb.CommonResp.String()) - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil + if _, err := client.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.CommID.FromUserID}); err != nil { + return nil, err } if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.ToUserID); err != nil { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.ToUserID) + trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "userID", req.CommID.ToUserID) } if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.FromUserID); err != nil { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.FromUserID) + trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "userID", req.CommID.FromUserID) } - chat.FriendAddedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID) + chat.FriendAddedNotification(tools.OperationID(ctx), tools.OpUserID(ctx), req.CommID.FromUserID, req.CommID.ToUserID) } } @@ -380,329 +297,174 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF } else if req.HandleResult == constant.FriendResponseRefuse { chat.FriendApplicationRejectedNotification(req) } else { - log.Error(req.CommID.OperationID, "HandleResult failed ", req.HandleResult) + trace_log.SetCtxInfo(ctx, utils.GetSelfFuncName(), nil, "handleResult", req.HandleResult) } - - log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok") - return &pbFriend.AddFriendResponseResp{CommonResp: &sdkws.CommonResp{}}, nil + return resp, nil } func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFriendReq) (*pbFriend.DeleteFriendResp, error) { - log.NewInfo(req.CommID.OperationID, "DeleteFriend args ", req.String()) - //Parse token, to find current user information - if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) { - log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) - return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil + resp := &pbFriend.DeleteFriendResp{} + if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil { + return nil, err } - err := imdb.DeleteSingleFriendInfo(req.CommID.FromUserID, req.CommID.ToUserID) - if err != nil { - log.NewError(req.CommID.OperationID, "DeleteSingleFriendInfo failed", err.Error(), req.CommID.FromUserID, req.CommID.ToUserID) - return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil + if err := s.friendModel.Delete(ctx, req.CommID.FromUserID, req.CommID.ToUserID); err != nil { + return nil, err } - log.NewInfo(req.CommID.OperationID, "DeleteFriend rpc ok") - - etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.CommID.OperationID, config.Config.Etcd.UserName, config.Config.Etcd.Password) - if etcdConn == nil { - errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil" - log.NewError(req.CommID.OperationID, errMsg) - return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrInternalServer.ErrCode, ErrMsg: errMsg}}, nil - } - client := pbCache.NewCacheClient(etcdConn) - respPb, err := client.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{OperationID: req.CommID.OperationID, UserID: req.CommID.FromUserID}) + etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName) if err != nil { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache rpc failed", err.Error()) - return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil + return nil, err } - if respPb.CommonResp.ErrCode != 0 { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "DelFriendIDListFromCache failed", respPb.CommonResp.String()) - return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil + _, err = pbCache.NewCacheClient(etcdConn).DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.CommID.FromUserID}) + if err != nil { + return nil, err } if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.FromUserID); err != nil { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.FromUserID) + trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "DelAllFriendsInfoFromCache", req.CommID.FromUserID) } if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.ToUserID); err != nil { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.FromUserID) + trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "DelAllFriendsInfoFromCache", req.CommID.ToUserID) } chat.FriendDeletedNotification(req) - return &pbFriend.DeleteFriendResp{CommonResp: &sdkws.CommonResp{}}, nil + return resp, nil } func (s *friendServer) GetBlacklist(ctx context.Context, req *pbFriend.GetBlacklistReq) (*pbFriend.GetBlacklistResp, error) { - log.NewInfo(req.CommID.OperationID, "GetBlacklist args ", req.String()) - - if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) { - log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) - return &pbFriend.GetBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil + resp := &pbFriend.GetBlacklistResp{} + if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil { + return nil, err } - blackIDList, err := rocksCache.GetBlackListFromCache(ctx, req.CommID.FromUserID) if err != nil { - log.NewError(req.CommID.OperationID, "GetBlackListByUID failed ", err.Error(), req.CommID.FromUserID) - return &pbFriend.GetBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil + return nil, err } - - var ( - userInfoList []*sdkws.PublicUserInfo - ) for _, userID := range blackIDList { user, err := rocksCache.GetUserInfoFromCache(ctx, userID) if err != nil { - log.NewError(req.CommID.OperationID, "GetUserByUserID failed ", err.Error(), userID) + trace_log.SetCtxInfo(ctx, "GetUserInfoFromCache", err, "userID", userID) continue } var blackUserInfo sdkws.PublicUserInfo utils.CopyStructFields(&blackUserInfo, user) - userInfoList = append(userInfoList, &blackUserInfo) + resp.BlackUserInfoList = append(resp.BlackUserInfoList, &blackUserInfo) } - log.NewInfo(req.CommID.OperationID, "rpc GetBlacklist ok ", pbFriend.GetBlacklistResp{BlackUserInfoList: userInfoList}) - return &pbFriend.GetBlacklistResp{BlackUserInfoList: userInfoList}, nil + return resp, nil } func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFriendRemarkReq) (*pbFriend.SetFriendRemarkResp, error) { - log.NewInfo(req.CommID.OperationID, "SetFriendComment args ", req.String()) - //Parse token, to find current user information - if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) { - log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) - return &pbFriend.SetFriendRemarkResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil + resp := &pbFriend.SetFriendRemarkResp{} + if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil { + return nil, err } - - err := imdb.UpdateFriendComment(req.CommID.FromUserID, req.CommID.ToUserID, req.Remark) - if err != nil { - log.NewError(req.CommID.OperationID, "UpdateFriendComment failed ", req.CommID.FromUserID, req.CommID.ToUserID, req.Remark, err.Error()) - return &pbFriend.SetFriendRemarkResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil + if err := s.friendModel.UpdateRemark(ctx, req.CommID.FromUserID, req.CommID.ToUserID, req.Remark); err != nil { + return nil, err } - log.NewInfo(req.CommID.OperationID, "rpc SetFriendComment ok") - err = rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.FromUserID) - if err != nil { - log.NewError(req.CommID.OperationID, "DelAllFriendInfoFromCache failed ", req.CommID.FromUserID, err.Error()) - return &pbFriend.SetFriendRemarkResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil + if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.FromUserID); err != nil { + return nil, err } - chat.FriendRemarkSetNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID) - return &pbFriend.SetFriendRemarkResp{CommonResp: &sdkws.CommonResp{}}, nil + chat.FriendRemarkSetNotification(tools.OperationID(ctx), tools.OpUserID(ctx), req.CommID.FromUserID, req.CommID.ToUserID) + return resp, nil } func (s *friendServer) RemoveBlacklist(ctx context.Context, req *pbFriend.RemoveBlacklistReq) (*pbFriend.RemoveBlacklistResp, error) { - log.NewInfo(req.CommID.OperationID, "RemoveBlacklist args ", req.String()) + resp := &pbFriend.RemoveBlacklistResp{} //Parse token, to find current user information - if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) { - log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) - return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil - } - err := imdb.RemoveBlackList(req.CommID.FromUserID, req.CommID.ToUserID) - if err != nil { - log.NewError(req.CommID.OperationID, "RemoveBlackList failed", err.Error(), req.CommID.FromUserID, req.CommID.ToUserID) - return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil - + if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil { + return nil, err } - log.NewInfo(req.CommID.OperationID, "rpc RemoveBlacklist ok ") - - etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.CommID.OperationID, config.Config.Etcd.UserName, config.Config.Etcd.Password) - if etcdConn == nil { - errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil" - log.NewError(req.CommID.OperationID, errMsg) - return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrInternalServer.ErrCode, ErrMsg: errMsg}}, nil + if err := s.blackModel.Delete(ctx, []*imdb.Black{{OwnerUserID: req.CommID.FromUserID, BlockUserID: req.CommID.ToUserID}}); err != nil { + return nil, err } - - cacheClient := pbCache.NewCacheClient(etcdConn) - cacheResp, err := cacheClient.DelBlackIDListFromCache(context.Background(), &pbCache.DelBlackIDListFromCacheReq{UserID: req.CommID.FromUserID, OperationID: req.CommID.OperationID}) + etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName) if err != nil { - log.NewError(req.CommID.OperationID, "DelBlackIDListFromCache rpc call failed ", err.Error()) - return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: 500, ErrMsg: "ReduceBlackUserFromCache rpc call failed"}}, nil + return nil, err } - if cacheResp.CommonResp.ErrCode != 0 { - log.NewError(req.CommID.OperationID, "DelBlackIDListFromCache rpc logic call failed ", cacheResp.CommonResp.String()) - return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}}, nil + _, err = pbCache.NewCacheClient(etcdConn).DelBlackIDListFromCache(context.Background(), &pbCache.DelBlackIDListFromCacheReq{UserID: req.CommID.FromUserID}) + if err != nil { + return nil, err } chat.BlackDeletedNotification(req) - return &pbFriend.RemoveBlacklistResp{CommonResp: &sdkws.CommonResp{}}, nil + return resp, nil } func (s *friendServer) IsInBlackList(ctx context.Context, req *pbFriend.IsInBlackListReq) (*pbFriend.IsInBlackListResp, error) { - log.NewInfo("IsInBlackList args ", req.String()) - if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) { - log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) - return &pbFriend.IsInBlackListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil + resp := &pbFriend.IsInBlackListResp{} + if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil { + return nil, err } blackIDList, err := rocksCache.GetBlackListFromCache(ctx, req.CommID.FromUserID) if err != nil { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.FromUserID) - return &pbFriend.IsInBlackListResp{CommonResp: &sdkws.CommonResp{ErrMsg: err.Error(), ErrCode: constant.ErrDB.ErrCode}}, nil - } - var isInBlacklist bool - if utils.IsContain(req.CommID.ToUserID, blackIDList) { - isInBlacklist = true + return nil, err } - log.NewInfo(req.CommID.OperationID, "IsInBlackList rpc ok ", pbFriend.IsInBlackListResp{Response: isInBlacklist}) - return &pbFriend.IsInBlackListResp{Response: isInBlacklist}, nil + resp.Response = utils.IsContain(req.CommID.ToUserID, blackIDList) + return resp, nil } func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq) (*pbFriend.IsFriendResp, error) { - log.NewInfo(req.CommID.OperationID, req.String()) - if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) { - log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) - return &pbFriend.IsFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil + resp := &pbFriend.IsFriendResp{} + if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil { + return nil, err } friendIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.CommID.FromUserID) if err != nil { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), req.CommID.FromUserID) - return &pbFriend.IsFriendResp{CommonResp: &sdkws.CommonResp{ErrMsg: err.Error(), ErrCode: constant.ErrDB.ErrCode}}, nil - } - var isFriend bool - if utils.IsContain(req.CommID.ToUserID, friendIDList) { - isFriend = true + return nil, err } - log.NewInfo(req.CommID.OperationID, pbFriend.IsFriendResp{Response: isFriend}) - return &pbFriend.IsFriendResp{Response: isFriend}, nil + resp.Response = utils.IsContain(req.CommID.ToUserID, friendIDList) + return resp, nil } func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFriendListReq) (*pbFriend.GetFriendListResp, error) { - log.NewInfo("GetFriendList args ", req.String()) - if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) { - log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) - return &pbFriend.GetFriendListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil + resp := &pbFriend.GetFriendListResp{} + if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil { + return nil, err } friendList, err := rocksCache.GetAllFriendsInfoFromCache(ctx, req.CommID.FromUserID) if err != nil { - log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "GetFriendIDListFromCache failed", err.Error(), req.CommID.FromUserID) - return &pbFriend.GetFriendListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil + return nil, err } - var userInfoList []*sdkws.FriendInfo for _, friendUser := range friendList { friendUserInfo := sdkws.FriendInfo{FriendUser: &sdkws.UserInfo{}} cp.FriendDBCopyOpenIM(&friendUserInfo, friendUser) - log.NewDebug(req.CommID.OperationID, "friends : ", friendUser, "openim friends: ", friendUserInfo) userInfoList = append(userInfoList, &friendUserInfo) } - log.NewInfo(req.CommID.OperationID, "rpc GetFriendList ok", pbFriend.GetFriendListResp{FriendInfoList: userInfoList}) - return &pbFriend.GetFriendListResp{FriendInfoList: userInfoList}, nil + return resp, nil } // received func (s *friendServer) GetFriendApplyList(ctx context.Context, req *pbFriend.GetFriendApplyListReq) (*pbFriend.GetFriendApplyListResp, error) { - log.NewInfo(req.CommID.OperationID, "GetFriendApplyList args ", req.String()) + resp := &pbFriend.GetFriendApplyListResp{} //Parse token, to find current user information - if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) { - log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) - return &pbFriend.GetFriendApplyListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil + if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil { + return nil, err } // Find the current user friend applications received - ApplyUsersInfo, err := imdb.GetReceivedFriendsApplicationListByUserID(req.CommID.FromUserID) + applyUsersInfo, err := s.friendRequestModel.FindToUserID(ctx, req.CommID.FromUserID) if err != nil { - log.NewError(req.CommID.OperationID, "GetReceivedFriendsApplicationListByUserID ", err.Error(), req.CommID.FromUserID) - return &pbFriend.GetFriendApplyListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil + return nil, err } - - var appleUserList []*sdkws.FriendRequest - for _, applyUserInfo := range ApplyUsersInfo { + for _, applyUserInfo := range applyUsersInfo { var userInfo sdkws.FriendRequest - cp.FriendRequestDBCopyOpenIM(&userInfo, &applyUserInfo) - // utils.CopyStructFields(&userInfo, applyUserInfo) - // u, err := imdb.GetUserByUserID(userInfo.FromUserID) - // if err != nil { - // log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.FromUserID) - // continue - // } - // userInfo.FromNickname = u.Nickname - // userInfo.FromFaceURL = u.FaceURL - // userInfo.FromGender = u.Gender - // - // u, err = imdb.GetUserByUserID(userInfo.ToUserID) - // if err != nil { - // log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.ToUserID) - // continue - // } - // userInfo.ToNickname = u.Nickname - // userInfo.ToFaceURL = u.FaceURL - // userInfo.ToGender = u.Gender - appleUserList = append(appleUserList, &userInfo) + cp.FriendRequestDBCopyOpenIM(&userInfo, applyUserInfo) + resp.FriendRequestList = append(resp.FriendRequestList, &userInfo) } - - log.NewInfo(req.CommID.OperationID, "rpc GetFriendApplyList ok", pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList}) - return &pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList}, nil + return resp, nil } func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetSelfApplyListReq) (*pbFriend.GetSelfApplyListResp, error) { - log.NewInfo(req.CommID.OperationID, "GetSelfApplyList args ", req.String()) - + resp := &pbFriend.GetSelfApplyListResp{} //Parse token, to find current user information - if !token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID) { - log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID) - return &pbFriend.GetSelfApplyListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil - + if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil { + return nil, err } // Find the self add other userinfo - usersInfo, err := imdb.GetSendFriendApplicationListByUserID(req.CommID.FromUserID) + usersInfo, err := s.friendRequestModel.FindFromUserID(ctx, req.CommID.FromUserID) if err != nil { - log.NewError(req.CommID.OperationID, "GetSendFriendApplicationListByUserID failed ", err.Error(), req.CommID.FromUserID) - return &pbFriend.GetSelfApplyListResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil + return nil, err } - var selfApplyOtherUserList []*sdkws.FriendRequest for _, selfApplyOtherUserInfo := range usersInfo { var userInfo sdkws.FriendRequest // pbFriend.ApplyUserInfo - cp.FriendRequestDBCopyOpenIM(&userInfo, &selfApplyOtherUserInfo) - //u, err := imdb.GetUserByUserID(userInfo.FromUserID) - //if err != nil { - // log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.FromUserID) - // continue - //} - //userInfo.FromNickname = u.Nickname - //userInfo.FromFaceURL = u.FaceURL - //userInfo.FromGender = u.Gender - // - //u, err = imdb.GetUserByUserID(userInfo.ToUserID) - //if err != nil { - // log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.ToUserID) - // continue - //} - //userInfo.ToNickname = u.Nickname - //userInfo.ToFaceURL = u.FaceURL - //userInfo.ToGender = u.Gender - - selfApplyOtherUserList = append(selfApplyOtherUserList, &userInfo) + cp.FriendRequestDBCopyOpenIM(&userInfo, selfApplyOtherUserInfo) + resp.FriendRequestList = append(resp.FriendRequestList, &userInfo) } - log.NewInfo(req.CommID.OperationID, "rpc GetSelfApplyList ok", pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList}) - return &pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList}, nil + return resp, nil } - -//// -//func (s *friendServer) GetFriendsInfo(ctx context.Context, req *pbFriend.GetFriendsInfoReq) (*pbFriend.GetFriendInfoResp, error) { -// return nil, nil -//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo args ", req.String()) -//// var ( -//// isInBlackList int32 -//// // isFriend int32 -//// comment string -//// ) -//// -//// friendShip, err := imdb.FindFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID) -//// if err != nil { -//// log.NewError(req.CommID.OperationID, "FindFriendRelationshipFromFriend failed ", err.Error()) -//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil -//// // isFriend = constant.FriendFlag -//// } -//// comment = friendShip.Remark -//// -//// friendUserInfo, err := imdb.FindUserByUID(req.CommID.ToUserID) -//// if err != nil { -//// log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error()) -//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil -//// } -//// -//// err = imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, req.CommID.ToUserID) -//// if err == nil { -//// isInBlackList = constant.BlackListFlag -//// } -//// -//// resp := pbFriend.GetFriendInfoResp{ErrCode: 0, ErrMsg: "",} -//// -//// utils.CopyStructFields(resp.FriendInfoList, friendUserInfo) -//// resp.Data.IsBlack = isInBlackList -//// resp.Data.OwnerUserID = req.CommID.FromUserID -//// resp.Data.Remark = comment -//// resp.Data.CreateTime = friendUserInfo.CreateTime -//// -//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo ok ", resp) -//// return &resp, nil -//// -//} diff --git a/internal/rpc/friend/other.go b/internal/rpc/friend/other.go index 592f9eada..3beebfada 100644 --- a/internal/rpc/friend/other.go +++ b/internal/rpc/friend/other.go @@ -8,3 +8,7 @@ import ( func GetUserInfo(ctx context.Context, userID string) (interface{}, error) { return nil, errors.New("TODO:GetUserInfo") } + +func GetUserInfoBatch(ctx context.Context, userIDs []string) (interface{}, error) { + return nil, errors.New("TODO:GetUserInfo") +} diff --git a/pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go b/pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go index 9f2105079..cdb317db9 100644 --- a/pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go +++ b/pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go @@ -27,15 +27,14 @@ func (f *Friend) Create(ctx context.Context, friends []*Friend) (err error) { defer func() { trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends) }() - err = utils.Wrap(f.db.Create(&friends).Error, "") - return err + return utils.Wrap(f.db.Create(&friends).Error, "") } -func (f *Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs []string) (err error) { +func (f *Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs string) (err error) { defer func() { trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs) }() - err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id in (?)", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "") + err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "") return err } @@ -53,17 +52,29 @@ func (f *Friend) Update(ctx context.Context, friends []*Friend) (err error) { return utils.Wrap(f.db.Updates(&friends).Error, "") } +func (f *Friend) UpdateRemark(ctx context.Context, ownerUserID, friendUserID, remark string) (err error) { + defer func() { + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "remark", remark) + }() + return utils.Wrap(f.db.Model(f).Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserID).Update("remark", remark).Error, "") +} + func (f *Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, err error) { defer func() { trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends) }() - err = utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "") - return friends, err + return friends, utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "") } func (f *Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *Friend, err error) { friend = &Friend{} defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "group", *friend) - err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "") - return friend, err + return friend, utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "") +} + +func (f *Friend) FindUserState(ctx context.Context, userID1, userID2 string) (friends []*Friend, err error) { + defer func() { + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "userID1", userID1, "userID2", userID2) + }() + return friends, utils.Wrap(f.db.Where("(owner_user_id = ? and friend_user_id = ?) or (owner_user_id = ? and friend_user_id = ?)", userID1, userID2, userID2, userID1).Find(&friends).Error, "") } diff --git a/pkg/common/db/mysql_model/im_mysql_model/friend_request_model.go b/pkg/common/db/mysql_model/im_mysql_model/friend_request_model.go index ce0563c29..fe2d9f33c 100644 --- a/pkg/common/db/mysql_model/im_mysql_model/friend_request_model.go +++ b/pkg/common/db/mysql_model/im_mysql_model/friend_request_model.go @@ -65,13 +65,27 @@ func (f *FriendRequest) Find(ctx context.Context, ownerUserID string) (friends [ return friends, err } -func (f *FriendRequest) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *FriendRequest, err error) { +func (f *FriendRequest) Take(ctx context.Context, fromUserID, toUserID string) (friend *FriendRequest, err error) { friend = &FriendRequest{} - defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "group", *friend) - err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "") + defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID, "friend", friend) + err = utils.Wrap(f.db.Where("from_user_id = ? and to_user_id", fromUserID, toUserID).Take(friend).Error, "") return friend, err } +func (f *FriendRequest) FindToUserID(ctx context.Context, toUserID string) (friends []*FriendRequest, err error) { + defer func() { + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "toUserID", toUserID, "friends", friends) + }() + return friends, utils.Wrap(f.db.Where("to_user_id = ?", toUserID).Find(&friends).Error, "") +} + +func (f *FriendRequest) FindFromUserID(ctx context.Context, fromUserID string) (friends []*FriendRequest, err error) { + defer func() { + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "friends", friends) + }() + return friends, utils.Wrap(f.db.Where("from_user_id = ?", fromUserID).Find(&friends).Error, "") +} + // who apply to add me func GetReceivedFriendsApplicationListByUserID(ToUserID string) ([]FriendRequest, error) { var usersInfo []FriendRequest