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

1

Browse Source
test-errcode
withchao 3 years ago
parent 033d1e0919
commit 62a67905af
4 changed files with 177 additions and 386 deletions
Show Stats Download Patch File Download Diff File

506
internal/rpc/friend/friend.go
Unescape View File

@ -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
if _, err := GetUserInfo(ctx, userID); err != nil {
return nil, err
}
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
fs, err := s.friendModel.FindUserState(ctx, req.FromUserID, userID)
if err != nil {
return nil, err
}
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)
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
}
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
resp := &pbFriend.DeleteFriendResp{}
if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); 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
if err := s.friendModel.Delete(ctx, req.CommID.FromUserID, req.CommID.ToUserID); err != nil {
return nil, err
}
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
////
//}

4
internal/rpc/friend/other.go
Unescape View File

@ -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")
}

27
pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go
Unescape View File

@ -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, "")
}

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

@ -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

Write Preview
Loading…
Cancel
Save