Merge branch 'errcode' of github.com:OpenIMSDK/Open-IM-Server into errcode

internal/rpc/friend/friend.go

@@ -4,6 +4,7 @@ import (
 	chat "Open_IM/internal/rpc/msg"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
 	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
 	rocksCache "Open_IM/pkg/common/db/rocks_cache"
 	"Open_IM/pkg/common/log"
@@ -11,6 +12,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 +20,8 @@ import (
 	sdkws "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"context"
+	"errors"
+	"gorm.io/gorm"
 	"net"
 	"strconv"
 	"strings"
@@ -40,14 +44,15 @@ type friendServer struct {
 
 func NewFriendServer(port int) *friendServer {
 	log.NewPrivateLog(constant.LogFileName)
+	DB := db.DB.MysqlDB.DefaultGormDB()
 	return &friendServer{
 		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),
+		friendModel:        imdb.NewFriend(DB),
+		friendRequestModel: imdb.NewFriendRequest(DB),
+		blackModel:         imdb.NewBlack(DB),
 	}
 }
 
@@ -108,10 +113,10 @@ func (s *friendServer) Run() {
 
 func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlacklistReq) (*pbFriend.AddBlacklistResp, error) {
 	resp := &pbFriend.AddBlacklistResp{}
-	if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil {
+	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
 		return nil, err
 	}
-	black := imdb.Black{OwnerUserID: req.CommID.FromUserID, BlockUserID: req.CommID.ToUserID, OperatorUserID: req.CommID.OpUserID}
+	black := imdb.Black{OwnerUserID: req.FromUserID, BlockUserID: req.ToUserID, OperatorUserID: tools.OpUserID(ctx)}
 	if err := s.blackModel.Create(ctx, []*imdb.Black{&black}); err != nil {
 		return nil, err
 	}
@@ -119,7 +124,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.FromUserID})
 	if err != nil {
 		return nil, err
 	}
@@ -129,25 +134,25 @@ func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlackl
 
 func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq) (*pbFriend.AddFriendResp, error) {
 	resp := &pbFriend.AddFriendResp{}
-	if err := token_verify.CheckAccessV3(ctx, req.CommID.FromUserID); err != nil {
+	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
 		return nil, err
 	}
 	if err := callbackBeforeAddFriendV1(req); err != nil {
 		return nil, err
 	}
-	userIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.CommID.ToUserID)
+	userIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.ToUserID)
 	if err != nil {
 		return nil, err
 	}
-	userIDList2, err := rocksCache.GetFriendIDListFromCache(ctx, req.CommID.FromUserID)
+	userIDList2, err := rocksCache.GetFriendIDListFromCache(ctx, req.FromUserID)
 	if err != nil {
 		return nil, err
 	}
 	var isSend = true
 	for _, v := range userIDList {
-		if v == req.CommID.FromUserID {
+		if v == req.FromUserID {
 			for _, v2 := range userIDList2 {
-				if v2 == req.CommID.ToUserID {
+				if v2 == req.ToUserID {
 					isSend = false
 					break
 				}
@@ -159,12 +164,12 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
 	//Cannot add non-existent users
 
 	if isSend {
-		if _, err := GetUserInfo(ctx, req.CommID.ToUserID); err != nil {
+		if _, err := GetUserInfo(ctx, req.ToUserID); err != nil {
 			return nil, err
 		}
 		friendRequest := imdb.FriendRequest{
-			FromUserID:   req.CommID.FromUserID,
-			ToUserID:     req.CommID.ToUserID,
+			FromUserID:   req.FromUserID,
+			ToUserID:     req.ToUserID,
 			HandleResult: 0,
 			ReqMsg:       req.ReqMsg,
 			CreateTime:   time.Now(),
@@ -179,199 +184,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
+	etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
+	if err != nil {
+		return nil, err
 	}
 	cacheClient := pbCache.NewCacheClient(etcdConn)
-	cacheResp, err := cacheClient.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.FromUserID, OperationID: req.OperationID})
-	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
-	}
-	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: 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.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.ToUserID, req.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
+	friendRequest.HandlerUserID = tools.OpUserID(ctx)
 	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.FromUserID, req.ToUserID)
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			if err := s.friendModel.Create(ctx, []*imdb.Friend{{OwnerUserID: req.FromUserID, FriendUserID: req.ToUserID, OperatorUserID: tools.OpUserID(ctx)}}); 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
+		if isInsert {
+			etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
+			if err != nil {
+				return nil, err
 			}
 			client := pbCache.NewCacheClient(etcdConn)
-			delFriendIDListFromCacheReq.UserID = req.CommID.ToUserID
-			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
+
+			if _, err := client.DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.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.FromUserID}); err != 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
+			if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.ToUserID); err != nil {
+				trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "userID", req.ToUserID)
 			}
-			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 := rocksCache.DelAllFriendsInfoFromCache(ctx, req.FromUserID); err != nil {
+				trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "userID", req.FromUserID)
 			}
-			if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.ToUserID); err != nil {
-				log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), 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)
-			}
-			chat.FriendAddedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
+			chat.FriendAddedNotification(tools.OperationID(ctx), tools.OpUserID(ctx), req.FromUserID, req.ToUserID)
 		}
 	}
 
@@ -380,329 +299,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.FromUserID); err != nil {
+		return nil, err
 	}
-	err := imdb.DeleteSingleFriendInfo(req.CommID.FromUserID, req.CommID.ToUserID)
+	if err := s.friendModel.Delete(ctx, req.FromUserID, req.ToUserID); err != nil {
+		return nil, err
+	}
+	etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
 	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
+		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})
+	_, err = pbCache.NewCacheClient(etcdConn).DelFriendIDListFromCache(context.Background(), &pbCache.DelFriendIDListFromCacheReq{UserID: req.FromUserID})
 	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
+	if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.FromUserID); err != nil {
+		trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "DelAllFriendsInfoFromCache", req.FromUserID)
 	}
-	if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.CommID.FromUserID); err != nil {
-		log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), err.Error(), 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)
+	if err := rocksCache.DelAllFriendsInfoFromCache(ctx, req.ToUserID); err != nil {
+		trace_log.SetCtxInfo(ctx, "DelAllFriendsInfoFromCache", err, "DelAllFriendsInfoFromCache", req.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.FromUserID); err != nil {
+		return nil, err
 	}
-
-	blackIDList, err := rocksCache.GetBlackListFromCache(ctx, req.CommID.FromUserID)
+	blackIDList, err := rocksCache.GetBlackListFromCache(ctx, req.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.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.FromUserID, req.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.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.FromUserID, req.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
+	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
+		return nil, err
 	}
-	err := imdb.RemoveBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
+	if err := s.blackModel.Delete(ctx, []*imdb.Black{{OwnerUserID: req.FromUserID, BlockUserID: req.ToUserID}}); err != nil {
+		return nil, err
+	}
+	etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
 	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
-
+		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
-	}
-
-	cacheClient := pbCache.NewCacheClient(etcdConn)
-	cacheResp, err := cacheClient.DelBlackIDListFromCache(context.Background(), &pbCache.DelBlackIDListFromCacheReq{UserID: req.CommID.FromUserID, OperationID: req.CommID.OperationID})
+	_, err = pbCache.NewCacheClient(etcdConn).DelBlackIDListFromCache(context.Background(), &pbCache.DelBlackIDListFromCacheReq{UserID: req.FromUserID})
 	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
-	}
-	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
+		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.FromUserID); err != nil {
+		return nil, err
 	}
-	blackIDList, err := rocksCache.GetBlackListFromCache(ctx, req.CommID.FromUserID)
+	blackIDList, err := rocksCache.GetBlackListFromCache(ctx, req.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
+		return nil, err
 	}
-	var isInBlacklist bool
-	if utils.IsContain(req.CommID.ToUserID, blackIDList) {
-		isInBlacklist = true
-	}
-	log.NewInfo(req.CommID.OperationID, "IsInBlackList rpc ok ", pbFriend.IsInBlackListResp{Response: isInBlacklist})
-	return &pbFriend.IsInBlackListResp{Response: isInBlacklist}, nil
+	resp.Response = utils.IsContain(req.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.FromUserID); err != nil {
+		return nil, err
 	}
-	friendIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.CommID.FromUserID)
+	friendIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.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
+		return nil, err
 	}
-	var isFriend bool
-	if utils.IsContain(req.CommID.ToUserID, friendIDList) {
-		isFriend = true
-	}
-	log.NewInfo(req.CommID.OperationID, pbFriend.IsFriendResp{Response: isFriend})
-	return &pbFriend.IsFriendResp{Response: isFriend}, nil
+	resp.Response = utils.IsContain(req.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.FromUserID); err != nil {
+		return nil, err
 	}
-	friendList, err := rocksCache.GetAllFriendsInfoFromCache(ctx, req.CommID.FromUserID)
+	friendList, err := rocksCache.GetAllFriendsInfoFromCache(ctx, req.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.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.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.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.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
-////
-//}

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

internal/rpc/group/g.go

@@ -5,8 +5,11 @@ import (
 	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
 	"Open_IM/pkg/common/tools"
 	pbGroup "Open_IM/pkg/proto/group"
+	sdk "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"context"
+	"math/big"
+	"strconv"
 	"time"
 )
 
@@ -19,16 +22,12 @@ func getDBGroupRequest(ctx context.Context, req *pbGroup.GroupApplicationRespons
 	return dbGroupRequest
 }
 
-func getDBGroupMember(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (dbGroupMember *imdb.GroupMember) {
+func getDBGroupMember(ctx context.Context, groupID, userID string) (dbGroupMember *imdb.GroupMember, err error) {
 	dbGroupMember = &imdb.GroupMember{}
-	utils.CopyStructFields(&dbGroupRequest, req)
-	dbGroupRequest.UserID = req.FromUserID
-	dbGroupRequest.HandleUserID = tools.OpUserID(ctx)
-	dbGroupRequest.HandledTime = time.Now()
 
 	member := imdb.GroupMember{}
-	member.GroupID = req.GroupID
-	member.UserID = req.FromUserID
+	member.GroupID = groupID
+	member.UserID = userID
 	member.RoleLevel = constant.GroupOrdinaryUsers
 	member.OperatorUserID = tools.OpUserID(ctx)
 
@@ -38,5 +37,20 @@ func getDBGroupMember(ctx context.Context, req *pbGroup.GroupApplicationResponse
 	member.InviterUserID = request.InviterUserID
 	member.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
 
-	return dbGroupRequest
+	return dbGroupMember, nil
+}
+
+func getUsersInfo(ctx context.Context, userIDs []string) ([]*sdk.UserInfo, error) {
+	return nil, nil
+}
+
+func genGroupID(ctx context.Context, groupID string) string {
+	if groupID != "" {
+		return groupID
+	}
+	groupID = utils.Md5(tools.OperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
+	bi := big.NewInt(0)
+	bi.SetString(groupID[0:8], 16)
+	groupID = bi.String()
+	return groupID
 }

internal/rpc/group/group.go

@@ -24,7 +24,6 @@ import (
 	"Open_IM/pkg/utils"
 	"context"
 	"errors"
-	"math/big"
 	"net"
 	"strconv"
 	"strings"
@@ -121,48 +120,36 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if err := token_verify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
-	var groupOwnerNum int
+	if req.OwnerUserID == "" {
+		return nil, constant.ErrArgs.Wrap("no group owner")
+	}
 	var userIDs []string
-	for _, info := range req.InitMemberList {
-		if info.RoleLevel == constant.GroupOwner {
-			groupOwnerNum++
-		}
-		userIDs = append(userIDs, info.UserID)
+	for _, ordinaryUserID := range req.InitMemberList {
+		userIDs = append(userIDs, ordinaryUserID)
 	}
-	if req.OwnerUserID != "" {
-		groupOwnerNum++
-		userIDs = append(userIDs, req.OwnerUserID)
+	userIDs = append(userIDs, req.OwnerUserID)
+	for _, adminUserID := range req.AdminUserIDs {
+		userIDs = append(userIDs, adminUserID)
 	}
-	if groupOwnerNum != 1 {
-		return nil, constant.ErrArgs.Wrap("groupOwnerNum != 1")
-	}
-	if utils.IsRepeatStringSlice(userIDs) {
+	if utils.IsRepeatID(userIDs) {
 		return nil, constant.ErrArgs.Wrap("group member is repeated")
 	}
-	users, err := rocksCache.GetUserInfoFromCacheBatch(ctx, userIDs)
+
+	users, err := getUsersInfo(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}
-	if len(users) != len(userIDs) {
-		return nil, constant.ErrDatabase.Wrap("len(users from cache) != len(userIDs)")
-	}
-	userMap := make(map[string]*imdb.User)
+
+	userMap := make(map[string]*open_im_sdk.UserInfo)
 	for i, user := range users {
 		userMap[user.UserID] = users[i]
 	}
-	if err := s.DelGroupAndUserCache(ctx, "", userIDs); err != nil {
-		return nil, err
-	}
+
 	if err := callbackBeforeCreateGroup(ctx, req); err != nil {
 		return nil, err
 	}
-	groupId := req.GroupInfo.GroupID
-	if groupId == "" {
-		groupId = utils.Md5(tools.OperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
-		bi := big.NewInt(0)
-		bi.SetString(groupId[0:8], 16)
-		groupId = bi.String()
-	}
+	groupId := genGroupID(ctx, req.GroupInfo.GroupID)
+
 	groupInfo := imdb.Group{}
 	utils.CopyStructFields(&groupInfo, req.GroupInfo)
 	groupInfo.CreatorUserID = tools.OpUserID(ctx)
@@ -171,7 +158,9 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if groupInfo.NotificationUpdateTime.Unix() < 0 {
 		groupInfo.NotificationUpdateTime = utils.UnixSecondToTime(0)
 	}
+
 	if req.GroupInfo.GroupType != constant.SuperGroup {
+
 		var groupMembers []*imdb.GroupMember
 		joinGroup := func(userID string, roleLevel int32) error {
 			groupMember := &imdb.GroupMember{GroupID: groupId, RoleLevel: roleLevel, OperatorUserID: tools.OpUserID(ctx), JoinSource: constant.JoinByInvitation, InviterUserID: tools.OpUserID(ctx)}
@@ -193,9 +182,11 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 				return nil, err
 			}
 		}
+
 		if err := (*imdb.GroupMember)(nil).Create(ctx, groupMembers); err != nil {
 			return nil, err
 		}
+
 	} else {
 		if err := db.DB.CreateSuperGroup(groupId, userIDs, len(userIDs)); err != nil {
 			return nil, err
@@ -673,30 +664,15 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 		return nil, err
 	}
 	if req.HandleResult == constant.GroupResponseAgree {
-		user, err := imdb.GetUserByUserID(req.FromUserID)
+		member, err := getDBGroupMember(ctx, req.GroupID, req.FromUserID)
 		if err != nil {
 			return nil, err
 		}
-		request, err := (&imdb.GroupRequest{}).Take(ctx, req.GroupID, req.FromUserID)
+		err = CallbackBeforeMemberJoinGroup(ctx, tools.OperationID(ctx), member, groupInfo.Ex)
 		if err != nil {
 			return nil, err
 		}
-		member := imdb.GroupMember{}
-		member.GroupID = req.GroupID
-		member.UserID = req.FromUserID
-		member.RoleLevel = constant.GroupOrdinaryUsers
-		member.OperatorUserID = tools.OpUserID(ctx)
-		member.FaceURL = user.FaceURL
-		member.Nickname = user.Nickname
-		member.JoinSource = request.JoinSource
-		member.InviterUserID = request.InviterUserID
-		member.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
-		err = CallbackBeforeMemberJoinGroup(ctx, tools.OperationID(ctx), &member, groupInfo.Ex)
-		if err != nil {
-			return nil, err
-		}
-
-		err = (&imdb.GroupMember{}).Create(ctx, []*imdb.GroupMember{&member})
+		err = (&imdb.GroupMember{}).Create(ctx, []*imdb.GroupMember{member})
 		if err != nil {
 			return nil, err
 		}