1

internal/rpc/friend/callback.go

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

internal/rpc/friend/friend.go

@@ -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"
@@ -33,6 +32,9 @@ type friendServer struct {
 	rpcRegisterName    string
 	etcdSchema         string
 	etcdAddr           []string
+	friendModel        *imdb.Friend
+	friendRequestModel *imdb.FriendRequest
+	blackModel         *imdb.Black
 }
 
 func NewFriendServer(port int) *friendServer {
@@ -42,6 +44,9 @@ func NewFriendServer(port int) *friendServer {
 		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())
+	resp := &pbFriend.AddBlacklistResp{}
-	ok := token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID)
+	if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil {
-	if !ok {
+		return nil, err
-		return &pbFriend.AddBlacklistResp{CommonResp: constant.Error2CommResp(ctx, constant.ErrNoPermission, "accress")}, nil
 	}
 	black := imdb.Black{OwnerUserID: req.CommID.FromUserID, BlockUserID: req.CommID.ToUserID, OperatorUserID: req.CommID.OpUserID}
-	err := imdb.InsertInToUserBlackList(ctx, black)
+	if err := s.blackModel.Create(ctx, []*imdb.Black{&black}); err != nil {
+		return nil, err
+	}
+	etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
 	if err != nil {
-		return &pbFriend.AddBlacklistResp{CommonResp: constant.Error2CommResp(ctx, constant.ErrDatabase, err.Error())}, 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)
+	_, err = pbCache.NewCacheClient(etcdConn).DelBlackIDListFromCache(ctx, &pbCache.DelBlackIDListFromCacheReq{UserID: req.CommID.FromUserID, OperationID: req.CommID.OperationID})
-	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})
 	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
 	}
 	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())
+	resp := &pbFriend.AddFriendResp{}
-	ok := token_verify.CheckAccess(ctx, req.CommID.OpUserID, req.CommID.FromUserID)
+	if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil {
-	if !ok {
+		return nil, err
-		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
 	}
-
+	if err := callbackBeforeAddFriendV1(req); err != nil {
-	callbackResp := callbackBeforeAddFriend(req)
+		return nil, err
-	if callbackResp.ErrCode != 0 {
-		log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg resp: ", callbackResp)
 	}
-	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
-	}
-	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 nil, err
-		return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
 	}
 	userIDList2, err := rocksCache.GetFriendIDListFromCache(ctx, req.CommID.FromUserID)
 	if err != nil {
-		log.NewError(req.CommID.OperationID, "GetUserByUserID failed ", err.Error(), req.CommID.FromUserID)
+		return nil, err
-		return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
 	}
-	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 {
+		if _, err := GetUserInfo(ctx, req.CommID.ToUserID); err != nil {
-			log.NewError(req.CommID.OperationID, "GetUserByUserID failed ", err.Error(), req.CommID.ToUserID)
+			return nil, err
-			return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 		}
 		friendRequest := imdb.FriendRequest{
-			HandleResult: 0, ReqMsg: req.ReqMsg, CreateTime: time.Now()}
+			FromUserID:   req.CommID.FromUserID,
-		utils.CopyStructFields(&friendRequest, req.CommID)
+			ToUserID:     req.CommID.ToUserID,
-		// {openIM001 openIM002 0 test add friend 0001-01-01 00:00:00 +0000 UTC   0001-01-01 00:00:00 +0000 UTC }]
+			HandleResult: 0,
-		log.NewDebug(req.CommID.OperationID, "UpdateFriendApplication args ", friendRequest)
+			ReqMsg:       req.ReqMsg,
-		//err := imdb.InsertFriendApplication(&friendRequest)
+			CreateTime:   time.Now(),
-		err := imdb.InsertFriendApplication(&friendRequest,
+		}
-			map[string]interface{}{"handle_result": 0, "req_msg": friendRequest.ReqMsg, "create_time": friendRequest.CreateTime,
+		if err := s.friendRequestModel.Create(ctx, []*imdb.FriendRequest{&friendRequest}); err != nil {
-				"handler_user_id": "", "handle_msg": "", "handle_time": utils.UnixSecondToTime(0), "ex": ""})
+			return nil, err
-		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
 		}
-
 		chat.FriendApplicationNotification(req)
 	}
-	//Establish a latest relationship in the friend request table
+	return resp, nil
-
-	return &pbFriend.AddFriendResp{CommonResp: &sdkws.CommonResp{}}, 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

internal/rpc/friend/other.go

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

pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go

@@ -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 (*Friend) Create(ctx context.Context, friends []*Friend) (err error) {
+func NewFriend(db *gorm.DB) *Friend {
+	return &Friend{db: db}
+}
+
+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
 }

pkg/common/db/mysql_model/im_mysql_model/friend_request_model.go

@@ -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 {
+func NewFriendRequest(db *gorm.DB) *FriendRequest {
-	return "friend_requests"
+	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

pkg/common/db/mysql_model/im_mysql_model/user_black_list_model.go

@@ -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 (*Black) Create(ctx context.Context, blacks []*Black) (err error) {
+func NewBlack(db *gorm.DB) *Black {
+	return &Black{db: db}
+}
+
+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
 	}