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 9b070bd8df
commit 176c65ebaf
6 changed files with 152 additions and 104 deletions
Show Stats Download Patch File Download Diff File

11
internal/rpc/friend/callback.go
Unescape View File

@ -12,6 +12,17 @@ import (
http2 "net/http"
)
func callbackBeforeAddFriendV1(req *pbFriend.AddFriendReq) error {
resp := callbackBeforeAddFriend(req)
if resp.ErrCode != 0 {
return (&constant.ErrInfo{
ErrCode: resp.ErrCode,
ErrMsg: resp.ErrMsg,
}).Wrap()
}
return nil
}
func callbackBeforeAddFriend(req *pbFriend.AddFriendReq) cbApi.CommonCallbackResp {
callbackResp := cbApi.CommonCallbackResp{OperationID: req.CommID.OperationID}
if !config.Config.Callback.CallbackBeforeAddFriend.Enable {

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

@ -7,17 +7,16 @@ import (
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
rocksCache "Open_IM/pkg/common/db/rocks_cache"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/middleware"
promePkg "Open_IM/pkg/common/prometheus"
"Open_IM/pkg/common/token_verify"
cp "Open_IM/pkg/common/utils"
"Open_IM/pkg/getcdv3"
pbCache "Open_IM/pkg/proto/cache"
pbFriend "Open_IM/pkg/proto/friend"
sdkws "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"context"
"errors"
"fmt"
"github.com/OpenIMSDK/getcdv3"
"net"
"strconv"
"strings"
@ -29,19 +28,25 @@ import (
)
type friendServer struct {
rpcPort int
rpcRegisterName string
etcdSchema string
etcdAddr []string
rpcPort int
rpcRegisterName string
etcdSchema string
etcdAddr []string
friendModel *imdb.Friend
friendRequestModel *imdb.FriendRequest
blackModel *imdb.Black
}
func NewFriendServer(port int) *friendServer {
log.NewPrivateLog(constant.LogFileName)
return &friendServer{
rpcPort: port,
rpcRegisterName: config.Config.RpcRegisterName.OpenImFriendName,
etcdSchema: config.Config.Etcd.EtcdSchema,
etcdAddr: config.Config.Etcd.EtcdAddr,
rpcPort: port,
rpcRegisterName: config.Config.RpcRegisterName.OpenImFriendName,
etcdSchema: config.Config.Etcd.EtcdSchema,
etcdAddr: config.Config.Etcd.EtcdAddr,
friendModel: imdb.NewFriend(nil),
friendRequestModel: imdb.NewFriendRequest(nil),
blackModel: imdb.NewBlack(nil),
}
}
@ -65,6 +70,7 @@ func (s *friendServer) Run() {
defer listener.Close()
//grpc server
var grpcOpts []grpc.ServerOption
grpcOpts = append(grpcOpts, grpc.UnaryInterceptor(middleware.RpcServerInterceptor))
if config.Config.Prometheus.Enable {
promePkg.NewGrpcRequestCounter()
promePkg.NewGrpcRequestFailedCounter()
@ -100,67 +106,43 @@ func (s *friendServer) Run() {
}
func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlacklistReq) (*pbFriend.AddBlacklistResp, error) {
log.NewInfo(req.CommID.OperationID, "AddBlacklist args ", req.String())
ok := token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID)
if !ok {
return &pbFriend.AddBlacklistResp{CommonResp: constant.Error2CommResp(ctx, constant.ErrNoPermission, "accress")}, nil
resp := &pbFriend.AddBlacklistResp{}
if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil {
return nil, err
}
black := imdb.Black{OwnerUserID: req.CommID.FromUserID, BlockUserID: req.CommID.ToUserID, OperatorUserID: req.CommID.OpUserID}
err := imdb.InsertInToUserBlackList(ctx, black)
if err != nil {
return &pbFriend.AddBlacklistResp{CommonResp: constant.Error2CommResp(ctx, constant.ErrDatabase, err.Error())}, nil
if err := s.blackModel.Create(ctx, []*imdb.Black{&black}); err != nil {
return nil, err
}
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 {
return &pbFriend.AddBlacklistResp{CommonResp: constant.Error2CommResp(ctx, constant.ErrInternalServer, "conn is nil")}, nil
}
cacheClient := pbCache.NewCacheClient(etcdConn)
cacheResp, err := cacheClient.DelBlackIDListFromCache(ctx, &pbCache.DelBlackIDListFromCacheReq{UserID: req.CommID.FromUserID, OperationID: req.CommID.OperationID})
etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
if err != nil {
return &pbFriend.AddBlacklistResp{CommonResp: constant.Error2CommResp(ctx, constant.ErrInternalServer, err.Error())}, nil
return nil, err
}
if cacheResp.CommonResp.ErrCode != 0 {
err = errors.New(fmt.Sprintf("call DelBlackIDListFromCache rpc failed code is %d, err is %s, args is %s", cacheResp.CommonResp.ErrCode, cacheResp.CommonResp.ErrMsg, req.CommID.FromUserID))
return &pbFriend.AddBlacklistResp{CommonResp: constant.Error2CommResp(ctx, constant.ErrInternalServer, err.Error())}, nil
_, err = pbCache.NewCacheClient(etcdConn).DelBlackIDListFromCache(ctx, &pbCache.DelBlackIDListFromCacheReq{UserID: req.CommID.FromUserID, OperationID: req.CommID.OperationID})
if err != nil {
return nil, err
}
chat.BlackAddedNotification(req)
return &pbFriend.AddBlacklistResp{CommonResp: constant.Error2CommResp(ctx, constant.ErrNone, "")}, nil
return resp, nil
}
func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq) (*pbFriend.AddFriendResp, error) {
log.NewInfo(req.CommID.OperationID, "AddFriend args ", req.String())
ok := token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID)
if !ok {
log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}}, nil
}
callbackResp := callbackBeforeAddFriend(req)
if callbackResp.ErrCode != 0 {
log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg resp: ", callbackResp)
resp := &pbFriend.AddFriendResp{}
if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil {
return nil, err
}
if callbackResp.ActionCode != constant.ActionAllow {
if callbackResp.ErrCode == 0 {
callbackResp.ErrCode = 201
}
log.NewDebug(req.CommID.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{
ErrCode: int32(callbackResp.ErrCode),
ErrMsg: callbackResp.ErrMsg,
}}, nil
if err := callbackBeforeAddFriendV1(req); err != nil {
return nil, err
}
var isSend = true
userIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.CommID.ToUserID)
if err != nil {
log.NewError(req.CommID.OperationID, "GetFriendIDListFromCache failed ", err.Error(), req.CommID.ToUserID)
return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
return nil, err
}
userIDList2, err := rocksCache.GetFriendIDListFromCache(ctx, req.CommID.FromUserID)
if err != nil {
log.NewError(req.CommID.OperationID, "GetUserByUserID failed ", err.Error(), req.CommID.FromUserID)
return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
return nil, err
}
log.NewDebug(req.CommID.OperationID, "toUserID", userIDList, "fromUserID", userIDList2)
var isSend = true
for _, v := range userIDList {
if v == req.CommID.FromUserID {
for _, v2 := range userIDList2 {
@ -176,36 +158,27 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
//Cannot add non-existent users
if isSend {
if _, err := imdb.GetUserByUserID(req.CommID.ToUserID); err != nil {
log.NewError(req.CommID.OperationID, "GetUserByUserID failed ", err.Error(), req.CommID.ToUserID)
return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
if _, err := GetUserInfo(ctx, req.CommID.ToUserID); err != nil {
return nil, err
}
friendRequest := imdb.FriendRequest{
HandleResult: 0, ReqMsg: req.ReqMsg, CreateTime: time.Now()}
utils.CopyStructFields(&friendRequest, req.CommID)
// {openIM001 openIM002 0 test add friend 0001-01-01 00:00:00 +0000 UTC 0001-01-01 00:00:00 +0000 UTC }]
log.NewDebug(req.CommID.OperationID, "UpdateFriendApplication args ", friendRequest)
//err := imdb.InsertFriendApplication(&friendRequest)
err := imdb.InsertFriendApplication(&friendRequest,
map[string]interface{}{"handle_result": 0, "req_msg": friendRequest.ReqMsg, "create_time": friendRequest.CreateTime,
"handler_user_id": "", "handle_msg": "", "handle_time": utils.UnixSecondToTime(0), "ex": ""})
if err != nil {
log.NewError(req.CommID.OperationID, "UpdateFriendApplication failed ", err.Error(), friendRequest)
return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
FromUserID: req.CommID.FromUserID,
ToUserID: req.CommID.ToUserID,
HandleResult: 0,
ReqMsg: req.ReqMsg,
CreateTime: time.Now(),
}
if err := s.friendRequestModel.Create(ctx, []*imdb.FriendRequest{&friendRequest}); err != nil {
return nil, err
}
chat.FriendApplicationNotification(req)
}
//Establish a latest relationship in the friend request table
return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{}}, nil
return resp, nil
}
func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFriendReq) (*pbFriend.ImportFriendResp, error) {
log.NewInfo(req.OperationID, "ImportFriend args ", req.String())
resp := pbFriend.ImportFriendResp{CommonResp: &sdkws.CommonResp{}}
var c sdkws.CommonResp
if !utils.IsContain(req.OpUserID, config.Config.Manager.AppManagerUid) {
log.NewError(req.OperationID, "not authorized", req.OpUserID, config.Config.Manager.AppManagerUid)
c.ErrCode = constant.ErrNoPermission.ErrCode

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

@ -0,0 +1,10 @@
package friend
import (
"context"
"errors"
)
func GetUserInfo(ctx context.Context, userID string) (interface{}, error) {
return nil, errors.New("TODO:GetUserInfo")
}

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

@ -8,8 +8,6 @@ import (
"time"
)
var FriendDB *gorm.DB
type Friend struct {
OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"`
FriendUserID string `gorm:"column:friend_user_id;primary_key;size:64"`
@ -18,49 +16,54 @@ type Friend struct {
AddSource int32 `gorm:"column:add_source"`
OperatorUserID string `gorm:"column:operator_user_id;size:64"`
Ex string `gorm:"column:ex;size:1024"`
db *gorm.DB `gorm:"-"`
}
func NewFriend(db *gorm.DB) *Friend {
return &Friend{db: db}
}
func (*Friend) Create(ctx context.Context, friends []*Friend) (err error) {
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(FriendDB.Create(&friends).Error, "")
err = utils.Wrap(f.db.Create(&friends).Error, "")
return err
}
func (*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(FriendDB.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 in (?)", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "")
return err
}
func (*Friend) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
func (f *Friend) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
}()
return utils.Wrap(FriendDB.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
return utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
}
func (*Friend) Update(ctx context.Context, friends []*Friend) (err error) {
func (f *Friend) Update(ctx context.Context, friends []*Friend) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}()
return utils.Wrap(FriendDB.Updates(&friends).Error, "")
return utils.Wrap(f.db.Updates(&friends).Error, "")
}
func (*Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, err 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(FriendDB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
err = utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
return friends, err
}
func (*Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *Friend, err 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(FriendDB.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "")
err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "")
return friend, err
}

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

@ -1,7 +1,9 @@
package im_mysql_model
import (
"Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils"
"context"
"gorm.io/gorm"
"time"
)
@ -18,10 +20,56 @@ type FriendRequest struct {
HandleMsg string `gorm:"column:handle_msg;size:255"`
HandleTime time.Time `gorm:"column:handle_time"`
Ex string `gorm:"column:ex;size:1024"`
db *gorm.DB `gorm:"-"`
}
func (FriendRequest) TableName() string {
return "friend_requests"
func NewFriendRequest(db *gorm.DB) *FriendRequest {
return &FriendRequest{db: db}
}
func (f *FriendRequest) Create(ctx context.Context, friends []*FriendRequest) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}()
err = utils.Wrap(f.db.Create(&friends).Error, "")
return err
}
func (f *FriendRequest) Delete(ctx context.Context, fromUserID, toUserID string) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID)
}()
err = utils.Wrap(f.db.Where("from_user_id = ? and to_user_id = ?", fromUserID, toUserID).Delete(&FriendRequest{}).Error, "")
return err
}
func (f *FriendRequest) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
}()
return utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
}
func (f *FriendRequest) Update(ctx context.Context, friends []*FriendRequest) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}()
return utils.Wrap(f.db.Updates(&friends).Error, "")
}
func (f *FriendRequest) Find(ctx context.Context, ownerUserID string) (friends []*FriendRequest, 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
}
func (f *FriendRequest) Take(ctx context.Context, ownerUserID, friendUserID 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, "")
return friend, err
}
// who apply to add me

31
pkg/common/db/mysql_model/im_mysql_model/user_black_list_model.go
Unescape View File

@ -8,8 +8,6 @@ import (
"time"
)
var BlackDB *gorm.DB
type Black struct {
OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"`
BlockUserID string `gorm:"column:block_user_id;primary_key;size:64"`
@ -17,37 +15,42 @@ type Black struct {
AddSource int32 `gorm:"column:add_source"`
OperatorUserID string `gorm:"column:operator_user_id;size:64"`
Ex string `gorm:"column:ex;size:1024"`
db *gorm.DB `gorm:"-"`
}
func NewBlack(db *gorm.DB) *Black {
return &Black{db: db}
}
func (*Black) Create(ctx context.Context, blacks []*Black) (err error) {
func (b *Black) Create(ctx context.Context, blacks []*Black) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}()
return utils.Wrap(BlackDB.Create(&blacks).Error, "")
return utils.Wrap(b.db.Create(&blacks).Error, "")
}
func (*Black) Delete(ctx context.Context, blacks []*Black) (err error) {
func (b *Black) Delete(ctx context.Context, blacks []*Black) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}()
return utils.Wrap(GroupMemberDB.Delete(blacks).Error, "")
}
func (*Black) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) {
func (b *Black) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "args", args)
}()
return utils.Wrap(BlackDB.Where("block_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Updates(args).Error, "")
return utils.Wrap(b.db.Where("block_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Updates(args).Error, "")
}
func (*Black) Update(ctx context.Context, blacks []*Black) (err error) {
func (b *Black) Update(ctx context.Context, blacks []*Black) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}()
return utils.Wrap(BlackDB.Updates(&blacks).Error, "")
return utils.Wrap(b.db.Updates(&blacks).Error, "")
}
func (*Black) Find(ctx context.Context, blacks []Black) (blackList []*Black, err error) {
func (b *Black) Find(ctx context.Context, blacks []Black) (blackList []*Black, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks, "blackList", blackList)
}()
@ -58,15 +61,15 @@ func (*Black) Find(ctx context.Context, blacks []Black) (blackList []*Black, err
return blackList, utils.Wrap(GroupMemberDB.Where("(owner_user_id, block_user_id) in ?", where).Find(&blackList).Error, "")
}
func (*Black) Take(ctx context.Context, blackID string) (black *Black, err error) {
func (b *Black) Take(ctx context.Context, blackID string) (black *Black, err error) {
black = &Black{}
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blackID", blackID, "black", *black)
}()
return black, utils.Wrap(BlackDB.Where("black_id = ?", blackID).Take(black).Error, "")
return black, utils.Wrap(b.db.Where("black_id = ?", blackID).Take(black).Error, "")
}
func (*Black) FindByOwnerUserID(ctx context.Context, ownerUserID string) (blackList []*Black, err error) {
func (b *Black) FindByOwnerUserID(ctx context.Context, ownerUserID string) (blackList []*Black, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blackList", blackList)
}()
@ -101,7 +104,7 @@ func GetBlackListByUserID(ownerUserID string) ([]Black, error) {
func GetBlackIDListByUserID(ownerUserID string) ([]string, error) {
var blackIDList []string
err := BlackDB.Where("owner_user_id=?", ownerUserID).Pluck("block_user_id", &blackIDList).Error
err := b.db.Where("owner_user_id=?", ownerUserID).Pluck("block_user_id", &blackIDList).Error
if err != nil {
return nil, err
}

Write Preview
Loading…
Cancel
Save